@monolith-forensics/monolith-ui 1.1.34 → 1.1.35

package/dist/Button/Button.d.ts

@@ -0,0 +1,19 @@
+import { ButtonHTMLAttributes, ReactNode } from "react";
+import { Size, Variant } from "../core";
+export interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    children?: ReactNode | string;
+    className?: string;
+    loading?: boolean;
+    leftSection?: ReactNode;
+    rightSection?: ReactNode;
+    href?: string | null;
+    download?: string | null;
+    fullWidth?: boolean;
+    size?: Size;
+    variant?: Variant;
+    color?: string;
+    disabled?: boolean;
+    onClick?: (event: React.MouseEvent<HTMLButtonElement>) => void;
+}
+declare const Button: import("react").ForwardRefExoticComponent<ButtonProps & import("react").RefAttributes<HTMLButtonElement>>;
+export default Button;

package/dist/Button/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from "./Button";
+export type { ButtonProps } from "./Button";

package/dist/Calendar/Calendar.d.ts

@@ -0,0 +1,15 @@
+interface CalendarProps {
+    defaultValue?: Date;
+    value?: Date | null;
+    onChange?: (date: Date | null) => void;
+    hourFormat?: "12" | "24";
+    includeTime?: boolean;
+    clearable?: boolean;
+    min?: Date;
+    max?: Date;
+}
+declare const Calendar: {
+    ({ defaultValue, value, onChange, hourFormat, includeTime, clearable, min, max, }: CalendarProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export default Calendar;

package/dist/Calendar/CalendarStyles.d.ts

@@ -0,0 +1,36 @@
+export declare const MainContainer: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const CalendarContainer: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const CalendarHeader: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const CalendarGrid: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const CalendarMonth: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+interface CalendarCellProps {
+    index?: number;
+    inMonth?: boolean | 0;
+    "data-disabled"?: boolean | 0;
+    key: string | null;
+    title?: string;
+}
+export declare const CalendarCell: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, CalendarCellProps>> & string;
+export declare const CalendarDay: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<Omit<import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof CalendarCellProps> & CalendarCellProps, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void | import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import("react").RefObject<HTMLDivElement> | null | undefined;
+}, CalendarCellProps>> & string;
+export declare const CalendarDate: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<Omit<import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof CalendarCellProps> & CalendarCellProps, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void | import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import("react").RefObject<HTMLDivElement> | null | undefined;
+}, CalendarCellProps>> & string;
+export declare const HighlightedCalendarDate: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<import("styled-components").FastOmit<Omit<import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof CalendarCellProps> & CalendarCellProps, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void | import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import("react").RefObject<HTMLDivElement> | null | undefined;
+}, keyof CalendarCellProps> & CalendarCellProps, CalendarCellProps>> & string;
+export declare const TodayCalendarDate: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<import("styled-components").FastOmit<import("styled-components").FastOmit<Omit<import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof CalendarCellProps> & CalendarCellProps, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void | import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import("react").RefObject<HTMLDivElement> | null | undefined;
+}, keyof CalendarCellProps> & CalendarCellProps, keyof CalendarCellProps> & CalendarCellProps, CalendarCellProps>> & string;
+export declare const TimeContainer: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const TimePickerContainer: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const TimeHeader: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const TimeHourSelect: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const TimeMinuteSelect: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const TimeItem: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const TimeItemActive: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<Omit<import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void | import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import("react").RefObject<HTMLDivElement> | null | undefined;
+}, never>> & string;
+export declare const NoValueButton: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, never>> & string;
+export {};

package/dist/Calendar/calendarHelpers.d.ts

