@evergis/uilib-gl 1.0.0

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

@@ -0,0 +1,122 @@
+import { ReactNode, KeyboardEvent, CSSProperties } from "react";
+export declare type HourMinuteSecondText = {
+    h: string;
+    m: string;
+    s: string;
+};
+export interface IPopupContent {
+    onPickDate: (value: Date) => void;
+    classNames?: string;
+    locale?: object;
+    withTime?: boolean;
+    value: DatePickerDate;
+    withHeader?: boolean;
+    timeLabelText?: HourMinuteSecondText;
+}
+export interface IHourMinuteSecond {
+    h: number;
+    m: number;
+    s: number;
+}
+export interface IWeekdays {
+    weekdays: string[];
+}
+export interface IControl {
+    locale?: object;
+    date: DatePickerDate;
+    handlePrevTime: () => void;
+    handleNextTime: () => void;
+}
+export declare type DateObject = {
+    date: DatePickerDate;
+    classNames?: string;
+};
+export interface IDateInput {
+    value: DatePickerDate;
+    endValue?: DatePickerDate;
+    disabled?: boolean;
+    withTime?: boolean;
+    onBlur: (value: string) => void;
+    onKeyDown?: (e: KeyboardEvent<HTMLInputElement>) => void;
+    iconBefore?: ReactNode;
+    onRefInput?: RefType<HTMLInputElement>;
+    label?: string;
+    width?: string;
+    onClick?: VoidFunction;
+    onFocus?: VoidFunction;
+    style?: CSSProperties;
+    placeholder?: string;
+    disableInputOnly?: boolean;
+    isRange?: boolean;
+    children?: ReactNode;
+    readOnly?: boolean;
+}
+export declare type DatePickerDate = Date | undefined;
+export interface IDatePickerProps {
+    value: DatePickerDate;
+    onChange: (value: Date) => void;
+    withTime?: boolean;
+    disabled?: boolean;
+    selectsStart?: boolean;
+    selectsEnd?: boolean;
+    withHeader?: boolean;
+    startDate?: DatePickerDate;
+    endDate?: DatePickerDate;
+    locale?: object;
+    focus?: boolean;
+    label?: string;
+    width?: string | number;
+    zIndex?: number;
+    bottomBind?: boolean;
+    onBlur?: () => void;
+    clickable?: boolean;
+    prefix?: ReactNode;
+    suffix?: ReactNode;
+    placeholder?: string;
+    className?: string;
+}
+export interface IHeader {
+    withTime?: boolean;
+    value: DatePickerDate;
+    locale?: object;
+    time: IHourMinuteSecond;
+    height: string;
+}
+export interface IRangeHeader extends Omit<IHeader, "value" | "time"> {
+    range: [DatePickerDate, DatePickerDate];
+}
+export interface ITime {
+    time: IHourMinuteSecond;
+    onChangeTime: (value: string, key: string) => void;
+    saveDate?: VoidFunction;
+    hasLabel?: boolean;
+    disabled?: boolean;
+    timeLabelText?: HourMinuteSecondText;
+}
+export interface ICalendarGridProps {
+    classNames?: string;
+    selectsStart?: string;
+    selectsEnd?: string;
+    enterDate?: string;
+    locale?: object;
+    date: DatePickerDate;
+    value: DatePickerDate;
+    onChangeDate: (date: DatePickerDate) => void;
+    time: IHourMinuteSecond;
+    withTime?: boolean;
+}
+export interface IDayProps {
+    enterDate: DatePickerDate;
+    onMouseEnter: (date: DatePickerDate) => void;
+    weekdays: string[];
+    selectsStart?: string;
+    startDate?: DatePickerDate;
+    endDate?: DatePickerDate;
+    selectsEnd?: string;
+    classNames?: string;
+    value: DatePickerDate;
+    date: DatePickerDate;
+    onChangeDate: (date: DatePickerDate) => void;
+    withTime?: boolean;
+    time: IHourMinuteSecond;
+}

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

@@ -0,0 +1,4 @@
+import { IHourMinuteSecond } from "./types";
+export declare const time: IHourMinuteSecond;
+export declare const getTimeDuration: (key: string, factor?: number) => number;
+export declare const getTimeFromDate: (val: number) => IHourMinuteSecond;

package/dist/organisms/Dialog/ActionsGroup.d.ts

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

package/dist/organisms/Dialog/Dialog.d.ts

@@ -0,0 +1,7 @@
+import { FC } from "react";
+import { IDialogProps } from "./types";
+/**
+ * TODO: group to HOCs
+ */
+export declare const DialogComponent: FC<IDialogProps>;
+export declare const Dialog: FC<IDialogProps>;

