@oliasoft-open-source/react-ui-library 3.12.0-beta-11 → 3.12.0-beta-13

package/dist/components/rich-text-input/rich-text-toolbar/enum.d.ts

@@ -0,0 +1,7 @@
+export declare enum RichTextIcon {
+    BOLD = "bold",
+    ITALIC = "italic",
+    CODE = "code",
+    UL = "ul",
+    OL = "ol"
+}

package/dist/components/rich-text-input/rich-text-toolbar/rich-text-toolbar.d.ts

@@ -0,0 +1,6 @@
+import React, { ReactNode } from 'react';
+export interface IRichTextToolbarProps {
+    disabled?: boolean;
+    toolbarComponent?: ReactNode;
+}
+export declare const RichTextToolbar: ({ disabled, toolbarComponent, }: IRichTextToolbarProps) => React.JSX.Element;

package/dist/components/select/custom-select/custom-select.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import { ICustomSelectProps } from "./custom-select.interface";
+export declare const CustomSelect: (props: ICustomSelectProps) => React.JSX.Element;

package/dist/components/select/custom-select/custom-select.interface.d.ts

@@ -0,0 +1,47 @@
+import { ChangeEvent, ReactNode } from 'react';
+import { ISelectSelectedOption } from '../select.interface';
+import { GroupOrder } from "../../../common-enum";
+interface Heading {
+    label: string | number;
+    type: string;
+}
+export type TCustomSelectSelectOption = ISelectSelectedOption | Heading;
+export type TSelectedOptionsIndexType = keyof ISelectSelectedOption;
+export type ICustomSelectOptionType = {
+    createAble?: boolean;
+    label?: string;
+    value?: string | number;
+    disabled?: boolean;
+    details?: string;
+};
+export type ICustomSelectScrollableComponent = {
+    scrollToItem: (index: number) => void;
+};
+export interface ICustomSelectProps {
+    multi?: boolean;
+    disabled?: boolean;
+    error?: string | number | ReactNode;
+    warning?: string | number | ReactNode;
+    tooltip?: string | number | ReactNode;
+    options: TCustomSelectSelectOption[];
+    selectedOptions: ISelectSelectedOption | ISelectSelectedOption[];
+    onChange?: (event: ChangeEvent<HTMLInputElement>, newSelectedOptions: ISelectSelectedOption) => void;
+    onCreate?: (value: string) => void;
+    placeholder?: string;
+    small?: boolean;
+    tabIndex?: number;
+    width?: string | number | null;
+    autoLayerWidth?: boolean;
+    onFocus?: () => void;
+    onBlur?: () => void;
+    searchable?: boolean;
+    clearable?: boolean;
+    isInTable?: boolean;
+    groupOrder?: GroupOrder;
+    firstSelectedOptionIndex: number | null;
+    right?: boolean;
+    maxTooltipWidth?: string | number;
+    closeOnOptionActionClick?: boolean;
+    testId?: string | undefined;
+}
+export {};

package/dist/components/select/custom-select/custom-select.reducer.d.ts

@@ -0,0 +1,6 @@
+import { ICustomSelectAction, ICustomSelectDirection, ICustomSelectLayerFocus, ICustomSelectState, ICustomSelectTriggerFocus } from "./reducer.interface";
+import { TCustomSelectSelectOption } from "./custom-select.interface";
+export declare const initialTriggerFocus: ICustomSelectTriggerFocus;
+export declare const initialLayerFocus: (options: TCustomSelectSelectOption[], firstSelectedOptionIndex: number) => ICustomSelectLayerFocus;
+export declare const nextLayerFocus: (direction: ICustomSelectDirection, layerFocus: ICustomSelectLayerFocus) => ICustomSelectLayerFocus;
+export declare const reducer: (state: ICustomSelectState, action: ICustomSelectAction) => ICustomSelectState;

package/dist/components/select/custom-select/enum.d.ts

