@google-psat/design-system 0.9.0-1

package/dist-types/components/table/components/filtersSidebar/subList.d.ts

@@ -0,0 +1,18 @@
+/**
+ * External dependencies.
+ */
+import React from 'react';
+/**
+ * Internal dependencies.
+ */
+import { type TableFilter } from '../../useTable';
+interface SubListProps {
+    filterValues: TableFilter[keyof TableFilter]['filterValues'];
+    filterKey: string;
+    sort: boolean;
+    isExpanded: boolean;
+    isSelectAllFilterEnabled: boolean;
+    isSelectAllFilterSelected: boolean;
+}
+declare const SubList: ({ filterValues, filterKey, sort, isExpanded, isSelectAllFilterEnabled, isSelectAllFilterSelected, }: SubListProps) => React.JSX.Element;
+export default SubList;

package/dist-types/components/table/components/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * External dependencies.
+ */
+import React from 'react';
+interface TableProps {
+    selectedKey: string | undefined | null;
+    isFiltersSidebarOpen?: boolean;
+    hideFiltering?: boolean;
+    extraInterfaceToTopBar?: () => React.JSX.Element;
+}
+declare const Table: ({ selectedKey, isFiltersSidebarOpen, hideFiltering, extraInterfaceToTopBar, }: TableProps) => React.JSX.Element;
+export default Table;

package/dist-types/components/table/components/tableBody/bodyCell.d.ts

@@ -0,0 +1,23 @@
+/**
+ * External dependencies.
+ */
+import React from 'react';
+/**
+ * Internal dependencies.
+ */
+import type { TableRow } from '../../useTable';
+interface BodyCellProps {
+    cell?: () => React.JSX.Element;
+    width: number;
+    isHighlighted?: boolean;
+    isRowFocused: boolean;
+    row: TableRow;
+    hasIcon?: boolean;
+    showIcon?: boolean | null;
+    icon?: {
+        Element: (props: any) => React.JSX.Element;
+    };
+    onRowClick: (e: React.MouseEvent<HTMLDivElement>) => void;
+}
+declare const BodyCell: ({ cell, width, isRowFocused, row, hasIcon, showIcon, icon, isHighlighted, }: BodyCellProps) => React.JSX.Element;
+export default BodyCell;

package/dist-types/components/table/components/tableBody/bodyRow.d.ts

@@ -0,0 +1,20 @@
+/**
+ * External dependencies.
+ */
+import React from 'react';
+import type { TableColumn, TableRow } from '../../useTable';
+interface BodyRowProps {
+    row: TableRow;
+    columns: TableColumn[];
+    index: number;
+    selectedKey: string | undefined | null;
+    isRowFocused: boolean;
+    getExtraClasses: () => string;
+    hasVerticalBar: boolean;
+    getRowObjectKey: (row: TableRow) => string;
+    onRowClick: (e: React.MouseEvent<HTMLDivElement>) => void;
+    onKeyDown: (e: React.KeyboardEvent<HTMLDivElement>, index: number) => void;
+    onRowContextMenu: (e: React.MouseEvent<HTMLDivElement>, row: TableRow) => void;
+}
+declare const BodyRow: ({ row, columns, index, selectedKey, isRowFocused, getExtraClasses, hasVerticalBar, getRowObjectKey, onRowClick, onKeyDown, onRowContextMenu, }: BodyRowProps) => React.JSX.Element;
+export default BodyRow;

package/dist-types/components/table/components/tableBody/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * External dependencies.
+ */
+import React from 'react';
+interface TableBodyProps {
+    isRowFocused: boolean;
+    setIsRowFocused: (state: boolean) => void;
+    selectedKey: string | undefined | null;
+}
+declare const TableBody: ({ isRowFocused, setIsRowFocused, selectedKey, }: TableBodyProps) => React.JSX.Element;
+export default TableBody;

package/dist-types/components/table/components/tableHeader/headerCell.d.ts

@@ -0,0 +1,12 @@
+/**
+ * External dependencies.
+ */
+import React from 'react';
+import { type TableColumn } from '../../useTable';
+interface HeaderCellProps {
+    index: number;
+    cell: TableColumn;
+    setIsRowFocused: (state: boolean) => void;
+}
+declare const HeaderCell: ({ index, cell, setIsRowFocused }: HeaderCellProps) => React.JSX.Element;
+export default HeaderCell;

