@turquoisehealth/pit-viper 2.216.0 → 2.216.1-dev.0

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

@@ -0,0 +1,525 @@
+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;
+    /** Optional section label used to group options under a heading in section-aware UIs (e.g. PvFilterModal). */
+    section?: string;
+    subduedText?: string;
+    subText?: string;
+    totalChildCount?: number;
+    value: string;
+}
+export interface PvFilterPanelFilterGroup {
+    fields: string[];
+    label: string;
+}
+/**
+ * Describes a section heading in section-aware UIs (e.g. PvFilterModal). Options are grouped by their
+ * `section` value; the matching def is forwarded to the section header renderer so it can decide how
+ * to display the heading. Configured per column via `colDef.context.filterSectionDefs`.
+ *
+ * Only `key`/`label` are typed; put anything else the renderer needs (icon, tooltip, counter, badge…)
+ * on `metadata` so new display needs don't require changing this type.
+ */
+export interface PvFilterPanelSectionDef {
+    /** Section key matching an option's `section` value. */
+    key: string;
+    /** Display label for the section heading. Defaults to `key`. */
+    label?: string;
+    /** Arbitrary display data forwarded to the section header renderer (e.g. icon, tooltip, count). */
+    metadata?: Record<string, unknown>;
+}
+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;
+    /**
+     * Section heading defs for section-aware UIs (e.g. PvFilterModal), keyed by section value. Supplies
+     * the label and any extra display data (via `metadata`) forwarded to `filterSectionHeaderRenderer`.
+     * Also determines section order; sections present in the options but absent here render last.
+     */
+    filterSectionDefs?: PvFilterPanelSectionDef[];
+    /**
+     * Optional renderer for section headings in section-aware UIs (e.g. PvFilterModal). Receives
+     * `{ colDef, field, section, options }` and replaces the default section label text, allowing
+     * hover tooltips, counters, or custom markup. Sections come from each option's `section` field.
+     */
+    filterSectionHeaderRenderer?: 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;
+    /**
+     * If true, the filter selection is supplied by the consumer and never written to the filter model.
+     */
+    filterPanelControlled?: boolean;
+    /**
+     * If true, this filter is hidden behind the panel's collapsed filters toggle by default.
+     */
+    filterCollapsedByDefault?: boolean;
+    /**
+     * Custom label for exists filters. Defaults to `Has ${headerName}`.
+     */
+    filterPanelExistsLabel?: string;
+    /**
+     * If true, hide this column from reusable filter panel UIs.
+     */
+    filterPanelHidden?: boolean;
+    /**
+     * If true, hide the value filter options sort label (defaults to "Suggested").
+     */
+    filterPanelHideOptionsSortDescription?: boolean;
+    /**
+     * If true, hide the value filter search input.
+     */
+    filterPanelHideSearch?: 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;
+    /**
+     * If true, value options render as radios and selecting one replaces the previous selection.
+     */
+    filterPanelSingleSelect?: boolean;
+    /**
+     * 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;
+    /**
+     * Shows a search box over the filter options. Unset uses the derived default,
+     * which omits it for columns that cannot benefit (currently `dataType: "boolean"`).
+     */
+    filterSearch?: boolean;
+    /**
+     * Per-field minimum search length. Overrides PvDataTable's table-level
+     * filterSearchMinLength so hosts can keep short values such as codes searchable.
+     */
+    filterSearchMinLength?: number;
+    /**
+     * If true, filter values for this column will be fetched eagerly in the background,
+     * even when table-level background refresh is disabled.
+     */
+    prefetchFilterValues?: 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.
+     * When provided, these fields are included in the auto-generated search placeholder
+     * (e.g., `["npi", "taxId"]` → `Search Provider Name, NPI, Tax ID`).
+     */
+    queryColIds?: string[];
+    /**
+     * When false, search-match subtext shows only the matched value instead of "Column: value".
+     */
+    showSearchMatchSubTextPrefix?: boolean;
+    /**
+     * 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;
+    /** Whether the consumer owns this filter's selection outside the filter model. */
+    controlled?: boolean;
+    dataType?: string | null;
+    disabled?: boolean;
+    displayPreferencesIcon?: boolean;
+    emptyResultsRenderer?: Component;
+    existsLabel?: string;
+    existsValue?: boolean;
+    filterFooterRenderer?: Component;
+    filterGroupLabel?: string;
+    filterGroupOptions?: PvFilterPanelGroupOption[];
+    filterHeaderRenderer?: Component;
+    filterOptionsRenderer?: Component;
+    filterSectionDefs?: PvFilterPanelSectionDef[];
+    filterSectionHeaderRenderer?: Component;
+    filterOptionsSortDescription?: string;
+    filterOptionsSortTooltip?: string;
+    hideOptionsSortDescription?: boolean;
+    hideSearch?: boolean;
+    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[];
+    /** Whether value options use single-select radio behavior. */
+    singleSelect?: boolean;
+    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;
+    /** Input control rendered for the option. */
+    control?: "checkbox" | "radio";
+    depth?: number;
+    disabled?: boolean;
+    indeterminate?: boolean;
+    focusText?: string;
+    isFocused?: boolean;
+    label: string;
+    /** Name shared by inputs in the same radio group. */
+    name?: string;
+    queryText?: string | null;
+    renderer?: Component;
+    resultCount?: PvFilterPanelResultCount | null;
+    selected?: boolean;
+    showFocusAction?: boolean;
+    subText?: string;
+    subduedText?: string;
+    value: string;
+}
+export type PvFilterPanelEmits = {
+    apply: [filterModel: PvFilterPanelFilterModel];
+    cancel: [];
+    /** Emitted when a consumer-controlled value filter selection changes. */
+    "controlled-change": [filterKey: string, values: string[], colDef: PvFilterPanelColDef];
+    "filter-change": [event: PvFilterPanelFilterChangeEvent];
+    "focus-change": [field: string, value: string, option: PvFilterPanelOption];
+    "handle-settings-icon": [field: string, colDef: PvFilterPanelColDef];
+    "load-more": [field: string, colDef: PvFilterPanelColDef, query: string, parentId?: string];
+    "open-change": [field: string, open: boolean, colDef: PvFilterPanelColDef];
+    "search-change": [field: string, query: string, colDef: PvFilterPanelColDef];
+    "suggestion-click": [suggestion: PvFilterPanelSuggestion];
+};
+export type PvFilterPanelEmitFn = <K extends keyof PvFilterPanelEmits>(event: K, ...args: PvFilterPanelEmits[K]) => void;
+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[];
+    /** Base label used by the collapsed filters toggle; rendered as `Show/Hide ${label}`. */
+    collapsedFilterDisplayLabel?: string;
+    clearAllBody?: string;
+    clearAllHeader?: string;
+    clearAllLabel?: string;
+    colDefs?: PvFilterPanelColDef[];
+    /** Selected values for consumer-controlled filters, keyed by column key. */
+    controlledValues?: Record<string, string[]>;
+    /** 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;
+    /** When true, hides the collapse button from the filter panel header. */
+    hideCollapseButton?: boolean;
+    /** 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;
+}
+/**
+ * Props consumed by the `usePvFilterPanel` composable. Mirrors `PvFilterPanelProps` but marks the
+ * fields that consuming components default via `withDefaults` as required, so the composable can rely
+ * on them being present. Both `PvFilterPanel` and `PvFilterModal` satisfy this after applying defaults.
+ */
+export type PvFilterPanelCoreProps = Omit<PvFilterPanelProps, "colDefs" | "controlledValues" | "devMode" | "displayPreferencesIcon" | "enableFocusView" | "filterHasMoreMap" | "filterLoadingMap" | "filterLoadingMoreMap" | "filterOptions" | "filterSearchQueries" | "filterSuggestions" | "focusableFields" | "focusedValues" | "focusText" | "rangeDebounceMs" | "readOnly" | "staged"> & {
+    colDefs: PvFilterPanelColDef[];
+    controlledValues: Record<string, string[]>;
+    devMode: boolean;
+    displayPreferencesIcon: boolean;
+    enableFocusView: boolean;
+    filterHasMoreMap: Record<string, boolean | undefined>;
+    filterLoadingMap: Record<string, boolean | undefined>;
+    filterLoadingMoreMap: Record<string, boolean | undefined>;
+    filterOptions: Record<string, PvFilterPanelOption[]>;
+    filterSearchQueries: Record<string, string | undefined>;
+    filterSuggestions: PvFilterPanelSuggestion[];
+    focusableFields: string[];
+    focusedValues: Record<string, string[] | undefined>;
+    focusText: string;
+    rangeDebounceMs: number;
+    readOnly: boolean;
+    staged: boolean;
+};

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