@@ -0,0 +1,11 @@
+export declare enum ReducerAction {
+    SET_VISIBLE_OPTIONS = "SET_VISIBLE_OPTIONS",
+    RESET_LAYER_FOCUS = "RESET_LAYER_FOCUS",
+    CLEAR_SEARCH = "CLEAR_SEARCH",
+    ON_CHANGE_SEARCH = "ON_CHANGE_SEARCH",
+    FOCUS_TRIGGER_INPUTS = "FOCUS_TRIGGER_INPUTS",
+    BLUR_TRIGGER_INPUTS = "BLUR_TRIGGER_INPUTS",
+    FOCUS_LAYER_OPTIONS = "FOCUS_LAYER_OPTIONS",
+    OPEN_LAYER = "OPEN_LAYER",
+    CLOSE_LAYER = "CLOSE_LAYER"
+}

package/dist/components/select/custom-select/helper.d.ts

@@ -0,0 +1,3 @@
+import { ISelectSelectedOption } from '../select.interface';
+export declare const getWidestOptionWidth: (options: ISelectSelectedOption[], small: boolean, isFontLoaded: boolean, placeholder?: string) => number;
+export declare const getMultiOptionWidth: (option: ISelectSelectedOption, small?: boolean, isFontLoaded?: boolean) => number;

package/dist/components/select/custom-select/hooks/enum.d.ts

@@ -0,0 +1,20 @@
+export declare enum ActionTypes {
+    CLOSE_LAYER = "CLOSE_LAYER",
+    OPEN_LAYER = "OPEN_LAYER",
+    SET_VISIBLE_OPTIONS = "SET_VISIBLE_OPTIONS",
+    CLEAR_SEARCH = "CLEAR_SEARCH",
+    RESET_LAYER_FOCUS = "RESET_LAYER_FOCUS",
+    FOCUS_LAYER_OPTIONS = "FOCUS_LAYER_OPTIONS",
+    BLUR_TRIGGER_INPUTS = "BLUR_TRIGGER_INPUTS",
+    FOCUS_TRIGGER_INPUTS = "FOCUS_TRIGGER_INPUTS",
+    ON_CHANGE_SEARCH = "ON_CHANGE_SEARCH"
+}
+export declare enum EventKey {
+    RIGHT = "right",
+    LEFT = "left",
+    UP = "up",
+    DOWN = "down",
+    ENTER = "enter",
+    ESC = "esc",
+    TAB = "tab"
+}

package/dist/components/select/custom-select/hooks/use-custom-select-logic.d.ts

@@ -0,0 +1,39 @@
+import React, { ChangeEvent } from "react";
+import { ISelectSelectedOption } from "../../select.interface";
+import { ICustomSelectDirection, ICustomSelectState } from "../reducer.interface";
+import { TCustomSelectSelectOption } from "../custom-select.interface";
+export interface UseCustomSelectLogicProps {
+    state: ICustomSelectState;
+    dispatch: (action: any) => void;
+    options: TCustomSelectSelectOption[];
+    setTriggerFocus: () => void;
+    disabled: boolean;
+    disabledContext: boolean;
+    onCreate: ((value: string) => void) | null;
+    onChange: ((evt: any, selected: any) => void) | null;
+    selectedOptions: ISelectSelectedOption | ISelectSelectedOption[];
+    width: string | number | null;
+    small: boolean;
+    isFontLoaded: boolean;
+    placeholder: string;
+    firstSelectedOptionIndex: number;
+    createAble: boolean;
+    listRef: React.RefObject<any>;
+    autoLayerWidth: boolean;
+}
+export declare const useCustomSelectLogic: ({ state, dispatch, options, setTriggerFocus, disabled, disabledContext, onCreate, onChange, selectedOptions, width, small, isFontLoaded, placeholder, firstSelectedOptionIndex, createAble, listRef, autoLayerWidth, }: UseCustomSelectLogicProps) => {
+    getTriggerWidth: () => string | number;
+    onKeyEvent: (key: string | ICustomSelectDirection, evt: KeyboardEvent) => void;
+    clearAllIsFocused: boolean;
+    triggerProps: import("react-laag").TriggerProps;
+    onClickTrigger: () => void;
+    onChangeSearch: (value: any) => void;
+    onClickDeselectOption: (evt: any, options?: any) => void;
+    onClickClearAll: (evt: ChangeEvent<any>) => void;
+    renderLayer: (children: React.ReactNode) => React.ReactPortal | null;
+    layerProps: import("react-laag").LayerProps;
+    closeLayer: () => void;
+    onSelectOption: (evt: any, option?: any, close?: () => void) => void;
+    getLayerWidth: (triggerBounds: any) => any;
+    triggerBounds: ClientRect | null;
+};

