@turquoisehealth/pit-viper 2.79.0 → 2.79.2-dev.0

package/pv-components/dist/src/components/charts/PvDataTableWithChart/types.d.ts

@@ -0,0 +1,75 @@
+import { CSSProperties } from "vue";
+import { AgChartOptions } from "ag-charts-enterprise";
+import { ValueFormatterFunc } from "ag-grid-enterprise";
+import { Option } from "@/types";
+import { PvDataTableProps } from "@tables/PvDataTable/types.ts";
+import type { ColumnVO } from "ag-grid-community/dist/types/src/interfaces/iColumnVO";
+import type { FilterModel } from "ag-grid-community/dist/types/src/interfaces/iFilter";
+import type { AdvancedFilterModel } from "ag-grid-community/dist/types/src/interfaces/advancedFilterModel";
+export type supportedChartType = "column" | "bar" | "column_stacked" | "bar_stacked" | "line" | "area" | "pie";
+export type ChartConfigPanelType = "y-axis" | "x-axis" | "sort" | "chart-type";
+export type ChartFilterOption = {
+    label: string;
+    value: string;
+    filterValues: string[];
+};
+export interface ChartFilter {
+    colId: string;
+    options: ChartFilterOption[];
+}
+export interface ServerSideChartDataHandlerParams {
+    rowGroupCols: ColumnVO[];
+    /** Columns that have aggregations on them.  */
+    valueCols: ColumnVO[];
+    /**
+     * If filtering, what the filter model is.
+     * If Advanced Filter is enabled, will be of type `AdvancedFilterModel | null`.
+     * If Advanced Filter is disabled, will be of type `FilterModel`.
+     */
+    filterModel: FilterModel | AdvancedFilterModel | null;
+}
+export interface ServerSideChartDataHandlerResponse {
+    data: AgChartOptions["data"];
+    stackField: string;
+}
+export interface PvDataTableWithChartProps<T> extends PvDataTableProps<T> {
+    enabledChartTypes?: supportedChartType[];
+    serverSideChartHandler?: (params: ServerSideChartDataHandlerParams) => Promise<ServerSideChartDataHandlerResponse>;
+    showSeriesLabels?: boolean;
+    truncateLabelValues?: boolean;
+    initialChartData?: AgChartOptions["data"];
+    enableCombinedChartConfigPanel?: boolean;
+    chartConfigPanelOptions?: ChartConfigPanelType[];
+    chartFilter?: ChartFilter;
+    chartType?: supportedChartType;
+    yKey?: string;
+    initialSort?: string;
+    hideChart?: boolean;
+    hideTable?: boolean;
+    filterPanelAboveChart?: boolean;
+    initialChartCollapsed?: boolean;
+    initialFocusData?: {
+        focuses: string[];
+        focusType: string | null;
+    };
+    percentOfFocusViewYKey?: string;
+    focusableColumns?: string[];
+    /**
+     * Enable toggle to group or ungroup
+     */
+    enableGroupingToggle?: boolean;
+    /**
+     * Css Properties
+     */
+    customCssProperties?: {
+        agGridWrapper: CSSProperties;
+    };
+}
+export interface OptionWithFormatterAndDataType extends Option {
+    formatter?: ValueFormatterFunc | string;
+    dataType?: string;
+}
+export interface StackField {
+    fieldName: string;
+    fieldValues: string[];
+}

package/pv-components/dist/src/components/charts/PvMapChart/PvMapChart.vue.d.ts

