@pdg/react-table 1.1.13 → 1.2.0

package/README.md

@@ -7,7 +7,18 @@ Typescript React Table Module
 npm install -D @pdg/react-table
 ```
 
-### simplebar-react css 추가
+### 추가 패키지 설치
 ```
-import 'simplebar-react/dist/simplebar.min.css';
+npm install -D @dnd-kit/core @dnd-kit/sortable @emotion/react @emotion/styled @mui/icons-material @mui/material @mui/x-date-pickers @pdg/react-component @pdg/react-form dayjs simplebar-react
 ```
+
+## simplebar-react css 추가
+- javascript/typescript 에 추가 시
+  ```javascript
+  import 'simplebar-react/dist/simplebar.min.css';
+  ```
+
+- css/scss 에 추가 시
+  ```css
+  @import 'simplebar-react/dist/simplebar.min.css';
+  ```

package/dist/PInfoTable/PInfoTable.d.ts

@@ -1,7 +1,4 @@
 import React from 'react';
 import { PInfoTableProps as Props, PInfoTableInfo } from './PInfoTable.types';
-interface WithType<T = PInfoTableInfo> extends React.FC<Props<T>> {
-    <T = PInfoTableInfo>(props: Props<T>): ReturnType<React.FC<Props<T>>>;
-}
-declare const PInfoTable: WithType;
+declare function PInfoTable<T extends PInfoTableInfo = PInfoTableInfo>({ cols, spacing, columnSpacing, rowSpacing, className, style, sx, labelClassName, labelColor, labelStyle, labelSx, dividerColor, valueClassName, valueStyle, valueSx, ellipsis, valueUnderline, info, items, onCopyToClipboard, }: Props<T>): React.JSX.Element;
 export default PInfoTable;

package/dist/PInfoTable/PInfoTable.types.d.ts

@@ -6,7 +6,7 @@ export interface PInfoTableInfo {
     [key: string]: any;
 }
 export type PInfoTableItemType = 'text' | 'number' | 'tel' | 'url' | 'email' | 'date' | 'datetime' | 'date-hour' | 'date-minute' | 'business_no' | 'personal_no' | 'divider';
-export interface PInfoTableItem<T = PInfoTableInfo> {
+export interface PInfoTableItem<T extends PInfoTableInfo = PInfoTableInfo> {
     icon?: PIconProps['children'];
     label?: ReactNode;
     name?: keyof T;
@@ -46,9 +46,9 @@ export interface PInfoTableItem<T = PInfoTableInfo> {
     onLg?: (info: T) => number;
     onXl?: (info: T) => number;
 }
-export type PInfoTableItems<T = PInfoTableInfo> = (PInfoTableItem<T> | false | undefined | null)[];
+export type PInfoTableItems<T extends PInfoTableInfo = PInfoTableInfo> = (PInfoTableItem<T> | false | undefined | null)[];
 export type PInfoTableCols = 1 | 2 | 3 | 4 | 6 | 12;
-export interface PInfoTableProps<T = PInfoTableInfo> {
+export interface PInfoTableProps<T extends PInfoTableInfo = PInfoTableInfo> {
     cols: PInfoTableCols | {
         xs?: PInfoTableCols;
         sm?: PInfoTableCols;

package/dist/PSearchTable/PSearchTable.d.ts

@@ -1,8 +1,5 @@
 import React from 'react';
-import { PSearchTableProps, PSearchTableCommands } from './PSearchTable.types';
+import { PSearchTableProps as Props } from './PSearchTable.types';
 import { PTableItem } from '../PTable';
-interface WithForwardRefType<T = PTableItem> extends React.FC<PSearchTableProps<T>> {
-    <T = PTableItem>(props: PSearchTableProps<T> & React.RefAttributes<PSearchTableCommands<T>>): ReturnType<React.FC<PSearchTableProps<T>>>;
-}
-declare const PSearchTable: WithForwardRefType;
+declare function PSearchTable<T extends PTableItem = PTableItem>({ ref, className, style: initStyle, sx, color, hash, stickyHeader, fullHeight, search, table, betweenSearchTableComponent, onGetData, onRequestHashChange, }: Props<T>): React.JSX.Element;
 export default PSearchTable;

package/dist/PSearchTable/PSearchTable.types.d.ts

@@ -8,22 +8,23 @@ export interface PSearchTableSearchInfo {
     searchGroups?: PSearchTableSearchProps['searchGroups'];
     props?: Omit<PSearchTableSearchProps, 'ref' | 'searchGroups'>;
 }
-export interface PSearchTableTableInfo {
-    ref?: PSearchTableTableProps['ref'];
-    props?: Omit<PSearchTableTableProps, 'ref'>;
+export interface PSearchTableTableInfo<T extends PTableItem = PTableItem> {
+    ref?: PSearchTableTableProps<T>['ref'];
+    props?: Omit<PSearchTableTableProps<T>, 'ref'>;
 }
-export interface PSearchTableData<T = PTableItem> {
+export interface PSearchTableData<T extends PTableItem = PTableItem> {
     items: PTableProps<T>['items'];
     paging?: PTableProps<T>['paging'];
 }
 export interface PSearchTableSearchProps extends Omit<PSearchProps, 'ref' | 'color' | 'autoSubmit' | 'onSubmit'> {
-    ref?: React.ForwardedRef<PSearchCommands>;
+    ref?: React.Ref<PSearchCommands>;
     searchGroups?: ReactNode;
 }
-export interface PSearchTableTableProps<T = PTableItem> extends Omit<PTableProps<T>, 'ref' | 'items' | 'paging' | 'onPageChange'> {
-    ref?: React.ForwardedRef<PTableCommands<T>>;
+export interface PSearchTableTableProps<T extends PTableItem = PTableItem> extends Omit<PTableProps<T>, 'ref' | 'items' | 'paging' | 'onPageChange'> {
+    ref?: React.Ref<PTableCommands<T>>;
 }
-export interface PSearchTableProps<T = PTableItem> extends PTableCommonSxProps {
+export interface PSearchTableProps<T extends PTableItem = PTableItem> extends PTableCommonSxProps {
+    ref?: React.Ref<PSearchTableCommands<T>>;
     color?: PSearchProps['color'];
     hash?: boolean;
     stickyHeader?: boolean;
@@ -34,7 +35,7 @@ export interface PSearchTableProps<T = PTableItem> extends PTableCommonSxProps {
     onGetData?(data: PFormValueMap): Promise<PSearchTableData<T>>;
     onRequestHashChange?: (hash: string) => void;
 }
-export interface PSearchTableCommands<T = PTableItem> {
+export interface PSearchTableCommands<T extends PTableItem = PTableItem> {
     reload: (page?: number) => void;
     getLastLoadData: () => PFormValueMap;
     getSearch: () => PSearchCommands | undefined;

package/dist/PTable/PTable.d.ts

@@ -1,7 +1,4 @@
 import React from 'react';
-import { PTableProps, PTableCommands, PTableItem } from './PTable.types';
-interface WithForwardRefType<T = PTableItem> extends React.FC<PTableProps<T>> {
-    <T = PTableItem>(props: PTableProps<T> & React.RefAttributes<PTableCommands<T>>): ReturnType<React.FC<PTableProps<T>>>;
-}
-declare const PTable: WithForwardRefType;
+import { PTableProps as Props, PTableItem } from './PTable.types';
+declare function PTable<T extends PTableItem = PTableItem>({ ref, className, style: initStyle, sx, caption, topHeadRows, columns: initColumns, items: initItems, paging: initPaging, pagingAlign, defaultAlign, defaultEllipsis, stickyHeader: initStickyHeader, height, minHeight, maxHeight, fullHeight, showOddColor, showEvenColor, cellPadding, footer, noData, pagination, sortable, progressiveVisible, onClick, onGetBodyRowClassName, onGetBodyRowStyle, onGetBodyRowSx, onGetBodyColumnClassName, onGetBodyColumnStyle, onGetBodyColumnSx, onPageChange, onSortChange, onCheckChange, }: Props<T>): React.JSX.Element | null;
 export default PTable;

package/dist/PTable/PTable.types.d.ts

@@ -1,6 +1,6 @@
-import { CSSProperties, ReactNode } from 'react';
+import React, { CSSProperties, ReactNode } from 'react';
 import { TableCellProps, TooltipProps } from '@mui/material';
-import { PTablePaginationProps } from '../PTablePagination/PTablePagination.types';
+import { PTablePaginationProps } from '../PTablePagination';
 import { PTableCommonSxProps } from '../@types';
 import { PTableTopHeadProps } from '../PTableTopHead';
 /********************************************************************************************************************
@@ -20,7 +20,7 @@ export interface PTableProgressiveVisibleInfo {
 /********************************************************************************************************************
  * PTableColumn
  * ******************************************************************************************************************/
-export interface PTableColumn<T = PTableItem> {
+export interface PTableColumn<T extends PTableItem = PTableItem> {
     id?: string;
     type?: 'text' | 'number' | 'tel' | 'date' | 'datetime' | 'date-hour' | 'date-minute' | 'business_no' | 'personal_no' | 'img' | 'button' | 'buttons' | 'check';
     label?: ReactNode;
@@ -81,13 +81,14 @@ export interface PTableColumn<T = PTableItem> {
     onCheckChange?: (item: T, checked: boolean) => void;
     onCheckDisabledChange?: (item: T, checkDisabled: boolean) => void;
 }
-export type PTableColumns<T = PTableItem> = (PTableColumn<T> | false | undefined | null)[];
+export type PTableColumns<T extends PTableItem = PTableItem> = (PTableColumn<T> | false | undefined | null)[];
 /********************************************************************************************************************
  * TableProps
  * ******************************************************************************************************************/
-export interface PTableProps<T = PTableItem> extends PTableCommonSxProps {
+export interface PTableProps<T extends PTableItem = PTableItem> extends PTableCommonSxProps {
+    ref?: React.Ref<PTableCommands<T>>;
     caption?: ReactNode;
-    topHeadRows?: PTableTopHeadProps['rows'];
+    topHeadRows?: PTableTopHeadProps<T>['rows'];
     columns?: PTableColumns<T>;
     defaultAlign?: TableCellProps['align'];
     defaultEllipsis?: boolean;
@@ -125,7 +126,7 @@ export interface PTableProps<T = PTableItem> extends PTableCommonSxProps {
 /********************************************************************************************************************
  * PTableCommands
  * ******************************************************************************************************************/
-export interface PTableCommands<T = PTableItem> {
+export interface PTableCommands<T extends PTableItem = PTableItem> {
     getColumns: () => PTableProps<T>['columns'];
     setColumns: (columns: PTableProps<T>['columns']) => void;
     getItems: () => PTableProps<T>['items'];

package/dist/PTableBodyCell/PTableBodyCell.d.ts

@@ -1,4 +1,5 @@
 import React from 'react';
 import { PTableBodyCellProps as Props } from './PTableBodyCell.types';
-declare const PTableBodyCell: React.ForwardRefExoticComponent<Props & React.RefAttributes<HTMLTableCellElement>>;
+import { PTableItem } from '../PTable/PTable.types';
+declare function PTableBodyCell<T extends PTableItem = PTableItem>({ ref, className, style, sx, item, index, column, defaultAlign, defaultEllipsis, onClick, onCheckChange, }: Props<T>): React.JSX.Element;
 export default PTableBodyCell;

package/dist/PTableBodyCell/PTableBodyCell.types.d.ts

@@ -1,18 +1,20 @@
-import { PTableColumn, PTableItem, PTableProps } from '../PTable/PTable.types';
+import { PTableColumn, PTableItem, PTableProps } from '../PTable';
 import { PTableCommonSxProps } from '../@types';
+import React from 'react';
 export interface PTableBodyCellCommands {
     setChecked: (checked: boolean) => void;
     setCheckDisabled: (disabled: boolean) => void;
 }
-export interface PTableBodyCellProps {
+export interface PTableBodyCellProps<T extends PTableItem = PTableItem> {
+    ref?: React.Ref<HTMLTableCellElement>;
     className?: PTableCommonSxProps['className'];
     style?: PTableCommonSxProps['style'];
     sx?: PTableCommonSxProps['sx'];
     index: number;
-    item: PTableItem;
-    column: PTableColumn;
-    defaultAlign?: PTableProps['defaultAlign'];
+    item: T;
+    column: PTableColumn<T>;
+    defaultAlign?: PTableProps<T>['defaultAlign'];
     defaultEllipsis?: boolean;
-    onClick: PTableProps['onClick'];
-    onCheckChange: (item: PTableItem, column: PTableColumn, checked: boolean) => void;
+    onClick: PTableProps<T>['onClick'];
+    onCheckChange: (item: T, column: PTableColumn<T>, checked: boolean) => void;
 }

package/dist/PTableBodyRow/PTableBodyRow.d.ts

@@ -1,5 +1,6 @@
 import React from 'react';
 import { PTableBodyRowProps as Props } from './PTableBodyRow.types';
+import { PTableItem } from '../PTable';
 export declare const PStyledBodyRow: import("@emotion/styled").StyledComponent<import("@mui/material").TableRowOwnProps & import("@mui/material/OverridableComponent").CommonProps & Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>, "className" | "style" | "classes" | "children" | "hover" | "selected" | "sx"> & import("@mui/system").MUIStyledCommonProps<import("@mui/material").Theme>, {}, {}>;
-declare const PTableBodyRow: React.FC<Props>;
+declare function PTableBodyRow<T extends PTableItem = PTableItem>({ className, style, id, index, defaultAlign, defaultEllipsis, sortable, columns, item, onClick, onCheckChange, onGetColumnClassName, onGetColumnStyle, onGetColumnSx, ...props }: Props<T>): React.JSX.Element;
 export default PTableBodyRow;

package/dist/PTableBodyRow/PTableBodyRow.types.d.ts

@@ -2,17 +2,17 @@ import { TableCellProps, TableRowProps } from '@mui/material';
 import { PTableColumn, PTableItem, PTableProps } from '../PTable';
 import { PTableBodyCellProps } from '../PTableBodyCell';
 import { PTableCommonSxProps } from '../@types';
-export interface PTableBodyRowProps extends Omit<TableRowProps, 'id' | 'onClick'> {
+export interface PTableBodyRowProps<T extends PTableItem = PTableItem> extends Omit<TableRowProps, 'id' | 'onClick'> {
     id: string | number;
     index: number;
     defaultAlign?: TableCellProps['align'];
     defaultEllipsis?: boolean;
     sortable?: boolean;
-    columns: PTableColumn[];
-    item: PTableItem;
-    onClick: PTableProps['onClick'];
-    onCheckChange: PTableBodyCellProps['onCheckChange'];
-    onGetColumnClassName?: (column: PTableColumn, item: PTableItem, index: number) => PTableCommonSxProps['className'] | undefined;
-    onGetColumnStyle?: (column: PTableColumn, item: PTableItem, index: number) => PTableCommonSxProps['style'] | undefined;
-    onGetColumnSx?: (column: PTableColumn, item: PTableItem, index: number) => PTableCommonSxProps['sx'] | undefined;
+    columns: PTableColumn<T>[];
+    item: T;
+    onClick: PTableProps<T>['onClick'];
+    onCheckChange: PTableBodyCellProps<T>['onCheckChange'];
+    onGetColumnClassName?: (column: PTableColumn<T>, item: T, index: number) => PTableCommonSxProps['className'] | undefined;
+    onGetColumnStyle?: (column: PTableColumn<T>, item: T, index: number) => PTableCommonSxProps['style'] | undefined;
+    onGetColumnSx?: (column: PTableColumn<T>, item: T, index: number) => PTableCommonSxProps['sx'] | undefined;
 }

package/dist/PTableButton/PTableButton.d.ts

@@ -1,4 +1,4 @@
 import React from 'react';
 import { PTableButtonProps as Props } from './PTableButton.types';
-declare const _default: React.NamedExoticComponent<Props & React.RefAttributes<HTMLButtonElement>>;
+declare const _default: React.MemoExoticComponent<({ children, className, sx: initSx, variant, color, startIcon, endIcon, onClick, ...props }: Props) => React.JSX.Element>;
 export default _default;

package/dist/PTableCommonCell/PTableCommonCell.d.ts

@@ -1,4 +1,5 @@
 import React from 'react';
-import { PTableCommonCellProps } from './PTableCommonCell.types';
-declare const PTableCommonCell: React.ForwardRefExoticComponent<PTableCommonCellProps & React.RefAttributes<HTMLTableCellElement>>;
+import { PTableCommonCellProps as Props } from './PTableCommonCell.types';
+import { PTableItem } from '../PTable';
+declare function PTableCommonCell<T extends PTableItem = PTableItem>({ ref, children, className: initClassName, style: initStyle, sx: initSx, type, column, defaultAlign, defaultEllipsis: initDefaultEllipsis, index, item, onClick, }: Props<T>): React.JSX.Element;
 export default PTableCommonCell;

package/dist/PTableCommonCell/PTableCommonCell.types.d.ts

@@ -1,11 +1,11 @@
+import React from 'react';
 import { PTableColumn, PTableItem, PTableProps } from '../PTable/PTable.types';
 import { PTableCommonSxProps } from '../@types';
-export interface PTableCommonCellProps extends PTableCommonSxProps {
+export interface PTableCommonCellProps<T extends PTableItem = PTableItem> extends PTableCommonSxProps, Pick<PTableProps<T>, 'defaultAlign' | 'onClick'> {
+    ref?: React.Ref<HTMLTableCellElement>;
     type: 'head' | 'body' | 'footer';
-    column: PTableColumn;
-    defaultAlign?: PTableProps['defaultAlign'];
+    column: PTableColumn<T>;
     defaultEllipsis?: boolean;
     index?: number;
-    item?: PTableItem;
-    onClick?: PTableProps['onClick'];
+    item?: T;
 }

package/dist/PTableContext/PTableContext.d.ts

@@ -1,3 +1,3 @@
 import { PTableContextValue } from './PTableContext.types';
-declare const PTableContext: import("react").Context<PTableContextValue>;
+declare const PTableContext: import("react").Context<PTableContextValue<import("..").PTableItem>>;
 export default PTableContext;

package/dist/PTableContext/PTableContext.types.d.ts

@@ -1,14 +1,14 @@
 import { PTableColumn, PTableItem, PTableProgressiveVisibleInfo } from '../PTable';
 import { PTableBodyCellCommands } from '../PTableBodyCell';
 import { PTableHeadCellCommands } from '../PTableHeadCell';
-export interface PTableContextValue {
+export interface PTableContextValue<T extends PTableItem = PTableItem> {
     menuOpen: boolean;
     openMenuId?: string;
     progressiveVisible?: PTableProgressiveVisibleInfo;
     setMenuOpen: (menuOpen: boolean, openMenuId?: string) => void;
-    setItemColumnChecked: (item: PTableItem, column: PTableColumn, checked: boolean) => void;
-    setItemColumnCheckDisabled: (item: PTableItem, column: PTableColumn, checkDisabled: boolean) => void;
-    setItemColumnCommands: (item: PTableItem, column: PTableColumn, commands: PTableBodyCellCommands) => void;
-    setHeadColumnChecked: (column: PTableColumn, checked: boolean) => void;
-    setHeadColumnCommands: (column: PTableColumn, commands: PTableHeadCellCommands) => void;
+    setItemColumnChecked: (item: T, column: PTableColumn<T>, checked: boolean) => void;
+    setItemColumnCheckDisabled: (item: T, column: PTableColumn<T>, checkDisabled: boolean) => void;
+    setItemColumnCommands: (item: T, column: PTableColumn<T>, commands: PTableBodyCellCommands) => void;
+    setHeadColumnChecked: (column: PTableColumn<T>, checked: boolean) => void;
+    setHeadColumnCommands: (column: PTableColumn<T>, commands: PTableHeadCellCommands) => void;
 }

package/dist/PTableContext/useTableState.d.ts

@@ -1,2 +1,3 @@
 import { PTableContextValue } from './PTableContext.types';
-export default function useTableState(): PTableContextValue;
+import { PTableItem } from '../PTable';
+export default function useTableState<T extends PTableItem = PTableItem>(): PTableContextValue<T>;

package/dist/PTableContextProvider/PTableContextProvider.d.ts

@@ -1,4 +1,5 @@
 import React from 'react';
 import { PTableContextProviderProps as Props } from './PTableContextProvider.types';
-declare const PTableContextProvider: React.FC<Props>;
+import { PTableItem } from '../PTable';
+declare function PTableContextProvider<T extends PTableItem = PTableItem>({ children, value }: Props<T>): React.JSX.Element;
 export default PTableContextProvider;

package/dist/PTableContextProvider/PTableContextProvider.types.d.ts

@@ -1,6 +1,7 @@
 import { ReactNode } from 'react';
 import { PTableContextValue } from '../PTableContext';
-export interface PTableContextProviderProps {
-    value: PTableContextValue;
+import { PTableItem } from '../PTable';
+export interface PTableContextProviderProps<T extends PTableItem = PTableItem> {
+    value: PTableContextValue<T>;
     children: ReactNode;
 }

package/dist/PTableFooterCell/PTableFooterCell.d.ts

@@ -1,4 +1,5 @@
 import React from 'react';
-import { PTableFooterCellProps } from './PTableFooterCell.types';
-declare const PTableFooterCell: React.FC<PTableFooterCellProps>;
+import { PTableFooterCellProps as Props } from './PTableFooterCell.types';
+import { PTableItem } from '../PTable';
+declare function PTableFooterCell<T extends PTableItem = PTableItem>({ column, items, defaultAlign }: Props<T>): React.JSX.Element;
 export default PTableFooterCell;

package/dist/PTableFooterCell/PTableFooterCell.types.d.ts

@@ -1,6 +1,6 @@
 import { PTableColumn, PTableItem, PTableProps } from '../PTable/PTable.types';
-export interface PTableFooterCellProps<T = PTableItem> {
-    column: PTableColumn;
+export interface PTableFooterCellProps<T extends PTableItem = PTableItem> {
+    column: PTableColumn<T>;
     items?: T[];
-    defaultAlign?: PTableProps['defaultAlign'];
+    defaultAlign?: PTableProps<T>['defaultAlign'];
 }

package/dist/PTableHeadCell/PTableHeadCell.d.ts

@@ -1,4 +1,5 @@
 import React from 'react';
-import { PTableHeadCellProps } from './PTableHeadCell.types';
-declare const PTableHeadCell: React.FC<PTableHeadCellProps>;
+import { PTableHeadCellProps as Props } from './PTableHeadCell.types';
+import { PTableItem } from '../PTable';
+declare function PTableHeadCell<T extends PTableItem = PTableItem>({ column, items, defaultAlign, top, onCheckChange, }: Props<T>): React.JSX.Element;
 export default PTableHeadCell;

package/dist/PTableHeadCell/PTableHeadCell.types.d.ts

@@ -3,10 +3,10 @@ export interface PTableHeadCellCommands {
     setChecked: (checked: boolean) => void;
     setCheckDisabled: (checkDisabled: boolean) => void;
 }
-export interface PTableHeadCellProps<T = PTableItem> {
-    column: PTableColumn;
+export interface PTableHeadCellProps<T extends PTableItem = PTableItem> {
+    column: PTableColumn<T>;
     items?: T[];
-    defaultAlign?: PTableProps['defaultAlign'];
+    defaultAlign?: PTableProps<T>['defaultAlign'];
     top?: number;
-    onCheckChange: (column: PTableColumn, checked: boolean) => void;
+    onCheckChange: (column: PTableColumn<T>, checked: boolean) => void;
 }

package/dist/PTableMenuButton/PTableMenuButton.d.ts

@@ -1,4 +1,4 @@
 import React from 'react';
 import { PTableMenuButtonProps as Props } from './PTableMenuButton.types';
-declare const PTableMenuButton: React.ForwardRefExoticComponent<Props & React.RefAttributes<HTMLButtonElement>>;
+declare const PTableMenuButton: ({ ref, children, className, sx: initSx, color, variant, startIcon, placement, inModal, zIndex, menuList, ...props }: Props) => React.JSX.Element;
 export default PTableMenuButton;

package/dist/PTablePagination/PTablePagination.d.ts

@@ -1,4 +1,4 @@
 import React from 'react';
-import { PTablePaginationProps } from './PTablePagination.types';
-declare const PTablePagination: React.FC<PTablePaginationProps>;
+import { PTablePaginationProps as Props } from './PTablePagination.types';
+declare const PTablePagination: ({ className, style, sx, paging, align, onChange }: Props) => React.JSX.Element;
 export default PTablePagination;

package/dist/PTableSortableBody/PTableSortableBody.d.ts

@@ -1,4 +1,5 @@
 import React from 'react';
 import { PTableSortableBodyProps as Props } from './PTableSortableBody.types';
-export declare const PTableSortableBody: ({ items, columns, showOddColor, showEvenColor, onGetBodyRowStyle, onGetBodyRowSx, onGetBodyRowClassName, onGetBodyColumnClassName, onGetBodyColumnStyle, onGetBodyColumnSx, defaultAlign, defaultEllipsis, sortable, onClick, onCheckChange, }: Props) => React.JSX.Element;
+import { PTableItem } from '../PTable';
+declare function PTableSortableBody<T extends PTableItem = PTableItem>({ items, columns, showOddColor, showEvenColor, onGetBodyRowStyle, onGetBodyRowSx, onGetBodyRowClassName, onGetBodyColumnClassName, onGetBodyColumnStyle, onGetBodyColumnSx, defaultAlign, defaultEllipsis, sortable, onClick, onCheckChange, }: Props<T>): React.JSX.Element;
 export default PTableSortableBody;

package/dist/PTableSortableBody/PTableSortableBody.types.d.ts

@@ -1,8 +1,8 @@
-import { PTableColumn, PTableItem, PTableProps } from '../PTable/PTable.types';
+import { PTableColumn, PTableItem, PTableProps } from '../PTable';
 import { PTableBodyRowProps } from '../PTableBodyRow';
-export interface PTableSortableBodyProps extends Pick<PTableProps, 'showOddColor' | 'showEvenColor' | 'onGetBodyRowSx' | 'onGetBodyRowClassName' | 'onGetBodyRowStyle' | 'onGetBodyColumnClassName' | 'onGetBodyColumnSx' | 'onGetBodyColumnStyle' | 'defaultAlign' | 'defaultEllipsis' | 'sortable' | 'onClick'>, Pick<PTableBodyRowProps, 'onCheckChange'> {
-    items: (PTableItem & {
+export interface PTableSortableBodyProps<T extends PTableItem = PTableItem> extends Pick<PTableProps<T>, 'showOddColor' | 'showEvenColor' | 'onGetBodyRowSx' | 'onGetBodyRowClassName' | 'onGetBodyRowStyle' | 'onGetBodyColumnClassName' | 'onGetBodyColumnSx' | 'onGetBodyColumnStyle' | 'defaultAlign' | 'defaultEllipsis' | 'sortable' | 'onClick'>, Pick<PTableBodyRowProps<T>, 'onCheckChange'> {
+    items: (T & {
         id: number | string;
     })[];
-    columns: PTableColumn[];
+    columns: PTableColumn<T>[];
 }

package/dist/PTableSortableBodyBlock/PTableSortableBodyBlock.d.ts

@@ -1,4 +1,5 @@
 import React from 'react';
 import { PTableSortableBodyBlockProps as Props } from './PTableSortableBodyBlock.types';
-export declare const PTableSortableBodyBlock: ({ items, baseIndex, columns, showOddColor, showEvenColor, onGetBodyRowStyle, onGetBodyRowSx, onGetBodyRowClassName, onGetBodyColumnClassName, onGetBodyColumnStyle, onGetBodyColumnSx, defaultAlign, defaultEllipsis, sortable, onClick, onCheckChange, }: Props) => React.JSX.Element;
+import { PTableItem } from '../PTable';
+declare function PTableSortableBodyBlock<T extends PTableItem = PTableItem>({ items, baseIndex, columns, showOddColor, showEvenColor, onGetBodyRowStyle, onGetBodyRowSx, onGetBodyRowClassName, onGetBodyColumnClassName, onGetBodyColumnStyle, onGetBodyColumnSx, defaultAlign, defaultEllipsis, sortable, onClick, onCheckChange, }: Props<T>): React.JSX.Element;
 export default PTableSortableBodyBlock;

package/dist/PTableSortableBodyBlock/PTableSortableBodyBlock.types.d.ts

@@ -1,4 +1,5 @@
-import { PTableSortableBodyProps } from '../PTableSortableBody/PTableSortableBody.types';
-export interface PTableSortableBodyBlockProps extends PTableSortableBodyProps {
+import { PTableSortableBodyProps } from '../PTableSortableBody';
+import { PTableItem } from '../PTable';
+export interface PTableSortableBodyBlockProps<T extends PTableItem = PTableItem> extends PTableSortableBodyProps<T> {
     baseIndex: number;
 }

package/dist/PTableTopHead/PTableTopHead.d.ts

@@ -1,4 +1,5 @@
 import React from 'react';
 import { PTableTopHeadProps as Props } from './PTableTopHead.types';
-declare const PTableTopHead: React.FC<Props>;
+import { PTableItem } from '../PTable';
+declare function PTableTopHead<T extends PTableItem = PTableItem>({ columns, items, rows, caption, defaultAlign, onCheckChange, }: Props<T>): React.JSX.Element;
 export default PTableTopHead;

package/dist/PTableTopHead/PTableTopHead.types.d.ts

@@ -1,6 +1,6 @@
 import { ReactNode } from 'react';
 import { TableCellProps } from '@mui/material';
-import { PTableColumn, PTableItem, PTableProps } from '../PTable/PTable.types';
+import { PTableColumn, PTableItem, PTableProps } from '../PTable';
 export interface PTableTopHeadRowColumn {
     colSpan?: number;
     rowSpan?: number;
@@ -8,11 +8,11 @@ export interface PTableTopHeadRowColumn {
     align?: TableCellProps['align'];
 }
 export type PTableTopHeadRowColumnValue = PTableTopHeadRowColumn | false | undefined | null;
-export interface PTableTopHeadProps<T = PTableItem> {
+export interface PTableTopHeadProps<T extends PTableItem = PTableItem> {
     caption?: ReactNode;
     rows?: PTableTopHeadRowColumnValue[] | PTableTopHeadRowColumnValue[][];
-    columns: PTableColumn[];
+    columns: PTableColumn<T>[];
     items?: T[];
-    defaultAlign: PTableProps['defaultAlign'];
-    onCheckChange: (column: PTableColumn, checked: boolean) => void;
+    defaultAlign: PTableProps<T>['defaultAlign'];
+    onCheckChange: (column: PTableColumn<T>, checked: boolean) => void;
 }