@evergis/uilib-gl 1.0.0

package/dist/organisms/Slider/common/Label.d.ts

@@ -0,0 +1,12 @@
+import { ILabel } from "../types";
+export declare const Label: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {
+    style: {
+        transform: "translate(0, 50%)" | "translate(-50%, 0)";
+        bottom: string;
+        left?: undefined;
+    } | {
+        transform: "translate(0, 50%)" | "translate(-50%, 0)";
+        left: string;
+        bottom?: undefined;
+    };
+} & ILabel, "style">;

package/dist/organisms/Slider/common/Labels.d.ts

@@ -0,0 +1,3 @@
+import { FC } from "react";
+import { ILabels } from "../types";
+export declare const Labels: FC<ILabels>;

package/dist/organisms/Slider/common/LabelsContainer.d.ts

@@ -0,0 +1,2 @@
+import { ILabelsContainer } from "../types";
+export declare const LabelsContainer: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, ILabelsContainer, never>;

package/dist/organisms/Slider/common/LowerTrack.d.ts

@@ -0,0 +1,4 @@
+import { ILowerTrack } from "../types";
+export declare const LowerTrack: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, ILowerTrack, never>;
+export declare const LowerTrackBackground: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, ILowerTrack, never>;
+export declare const LowerTrackBorder: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, ILowerTrack, never>;

package/dist/organisms/Slider/common/Main.d.ts

@@ -0,0 +1,2 @@
+import { IMain } from "../types";
+export declare const Main: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, IMain, never>;

package/dist/organisms/Slider/common/Mark.d.ts

@@ -0,0 +1,37 @@
+import { IDragMark, IMark } from "../types";
+export declare const DefaultMark: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {
+    style: {
+        bottom: string | undefined;
+        left?: undefined;
+    } | {
+        left: string | undefined;
+        bottom?: undefined;
+    };
+} & IMark, "style">;
+export declare const Mark: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {
+    style: {
+        bottom: string | undefined;
+        left?: undefined;
+    } | {
+        left: string | undefined;
+        bottom?: undefined;
+    };
+} & IMark, "style">;
+export declare const ActiveMark: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {
+    style: {
+        bottom: string | undefined;
+        left?: undefined;
+    } | {
+        left: string | undefined;
+        bottom?: undefined;
+    };
+} & IMark, "style">;
+export declare const DragMarkContainer: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {
+    style: {
+        bottom: string | undefined;
+        left?: undefined;
+    } | {
+        left: string | undefined;
+        bottom?: undefined;
+    };
+} & IDragMark, "style">;

package/dist/organisms/Slider/common/Marks.d.ts

@@ -0,0 +1,3 @@
+import { FC } from "react";
+import { IMarks } from "../types";
+export declare const Marks: FC<IMarks>;

package/dist/organisms/Slider/common/MarksContainer.d.ts

@@ -0,0 +1,2 @@
+import { IMarksContainer } from "../types";
+export declare const MarksContainer: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, IMarksContainer, never>;

package/dist/organisms/Slider/common/Overlay.d.ts

@@ -0,0 +1 @@
+export declare const Overlay: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;

package/dist/organisms/Slider/common/SliderContainer.d.ts

@@ -0,0 +1,7 @@
+interface ISliderContainer {
+    vertical?: boolean;
+    isDragMarks?: boolean;
+    sliderWidth?: string | number;
+}
+export declare const SliderContainer: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, ISliderContainer, never>;
+export {};

package/dist/organisms/Slider/common/Tooltip.d.ts

@@ -0,0 +1,3 @@
+export declare const Tooltip: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {
+    tooltipPosition?: "top" | "bottom" | "right" | "left" | undefined;
+}, never>;

package/dist/organisms/Slider/common/Track.d.ts

@@ -0,0 +1,3 @@
+import { FC } from "react";
+import { ITrack } from "../types";
+export declare const Track: FC<ITrack>;

package/dist/organisms/Slider/common/TrackContainer.d.ts

@@ -0,0 +1,8 @@
+import { ITrackContainerProps } from "../types";
+export declare const DefaultTrack: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, ITrackContainerProps, never>;
+export declare const TrackContainer: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, ITrackContainerProps, never>;
+export declare const IntervalTrackContainer: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, ITrackContainerProps, never>;
+export declare const ActiveTrackContainer: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, ITrackContainerProps & {
+    isDragMarks?: boolean | undefined;
+}, never>;
+export declare const TrackTooltip: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, ITrackContainerProps, never>;