@@ -0,0 +1,44 @@
+import { MapTopologyType } from "@charts/chart-components/maps/useTopology.ts";
+import { AgMapLineSeriesTooltipRendererParams } from "ag-charts-enterprise";
+export interface PvMapChartData {
+    [key: string]: string | number;
+}
+export interface RegionSelectionChangedEvent {
+    region: string | null | undefined;
+}
+export interface PvMapChartProps {
+    seriesKey: string;
+    mapType?: MapTopologyType;
+    displayGradientLegend?: boolean;
+    displayRegionSelector?: boolean;
+    gradientLegendMin?: number;
+    gradientLegendMax?: number;
+    seriesValueFormatter?: (value: number) => string;
+    isLoading?: boolean;
+    noDataMessage?: string;
+    tooltipRenderer?: (params: AgMapLineSeriesTooltipRendererParams<PvMapChartData>) => string | HTMLElement;
+}
+declare const _default: import("vue").DefineComponent<PvMapChartProps & {
+    chartData: PvMapChartData[];
+    selectedRegion?: string | undefined;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:chartData": (value: PvMapChartData[]) => any;
+    "update:selectedRegion": (value: string | undefined) => any;
+} & {
+    "region-selection-changed": (event: RegionSelectionChangedEvent) => any;
+}, string, import("vue").PublicProps, Readonly<PvMapChartProps & {
+    chartData: PvMapChartData[];
+    selectedRegion?: string | undefined;
+}> & Readonly<{
+    "onUpdate:chartData"?: ((value: PvMapChartData[]) => any) | undefined;
+    "onUpdate:selectedRegion"?: ((value: string | undefined) => any) | undefined;
+    "onRegion-selection-changed"?: ((event: RegionSelectionChangedEvent) => any) | undefined;
+}>, {
+    isLoading: boolean;
+    mapType: MapTopologyType;
+    displayGradientLegend: boolean;
+    gradientLegendMin: number;
+    gradientLegendMax: number;
+    seriesValueFormatter: (value: number) => string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/pv-components/dist/src/components/charts/chart-components/maps/MapGradient.vue.d.ts

@@ -0,0 +1,10 @@
+type ChartGradientProps = {
+    min?: number;
+    max?: number;
+    valueFormatter?: (value: number) => string;
+};
+declare const _default: import("vue").DefineComponent<ChartGradientProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ChartGradientProps> & Readonly<{}>, {
+    min: number;
+    max: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/pv-components/dist/src/components/charts/chart-components/maps/MapRegionSelector.vue.d.ts

@@ -0,0 +1,15 @@
+import { MapTopologyType } from "@charts/chart-components/maps/useTopology.ts";
+type ChartStateSelectorProps = {
+    topologyType: MapTopologyType;
+    selectableRegions?: string[];
+};
+type __VLS_Props = ChartStateSelectorProps;
+type __VLS_PublicProps = __VLS_Props & {
+    modelValue?: string | undefined;
+};
+declare const _default: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string | undefined) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string | undefined) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/pv-components/dist/src/components/charts/chart-components/maps/topologies/alaskaStateTopology.d.ts

@@ -0,0 +1,20 @@
+export declare const processedAlaskaTopology: {
+    type: string;
+    properties: {
+        name: string;
+    };
+    geometry: {
+        type: string;
+        coordinates: number[][][][];
+    };
+};
+export declare const rawAlaskaTopology: {
+    type: string;
+    properties: {
+        name: string;
+    };
+    geometry: {
+        type: string;
+        coordinates: number[][][][];
+    };
+};

package/pv-components/dist/src/components/charts/chart-components/maps/topologies/hawaiiStateTopology.d.ts

@@ -0,0 +1,20 @@
+export declare const processedHawaiiTopology: {
+    type: string;
+    properties: {
+        name: string;
+    };
+    geometry: {
+        type: string;
+        coordinates: number[][][][];
+    };
+};
+export declare const rawHawaiiTopology: {
+    type: string;
+    properties: {
+        name: string;
+    };
+    geometry: {
+        type: string;
+        coordinates: number[][][][];
+    };
+};

package/pv-components/dist/src/components/charts/chart-components/maps/topologies/usStateTopology.d.ts

@@ -0,0 +1,28 @@
+export declare const minFeatureName = "_FeatureMin";
+export declare const maxFeatureName = "_FeatureMax";
+export declare const stateCodeToName: (stateCode: string) => string;
+export declare const stateMappings: {
+    [key: string]: string;
+};
+export declare const usStateTopology: {
+    type: string;
+    features: ({
+        type: string;
+        properties: {
+            name: string;
+        };
+        geometry: {
+            type: string;
+            coordinates: number[][][][];
+        };
+    } | {
+        type: string;
+        geometry: {
+            type: string;
+            coordinates: number[][][];
+        };
+        properties: {
+            name: string;
+        };
+    })[];
+};

