@atlaskit/dynamic-table 14.9.0 → 14.9.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @atlaskit/dynamic-table
 
+## 14.9.2
+
+### Patch Changes
+
+- [`9d00501a414`](https://bitbucket.org/atlassian/atlassian-frontend/commits/9d00501a414) - Ensure legacy types are published for TS 4.5-4.8
+
+## 14.9.1
+
+### Patch Changes
+
+- [`41fae2c6f68`](https://bitbucket.org/atlassian/atlassian-frontend/commits/41fae2c6f68) - Upgrade Typescript from `4.5.5` to `4.9.5`
+
 ## 14.9.0
 
 ### Minor Changes

package/dist/cjs/components/stateless.js

@@ -29,7 +29,7 @@ var _tableHead = _interopRequireDefault(require("./table-head"));
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(this, result); }; }
 function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 var packageName = "@atlaskit/dynamic-table";
-var packageVersion = "14.9.0";
+var packageVersion = "14.9.2";
 function toggleSortOrder(currentSortOrder) {
   switch (currentSortOrder) {
     case _constants.DESC:

package/dist/cjs/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/dynamic-table",
-	"version": "14.9.0",
+	"version": "14.9.2",
 	"sideEffects": false
 }

package/dist/es2019/components/stateless.js

@@ -14,7 +14,7 @@ import ManagedPagination from './managed-pagination';
 import RankableTableBody from './rankable/body';
 import TableHead from './table-head';
 const packageName = "@atlaskit/dynamic-table";
-const packageVersion = "14.9.0";
+const packageVersion = "14.9.2";
 function toggleSortOrder(currentSortOrder) {
   switch (currentSortOrder) {
     case DESC:

package/dist/es2019/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/dynamic-table",
-	"version": "14.9.0",
+	"version": "14.9.2",
 	"sideEffects": false
 }

package/dist/esm/components/stateless.js

@@ -22,7 +22,7 @@ import ManagedPagination from './managed-pagination';
 import RankableTableBody from './rankable/body';
 import TableHead from './table-head';
 var packageName = "@atlaskit/dynamic-table";
-var packageVersion = "14.9.0";
+var packageVersion = "14.9.2";
 function toggleSortOrder(currentSortOrder) {
   switch (currentSortOrder) {
     case DESC:

package/dist/esm/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/dynamic-table",
-	"version": "14.9.0",
+	"version": "14.9.2",
 	"sideEffects": false
 }

package/dist/types/components/loading-container-advanced.d.ts

@@ -23,7 +23,7 @@ export default class LoadingContainerAdvanced extends React.Component<LoadingCon
     getTargetNode: (nextProps?: LoadingContainerAdvancedProps) => Element | Text | null;
     getThisNode: () => Element | Text | null;
     getSpinnerNode: () => Element | Text | null;
-    hasTargetNode: (nextProps?: LoadingContainerAdvancedProps | undefined) => boolean;
+    hasTargetNode: (nextProps?: LoadingContainerAdvancedProps) => boolean;
     isVerticallyVisible: (elementRect: {
         top: number;
         bottom: number;
@@ -36,7 +36,7 @@ export default class LoadingContainerAdvanced extends React.Component<LoadingCon
     detachListeners(): void;
     handleResize: () => void;
     handleScroll: () => void;
-    translateSpinner: (spinnerNode: HTMLElement, transformY: number, isFixed?: boolean | undefined) => void;
+    translateSpinner: (spinnerNode: HTMLElement, transformY: number, isFixed?: boolean) => void;
     updateTargetAppearance: () => void;
     updateSpinnerPosition(): void;
     render(): JSX.Element;

package/dist/types/components/managed-pagination.d.ts

@@ -9,7 +9,7 @@ interface ManagedPaginationProps {
     testId?: string;
 }
 export default class ManagedPagination extends React.Component<ManagedPaginationProps> {
-    onChange: (_event: any, newValue: any, analyticsEvent?: UIAnalyticsEvent | undefined) => void;
+    onChange: (_event: any, newValue: any, analyticsEvent?: UIAnalyticsEvent) => void;
     render(): JSX.Element;
 }
 export {};

package/dist/types/components/stateful.d.ts

@@ -51,8 +51,8 @@ export default class DynamicTable extends React.Component<StatefulProps, State>
         rows: RowType[] | undefined;
     };
     UNSAFE_componentWillReceiveProps(newProps: StatefulProps): void;
-    onSetPageHandler: (page: number, analyticsEvent?: UIAnalyticsEvent | undefined) => void;
-    onSortHandler: ({ key, item, sortOrder }: any, analyticsEvent?: UIAnalyticsEvent | undefined) => void;
+    onSetPageHandler: (page: number, analyticsEvent?: UIAnalyticsEvent) => void;
+    onSortHandler: ({ key, item, sortOrder }: any, analyticsEvent?: UIAnalyticsEvent) => void;
     onRankEndIfExistsHandler: (params: RankEnd) => void;
     onRankEndHandler: (params: RankEnd) => void;
     render(): JSX.Element;

package/dist/types/components/stateless.d.ts

@@ -30,7 +30,7 @@ declare class DynamicTable extends React.Component<Props, State> {
     UNSAFE_componentWillMount(): void;
     UNSAFE_componentWillReceiveProps(nextProps: Props): void;
     onSortHandler: (item: RowCellType) => () => void;
-    onSetPageHandler: (page: number, event?: UIAnalyticsEvent | undefined) => void;
+    onSetPageHandler: (page: number, event?: UIAnalyticsEvent) => void;
     onRankStartHandler: (params: RankStart) => void;
     onRankEndHandler: (params: RankEnd) => void;
     getSpinnerSize: () => import("../types").LoadingSpinnerSizeType;

package/dist/types/internal/helpers.d.ts

@@ -1,7 +1,7 @@
 import { HeadType, RankEnd, RowType } from '../types';
-export declare const getPageRows: (allRows: Array<RowType>, pageNumber?: number | undefined, rowsPerPage?: number | undefined) => Array<RowType>;
-export declare const assertIsSortable: (head?: HeadType | undefined) => void;
-export declare const validateSortKey: (sortKey?: string | undefined, head?: HeadType | undefined) => void;
-export declare const inlineStylesIfRanking: (isRanking: boolean, width: number, height?: number | undefined) => {};
-export declare const computeIndex: (index: number, page: number, rowsPerPage?: number | undefined) => number;
-export declare const reorderRows: (rankEnd: RankEnd, rows: RowType[], page?: number, rowsPerPage?: number | undefined) => RowType[];
+export declare const getPageRows: (allRows: Array<RowType>, pageNumber?: number, rowsPerPage?: number) => Array<RowType>;
+export declare const assertIsSortable: (head?: HeadType) => void;
+export declare const validateSortKey: (sortKey?: string, head?: HeadType) => void;
+export declare const inlineStylesIfRanking: (isRanking: boolean, width: number, height?: number) => {};
+export declare const computeIndex: (index: number, page: number, rowsPerPage?: number) => number;
+export declare const reorderRows: (rankEnd: RankEnd, rows: RowType[], page?: number, rowsPerPage?: number) => RowType[];

package/dist/types/styled/dynamic-table.d.ts

@@ -1,6 +1,6 @@
 /** @jsx jsx */
 import { FC, HTMLProps, ReactNode } from 'react';
-export declare type TableProps = HTMLProps<HTMLTableElement> & {
+export type TableProps = HTMLProps<HTMLTableElement> & {
     isFixedSize?: boolean;
     hasDataRow: boolean;
     testId?: string;

package/dist/types/styled/empty-body.d.ts

@@ -1,10 +1,10 @@
 /** @jsx jsx */
 import { FC, ReactNode } from 'react';
-declare type EmptyViewWithFixedHeightProps = {
+type EmptyViewWithFixedHeightProps = {
     testId?: string;
     children?: ReactNode;
 };
-declare type EmptyViewContainerProps = {
+type EmptyViewContainerProps = {
     testId?: string;
     children: ReactNode;
 };

package/dist/types/styled/loading-container-advanced.d.ts

@@ -1,11 +1,11 @@
 /** @jsx jsx */
 import { FC, HTMLProps, ReactNode } from 'react';
 import { jsx } from '@emotion/react';
-declare type ContainerProps = HTMLProps<HTMLDivElement> & {
+type ContainerProps = HTMLProps<HTMLDivElement> & {
     testId?: string;
 };
 export declare const Container: (props: ContainerProps) => jsx.JSX.Element;
-declare type SpinnerBackdropProps = {
+type SpinnerBackdropProps = {
     testId?: string;
     children: ReactNode;
 };

package/dist/types/styled/loading-container.d.ts

@@ -1,11 +1,11 @@
 /** @jsx jsx */
 import { FC, ReactNode } from 'react';
 export declare const CSS_VAR_CONTENTS_OPACITY = "--contents-opacity";
-declare type ContainerProps = {
+type ContainerProps = {
     testId?: string;
     children: ReactNode;
 };
-declare type LoadingContainerProps = ContainerProps & {
+type LoadingContainerProps = ContainerProps & {
     contentsOpacity: number;
 };
 export declare const Container: FC<ContainerProps>;

package/dist/types/styled/rankable/table-cell.d.ts

@@ -1,7 +1,7 @@
 /** @jsx jsx */
 import { FC, HTMLProps, ReactNode } from 'react';
 import { TruncateStyleProps } from '../constants';
-declare type RankableTableBodyCellProps = HTMLProps<HTMLTableCellElement | HTMLTableRowElement> & TruncateStyleProps & {
+type RankableTableBodyCellProps = HTMLProps<HTMLTableCellElement | HTMLTableRowElement> & TruncateStyleProps & {
     isRanking?: boolean;
     children?: ReactNode;
 };

package/dist/types/styled/rankable/table-row.d.ts

@@ -1,7 +1,7 @@
 /** @jsx jsx */
 import { HTMLAttributes } from 'react';
 import { ITableRowProps } from '../table-row';
-export declare type RankableTableBodyRowProps = HTMLAttributes<HTMLTableRowElement> & ITableRowProps & {
+export type RankableTableBodyRowProps = HTMLAttributes<HTMLTableRowElement> & ITableRowProps & {
     isRanking?: boolean;
     isRankingItem?: boolean;
     testId?: string;

package/dist/types/styled/table-head.d.ts

@@ -8,7 +8,7 @@ interface HeadProps {
     testId?: string;
 }
 export declare const Head: FC<HeadProps>;
-declare type HeadCellProps = TruncateStyleProps & HTMLProps<HTMLTableCellElement> & {
+type HeadCellProps = TruncateStyleProps & HTMLProps<HTMLTableCellElement> & {
     onClick?: () => void;
     isSortable?: boolean;
     sortOrder?: SortOrderType;

package/dist/types/styled/table-row.d.ts

@@ -1,6 +1,6 @@
 /** @jsx jsx */
 import { CSSProperties, ReactNode } from 'react';
-export declare type ITableRowProps = {
+export type ITableRowProps = {
     isHighlighted?: boolean;
     children?: ReactNode;
     style?: CSSProperties;

package/dist/types/types.d.ts

@@ -305,13 +305,13 @@ export interface RowType extends React.ComponentPropsWithoutRef<'tr'> {
 /**
  * Enum style type to determine whether sort results are ascending or descending.
  */
-export declare type SortOrderType = 'ASC' | 'DESC';
+export type SortOrderType = 'ASC' | 'DESC';
 /**
  * Determines the size of the table loading spinner.
  * This matches the underlying `Size` type in `@atlaskit/spinner`
  */
-export declare type SpinnerSizeType = SizeType;
-export declare type LoadingSpinnerSizeType = 'small' | 'large';
+export type SpinnerSizeType = SizeType;
+export type LoadingSpinnerSizeType = 'small' | 'large';
 export interface HeadCellType extends RowCellType {
     /**
      * Whether the column the cell sits above is sortable.

package/dist/types-ts4.5/components/body.d.ts

@@ -0,0 +1,112 @@
+import React from 'react';
+import { WithSortedPageRowsProps } from '../hoc/with-sorted-page-rows';
+import { HeadType } from '../types';
+interface BodyProps extends WithSortedPageRowsProps {
+    head?: HeadType;
+    highlightedRowIndex?: number | number[];
+    isFixedSize: boolean;
+    testId?: string;
+}
+declare const _default: {
+    new (props: Readonly<Omit<BodyProps & import("../hoc/with-sorted-page-rows").TableProps, "pageRows">>): {
+        state: {
+            pageRows: never[];
+        };
+        componentDidMount(): void;
+        componentDidUpdate(_prevProps: Omit<BodyProps & import("../hoc/with-sorted-page-rows").TableProps, "pageRows">, prevState: {
+            pageRows: import("../types").RowType[];
+        }): void;
+        render(): JSX.Element;
+        context: any;
+        setState<K extends "pageRows">(state: {
+            pageRows: import("../types").RowType[];
+        } | ((prevState: Readonly<{
+            pageRows: import("../types").RowType[];
+        }>, props: Readonly<Omit<BodyProps & import("../hoc/with-sorted-page-rows").TableProps, "pageRows">>) => {
+            pageRows: import("../types").RowType[];
+        } | Pick<{
+            pageRows: import("../types").RowType[];
+        }, K> | null) | Pick<{
+            pageRows: import("../types").RowType[];
+        }, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callBack?: (() => void) | undefined): void;
+        readonly props: Readonly<Omit<BodyProps & import("../hoc/with-sorted-page-rows").TableProps, "pageRows">> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        shouldComponentUpdate?(nextProps: Readonly<Omit<BodyProps & import("../hoc/with-sorted-page-rows").TableProps, "pageRows">>, nextState: Readonly<{
+            pageRows: import("../types").RowType[];
+        }>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<Omit<BodyProps & import("../hoc/with-sorted-page-rows").TableProps, "pageRows">>, prevState: Readonly<{
+            pageRows: import("../types").RowType[];
+        }>): any;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<Omit<BodyProps & import("../hoc/with-sorted-page-rows").TableProps, "pageRows">>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Omit<BodyProps & import("../hoc/with-sorted-page-rows").TableProps, "pageRows">>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<Omit<BodyProps & import("../hoc/with-sorted-page-rows").TableProps, "pageRows">>, nextState: Readonly<{
+            pageRows: import("../types").RowType[];
+        }>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<Omit<BodyProps & import("../hoc/with-sorted-page-rows").TableProps, "pageRows">>, nextState: Readonly<{
+            pageRows: import("../types").RowType[];
+        }>, nextContext: any): void;
+    };
+    new (props: Omit<BodyProps & import("../hoc/with-sorted-page-rows").TableProps, "pageRows">, context?: any): {
+        state: {
+            pageRows: never[];
+        };
+        componentDidMount(): void;
+        componentDidUpdate(_prevProps: Omit<BodyProps & import("../hoc/with-sorted-page-rows").TableProps, "pageRows">, prevState: {
+            pageRows: import("../types").RowType[];
+        }): void;
+        render(): JSX.Element;
+        context: any;
+        setState<K extends "pageRows">(state: {
+            pageRows: import("../types").RowType[];
+        } | ((prevState: Readonly<{
+            pageRows: import("../types").RowType[];
+        }>, props: Readonly<Omit<BodyProps & import("../hoc/with-sorted-page-rows").TableProps, "pageRows">>) => {
+            pageRows: import("../types").RowType[];
+        } | Pick<{
+            pageRows: import("../types").RowType[];
+        }, K> | null) | Pick<{
+            pageRows: import("../types").RowType[];
+        }, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callBack?: (() => void) | undefined): void;
+        readonly props: Readonly<Omit<BodyProps & import("../hoc/with-sorted-page-rows").TableProps, "pageRows">> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        shouldComponentUpdate?(nextProps: Readonly<Omit<BodyProps & import("../hoc/with-sorted-page-rows").TableProps, "pageRows">>, nextState: Readonly<{
+            pageRows: import("../types").RowType[];
+        }>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<Omit<BodyProps & import("../hoc/with-sorted-page-rows").TableProps, "pageRows">>, prevState: Readonly<{
+            pageRows: import("../types").RowType[];
+        }>): any;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<Omit<BodyProps & import("../hoc/with-sorted-page-rows").TableProps, "pageRows">>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Omit<BodyProps & import("../hoc/with-sorted-page-rows").TableProps, "pageRows">>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<Omit<BodyProps & import("../hoc/with-sorted-page-rows").TableProps, "pageRows">>, nextState: Readonly<{
+            pageRows: import("../types").RowType[];
+        }>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<Omit<BodyProps & import("../hoc/with-sorted-page-rows").TableProps, "pageRows">>, nextState: Readonly<{
+            pageRows: import("../types").RowType[];
+        }>, nextContext: any): void;
+    };
+    getDerivedStateFromProps(props: Omit<BodyProps & import("../hoc/with-sorted-page-rows").TableProps, "pageRows">, state: {
+        pageRows: import("../types").RowType[];
+    }): {
+        pageRows: import("../types").RowType[];
+    };
+    contextType?: React.Context<any> | undefined;
+};
+export default _default;

package/dist/types-ts4.5/components/loading-container-advanced.d.ts

@@ -0,0 +1,43 @@
+import React from 'react';
+import type { SpinnerSizeType } from '../types';
+export interface LoadingContainerAdvancedProps {
+    children: React.ReactElement<any>;
+    isLoading?: boolean;
+    spinnerSize?: SpinnerSizeType;
+    contentsOpacity: number | string;
+    targetRef?: () => HTMLDivElement | undefined;
+    testId?: string;
+}
+export default class LoadingContainerAdvanced extends React.Component<LoadingContainerAdvancedProps, {}> {
+    children?: HTMLElement;
+    spinnerRef?: HTMLDivElement;
+    static defaultProps: {
+        isLoading: boolean;
+        spinnerSize: string;
+        contentsOpacity: "var(--ds-opacity-loading)";
+    };
+    componentDidMount: () => void;
+    UNSAFE_componentWillReceiveProps: (nextProps: LoadingContainerAdvancedProps) => void;
+    componentDidUpdate: () => void;
+    componentWillUnmount: () => void;
+    getTargetNode: (nextProps?: LoadingContainerAdvancedProps) => Element | Text | null;
+    getThisNode: () => Element | Text | null;
+    getSpinnerNode: () => Element | Text | null;
+    hasTargetNode: (nextProps?: LoadingContainerAdvancedProps) => boolean;
+    isVerticallyVisible: (elementRect: {
+        top: number;
+        bottom: number;
+    }, viewportHeight: number) => boolean;
+    isFullyVerticallyVisible: (elementRect: {
+        top: number;
+        bottom: number;
+    }, viewportHeight: number) => boolean;
+    attachListeners(): void;
+    detachListeners(): void;
+    handleResize: () => void;
+    handleScroll: () => void;
+    translateSpinner: (spinnerNode: HTMLElement, transformY: number, isFixed?: boolean) => void;
+    updateTargetAppearance: () => void;
+    updateSpinnerPosition(): void;
+    render(): JSX.Element;
+}

package/dist/types-ts4.5/components/loading-container.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import type { SpinnerSizeType } from '../types';
+interface LoadingContainerProps {
+    children: React.ReactNode;
+    isLoading?: boolean;
+    spinnerSize?: SpinnerSizeType;
+    contentsOpacity: number;
+    testId?: string;
+}
+export default class LoadingContainer extends React.Component<LoadingContainerProps> {
+    static defaultProps: {
+        isLoading: boolean;
+        spinnerSize: string;
+        contentsOpacity: number;
+    };
+    render(): JSX.Element;
+}
+export {};

package/dist/types-ts4.5/components/managed-pagination.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { UIAnalyticsEvent } from '@atlaskit/analytics-next';
+import type { I18nShape } from '../types';
+interface ManagedPaginationProps {
+    value?: number;
+    onChange: (newValue: any, analyticsEvent?: UIAnalyticsEvent) => void;
+    total: number;
+    i18n?: I18nShape;
+    testId?: string;
+}
+export default class ManagedPagination extends React.Component<ManagedPaginationProps> {
+    onChange: (_event: any, newValue: any, analyticsEvent?: UIAnalyticsEvent) => void;
+    render(): JSX.Element;
+}
+export {};

package/dist/types-ts4.5/components/rankable/body.d.ts

@@ -0,0 +1,122 @@
+import React from 'react';
+import { DragStart, DropResult } from 'react-beautiful-dnd';
+import { WithSortedPageRowsProps } from '../../hoc/with-sorted-page-rows';
+import { HeadType, RankEnd, RankStart, RowType } from '../../types';
+export interface RankableBodyProps extends WithSortedPageRowsProps {
+    highlightedRowIndex?: number | number[];
+    onRankStart: (rankStart: RankStart) => void;
+    onRankEnd: (rankEnd: RankEnd) => void;
+    isFixedSize: boolean;
+    isRanking: boolean;
+    isRankingDisabled: boolean;
+    head?: HeadType;
+    testId?: string;
+}
+export declare class RankableBody extends React.Component<RankableBodyProps, {}> {
+    onBeforeDragStart: (dragStart: DragStart) => void;
+    onDragEnd: (result: DropResult) => void;
+    render(): JSX.Element;
+}
+declare const _default: {
+    new (props: Readonly<Omit<RankableBodyProps & import("../../hoc/with-sorted-page-rows").TableProps, "pageRows">>): {
+        state: {
+            pageRows: never[];
+        };
+        componentDidMount(): void;
+        componentDidUpdate(_prevProps: Omit<RankableBodyProps & import("../../hoc/with-sorted-page-rows").TableProps, "pageRows">, prevState: {
+            pageRows: RowType[];
+        }): void;
+        render(): JSX.Element;
+        context: any;
+        setState<K extends "pageRows">(state: {
+            pageRows: RowType[];
+        } | ((prevState: Readonly<{
+            pageRows: RowType[];
+        }>, props: Readonly<Omit<RankableBodyProps & import("../../hoc/with-sorted-page-rows").TableProps, "pageRows">>) => {
+            pageRows: RowType[];
+        } | Pick<{
+            pageRows: RowType[];
+        }, K> | null) | Pick<{
+            pageRows: RowType[];
+        }, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callBack?: (() => void) | undefined): void;
+        readonly props: Readonly<Omit<RankableBodyProps & import("../../hoc/with-sorted-page-rows").TableProps, "pageRows">> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        shouldComponentUpdate?(nextProps: Readonly<Omit<RankableBodyProps & import("../../hoc/with-sorted-page-rows").TableProps, "pageRows">>, nextState: Readonly<{
+            pageRows: RowType[];
+        }>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<Omit<RankableBodyProps & import("../../hoc/with-sorted-page-rows").TableProps, "pageRows">>, prevState: Readonly<{
+            pageRows: RowType[];
+        }>): any;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<Omit<RankableBodyProps & import("../../hoc/with-sorted-page-rows").TableProps, "pageRows">>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Omit<RankableBodyProps & import("../../hoc/with-sorted-page-rows").TableProps, "pageRows">>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<Omit<RankableBodyProps & import("../../hoc/with-sorted-page-rows").TableProps, "pageRows">>, nextState: Readonly<{
+            pageRows: RowType[];
+        }>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<Omit<RankableBodyProps & import("../../hoc/with-sorted-page-rows").TableProps, "pageRows">>, nextState: Readonly<{
+            pageRows: RowType[];
+        }>, nextContext: any): void;
+    };
+    new (props: Omit<RankableBodyProps & import("../../hoc/with-sorted-page-rows").TableProps, "pageRows">, context?: any): {
+        state: {
+            pageRows: never[];
+        };
+        componentDidMount(): void;
+        componentDidUpdate(_prevProps: Omit<RankableBodyProps & import("../../hoc/with-sorted-page-rows").TableProps, "pageRows">, prevState: {
+            pageRows: RowType[];
+        }): void;
+        render(): JSX.Element;
+        context: any;
+        setState<K extends "pageRows">(state: {
+            pageRows: RowType[];
+        } | ((prevState: Readonly<{
+            pageRows: RowType[];
+        }>, props: Readonly<Omit<RankableBodyProps & import("../../hoc/with-sorted-page-rows").TableProps, "pageRows">>) => {
+            pageRows: RowType[];
+        } | Pick<{
+            pageRows: RowType[];
+        }, K> | null) | Pick<{
+            pageRows: RowType[];
+        }, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callBack?: (() => void) | undefined): void;
+        readonly props: Readonly<Omit<RankableBodyProps & import("../../hoc/with-sorted-page-rows").TableProps, "pageRows">> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        shouldComponentUpdate?(nextProps: Readonly<Omit<RankableBodyProps & import("../../hoc/with-sorted-page-rows").TableProps, "pageRows">>, nextState: Readonly<{
+            pageRows: RowType[];
+        }>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<Omit<RankableBodyProps & import("../../hoc/with-sorted-page-rows").TableProps, "pageRows">>, prevState: Readonly<{
+            pageRows: RowType[];
+        }>): any;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<Omit<RankableBodyProps & import("../../hoc/with-sorted-page-rows").TableProps, "pageRows">>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Omit<RankableBodyProps & import("../../hoc/with-sorted-page-rows").TableProps, "pageRows">>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<Omit<RankableBodyProps & import("../../hoc/with-sorted-page-rows").TableProps, "pageRows">>, nextState: Readonly<{
+            pageRows: RowType[];
+        }>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<Omit<RankableBodyProps & import("../../hoc/with-sorted-page-rows").TableProps, "pageRows">>, nextState: Readonly<{
+            pageRows: RowType[];
+        }>, nextContext: any): void;
+    };
+    getDerivedStateFromProps(props: Omit<RankableBodyProps & import("../../hoc/with-sorted-page-rows").TableProps, "pageRows">, state: {
+        pageRows: RowType[];
+    }): {
+        pageRows: RowType[];
+    };
+    contextType?: React.Context<any> | undefined;
+};
+export default _default;

package/dist/types-ts4.5/components/rankable/table-cell.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { WithDimensionsProps } from '../../hoc/with-dimensions';
+import { HeadCellType, RowCellType } from '../../types';
+export interface RankableTableCellProps extends WithDimensionsProps {
+    head?: HeadCellType;
+    cell: RowCellType;
+    isFixedSize: boolean;
+    testId?: string;
+}
+export declare class RankableTableCell extends React.Component<RankableTableCellProps, {}> {
+    render(): JSX.Element;
+}
+declare const _default: React.ComponentClass<Omit<RankableTableCellProps, "innerRef" | "refWidth" | "refHeight">, import("../../hoc/with-dimensions").State>;
+export default _default;

package/dist/types-ts4.5/components/rankable/table-head-cell.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { WithDimensionsProps } from '../../hoc/with-dimensions';
+import { TableHeadCellProps } from '../table-head-cell';
+declare const _default: React.ComponentClass<Omit<WithDimensionsProps & TableHeadCellProps, "innerRef" | "refWidth" | "refHeight">, import("../../hoc/with-dimensions").State>;
+export default _default;

package/dist/types-ts4.5/components/rankable/table-row.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import { WithDimensionsProps } from '../../hoc/with-dimensions';
+import { HeadType, RowType } from '../../types';
+export interface RankableTableRowProps extends WithDimensionsProps {
+    head?: HeadType;
+    isFixedSize: boolean;
+    row: RowType;
+    rowIndex: number;
+    isRankingDisabled: boolean;
+    isHighlighted?: boolean;
+    testId?: string;
+}
+export declare class RankableTableRow extends React.Component<RankableTableRowProps> {
+    innerRef: (innerRefFn: Function) => (ref: HTMLTableRowElement) => void;
+    render(): JSX.Element;
+}
+declare const _default: React.ComponentClass<Omit<RankableTableRowProps, "innerRef" | "refWidth" | "refHeight">, import("../../hoc/with-dimensions").State>;
+export default _default;