package/dist/components/select/custom-select/layer/heading.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+export declare const Heading: ({ label }: {
+    label: string | number;
+}) => React.JSX.Element;

package/dist/components/select/custom-select/layer/layer.d.ts

@@ -0,0 +1,17 @@
+import React, { RefObject } from 'react';
+import { ISelectSection } from './section';
+import { ISelectSelectedOption } from '../../select.interface';
+export interface ISelectLayerProps {
+    listRef: RefObject<any>;
+    isMulti?: boolean;
+    sections: ISelectSection[];
+    selectedOptions: ISelectSelectedOption | ISelectSelectedOption[];
+    onSelectOption: (event?: React.MouseEvent<HTMLDivElement, MouseEvent>, section?: ISelectSection) => void;
+    focusedOptionIndex?: number;
+    width: number;
+    small?: boolean;
+    firstSelectedOptionIndex?: number;
+    closeLayer: () => void;
+    testId?: string;
+}
+export declare const Layer: ({ listRef, isMulti, sections, selectedOptions, onSelectOption, focusedOptionIndex, width, small, firstSelectedOptionIndex, closeLayer, testId, }: ISelectLayerProps) => React.JSX.Element;

package/dist/components/select/custom-select/layer/option.d.ts

@@ -0,0 +1,15 @@
+import React, { ReactNode } from 'react';
+import { ISelectSectionProps } from './section';
+export interface ISelectOptionProps {
+    details?: string;
+    label: string;
+    icon?: ReactNode;
+    disabled?: boolean;
+    selected?: boolean;
+    focused?: boolean;
+    onSelectOption?: (event?: React.MouseEvent<HTMLDivElement, MouseEvent>, section?: ISelectSectionProps) => void;
+    actions?: any[];
+    closeLayer?: () => void;
+    testId?: string;
+}
+export declare const Option: ({ details, label, icon, disabled, selected, focused, onSelectOption, actions, closeLayer, testId, }: ISelectOptionProps) => React.JSX.Element;

package/dist/components/select/custom-select/layer/placementOptions.d.ts

@@ -0,0 +1,10 @@
+type PlacementType = 'bottom-start' | 'top-start';
+export interface PlacementOptions {
+    auto: boolean;
+    possiblePlacements: PlacementType[];
+    placement: PlacementType;
+    preferX: 'right';
+    preferY: 'bottom';
+}
+export declare const placementOptions: PlacementOptions;
+export {};

package/dist/components/select/custom-select/layer/section.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { ISelectOptionProps } from './option';
+import { MenuType } from "../../../menu/enum";
+export interface ISelectSection extends ISelectOptionProps {
+    type: MenuType.HEADING | MenuType.OPTION;
+    value?: string | number;
+}
+export type ISelectSectionProps = {
+    section: ISelectSection;
+    selected?: boolean;
+    focused?: boolean;
+    onSelectOption?: (event?: React.MouseEvent<HTMLDivElement, MouseEvent>, section?: ISelectSectionProps) => void;
+    closeLayer?: () => void;
+};
+export declare const Section: ({ section, selected, focused, onSelectOption, closeLayer, }: ISelectSectionProps) => React.JSX.Element;

package/dist/components/select/custom-select/reducer.interface.d.ts

