@firecms/core 3.0.0-alpha.70 → 3.0.0-alpha.71

package/src/components/EntityCollectionView/EntityCollectionViewActions.d.ts

@@ -0,0 +1,14 @@
+import { EntityCollection, SelectionController, TableController } from "../../types";
+export type EntityCollectionViewActionsProps<M extends Record<string, any>> = {
+    collection: EntityCollection<M>;
+    path: string;
+    relativePath: string;
+    parentCollectionIds: string[];
+    selectionEnabled: boolean;
+    onNewClick: () => void;
+    onMultipleDeleteClick: () => void;
+    selectionController: SelectionController<M>;
+    tableController: TableController<M>;
+    collectionEntitiesCount: number;
+};
+export declare function EntityCollectionViewActions<M extends Record<string, any>>({ collection, relativePath, parentCollectionIds, onNewClick, onMultipleDeleteClick, selectionEnabled, path, selectionController, tableController, collectionEntitiesCount }: EntityCollectionViewActionsProps<M>): import("react/jsx-runtime").JSX.Element;

package/src/components/EntityCollectionView/useColumnsIds.d.ts

@@ -0,0 +1,4 @@
+import { ResolvedEntityCollection, ResolvedProperty } from "../../types";
+import { PropertyColumnConfig } from "../EntityCollectionTable/EntityCollectionTableProps";
+export declare function useColumnIds<M extends Record<string, any>>(collection: ResolvedEntityCollection<M>, includeSubcollections: boolean): PropertyColumnConfig[];
+export declare function getColumnKeysForProperty(property: ResolvedProperty, key: string, disabled?: boolean): PropertyColumnConfig[];

package/src/components/EntityPreview.d.ts

@@ -0,0 +1,11 @@
+import { Entity, EntityCollection } from "../types";
+/**
+ * @group Components
+ */
+export interface EntityPreviewProps<M extends Record<string, any>> {
+    entity: Entity<M>;
+    collection: EntityCollection<M>;
+    path: string;
+    className?: string;
+}
+export declare function EntityPreview<M extends Record<string, any>>({ entity, collection, path, className }: EntityPreviewProps<M>): import("react/jsx-runtime").JSX.Element;

package/src/components/ErrorBoundary.d.ts

@@ -0,0 +1,11 @@
+import React, { ErrorInfo, PropsWithChildren } from "react";
+export declare class ErrorBoundary extends React.Component<PropsWithChildren<Record<string, unknown>>, {
+    error: Error | null;
+}> {
+    constructor(props: any);
+    static getDerivedStateFromError(error: Error): {
+        error: Error;
+    };
+    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
+    render(): string | number | boolean | Iterable<React.ReactNode> | import("react/jsx-runtime").JSX.Element | null | undefined;
+}

package/src/components/ErrorTooltip.d.ts

@@ -0,0 +1,2 @@
+import { TooltipProps } from "@firecms/ui";
+export declare function ErrorTooltip(props: TooltipProps): import("react/jsx-runtime").JSX.Element;

package/src/components/ErrorView.d.ts

@@ -0,0 +1,19 @@
+import React from "react";
+/**
+ * @group Components
+ */
+export interface ErrorViewProps {
+    title?: string;
+    error: Error | React.ReactElement | string;
+    tooltip?: string;
+}
+/**
+ * Generic error view. Displayed for example when an unexpected value comes
+ * from the datasource in a collection view.
+ * @param title
+ * @param error
+ * @param tooltip
+ * @constructor
+ * @group Components
+ */
+export declare function ErrorView({ title, error, tooltip }: ErrorViewProps): React.ReactElement;

package/src/components/FieldConfigBadge.d.ts

@@ -0,0 +1,4 @@
+import { PropertyConfig } from "../types";
+export declare function FieldConfigBadge({ propertyConfig }: {
+    propertyConfig: PropertyConfig | undefined;
+}): React.ReactNode;

package/src/components/FireCMSAppBar.d.ts