package/dist/organisms/Slider/common/Tracks.d.ts

@@ -0,0 +1,3 @@
+import { FC } from "react";
+import { ITracks } from "../types";
+export declare const Tracks: FC<ITracks>;

package/dist/organisms/Slider/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./Slider";
+export { Label as SliderLabel } from "./common/Label";
+export { HandleContainer as SliderHandle } from "./common/HandleContainer";
+export { LowerTrackBackground as SliderLowerTrackBackground } from "./common/LowerTrack";
+export { Track as SliderTrack } from "./common/Track";
+export * from "./types";

package/dist/organisms/Slider/types.d.ts

@@ -0,0 +1,257 @@
+import React, { ReactNode, MouseEvent, HTMLAttributes, CSSProperties } from "react";
+import { ITheme } from "../../theme/ITheme";
+export interface ISimpleSlider extends Required<Pick<ISliderProps, "showStepMarks" | "step" | "min" | "max" | "marks">> {
+    simpleValue: Required<ISliderProps<false>>["value"];
+    rangeValue: Required<ISliderProps<true>>["value"];
+    colorSchemeValue: string;
+    position: boolean;
+    showTooltips: boolean;
+    markLabels: boolean;
+    showMarks: boolean;
+    isDragMarks: boolean;
+    mark: number;
+    slider: string;
+    sliderWidth: number;
+    valuesOrder: boolean;
+    disableHandlersCrossing: boolean;
+    minRange: number;
+}
+export declare type Formatter = (value: number) => string;
+export declare type ISliderProps<IsRange extends boolean = boolean> = {
+    className?: string;
+    vertical?: boolean;
+    disabled?: boolean;
+    sliderWidth?: string | number;
+    showStepMarks?: boolean;
+    markLabels?: boolean;
+    showTooltips?: boolean;
+    primary?: boolean;
+    secondary?: boolean;
+    error?: boolean;
+    autoFocus?: boolean;
+    min?: number;
+    max?: number;
+    step?: number;
+    marks?: number[];
+    isDragMarks?: boolean;
+    labelFormatter?: Formatter;
+    tipFormatter?: Formatter;
+    tabIndex?: number[] | number;
+    lowerTrackBackground?: string;
+    range?: IsRange;
+    trackTooltip?: string;
+    tooltipPosition?: "top" | "bottom" | "right" | "left";
+    minRange?: number;
+    children?: ReactNode;
+    onChangeMarks?: (marks: number[]) => void;
+    /**
+     * Range slider option
+     * @name disableHandlersCrossing
+     * @description Allows to prevent crossing of left/right side handler more than right/left side handler
+     */
+    disableHandlersCrossing?: boolean;
+    /**
+     * Range slider option
+     * @name valuesOrder
+     * @description Output value always will have order of min max values.
+     */
+    valuesOrder?: boolean;
+} & SliderCommonType<IsRange>;
+declare type SliderCommonType<T extends boolean> = T extends true ? {
+    value: [number, number];
+    onChange?: (newValue: [number, number]) => void;
+    onStop?: (newValue: [number, number]) => void;
+} : T extends false | never | void ? {
+    value: number;
+    onChange?: (newValue: number) => void;
+    onStop?: (newValue: number) => void;
+} : {};
+export declare type SimpleValue = ISliderProps<false>["value"];
+export declare type RangeValue = ISliderProps<true>["value"];
+export interface IHandle {
+    vertical?: boolean;
+    colorScheme: {
+        primary?: boolean;
+        secondary?: boolean;
+        error?: boolean;
+    };
+    offset?: number;
+    disabled?: boolean;
+    tabIndex?: number;
+    onMouseDown?: (e: MouseEvent<HTMLDivElement>) => void;
+    onHandleRef?: (ref: HTMLDivElement) => void;
+    isDefaultTheme?: boolean;
+}
+export declare enum Handlers {
+    From = 0,
+    To = 1
+}
+export declare type Value = Required<ISliderProps>["value"];
+export declare type ProcessedValues = {
+    trimmedValueFrom: number;
+    trimmedValueTo: number;
+    offsetFrom: number;
+    offsetTo: number;
+    lowerBound: number;
+    upperBound: number;
+};
+export interface IHandleContainer {
+    disabled?: boolean;
+    primary?: boolean;
+    secondary?: boolean;
+    error?: boolean;
+    vertical?: boolean;
+    offset?: number;
+    isDefaultTheme?: boolean;
+}
+export interface ILabel {
+    vertical?: boolean;
+    left: string;
+    bottom: string;
+    isDragMarks?: boolean;
+    isHoverMark?: boolean;
+}
+export interface ILabels {
+    vertical?: boolean;
+    marks?: number[];
+    upperBound: number;
+    lowerBound: number;
+    max: number;
+    min: number;
+    step: number;
+    labelFormatter?: Formatter;
+    sliderWidth?: string | number;
+    showStepMarks?: boolean;
+    markLabels?: boolean;
+    hoverMark?: number | null;
+    isDragMarks?: boolean;
+}
+export interface ILabelsContainer {
+    vertical?: boolean;
+    isDragMarks?: boolean;
+    sliderWidth?: string | number;
+}
+export interface ILowerTrack {
+    vertical?: boolean;
+    showStepMarks?: boolean;
+    isDefaultTheme?: boolean;
+    disabled?: boolean;
+    lowerTrackBackground?: string;
+    theme: ITheme;
+}
+export interface IMain {
+    disabled?: boolean;
+    vertical?: boolean;
+    sliderWidth?: number | string;
+    showStepMarks?: boolean;
+    isDefaultTheme?: boolean;
+    lowerTrackBackground?: string;
+    isDragMarks?: boolean;
+}
+export interface IMark extends HTMLAttributes<HTMLDivElement> {
+    primary?: boolean;
+    secondary?: boolean;
+    error?: boolean;
+    vertical: boolean;
+    offset: string;
+}
+export interface IDragMark extends IMark {
+    style?: CSSProperties;
+    closable?: boolean;
+    disabled?: boolean;
+    onRemove?: VoidFunction;
+}
+export interface IMarks {
+    vertical: boolean;
+    marks?: number[];
+    isDragMarks?: boolean;
+    step: number;
+    lowerBound: number;
+    upperBound: number;
+    max: number;
+    min: number;
+    isDefaultTheme: boolean;
+    disabled?: boolean;
+    showStepMarks?: boolean;
+    activeMark?: number | null;
+    hoverMark?: number | null;
+    colorScheme: {
+        primary?: boolean;
+        secondary?: boolean;
+        error?: boolean;
+    };
+    onAdd?: (point: number) => void;
+    onRemove?: (point: number) => void;
+    onMouseDown?: (e: React.MouseEvent<HTMLSpanElement>, point: number) => void;
+    onMouseOver?: (e: React.MouseEvent<HTMLSpanElement>) => void;
+    onKeyDown?: (e: React.KeyboardEvent<HTMLSpanElement>) => void;
+}
+export interface IMarksContainer {
+    vertical: boolean;
+    showStepMarks?: boolean;
+}
+export interface ITrack {
+    className?: string;
+    vertical?: boolean;
+    offset?: number;
+    length?: number;
+    colorScheme?: {
+        primary?: boolean;
+        secondary?: boolean;
+        error?: boolean;
+    };
+    disabled?: boolean;
+    showStepMarks?: boolean;
+    itemsAmount?: number;
+    index?: number;
+    max?: number;
+    step?: number;
+    min?: number;
+    lowerBound: number;
+    upperBound: number;
+    point: number;
+    range?: boolean;
+    tooltip?: string;
+    isDefaultTheme?: boolean;
+    isDragMarks?: boolean;
+}
+export interface ITrackContainerProps {
+    primary?: boolean;
+    secondary?: boolean;
+    error?: boolean;
+    disabled?: boolean;
+    vertical?: boolean;
+    isDefaultTheme?: boolean;
+    isDragMarks?: boolean;
+    showStepMarks?: boolean;
+    theme?: any;
+    offset?: number;
+    length?: number;
+    size?: string;
+    position?: string;
+    range?: boolean;
+}
+export interface ITracks {
+    showStepMarks?: boolean;
+    vertical?: boolean;
+    disabled?: boolean;
+    isDefaultTheme?: boolean;
+    offset?: number;
+    min?: number;
+    max?: number;
+    step?: number;
+    colorScheme: {
+        primary?: boolean;
+        secondary?: boolean;
+        error?: boolean;
+    };
+    point?: number;
+    length?: number;
+    range?: boolean;
+    lowerBound: number;
+    upperBound: number;
+    tooltip?: string;
+    className?: string;
+    isDragMarks?: boolean;
+}
+export {};