@@ -0,0 +1,53 @@
+export declare const THIS_YEAR: number;
+export declare const THIS_MONTH: number;
+export declare const HOURS24: {
+    value: number;
+    label: string;
+}[];
+export declare const HOURS12: {
+    value: number;
+    label: string;
+}[];
+export declare const MINUTES: (string | number)[];
+export declare const WEEK_DAYS: {
+    Sunday: string;
+    Monday: string;
+    Tuesday: string;
+    Wednesday: string;
+    Thursday: string;
+    Friday: string;
+    Saturday: string;
+};
+export type WeekDay = keyof typeof WEEK_DAYS;
+export declare const CALENDAR_MONTHS: {
+    January: string;
+    February: string;
+    March: string;
+    April: string;
+    May: string;
+    June: string;
+    July: string;
+    August: string;
+    September: string;
+    October: string;
+    November: string;
+    December: string;
+};
+export declare const CALENDAR_WEEKS = 6;
+export declare const zeroPad: (value: number, length: number) => string;
+export declare const getMonthDays: (month?: number, year?: number) => 29 | 28 | 30 | 31;
+export declare const getMonthFirstDay: (month?: number, year?: number) => number;
+export declare const isDate: (date: Date) => boolean;
+export declare const isSameMonth: (date: Date, basedate?: Date) => boolean;
+export declare const isSameDay: (date: Date, basedate?: Date) => boolean;
+export declare const getDateISO: (date: Date) => string | null;
+export declare const getPreviousMonth: (month: number, year: number) => {
+    month: number;
+    year: number;
+};
+export declare const getNextMonth: (month: number, year: number) => {
+    month: number;
+    year: number;
+};
+declare const calendarBuilder: (month?: number, year?: number) => (string | number)[][];
+export default calendarBuilder;

package/dist/Calendar/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./Calendar";

package/dist/CheckBox/CheckBox.d.ts

@@ -0,0 +1,13 @@
+import { CSSProperties } from "react";
+import { Size } from "../core";
+interface CheckBoxProps {
+    className?: string;
+    size?: Size;
+    defaultValue?: boolean;
+    value?: boolean | undefined;
+    partialCheck?: boolean;
+    onChange?: (value: boolean) => void;
+    style?: CSSProperties;
+}
+declare const CheckBox: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<CheckBoxProps, never>> & string & Omit<({ className, defaultValue, value, partialCheck, onChange, }: CheckBoxProps) => import("react/jsx-runtime").JSX.Element, keyof import("react").Component<any, {}, any>>;
+export default CheckBox;

package/dist/CheckBox/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./CheckBox";

package/dist/DateInput/DateInput.d.ts

@@ -0,0 +1,24 @@
+import React from "react";
+import { Size, Variant } from "../core";
+interface DateInputProps {
+    className?: string;
+    defaultValue?: string | null | undefined;
+    format?: string;
+    label?: string;
+    description?: string;
+    arrow?: boolean;
+    size?: Size;
+    variant?: Variant;
+    clearable?: boolean;
+    required?: boolean;
+    onChange?: (value: string | null) => void;
+    min?: Date;
+    max?: Date;
+    error?: string;
+    width?: string;
+    enableCalendar?: boolean;
+    utc?: boolean;
+    closeOnSelect?: boolean;
+}
+declare const DateInput: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<DateInputProps, never>> & string & Omit<({ className, defaultValue, format, label, description, arrow, size, variant, clearable, required, onChange, min, max, error, enableCalendar, utc, closeOnSelect, }: DateInputProps) => import("react/jsx-runtime").JSX.Element, keyof React.Component<any, {}, any>>;
+export default DateInput;

package/dist/DateInput/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./DateInput";

package/dist/DropDownMenu/DropDownMenu.d.ts

@@ -0,0 +1,36 @@
+import { ComponentPropsWithoutRef, ComponentType, ReactNode, UIEvent } from "react";
+import { ButtonProps } from "../Button";
+import { Size, Variant } from "../core";
+interface StyledContentProps {
+    maxDropdownHeight?: number | string;
+    variant?: Variant;
+}
+declare const StyledContent: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, StyledContentProps>> & string;
+interface DropDownItem {
+    toLowerCase?: () => string;
+    label: string;
+    value: string;
+    data?: any;
+}
+interface DropDownMenuProps {
+    className?: string;
+    children?: ReactNode;
+    data?: DropDownItem[];
+    variant?: Variant;
+    defaultValue?: DropDownItem[];
+    multiselect?: boolean;
+    size?: Size;
+    title?: string;
+    TooltipContent?: ComponentType<any>;
+    renderOption?: (item: DropDownItem) => ReactNode;
+    onChange?: (selected: DropDownItem[], diff: DropDownItem[]) => void;
+    onItemSelect?: (item: DropDownItem) => void;
+    onScroll?: (e: UIEvent<HTMLDivElement>) => void;
+    loading?: boolean;
+    arrow?: boolean;
+    searchable?: boolean;
+    dropDownProps?: ComponentPropsWithoutRef<typeof StyledContent>;
+    buttonProps?: ButtonProps;
+}
+declare const DropDownMenu: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<DropDownMenuProps, never>> & string & Omit<({ className, children, data, variant, defaultValue, multiselect, size, TooltipContent, renderOption, onChange, onItemSelect, onScroll, loading, arrow, searchable, dropDownProps, buttonProps, }: DropDownMenuProps) => import("react/jsx-runtime").JSX.Element, keyof import("react").Component<any, {}, any>>;
+export default DropDownMenu;