@@ -0,0 +1,26 @@
+import React from "react";
+import { User } from "../types";
+export type FireCMSAppBarProps<ADDITIONAL_PROPS = object> = {
+    title: string;
+    /**
+     * A component that gets rendered on the upper side of the main toolbar
+     */
+    endAdornment?: React.ReactNode;
+    startAdornment?: React.ReactNode;
+    dropDownActions?: React.ReactNode;
+    includeDrawer?: boolean;
+    drawerOpen: boolean;
+    className?: string;
+    style?: React.CSSProperties;
+    user?: User;
+} & ADDITIONAL_PROPS;
+/**
+ * This component renders the main app bar of FireCMS.
+ * You will likely not need to use this component directly.
+ *
+ * @param title
+ * @param toolbarExtraWidget
+ * @param drawerOpen
+ * @constructor
+ */
+export declare const FireCMSAppBar: ({ title, endAdornment, startAdornment, drawerOpen, dropDownActions, includeDrawer, className, style, user: userProp }: FireCMSAppBarProps) => import("react/jsx-runtime").JSX.Element;

package/src/components/FireCMSLogo.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+export declare function FireCMSLogo({ width, height, className, style }: {
+    width?: string;
+    height?: string;
+    className?: string;
+    style?: React.CSSProperties;
+}): import("react/jsx-runtime").JSX.Element;

package/src/components/HomePage/DefaultHomePage.d.ts

