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

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

@@ -0,0 +1,26 @@
+import { AdvancedFilterModel } from 'ag-grid-enterprise';
+import { PvFilterPanelColDef, PvFilterPanelFilterModelType } from './types';
+export interface PvFilterPanelRangeValue {
+    max: number | null;
+    min: number | null;
+}
+export type PvAdvancedFilterColumnType = "date" | "dateString" | "dateTime" | "dateTimeString" | "number" | "object" | "text";
+export interface PvFilterPanelModelIndexEntry {
+    booleanValue: boolean | null;
+    existsValue: boolean;
+    rangeValue: PvFilterPanelRangeValue;
+    values: string[];
+}
+export type PvFilterPanelModelIndex = Map<string, PvFilterPanelModelIndexEntry>;
+export declare const createFilterPanelModelIndex: (model: AdvancedFilterModel | null | undefined | unknown, modelType?: PvFilterPanelFilterModelType) => PvFilterPanelModelIndex;
+export declare const advancedFilterHasConditions: (model: AdvancedFilterModel | null | undefined | unknown, modelType?: PvFilterPanelFilterModelType) => boolean;
+export declare const getBooleanFilter: (model: AdvancedFilterModel | null | unknown, colId: string, modelType?: PvFilterPanelFilterModelType) => boolean | null;
+export declare const getExistsFilter: (model: AdvancedFilterModel | null | unknown, colId: string, modelType?: PvFilterPanelFilterModelType) => boolean;
+export declare const getRangeFilter: (model: AdvancedFilterModel | null | unknown, colId: string, modelType?: PvFilterPanelFilterModelType) => PvFilterPanelRangeValue;
+export declare const getAdvancedFilterTypeForDataType: (dataType?: string | null) => PvAdvancedFilterColumnType;
+export declare const getValueSelections: (model: AdvancedFilterModel | null | unknown, colId: string, modelType?: PvFilterPanelFilterModelType) => string[];
+export declare const removeColumnFilter: (model: AdvancedFilterModel | null, colId: string, modelType?: PvFilterPanelFilterModelType) => AdvancedFilterModel | null;
+export declare const updateBooleanFilter: (model: AdvancedFilterModel | null, colId: string, value: boolean | null, modelType?: PvFilterPanelFilterModelType, advancedFilterType?: "boolean" | "text", colDef?: PvFilterPanelColDef) => AdvancedFilterModel | null;
+export declare const updateExistsFilter: (model: AdvancedFilterModel | null, colId: string, value: boolean, filterType?: PvAdvancedFilterColumnType, modelType?: PvFilterPanelFilterModelType, colDef?: PvFilterPanelColDef) => AdvancedFilterModel | null;
+export declare const updateRangeFilter: (model: AdvancedFilterModel | null, colId: string, minValue: number | null, maxValue: number | null, modelType?: PvFilterPanelFilterModelType, colDef?: PvFilterPanelColDef) => AdvancedFilterModel | null;
+export declare const updateValueFilter: (model: AdvancedFilterModel | null, colId: string, values: string[], modelType?: PvFilterPanelFilterModelType, colDef?: PvFilterPanelColDef) => AdvancedFilterModel | null;

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