@@ -0,0 +1,34 @@
+import { ICustomSelectOptionType } from './custom-select.interface';
+import { ReducerAction } from "./enum";
+export type ICustomSelectDirection = 'right' | 'left' | 'up' | 'down';
+export interface ICustomSelectTriggerFocus {
+    options: Array<'none' | 'clearAll' | number>;
+    currentIndex: number;
+    currentOption: boolean | 'none' | 'clearAll' | number;
+    clearAll: boolean;
+}
+export interface ICustomSelectLayerFocus {
+    options: (number | 'none')[];
+    currentIndex: number;
+    current: number | 'none';
+}
+export interface ICustomSelectState {
+    visibleOptions?: ICustomSelectOptionType[];
+    searchValue?: string;
+    layerFocus: ICustomSelectLayerFocus;
+    triggerFocus: ICustomSelectTriggerFocus;
+    isLayerOpen?: boolean;
+}
+export interface ICustomSelectAction {
+    type: ReducerAction;
+    options?: ICustomSelectOptionType[];
+    firstSelectedOptionIndex: number;
+    value?: string;
+    createAble?: boolean;
+    direction?: ICustomSelectDirection;
+    selectedOptions?: Array<string | number | {
+        label: string | number;
+        value: string | number | boolean;
+    }>;
+    nextLayerFocus?: ICustomSelectLayerFocus;
+}

package/dist/components/select/custom-select/trigger/input.d.ts

@@ -0,0 +1,14 @@
+import React, { MutableRefObject, ReactNode } from 'react';
+import { ISelectSelectedOption } from '../../select.interface';
+interface ISelectInputProps {
+    selectedOptions?: ISelectSelectedOption | ISelectSelectedOption[];
+    searchable?: boolean;
+    searchValue?: string;
+    inputRef: MutableRefObject<HTMLInputElement | null>;
+    onChange?: (value: string) => void;
+    error?: string | ReactNode;
+    placeholder?: string;
+    small?: boolean;
+}
+export declare const Input: ({ selectedOptions, searchable, searchValue, onChange, inputRef, error, placeholder, small, }: ISelectInputProps) => React.JSX.Element;
+export {};

package/dist/components/select/custom-select/trigger/multi-selected-options.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { ISelectSelectedOption } from '../../select.interface';
+interface ISelectMultiSelectedOptionsProps {
+    selectedOptions: ISelectSelectedOption[];
+    small?: boolean;
+    width: number;
+}
+export declare const MultiSelectedOptions: ({ selectedOptions, small, width }: ISelectMultiSelectedOptionsProps) => React.JSX.Element;
+export {};

package/dist/components/select/custom-select/trigger/trigger.d.ts

@@ -0,0 +1,34 @@
+import React, { ReactNode, RefObject } from "react";
+import { ISelectSelectedOption } from "../../select.interface";
+import { GroupOrder } from "../../../../common-enum";
+interface ISelectTriggerProps {
+    selectedOptions?: ISelectSelectedOption;
+    searchValue?: string;
+    searchable?: boolean;
+    clearable?: boolean;
+    onClickTrigger: (event: React.MouseEvent<HTMLDivElement, MouseEvent>) => void;
+    element?: ReactNode;
+    error?: string | ReactNode;
+    warning?: string | ReactNode;
+    tooltip?: string | ReactNode;
+    small?: boolean;
+    isInTable?: boolean;
+    disabled?: boolean;
+    onChangeSearch?: (value: string) => void;
+    onClickDeselect?: (event: React.MouseEvent<HTMLDivElement, MouseEvent>) => void;
+    onClickClear?: (event: React.MouseEvent<HTMLSpanElement, MouseEvent>) => void;
+    tabIndex?: number;
+    isOpen?: boolean;
+    triggerRef?: RefObject<HTMLDivElement>;
+    clearAllIsFocused?: boolean;
+    focusedSelectedOptionIndex?: number;
+    onFocus?: (event: React.FocusEvent<HTMLDivElement>) => void;
+    onBlur?: (event: React.FocusEvent<HTMLDivElement>) => void;
+    groupOrder?: GroupOrder;
+    maxTooltipWidth?: string | number;
+    placeholder?: string;
+    right?: boolean;
+    testId?: string;
+}
+export declare const Trigger: ({ selectedOptions, searchValue, searchable, clearable, onClickTrigger, element, error, warning, tooltip, small, isInTable, disabled, onChangeSearch, onClickDeselect, onClickClear, tabIndex, isOpen, triggerRef, clearAllIsFocused, focusedSelectedOptionIndex, onFocus, onBlur, groupOrder, maxTooltipWidth, placeholder, right, testId, }: ISelectTriggerProps) => React.JSX.Element;
+export {};