package/dist/organisms/Dialog/DialogActions.d.ts

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

package/dist/organisms/Dialog/DialogContent.d.ts

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

package/dist/organisms/Dialog/DialogOverlay.d.ts

@@ -0,0 +1,3 @@
+export declare const DialogOverlay: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {
+    zIndex?: number | undefined;
+}, never>;

package/dist/organisms/Dialog/DialogTitle.d.ts

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

package/dist/organisms/Dialog/MyBlank.d.ts

@@ -0,0 +1,2 @@
+import { IMyBlankProps } from "./types";
+export declare const MyBlank: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, import("../../atoms/Blank").IBlankProps & IMyBlankProps, never>;

package/dist/organisms/Dialog/TitleText.d.ts

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

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

@@ -0,0 +1,8 @@
+export * from "./Dialog";
+export * from "./ActionsGroup";
+export * from "./DialogActions";
+export * from "./DialogContent";
+export * from "./DialogTitle";
+export * from "./DialogOverlay";
+export * from "./TitleText";
+export * from "./types";

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

@@ -0,0 +1,30 @@
+import { HTMLAttributes } from "react";
+export interface IImageProps {
+    img: boolean;
+}
+export interface IDialogProps extends IMyBlankProps {
+    onCloseRequest: (e: MouseEvent | KeyboardEvent) => void;
+    onApply?: () => void;
+    modal?: boolean;
+    fullScreen?: boolean;
+    isOpen: boolean;
+    className?: string;
+    zIndex?: number;
+    root?: HTMLElement | null;
+}
+export interface IMyBlankProps extends HTMLAttributes<HTMLDivElement> {
+    maxWidth?: string;
+    minWidth?: string;
+    minHeight?: string;
+    height?: string;
+    fullScreen?: boolean;
+}
+export interface IDialogActionsProps {
+    showShadow?: boolean | null;
+}
+export interface IDialogTitleProps {
+    showShadow?: boolean | null;
+    primary?: boolean;
+    secondary?: boolean;
+    error?: boolean;
+}

package/dist/organisms/Dropdown/Dropdown.d.ts

@@ -0,0 +1 @@
+export declare const Dropdown: any;

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

@@ -0,0 +1,3 @@
+export * from "./Dropdown";
+export * from "./styled";
+export * from "./types";

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

@@ -0,0 +1,19 @@
+import { IDropdownFieldProps } from "./types";
+export declare const LinearLoader: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, import("../../atoms/LinearProgress").ILinearProgressProps, never>;
+export declare const DropdownContainer: import("styled-components").StyledComponent<"span", import("styled-components").DefaultTheme, {
+    disabled?: boolean | undefined;
+    width?: string | undefined;
+}, never>;
+export declare const Placeholder: import("styled-components").StyledComponent<"span", import("styled-components").DefaultTheme, {}, never>;
+export declare const DropdownField: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, IDropdownFieldProps, never>;
+export declare const SearchInputContainer: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {
+    width?: string | undefined;
+    minWidth?: string | undefined;
+}, never>;
+export declare const MenuContainer: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {
+    width?: string | undefined;
+    height?: string | undefined;
+    maxHeight?: string | undefined;
+    minWidth?: string | undefined;
+    searchable?: boolean | undefined;
+}, never>;

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

@@ -0,0 +1,37 @@
+import { FocusEvent, ReactNode, SelectHTMLAttributes } from "react";
+import { FlattenSimpleInterpolation } from "styled-components";
+import { IJSXOption } from "../Menu";
+export interface IDropdownProps extends Omit<SelectHTMLAttributes<HTMLSelectElement>, "onChange"> {
+    error?: boolean;
+    help?: ReactNode;
+    label?: string;
+    options: IJSXOption[];
+    onFocus?: (e?: FocusEvent) => void;
+    onBlur?: (e?: FocusEvent) => void;
+    value?: string | string[];
+    placeholder?: string;
+    width?: string;
+    bottomBind?: boolean;
+    menuHeight?: string;
+    menuMaxHeight?: string;
+    menuWidth?: string;
+    menuMinWidth?: string;
+    onChange: (items: IJSXOption[]) => void;
+    zIndex?: number;
+    renderResultOptions?: (items: IJSXOption[]) => number | string | JSX.Element;
+    onOpen?: () => void;
+    loading?: boolean;
+    popoverMixin?: FlattenSimpleInterpolation;
+    children?: ReactNode;
+    searchable?: boolean;
+    searchPlaceholder?: string;
+    root?: HTMLElement | null;
+}
+export interface IDropdownFieldProps {
+    width?: string;
+    height?: string;
+    error?: boolean;
+    active?: boolean;
+    disabled?: boolean;
+    focused?: boolean;
+}