package/dist/DropDownMenu/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./DropDownMenu";

package/dist/Error/Error.d.ts

@@ -0,0 +1,4 @@
+declare const ErrorComponent: ({ error }: {
+    error: string;
+}) => import("react/jsx-runtime").JSX.Element;
+export default ErrorComponent;

package/dist/Error/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./Error";

package/dist/FieldLabel/FieldLabel.d.ts

@@ -0,0 +1,19 @@
+import { ReactNode } from "react";
+import { Size } from "../core";
+interface InfoComponentProps {
+    className?: string;
+    children?: ReactNode;
+    description?: string;
+    label?: string | ReactNode;
+}
+export declare const InfoComponent: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<InfoComponentProps, never>> & string & Omit<({ className, children, description, label }: InfoComponentProps) => string | number | boolean | Iterable<ReactNode> | import("react/jsx-runtime").JSX.Element | null | undefined, keyof import("react").Component<any, {}, any>>;
+interface FieldLabelProps {
+    className?: string;
+    children?: ReactNode;
+    error?: string;
+    description?: string;
+    size?: Size;
+    asterisk?: boolean;
+}
+declare const FieldLabel: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<FieldLabelProps, never>> & string & Omit<({ className, children, error, description, size, }: FieldLabelProps) => import("react/jsx-runtime").JSX.Element, keyof import("react").Component<any, {}, any>>;
+export default FieldLabel;

package/dist/FieldLabel/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./FieldLabel";

package/dist/FileInputField/FileInputField.d.ts

@@ -0,0 +1,19 @@
+import { ReactNode, HTMLAttributes } from "react";
+import { DropzoneOptions } from "react-dropzone";
+import { Size, Variant } from "../core";
+interface FileInputFieldProps {
+    className?: string;
+    children?: ReactNode;
+    variant?: Variant;
+    label?: string;
+    error?: string;
+    required?: boolean;
+    size?: Size;
+    onChange?: (files: File[]) => void;
+    onFocus?: () => void;
+    dropZoneOptions?: DropzoneOptions;
+    colSpan?: number;
+    style?: HTMLAttributes<HTMLDivElement>;
+}
+declare const FileInputField: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<FileInputFieldProps, never>> & string & Omit<({ className, children, label, error, required, size, onChange, onFocus, dropZoneOptions, colSpan, style, }: FileInputFieldProps) => import("react/jsx-runtime").JSX.Element, keyof import("react").Component<any, {}, any>>;
+export default FileInputField;

package/dist/FileInputField/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./FileInputField";

package/dist/Flyout/Flyout.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+interface FlyoutProps {
+    children: React.ReactNode;
+    open?: boolean;
+    onClose?: () => void;
+    style?: React.CSSProperties;
+    closeOnOutsideClick?: boolean;
+    showCloseButton?: boolean;
+}
+declare const Flyout: React.FC<FlyoutProps>;
+export default Flyout;

package/dist/Flyout/FlyoutHeader.d.ts

@@ -0,0 +1,5 @@
+interface FlyoutHeaderProps {
+    hasBorder?: boolean;
+}
+declare const FlyoutHeader: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, FlyoutHeaderProps>> & string;
+export default FlyoutHeader;

package/dist/Flyout/FlyoutTitle.d.ts

@@ -0,0 +1,2 @@
+declare const FlyoutTitle: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, never>> & string;
+export default FlyoutTitle;

package/dist/Flyout/index.d.ts

@@ -0,0 +1,3 @@
+export { default } from "./Flyout";
+export { default as FlyoutHeader } from "./FlyoutHeader";
+export { default as FlyoutTitle } from "./FlyoutTitle";

package/dist/FormSection/FormSection.d.ts