package/dist/organisms/Slider/utils.d.ts

@@ -0,0 +1,42 @@
+import React from "react";
+import { ISliderProps, SimpleValue, RangeValue } from "./types";
+export declare function isEventFromHandle(e: MouseEvent | TouchEvent | React.MouseEvent<HTMLDivElement>, handles: HTMLDivElement[]): boolean;
+export declare function getMousePosition(e: MouseEvent | React.MouseEvent<HTMLDivElement>, vertical?: boolean): number;
+export declare function getTouchPosition(e: TouchEvent | React.TouchEvent<HTMLDivElement>, vertical?: boolean): number;
+export declare function getPosition(e: MouseEvent | TouchEvent | React.MouseEvent<HTMLDivElement>, vertical?: boolean): number;
+export declare function ensureValueInRange(value: number, { max, min }: {
+    max: number;
+    min: number;
+}): number;
+export declare function ensureValuePrecision(value: number, { step, min }: {
+    step: number;
+    min: number;
+}): number;
+export declare const getSliderWidth: (vertical: boolean, sliderWidth?: string | number | undefined, defaultHeight?: number | string) => import("styled-components").FlattenSimpleInterpolation;
+export declare const getIntervals: (min: number, max: number, step: number) => number[];
+export declare function pauseEvent(e: MouseEvent | TouchEvent | React.KeyboardEvent<HTMLDivElement> | React.MouseEvent<HTMLDivElement>): void;
+export declare function isOutOfRange(value: SimpleValue, { min, max }: Pick<ISliderProps, "min" | "max">): boolean;
+export declare function isValueOutOfRange(value: ISliderProps["value"], minMax: Pick<ISliderProps, "min" | "max">): boolean;
+declare type ValueMutatorProps = {
+    step?: number;
+    max?: number;
+    min?: number;
+};
+export declare function getKeyboardValueMutator(e: React.KeyboardEvent<HTMLDivElement>): (value: number, props: ValueMutatorProps) => number;
+export declare function isNotTouchEvent(e: React.TouchEvent<HTMLDivElement> | TouchEvent): e is React.TouchEvent<HTMLDivElement>;
+export declare function getSliderLength(vertical: boolean, node: HTMLDivElement): number;
+export declare function getSliderStart(vertical: boolean, node: HTMLDivElement): number;
+export declare function calcValue(offset: number, { min, max, vertical, node }: {
+    min: number;
+    max: number;
+    vertical: boolean;
+    node: HTMLDivElement;
+}): number;
+export declare function calcOffset(value: number, { min, max }: {
+    min: number;
+    max: number;
+}): number;
+export declare function compareRangeValues(prevValues: RangeValue, currValues: RangeValue): boolean;
+export declare function trimAlignValue<V extends [number, number] | number>(value: V, options: Pick<ISliderProps, "step" | "min" | "max">): V;
+export declare function calcValueByPos(position: number, options: ISliderProps, slider: HTMLDivElement | null): number;
+export {};