package/dist-types/components/table/components/tableHeader/headerResizer.d.ts

@@ -0,0 +1,9 @@
+/**
+ * External dependencies.
+ */
+import React from 'react';
+interface HeaderResizerProps {
+    onMouseDown: (e: React.MouseEvent<HTMLDivElement, MouseEvent>) => void;
+}
+declare const HeaderResizer: ({ onMouseDown }: HeaderResizerProps) => React.JSX.Element;
+export default HeaderResizer;

package/dist-types/components/table/components/tableHeader/headerRow.d.ts

@@ -0,0 +1,9 @@
+/**
+ * External dependencies.
+ */
+import React from 'react';
+interface HeaderRowProps {
+    setIsRowFocused: (state: boolean) => void;
+}
+declare const HeaderRow: ({ setIsRowFocused }: HeaderRowProps) => React.JSX.Element;
+export default HeaderRow;

package/dist-types/components/table/components/tableHeader/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * External dependencies.
+ */
+import React from 'react';
+interface TableHeaderProps {
+    setColumnPosition: (position: {
+        x: number;
+        y: number;
+    }) => void;
+    onRightClick: (event: React.MouseEvent<HTMLTableSectionElement, MouseEvent>) => void;
+    setIsRowFocused: (state: boolean) => void;
+}
+declare const TableHeader: ({ setColumnPosition, onRightClick, setIsRowFocused, }: TableHeaderProps) => React.JSX.Element;
+export default TableHeader;

package/dist-types/components/table/components/tableTopBar/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * External dependencies.
+ */
+import React from 'react';
+interface TableTopBarProps {
+    showFilterSidebar: boolean;
+    setShowFilterSidebar: React.Dispatch<React.SetStateAction<boolean>>;
+    hideFiltering?: boolean;
+    disableFiltering?: boolean;
+    extraInterface?: () => React.JSX.Element;
+}
+declare const TableTopBar: ({ showFilterSidebar, setShowFilterSidebar, hideFiltering, disableFiltering, extraInterface, }: TableTopBarProps) => React.JSX.Element;
+export default TableTopBar;

package/dist-types/components/table/index.d.ts

@@ -0,0 +1,4 @@
+export { default as Table } from './components';
+export * from './persistentSettingsStore';
+export * from './useTable';
+export * from './utils';

package/dist-types/components/table/persistentSettingsStore/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * External dependencies
+ */
+import React, { PropsWithChildren } from 'react';
+/**
+ * Internal dependencies
+ */
+import { PersistentStorageData } from '../useTable';
+export declare const TABLE_PERSISTENT_SETTINGS_STORE_KEY = "tablePersistentSettingsStore";
+export interface TablePersistentSettingsStoreContext {
+    state: {
+        [persistenceKey: string]: PersistentStorageData;
+    };
+    actions: {
+        setPreferences: (options: PersistentStorageData, persistenceKey: string) => Promise<void>;
+        getPreferences: (persistentkey: string, type: keyof PersistentStorageData) => PersistentStorageData[keyof PersistentStorageData];
+    };
+}
+export declare const Context: import("use-context-selector").Context<TablePersistentSettingsStoreContext>;
+export declare const Provider: ({ children }: PropsWithChildren) => React.JSX.Element;
+export declare function useTablePersistentSettingsStore(): TablePersistentSettingsStoreContext;
+export declare function useTablePersistentSettingsStore<T>(selector: (state: TablePersistentSettingsStoreContext) => T): T;

package/dist-types/components/table/persistentSettingsStore/utils/extractStorage.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Internal dependencies
+ */
+import { TablePersistentSettingsStoreContext } from '..';
+declare const extractStorage: (persistenceKey: string, isChromeExtension: boolean) => Promise<TablePersistentSettingsStoreContext['state']>;
+export default extractStorage;

package/dist-types/components/table/persistentSettingsStore/utils/index.d.ts

@@ -0,0 +1,2 @@
+export { default as extractStorage } from './extractStorage';
+export { default as updateStorage } from './updateStorage';