package/dist/organisms/FilterInput/FilterInput.d.ts

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

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

@@ -0,0 +1,6 @@
+import { FilterTypeOption } from "./types";
+export declare const FILTER_OPTIONS_INACTIVE: FilterTypeOption[];
+export declare const FILTER_OPTIONS_COMMON: FilterTypeOption[];
+export declare const FILTER_OPTIONS_NUMBER: FilterTypeOption[];
+export declare const FILTER_OPTIONS_STRING: FilterTypeOption[];
+export declare const FILTER_OPTIONS_DATE: FilterTypeOption[];

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

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

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

@@ -0,0 +1,72 @@
+import { MouseEvent, ReactNode } from "react";
+import { DatePickerDate } from "../DatePicker";
+import { IOption } from "../Menu";
+export declare enum ComparisonOperator {
+    /** `==` */
+    Equals = "Equals",
+    /** `!=` */
+    NotEquals = "NotEquals",
+    /** `>` */
+    GreaterThan = "GreaterThan",
+    /** `<` */
+    LessThan = "LessThan",
+    /** `>=` */
+    GreaterOrEquals = "GreaterOrEquals",
+    /** `<=` */
+    LessOrEquals = "LessOrEquals",
+    Filled = "Filled",
+    Empty = "Empty",
+    /** `==` */
+    Contains = "Contains",
+    /** `!=` */
+    NotContains = "NotContains",
+    StartsWith = "StartsWith",
+    NotStartsWith = "NotStartsWith",
+    EndsWith = "EndsWith",
+    NotEndsWith = "NotEndsWith",
+    Between = "Between",
+    Outside = "Outside"
+}
+export interface FilterValues {
+    filter1: [number, number] | number | null;
+    filter2: string;
+    filter3: [DatePickerDate, DatePickerDate] | DatePickerDate;
+    filter4: [DatePickerDate, DatePickerDate] | DatePickerDate;
+}
+export interface FilterTypes {
+    filter1: FilterTypeOption | null;
+    filter2: FilterTypeOption | null;
+    filter3: FilterTypeOption | null;
+    filter4: FilterTypeOption | null;
+}
+export declare type FilterInputType = "number" | "double" | "int64" | "int32" | "string" | "date" | "datetime";
+export declare type FilterTypeOption = IOption & {
+    inactive?: boolean;
+    autocomplete?: boolean;
+    range?: boolean;
+    checkboxes?: boolean;
+};
+export declare type FilterValue = [DatePickerDate, DatePickerDate] | Date | [number | undefined, number | undefined] | number | string | string[] | null | undefined;
+export interface FilterInputProps {
+    label?: string;
+    value?: FilterValue;
+    type: FilterInputType;
+    options: FilterTypeOption[];
+    defaultOption?: string;
+    selectedOption?: FilterTypeOption | null;
+    onShown?: VoidFunction;
+    onChange?: (filterType: FilterTypeOption | null, value: FilterValue) => void;
+    asyncCallback?: (value: string) => Promise<IOption[]>;
+    zIndex?: number;
+    menuTitle?: string;
+    clearTitle?: string;
+    min?: number | Date;
+    max?: number | Date;
+    disabled?: boolean;
+    prefix?: ReactNode;
+    fromTable?: boolean;
+    onInputClick?: (e: MouseEvent<HTMLInputElement>, option?: FilterTypeOption | null) => void;
+    active?: boolean;
+    checkboxSelectedText?: string;
+    menuMaxHeight?: string;
+}

package/dist/organisms/FocusTrap/FocusTrap.d.ts

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

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

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

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

@@ -0,0 +1,19 @@
+import { KeyboardEvent, FocusEvent } from "react";
+export interface IFocusTrapKeysProps {
+    onEnter?: (e: KeyboardEvent<HTMLInputElement>) => void;
+    onArrowUp?: (e: KeyboardEvent<HTMLInputElement>) => void;
+    onArrowDown?: (e: KeyboardEvent<HTMLInputElement>) => void;
+    onArrowRight?: (e: KeyboardEvent<HTMLInputElement>) => void;
+    onArrowLeft?: (e: KeyboardEvent<HTMLInputElement>) => void;
+    onSpace?: (e: KeyboardEvent<HTMLInputElement>) => void;
+    onDel?: (e: KeyboardEvent<HTMLInputElement>) => void;
+    onEsc?: (e: KeyboardEvent<HTMLInputElement>) => void;
+    onBackspace?: (e: KeyboardEvent<HTMLInputElement>) => void;
+}
+export interface IFocusTrapProps extends IFocusTrapKeysProps {
+    onFocus?: (e: FocusEvent<HTMLInputElement>) => void;
+    onBlur?: (e: FocusEvent<HTMLInputElement>) => void;
+    onKeyDown?: (e: KeyboardEvent<HTMLInputElement>) => void;
+    innerRef?: (ref: HTMLInputElement) => void;
+    readOnly?: boolean;
+}