@@ -0,0 +1,9 @@
+import { ReactNode } from "react";
+interface FormSectionProps {
+    children?: ReactNode;
+    className?: string;
+    title?: string;
+    defaultOpen?: boolean;
+}
+declare const FormSection: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<FormSectionProps, never>> & string & Omit<({ className, title, children, defaultOpen }: FormSectionProps) => import("react/jsx-runtime").JSX.Element, keyof import("react").Component<any, {}, any>>;
+export default FormSection;

package/dist/FormSection/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./FormSection";

package/dist/Grid/Grid.d.ts

@@ -0,0 +1,8 @@
+interface GridProps {
+    className?: string;
+    children: React.ReactNode;
+    col?: number;
+    width?: string | number;
+}
+declare const Grid: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<GridProps, never>> & string & Omit<({ className, children }: GridProps) => import("react/jsx-runtime").JSX.Element, keyof import("react").Component<any, {}, any>>;
+export default Grid;

package/dist/Grid/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./Grid";

package/dist/IconButton/IconButton.d.ts

@@ -0,0 +1,5 @@
+import { ButtonProps } from "../Button/Button.js";
+declare const IconButton: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<Omit<ButtonProps & import("react").RefAttributes<HTMLButtonElement>, "ref"> & {
+    ref?: ((instance: HTMLButtonElement | null) => void | import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import("react").RefObject<HTMLButtonElement> | null | undefined;
+}, ButtonProps>> & string & Omit<import("react").ForwardRefExoticComponent<ButtonProps & import("react").RefAttributes<HTMLButtonElement>>, keyof import("react").Component<any, {}, any>>;
+export default IconButton;

package/dist/IconButton/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./IconButton";

package/dist/Input/Input.d.ts

@@ -0,0 +1,21 @@
+import { Size, Variant } from "../core";
+export interface InputProps {
+    ref?: React.Ref<HTMLInputElement>;
+    className?: string;
+    size?: Size;
+    variant?: Variant;
+    width?: string | number | null | undefined;
+    style?: React.CSSProperties;
+    placeholder?: string;
+    onChange?: (e: React.ChangeEvent<HTMLInputElement>) => void;
+    onKeyUp?: (e: React.KeyboardEvent<HTMLInputElement>) => void;
+    onKeyDown?: (e: React.KeyboardEvent<HTMLInputElement>) => void;
+    onFocus?: (e: React.FocusEvent<HTMLInputElement>) => void;
+    onBlur?: (e: React.FocusEvent<HTMLInputElement>) => void;
+    autoFocus?: boolean;
+    readOnly?: boolean;
+}
+declare const Input: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<Omit<Omit<InputProps, "ref"> & import("react").RefAttributes<HTMLInputElement>, "ref"> & {
+    ref?: ((instance: HTMLInputElement | null) => void | import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import("react").RefObject<HTMLInputElement> | null | undefined;
+}, never>> & string & Omit<import("react").ForwardRefExoticComponent<Omit<InputProps, "ref"> & import("react").RefAttributes<HTMLInputElement>>, keyof import("react").Component<any, {}, any>>;
+export default Input;

package/dist/Input/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./Input";

package/dist/Modal/Modal.d.ts

@@ -0,0 +1,14 @@
+interface ModalProps {
+    children: React.ReactNode;
+    open?: boolean;
+    onClose?: () => void;
+    style?: React.CSSProperties;
+    showCloseButton?: boolean;
+    FocusProps?: any;
+}
+declare const Modal: {
+    ({ children, open, onClose, style, showCloseButton, FocusProps, }: ModalProps): import("react/jsx-runtime").JSX.Element;
+    Title: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, never>> & string;
+    SubTitle: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLHeadingElement>, HTMLHeadingElement>, never>> & string;
+};
+export default Modal;

package/dist/Modal/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./Modal";

package/dist/MonolithUIProvider/GlobalStyle.d.ts

@@ -0,0 +1,4 @@
+declare const GlobalStyle: import("react").NamedExoticComponent<import("styled-components").ExecutionProps & {
+    theme: any;
+}>;
+export default GlobalStyle;

package/dist/MonolithUIProvider/MonolithUIProvider.d.ts

@@ -0,0 +1,18 @@
+import { DefaultTheme } from "styled-components";
+import { Themes } from "../theme";
+import React from "react";
+export interface MonolithUIContextType {
+    theme: DefaultTheme;
+    Themes: typeof Themes;
+    colorScheme: "LIGHT" | "DARK";
+    toggleColorScheme: () => void;
+    setColorScheme: React.Dispatch<React.SetStateAction<"LIGHT" | "DARK">>;
+}
+export declare const MonolithUIContext: React.Context<MonolithUIContextType | undefined>;
+interface MonolithUIProviderProps {
+    children: React.ReactNode | React.ReactNode[];
+    theme?: DefaultTheme;
+    defaultColorScheme?: "LIGHT" | "DARK";
+}
+declare const MonolithUIProvider: ({ children, theme, defaultColorScheme, }: MonolithUIProviderProps) => import("react/jsx-runtime").JSX.Element;
+export default MonolithUIProvider;

package/dist/MonolithUIProvider/index.d.ts

@@ -0,0 +1,3 @@
+export { default } from "./MonolithUIProvider";
+export { default as useMonolithUITheme } from "./useMonolithUITheme";
+export { default as getTheme } from "../theme";

package/dist/MonolithUIProvider/useMonolithUITheme.d.ts

@@ -0,0 +1,3 @@
+import { MonolithUIContextType } from "./MonolithUIProvider";
+declare const useMonolithUITheme: () => MonolithUIContextType;
+export default useMonolithUITheme;

package/dist/Pill/Pill.d.ts

@@ -0,0 +1,11 @@
+import { ReactNode } from "react";
+import { Size } from "../core";
+interface PillProps {
+    className?: string;
+    children?: ReactNode;
+    size?: Size;
+    showRemoveIcon?: boolean;
+    onRemove?: () => void;
+}
+declare const Pill: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<PillProps, never>> & string & Omit<({ className, children, size, showRemoveIcon, onRemove, }: PillProps) => import("react/jsx-runtime").JSX.Element, keyof import("react").Component<any, {}, any>>;
+export default Pill;

package/dist/Pill/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./Pill";

package/dist/SelectBox/SelectBox.d.ts

@@ -0,0 +1,45 @@
+import { ReactNode } from "react";
+import { Size, Variant } from "../core";
+export declare const StyledInputContainer: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
+    width?: string | number | null;
+}>> & string;
+type Option = {
+    label: string;
+    value: any;
+    group?: string;
+    data?: any;
+};
+interface SelectBoxProps {
+    className?: string;
+    defaultValue?: Option | string;
+    data?: Option[] | string[];
+    placeholder?: string;
+    arrow?: boolean;
+    onChange?: (value: any, item: any) => void;
+    onSearch?: (value: string) => void;
+    searchFn?: (value: string) => void;
+    onScroll?: (e: any) => void;
+    loading?: boolean;
+    onItemAdded?: (item: any) => void;
+    size?: Size;
+    variant?: Variant;
+    width?: string | number | null;
+    allowCustomValue?: boolean;
+    searchable?: boolean;
+    clearable?: boolean;
+    label?: string;
+    description?: string;
+    required?: boolean;
+    error?: string;
+    openOnFocus?: boolean;
+    renderOption?: (item: Option | string) => ReactNode;
+    actionComponent?: JSX.Element;
+    focused?: boolean;
+    grouped?: boolean;
+    TooltipContent?: React.FC<{
+        data: any;
+    }>;
+    DropDownProps?: any;
+}
+declare const SelectBox: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<SelectBoxProps, never>> & string & Omit<({ className, data, placeholder, arrow, onChange, onSearch, searchFn, onScroll, loading, defaultValue, onItemAdded, size, variant, width, allowCustomValue, searchable, clearable, label, description, required, error, openOnFocus, renderOption, actionComponent, focused, grouped, TooltipContent, DropDownProps, }: SelectBoxProps) => import("react/jsx-runtime").JSX.Element, keyof import("react").Component<any, {}, any>>;
+export default SelectBox;

package/dist/SelectBox/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./SelectBox";

package/dist/Switch/Switch.d.ts

@@ -0,0 +1,18 @@
+import { CSSProperties } from "react";
+import { Size } from "../core";
+interface SwitchProps {
+    className?: string;
+    onChange: (e: any) => void;
+    size?: Size;
+    label?: string;
+    labelPosition?: "left" | "right";
+    description?: string;
+    error?: string;
+    required?: boolean;
+    disabled?: boolean;
+    defaultValue?: boolean;
+    value?: boolean;
+    style?: CSSProperties;
+}
+declare const Switch: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<SwitchProps, never>> & string & Omit<({ className, onChange, size, label, labelPosition, description, error, required, disabled, defaultValue, value, style, ...other }: SwitchProps) => import("react/jsx-runtime").JSX.Element, keyof import("react").Component<any, {}, any>>;
+export default Switch;

package/dist/Switch/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./Switch";

package/dist/Table/Table.d.ts

@@ -0,0 +1,92 @@
+import "overlayscrollbars/overlayscrollbars.css";
+interface ColumnProps {
+    className?: string;
+    key?: string | number;
+    dataField: string;
+    caption: string;
+    columnId?: string | number;
+    allowSorting?: boolean;
+    allowReorder?: boolean;
+    resizeEnabled?: boolean;
+    width?: number;
+    sorting?: {
+        active: boolean;
+        direction: "asc" | "desc";
+    };
+    format?: {
+        type: string;
+    };
+    props?: any;
+    render: (data: any, options: any) => React.ReactNode;
+}
+interface ColumnType extends React.FunctionComponent<ColumnProps> {
+    displayName: string;
+}
+export declare const Column: ColumnType;
+interface onResizeProps {
+    columns: {
+        dataField: string;
+        width: number;
+    }[];
+}
+type SelectionState = "all" | "none" | "someIncluded" | "someExcluded";
+interface TableInstanceProps {
+    setTableInstance: (e: any) => void;
+    toggleCompact: () => void;
+    toggleStripes: () => void;
+    isCompact: boolean;
+    isStriped: boolean;
+    getVirtualSelectionTotal: () => number;
+    getSelectedRows: () => any[];
+    getExcludedRows: () => any[];
+    getSelectionState: () => SelectionState;
+    clearSelections: () => void;
+    onColumnResize: (e: onResizeProps) => void;
+}
+export declare const useTable: () => {
+    setTableInstance: import("react").Dispatch<import("react").SetStateAction<TableInstanceProps | null>>;
+    toggleCompact: () => void | undefined;
+    toggleStripes: () => void | undefined;
+    isCompact: boolean;
+    isStriped: boolean;
+    getVirtualSelectionTotal: () => number;
+    getSelectedRows: () => any[];
+    getExcludedRows: () => any[];
+    getSelectionState: () => {};
+    clearSelections: () => void | undefined;
+    onColumnResize: (e: onResizeProps) => void | undefined;
+};
+interface TableProps {
+    className?: string;
+    children: React.ReactNode | React.ReactNode[];
+    data: {
+        [key: string]: any;
+    }[];
+    rowHeight?: number;
+    headerHeight?: number;
+    tableInstance?: TableInstanceProps;
+    queryKey?: any;
+    totalRecords?: number;
+    compact?: boolean;
+    focusedRow?: {
+        [key: string]: any;
+    };
+    keyValue?: string;
+    onScroll?: (e: any) => void;
+    allowColumnResize?: boolean;
+    allowColumnReorder?: boolean;
+    showActionColumn?: boolean;
+    showSelection?: boolean;
+    selectAll?: boolean;
+    reloadFn?: () => void;
+    onColumnReorder?: (e: any) => void;
+    onSelectionChanged?: (e: any) => void;
+    onActionButtonClick?: (e: any) => void;
+    onHeaderClick?: (e: any) => void;
+    onColumnResize?: (e: any) => void;
+    onRowUpdated?: (e: any) => void;
+    onRowClick?: (e: any) => void;
+    onRowDoubleClick?: (e: any) => void;
+}
+declare const Table: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<TableProps, never>> & string & Omit<({ className, children, data, rowHeight, headerHeight, tableInstance, queryKey, totalRecords, compact, focusedRow, keyValue, onScroll, allowColumnResize, allowColumnReorder, showActionColumn, showSelection, selectAll, reloadFn, onColumnReorder, onSelectionChanged, onActionButtonClick, onHeaderClick, onColumnResize, onRowUpdated, onRowClick, onRowDoubleClick, }: TableProps) => import("react/jsx-runtime").JSX.Element, keyof import("react").Component<any, {}, any>>;
+export default Table;

package/dist/Table/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from "./Table";
+export { Column } from "./Table";