package/dist-types/components/table/persistentSettingsStore/utils/updateStorage.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Internal dependencies
+ */
+import { PersistentStorageData } from '../../useTable';
+declare const updateStorage: (persistenceKey: string, isChromeExtension: boolean, options: PersistentStorageData) => Promise<{
+    [persistenceKey: string]: PersistentStorageData;
+}>;
+export default updateStorage;

package/dist-types/components/table/useTable/context.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Internal dependencies.
+ */
+import { TableColumn, TableFilter, TableRow, TableProviderProps } from './types';
+import { ColumnResizingOutput } from './useColumnResizing';
+import { ColumnSortingOutput } from './useColumnSorting';
+import { ColumnVisibilityOutput } from './useColumnVisibility';
+import { TableFilteringOutput } from './useFiltering';
+import { TableSearchOutput } from './useSearch';
+export interface TableStoreContext {
+    state: {
+        columns: TableColumn[];
+        hideableColumns: TableColumn[];
+        rows: TableRow[];
+        sortKey: ColumnSortingOutput['sortKey'];
+        sortOrder: ColumnSortingOutput['sortOrder'];
+        areAllColumnsVisible: ColumnVisibilityOutput['areAllColumnsVisible'];
+        tableContainerRef: ColumnResizingOutput['tableContainerRef'];
+        isResizing: ColumnResizingOutput['isResizing'];
+        filters: TableFilter;
+        selectedFilters: TableFilter;
+        isFiltering: TableFilteringOutput['isFiltering'];
+        searchValue: TableSearchOutput['searchValue'];
+    };
+    actions: {
+        setSortKey: ColumnSortingOutput['setSortKey'];
+        setSortOrder: ColumnSortingOutput['setSortOrder'];
+        hideColumn: ColumnVisibilityOutput['hideColumn'];
+        toggleVisibility: ColumnVisibilityOutput['toggleVisibility'];
+        showColumn: ColumnVisibilityOutput['showColumn'];
+        isColumnHidden: ColumnVisibilityOutput['isColumnHidden'];
+        onMouseDown: ColumnResizingOutput['onMouseDown'];
+        toggleFilterSelection: TableFilteringOutput['toggleFilterSelection'];
+        toggleSelectAllFilter: TableFilteringOutput['toggleSelectAllFilter'];
+        resetFilters: TableFilteringOutput['resetFilters'];
+        isSelectAllFilterSelected: TableFilteringOutput['isSelectAllFilterSelected'];
+        setSearchValue: TableSearchOutput['setSearchValue'];
+        onRowClick: TableProviderProps['onRowClick'];
+        onRowContextMenu: TableProviderProps['onRowContextMenu'];
+        getRowObjectKey: TableProviderProps['getRowObjectKey'];
+        conditionalTableRowClassesHandler?: TableProviderProps['conditionalTableRowClassesHandler'];
+        exportTableData?: TableProviderProps['exportTableData'];
+        hasVerticalBar?: TableProviderProps['hasVerticalBar'];
+    };
+}
+export declare const TableContext: import("use-context-selector").Context<TableStoreContext>;

package/dist-types/components/table/useTable/index.d.ts

@@ -0,0 +1,3 @@
+export * from './provider';
+export * from './types';
+export * from './useTable';

package/dist-types/components/table/useTable/provider.d.ts

@@ -0,0 +1,6 @@
+/**
+ * External dependencies.
+ */
+import React, { PropsWithChildren } from 'react';
+import { TableProviderProps } from './types';
+export declare const TableProvider: ({ data, tableColumns, tableFilterData, tableSearchKeys, tablePersistentSettingsKey, onRowClick, onRowContextMenu, getRowObjectKey, conditionalTableRowClassesHandler, exportTableData, hasVerticalBar, isRowSelected, children, }: PropsWithChildren<TableProviderProps>) => React.JSX.Element;

package/dist-types/components/table/useTable/types.d.ts