package/dist/organisms/IconMenu/IconMenu.d.ts

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

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

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

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

@@ -0,0 +1,12 @@
+import { ReactNode } from "react";
+import { IconTypesKeys } from "../../atoms/Icon";
+import { IOption } from "../Menu";
+export declare type IconMenuProps = {
+    kind?: IconTypesKeys;
+    options?: Array<IOption<string | JSX.Element | ReactNode>>;
+    disabled?: boolean;
+    onSelect?: (value: string) => void;
+    titleText?: string;
+    buttonText?: string | JSX.Element | ReactNode;
+    iconRight?: boolean;
+};

package/dist/organisms/ImageLoader/Background.d.ts

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

package/dist/organisms/ImageLoader/Container.d.ts

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

package/dist/organisms/ImageLoader/IconsContainer.d.ts

@@ -0,0 +1,6 @@
+interface IIconsProps {
+    imageLoaded: boolean;
+}
+export declare const Background: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, import("./types").IBackgroundProps, never>;
+export declare const IconsContainer: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, IIconsProps, never>;
+export {};

package/dist/organisms/ImageLoader/ImageLoader.d.ts

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

package/dist/organisms/ImageLoader/UnicodeBig.d.ts

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

package/dist/organisms/ImageLoader/UnicodeSmall.d.ts

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

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

@@ -0,0 +1,4 @@
+export * from "./ImageLoader";
+export * from "./UnicodeSmall";
+export * from "./UnicodeBig";
+export * from "./types";

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

@@ -0,0 +1,33 @@
+export interface IBackgroundProps {
+    imageLoaded: boolean;
+}
+export interface IImageLoaderProps {
+    src?: string;
+    fallback?: string;
+    loaderLabel?: string;
+    onUpload?: (url: string, file: IFile | File) => void;
+    onRemoveRequest?: () => void;
+    onGenerateImage?: () => void;
+    accept?: string;
+    className?: string;
+    onError?: () => void;
+    showLoadingProgress?: boolean;
+    loading?: boolean;
+    downloadTitleText?: string;
+    deleteTitleText?: string;
+    isSmall?: boolean;
+    fileName?: string;
+    unicode?: string | number;
+}
+export interface IFile extends Blob {
+    lastModified: number;
+    lastModifiedDate: Date;
+    name: string;
+    size: number;
+    type: string;
+    webkitRelativePath: string;
+}
+export interface IResult {
+    dataURL: string;
+    name: string;
+}

package/dist/organisms/JSONEditor/GlobalStyle.d.ts

@@ -0,0 +1 @@
+export declare const GlobalStyle: import("styled-components").GlobalStyleComponent<{}, import("styled-components").DefaultTheme>;

package/dist/organisms/JSONEditor/JSONEditor.d.ts

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

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

@@ -0,0 +1,2 @@
+import { JSONEditorOptions } from "jsoneditor";
+export declare const defaultOptions: JSONEditorOptions;

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

@@ -0,0 +1,4 @@
+export * from "./JSONEditor";
+export * from "./styled";
+export * from "./constants";
+export * from "./types";

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

@@ -0,0 +1,7 @@
+export declare const JSONEditorContainer: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {
+    hasNoActions?: boolean | undefined;
+}, never>;
+export declare const JSONEditorLinearProgress: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, import("../../atoms/LinearProgress").ILinearProgressProps, never>;
+export declare const JSONEditorWrapper: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
+export declare const LeftSide: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
+export declare const Actions: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;

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

@@ -0,0 +1,29 @@
+import { CSSProperties, MutableRefObject } from "react";
+import JsonEditor, { JSONEditorOptions as JSONEditorOptionsBase, EditableNode as EditableNodeBase } from "jsoneditor";
+export declare type JSONEditorOptions = JSONEditorOptionsBase;
+export declare type EditableNode = EditableNodeBase;
+export declare type JSONEditorInstance = JsonEditor;
+export declare type JSONEditorProps = {
+    innerRef?: MutableRefObject<JsonEditor | null>;
+    json?: Record<string, unknown>;
+    loading?: boolean;
+    style?: CSSProperties;
+    editorStyle?: CSSProperties;
+    options?: Omit<JSONEditorOptions, "schema"> & {
+        schema?: Record<string, any>;
+        mode?: string;
+    };
+    onSubmit?: (json: any) => void;
+    onPreview?: (json: any) => void | undefined;
+    isWaiting?: boolean;
+    expandAll?: boolean;
+    isWaitingPreview?: boolean;
+    hideModeSwitcher?: boolean;
+    language?: string;
+    text?: {
+        treeMode?: string;
+        codeMode?: string;
+        preview?: string;
+        save?: string;
+    };
+};