package/dist/organisms/SliderPopover/SliderPopover.d.ts

@@ -0,0 +1,3 @@
+import { FC } from "react";
+import { SliderPopoverProps } from "./types";
+export declare const SliderPopover: FC<SliderPopoverProps>;

package/dist/organisms/SliderPopover/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./SliderPopover";
+export * from "./types";

package/dist/organisms/SliderPopover/styled.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+export declare const SliderContainer: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, import("../../atoms/Blank").IBlankProps, never>;
+export declare const Slider: import("styled-components").StyledComponent<import("react").FC<import("../Slider").ISliderProps<boolean>>, import("styled-components").DefaultTheme, {}, never>;

package/dist/organisms/SliderPopover/types.d.ts

@@ -0,0 +1,10 @@
+import { ReactNode } from "react";
+import { PopoverProps } from "../Popover";
+import { ISliderProps } from "../Slider";
+export declare type SliderPopoverProps = PopoverProps & Pick<ISliderProps, "min" | "max" | "step" | "primary" | "secondary" | "error"> & {
+    width?: string;
+    sliderValue: ISliderProps<false>["value"];
+    onSliderChange: ISliderProps<false>["onChange"];
+    sliderWidth?: string;
+    children?: ReactNode;
+};

package/dist/organisms/Stepper/Step.d.ts