@@ -0,0 +1,77 @@
+/// <reference types="react" />
+/**
+ * External dependencies.
+ */
+import { CookieTableData, TechnologyData } from '@google-psat/common';
+export type TableData = (CookieTableData | TechnologyData) & {
+    highlighted?: boolean;
+};
+export type InfoType = number | string | boolean | Array<string | number> | [];
+export type TableColumn = {
+    header: string;
+    accessorKey: string;
+    cell: (info: InfoType, details?: TableData) => React.JSX.Element | InfoType;
+    enableHiding?: boolean;
+    isHiddenByDefault?: boolean;
+    enableBodyCellPrefixIcon?: boolean;
+    bodyCellPrefixIcon?: {
+        Element: (props: any) => React.JSX.Element;
+    };
+    showBodyCellPrefixIcon?: (row: TableRow) => boolean;
+    widthWeightagePercentage?: number;
+    width?: number;
+};
+export type TableRow = {
+    [accessorKey: string]: {
+        value: () => React.JSX.Element;
+    };
+    originalData: TableData;
+};
+export type TableFilter = {
+    [accessorKey: string]: {
+        title: string;
+        description?: string;
+        hasStaticFilterValues?: boolean;
+        hasPrecalculatedFilterValues?: boolean;
+        enableSelectAllOption?: boolean;
+        isSelectAllOptionSelected?: boolean;
+        filterValues?: {
+            [filterValue: string]: {
+                selected: boolean | null;
+                description?: string;
+            };
+        };
+        sortValues?: boolean;
+        useGenericPersistenceKey?: boolean;
+        calculateFilterValues?: (value: InfoType) => string;
+        comparator?: (value: InfoType, filterValue: string) => boolean;
+    };
+};
+export type PersistentStorageData = {
+    columnsVisibility?: {
+        [key: string]: boolean;
+    };
+    columnsSizing?: {
+        [key: string]: number;
+    };
+    sortBy?: string;
+    sortOrder?: 'asc' | 'desc';
+    selectedFilters?: {
+        [key: string]: TableFilter[keyof TableFilter]['filterValues'];
+    };
+    searchValue?: string;
+};
+export interface TableProviderProps {
+    data: TableData[];
+    tableColumns: TableColumn[];
+    tableFilterData?: TableFilter;
+    tableSearchKeys?: string[];
+    tablePersistentSettingsKey?: string;
+    onRowClick: (row: TableData | null) => void;
+    onRowContextMenu: (e: React.MouseEvent<HTMLDivElement>, row: TableRow) => void;
+    getRowObjectKey: (row: TableRow) => string;
+    conditionalTableRowClassesHandler?: (row: TableRow, isRowFocused: boolean, rowIndex: number) => string;
+    exportTableData?: (rows: TableRow[]) => void;
+    hasVerticalBar?: (row: TableRow) => boolean;
+    isRowSelected?: (cookie: TableData | null) => boolean;
+}

package/dist-types/components/table/useTable/useColumnResizing/handleResizeOnColumnsVisibilityChange.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Internal dependencies
+ */
+import { TableColumn } from '../types';
+export declare const handleResizeOnColumnsVisibilityChange: (prevColumnsState: TableColumn[], newTableColumnsToRender: TableColumn[], columnsSizing: {
+    [key: string]: number;
+}, tableWidth: number, isToggleAll: boolean) => TableColumn[];

package/dist-types/components/table/useTable/useColumnResizing/index.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+/**
+ * Internal dependencies.
+ */
+import type { TableColumn } from '../types';
+export type ColumnResizingOutput = {
+    columns: TableColumn[];
+    tableContainerRef: React.RefObject<HTMLDivElement> | null;
+    onMouseDown: (selectedColumnRef: React.RefObject<HTMLTableHeaderCellElement>, index: number) => void;
+    isResizing: boolean;
+};
+declare const useColumnResizing: (tableColumns: TableColumn[], allTableColumnsKeys: string[], tablePersistentSettingsKey?: string) => ColumnResizingOutput;
+export default useColumnResizing;

package/dist-types/components/table/useTable/useColumnResizing/resizeColumns.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Internal dependencies
+ */
+import { TableColumn } from '../types';
+export declare const resizeColumns: (columnsToResize: TableColumn[], tableWidth: number) => TableColumn[];