package/pv-components/dist/src/components/charts/chart-components/maps/useTopology.d.ts

@@ -0,0 +1,8 @@
+import { PvMapChartData } from "@charts/PvMapChart/PvMapChart.vue";
+export type MapTopologyType = "state" | "city" | "county" | "cbsa" | "zip_code";
+export declare const useTopology: () => {
+    getTopologyObject: (topologyType: MapTopologyType) => any;
+    buildMapData: (inputData: PvMapChartData[], topologyType: MapTopologyType, seriesKey: string, scaleMin: number, scaleMax: number) => {
+        [key: string]: string | number;
+    }[];
+};

package/pv-components/dist/src/components/charts/themes.d.ts

@@ -0,0 +1,5 @@
+import { AgChartTheme } from "ag-charts-enterprise";
+export declare const PitViperAGChartsMonochromeThemeName = "pv-ag-chart-monochrome";
+export declare const PitViperAGChartsMonochromeTheme: AgChartTheme;
+export declare const PitViperAGChartsMulticolorThemeName = "pv-ag-chart-multicolor";
+export declare const PitViperAGChartsMulticolorTheme: AgChartTheme;

package/pv-components/dist/src/components/helpers/charts/mockChartData.d.ts

@@ -0,0 +1,7 @@
+import { AgChartOptions } from "ag-charts-types";
+import { AgCartesianChartOptions } from "ag-charts-enterprise";
+export declare const mockHistoricalChartOptions: AgChartOptions;
+export declare const mockScatterChartOptions: AgChartOptions;
+export declare const mockBucketedLineChartOptions: AgChartOptions;
+export declare const mockDoubleBarChartCommonOptions: AgChartOptions;
+export declare const createDoubleBarChartConfig: (inverted?: boolean) => AgCartesianChartOptions[];

package/pv-components/dist/src/components/helpers/components/ExampleTable.vue.d.ts