package/dist/components/select/native-select/native-select.d.ts

@@ -0,0 +1,29 @@
+import React, { ChangeEvent } from 'react';
+import { ISelectSelectedOption } from '../select.interface';
+interface NativeSelectProps {
+    borderRadius?: string | number;
+    disabled?: boolean;
+    error?: string | number | React.ReactNode | null;
+    warning?: string | number | React.ReactNode | null;
+    tooltip?: string | number | React.ReactNode | null;
+    options: ISelectSelectedOption[];
+    onChange?: (event: ChangeEvent<HTMLSelectElement>, value: ISelectSelectedOption | {
+        value: null;
+    }) => void;
+    onFocus?: () => void;
+    onBlur?: () => void;
+    right?: boolean;
+    small?: boolean;
+    tabIndex?: number;
+    selectedOption?: ISelectSelectedOption;
+    width?: string | number | null;
+    groupOrder?: string | null;
+    testId?: string | undefined;
+    isInTable?: boolean;
+    clearable?: boolean;
+    placeholder?: string;
+    hasNonExistentValue?: boolean;
+    maxTooltipWidth?: string | number;
+}
+export declare const NativeSelect: ({ disabled, error, warning, tooltip, options, onChange, onFocus, onBlur, right, small, tabIndex, selectedOption, width, groupOrder, testId, isInTable, clearable, placeholder, hasNonExistentValue, maxTooltipWidth, borderRadius, }: NativeSelectProps) => React.JSX.Element;
+export {};

package/dist/components/select/select.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { ISelectProps } from './select.interface';
+export declare const Select: (props: ISelectProps) => React.JSX.Element;

package/dist/components/select/select.input.d.ts

@@ -0,0 +1,21 @@
+import { ISelectSelectedOption } from './select.interface';
+type Option = ISelectSelectedOption;
+type SimpleOption = string | number;
+type SelectedOption = Option | SimpleOption;
+export declare const isMulti: (selectedOptions: any) => boolean;
+export declare const standardizeOptions: (options: any[], simple: boolean) => Option[];
+export declare const standardizeSelectedOption: (standardizedOptions: Option[], selectedOption: SelectedOption) => Option | undefined;
+export declare const standardizeSelectedOptions: (standardizedOptions: Option[], selectedOptions: SelectedOption[] | SelectedOption) => Option[] | Option | undefined;
+export declare const isSimpleOptions: (options: Option[]) => boolean;
+export declare const isSimpleSelectedOptions: (selectedOptions: SelectedOption | SelectedOption[]) => boolean;
+export declare const getFirstSelectedOptionIndex: (options: Option[], selectedOptions: SelectedOption | SelectedOption[]) => number | null;
+export declare const nonExistentValue: (options: Option[], selectedOptions: SelectedOption | SelectedOption[]) => boolean;
+export declare const standardizeInputs: (options: Option[], selectedOptions: SelectedOption | SelectedOption[], enableAutoScroll?: boolean, checkNonExistentValues?: boolean) => {
+    options: ISelectSelectedOption[];
+    selectedOptions: ISelectSelectedOption | ISelectSelectedOption[] | undefined;
+    multi: boolean;
+    simpleInputs: boolean;
+    firstSelectedOptionIndex: number | null;
+    hasNonExistentValue: boolean;
+};
+export {};

package/dist/components/select/select.interface.d.ts