package/dist-types/components/table/useTable/useColumnSorting/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Internal dependencies.
+ */
+import type { TableData } from '../types';
+export type DefaultOptions = {
+    defaultSortKey?: string;
+    defaultSortOrder?: 'asc' | 'desc';
+};
+export type ColumnSortingOutput = {
+    sortedData: TableData[];
+    setSortKey: (key: string) => void;
+    setSortOrder: (order: 'asc' | 'desc') => void;
+    sortKey: string;
+    sortOrder: 'asc' | 'desc';
+};
+declare const useColumnSorting: (data: TableData[], tablePersistentSettingsKey?: string) => ColumnSortingOutput;
+export default useColumnSorting;

package/dist-types/components/table/useTable/useColumnVisibility/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Internal dependencies.
+ */
+import type { TableColumn } from '../types';
+export type ColumnVisibilityOutput = {
+    visibleColumns: TableColumn[];
+    hideColumn: (key: string) => void;
+    toggleVisibility: () => void;
+    areAllColumnsVisible: boolean;
+    showColumn: (key: string) => void;
+    isColumnHidden: (key: string) => boolean;
+};
+declare const useColumnVisibility: (columns: TableColumn[], tablePersistentSettingsKey?: string) => ColumnVisibilityOutput;
+export default useColumnVisibility;

package/dist-types/components/table/useTable/useFiltering/hooks/index.d.ts

@@ -0,0 +1,3 @@
+export { default as useFiltersPersistence } from './useFiltersPersistence';
+export { default as useFiltersOptions } from './useFiltersOptions';
+export { default as useFiltersExtraction } from './useFiltersExtraction';

package/dist-types/components/table/useTable/useFiltering/hooks/useFiltersExtraction.d.ts

@@ -0,0 +1,14 @@
+import { PersistentStorageData, TableData, TableFilter } from '../../types';
+/**
+ * External dependencies.
+ */
+declare const useFiltersExtraction: (data: TableData[], tableFilterData: TableFilter | undefined, options: React.MutableRefObject<PersistentStorageData['selectedFilters']>, selectAllFilterSelection: {
+    [filterKey: string]: {
+        selected: boolean | null;
+    };
+}, setFilters: React.Dispatch<React.SetStateAction<TableFilter>>, setSelectAllFilterSelection: React.Dispatch<React.SetStateAction<{
+    [filterKey: string]: {
+        selected: boolean | null;
+    };
+}>>) => void;
+export default useFiltersExtraction;

package/dist-types/components/table/useTable/useFiltering/hooks/useFiltersOptions.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Internal dependencies.
+ */
+import { PersistentStorageData, TableFilter } from '../../types';
+declare const useFiltersOptions: (setSelectAllFilterSelection: React.Dispatch<React.SetStateAction<{
+    [filterKey: string]: {
+        selected: boolean | null;
+    };
+}>>, setFilters: React.Dispatch<React.SetStateAction<TableFilter>>, options: React.MutableRefObject<PersistentStorageData['selectedFilters']>, isDataLoading: boolean) => void;
+export default useFiltersOptions;

package/dist-types/components/table/useTable/useFiltering/hooks/useFiltersPersistence.d.ts

@@ -0,0 +1,7 @@
+import { PersistentStorageData, TableFilter } from '../../types';
+declare const useFiltersPersistence: (filters: TableFilter | undefined, options: React.MutableRefObject<PersistentStorageData['selectedFilters']>, selectAllFilters: {
+    [filterKey: string]: {
+        selected: boolean | null;
+    };
+}, setIsDataLoading: React.Dispatch<React.SetStateAction<boolean>>, specificTablePersistentSettingsKey?: string, genericTablePersistentSettingsKey?: string) => void;
+export default useFiltersPersistence;

package/dist-types/components/table/useTable/useFiltering/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Internal dependencies.
+ */
+import type { TableData, TableFilter } from '../types';
+export type TableFilteringOutput = {
+    filters: TableFilter;
+    selectedFilters: TableFilter;
+    filteredData: TableData[];
+    isFiltering: boolean;
+    toggleFilterSelection: (filterKey: string, filterValue: string, isRemovalAction?: boolean) => void;
+    toggleSelectAllFilter: (filterKey: string, isSingleFilterRemovalAction?: boolean) => void;
+    isSelectAllFilterSelected: (filterKey: string) => boolean;
+    resetFilters: () => void;
+};
+declare const useFiltering: (data: TableData[], tableFilterData: TableFilter | undefined, specificTablePersistentSettingsKey?: string, genericTablePersistentSettingsKey?: string) => TableFilteringOutput;
+export default useFiltering;

