ados-rcm 1.0.8 → 1.0.10

package/dist/AModule/AComponents/ATable/ATable.d.ts

@@ -1,34 +1,126 @@
-import { TCBAble } from '../../AUtils/cbF';
-import { IItem } from '../../AUtils/objF';
-import { TIdx } from '../ATypes/ATypes';
+/**
+ * ATable
+ *
+ * Notice 1 : Defs Explanation
+ * - Keys of defs are used as each columns.
+ * - defaultDef is used as default for each columns, and will not be rendered.
+ * - def is calculated as {...defaultDef, ...def}.
+ *
+ * Notice 2 : Select and Check
+ * - Select and Check are different. not like ATree. careful.
+ *
+ * Notice 3 : entireItems and pagedItems
+ * - pagedItems is the items to be rendered.
+ * - pagedItems can be provided directly, or it can be calculated from entireItems.
+ * - entireItems is the entire items, and will be filtered, sorted, and paged to become the pagedItems.
+ *
+ *
+ * Todo 1 : Defs is declared as type. it would be better to declare as interface, but I couldn't find the way.
+ *
+ */
 import React from 'react';
 import { TUseValues } from '../../AHooks/useValues';
+import { TCanCallback } from '../../AUtils/cbF';
+import { IItem } from '../../AUtils/objF';
 import { Resources } from '../AResource/AResource';