@@ -0,0 +1,39 @@
+import { ReactNode } from 'react';
+export interface ISelectSelectedOption {
+    value?: string | number | boolean;
+    label?: string | ReactNode;
+    details?: string;
+    actions?: any[];
+    icon?: boolean | ReactNode;
+    type?: string;
+    disabled?: boolean;
+    testId?: string;
+}
+export interface ISelectProps {
+    name?: string;
+    multi?: boolean;
+    options?: ISelectSelectedOption[];
+    value?: any;
+    native?: boolean;
+    onChange?: (value: any) => void;
+    deprecatedEventHandler?: boolean;
+    autoScroll?: boolean;
+    warning?: string | number | ReactNode;
+    error?: string | number | ReactNode;
+    checkNonExistentValues?: boolean;
+    closeOnOptionActionClick?: boolean;
+    small?: boolean;
+    width?: string | number | null;
+    borderRadius?: string | number;
+    onCreate?: (evt: any) => any;
+    disabled?: boolean;
+    placeholder?: string;
+    isInTable?: boolean;
+    clearable?: boolean;
+    searchable?: boolean;
+    maxTooltipWidth?: string | number;
+    autoLayerWidth?: boolean;
+    right?: boolean;
+    tabIndex?: number;
+    testId?: string;
+}

package/dist/components/select/select.stories-data.d.ts

@@ -0,0 +1,25 @@
+import { ReactElement } from 'react';
+import { ISelectSelectedOption } from './select.interface';
+type Action = {
+    label: string;
+    icon: string | ReactElement;
+    onClick: () => void;
+};
+type Option = ISelectSelectedOption;
+type Heading = {
+    type: 'Heading';
+    label: string;
+};
+type OptionOrHeading = Option | Heading;
+export declare const options: Option[];
+export declare const optionsWithDetails: Option[];
+export declare const optionsWithHeadings: OptionOrHeading[];
+export declare const optionsNumeric: Option[];
+export declare const optionsBoolean: Option[];
+export declare const optionsWithIcons: Option[];
+export declare const actions: Action[];
+export declare const optionsWithActions: Option[];
+export declare const optionsWithEverything: Option[];
+export declare const optionsLong: Option[];
+export declare const optionsSimple: string[];
+export {};

package/dist/components/select/select.stories.d.ts

@@ -0,0 +1,30 @@
+import { StoryFn } from '@storybook/react';
+import { ISelectProps } from './select.interface';
+import { ICustomSelectProps } from './custom-select/custom-select.interface';
+declare const _default: import("@storybook/types").ComponentAnnotations<import("@storybook/react/dist/types-0a347bb9").R, import("@storybook/types").Args>;
+export default _default;
+type TSelectType = ISelectProps | ICustomSelectProps;
+export declare const Default: StoryFn<TSelectType>;
+export declare const Native: StoryFn<TSelectType>;
+export declare const Multiselect: StoryFn<TSelectType>;
+export declare const Empty: StoryFn<TSelectType>;
+export declare const Clearable: StoryFn<TSelectType>;
+export declare const NonExistentValue: StoryFn<TSelectType>;
+export declare const CustomPlaceholder: StoryFn<TSelectType>;
+export declare const OptionsWithHeadings: StoryFn<TSelectType>;
+export declare const OptionsWithDetails: StoryFn<TSelectType>;
+export declare const OptionsWithIcons: StoryFn<TSelectType>;
+export declare const OptionsWithActions: StoryFn<TSelectType>;
+export declare const OptionsWithEverything: StoryFn<TSelectType>;
+export declare const NotSearchable: StoryFn<TSelectType>;
+export declare const RightAligned: StoryFn<TSelectType>;
+export declare const AutoLayerWidth: StoryFn<TSelectType>;
+export declare const Tooltip: StoryFn<TSelectType>;
+export declare const Error: StoryFn<TSelectType>;
+export declare const Warning: StoryFn<TSelectType>;
+export declare const Disabled: StoryFn<TSelectType>;
+export declare const NumericOptions: StoryFn<TSelectType>;
+export declare const BooleanOptions: StoryFn<TSelectType>;
+export declare const SimpleOptions: StoryFn<TSelectType>;
+export declare const VeryLongList: StoryFn<TSelectType>;
+export declare const DeprecatedEventHandler: StoryFn<TSelectType>;

package/dist/components/select/select.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/side-bar/link.d.ts