package/dist-types/components/table/useTable/useSearch/index.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="react" />
+/**
+ * Internal dependencies.
+ */
+import { TableData } from '../types';
+export type TableSearchOutput = {
+    searchValue: string;
+    setSearchValue: (value: string) => void;
+    searchFilteredData: TableData[];
+};
+declare const useSearch: (data: TableData[], searchKeys?: string[], tablePersistentSettingsKey?: string) => {
+    searchValue: string;
+    setSearchValue: import("react").Dispatch<import("react").SetStateAction<string>>;
+    searchFilteredData: TableData[];
+};
+export default useSearch;

package/dist-types/components/table/useTable/useTable.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Internal dependencies.
+ */
+import { TableStoreContext } from './context';
+export declare function useTable(): TableStoreContext;
+export declare function useTable<T>(selector: (state: TableStoreContext) => T): T;

package/dist-types/components/table/utils/generatExtensionCookietableCSV.d.ts

@@ -0,0 +1,6 @@
+/**
+ * External dependencies.
+ */
+import { CookieTableData } from '@google-psat/common';
+declare const generateExtensionCookieTableCSV: (cookies: CookieTableData[]) => Blob;
+export default generateExtensionCookieTableCSV;

package/dist-types/components/table/utils/generateCLICookieTableCSV.d.ts

@@ -0,0 +1,6 @@
+/**
+ * External dependencies.
+ */
+import { CookieTableData } from '@google-psat/common';
+declare const generateCLICookieTableCSV: (cookies: CookieTableData[]) => Blob;
+export default generateCLICookieTableCSV;

package/dist-types/components/table/utils/index.d.ts

@@ -0,0 +1,3 @@
+export { default as generateCLICookieTableCSV } from './generateCLICookieTableCSV';
+export { default as generateExtensionCookieTableCSV } from './generatExtensionCookietableCSV';
+export * from './precalculatedFiltersUtils';

package/dist-types/components/table/utils/precalculatedFiltersUtils/calculateBlockedReasonsFilterValues.d.ts

@@ -0,0 +1,19 @@
+/**
+ * External dependencies
+ */
+import { type CookieTableData } from '@google-psat/common';
+/**
+ * Calculate the filter values for the blocked reasons filter.
+ * Use options to preselect the filter values.
+ * @param tabCookies Cookies to calculate the filter values from.
+ * @param options Options to preselect the filter values.
+ * @param clearQuery Function to clear the query(when options are provided) to avoid conflicts.
+ * @returns Filter values for the blocked reasons filter.
+ */
+declare const calculateBlockedReasonsFilterValues: (tabCookies: CookieTableData[], options: string[], clearQuery?: () => void) => {
+    [filterValue: string]: {
+        selected: boolean | null;
+        description?: string | undefined;
+    };
+} | undefined;
+export default calculateBlockedReasonsFilterValues;

package/dist-types/components/table/utils/precalculatedFiltersUtils/calculateDynamicFilterValues.d.ts

@@ -0,0 +1,20 @@
+/**
+ * External dependencies
+ */
+import { type CookieTableData } from '@google-psat/common';
+/**
+ * Internal dependencies
+ */
+import { TableFilter } from '../../useTable';
+/**
+ * Calculate the filter values for the provider key.
+ * Use options to preselect the filter values, if options are provided clear the query to avoid conflicts.
+ * @param key Key to calculate the filter values for.
+ * @param tabCookies Cookies to calculate the filter values from.
+ * @param options Options to preselect the filter values.
+ * @param clearQuery Function to clear the query(when options are provided) to avoid conflicts.
+ * @param runTranslation Boolean to check if the translation should be run.
+ * @returns	Filters for the provider key.
+ */
+declare const calculateDynamicFilterValues: (key: string, tabCookies: CookieTableData[], options: string[], clearQuery?: () => void, runTranslation?: boolean) => TableFilter[keyof TableFilter]['filterValues'];
+export default calculateDynamicFilterValues;

