re-resizable

constructor(props: ResizableProps);

appendBase: () => HTMLDivElement | null;

static defaultProps: {
    as: string;
    onResizeStart: () => void;
    onResize: () => void;
    onResizeStop: () => void;
    enable: {
        top: boolean;
        right: boolean;
        bottom: boolean;
        left: boolean;
        topRight: boolean;
        bottomRight: boolean;
        bottomLeft: boolean;
        topLeft: boolean;
    };
    style: {};
    grid: number[];
    lockAspectRatio: boolean;
    lockAspectRatioExtraWidth: number;
    lockAspectRatioExtraHeight: number;
    scale: number;
    resizeRatio: number;
    snapGap: number;
};

flexDir?: 'row' | 'column';

parentLeft: number;

readonly parentNode: HTMLElement;

parentTop: number;

readonly propsSize: Size;

ratio: number;

removeBase: (base: HTMLElement) => void;

resizable: HTMLElement;

resizableBottom: number;

resizableLeft: number;

resizableRight: number;

resizableTop: number;

readonly size: NumberSize;

readonly sizeStyle: { width: string; height: string };

targetLeft: number;

targetTop: number;

readonly window: Window;

bindEvents: () => void;

calculateNewMaxFromBoundary: (
    maxWidth?: number,
    maxHeight?: number
) => { maxWidth: number | undefined; maxHeight: number | undefined };

calculateNewSizeFromAspectRatio: (
    newWidth: number,
    newHeight: number,
    max: { width?: number; height?: number },
    min: { width?: number; height?: number }
) => { newWidth: number; newHeight: number };

calculateNewSizeFromDirection: (
    clientX: number,
    clientY: number
) => { newWidth: number; newHeight: number };

componentDidMount: () => void;

componentWillUnmount: () => void;

createSizeForCssProperty: (
    newSize: number | string,
    kind: 'width' | 'height'
) => number | string;

getParentSize: () => { width: number; height: number };

onMouseMove: (event: MouseEvent | TouchEvent) => void;

onMouseUp: (event: MouseEvent | TouchEvent) => void;

onResizeStart: (
    event: React.MouseEvent<HTMLElement> | React.TouchEvent<HTMLElement>,
    direction: Direction
) => void;

render: () => JSX.Element;

renderResizer: () => JSX.Element | null;

setBoundingClientRect: () => void;

unbindEvents: () => void;

updateSize: (size: Size) => void;

bottom?: boolean;

bottomLeft?: boolean;

bottomRight?: boolean;

left?: boolean;

right?: boolean;

top?: boolean;

topLeft?: boolean;

topRight?: boolean;

bottom?: string;

bottomLeft?: string;

bottomRight?: string;

left?: string;

right?: string;

top?: string;

topLeft?: string;

topRight?: string;

bottom?: React.ReactElement<any>;

bottomLeft?: React.ReactElement<any>;

bottomRight?: React.ReactElement<any>;

left?: React.ReactElement<any>;

right?: React.ReactElement<any>;

top?: React.ReactElement<any>;

topLeft?: React.ReactElement<any>;

topRight?: React.ReactElement<any>;

bottom?: React.CSSProperties;

bottomLeft?: React.CSSProperties;

bottomRight?: React.CSSProperties;

left?: React.CSSProperties;

right?: React.CSSProperties;

top?: React.CSSProperties;

topLeft?: React.CSSProperties;

topRight?: React.CSSProperties;

height: number;

width: number;

as?: string | React.ComponentType<any>;

bounds?: 'parent' | 'window' | HTMLElement;

boundsByDirection?: boolean;

children?: React.ReactNode;

className?: string;

defaultSize?: Size;

enable?: Enable | false;

grid?: [number, number];

handleClasses?: HandleClassName;

handleComponent?: HandleComponent;

handleStyles?: HandleStyles;

handleWrapperClass?: string;

handleWrapperStyle?: React.CSSProperties;

lockAspectRatio?: boolean | number;

lockAspectRatioExtraHeight?: number;

lockAspectRatioExtraWidth?: number;

maxHeight?: string | number;

maxWidth?: string | number;

minHeight?: string | number;

minWidth?: string | number;

onResize?: ResizeCallback;

onResizeStart?: ResizeStartCallback;

onResizeStop?: ResizeCallback;

resizeRatio?: number | [number, number];

scale?: number;

size?: Size;

snap?: {
    x?: number[];
    y?: number[];
};

snapGap?: number;

style?: React.CSSProperties;

height?: string | number;

width?: string | number;