@@ -0,0 +1,17 @@
+import React, { ReactNode } from 'react';
+export interface ISideBarLinkProps {
+    isOpen: boolean;
+    items: {
+        value: string;
+        isActive?: boolean;
+        isExperimental?: boolean;
+        label: string | ReactNode;
+        icon: any;
+        invalid?: boolean;
+        onClick?: (event: React.MouseEvent<HTMLAnchorElement, MouseEvent>) => void;
+    }[];
+    sectionIndex: number;
+    onClick: (evt: React.MouseEvent<HTMLAnchorElement, MouseEvent>, value: string, label: string | ReactNode, onClickCallback?: (event: React.MouseEvent<HTMLAnchorElement, MouseEvent>) => void) => void;
+    testId?: string;
+}
+export declare const Link: ({ isOpen, items, sectionIndex, onClick, testId, }: ISideBarLinkProps) => React.JSX.Element;

package/dist/components/side-bar/sections.d.ts

@@ -0,0 +1,21 @@
+import React, { ReactNode } from 'react';
+interface ISection {
+    heading: string;
+    items: {
+        value: string;
+        isActive?: boolean;
+        isExperimental?: boolean;
+        label: string | ReactNode;
+        icon: any;
+        invalid?: boolean;
+        onClick?: (event: React.MouseEvent<HTMLAnchorElement, MouseEvent>) => void;
+    }[];
+    testId?: string;
+}
+export interface ISideBarSectionsProps {
+    isOpen: boolean;
+    sections: ISection[];
+    onClick: (evt: React.MouseEvent<HTMLAnchorElement, MouseEvent>, value: string, label: string | ReactNode, onClickCallback?: (event: React.MouseEvent<HTMLAnchorElement, MouseEvent>) => void) => void;
+}
+export declare const Sections: ({ isOpen, sections, onClick, }: ISideBarSectionsProps) => React.JSX.Element;
+export {};

package/dist/components/side-bar/side-bar.d.ts

@@ -0,0 +1,26 @@
+import React, { MouseEvent, ReactNode } from "react";
+interface IOptionItem {
+    label: ReactNode;
+    value: string;
+    icon: ReactNode;
+    onClick: (event: MouseEvent<HTMLAnchorElement, globalThis.MouseEvent>) => void;
+    isActive?: boolean;
+    isExperimental?: boolean;
+    invalid?: boolean;
+    testId?: string;
+}
+interface IOptionSection {
+    heading: string;
+    items: IOptionItem[];
+}
+export interface ISideBarProps {
+    options: {
+        title: string;
+        sections: IOptionSection[];
+    };
+    startOpen?: boolean;
+    onShiftClickToggleOpen?: (event: MouseEvent<HTMLButtonElement, globalThis.MouseEvent>) => void;
+    top?: string | number;
+}
+export declare const SideBar: React.MemoExoticComponent<({ options, startOpen, onShiftClickToggleOpen, top }: ISideBarProps) => React.JSX.Element>;
+export {};

package/dist/components/side-bar/side-bar.stories.d.ts

@@ -0,0 +1,5 @@
+import { ISideBarProps } from './side-bar';
+declare const _default: import("@storybook/types").ComponentAnnotations<import("@storybook/react/dist/types-0a347bb9").R, import("@storybook/types").Args>;
+export default _default;
+export declare const Default: import("@storybook/types").AnnotatedStoryFn<import("@storybook/react/dist/types-0a347bb9").R, ISideBarProps>;
+export declare const StartOpen: import("@storybook/types").AnnotatedStoryFn<import("@storybook/react/dist/types-0a347bb9").R, ISideBarProps>;

package/dist/components/slider/slider-tooltip.d.ts

@@ -0,0 +1,5 @@
+import React, { ReactNode } from 'react';
+export interface ISliderTooltipProps {
+    text: string | number | ReactNode;
+}
+export declare const SliderTooltip: ({ text }: ISliderTooltipProps) => React.JSX.Element;

package/dist/components/slider/slider.d.ts