package/dist-types/components/table/utils/precalculatedFiltersUtils/calculateExemptionReasons.d.ts

@@ -0,0 +1,15 @@
+import { CookieTableData } from '@google-psat/common';
+/**
+ * This function will return set of non duplicated cookie execmption reason.
+ * @param cookies The cookie table data.
+ * @param clearQuery Function to clear the query(when options are provided) to avoid conflicts.
+ * @param options Options to preselect the filter values.
+ * @returns {string[]} Unique set of exemption reasons.
+ */
+declare function frameOnlyExemptionReasonValues(cookies: CookieTableData[], clearQuery?: () => void, options?: string[]): {
+    [filterValue: string]: {
+        selected: boolean | null;
+        description?: string | undefined;
+    };
+} | undefined;
+export default frameOnlyExemptionReasonValues;

package/dist-types/components/table/utils/precalculatedFiltersUtils/evaluateSelectAllOption.d.ts

@@ -0,0 +1,9 @@
+/**
+ *	Evaluate if the 'All' option is present in parsedQuery.
+ * @param filterKey Filter key to evaluate.
+ * @param parsedQuery Query to evaluate from.
+ * @param clearActivePanelQuery Function to clear the query to avoid conflicts.
+ * @returns True if 'All' option is present in parsedQuery, false otherwise.
+ */
+declare const evaluateSelectAllOption: (filterKey: string, parsedQuery: Record<string, any>, clearActivePanelQuery?: () => void) => boolean;
+export default evaluateSelectAllOption;

package/dist-types/components/table/utils/precalculatedFiltersUtils/evaluateStaticFilterValues.d.ts

@@ -0,0 +1,16 @@
+import { TableFilter } from '../../useTable';
+/**
+ * Preselect the static filter values based on the options provided.
+ * @param staticValues Filter values to evaluate.
+ * @param filterKey Filter key to evaluate.
+ * @param parsedQuery Query to evaluate from.
+ * @param clearActivePanelQuery Function to clear the query to avoid conflicts.
+ * @returns Filter values for the static filter.
+ */
+declare const evaluateStaticFilterValues: (staticValues: TableFilter[keyof TableFilter]['filterValues'], filterKey: string, parsedQuery: Record<string, any>, clearActivePanelQuery?: () => void) => {
+    [filterValue: string]: {
+        selected: boolean | null;
+        description?: string | undefined;
+    };
+} | undefined;
+export default evaluateStaticFilterValues;

package/dist-types/components/table/utils/precalculatedFiltersUtils/index.d.ts

@@ -0,0 +1,5 @@
+export { default as calculateDynamicFilterValues } from './calculateDynamicFilterValues';
+export { default as evaluateStaticFilterValues } from './evaluateStaticFilterValues';
+export { default as evaluateSelectAllOption } from './evaluateSelectAllOption';
+export { default as calculateBlockedReasonsFilterValues } from './calculateBlockedReasonsFilterValues';
+export { default as calculateExemptionReason } from './calculateExemptionReasons';

package/dist-types/components/toastMessage/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * External dependencies.
+ */
+import React from 'react';
+interface ToastMessageProps {
+    text: string;
+    onClick: () => void;
+    additionalStyles?: string;
+    textAdditionalStyles?: string;
+    variant?: 'primary' | 'secondary' | 'danger' | 'small' | 'large';
+    buttonText?: string;
+}
+declare const ToastMessage: ({ text, onClick, additionalStyles, textAdditionalStyles, variant, buttonText, }: ToastMessageProps) => React.JSX.Element;
+export default ToastMessage;

package/dist-types/components/toggleSwitch/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * External dependencies
+ */
+import React from 'react';
+type ToggleSwitchProps = {
+    enabled: boolean;
+    setEnabled: (newValue: boolean) => void;
+    onLabel?: string;
+    additionalStyles?: string;
+};
+declare const ToggleSwitch: ({ enabled, setEnabled, onLabel, additionalStyles, }: ToggleSwitchProps) => React.JSX.Element;
+export default ToggleSwitch;