ados-rcm 1.0.9 → 1.0.12

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

@@ -27,11 +27,13 @@ import { TIdx } from '../ATypes/ATypes';
 export interface IATableTHProps<T extends IItem> {
     /**
      * defKey : TIdx
+     *
      * Description : defKey of the given defs
      */
     defKey: TIdx;
     /**
      * def : IATableDef<T>
+     *
      * Description : def of the given defs
      */
     def: IATableDef<T>;
@@ -39,6 +41,7 @@ export interface IATableTHProps<T extends IItem> {
 export interface IATableTRProps<T extends IItem> {
     /**
      * item : T
+     *
      * Description : item of the given items
      */
     item: T;
@@ -48,76 +51,91 @@ export interface IATableTDProps<T extends IItem> extends IATableTHProps<T>, IATa
 export interface IATableDef<T extends IItem> {
     /**
      * width? : TCanCallback<IATableTHProps<T>, number>
+     *
      * Description : width of the column
      */
     width?: TCanCallback<IATableTHProps<T>, number>;
     /**
      * maxWidth? : TCanCallback<IATableTHProps<T>, number>
+     *
      * Description : maxWidth of the column
      */
     maxWidth?: TCanCallback<IATableTHProps<T>, number>;
     /**
      * minWidth? : TCanCallback<IATableTHProps<T>, number>
+     *
      * Description : minWidth of the column
      */
     minWidth?: TCanCallback<IATableTHProps<T>, number>;
     /**
      * align? : TCanCallback<IATableTHProps<T>, React.CSSProperties['justifyContent']>
+     *
      * Description : align of the column. type of justifyContent
      */
     align?: TCanCallback<IATableTHProps<T>, React.CSSProperties['justifyContent']>;
     /**
      * colSpan? : TCanCallback<IATableTHProps<T>, number>
+     *
      * 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>
+     *
      * Description : content of the th
      */
     hContent?: TCanCallback<IATableTHProps<T>, React.ReactNode>;
     /**
      * hColor? : TCanCallback<IATableTHProps<T>, React.CSSProperties['color']>
+     *
      * Description : color of the th
      */
     hColor?: TCanCallback<IATableTHProps<T>, React.CSSProperties['color']>;
     /**
      * hBackgroundColor? : TCanCallback<IATableTHProps<T>, React.CSSProperties['backgroundColor']>
+     *
      * Description : backgroundColor of the th
      */
     hBackgroundColor?: TCanCallback<IATableTHProps<T>, React.CSSProperties['backgroundColor']>;
     /**
      * isSortable? : boolean
+     *
      * Description : decides whether the column is sortable or not
      */
     isSortable?: boolean;
     /**
      * noResize? : boolean
+     *
      * Description : decides whether the column is resizable or not
      */
     noResize?: boolean;
     /**
      * sortF? : (a: T, b: T) => number
+     *
      * Description : sortF of the column
      */
     sortF?: (a: T, b: T) => number;
     /**
      * content? : TCanCallback<IATableTDProps<T>, React.ReactNode>
+     *
      * Description : content of the td
      */
     content?: TCanCallback<IATableTDProps<T>, React.ReactNode>;
     /**
      * asText? : TCanCallback<IATableTDProps<T>, string | number>
+     *
      * Description : for filteration. complicated contents can be filtered using asText.
      */
     asText?: TCanCallback<IATableTDProps<T>, string | number>;
     /**
      * color? : TCanCallback<IATableTDProps<T>, React.CSSProperties['color']>
+     *
      * Description : color of the td
      */
     color?: TCanCallback<IATableTDProps<T>, React.CSSProperties['color']>;
     /**
      * backgroundColor? : TCanCallback<IATableTDProps<T>, React.CSSProperties['backgroundColor']>
+     *
      * Description : backgroundColor of the td
      */
     backgroundColor?: TCanCallback<IATableTDProps<T>, React.CSSProperties['backgroundColor']>;
@@ -132,21 +150,25 @@ export interface IATableFilterDef<T extends IItem> {
     String: {
         /**
          * type : 'String'
+         *
          * Description : type of the String filter Def
          */
         type: 'String';
         /**
          * defKey? : keyof T | ''
+         *
          * Description : defKey of the String filter Def
          */
         defKey?: keyof T | '';
         /**
          * predicate? : (item: T, defs: TATableDefs<T>, filter: IATableFilter<T>['String']) => any
+         *
          * 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
+         *
          * Description : placeholder of the String filter Def
          */
         placeholder?: string;
@@ -154,31 +176,37 @@ export interface IATableFilterDef<T extends IItem> {
     Select: {
         /**
          * type : 'Select'
+         *
          * Description : type of the Select filter Def
          */
         type: 'Select';
         /**
          * defKey? : keyof T | ''
+         *
          * Description : defKey of the Select filter Def
          */
         defKey?: keyof T | '';
         /**
          * options : (string | number)[]
+         *
          * Description : options of the Select filter Def
          */
         options: (string | number)[];
         /**
          * placeholder : (string | number)[]
+         *
          * Description : values of the Select filter Def
          */
         placeholder?: string;
         /**
          * OptionRenderer? : (option: string | number) => React.ReactNode
+         *
          * Description : OptionRenderer of the Select filter Def
          */
         OptionRenderer?: (option: string | number) => React.ReactNode;
         /**
          * predicate? : (item: T, defs: TATableDefs<T>, filter: IATableFilter<T>['Select']) => any
+         *
          * 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;
@@ -186,26 +214,31 @@ export interface IATableFilterDef<T extends IItem> {
     Date: {
         /**
          * type : 'Date'
+         *
          * Description : type of the Date filter Def
          */
         type: 'Date';
         /**
          * defKey? : keyof T | ''
+         *
          * Description : defKey of the Date filter Def
          */
         defKey?: keyof T | '';
         /**
          * minDate? : Date
+         *
          * Description : minDate of the Date filter Def
          */
         minDate?: Date;
         /**
          * maxDate? : Date
+         *
          * Description : maxDate of the Date filter Def
          */
         maxDate?: Date;
         /**
          * predicate? : (item: T, defs: TATableDefs<T>, filter: IATableFilter<T>['Date']) => any
+         *
          * 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;
@@ -213,26 +246,31 @@ export interface IATableFilterDef<T extends IItem> {
     DateRange: {
         /**
          * type : 'DateRange'
+         *
          * Description : type of the DateRange filter Def
          */
         type: 'DateRange';
         /**
          * defKey? : keyof T | ''
+         *
          * Description : defKey of the DateRange filter Def
          */
         defKey?: keyof T | '';
         /**
          * minDate? : Date
+         *
          * Description : minDate of the DateRange filter Def
          */
         minDate?: Date;
         /**
          * maxDate? : Date
+         *
          * Description : maxDate of the DateRange filter Def
          */
         maxDate?: Date;
         /**
          * predicate? : (item: T, defs: TATableDefs<T>, filter: IATableFilter<T>['DateRange']) => any
+         *
          * 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;
@@ -242,11 +280,13 @@ export type TATableSomeFilterDef<T extends IItem> = IATableFilterDef<T>[TATableF
 export type TATableFilterationDefs<T extends IItem> = {
     /**
      * type : 'And' | 'Or'
+     *
      * Description : type of the filteration Defs
      */
     type: 'And' | 'Or';
     /**
      * defs : TATableSomeFilterDef<T>[]
+     *
      * Description : defs of the filteration Defs
      */
     defs: TATableSomeFilterDef<T>[];
@@ -255,26 +295,31 @@ export interface IATableFilter<T extends IItem> {
     String: {
         /**
          * type : 'String'
+         *
          * Description : type of the String filter
          */
         type: 'String';
         /**
          * defKey? : keyof T | ''
+         *
          * Description : defKey of the String filter
          */
         defKey: keyof T | '';
         /**
          * value : string
+         *
          * Description : value of the String filter
          */
         value: string;
         /**
          * predicate? : (item: T, defs: TATableDefs<T>, filter: IATableFilter<T>['String']) => any
+         *
          * Description : predicate of the String filter
          */
         predicate?: (item: T, defs: TATableDefs<T>, filter: IATableFilter<T>['String']) => any;
         /**
          * placeholder? : string
+         *
          * Description : placeholder of the String filter
          */
         placeholder?: string;
@@ -282,36 +327,43 @@ export interface IATableFilter<T extends IItem> {
     Select: {
         /**
          * type : 'Select'
+         *
          * Description : type of the Select filter
          */
         type: 'Select';
         /**
          * defKey : keyof T | ''
+         *
          * Description : defKey of the Select filter
          */
         defKey: keyof T | '';
         /**
          * values : (string | number)[]
+         *
          * Description : values of the Select filter
          */
         values: (string | number)[];
         /**
          * options : (string | number)[]
+         *
          * Description : options of the Select filter
          */
         options: (string | number)[];
         /**
          * placeholder : string
+         *
          * Description : placeholder of the Select filter
          */
         placeholder?: string;
         /**
          * OptionRenderer? : (option: string | number) => React.ReactNode
+         *
          * Description : OptionRenderer of the Select filter
          */
         OptionRenderer?: (option: string | number) => React.ReactNode;
         /**
          * predicate? : (item: T, defs: TATableDefs<T>, filter: IATableFilter<T>['Select']) => any
+         *
          * 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;
@@ -319,31 +371,37 @@ export interface IATableFilter<T extends IItem> {
     Date: {
         /**
          * type : 'Date'
+         *
          * Description : type of the Date filter
          */
         type: 'Date';
         /**
          * defKey : keyof T | ''
+         *
          * Description : defKey of the Date filter
          */
         defKey: keyof T;
         /**
          * value : Date
+         *
          * Description : value of the Date filter
          */
         value: Date;
         /**
          * minDate? : Date
+         *
          * Description : minDate of the Date filter
          */
         minDate?: Date;
         /**
          * maxDate? : Date
+         *
          * Description : maxDate of the Date filter
          */
         maxDate?: Date;
         /**
          * predicate? : (item: T, defs: TATableDefs<T>, filter: IATableFilter<T>['Date']) => any
+         *
          * 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;
@@ -351,36 +409,43 @@ export interface IATableFilter<T extends IItem> {
     DateRange: {
         /**
          * type : 'DateRange'
+         *
          * Description : type of the DateRange filter
          */
         type: 'DateRange';
         /**
          * defKey : keyof T | ''
+         *
          * Description : defKey of the DateRange filter
          */
         defKey: keyof T | '';
         /**
          * sDate : Date
+         *
          * Description : sDate of the DateRange filter
          */
         sDate: Date;
         /**
          * eDate : Date
+         *
          * Description : eDate of the DateRange filter
          */
         eDate: Date;
         /**
          * minDate? : Date
+         *
          * Description : minDate of the DateRange filter
          */
         minDate?: Date;
         /**
          * maxDate? : Date
+         *
          * Description : maxDate of the DateRange filter
          */
         maxDate?: Date;
         /**
          * predicate? : (item: T, defs: TATableDefs<T>, filter: IATableFilter<T>['DateRange']) => any
+         *
          * 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;
@@ -390,11 +455,13 @@ export type TATableSomeFilter<T extends IItem> = IATableFilter<T>[TATableFilterT
 export type TATableFilteration<T extends IItem> = {
     /**
      * type : 'And' | 'Or'
+     *
      * Description : type of the filteration
      */
     type: 'And' | 'Or';
     /**
      * filters : TATableSomeFilter<T>[]
+     *
      * Description : filters of the filteration
      */
     filters: TATableSomeFilter<T>[];
@@ -403,16 +470,19 @@ export type TATableSortF<T extends IItem> = (a: T, b: T) => number;
 export interface IATableSortation<T extends IItem> {
     /**
      * defKey? : keyof T
+     *
      * Description : defKey of the sortation
      */
     defKey?: keyof T;
     /**
      * isAsc? : boolean
+     *
      * Description : isAsc of the sortation
      */
     isAsc?: boolean;
     /**
      * sortF? : TATableSortF<T>
+     *
      * Description : sortF of the sortation
      */
     sortF?: TATableSortF<T>;
@@ -420,16 +490,19 @@ export interface IATableSortation<T extends IItem> {
 export interface IATablePagination {
     /**
      * page : number
+     *
      * Description : page of the pagination
      */
     page: number;
     /**
      * pageSize : number
+     *
      * Description : pageSize of the pagination
      */
     pageSize: number;
     /**
      * pageRange : number
+     *
      * Description : pageRange of the pagination
      */
     pageRange: number;
@@ -437,21 +510,25 @@ export interface IATablePagination {
 export interface IATableState<T extends IItem> {
     /**
      * entireItems? : T[]
+     *
      * Description : entireItems of the state
      */
     entireItems?: T[];
     /**
      * filteration : TATableFilteration<T>
+     *
      * Description : filteration of the state
      */
     filteration: TATableFilteration<T>;
     /**
      * pagination : IATablePagination
+     *
      * Description : pagination of the state
      */
     pagination: IATablePagination;
     /**
      * sortation : IATableSortation<T>
+     *
      * Description : sortation of the state
      */
     sortation: IATableSortation<T>;
@@ -459,224 +536,196 @@ export interface IATableState<T extends IItem> {
 export interface IATableProps<T extends IItem> {
     /**
      * defs : TATableDefs<T>
+     *
      * Description : defs of ATable
-     * Basic Usage :
-     * (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>
+     *
      * Description : defaultDef of ATable
-     * Basic Usage :
-     * (1) const defaultDef = {content: ({item}) => item.name};
-     * <ATable defs={defs} defaultDef={defaultDef}/>
      */
     defaultDef?: IATableDef<T>;
     /**
      * rProps? : TCanCallback<IATableTRProps<T>, React.DetailedHTMLProps<React.HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>>
+     *
      * Description : rProps of ATable
-     * Basic Usage :
-     * (1) const rProps = ({item}) => ({backgroundColor : 'pink'});
-     * <ATable defs={defs} rProps={rProps}/>
      */
     rProps?: TCanCallback<IATableTRProps<T>, React.DetailedHTMLProps<React.HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>>;
     /**
      * useSelect? : TUseValues<T>
+     *
      * Description : useSelect of ATable.
-     * Basic Usage :
-     * (1) const [selectedItems, setSelectedItems] = useState<T[]>([]);
-     * <ATable defs={defs} entireItems={entireItems} useSelect={[selectedItems, setSelectedItems]}/>
      */
     useSelect?: TUseValues<T[]>;
     /**
      * isSelectMulti? : boolean
+     *
      * Description : isSelectMulti of ATable. if true, multiple items can be selected.
      */
     isSelectMulti?: boolean;
     /**
      * selectDisabled? : (item: T) => string | boolean | undefined
+     *
      * Description : selectDisabled of ATable. if string is returned, it will be displayed as tooltip.
      */
     selectDisabled?: (item: T) => string | boolean | undefined;
     /**
      * useCheck? : TUseValues<T[]>
+     *
      * Description : useCheck of ATable
-     * Basic Usage :
-     * (1) const [checkedItems, setCheckedItems] = useState<T[]>([]);
-     * <ATable defs={defs} entireItems={entireItems} useCheck={[checkedItems, setCheckedItems]}/>
      */
     useCheck?: TUseValues<T[]>;
     /**
      * checkDisabled? : (item: T) => string | boolean | undefined
+     *
      * Description : checkDisabled of ATable. if string is returned, it will be displayed as tooltip.
      */
     checkDisabled?: (item: T) => string | boolean | undefined;
     /**
      * isLoading? : boolean
+     *
      * Description : decides whether the table is loading or not
      */
     isLoading?: boolean;
     /**
      * isDisabled? : boolean
+     *
      * Description : decides whether the table is disabled or not
      */
     isDisabled?: boolean;
     /**
      * title? : React.ReactNode
+     *
      * Description : title of ATable
      */
     title?: React.ReactNode;
     /**
      * entireItems? : T[]
+     *
      * Description : entireItems of ATable. entireItems will be affected by filteration, sortation, and pagination.
-     * Basic Usage :
-     * (1) const entireItems = [{name: 'John', age: 20}, {name: 'Jane', age: 21}];
-     * <ATable defs={defs} entireItems={entireItems}/>   *
      */
     entireItems?: T[];
     /**
      * onStateChange? : (params: IATableState<T>) => void
+     *
      * Description : onStateChange of ATable. will be called when filteration, sortation, and pagination changes.
-     * Basic Usage :
-     * (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[]
+     *
      * Description : pagedItems of ATable. if provided, entireItems will be ignored. pagedItems will not be affected by filteration, sortation, and pagination.
-     * Basic Usage :
-     * (1) const pagedItems = [{name: 'John', age: 20}, {name: 'Jane', age: 21}];
-     * <ATable defs={defs} pagedItems={pagedItems}/>
      */
     pagedItems?: T[];
     /**
      * totalCount? : number
+     *
      * Description : totalCount of ATable. if provided, pagination will be affected.
      */
     totalCount?: number;
     /**
      * filterationDefs? : TATableFilterationDefs<T>
+     *
      * Description : filterationDefs of ATable
-     * Basic Usage :
-     * (1) const filterationDefs = {type: 'Or', defs: [{type: 'String', placeholder: 'Search'}]};
-     * <ATable defs={defs} entireItems={entireItems} filterationDefs={filterationDefs}/>
      */
     filterationDefs?: TATableFilterationDefs<T>;
     /**
      * useFilteration? : TUseValues<TATableFilteration<T>>
+     *
      * Description : useFilteration of ATable. filteration can be controlled by useFilteration.
-     * Basic Usage :
-     * (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>
+     *
      * Description : toggleFilterationDefs of ATable. table can have two filterations. one is main filteration, and the other is toggle filteration.
-     * Basic Usage :
-     * (1) const toggleFilterationDefs = {type: 'Or', defs: [{type: 'String', placeholder: 'Search'}]};
-     * <ATable defs={defs} entireItems={entireItems} toggleFilterationDefs={toggleFilterationDefs}/>
      */
     toggleFilterationDefs?: TATableFilterationDefs<T>;
     /**
      * useToggleFilteration? : TUseValues<TATableFilteration<T>>
+     *
      * Description : useToggleFilteration of ATable. toggleFilteration can be controlled by useToggleFilteration.
-     * Basic Usage :
-     * (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>
+     *
      * Description : usePagination of ATable. pagination can be controlled by usePagination.
-     * Basic Usage :
-     * (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>>
+     *
      * Description : useSortation of ATable. sortation can be controlled by useSortation.
-     * Basic Usage :
-     * (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
+     *
      * Description : TopRightAddon of ATable
-     * Basic Usage :
-     * (1) <ATable defs={defs} entireItems={entireItems} TopRightAddon={<AButton>Click</AButton>}/>
      */
     TopRightAddon?: React.ReactNode;
     /**
      * resources? : Partial<typeof Resources.ATable>
+     *
      * Description : resources of ATable
      */
     resources?: Partial<typeof Resources.ATable>;
 }
 /**
  * AComponent : ATable
+ *
  * 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.
+ *
  * Basic Usage :
- * (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}/>
  *
- * (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}/>
+ *     const entireItems = [{name: 'John', age: 20}, {name: 'Jane', age: 21}];
+ *     const [pagedItems, setPagedItems] = useState<T[]>([{name: 'John', age: 20}, {name: 'Jane', age: 21}]);
+ *     const [totalCount, setTotalCount] = useState<number>(pagedItems.length);
+ *     const defs = {
+ *       name: {content: ({item}) => item.name},
+ *       age: {content: ({item}) => item.age},
+ *       height : {}
+ *     }
+ *     const defaultDefs = {
+ *       content : ({item}) => 'default value!'
+ *     }
+ *     const onStateChange = ({entireItems, filteration, pagination, sortation}) => {
+ *       const {items, totalCount} = apiCall(entireItems, filteration, pagination, sortation);
+ *       setPagedItems(items);
+ *       setTotalCount(totalCount);
+ *     }
+ *     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 filterationDefs = {type: 'Or', defs: [{type: 'String', placeholder: 'Search'}]};
+ *     const defaultPagination = {page: 1, pageSize: 50, pageRange: 10}; *
+ *
+ *     if (case 1)
+ *       <ATable defs={defs}
+ *         entireItems={entireItems}
+ *         defaultDef={defaultDefs}/>
+ *
+ *     if (case 2)
+ *       <ATable defs={defs}
+ *         pagedItems={pagedItems}
+ *         totalCount={totalCount}
+ *         onStateChange={onStateChange}/>
  *
- * (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}/>
+ *     if (case 3)
+ *       <ATable defs={defs}
+ *         entireItems={entireItems}
+ *         useSelect={[selectedItems, setSelectedItems]}
+ *         useCheck={[checkedItems, setCheckedItems]}
+ *         selectDisabled={selectDisabled}
+ *         checkDisabled={checkDisabled}/>
  *
- * (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]}/>
+ *     if (case 4)
+ *       <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;