package/dist/organisms/Menu/Menu.d.ts

@@ -0,0 +1,5 @@
+import { FC } from "react";
+import { IMenuProps } from "./types";
+export declare function removeItem<T>(array: T[], index: number): T[];
+export declare function addItem<T>(array: T[], newItem: T): T[];
+export declare const Menu: FC<IMenuProps>;

package/dist/organisms/Menu/Option.d.ts

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

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

@@ -0,0 +1,4 @@
+export * from "./Menu";
+export * from "./Option";
+export * from "./toOption";
+export * from "./types";

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

@@ -0,0 +1,12 @@
+import { IBaseOption } from "./types";
+export declare const OptionContainer: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, IBaseOption, never>;
+export declare const OptionIcon: import("styled-components").StyledComponent<"span", import("styled-components").DefaultTheme, {}, never>;
+export declare const OptionDescription: import("styled-components").StyledComponent<"p", import("styled-components").DefaultTheme, {}, never>;
+export declare const DividerLine: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, import("../../atoms/Divider").DividerProps, never>;
+export declare const OptionText: import("styled-components").StyledComponent<"span", import("styled-components").DefaultTheme, {
+    disabled?: boolean | undefined;
+}, never>;
+export declare const OptionValueWrapper: import("styled-components").StyledComponent<"span", import("styled-components").DefaultTheme, {}, never>;
+export declare const OptionValueContainer: import("styled-components").StyledComponent<"span", import("styled-components").DefaultTheme, {
+    disabled?: boolean | undefined;
+}, never>;

package/dist/organisms/Menu/toOption.d.ts

@@ -0,0 +1,3 @@
+import { IOption } from "./types";
+export declare const toSimpleOption: (text: string) => IOption;
+export declare const mapToSimpleOption: (texts: string[]) => IOption[];

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

@@ -0,0 +1,54 @@
+import { CSSProperties, ReactNode, ReactChild, ReactFragment, ReactPortal } from "react";
+import { IconTypesKeys } from "../../atoms/Icon";
+export declare type ComplexOptionText = ReactNode | ReactChild | ReactFragment | ReactPortal | string;
+export interface IBaseOption {
+    nullable?: boolean;
+    selected?: boolean;
+    focused?: boolean;
+    disabled?: boolean;
+    withPadding?: boolean;
+    heading?: boolean;
+    primary?: boolean;
+    withCheckbox?: boolean;
+}
+export interface IOption<Text = string> {
+    icon?: IconTypesKeys;
+    text?: Text;
+    value?: string | null;
+    children?: IOption<ComplexOptionText>[] | IOption<ComplexOptionText>[][] | null;
+    disabled?: boolean;
+    description?: string;
+    heading?: boolean;
+    primary?: boolean;
+    indeterminate?: boolean;
+    prefix?: ReactNode;
+    suffix?: ReactNode;
+    style?: CSSProperties;
+}
+export declare type IJSXOption = IOption<string | JSX.Element>;
+export interface IOptionComponentProps {
+    item: IOption<ComplexOptionText>;
+    focusedValue?: string | number | null;
+    multiple?: boolean;
+    selectedOptions?: IOption<ComplexOptionText>[];
+    select: (item: IOption<ComplexOptionText>) => void;
+    className?: string;
+    withPadding?: boolean;
+    heading?: boolean;
+}
+export interface IMenuProps extends Omit<IOptionComponentProps, "item" | "select"> {
+    options?: IOption<ComplexOptionText>[] | IOption<ComplexOptionText>[][] | null;
+    title?: JSX.Element | string;
+    withPadding?: boolean;
+    selectOption?(items?: IOption<ComplexOptionText>[], item?: IOption<ComplexOptionText>): void;
+    setFocusedOption?(item: IOption<ComplexOptionText>): void;
+    loading?: boolean;
+}
+export interface IChildOptionProps {
+    text?: string;
+    value?: string;
+    disabled?: boolean;
+    dropdown?: {
+        nullableColor: string;
+    };
+}

package/dist/organisms/Notifications/ButtonContainer.d.ts

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

package/dist/organisms/Notifications/CloseButtonContainer.d.ts

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