@@ -0,0 +1,30 @@
+import { Ref, ComputedRef } from 'vue';
+import { PvFilterPanelAppliedGroup, PvFilterPanelColDef, PvFilterPanelControlChange, PvFilterPanelCoreProps, PvFilterPanelEmitFn, PvFilterPanelFilterModel, PvFilterPanelFilterType, PvFilterPanelResolvedFilter, PvFilterPanelSuggestion, PvFilterStore, PvFilterPanelFilterModelType } from './types';
+/**
+ * View-agnostic "brain" for filter panel presentations. Owns option/store wiring, the resolved filter
+ * model, applied-filter derivation, and all mutation handlers. Presentation components (`PvFilterPanel`
+ * drawer, `PvFilterModal`) consume this and supply their own layout + local view state.
+ */
+export declare function usePvFilterPanel(props: PvFilterPanelCoreProps, filterModel: Ref<PvFilterPanelFilterModel>, emit: PvFilterPanelEmitFn): {
+    resolvedFilters: ComputedRef<PvFilterPanelResolvedFilter[]>;
+    appliedGroups: ComputedRef<PvFilterPanelAppliedGroup[]>;
+    appliedCount: ComputedRef<number>;
+    hasActiveFilters: ComputedRef<boolean>;
+    showClearAll: ComputedRef<boolean>;
+    visibleSuggestions: ComputedRef<PvFilterPanelSuggestion[]>;
+    effectiveFilterModelType: ComputedRef<PvFilterPanelFilterModelType>;
+    activeFilterModel: ComputedRef<PvFilterPanelFilterModel>;
+    effectiveFilterStore: ComputedRef<PvFilterStore>;
+    findResolvedFilter: (field: string) => PvFilterPanelResolvedFilter | undefined;
+    getRepresentedFields: (colDef: PvFilterPanelColDef) => string[];
+    activateFilter: (filter: PvFilterPanelResolvedFilter, query?: string) => void;
+    applyStagedFilters: () => void;
+    cancelStagedFilters: () => void;
+    clearAllFilters: () => void;
+    getSuggestionKey: (suggestion: PvFilterPanelSuggestion) => string;
+    handleControlChange: (field: string, change: PvFilterPanelControlChange) => void;
+    handleLoadMore: (filter: PvFilterPanelResolvedFilter, query: string, parentId?: string) => void;
+    handleSearchChange: (filter: PvFilterPanelResolvedFilter, query: string) => void;
+    handleSuggestionClick: (suggestion: PvFilterPanelSuggestion) => void;
+    removeAppliedFilter: (field: string, value: string, type?: PvFilterPanelFilterType) => void;
+};