@@ -0,0 +1,20 @@
+interface ExampleTablePorps {
+    label: string;
+    cols: string[];
+    rows: string[];
+}
+declare var __VLS_1: {
+    col: string;
+    row: string;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<ExampleTablePorps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ExampleTablePorps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/pv-components/dist/src/components/helpers/tables/mockData.d.ts

@@ -0,0 +1,25 @@
+import { ColDef } from "ag-grid-community";
+import { ChartFilter } from "@charts/PvDataTableWithChart/types.ts";
+export interface MockRowData {
+    id: string;
+    provider_name: string;
+    payer_name: string;
+    payer_type: string;
+    payer_class: string;
+    provider_type: string;
+    bill_type: string;
+    npi: string[];
+    service_category: string;
+    code: string;
+    rate: number;
+    yield: number;
+    state: string;
+    effective_date: string;
+    termination_date?: string;
+    status: "active" | "inactive" | "pending";
+    market_share: number;
+    volume: number;
+    specialties: string[];
+}
+export declare const mockColDefs: ColDef[];
+export declare const mockChartFilter: ChartFilter;

package/pv-components/dist/src/components/helpers/tables/mockPvDataTableServer.d.ts

@@ -0,0 +1,49 @@
+import type { IServerSideGetRowsParams } from "ag-grid-enterprise";
+import type { ColDef } from "ag-grid-community";
+import { FilterValueResponseOption, FilterValuesSetHandlerParams, TableSearchHandlerParams } from "@tables/PvDataTable/types.ts";
+import { MockRowData } from "@/components/helpers/tables/mockData.ts";
+import { ChartFilter, ServerSideChartDataHandlerParams, ServerSideChartDataHandlerResponse } from "@charts/PvDataTableWithChart/types.ts";
+import { QueryTerm } from "@/components/base/PvQueryBuilderInput/useQueryBuilder.ts";
+interface MockTableConfig<T> {
+    serverSideRowHandler?: (params: IServerSideGetRowsParams<T>, isCsvExport?: boolean) => void;
+    serverSideChartHandler?: (params: ServerSideChartDataHandlerParams) => Promise<ServerSideChartDataHandlerResponse>;
+    filterValuesSetHandler?: (params: FilterValuesSetHandlerParams<T>) => Promise<(FilterValueResponseOption | null)[]>;
+    tableSearchHandler?: (params: TableSearchHandlerParams<T>) => Promise<(QueryTerm | null)[]>;
+    rowData?: MockRowData[];
+    colDefs?: ColDef[];
+    chartFilter?: ChartFilter;
+}
+/**
+ * Server-side row handler for PvDataTable
+ * Handles pagination, sorting, filtering, and grouping
+ */
+export declare function createServerSideRowHandler<T = MockRowData>(mockDelay: number): (params: IServerSideGetRowsParams<T>, isCsvExport?: boolean) => void;
+export declare function createServerSideChartHandler(mockDelay: number): (params: ServerSideChartDataHandlerParams) => Promise<ServerSideChartDataHandlerResponse>;
+/**
+ * Server-side filter values handler for PvDataTable
+ * Provides filter options for set filters
+ */
+export declare function createFilterValuesSetHandler<T = MockRowData>(mockDelay: number): (params: FilterValuesSetHandlerParams<T>) => Promise<(FilterValueResponseOption | null)[]>;
+/**
+ * Table search handler for PvDataTable query builder
+ * Provides search suggestions based on table data
+ */
+export declare function createTableSearchHandler<T = MockRowData>(mockDelay: number): (params: TableSearchHandlerParams<T>) => Promise<(QueryTerm | null)[]>;
+/**
+ * Helper function to create mock server configuration for PvDataTable
+ */
+export declare function createMockServerConfig<T = MockRowData>(mockDelay?: number): MockTableConfig<T>;
+export declare function createMockClientConfig<T = MockRowData>(size?: number): MockTableConfig<T>;
+/**
+ * Get a subset of mock data for client-side testing
+ */
+export declare function getMockData(count?: number): MockRowData[];
+/**
+ * Generate additional mock data on demand
+ */
+export declare function generateAdditionalMockData(count: number): MockRowData[];
+/**
+ * Clear the cached mock data to force regeneration with updated logic
+ */
+export declare function clearMockDataCache(): void;
+export {};

package/pv-components/dist/src/components/layout/PvSidePanel/PvSidePanel.spec.d.ts

@@ -0,0 +1 @@
+import "@testing-library/jest-dom/vitest";

package/pv-components/dist/src/components/layout/PvSidePanel/PvSidePanel.vue.d.ts

@@ -0,0 +1,20 @@
+interface PvSidePanelProps {
+    showLeftSidebar?: boolean;
+    showRightSidebar?: boolean;
+}
+declare var __VLS_1: {}, __VLS_3: {}, __VLS_5: {};
+type __VLS_Slots = {} & {
+    'left-sidebar'?: (props: typeof __VLS_1) => any;
+} & {
+    main?: (props: typeof __VLS_3) => any;
+} & {
+    'right-sidebar'?: (props: typeof __VLS_5) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<PvSidePanelProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<PvSidePanelProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/pv-components/dist/src/components/tables/PvDataTable/PvDataTable.vue.d.ts

@@ -0,0 +1,31 @@
+import { SortChangedEvent } from "ag-grid-community";
+import { ColumnMovedEvent, ColumnResizedEvent, ColumnRowGroupChangedEvent, FilterChangedEvent } from "ag-grid-enterprise";
+import { PvDataTableProps, PvDataTablePublicInterface } from "@tables/PvDataTable/types.ts";
+import { FirstDataRenderedEvent, GridReadyEvent } from "ag-grid-community";
+import { FocusUpdateEvent } from "@/components/tables/PvDataTable/types";
+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<any & PvDataTableProps<T> & Partial<{}>> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<PvDataTablePublicInterface>): void;
+    attrs: any;
+    slots: {
+        'top-slot'?: (props: {}) => any;
+    };
+    emit: {
+        (e: "column-moved", event: ColumnMovedEvent<T>): void;
+        (e: "column-resized", event: ColumnResizedEvent<T>): void;
+        (e: "column-row-group-changed", event: ColumnRowGroupChangedEvent<T>): void;
+        (e: "grid-ready", event: GridReadyEvent<T>): void;
+        (e: "filter-changed", event: FilterChangedEvent<T>): void;
+        (e: "sort-changed", event: SortChangedEvent<T>): void;
+        (e: "filter-opened", event: FilterChangedEvent<T>): void;
+        (e: "first-data-rendered", event: FirstDataRenderedEvent<T>): void;
+        (e: "handle-settings-icon", value: string): void;
+        (e: "focus-update", event: FocusUpdateEvent): void;
+    };
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/pv-components/dist/src/components/tables/PvDataTable/helpers.d.ts

@@ -0,0 +1,24 @@
+import { Column, FilterModel, GridState, SetFilter, SetFilterValuesFuncParams, ValueFormatterFunc } from "ag-grid-enterprise";
+import type { ColumnVO } from "ag-grid-community/dist/types/src/interfaces/iColumnVO";
+import { QueryBuilderOutput } from "@/components/base/PvQueryBuilderInput/useQueryBuilder.ts";
+import { ColDef, GridApi, IMultiFilterModel } from "ag-grid-community";
+import { ColDefContextProps } from "@tables/PvDataTable/types.ts";
+export declare const mapFilterBasedOnColDef: (filter: any, colDef: ColDef | undefined | null) => any;
+export declare const cleanInitialGridState: (state: GridState | null | undefined, colDefs: ColDef[]) => GridState | null | undefined;
+export declare const liftFocusedOptions: <T>(currentOptions: T[] | undefined, key: keyof T, currentFocuses: string[]) => T[] | undefined;
+export declare const colDefContext: <T>(colDef: ColDef<T> | null | undefined) => ColDefContextProps<T>;
+export declare const colDefValueFormatter: <T>(colDef: ColDef<T>) => ValueFormatterFunc<T> | null;
+export declare const colDefMaxSelectableValues: <T>(colDef: ColDef<T>) => number | null;
+export declare const isColDefSingleSelect: <T>(colDef: ColDef<T>) => boolean;
+export declare const isColDefNumericDataType: <T>(colDef: ColDef<T>) => boolean;
+export declare const mapQueryToFilterModel: (query: QueryBuilderOutput | null) => FilterModel;
+export declare const mergeFilterModels: (colDefs: ColDef[], primaryModel: FilterModel | null, secondaryModel: FilterModel | null) => FilterModel;
+export declare const hasSetFilter: (colDef: ColDef) => boolean;
+export declare const addHandlerToSetFilter: <T>(colDef: ColDef, handler: (params: SetFilterValuesFuncParams<T>) => void) => ColDef<T>;
+export declare const getSetFilter: (gridApi: GridApi, colDef: ColDef) => Promise<SetFilter | null>;
+export declare const updateColumnSetFilterModel: (gridApi: GridApi, colDef: ColDef, newValues: (string | null)[] | null) => Promise<IMultiFilterModel | {
+    values: (string | null)[] | null;
+} | null>;
+export declare const getSelectedValuesFromFilterModel: (colDef: ColDef, filterModel: FilterModel | null) => any;
+export declare const filterModelsEqual: (modelA: FilterModel | null | undefined, modelB: FilterModel | null | undefined) => boolean;
+export declare const mapColsToColumnV0: (columns: Column[]) => ColumnVO[];

package/pv-components/dist/src/components/tables/PvDataTable/helpers.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/pv-components/dist/src/components/tables/PvDataTable/table-components/ColumnVisibilitySelector.vue.d.ts

@@ -0,0 +1,13 @@
+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<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, never> & {} & Partial<{}>> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {};
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/pv-components/dist/src/components/tables/PvDataTable/table-components/ExportMenu.vue.d.ts

@@ -0,0 +1,15 @@
+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<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, never> & {
+        getCsvData: () => Promise<string | null>;
+    } & Partial<{}>> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {};
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/pv-components/dist/src/components/tables/PvDataTable/table-components/FilterPanel.vue.d.ts

@@ -0,0 +1,22 @@
+export interface FilterPanelProps {
+    enableFocusView?: boolean;
+    enableVerticalPanel?: boolean;
+    displayPreferencesIcon?: boolean;
+    focusableColumns?: string[];
+    maxHorizontalFilters: number;
+}
+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;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onHandle-settings-icon"> & FilterPanelProps & Partial<{}>> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {};
+    emit: (e: "handle-settings-icon", value: string) => void;
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/pv-components/dist/src/components/tables/PvDataTable/table-components/FilterValueLabel.vue.d.ts

@@ -0,0 +1,15 @@
+import { type Component } from "vue";
+export interface FilterValueLabelProps {
+    option: string | null;
+    enableFocusView: boolean;
+    filterField: string;
+    filterOptionsRenderer?: Component | null;
+    forceCheckSelection: boolean;
+    formatDisplayValue: (option: string | null) => string | null;
+    handleInputChange: (event: Event, option: string | null) => void;
+    isSingleSelect: boolean;
+    selectedValues: (string | null)[];
+    selectionDisabled: (option: string | null) => boolean;
+}
+declare const _default: import("vue").DefineComponent<FilterValueLabelProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<FilterValueLabelProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/pv-components/dist/src/components/tables/PvDataTable/table-components/FocusItemRenderer.vue.d.ts

@@ -0,0 +1,7 @@
+import { MenuOption } from "@/types";
+export interface FocusItemRendererProps {
+    filterField: string;
+    onFocusUpdate: (option: string | null) => void;
+}
+declare const _default: import("vue").DefineComponent<MenuOption, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MenuOption> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/pv-components/dist/src/components/tables/PvDataTable/table-components/GroupAggCellRenderer.vue.d.ts

@@ -0,0 +1,16 @@
+import { ICellRendererParams } from "ag-grid-enterprise";
+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<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, never> & {
+        params: ICellRendererParams;
+    } & Partial<{}>> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {};
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/pv-components/dist/src/components/tables/PvDataTable/table-components/GroupBySelector.vue.d.ts

@@ -0,0 +1,16 @@
+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<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, never> & {
+        rowGroupLimit?: number;
+        enableFocusView?: boolean;
+    } & Partial<{}>> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {};
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/pv-components/dist/src/components/tables/PvDataTable/table-components/GroupedCellRenderer.vue.d.ts

@@ -0,0 +1,15 @@
+import { GridApi } from "ag-grid-community";
+import { RowNode } from "ag-grid-enterprise";
+interface GroupCellRendererParams {
+    displayBaseAggregationsOnly: boolean;
+    displayCount: boolean;
+    displayRowNumber: boolean;
+    formattedValue: string;
+    rowNode: RowNode;
+    api: GridApi;
+}
+type __VLS_Props = {
+    params: GroupCellRendererParams;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/pv-components/dist/src/components/tables/PvDataTable/table-components/HeaderCellRenderer.vue.d.ts

@@ -0,0 +1,9 @@
+import { IHeaderParams } from "ag-grid-enterprise";
+type __VLS_Props = {
+    params: IHeaderParams;
+};
+declare function refresh(params: IHeaderParams): boolean;
+declare const _default: import("vue").DefineComponent<__VLS_Props, {
+    refresh: typeof refresh;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/pv-components/dist/src/components/tables/PvDataTable/table-components/LogoCellRenderer.vue.d.ts

@@ -0,0 +1,6 @@
+import { ICellRendererParams } from "ag-grid-enterprise";
+type __VLS_Props = {
+    params: ICellRendererParams;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/pv-components/dist/src/components/tables/PvDataTable/table-components/PaginationPanel.vue.d.ts

@@ -0,0 +1,15 @@
+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<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, never> & {
+        panelSize?: "xl" | "l";
+    } & Partial<{}>> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {};
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/pv-components/dist/src/components/tables/PvDataTable/table-components/RowCountCellRenderer.vue.d.ts

@@ -0,0 +1,16 @@
+import { ICellRendererParams } from "ag-grid-enterprise";
+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<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, never> & {
+        params: ICellRendererParams;
+    } & Partial<{}>> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {};
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/pv-components/dist/src/components/tables/PvDataTable/table-components/RowLoadingCellRenderer.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;