@@ -0,0 +1,3 @@
+import { FC } from "react";
+import { StepProps } from "./types";
+export declare const Step: FC<StepProps>;

package/dist/organisms/Stepper/StepLevel.d.ts

@@ -0,0 +1,3 @@
+import { FC } from "react";
+import { StepLevelProps } from "./types";
+export declare const StepLevel: FC<StepLevelProps>;

package/dist/organisms/Stepper/Stepper.d.ts

@@ -0,0 +1,3 @@
+import { FC } from "react";
+import { StepperProps } from "./types";
+export declare const Stepper: FC<StepperProps>;

package/dist/organisms/Stepper/hooks/useLevelDivider.d.ts

@@ -0,0 +1,3 @@
+import { ReactNode } from "react";
+import { LevelDividerResponse } from "../types";
+export declare const useLevelDivider: (stepHeader: string | ReactNode) => LevelDividerResponse;

package/dist/organisms/Stepper/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Stepper";
+export * from "./types";

package/dist/organisms/Stepper/styled.d.ts

@@ -0,0 +1,15 @@
+export declare const StepTitle: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, import("../../atoms/Grid").IFlexProps, never>;
+export declare const StepHeaderText: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {
+    isFinished?: boolean | undefined;
+    isLast?: boolean | undefined;
+}, never>;
+export declare const StepHeaderComponent: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
+export declare const StepLevelContainer: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {
+    isLast?: boolean | undefined;
+    isFinished?: boolean | undefined;
+    disabled?: boolean | undefined;
+}, never>;
+export declare const StepComponent: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
+export declare const Divider: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {
+    height: number;
+}, never>;

package/dist/organisms/Stepper/types.d.ts

@@ -0,0 +1,24 @@
+import React from "react";
+export declare type StepProps = StepLevelType & {
+    stepNumber: number;
+};
+export declare type StepperProps = {
+    steps: StepLevelType[];
+};
+export declare type StepLevelType = {
+    stepHeader: string | React.ReactNode;
+    component?: React.ReactNode;
+    isLast?: boolean;
+    isFinished?: boolean;
+    disabled?: boolean;
+};
+export declare type StepLevelProps = {
+    stepNumber: number;
+    isLast?: boolean;
+    isFinished?: boolean;
+    disabled?: boolean;
+};
+export declare type LevelDividerResponse = {
+    stepRef: React.RefObject<HTMLEmbedElement>;
+    dividerHeight: number;
+};

package/dist/organisms/SymbolLibrary/Groups.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { IGroupProps } from "./types";
+export declare const Groups: <S, _>({ library, getSymbol, onSymbolSelect }: IGroupProps<S>) => JSX.Element;

package/dist/organisms/SymbolLibrary/SymbolLibrary.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { ISymbolLibraryProps } from "./types";
+export declare const SymbolLibrary: <S, _>({ anchor, isOpen, onRequestClose, symbolsInRow, library, onSymbolSelect, getSymbol, zIndex, children, innerRef, className, anchorOrigin, targetOrigin, selectSymbolText, }: ISymbolLibraryProps<S>) => JSX.Element;

package/dist/organisms/SymbolLibrary/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./SymbolLibrary";
+export * from "./types";

package/dist/organisms/SymbolLibrary/styled.d.ts

@@ -0,0 +1,8 @@
+export declare const Blank: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, import("../../atoms/Blank").IBlankProps & {
+    symbolsInRow: number;
+}, never>;
+export declare const Header: import("styled-components").StyledComponent<"h3", import("styled-components").DefaultTheme, {}, never>;
+export declare const SymbolsContainer: import("styled-components").StyledComponent<"span", import("styled-components").DefaultTheme, {}, never>;
+export declare const Description: import("styled-components").StyledComponent<"p", import("styled-components").DefaultTheme, {}, never>;
+export declare const Symbols: import("styled-components").StyledComponent<"span", import("styled-components").DefaultTheme, {}, never>;
+export declare const IconContainer: import("styled-components").StyledComponent<"span", import("styled-components").DefaultTheme, {}, never>;

package/dist/organisms/SymbolLibrary/types.d.ts