package/pv-components/dist/vue/ai/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/ai/components/base/PvGhostInput/PvGhostInput.vue.d.ts

@@ -0,0 +1,45 @@
+import { PvGhostInputVariant } from './types';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+interface PvGhostInputProps {
+    /**
+     * The typographic style applied to the input text (e.g. h1, h2, text-md, caption).
+     */
+    variant?: PvGhostInputVariant;
+    /** Placeholder text shown when the input is empty. */
+    placeholder?: string;
+    /** When true, the input is non-interactive and visually dimmed. */
+    disabled?: boolean;
+    /** When true, displays an edit (pencil) icon button beside the input that focuses it on click. */
+    showEditIcon?: boolean;
+}
+type __VLS_Props = PvGhostInputProps;
+type __VLS_PublicProps = {
+    modelValue?: string;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        action?(_: {}): any;
+    };
+    refs: {
+        inputRef: HTMLInputElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+}, string, PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    variant: PvGhostInputVariant;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
+    inputRef: HTMLInputElement;
+}, 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/ai/components/base/PvGhostInput/types.d.ts

@@ -0,0 +1,2 @@
+import { PvInputVariants } from '../baseProps';
+export type PvGhostInputVariant = PvInputVariants;

package/pv-components/dist/vue/ai/components/base/PvHeader/PvHeader.vue.d.ts

@@ -0,0 +1,36 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type __VLS_Props = {
+    title?: string;
+    showAskTqButton?: boolean;
+    askTqButtonId?: string;
+    headerTitleId?: string;
+    headerActionsId?: string;
+    sticky?: boolean;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        left?(_: {}): any;
+        right?(_: {}): any;
+    };
+    refs: {
+        rootRef: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    sticky: boolean;
+    askTqButtonId: string;
+    headerTitleId: string;
+    headerActionsId: string;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
+    rootRef: 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;
+    };
+};