@@ -0,0 +1,36 @@
+import React, { ReactNode } from 'react';
+export type TSliderMark = {
+    value: number | string;
+    label?: number | string | ReactNode;
+    tooltip?: number | string | ReactNode;
+};
+export interface ISliderProps {
+    name?: string;
+    label?: string | number | ReactNode;
+    width?: string | number;
+    labelWidth?: string | number;
+    value: number | number[];
+    min: number;
+    max: number;
+    step?: number;
+    marks?: TSliderMark[];
+    showArrows?: boolean;
+    showTooltip?: boolean;
+    tooltipFormatter?: (value: number | number[]) => string | number | ReactNode;
+    disabled?: boolean;
+    range?: boolean;
+    small?: boolean;
+    vertical?: {
+        enabled: boolean;
+        width?: string;
+        height?: string;
+    };
+    onChange: (event: {
+        target: {
+            name?: string;
+            value: number | number[];
+            label?: string | number | ReactNode;
+        };
+    }) => void;
+}
+export declare const Slider: ({ name, label, width, labelWidth, value, min, max, step, marks, showArrows, showTooltip, tooltipFormatter, disabled, range, small, vertical, onChange, }: ISliderProps) => React.JSX.Element;

package/dist/components/slider/slider.stories.d.ts

@@ -0,0 +1,16 @@
+import { StoryFn } from '@storybook/react';
+import { ISliderProps } from './slider';
+declare const _default: import("@storybook/types").ComponentAnnotations<import("@storybook/react/dist/types-0a347bb9").R, import("@storybook/types").Args>;
+export default _default;
+export declare const Default: import("@storybook/types").AnnotatedStoryFn<import("@storybook/react/dist/types-0a347bb9").R, ISliderProps>;
+export declare const Range: import("@storybook/types").AnnotatedStoryFn<import("@storybook/react/dist/types-0a347bb9").R, ISliderProps>;
+export declare const Label: import("@storybook/types").AnnotatedStoryFn<import("@storybook/react/dist/types-0a347bb9").R, ISliderProps>;
+export declare const RangeWithArrows: import("@storybook/types").AnnotatedStoryFn<import("@storybook/react/dist/types-0a347bb9").R, ISliderProps>;
+export declare const JSXLabel: StoryFn<ISliderProps>;
+export declare const Tooltip: import("@storybook/types").AnnotatedStoryFn<import("@storybook/react/dist/types-0a347bb9").R, ISliderProps>;
+export declare const FormattedTooltip: import("@storybook/types").AnnotatedStoryFn<import("@storybook/react/dist/types-0a347bb9").R, ISliderProps>;
+export declare const Arrows: import("@storybook/types").AnnotatedStoryFn<import("@storybook/react/dist/types-0a347bb9").R, ISliderProps>;
+export declare const Marks: import("@storybook/types").AnnotatedStoryFn<import("@storybook/react/dist/types-0a347bb9").R, ISliderProps>;
+export declare const Small: import("@storybook/types").AnnotatedStoryFn<import("@storybook/react/dist/types-0a347bb9").R, ISliderProps>;
+export declare const Disabled: import("@storybook/types").AnnotatedStoryFn<import("@storybook/react/dist/types-0a347bb9").R, ISliderProps>;
+export declare const Vertical: import("@storybook/types").AnnotatedStoryFn<import("@storybook/react/dist/types-0a347bb9").R, ISliderProps>;

package/dist/components/spinner/spinner.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+export interface ISpinnerProps {
+    small?: boolean;
+    colored?: boolean;
+    dark?: boolean;
+    tiny?: boolean;
+}
+export declare const Spinner: ({ small, colored, dark, tiny, }: ISpinnerProps) => React.JSX.Element;

package/dist/components/spinner/spinner.stories.d.ts

@@ -0,0 +1,4 @@
+import { ISpinnerProps } from './spinner';
+declare const _default: import("@storybook/types").ComponentAnnotations<import("@storybook/react/dist/types-0a347bb9").R, import("@storybook/types").Args>;
+export default _default;
+export declare const Default: import("@storybook/types").AnnotatedStoryFn<import("@storybook/react/dist/types-0a347bb9").R, ISpinnerProps>;

package/dist/components/table/cell/cell-types/action-cell.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import { IActionCell } from './cell-types.interface';
+export interface IActionsCellProps {
+    cell: IActionCell;
+}
+export declare const ActionsCell: ({ cell }: IActionsCellProps) => React.JSX.Element;