@@ -0,0 +1,34 @@
+import { ReactNode } from "react";
+import { IconTypesKeys } from "../../atoms/Icon";
+import { Origin } from "../Popover";
+export interface IGroupProps<S = string> {
+    onSymbolSelect: (symbol: ISymbol<S>) => void;
+    library: ILibGroup<S>[];
+    getSymbol: (symbol: ISymbol<S>) => JSX.Element;
+}
+export interface ILibGroup<S = string> {
+    id: string | number;
+    name: string;
+    symbols: ISymbol<S>[];
+}
+export interface ISymbol<S = string> {
+    id: string;
+    name: string;
+    symbol?: S;
+}
+export interface ISymbolGroupProps<S = string> extends Omit<IGroupProps<S>, "library"> {
+    symbols: ISymbol<S>[];
+}
+export interface ISymbolLibraryProps<S> extends IGroupProps<S> {
+    anchor: IconTypesKeys;
+    isOpen?: boolean;
+    onRequestClose: () => void;
+    symbolsInRow?: number;
+    zIndex?: number;
+    children?: ReactNode;
+    innerRef?: (node: HTMLElement | null) => void;
+    className?: string;
+    anchorOrigin?: Origin;
+    targetOrigin?: Origin;
+    selectSymbolText?: string;
+}

package/dist/organisms/Table/HeaderCell.d.ts

@@ -0,0 +1,3 @@
+import { FC } from "react";
+import { HeaderCellProps } from "./types";
+export declare const HeaderCell: FC<HeaderCellProps>;

package/dist/organisms/Table/Table.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import { TableProps } from "./types";
+export declare const Table: React.FC<TableProps>;

package/dist/organisms/Table/TableBody.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+import { SpecialColumn, TableProps } from "./types";
+declare type TableBodyProps = Pick<TableProps, "columns" | "data" | "menuOptions" | "onMenuSelect" | "onRowClick" | "onSelect" | "selectedData" | "excludedData" | "pageSize" | "currentPage"> & {
+    special?: SpecialColumn["render"];
+    showSpecial?: boolean;
+    showTable?: boolean;
+    isPaginationOn?: boolean;
+};
+export declare const TableBody: React.FC<TableBodyProps>;
+export {};

package/dist/organisms/Table/TableColGroup.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+import { Column, TableColumnParam, SpecialColumn, TableProps } from "./types";
+declare type TableColGroupProps = Pick<TableProps, "onSelect"> & {
+    columns: Column[];
+    columnParams: TableColumnParam[];
+    specialWidth?: SpecialColumn["width"];
+};
+export declare const TableColGroup: React.FC<TableColGroupProps>;
+export {};

package/dist/organisms/Table/TableHead.d.ts

@@ -0,0 +1,12 @@
+import React from "react";
+import { BodyScrollParams, Column, TableProps, SpecialColumn } from "./types";
+declare type TableHeadProps = Pick<TableProps, "columns" | "filtersOn" | "onSelect" | "selectedData" | "data" | "excludedData"> & {
+    bodyScroll: BodyScrollParams;
+    resizeRefs: React.RefObject<HTMLDivElement>[];
+    children?: (content: Column) => React.ReactNode;
+    special?: SpecialColumn["header"];
+    showSpecial?: boolean;
+    renderMenu?: React.ReactNode;
+};
+export declare const TableHead: React.FC<TableHeadProps>;
+export {};

package/dist/organisms/Table/TableRow.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+import { Row, SpecialColumn, TableProps } from "./types";
+export declare type TableRowProps = Pick<TableProps, "onRowClick" | "columns" | "menuOptions" | "onMenuSelect" | "excludedData"> & {
+    row: Row;
+    selected: boolean;
+    rowIndex: number;
+    showSpecial?: boolean;
+    special?: SpecialColumn["render"];
+    onSelect?: (id: string | number) => void;
+};
+export declare const TableRow: React.NamedExoticComponent<TableRowProps>;

package/dist/organisms/Table/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const DEFAULT_COLUMN_WIDTH = 200;
+export declare const DEFAULT_SPECIAL_WIDTH = 42;
+export declare const DEFAULT_SELECT_WIDTH = 32;

package/dist/organisms/Table/generateData.d.ts

@@ -0,0 +1,5 @@
+import { Column, Row } from "./types";
+export declare function generateData(columnsCount: number | undefined, rowsCount: number | undefined, customRow: string, customTd: string): {
+    data: Row[];
+    columns: Column[];
+};