@@ -0,0 +1,21 @@
+import React from "react";
+/**
+ * Default entry view for the CMS. This component renders navigation cards
+ * for each collection defined in the navigation.
+ * @constructor
+ * @group Components
+ */
+export declare function DefaultHomePage({ additionalActions, additionalChildrenStart, additionalChildrenEnd }: {
+    /**
+     * Additional actions to be rendered in the home page, close to the search bar.
+     */
+    additionalActions?: React.ReactNode;
+    /**
+     * Additional children to be rendered in the beginning of the home page.
+     */
+    additionalChildrenStart?: React.ReactNode;
+    /**
+     * Additional children to be rendered at the end of the home page.
+     */
+    additionalChildrenEnd?: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/src/components/HomePage/FavouritesView.d.ts

@@ -0,0 +1,3 @@
+export declare function FavouritesView({ hidden }: {
+    hidden: boolean;
+}): import("react/jsx-runtime").JSX.Element | null;

package/src/components/HomePage/NavigationCollectionCard.d.ts

@@ -0,0 +1,17 @@
+import { TopNavigationEntry } from "../../types";
+/**
+ * This is the component used in the home page to render a card for each
+ * collection.
+ * @group Components
+ * @param view
+ * @param path
+ * @param collection
+ * @param url
+ * @param name
+ * @param description
+ * @param onClick
+ * @constructor
+ */
+export declare function NavigationCollectionCard({ view, path, collection, url, name, description, onClick }: TopNavigationEntry & {
+    onClick?: () => void;
+}): import("react/jsx-runtime").JSX.Element;

package/src/components/HomePage/NavigationGroup.d.ts

@@ -0,0 +1,4 @@
+import { PropsWithChildren } from "react";
+export declare function NavigationGroup({ children, group }: PropsWithChildren<{
+    group: string | undefined;
+}>): import("react/jsx-runtime").JSX.Element;

package/src/components/HomePage/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./DefaultHomePage";
+export * from "./NavigationCollectionCard";
+export * from "./NavigationGroup";

package/src/components/LabelWithIcon.d.ts

@@ -0,0 +1,14 @@
+import React from "react";
+interface LabelWithIconProps {
+    icon: React.ReactNode;
+    title?: string;
+    small?: boolean;
+    className?: string;
+    required?: boolean;
+}
+/**
+ * Render the label of with an icon and the title of a property
+ * @group Form custom fields
+ */
+export declare function LabelWithIcon({ icon, title, small, className, required }: LabelWithIconProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/src/components/NotFoundPage.d.ts

@@ -0,0 +1 @@
+export declare function NotFoundPage(): import("react/jsx-runtime").JSX.Element;

package/src/components/ReferenceSelectionInner.d.ts

@@ -0,0 +1,58 @@
+import React from "react";
+import { Entity, EntityCollection, FilterValues } from "../types";
+/**
+ * @group Components
+ */
+export interface ReferenceSelectionInnerProps<M extends Record<string, any>> {
+    /**
+     * Allow multiple selection of values
+     */
+    multiselect?: boolean;
+    /**
+     * Entity collection config
+     */
+    collection?: EntityCollection<M>;
+    /**
+     * Absolute path of the collection.
+     * May be not set if this hook is being used in a component and the path is
+     * dynamic. If not set, the dialog won't open.
+     */
+    path: string;
+    /**
+     * If you are opening the dialog for the first time, you can select some
+     * entity ids to be displayed first.
+     */
+    selectedEntityIds?: string[];
+    /**
+     * If `multiselect` is set to `false`, you will get the selected entity
+     * in this callback.
+     * @param entity
+     * @callback
+     */
+    onSingleEntitySelected?(entity: Entity<any> | null): void;
+    /**
+     * If `multiselect` is set to `true`, you will get the selected entities
+     * in this callback.
+     * @param entities
+     * @callback
+     */
+    onMultipleEntitiesSelected?(entities: Entity<any>[]): void;
+    /**
+     * Allow selection of entities that pass the given filter only.
+     */
+    forceFilter?: FilterValues<string>;
+    /**
+     * Use this description to indicate the user what to do in this dialog.
+     */
+    description?: React.ReactNode;
+    /**
+     * Maximum number of entities that can be selected.
+     */
+    maxSelection?: number;
+}
+/**
+ * This component allows to select entities from a given collection.
+ * You probably want to open this dialog as a side view using {@link useReferenceDialog}
+ * @group Components
+ */
+export declare function ReferenceSelectionInner<M extends Record<string, any>>({ onSingleEntitySelected, onMultipleEntitiesSelected, multiselect, collection, path: pathInput, selectedEntityIds: selectedEntityIdsProp, description, forceFilter, maxSelection }: ReferenceSelectionInnerProps<M>): import("react/jsx-runtime").JSX.Element;

package/src/components/ReferenceWidget.d.ts

@@ -0,0 +1,28 @@
+import { Entity, EntityReference, FilterValues } from "../types";
+import { PreviewSize } from "../preview";
+export type ReferenceWidgetProps<M extends Record<string, any>> = {
+    name?: string;
+    multiselect?: boolean;
+    value: EntityReference<M> | EntityReference<M>[] | null;
+    onReferenceSelected?: (params: {
+        reference: EntityReference<M> | null;
+        entity: Entity<M> | null;
+    }) => void;
+    onMultipleReferenceSelected?: (params: {
+        references: EntityReference<M>[] | null;
+        entities: Entity<M>[] | null;
+    }) => void;
+    path: string;
+    disabled?: boolean;
+    previewProperties?: string[];
+    /**
+     * Allow selection of entities that pass the given filter only.
+     */
+    forceFilter?: FilterValues<string>;
+    size: PreviewSize;
+    className?: string;
+};
+/**
+ * This field allows selecting reference/s.
+ */
+export declare function ReferenceWidget<M extends Record<string, any>>({ name, multiselect, path, disabled, value, onReferenceSelected, onMultipleReferenceSelected, previewProperties, forceFilter, size, className }: ReferenceWidgetProps<M>): import("react/jsx-runtime").JSX.Element;

package/src/components/VirtualTable/VirtualTable.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+import { VirtualTableProps } from "./VirtualTableProps";
+/**
+ * This is a Table component that allows displaying arbitrary data, not
+ * necessarily related to entities or properties. It is the component
+ * that powers the entity collections but has a generic API, so it
+ * can be reused.
+ *
+ * @group Components
+ */
+export declare const VirtualTable: React.NamedExoticComponent<VirtualTableProps<any>>;

package/src/components/VirtualTable/VirtualTableCell.d.ts

@@ -0,0 +1,14 @@
+import React from "react";
+import { CellRendererParams, VirtualTableColumn } from "./VirtualTableProps";
+type VirtualTableCellProps<T extends any> = {
+    dataKey: string;
+    column: VirtualTableColumn;
+    columns: VirtualTableColumn[];
+    rowData: any;
+    cellData: any;
+    rowIndex: any;
+    columnIndex: number;
+    cellRenderer: (params: CellRendererParams<T>) => React.ReactNode;
+};
+export declare const VirtualTableCell: React.NamedExoticComponent<VirtualTableCellProps<any>>;
+export {};

package/src/components/VirtualTable/VirtualTableHeader.d.ts

@@ -0,0 +1,27 @@
+import React, { RefObject } from "react";
+import { VirtualTableColumn, VirtualTableSort, VirtualTableWhereFilterOp } from "./VirtualTableProps";
+export type FilterFormFieldProps<CustomProps> = {
+    id: React.Key;
+    filterValue: [VirtualTableWhereFilterOp, any] | undefined;
+    setFilterValue: (filterValue?: [VirtualTableWhereFilterOp, any]) => void;
+    column: VirtualTableColumn<CustomProps>;
+    hidden: boolean;
+    setHidden: (hidden: boolean) => void;
+};
+type VirtualTableHeaderProps<M extends Record<string, any>> = {
+    resizeHandleRef: RefObject<HTMLDivElement>;
+    columnIndex: number;
+    isResizingIndex: number;
+    column: VirtualTableColumn<any>;
+    onColumnSort: (key: Extract<keyof M, string>) => void;
+    filter?: [VirtualTableWhereFilterOp, any];
+    sort: VirtualTableSort;
+    onFilterUpdate: (column: VirtualTableColumn, filterForProperty?: [VirtualTableWhereFilterOp, any]) => void;
+    onClickResizeColumn?: (columnIndex: number, column: VirtualTableColumn) => void;
+    createFilterField?: (props: FilterFormFieldProps<any>) => React.ReactNode;
+    AdditionalHeaderWidget?: (props: {
+        onHover: boolean;
+    }) => React.ReactNode;
+};
+export declare const VirtualTableHeader: React.FunctionComponent<VirtualTableHeaderProps<any>>;
+export {};

package/src/components/VirtualTable/VirtualTableHeaderRow.d.ts

@@ -0,0 +1,2 @@
+import { VirtualTableContextProps } from "./types";
+export declare const VirtualTableHeaderRow: ({ columns, currentSort, onColumnSort, onFilterUpdate, sortByProperty, filter, onColumnResize, onColumnResizeEnd, createFilterField, AddColumnComponent }: VirtualTableContextProps<any>) => import("react/jsx-runtime").JSX.Element;

package/src/components/VirtualTable/VirtualTableProps.d.ts

@@ -0,0 +1,215 @@
+import React from "react";
+import { WhereFilterOp } from "../../types";
+import { FilterFormFieldProps } from "./VirtualTableHeader";
+export type OnRowClickParams<T extends Record<string, any>> = {
+    rowData: T;
+    rowIndex: number;
+    event: React.SyntheticEvent;
+};
+/**
+ * @see Table
+ * @group Components
+ */
+export interface VirtualTableProps<T extends Record<string, any>> {
+    /**
+     * Array of arbitrary data
+     */
+    data?: T[];
+    /**
+     * Properties displayed in this collection. If this property is not set
+     * every property is displayed, you can filter
+     */
+    columns: VirtualTableColumn[];
+    /**
+     * Custom cell renderer
+     * The renderer receives props `{ cellData, columns, column, columnIndex, rowData, rowIndex, container, isScrolling }`
+     */
+    cellRenderer: (params: CellRendererParams<T>) => React.ReactNode;
+    /**
+     * If enabled, content is loaded in batch
+     */
+    paginationEnabled?: boolean;
+    /**
+     * Set this callback if you want to support some combinations
+     * of filter combinations only.
+     * @param filterValues
+     * @param sortBy
+     */
+    checkFilterCombination?: (filterValues: VirtualTableFilterValues<Extract<keyof T, string>>, sortBy?: [string, "asc" | "desc"]) => boolean;
+    /**
+     * A callback function when scrolling the table to near the end
+     */
+    onEndReached?: () => void;
+    /**
+     * When the pagination should be reset. E.g. the filters or sorting
+     * has been reset.
+     */
+    onResetPagination?: () => void;
+    /**
+     * Callback when a row is clicked
+     */
+    onRowClick?: (props: OnRowClickParams<T>) => void;
+    /**
+     * Callback when a column is resized
+     */
+    onColumnResize?: (params: OnVirtualTableColumnResizeParams) => void;
+    /**
+     * Size of the table
+     */
+    size?: VirtualTableSize;
+    /**
+     * In case this table should have some filters set by default
+     */
+    filter?: VirtualTableFilterValues<any>;
+    /**
+     * Callback used when filters are updated
+     * @param filter
+     */
+    onFilterUpdate?: (filter?: VirtualTableFilterValues<any> | undefined) => void;
+    /**
+     * Default sort applied to this collection
+     */
+    sortBy?: [string, "asc" | "desc"];
+    /**
+     * Callback used when sorting is updated
+     * @param sortBy
+     */
+    onSortByUpdate?: (sortBy?: [string, "asc" | "desc"]) => void;
+    /**
+     * If there is an error loading data you can pass it here, so it gets
+     * displayed instead of the content
+     */
+    error?: Error;
+    /**
+     * Message displayed when there is no data
+     */
+    emptyComponent?: React.ReactNode;
+    /**
+     * Is the table in a loading state
+     */
+    loading?: boolean;
+    /**
+     * Should apply a different style when hovering
+     */
+    hoverRow?: boolean;
+    /**
+     * Apply a custom class name to the row
+     * @param rowData
+     */
+    rowClassName?: (rowData: T) => string | undefined;
+    /**
+     * Callback to create a filter field, displayed in the header as a dropdown
+     * @param props
+     */
+    createFilterField?: (props: FilterFormFieldProps<any>) => React.ReactNode;
+    /**
+     * Class name applied to the table
+     */
+    className?: string;
+    /**
+     * Component rendered at the end of the table, after scroll
+     */
+    endAdornment?: React.ReactNode;
+    /**
+     * If adding this callback, a button to add a new column is displayed.
+     * @param column
+     */
+    AddColumnComponent?: React.ComponentType;
+}
+export type CellRendererParams<T extends any> = {
+    cellData?: any;
+    column: VirtualTableColumn;
+    columns: VirtualTableColumn[];
+    columnIndex: number;
+    rowData?: T;
+    rowIndex: number;
+    width: number;
+    isScrolling?: boolean;
+};
+/**
+ * @see Table
+ * @group Components
+ */
+export interface VirtualTableColumn<CustomProps extends any = any> {
+    /**
+     * Data key for the cell value, could be "a.b.c"
+     */
+    key: string;
+    /**
+     * The width of the column, gutter width is not included
+     */
+    width: number;
+    /**
+     * Label displayed in the header
+     */
+    title?: string;
+    /**
+     * This column is frozen to the left
+     */
+    frozen?: boolean;
+    /**
+     * How is the
+     */
+    headerAlign?: "left" | "center" | "right";
+    /**
+     * Icon displayed in the header
+     */
+    icon?: (hoverOrOpen: boolean) => React.ReactNode;
+    /**
+     *
+     */
+    filter?: boolean;
+    /**
+     * Alignment of the column cell
+     */
+    align?: "left" | "right" | "center";
+    /**
+     * Whether the column is sortable, defaults to false
+     */
+    sortable?: boolean;
+    /**
+     * Can it be resized
+     */
+    resizable?: boolean;
+    /**
+     * Custom props passed to the cell renderer
+     */
+    custom?: CustomProps;
+    /**
+     * Additional children to be rendered in the header when hovering
+     */
+    AdditionalHeaderWidget?: (props: {
+        onHover: boolean;
+    }) => React.ReactNode;
+}
+/**
+ * @see Table
+ * @group Collection components
+ */
+export type OnVirtualTableColumnResizeParams = {
+    width: number;
+    key: string;
+    column: VirtualTableColumn;
+};
+/**
+ * @see Table
+ * @group Components
+ */
+export type VirtualTableSize = "xs" | "s" | "m" | "l" | "xl";
+/**
+ * @see Table
+ * @group Components
+ */
+export type VirtualTableSort = "asc" | "desc" | undefined;
+/**
+ * @see Table
+ * @group Components
+ */
+export type VirtualTableFilterValues<Key extends string> = Partial<Record<Key, [WhereFilterOp, any]>>;
+/**
+ * Filter conditions in a `Query.where()` clause are specified using the
+ * strings '<', '<=', '==', '>=', '>', 'array-contains', 'in', 'not-in', and 'array-contains-any'.
+ * @see Table
+ * @group Models
+ */
+export type VirtualTableWhereFilterOp = "<" | "<=" | "==" | "!=" | ">=" | ">" | "array-contains" | "in" | "not-in" | "array-contains-any";

package/src/components/VirtualTable/VirtualTableRow.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import { VirtualTableRowProps } from "./types";
+export declare const VirtualTableRow: React.NamedExoticComponent<VirtualTableRowProps<any>>;

package/src/components/VirtualTable/common.d.ts

@@ -0,0 +1,2 @@
+import { VirtualTableSize } from "./VirtualTableProps";
+export declare function getRowHeight(size: VirtualTableSize): number;

package/src/components/VirtualTable/fields/VirtualTableDateField.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+export declare function VirtualTableDateField(props: {
+    name: string;
+    error: Error | undefined;
+    mode?: "date" | "date_time";
+    internalValue: Date | undefined | null;
+    updateValue: (newValue: (Date | null)) => void;
+    focused: boolean;
+    disabled: boolean;
+    onBlur?: React.FocusEventHandler<HTMLInputElement | HTMLTextAreaElement>;
+}): import("react/jsx-runtime").JSX.Element;

package/src/components/VirtualTable/fields/VirtualTableInput.d.ts

@@ -0,0 +1,8 @@
+export declare function VirtualTableInput(props: {
+    error: Error | undefined;
+    value: string;
+    multiline: boolean;
+    focused: boolean;
+    disabled: boolean;
+    updateValue: (newValue: (string | null)) => void;
+}): import("react/jsx-runtime").JSX.Element;

package/src/components/VirtualTable/fields/VirtualTableNumberInput.d.ts

@@ -0,0 +1,8 @@
+export declare function VirtualTableNumberInput(props: {
+    error: Error | undefined;
+    value: number;
+    align: "right" | "left" | "center";
+    updateValue: (newValue: (number | null)) => void;
+    focused: boolean;
+    disabled: boolean;
+}): import("react/jsx-runtime").JSX.Element;

package/src/components/VirtualTable/fields/VirtualTableSelect.d.ts

@@ -0,0 +1,15 @@
+import { EnumValueConfig } from "../../../types";
+import React from "react";
+export declare function VirtualTableSelect(props: {
+    name: string;
+    enumValues: EnumValueConfig[];
+    error: Error | undefined;
+    multiple: boolean;
+    disabled: boolean;
+    small: boolean;
+    internalValue: string | number | string[] | number[] | undefined;
+    valueType: "string" | "number";
+    updateValue: (newValue: (string | number | string[] | number[] | null)) => void;
+    focused: boolean;
+    onBlur?: React.FocusEventHandler<HTMLInputElement | HTMLTextAreaElement>;
+}): import("react/jsx-runtime").JSX.Element;

package/src/components/VirtualTable/fields/VirtualTableSwitch.d.ts

@@ -0,0 +1,7 @@
+export declare function VirtualTableSwitch(props: {
+    error: Error | undefined;
+    internalValue?: boolean;
+    focused: boolean;
+    disabled: boolean;
+    updateValue: (newValue: (boolean | null)) => void;
+}): import("react/jsx-runtime").JSX.Element;

package/src/components/VirtualTable/index.d.ts

@@ -0,0 +1,2 @@
+export { VirtualTable } from "./VirtualTable";
+export * from "./VirtualTableProps";

package/src/components/VirtualTable/types.d.ts

@@ -0,0 +1,34 @@
+import React from "react";
+import { CellRendererParams, OnRowClickParams, OnVirtualTableColumnResizeParams, VirtualTableColumn, VirtualTableFilterValues, VirtualTableSize, VirtualTableWhereFilterOp } from "./VirtualTableProps";
+import { FilterFormFieldProps } from "./VirtualTableHeader";
+export type VirtualTableRowProps<T> = {
+    style: any;
+    size: VirtualTableSize;
+    rowData: T;
+    rowIndex: number;
+    onRowClick?: (props: OnRowClickParams<any>) => void;
+    children: React.ReactNode[];
+    columns: VirtualTableColumn[];
+    hoverRow?: boolean;
+    rowClassName?: (rowData: T) => string | undefined;
+};
+export type VirtualTableContextProps<T extends any> = {
+    data?: T[];
+    size?: VirtualTableSize;
+    columns: VirtualTableColumn[];
+    cellRenderer: (params: CellRendererParams<T>) => React.ReactNode;
+    currentSort: "asc" | "desc" | undefined;
+    filter?: VirtualTableFilterValues<any>;
+    onRowClick?: (props: OnRowClickParams<any>) => void;
+    onColumnSort: (key: string) => any;
+    onColumnResize: (params: OnVirtualTableColumnResizeParams) => void;
+    onColumnResizeEnd: (params: OnVirtualTableColumnResizeParams) => void;
+    onFilterUpdate: (column: VirtualTableColumn, filterForProperty?: [VirtualTableWhereFilterOp, any]) => void;
+    sortByProperty?: string;
+    customView?: React.ReactNode;
+    hoverRow: boolean;
+    createFilterField?: (props: FilterFormFieldProps<any>) => React.ReactNode;
+    rowClassName?: (rowData: T) => string | undefined;
+    endAdornment?: React.ReactNode;
+    AddColumnComponent?: React.ComponentType;
+};