+import { TIdx } from '../ATypes/ATypes';
 export interface IATableTHProps<T extends IItem> {
+    /**
+     * defKey : TIdx
+     * <br/>Description : defKey of the given defs
+     */
     defKey: TIdx;
+    /**
+     * def : IATableDef<T>
+     * <br/>Description : def of the given defs
+     */
     def: IATableDef<T>;
 }
 export interface IATableTRProps<T extends IItem> {
+    /**
+     * item : T
+     * <br/>Description : item of the given items
+     */
     item: T;
 }
 export interface IATableTDProps<T extends IItem> extends IATableTHProps<T>, IATableTRProps<T> {
 }
 export interface IATableDef<T extends IItem> {
-    width?: TCBAble<IATableTHProps<T>, number>;
-    maxWidth?: TCBAble<IATableTHProps<T>, number>;
-    minWidth?: TCBAble<IATableTHProps<T>, number>;
-    align?: TCBAble<IATableTHProps<T>, React.CSSProperties['justifyContent']>;
-    colSpan?: TCBAble<IATableTHProps<T>, number>;
-    hContent?: TCBAble<IATableTHProps<T>, React.ReactNode>;
-    hColor?: TCBAble<IATableTHProps<T>, React.CSSProperties['color']>;
-    hBackgroundColor?: TCBAble<IATableTHProps<T>, React.CSSProperties['backgroundColor']>;
+    /**
+     * width? : TCanCallback<IATableTHProps<T>, number>
+     * <br/>Description : width of the column
+     */
+    width?: TCanCallback<IATableTHProps<T>, number>;
+    /**
+     * maxWidth? : TCanCallback<IATableTHProps<T>, number>
+     * <br/>Description : maxWidth of the column
+     */
+    maxWidth?: TCanCallback<IATableTHProps<T>, number>;
+    /**
+     * minWidth? : TCanCallback<IATableTHProps<T>, number>
+     * <br/>Description : minWidth of the column
+     */
+    minWidth?: TCanCallback<IATableTHProps<T>, number>;
+    /**
+     * align? : TCanCallback<IATableTHProps<T>, React.CSSProperties['justifyContent']>
+     * <br/>Description : align of the column. type of justifyContent
+     */
+    align?: TCanCallback<IATableTHProps<T>, React.CSSProperties['justifyContent']>;
+    /**
+     * colSpan? : TCanCallback<IATableTHProps<T>, number>
+     * <br/>Description : colSpan of the column. headers will be not affected and td will overlap.
+     */
+    colSpan?: TCanCallback<IATableTHProps<T>, number>;
+    /**
+     * hContent? : TCanCallback<IATableTHProps<T>, React.ReactNode>
+     * <br/>Description : content of the th
+     */
+    hContent?: TCanCallback<IATableTHProps<T>, React.ReactNode>;
+    /**
+     * hColor? : TCanCallback<IATableTHProps<T>, React.CSSProperties['color']>
+     * <br/>Description : color of the th
+     */
+    hColor?: TCanCallback<IATableTHProps<T>, React.CSSProperties['color']>;
+    /**
+     * hBackgroundColor? : TCanCallback<IATableTHProps<T>, React.CSSProperties['backgroundColor']>
+     * <br/>Description : backgroundColor of the th
+     */
+    hBackgroundColor?: TCanCallback<IATableTHProps<T>, React.CSSProperties['backgroundColor']>;
+    /**
+     * isSortable? : boolean
+     * <br/>Description : decides whether the column is sortable or not
+     */
     isSortable?: boolean;
+    /**
+     * noResize? : boolean
+     * <br/>Description : decides whether the column is resizable or not
+     */
     noResize?: boolean;
+    /**
+     * sortF? : (a: T, b: T) => number
+     * <br/>Description : sortF of the column
+     */
     sortF?: (a: T, b: T) => number;
-    content?: TCBAble<IATableTDProps<T>, React.ReactNode>;
-    asText?: TCBAble<IATableTDProps<T>, string | number>;
-    color?: TCBAble<IATableTDProps<T>, React.CSSProperties['color']>;
-    backgroundColor?: TCBAble<IATableTDProps<T>, React.CSSProperties['backgroundColor']>;
+    /**
+     * content? : TCanCallback<IATableTDProps<T>, React.ReactNode>
+     * <br/>Description : content of the td
+     */
+    content?: TCanCallback<IATableTDProps<T>, React.ReactNode>;
+    /**
+     * asText? : TCanCallback<IATableTDProps<T>, string | number>
+     * <br/>Description : for filteration. complicated contents can be filtered using asText.
+     */
+    asText?: TCanCallback<IATableTDProps<T>, string | number>;
+    /**
+     * color? : TCanCallback<IATableTDProps<T>, React.CSSProperties['color']>
+     * <br/>Description : color of the td
+     */
+    color?: TCanCallback<IATableTDProps<T>, React.CSSProperties['color']>;
+    /**
+     * backgroundColor? : TCanCallback<IATableTDProps<T>, React.CSSProperties['backgroundColor']>
+     * <br/>Description : backgroundColor of the td
+     */
+    backgroundColor?: TCanCallback<IATableTDProps<T>, React.CSSProperties['backgroundColor']>;
 }
 export type TATableDefs<T extends IItem> = {
     [key in Exclude<keyof T, symbol>]?: IATableDef<T>;
@@ -38,118 +130,553 @@ export type TATableDefs<T extends IItem> = {
 export type TATableFilterType = 'String' | 'Select' | 'Date' | 'DateRange';
 export interface IATableFilterDef<T extends IItem> {
     String: {
+        /**
+         * type : 'String'
+         * <br/>Description : type of the String filter Def
+         */
         type: 'String';
+        /**
+         * defKey? : keyof T | ''
+         * <br/>Description : defKey of the String filter Def
+         */
         defKey?: keyof T | '';
+        /**
+         * predicate? : (item: T, defs: TATableDefs<T>, filter: IATableFilter<T>['String']) => any
+         * <br/>Description : predicate of the String filter Def. if not provided, it will have default predicate.
+         */
         predicate?: (item: T, defs: TATableDefs<T>, filter: IATableFilter<T>['String']) => any;
+        /**
+         * placeholder? : string
+         * <br/>Description : placeholder of the String filter Def
+         */
         placeholder?: string;
     };
     Select: {
+        /**
+         * type : 'Select'
+         * <br/>Description : type of the Select filter Def
+         */
         type: 'Select';
+        /**
+         * defKey? : keyof T | ''
+         * <br/>Description : defKey of the Select filter Def
+         */
         defKey?: keyof T | '';
+        /**
+         * options : (string | number)[]
+         * <br/>Description : options of the Select filter Def
+         */
         options: (string | number)[];
-        placeHolder?: string;
+        /**
+         * placeholder : (string | number)[]
+         * <br/>Description : values of the Select filter Def
+         */
+        placeholder?: string;
+        /**
+         * OptionRenderer? : (option: string | number) => React.ReactNode
+         * <br/>Description : OptionRenderer of the Select filter Def
+         */
         OptionRenderer?: (option: string | number) => React.ReactNode;
+        /**
+         * predicate? : (item: T, defs: TATableDefs<T>, filter: IATableFilter<T>['Select']) => any
+         * <br/>Description : predicate of the Select filter Def. if not provided, it will have default predicate.
+         */
         predicate?: (item: T, defs: TATableDefs<T>, filter: IATableFilter<T>['Select']) => any;
     };
     Date: {
+        /**
+         * type : 'Date'
+         * <br/>Description : type of the Date filter Def
+         */
         type: 'Date';
+        /**
+         * defKey? : keyof T | ''
+         * <br/>Description : defKey of the Date filter Def
+         */
         defKey?: keyof T | '';
+        /**
+         * minDate? : Date
+         * <br/>Description : minDate of the Date filter Def
+         */
         minDate?: Date;
+        /**
+         * maxDate? : Date
+         * <br/>Description : maxDate of the Date filter Def
+         */
         maxDate?: Date;
+        /**
+         * predicate? : (item: T, defs: TATableDefs<T>, filter: IATableFilter<T>['Date']) => any
+         * <br/>Description : predicate of the Date filter Def. if not provided, it will have default predicate.
+         */
         predicate?: (item: T, defs: TATableDefs<T>, filter: IATableFilter<T>['Date']) => any;
     };
     DateRange: {
+        /**
+         * type : 'DateRange'
+         * <br/>Description : type of the DateRange filter Def
+         */
         type: 'DateRange';
+        /**
+         * defKey? : keyof T | ''
+         * <br/>Description : defKey of the DateRange filter Def
+         */
         defKey?: keyof T | '';
+        /**
+         * minDate? : Date
+         * <br/>Description : minDate of the DateRange filter Def
+         */
         minDate?: Date;
+        /**
+         * maxDate? : Date
+         * <br/>Description : maxDate of the DateRange filter Def
+         */
         maxDate?: Date;
+        /**
+         * predicate? : (item: T, defs: TATableDefs<T>, filter: IATableFilter<T>['DateRange']) => any
+         * <br/>Description : predicate of the DateRange filter Def. if not provided, it will have default predicate.
+         */
         predicate?: (item: T, defs: TATableDefs<T>, filter: IATableFilter<T>['DateRange']) => any;
     };
 }
+export type TATableSomeFilterDef<T extends IItem> = IATableFilterDef<T>[TATableFilterType];
 export type TATableFilterationDefs<T extends IItem> = {
+    /**
+     * type : 'And' | 'Or'
+     * <br/>Description : type of the filteration Defs
+     */
     type: 'And' | 'Or';
-    defs: IATableFilterDef<T>[TATableFilterType][];
+    /**
+     * defs : TATableSomeFilterDef<T>[]
+     * <br/>Description : defs of the filteration Defs
+     */
+    defs: TATableSomeFilterDef<T>[];
 };
 export interface IATableFilter<T extends IItem> {
     String: {
+        /**
+         * type : 'String'
+         * <br/>Description : type of the String filter
+         */
         type: 'String';
+        /**
+         * defKey? : keyof T | ''
+         * <br/>Description : defKey of the String filter
+         */
         defKey: keyof T | '';
+        /**
+         * value : string
+         * <br/>Description : value of the String filter
+         */
         value: string;
+        /**
+         * predicate? : (item: T, defs: TATableDefs<T>, filter: IATableFilter<T>['String']) => any
+         * <br/>Description : predicate of the String filter
+         */
         predicate?: (item: T, defs: TATableDefs<T>, filter: IATableFilter<T>['String']) => any;
+        /**
+         * placeholder? : string
+         * <br/>Description : placeholder of the String filter
+         */
         placeholder?: string;
     };
     Select: {
+        /**
+         * type : 'Select'
+         * <br/>Description : type of the Select filter
+         */
         type: 'Select';
+        /**
+         * defKey : keyof T | ''
+         * <br/>Description : defKey of the Select filter
+         */
         defKey: keyof T | '';
+        /**
+         * values : (string | number)[]
+         * <br/>Description : values of the Select filter
+         */
         values: (string | number)[];
+        /**
+         * options : (string | number)[]
+         * <br/>Description : options of the Select filter
+         */
         options: (string | number)[];
+        /**
+         * placeholder : string
+         * <br/>Description : placeholder of the Select filter
+         */
         placeholder?: string;
+        /**
+         * OptionRenderer? : (option: string | number) => React.ReactNode
+         * <br/>Description : OptionRenderer of the Select filter
+         */
         OptionRenderer?: (option: string | number) => React.ReactNode;
+        /**
+         * predicate? : (item: T, defs: TATableDefs<T>, filter: IATableFilter<T>['Select']) => any
+         * <br/>Description : predicate of the Select filter. if not provided, it will have default predicate.
+         */
         predicate?: (item: T, defs: TATableDefs<T>, filter: IATableFilter<T>['Select']) => any;
     };
     Date: {
+        /**
+         * type : 'Date'
+         * <br/>Description : type of the Date filter
+         */
         type: 'Date';
+        /**
+         * defKey : keyof T | ''
+         * <br/>Description : defKey of the Date filter
+         */
         defKey: keyof T;
+        /**
+         * value : Date
+         * <br/>Description : value of the Date filter
+         */
         value: Date;
+        /**
+         * minDate? : Date
+         * <br/>Description : minDate of the Date filter
+         */
         minDate?: Date;
+        /**
+         * maxDate? : Date
+         * <br/>Description : maxDate of the Date filter
+         */
         maxDate?: Date;
+        /**
+         * predicate? : (item: T, defs: TATableDefs<T>, filter: IATableFilter<T>['Date']) => any
+         * <br/>Description : predicate of the Date filter. if not provided, it will have default predicate.
+         */
         predicate?: (item: T, defs: TATableDefs<T>, filter: IATableFilter<T>['Date']) => any;
     };
     DateRange: {
+        /**
+         * type : 'DateRange'
+         * <br/>Description : type of the DateRange filter
+         */
         type: 'DateRange';
+        /**
+         * defKey : keyof T | ''
+         * <br/>Description : defKey of the DateRange filter
+         */
         defKey: keyof T | '';
+        /**
+         * sDate : Date
+         * <br/>Description : sDate of the DateRange filter
+         */
         sDate: Date;
+        /**
+         * eDate : Date
+         * <br/>Description : eDate of the DateRange filter
+         */
         eDate: Date;
+        /**
+         * minDate? : Date
+         * <br/>Description : minDate of the DateRange filter
+         */
         minDate?: Date;
+        /**
+         * maxDate? : Date
+         * <br/>Description : maxDate of the DateRange filter
+         */
         maxDate?: Date;
+        /**
+         * predicate? : (item: T, defs: TATableDefs<T>, filter: IATableFilter<T>['DateRange']) => any
+         * <br/>Description : predicate of the DateRange filter. if not provided, it will have default predicate.
+         */
         predicate?: (item: T, defs: TATableDefs<T>, filter: IATableFilter<T>['DateRange']) => any;
     };
 }
 export type TATableSomeFilter<T extends IItem> = IATableFilter<T>[TATableFilterType];
 export type TATableFilteration<T extends IItem> = {
+    /**
+     * type : 'And' | 'Or'
+     * <br/>Description : type of the filteration
+     */
     type: 'And' | 'Or';
+    /**
+     * filters : TATableSomeFilter<T>[]
+     * <br/>Description : filters of the filteration
+     */
     filters: TATableSomeFilter<T>[];
 };
 export type TATableSortF<T extends IItem> = (a: T, b: T) => number;
 export interface IATableSortation<T extends IItem> {
+    /**
+     * defKey? : keyof T
+     * <br/>Description : defKey of the sortation
+     */
     defKey?: keyof T;
+    /**
+     * isAsc? : boolean
+     * <br/>Description : isAsc of the sortation
+     */
     isAsc?: boolean;
+    /**
+     * sortF? : TATableSortF<T>
+     * <br/>Description : sortF of the sortation
+     */
     sortF?: TATableSortF<T>;
 }
 export interface IATablePagination {
+    /**
+     * page : number
+     * <br/>Description : page of the pagination
+     */
     page: number;
+    /**
+     * pageSize : number
+     * <br/>Description : pageSize of the pagination
+     */
     pageSize: number;
+    /**
+     * pageRange : number
+     * <br/>Description : pageRange of the pagination
+     */
     pageRange: number;
 }
 export interface IATableState<T extends IItem> {
+    /**
+     * entireItems? : T[]
+     * <br/>Description : entireItems of the state
+     */
     entireItems?: T[];
+    /**
+     * filteration : TATableFilteration<T>
+     * <br/>Description : filteration of the state
+     */
     filteration: TATableFilteration<T>;
+    /**
+     * pagination : IATablePagination
+     * <br/>Description : pagination of the state
+     */
     pagination: IATablePagination;
+    /**
+     * sortation : IATableSortation<T>
+     * <br/>Description : sortation of the state
+     */
     sortation: IATableSortation<T>;
 }
 export interface IATableProps<T extends IItem> {
+    /**
+     * defs : TATableDefs<T>
+     * <br/>Description : defs of ATable
+     * <br/>Basic Usage :
+     * <br/>(1)const entireItems = [{name: 'John', age: 20}, {name: 'Jane', age: 21}];
+     * const defs = {
+     *   'name': {content: ({item}) => item.name},
+     *   'age': {content: ({item}) => item.age},
+     * }
+     * <ATable defs={defs} entireItems={entireItems}/>
+     */
     defs: TATableDefs<T>;
+    /**
+     * defaultDef? : IATableDef<T>
+     * <br/>Description : defaultDef of ATable
+     * <br/>Basic Usage :
+     * <br/>(1)const defaultDef = {content: ({item}) => item.name};
+     * <ATable defs={defs} defaultDef={defaultDef}/>
+     */
     defaultDef?: IATableDef<T>;
-    rProps?: TCBAble<IATableTRProps<T>, React.DetailedHTMLProps<React.HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>>;
+    /**
+     * rProps? : TCanCallback<IATableTRProps<T>, React.DetailedHTMLProps<React.HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>>
+     * <br/>Description : rProps of ATable
+     * <br/>Basic Usage :
+     * <br/>(1)const rProps = ({item}) => ({backgroundColor : 'pink'});
+     * <ATable defs={defs} rProps={rProps}/>
+     */
+    rProps?: TCanCallback<IATableTRProps<T>, React.DetailedHTMLProps<React.HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>>;
+    /**
+     * useSelect? : TUseValues<T>
+     * <br/>Description : useSelect of ATable.
+     * <br/>Basic Usage :
+     * <br/>(1)const [selectedItems, setSelectedItems] = useState<T[]>([]);
+     * <ATable defs={defs} entireItems={entireItems} useSelect={[selectedItems, setSelectedItems]}/>
+     */
     useSelect?: TUseValues<T[]>;
+    /**
+     * isSelectMulti? : boolean
+     * <br/>Description : isSelectMulti of ATable. if true, multiple items can be selected.
+     */
     isSelectMulti?: boolean;
+    /**
+     * selectDisabled? : (item: T) => string | boolean | undefined
+     * <br/>Description : selectDisabled of ATable. if string is returned, it will be displayed as tooltip.
+     */
     selectDisabled?: (item: T) => string | boolean | undefined;
+    /**
+     * useCheck? : TUseValues<T[]>
+     * <br/>Description : useCheck of ATable
+     * <br/>Basic Usage :
+     * <br/>(1)const [checkedItems, setCheckedItems] = useState<T[]>([]);
+     * <ATable defs={defs} entireItems={entireItems} useCheck={[checkedItems, setCheckedItems]}/>
+     */
     useCheck?: TUseValues<T[]>;
+    /**
+     * checkDisabled? : (item: T) => string | boolean | undefined
+     * <br/>Description : checkDisabled of ATable. if string is returned, it will be displayed as tooltip.
+     */
     checkDisabled?: (item: T) => string | boolean | undefined;
+    /**
+     * isLoading? : boolean
+     * <br/>Description : decides whether the table is loading or not
+     */
     isLoading?: boolean;
+    /**
+     * isDisabled? : boolean
+     * <br/>Description : decides whether the table is disabled or not
+     */
     isDisabled?: boolean;
+    /**
+     * title? : React.ReactNode
+     * <br/>Description : title of ATable
+     */
     title?: React.ReactNode;
+    /**
+     * entireItems? : T[]
+     * <br/>Description : entireItems of ATable. entireItems will be affected by filteration, sortation, and pagination.
+     * <br/>Basic Usage :
+     * <br/>(1)const entireItems = [{name: 'John', age: 20}, {name: 'Jane', age: 21}];
+     * <ATable defs={defs} entireItems={entireItems}/>   *
+     */
     entireItems?: T[];
+    /**
+     * onStateChange? : (params: IATableState<T>) => void
+     * <br/>Description : onStateChange of ATable. will be called when filteration, sortation, and pagination changes.
+     * <br/>Basic Usage :
+     * <br/>(1)const [pagedItems, setPagedItems] = useState<T[]>([]);
+     * const [totalCount, setTotalCount] = useState<number>(0);
+     * const onStateChange = ({entireItems, filteration, pagination, sortation}) => {
+     *   const {items, totalCount} = apiCall(entireItems, filteration, pagination, sortation);
+     *   setPagedItems(newItems);
+     *   setTotalCount(newTotalCount);
+     * }
+     * <ATable defs={defs} pagedItems={pagedItems} totalCount={totalCount} onStateChange={onStateChange}/>
+     */
     onStateChange?: (params: IATableState<T>) => void;
+    /**
+     * pagedItems? : T[]
+     * <br/>Description : pagedItems of ATable. if provided, entireItems will be ignored. pagedItems will not be affected by filteration, sortation, and pagination.
+     * <br/>Basic Usage :
+     * <br/>(1)const pagedItems = [{name: 'John', age: 20}, {name: 'Jane', age: 21}];
+     * <ATable defs={defs} pagedItems={pagedItems}/>
+     */
     pagedItems?: T[];
+    /**
+     * totalCount? : number
+     * <br/>Description : totalCount of ATable. if provided, pagination will be affected.
+     */
     totalCount?: number;
+    /**
+     * filterationDefs? : TATableFilterationDefs<T>
+     * <br/>Description : filterationDefs of ATable
+     * <br/>Basic Usage :
+     * <br/>(1)const filterationDefs = {type: 'Or', defs: [{type: 'String', placeholder: 'Search'}]};
+     * <ATable defs={defs} entireItems={entireItems} filterationDefs={filterationDefs}/>
+     */
     filterationDefs?: TATableFilterationDefs<T>;
+    /**
+     * useFilteration? : TUseValues<TATableFilteration<T>>
+     * <br/>Description : useFilteration of ATable. filteration can be controlled by useFilteration.
+     * <br/>Basic Usage :
+     * <br/>(1)const [filteration, setFilteration] = useState<TATableFilteration<T>>({type: 'Or', filters: []});
+     * <ATable defs={defs} entireItems={entireItems} useFilteration={[filteration, setFilteration]}/>
+     */
     useFilteration?: TUseValues<TATableFilteration<T>>;
+    /**
+     * toggleFilterationDefs? : TATableFilterationDefs<T>
+     * <br/>Description : toggleFilterationDefs of ATable. table can have two filterations. one is main filteration, and the other is toggle filteration.
+     * <br/>Basic Usage :
+     * <br/>(1)const toggleFilterationDefs = {type: 'Or', defs: [{type: 'String', placeholder: 'Search'}]};
+     * <ATable defs={defs} entireItems={entireItems} toggleFilterationDefs={toggleFilterationDefs}/>
+     */
     toggleFilterationDefs?: TATableFilterationDefs<T>;
+    /**
+     * useToggleFilteration? : TUseValues<TATableFilteration<T>>
+     * <br/>Description : useToggleFilteration of ATable. toggleFilteration can be controlled by useToggleFilteration.
+     * <br/>Basic Usage :
+     * <br/>(1)const [toggleFilteration, setToggleFilteration] = useState<TATableFilteration<T>>({type: 'Or', filters: []});
+     * <ATable defs={defs} entireItems={entireItems} useToggleFilteration={[toggleFilteration, setToggleFilteration]}/>
+     */
     useToggleFilteration?: TUseValues<TATableFilteration<T>>;
+    /**
+     * usePagination? : TUseValues<IATablePagination>
+     * <br/>Description : usePagination of ATable. pagination can be controlled by usePagination.
+     * <br/>Basic Usage :
+     * <br/>(1)const [pagination, setPagination] = useState<IATablePagination>({page: 1, pageSize: 50, pageRange: 10});
+     * <ATable defs={defs} entireItems={entireItems} usePagination={[pagination, setPagination]}/>
+     */
     usePagination?: TUseValues<IATablePagination>;
+    /**
+     * useSortation? : TUseValues<IATableSortation<T>>
+     * <br/>Description : useSortation of ATable. sortation can be controlled by useSortation.
+     * <br/>Basic Usage :
+     * <br/>(1)const [sortation, setSortation] = useState<IATableSortation<T>>({defKey: 'name', isAsc: true});
+     * <ATable defs={defs} entireItems={entireItems} useSortation={[sortation, setSortation]}/>
+     */
     useSortation?: TUseValues<IATableSortation<T>>;
+    /**
+     * TopRightAddon? : React.ReactNode
+     * <br/>Description : TopRightAddon of ATable
+     * <br/>Basic Usage :
+     * <br/>(1)<ATable defs={defs} entireItems={entireItems} TopRightAddon={<AButton>Click</AButton>}/>
+     */
     TopRightAddon?: React.ReactNode;
+    /**
+     * resources? : Partial<typeof Resources.ATable>
+     * <br/>Description : resources of ATable
+     */
     resources?: Partial<typeof Resources.ATable>;
 }
+/**
+ * AComponent : ATable
+ * <br/>Description : ATable is a table component. it can have defs and items to display the table. and has select, check, filteration, sortation, pagination options available.
+ * <br/>Basic Usage :
+ * <br/>(1)const entireItems = [{name: 'John', age: 20}, {name: 'Jane', age: 21}];
+ * const defs = {
+ *  'name': {content: ({item}) => item.name},
+ *  'age': {content: ({item}) => item.age},
+ *  'height' : {}
+ * }
+ * const defaultDefs = {
+ *   content : ({item}) => 'default value!'
+ * }
+ * <ATable defs={defs} entireItems={entireItems} defaultDef={defaultDefs}/>
+ *
+ * <br/>(2)const [pagedItems, setPagedItems] = useState<T[]>([{name: 'John', age: 20}, {name: 'Jane', age: 21}]);
+ * const [totalCount, setTotalCount] = useState<number>(2);
+ * const defs = {
+ *   'name': {content: ({item}) => item.name},
+ *   'age': {content: ({item}) => item.age},
+ * }
+ * const onStateChange = ({entireItems, filteration, pagination, sortation}) => {
+ *   const {items, totalCount} = apiCall(entireItems, filteration, pagination, sortation);
+ *   setPagedItems(newItems);
+ *   setTotalCount(newTotalCount);
+ * }
+ * <ATable defs={defs} pagedItems={pagedItems} totalCount={totalCount} onStateChange={onStateChange}/>
+ *
+ * <br/>(3)const [entireItems, setEntireItems] = useState<T[]>([{name: 'John', age: 20}, {name: 'Jane', age: 21}]);
+ * const [selectedItems, setSelectedItems] = useState<T[]>([]);
+ * const [checkedItems, setCheckedItems] = useState<T[]>([]);
+ * const selectDisabled = (item) => item.name === 'John' ? 'John is disabled' : false;
+ * const checkDisabled = (item) => item.name === 'Jane' ? 'Jane is disabled' : false;
+ * const defs = {
+ *   'name': {content: ({item}) => item.name},
+ *   'age': {content: ({item}) => item.age},
+ * }
+ * <ATable defs={defs} entireItems={entireItems}
+ *  useSelect={[selectedItems, setSelectedItems]}
+ *  useCheck={[checkedItems, setCheckedItems]}
+ *  selectDisabled={selectDisabled}
+ *  checkDisabled={checkDisabled}/>
+ *
+ * <br/>(4)const [entireItems, setEntireItems] = useState<T[]>([{name: 'John', age: 20}, {name: 'Jane', age: 21}]);
+ * const filterationDefs = {type: 'Or', defs: [{type: 'String', placeholder: 'Search'}]};
+ * const defaultPagination = {page: 1, pageSize: 50, pageRange: 10};
+ * const defs = {
+ *   'name': {content: ({item}) => item.name},
+ *   'age': {content: ({item}) => item.age, asText: ({item}) => item.age, isSortable : true},
+ * }
+ * <ATable defs={defs} entireItems={entireItems} filterationDefs={filterationDefs} usePagination={[defaultPagination, undefined]}/>
+ */
 export declare const ATable: <T extends IItem>({ defs: extDefs, defaultDef: extDefaultDef, rProps, useSelect, isSelectMulti, selectDisabled, useCheck, checkDisabled, isLoading, isDisabled, title, entireItems, onStateChange, pagedItems: extPagedItems, totalCount: extTotalCount, filterationDefs, useFilteration, toggleFilterationDefs, useToggleFilteration, usePagination, useSortation, TopRightAddon, resources: extResources, }: IATableProps<T>) => import("react/jsx-runtime").JSX.Element;