@@ -0,0 +1,56 @@
+import { AdvancedFilterModel } from 'ag-grid-enterprise';
+import { MultiSelectState } from '../../../types';
+import { PvFilterPanelAggregateFieldHierarchy, PvFilterPanelColDef, PvFilterPanelOption } from './types';
+export interface PvFilterPanelAggregateSelectionStatus {
+    indeterminate: boolean;
+    selected: boolean;
+}
+export interface PvFilterPanelAggregateFieldValue {
+    field?: string;
+    value: string;
+}
+export declare const removeFilterPanelAggregateFieldsFromModel: (model: AdvancedFilterModel | null | undefined, fields: string[] | Set<string>) => AdvancedFilterModel | null;
+export declare const flattenFilterPanelAggregateFieldHierarchy: (hierarchy: PvFilterPanelAggregateFieldHierarchy | undefined) => string[];
+export declare const getFilterPanelAggregateLeafFields: (hierarchy: PvFilterPanelAggregateFieldHierarchy | undefined) => string[];
+export declare const getFilterPanelAggregateFields: (colDef: PvFilterPanelColDef | null | undefined) => string[];
+export declare const getFilterPanelAggregateRootField: (colDef: PvFilterPanelColDef | null | undefined) => string | undefined;
+export declare const isFilterPanelAggregateColDef: (colDef: PvFilterPanelColDef | null | undefined) => boolean;
+export declare const findFilterPanelOptionByValue: (options: (PvFilterPanelOption | null)[] | undefined, value: string) => PvFilterPanelOption | undefined;
+export declare const getFilterPanelAggregateFieldValue: (optionId: string, options?: (PvFilterPanelOption | null)[]) => PvFilterPanelAggregateFieldValue;
+export declare const findFilterPanelAggregateOptionId: (options: (PvFilterPanelOption | null)[] | undefined, field: string, rawValue: string) => string;
+export declare const buildFilterPanelAggregateModelFromSelectionState: (params: {
+    baseModel: AdvancedFilterModel | null | undefined;
+    colDef: PvFilterPanelColDef;
+    options?: (PvFilterPanelOption | null)[];
+    state: MultiSelectState;
+}) => AdvancedFilterModel | null;
+export declare const seedFilterPanelAggregateSelectionState: (params: {
+    colDef: PvFilterPanelColDef;
+    model: AdvancedFilterModel | null | undefined;
+    options?: (PvFilterPanelOption | null)[];
+}) => MultiSelectState;
+export declare const getFilterPanelAggregateSelectedValuesByField: (params: {
+    colDef: PvFilterPanelColDef;
+    model: AdvancedFilterModel | null | undefined;
+    options?: (PvFilterPanelOption | null)[];
+}) => Map<string, string[]>;
+export declare const updateFilterPanelAggregateSelectionState: (params: {
+    checked: boolean;
+    option: PvFilterPanelOption;
+    options?: (PvFilterPanelOption | null)[];
+    state: MultiSelectState;
+}) => MultiSelectState;
+export declare const createFilterPanelAggregateSelectionStatusMap: (params: {
+    options?: (PvFilterPanelOption | null)[];
+    state: MultiSelectState;
+}) => Map<string, PvFilterPanelAggregateSelectionStatus>;
+export declare const getFilterPanelAggregateOptionSelectionStatus: (params: {
+    option: PvFilterPanelOption;
+    options?: (PvFilterPanelOption | null)[];
+    state: MultiSelectState;
+}) => PvFilterPanelAggregateSelectionStatus;
+export declare const getFilterPanelAggregateSelectionOptions: (params: {
+    options?: (PvFilterPanelOption | null)[];
+    state: MultiSelectState;
+}) => PvFilterPanelOption[];
+export declare const getFilterPanelAggregateSelectionCount: (state: MultiSelectState) => number;

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

@@ -0,0 +1,28 @@
+export type PvFilterPanelDisplayResultCount = number | string;
+export type FilterPanelDisplayResultCount = PvFilterPanelDisplayResultCount;
+interface FilterOptionDisplaySource {
+    label?: string;
+    metadata?: unknown;
+    rawValue?: boolean | number | string | null;
+    resultCount?: unknown;
+    totalChildCount?: unknown;
+    value: string;
+}
+interface FilterOptionColDefLike {
+    context?: {
+        filterValueFormatter?: ((params: never) => string) | string | null;
+        metadataDisplayFields?: string[];
+    } | null;
+    valueFormatter?: ((params: never) => string) | string | null;
+}
+export declare const formatFilterPanelScalarValue: (value: number, options?: {
+    dataType?: string | null;
+    valueDecimals?: number | null;
+}) => string;
+export declare const formatFilterPanelRangeValue: (min: number | null, max: number | null, options?: {
+    dataType?: string | null;
+    valueDecimals?: number | null;
+}) => string;
+export declare const getFilterOptionLabel: (option: FilterOptionDisplaySource, colDef?: FilterOptionColDefLike) => string;
+export declare const getFilterOptionResultCount: (option: FilterOptionDisplaySource | null | undefined) => PvFilterPanelDisplayResultCount | undefined;
+export {};

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

@@ -0,0 +1,15 @@
+import { PvFilterPanelOption } from './types';
+export interface PvFilterPanelScopedValue {
+    field?: string;
+    pairs: Array<{
+        field: string;
+        value: string;
+    }>;
+    value: string;
+}
+export declare const parseFilterPanelScopedValue: (value: string | null | undefined) => PvFilterPanelScopedValue | null;
+export declare const createFilterPanelScopedValue: (field: string, value: string) => string;
+export declare const getFilterPanelOptionRawValue: (option: PvFilterPanelOption | null | undefined) => string | null;
+export declare const getFilterPanelOptionField: (option: PvFilterPanelOption | null | undefined, fallbackField: string) => string;
+export declare const flattenFilterPanelOptions: (options: PvFilterPanelOption[]) => PvFilterPanelOption[];
+export declare const filterPanelOptionMatchesRawValue: (option: PvFilterPanelOption, field: string, rawValue: string, fallbackField: string) => boolean;

package/pv-components/dist/vue/base/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/base/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/base/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/base/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/base/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;
 }>, {
-    step: number;
-    min: number;
-    max: number;
-}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLInputElement>;
+    size: PvRangeSize;
+    label: string;
+    disabled: boolean;
+    showClear: boolean;
+    color: PvRangeColor;
+    mode: PvRangeMode;
+    step: number | null;
+    min: number | null;
+    max: 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;