import currency from 'currency.js';
import { Options as currencyOptions } from 'currency.js';
import { Moment } from 'moment';
import { ChangeEvent, ComponentType, FocusEvent, FunctionComponent, KeyboardEvent, MouseEvent, MouseEventHandler, ReactNode, SyntheticEvent } from 'react';
import { DateRangePickerShape, FocusedInputShape, SingleDatePickerShape } from 'react-dates';
import { Column, Row, TableInstance, TableState, UseSortByColumnProps, UseTableColumnOptions, UseTableRowProps } from 'react-table';
import { DefaultTheme, FlattenSimpleInterpolation, StyledComponent } from 'styled-components';

declare module "react-table" {
	export interface TableOptions<D extends object> extends UseExpandedOptions<D>, UseFiltersOptions<D>, UseGroupByOptions<D>, UsePaginationOptions<D>, UseRowSelectOptions<D>, UseResizeColumnsOptions<D>, UseSortByOptions<D> {
	}
	export interface TableInstance<D extends object = {}> extends UseExpandedInstanceProps<D>, UseFiltersInstanceProps<D>, UseGroupByInstanceProps<D>, UseTableColumnOptions<D>, UsePaginationInstanceProps<D>, UseRowSelectInstanceProps<D>, UseSortByInstanceProps<D> {
	}
	export interface TableState<D extends object = {}> extends UseExpandedState<D>, UseFiltersState<D>, UseGroupByState<D>, UsePaginationState<D>, UseTableColumnOptions<D>, UseRowSelectState<D>, UseSortByState<D> {
		locale?: Locale;
	}
	export interface ColumnInterface<D extends object = {}> extends UseFiltersColumnOptions<D>, UseGroupByColumnOptions<D>, UseResizeColumnsColumnOptions<D>, UseSortByColumnOptions<D> {
		align?: Alignment;
		hasCellPadding?: boolean;
		isCurrency?: boolean;
		// eslint-disable-next-line @typescript-eslint/no-explicit-any
		onClick?: (...args: any[]) => void;
	}
	export interface ColumnInstance<D extends object = {}> extends UseFiltersColumnProps<D>, UseGroupByColumnProps<D>, UseResizeColumnsColumnProps<D>, UseSortByColumnProps<D> {
	}
	export interface Cell<D extends object = {}> extends UseGroupByCellProps<D> {
	}
	export interface Row<D extends object = {}> extends UseExpandedRowProps<D>, UseGroupByRowProps<D>, UseRowSelectRowProps<D> {
		isDisabled?: boolean;
	}
}
export declare const Button: FunctionComponent<ButtonProps & {
	[key: string]: unknown;
}>;
export declare const ButtonIcon: FunctionComponent<ButtonIconProps & {
	[key: string]: any;
}>;
export declare const Card: FunctionComponent<CardProps>;
export declare const CardNoResults: FunctionComponent<CardNoResultsProps>;
export declare const CardStatus: FunctionComponent<CardStatusProps>;
export declare const Chip: FunctionComponent<ChipProps & {
	[key: string]: any;
}>;
export declare const ChipInfo: FunctionComponent<ChipInfoProps>;
export declare const ChipStatus: FunctionComponent<ChipStatusProps>;
export declare const CloseablePanel: FunctionComponent<CloseablePanelProps>;
export declare const ContentCell: FunctionComponent<ContentCellProps>;
export declare const DateRangePicker: FunctionComponent<DateRangePickerProps>;
export declare const Dialog: FunctionComponent<DialogProps>;
export declare const DialogFooter: FunctionComponent<DialogFooterProps>;
export declare const Dropdown: FunctionComponent<DropdownProps & {
	[key: string]: any;
}>;
export declare const DropdownMultiSelect: <T extends DropdownMultiSelectOption>({ allSelectedLabel, buttonCancelText, buttonConfirmText, className, deselectAllLabel, elevation, errorMessage, hasError, isDisabled, isRequired, isValid, label, maxHeight, minHeight, name, noOptionsText, onCancel, onClick, onConfirm, onChange, options, parentContainer, placeholder, resetOnOutsideClick, selectAllLabel, variant, }: DropdownMultiSelectProps<T>) => JSX.Element;
export declare const DropdownSelect: <T extends DropdownSelectOption>({ autoFocus, className, defaultValue, elevation, errorMessage, hasError, iconType, footerText, isDisabled, isRequired, isSearchAny, isValid, label, maxHeight, name, noResultsMessage, onChange, onConfirm, options, optionLabel, value, variant, }: DropdownSelectProps<T>) => JSX.Element;
export declare const EditableInformation: <T extends DropdownOption, U extends DropdownMultiSelectOption>({ amountOfColumns, amountOfRows, data, dateFormat, cancelConfirmDialog, errors, hasAutoFocus, iconCancel, iconEdit, iconSave, iconType, isButtonDisabled, isDisabled, isEditing, isLoading, isSaving, keepEditMode, locale, localeCurrency, onCancel, onChange, onEdit, onSave, onValidation, options, saveConfirmDialog, status, textCancel, textEdit, textSave, title, warnings, }: EditableInformationProps<T, U>) => JSX.Element;
export declare const EditablePanel: FunctionComponent<EditablePanelProps>;
export declare const ErrorMessage: FunctionComponent<ErrorMessageProps>;
export declare const FileUploadDialog: FunctionComponent<FileUploadDialogProps>;
export declare const FileUploader: FunctionComponent<FileUploaderProps>;
export declare const FormElementLabel: FunctionComponent<FormElementLabelProps>;
export declare const FullscreenLoader: FunctionComponent<FullscreenLoaderProps>;
export declare const Header: FunctionComponent<HeaderProps>;
export declare const Icon: FunctionComponent<IconProps>;
export declare const IconCustomizable: FunctionComponent<IconCustomizableProps>;
export declare const InformationTable: FunctionComponent<InformationTableProps>;
export declare const Input: FunctionComponent<InputProps & {
	[key: string]: any;
}>;
export declare const InputColor: FunctionComponent<InputColorProps>;
export declare const InputCurrency: FunctionComponent<InputCurrencyProps>;
export declare const InputPassword: FunctionComponent<InputPasswordProps>;
export declare const Label: FunctionComponent<LabelProps>;
export declare const Link: FunctionComponent<NativeLinkProps | RouterLinkProps>;
export declare const Loader: FunctionComponent<LoaderProps>;
export declare const Menu: FunctionComponent<MenuProps>;
export declare const Modal: FunctionComponent<ModalProps>;
export declare const Overlay: FunctionComponent<OverlayProps>;
export declare const Paginator: <T extends object>({ hasAllPagingButtons, hasGoToPage, hasPageSizeSelector, instance, isDisabled, pageSizes, texts, useResultsOfText, }: PaginatorProps<T>) => JSX.Element;
export declare const PanelHeader: FunctionComponent<PanelHeaderProps>;
export declare const PanelStatus: FunctionComponent<PanelStatusProps>;
export declare const PicklistMultiSelect: <T extends object, U extends T & PicklistMultiSelectOption>({ addButtonText, availablePanelProps, columns, data, fitToScreen, hasPaging, isDisabled, isLoading, locale, loadingNumberOfRows, onChange, options, paginatorTexts, selectedPanelProps, removeButtonText, tableTexts, }: PicklistMultiSelectProps<T, U>) => JSX.Element;
export declare const ProgressBar: FunctionComponent<ProgressBarProps>;
export declare const ScorePicker: FunctionComponent<ScorePickerProps>;
export declare const SelectOption: FunctionComponent<SelectOptionProps>;
export declare const SelectionControl: FunctionComponent<SelectionControlProps & {
	[key: string]: any;
}>;
export declare const SelectionControlGroup: FunctionComponent<SelectionControlGroupProps>;
export declare const SidePanel: FunctionComponent<SidePanelProps>;
export declare const SingleDatePicker: FunctionComponent<SingleDatePickerProps>;
export declare const Skeleton: FunctionComponent<SkeletonProps>;
export declare const StatusCell: FunctionComponent<StatusCellProps>;
export declare const StatusIndicator: FunctionComponent<StatusIndicatorProps>;
export declare const TabHeaders: import("styled-components").StyledComponent<"div", any, {}, never>;
export declare const TabPanel: import("styled-components").StyledComponent<"div", any, TabbPanelProps, never>;
export declare const Table: <T extends object>({ caption, className, elevation, footer, footerTitleColumnSpan, hasUnsortedStateIcon, instance, isDisabled, isFullWidth, noResults, onClickFooter, onClickRow, paginator, texts, }: TableProps<T>) => JSX.Element;
export declare const TableSkeleton: FunctionComponent<TableSkeletonProps>;
export declare const Tabs: FunctionComponent<TabsProps>;
export declare const TextIcon: FunctionComponent<TextIconProps & {
	[key: string]: any;
}>;
export declare const TextWithOptionalIcon: FunctionComponent<TextWithOptionalIconProps & {
	[key: string]: any;
}>;
export declare const TimePicker: FunctionComponent<TimePickerProps>;
export declare const ToggleCheckbox: FunctionComponent<ToggleCheckboxProps>;
export declare const Toolbar: FunctionComponent<ToolbarProps>;
export declare const Tooltip: FunctionComponent<TooltipProps>;
export declare const areAllOptionsSelected: <U, T extends U[]>(data: T, propertyName: keyof U) => boolean;
export declare const areEqualObjects: <T, U>(prevObject: T, nextObject: U, ignoreKeys?: string[] | undefined) => boolean;
export declare const base64ToBlob: (base64: string) => Blob;
export declare const blobToObjectUrl: (input: string) => string;
export declare const capitalizeFirstLetter: (value: string) => string;
export declare const capitalizeFirstLetters: (value: string) => string;
export declare const compareDates: (d1: Moment | Date | string | null, d2: Moment | Date | string | null) => boolean;
export declare const compareValues: <T extends Record<string, unknown>>(key: import("react-table").IdType<T>, desc?: boolean, caseSensitive?: boolean) => (a: UseTableRowProps<T>, b: UseTableRowProps<T>) => number;
export declare const convertLocale: (locale: Locale) => string;
export declare const convertToLocaleValue: (value: number | string, locale: Locale) => string;
export declare const convertToValidURIValue: (value: string) => string;
export declare const createDuiTheme: (baseTheme: Theme, overrides: Partial<Theme>) => Theme;
export declare const createTable: <T extends object>(columns: Column<T>[], data: T[], initialState?: Partial<TableState<T>> | undefined, defaultColumn?: Partial<Column<T>> | undefined, locale?: Locale, tableMultiSelectProps?: TableMultiSelectProps | undefined) => TableInstance<T>;
export declare const currentDate: (lang?: string) => Date;
export declare const customSortByBoolean: <T extends object>(a: UseTableRowProps<T>, b: UseTableRowProps<T>, key: import("react-table").IdType<T>, desc?: boolean) => -1 | 1;
export declare const customSortByCaseInsensitive: <T extends Record<string, unknown>>(rows: UseTableRowProps<T>[], key: import("react-table").IdType<T>) => UseTableRowProps<T>[];
export declare const customSortByDate: <T extends object>(a: UseTableRowProps<T>, b: UseTableRowProps<T>, key: import("react-table").IdType<T>, emptyValuesAtEnd?: boolean) => -1 | 1;
export declare const defaultCurrencySettings: (hasRounding: boolean | undefined, hasSymbol: boolean | undefined, isCentsValue: boolean, locale?: Locale | undefined) => currencyOptions;
export declare const fadeInEffect: ({ duration, easing, isVisible, property, }?: {
	duration?: number | undefined;
	easing?: Easing | undefined;
	isVisible?: boolean | undefined;
	property?: string | undefined;
}) => FlattenSimpleInterpolation;
export declare const formatAsSystemDate: (value: string | Date | Moment, lang?: string) => string;
export declare const formatDate: (value: string | Date | Moment, lang?: string, format?: string) => string;
export declare const formatMoney: (value: number | string, locale: Locale, isCentsValue?: boolean | undefined) => string;
export declare const formatMoneyWithoutSymbol: (value: number | string, locale: Locale, isCentsValue?: boolean | undefined) => string;
export declare const formatTime: (value: string | Date | Moment, addLeadingZero?: boolean) => string;
export declare const getAlignment: (alignment: Alignment, alignText?: boolean) => FlattenSimpleInterpolation;
export declare const getBorderColor: ({ hasError, isDisabled, isFocused, isHovered, isValid, defaultColor, theme, }: {
	defaultColor?: string | undefined;
	hasError?: boolean | undefined;
	isDisabled?: boolean | undefined;
	isFocused?: boolean | undefined;
	isHovered?: boolean | undefined;
	isValid?: boolean | undefined;
	theme: Theme;
}) => string;
export declare const getColumnWidthByPercentage: (availableWidth: number, requestedPercentage: number) => number;
export declare const getCurrencySymbol: (locale?: Locale | undefined) => string;
export declare const getCurrencyType: (locale?: Locale | undefined) => Currencies;
export declare const getDropdownSelectOption: <T extends DropdownSelectOption>(data: T[], value: string) => T | undefined;
export declare const getElevation: (level?: Elevation, isBottomOnly?: boolean) => FlattenSimpleInterpolation;
export declare const getFileFormats: (types: string[]) => string[];
export declare const getFileNames: (files: File[]) => string[];
export declare const getFileSizes: (files: File[]) => number[];
export declare const getFileType: (file: File) => string;
export declare const getFileTypes: (files: File[]) => string[];
export declare const getObjectDifference: <T>(prevObject: T, nextObject: T) => Array<string>;
export declare const getOptionLabel: <T extends DropdownSelectOption>(data: T[], value: string) => string;
export declare const getPosition: (position: Position) => FlattenSimpleInterpolation;
export declare const getSelectedElements: <U, T extends U>(data: T[], propertyName: keyof U) => T[];
export declare const getSelectedRowIds: <T extends SelectableRowObject>(data: T[]) => Record<string, boolean>;
export declare const getSelectedRows: <T extends object>(instance: TableInstance<T>) => T[];
export declare const getSelectedText: <U, T extends U>(selectedOptions: T[], propertyNameDescription: keyof U, delimiter?: string) => string;
export declare const getStatusColor: (status: Status, theme: Theme) => string;
export declare const getStatusIndicator: ({ placement, size, status, theme, }: {
	placement?: Placement | undefined;
	size?: StatusIndicatorSize | undefined;
	status?: Status | undefined;
	theme: Theme;
}) => string;
export declare const getTotalSizeFiles: (fileSizes: number[]) => number;
export declare const hexToRgb: (hex: string, transparency?: number) => string;
export declare const invertColor: (hex: string, bw?: boolean) => string;
export declare const isAnyOptionSelected: <U, T extends U>(data: T[], propertyName: keyof U) => boolean;
export declare const isDateBetween: (date: Moment, dateFrom: Moment, dateTo: Moment) => boolean;
export declare const isDotDecimalCountry: (locale: Locale) => boolean;
export declare const isEmpty: (value: string | unknown | undefined | null | Array<unknown>) => boolean;
export declare const isFutureDate: (date: Moment | null, includeToday?: boolean) => boolean;
export declare const isObject: (object: unknown) => boolean;
export declare const isObjectPropertyChanged: <T>(prevObject: T, nextObject: T, key: keyof T) => boolean;
export declare const isValidClockTime: (value: string) => boolean;
export declare const isValidDate: (value: string | Date | Moment, lang?: string) => boolean;
export declare const isValidEditableInput: <T extends DropdownSelectOption, U extends DropdownMultiSelectOption>(data: EditableInformationData<T, U>, values: {
	[key: string]: ValueTypes<T, U>;
}, locale: Locale) => boolean;
export declare const isValidEmail: (value: string) => boolean;
export declare const isValidIBAN: (value: string) => boolean;
export declare const isValidMoney: (value: string, locale?: Locale | undefined) => boolean;
export declare const isValidNumber: (value: string, allowDecimals?: boolean, locale?: Locale | undefined) => boolean;
export declare const isValidPhoneNumber: (value: string) => boolean;
export declare const isValidStringDate: (inputText: string) => boolean;
export declare const isValidURI: (value: string) => boolean;
export declare const modulo: (aNumStr: string, aDiv: number) => number;
export declare const openBinary: (openBinaryProps: OpenBinaryProps) => void;
export declare const openUrl: (url: string, title?: string | undefined) => void;
export declare const parseClocktimeToTimePickerValue: (value: null | string | undefined) => [
	string,
	string
];
export declare const parseMomentToTimePickerValue: (momentInstance: Moment) => [
	string,
	string
];
export declare const parseTimePickerValueToClocktime: (value: null | undefined | [
	string,
	string
], zeroIsDelete?: boolean | undefined) => string | null;
export declare const picklistMultiSelectFacade: <T, U extends T & PicklistMultiSelectOption>(data: T[], idPropertyName: keyof T, selectedPropertyName: keyof T) => U[];
export declare const removeElement: <U, T extends U>(data: T[], propertyName: keyof U, propertyValue: unknown) => T[];
export declare const renderSortIcon: <T extends object>(column: UseSortByColumnProps<T>, hasUnsortedStateIcon?: boolean) => ReactNode;
export declare const rippleEffect: (backgroundColor?: string) => FlattenSimpleInterpolation;
export declare const rippleEffectInit: () => FlattenSimpleInterpolation;
export declare const rippleEffectReset: () => FlattenSimpleInterpolation;
export declare const selectOptionsExtend: <T, U extends T & DropdownMultiSelectOption>(data: T[], labelPropertyName: keyof T, valuePropertyName: keyof T, selectedPropertyName: keyof T) => U[];
export declare const selectOptionsFacade: <U, T extends U>(data: T[], labelPropertyName: keyof U, valuePropertyName: keyof U) => DropdownOption[];
export declare const setBoxSizing: (boxSizing?: string) => FlattenSimpleInterpolation;
export declare const setCentered: () => FlattenSimpleInterpolation;
export declare const setElementSelected: <U, T extends U>(data: T[], selectedElement: T, propertyIdName: keyof U, propertySelectedName: keyof U, unsetOtherValues?: boolean | undefined) => T[];
export declare const setTruncate: () => FlattenSimpleInterpolation;
export declare const slideUpEffect: ({ duration, easing, isVisible, property, }?: {
	duration?: number | undefined;
	easing?: Easing | undefined;
	isVisible?: boolean | undefined;
	property?: string | undefined;
}) => FlattenSimpleInterpolation;
export declare const sum: (values: Array<string | number>, isCurrency?: boolean, locale?: Locale | undefined) => number;
export declare const themeBasic: Theme;
export declare const themeBasicDefinition: (fontFamilyPrimary: string, fontFamilySecondary: string) => Theme;
export declare const themeCyrillic: Theme;
export declare const themeCyrillicDark: Theme;
export declare const themeDark: Theme;
export declare const toBasicLowercase: (inputString: string) => string;
export declare const toBoolean: (value: string | number | null | undefined) => boolean;
export declare const toCents: (value: number | string) => number;
export declare const toDate: (value: string | Date | Moment, lang?: string) => Date | null;
export declare const toMoment: (value: string | Date | Moment, lang?: string) => Moment | null;
export declare const toMoney: (value: number | string, locale: Locale, isCentsValue?: boolean | undefined) => currency;
export declare const toMoneyValue: (value: number | string, locale: Locale, isCentsValue?: boolean | undefined) => number;
export declare const toNumber: (value: string) => number;
export declare const toString: (value: string | number | boolean) => string;
export declare const transitionEffect: ({ duration, delay, easing, property, }?: {
	duration?: number | undefined;
	delay?: number | undefined;
	easing?: Easing | undefined;
	property?: string | undefined;
}) => FlattenSimpleInterpolation;
export declare const useInterval: (callback: any, delay: number | null) => void;
export declare enum AdornmentPosition {
	LEFT = "LEFT",
	RIGHT = "RIGHT"
}
export declare enum Alignment {
	CENTER = "CENTER",
	LEFT = "LEFT",
	RIGHT = "RIGHT"
}
export declare enum ButtonSize {
	LARGE = "LARGE",
	MEDIUM = "MEDIUM",
	SMALL = "SMALL"
}
export declare enum ButtonVariant {
	FILLED = "FILLED",
	OUTLINE = "OUTLINE",
	TEXT_ONLY = "TEXT_ONLY"
}
export declare enum ChipStatusVariant {
	DESELECTED = "DESELECTED",
	INDETERMINATE = "INDETERMINATE",
	SELECTED = "SELECTED"
}
export declare enum Currencies {
	EUR = "EUR",
	GBP = "GBP",
	KZT = "KZT",
	RUB = "RUB",
	USD = "USD"
}
export declare enum DialogButtonClosePosition {
	LEFT = "LEFT",
	RIGHT = "RIGHT"
}
export declare enum DialogSize {
	DEFAULT = "DEFAULT",
	LARGE = "LARGE",
	MEDIUM = "MEDIUM"
}
export declare enum Direction {
	LTR = "LTR",
	RTL = "RTL"
}
export declare enum DropdownOptionAllTexts {
	INDETERMINATE = "indeterminate",
	OFF = "off",
	ON = "on"
}
export declare enum DropdownVariant {
	COMPACT = "COMPACT",
	OUTLINE = "OUTLINE"
}
export declare enum Easing {
	EASE = "ease",
	EASE_IN = "ease-in",
	EASE_IN_OUT = "ease-in-out",
	EASE_OUT = "ease-out",
	LINEAR = "linear",
	NONE = "none"
}
export declare enum EditableDataComponent {
	CHECKBOX = "Checkbox",
	DATEPICKER = "DatePicker",
	DROPDOWN = "Dropdown",
	DROPDOWNMULTISELECT = "DropdownMultiSelect",
	DROPDOWNSELECT = "DropdownSelect",
	IMMUTABLE = "Immutable",
	INPUT = "Input",
	INPUTCOLOR = "InputColor",
	INPUTCURRENCY = "InputCurrency",
	INPUTNUMBER = "InputNumber",
	SCOREPICKER = "ScorePicker",
	TEXTAREA = "Textarea",
	TIMEPICKER = "TimePicker"
}
export declare enum Elevation {
	LEVEL_0 = "LEVEL_0",
	LEVEL_1 = "LEVEL_1",
	LEVEL_2 = "LEVEL_2",
	LEVEL_3 = "LEVEL_3",
	LEVEL_4 = "LEVEL_4",
	LEVEL_6 = "LEVEL_6",
	LEVEL_8 = "LEVEL_8",
	LEVEL_12 = "LEVEL_12",
	LEVEL_16 = "LEVEL_16",
	LEVEL_24 = "LEVEL_24"
}
export declare enum FileAlertType {
	NAME = "nameError",
	NUMBER = "numberError",
	SIZE = "sizeError",
	TYPE = "typeError"
}
export declare enum FileTypes {
	ARCHIVE = "ZIP, RAR",
	AUDIO = "MP3, MIDI",
	CSV = "CSV",
	EXCEL = "XLS, XLSX, XLSM, XLT, ODS",
	HTML = "HTML",
	IMAGE = "BMP, GIF, JPEG, JPG, PNG",
	OTHER = "OTHER",
	PDF = "PDF",
	POWERPOINT = "PPT, PPTX",
	TEXT = "TXT",
	VCF = "VCF",
	VIDEO = "MP4, MPG, MOV, AVI",
	WORD = "DOC, DOCX, DOT, ODT",
	XML = "XML"
}
export declare enum FullscreenLoaderType {
	CIRCLES = "CIRCLES"
}
export declare enum IconCustomizableSize {
	SIZE120 = "120",
	SIZE128 = "128",
	SIZE14 = "14",
	SIZE18 = "18",
	SIZE20 = "20",
	SIZE22 = "22",
	SIZE24 = "24",
	SIZE26 = "26",
	SIZE28 = "28",
	SIZE30 = "30",
	SIZE32 = "32",
	SIZE34 = "34",
	SIZE36 = "36",
	SIZE38 = "38",
	SIZE40 = "40",
	SIZE42 = "42",
	SIZE44 = "44",
	SIZE46 = "46",
	SIZE48 = "48",
	SIZE50 = "50",
	SIZE64 = "64",
	SIZE84 = "84",
	SIZE96 = "96"
}
export declare enum IconPlacement {
	BOTTOM = "BOTTOM",
	CENTER = "CENTER",
	TOP = "TOP"
}
export declare enum IconSize {
	LARGE = "LARGE",
	MEDIUM = "MEDIUM",
	SMALL = "SMALL",
	XLARGE = "XLARGE",
	XSMALL = "XSMALL"
}
export declare enum IconType {
	ADJUSTMENT = "ADJUSTMENT",
	ADVERTISEMENT = "ADVERTISEMENT",
	ARROWDOWN = "ARROWDOWN",
	ARROWLEFT = "ARROWLEFT",
	ARROWLEFTUP = "ARROWLEFTUP",
	ARROWRIGHT = "ARROWRIGHT",
	ARROWRIGHTUP = "ARROWRIGHTUP",
	ARROWUP = "ARROWUP",
	AWARD = "AWARD",
	BEACH = "BEACH",
	BENCH = "BENCH",
	CABLE = "CABLE",
	CALENDAR = "CALENDAR",
	CALENDARACCEPT = "CALENDARACCEPT",
	CALENDARDECLINE = "CALENDARDECLINE",
	CAMERA = "CAMERA",
	CARDS = "CARDS",
	CHANGE = "CHANGE",
	CHANGE_REVERSE = "CHANGE_REVERSE",
	CHART = "CHART",
	CHECK = "CHECK",
	CHECKBOXCHECK = "CHECKBOXCHECK",
	CHECKBOXMINUS1 = "CHECKBOXMINUS1",
	CHEVRONDOWN = "CHEVRONDOWN",
	CHEVRONFIRST = "CHEVRONFIRST",
	CHEVRONLAST = "CHEVRONLAST",
	CHEVRONLEFT = "CHEVRONLEFT",
	CHEVRONRIGHT = "CHEVRONRIGHT",
	CHEVRONUP = "CHEVRONUP",
	CLIPBOARDCHECK = "CLIPBOARDCHECK",
	CLIPBOARDQUESTION = "CLIPBOARDQUESTION",
	CLOCK = "CLOCK",
	CLUBADD = "CLUBADD",
	CLUBMULTIPLE = "CLUBMULTIPLE",
	CLUBPLACEHOLDER09 = "CLUBPLACEHOLDER09",
	CLUBPLACEHOLDER1 = "CLUBPLACEHOLDER1",
	CLUBPLACEHOLDER10 = "CLUBPLACEHOLDER10",
	CLUBPLACEHOLDER11 = "CLUBPLACEHOLDER11",
	CLUBPLACEHOLDER12 = "CLUBPLACEHOLDER12",
	CLUBPLACEHOLDER13 = "CLUBPLACEHOLDER13",
	CLUBPLACEHOLDER14 = "CLUBPLACEHOLDER14",
	CLUBPLACEHOLDER15 = "CLUBPLACEHOLDER15",
	CLUBPLACEHOLDER16 = "CLUBPLACEHOLDER16",
	CLUBPLACEHOLDER2 = "CLUBPLACEHOLDER2",
	CLUBPLACEHOLDER3 = "CLUBPLACEHOLDER3",
	CLUBPLACEHOLDER4 = "CLUBPLACEHOLDER4",
	CLUBPLACEHOLDER5 = "CLUBPLACEHOLDER5",
	CLUBPLACEHOLDER6 = "CLUBPLACEHOLDER6",
	CLUBPLACEHOLDER7 = "CLUBPLACEHOLDER7",
	CLUBPLACEHOLDER8 = "CLUBPLACEHOLDER8",
	CLUBREMOVE = "CLUBREMOVE",
	CLUBUNKNOWN = "CLUBUNKNOWN",
	COFFEE = "COFFEE",
	COMMUNICATIONMAIL = "COMMUNICATIONMAIL",
	COMMUNICATIONPHONE = "COMMUNICATIONPHONE",
	CONTRIBUTION = "CONTRIBUTION",
	CROSS = "CROSS",
	CURRENCY_CN = "CURRENCY_CN",
	CURRENCY_EU = "CURRENCY_EU",
	CURRENCY_IN = "CURRENCY_IN",
	CURRENCY_JP = "CURRENCY_JP",
	CURRENCY_KR = "CURRENCY_KR",
	CURRENCY_KZ = "CURRENCY_KZ",
	CURRENCY_NL = "CURRENCY_NL",
	CURRENCY_RU = "CURRENCY_RU",
	CURRENCY_SA = "CURRENCY_SA",
	CURRENCY_UK = "CURRENCY_UK",
	CURRENCY_US = "CURRENCY_US",
	DANGER = "DANGER",
	DIAMOND = "DIAMOND",
	DROPDOWN = "DROPDOWN",
	DROPLEFT = "DROPLEFT",
	DROPRIGHT = "DROPRIGHT",
	DROPUP = "DROPUP",
	EVENTGENERIC = "EVENTGENERIC",
	EVENTREDCARD = "EVENTREDCARD",
	EVENTYELLOWCARD = "EVENTYELLOWCARD",
	FENCE = "FENCE",
	FIELDSOCCER = "FIELDSOCCER",
	FILEADD = "FILEADD",
	FILEAUDIO = "FILEAUDIO",
	FILECOMPRESSED = "FILECOMPRESSED",
	FILEDELETE = "FILEDELETE",
	FILEDEV = "FILEDEV",
	FILEDOCUMENT = "FILEDOCUMENT",
	FILEDOWNLOAD = "FILEDOWNLOAD",
	FILEGENERIC = "FILEGENERIC",
	FILEIMAGE = "FILEIMAGE",
	FILEMAIL = "FILEMAIL",
	FILEPRESENTATION = "FILEPRESENTATION",
	FILEREMOVE = "FILEREMOVE",
	FILETABLE = "FILETABLE",
	FILEVIDEO = "FILEVIDEO",
	FLAG = "FLAG",
	FLAME = "FLAME",
	FOLDERADD = "FOLDERADD",
	FOLDERDELETE = "FOLDERDELETE",
	FOLDERGENERIC = "FOLDERGENERIC",
	FOLDEROPEN = "FOLDEROPEN",
	FOLDERREMOVE = "FOLDERREMOVE",
	FOLDERSEARCH = "FOLDERSEARCH",
	GEAR = "GEAR",
	GENDERFEMALE = "GENDERFEMALE",
	GENDERMALE = "GENDERMALE",
	GENDERMIXED = "GENDERMIXED",
	HANDSNAP = "HANDSNAP",
	HANGER = "HANGER",
	HASH = "HASH",
	HEART = "HEART",
	HELPDESK = "HELPDESK",
	HOME = "HOME",
	IDCARD = "IDCARD",
	INDICATOR = "INDICATOR",
	LETTERICON_A = "LETTERICON_A",
	LETTERICON_B = "LETTERICON_B",
	LETTERICON_C = "LETTERICON_C",
	LETTERICON_D = "LETTERICON_D",
	LETTERICON_E = "LETTERICON_E",
	LETTERICON_F = "LETTERICON_F",
	LETTERICON_G = "LETTERICON_G",
	LETTERICON_H = "LETTERICON_H",
	LETTERICON_I = "LETTERICON_I",
	LETTERICON_J = "LETTERICON_J",
	LETTERICON_K = "LETTERICON_K",
	LETTERICON_L = "LETTERICON_L",
	LETTERICON_M = "LETTERICON_M",
	LETTERICON_N = "LETTERICON_N",
	LETTERICON_O = "LETTERICON_O",
	LETTERICON_P = "LETTERICON_P",
	LETTERICON_Q = "LETTERICON_Q",
	LETTERICON_R = "LETTERICON_R",
	LETTERICON_S = "LETTERICON_S",
	LETTERICON_T = "LETTERICON_T",
	LETTERICON_U = "LETTERICON_U",
	LETTERICON_V = "LETTERICON_V",
	LETTERICON_W = "LETTERICON_W",
	LETTERICON_X = "LETTERICON_X",
	LETTERICON_Y = "LETTERICON_Y",
	LETTERICON_Z = "LETTERICON_Z",
	LIGHTBULB = "LIGHTBULB",
	LIGHTPOLE = "LIGHTPOLE",
	LOCATION = "LOCATION",
	LOCKOFF = "LOCKOFF",
	LOCKON = "LOCKON",
	LOGOUT = "LOGOUT",
	MATCHCANCEL = "MATCHCANCEL",
	MATCHCUP = "MATCHCUP",
	MATCHDELETE = "MATCHDELETE",
	MATCHOWN = "MATCHOWN",
	MATCHRESUME = "MATCHRESUME",
	MENU = "MENU",
	MESSAGE = "MESSAGE",
	MINUS = "MINUS",
	MONEY = "MONEY",
	MOVEALL = "MOVEALL",
	MOVELEFTRIGHT = "MOVELEFTRIGHT",
	MOVEUPDOWN = "MOVEUPDOWN",
	NEWS = "NEWS",
	NOTEBOOK = "NOTEBOOK",
	NUMBERICON_0 = "NUMBERICON_0",
	NUMBERICON_1 = "NUMBERICON_1",
	NUMBERICON_2 = "NUMBERICON_2",
	NUMBERICON_3 = "NUMBERICON_3",
	NUMBERICON_4 = "NUMBERICON_4",
	NUMBERICON_5 = "NUMBERICON_5",
	NUMBERICON_6 = "NUMBERICON_6",
	NUMBERICON_7 = "NUMBERICON_7",
	NUMBERICON_8 = "NUMBERICON_8",
	NUMBERICON_9 = "NUMBERICON_9",
	OFFICE = "OFFICE",
	OFFICIALSHIRT = "OFFICIALSHIRT",
	OPTIONS = "OPTIONS",
	PACKAGE = "PACKAGE",
	PASSADD = "PASSADD",
	PASSES = "PASSES",
	PENCIL = "PENCIL",
	PLACEHOLDER = "PLACEHOLDER",
	PLANE = "PLANE",
	PLATFORM = "PLATFORM",
	PLUS = "PLUS",
	POSTBOXIN = "POSTBOXIN",
	POSTBOXOUT = "POSTBOXOUT",
	PUZZLEPIECE = "PUZZLEPIECE",
	QUESTION = "QUESTION",
	REDO = "REDO",
	ROOF = "ROOF",
	ROUNDEURO_DASHED = "ROUNDEURO_DASHED",
	ROUND_ALERT = "ROUND_ALERT",
	ROUND_ALERT_DASHED = "ROUND_ALERT_DASHED",
	ROUND_ARROWDOWN = "ROUND_ARROWDOWN",
	ROUND_ARROWDOWN_DASHED = "ROUND_ARROWDOWN_DASHED",
	ROUND_ARROWLEFT = "ROUND_ARROWLEFT",
	ROUND_ARROWLEFT_DASHED = "ROUND_ARROWLEFT_DASHED",
	ROUND_ARROWRIGHT = "ROUND_ARROWRIGHT",
	ROUND_ARROWRIGHT_DASHED = "ROUND_ARROWRIGHT_DASHED",
	ROUND_ARROWUP = "ROUND_ARROWUP",
	ROUND_ARROWUP_DASHED = "ROUND_ARROWUP_DASHED",
	ROUND_CHECK = "ROUND_CHECK",
	ROUND_CHECK_DASHED = "ROUND_CHECK_DASHED",
	ROUND_CROSS = "ROUND_CROSS",
	ROUND_CROSS_DASHED = "ROUND_CROSS_DASHED",
	ROUND_EURO = "ROUND_EURO",
	ROUND_EURODISABLED = "ROUND_EURODISABLED",
	ROUND_HELP = "ROUND_HELP",
	ROUND_INFO = "ROUND_INFO",
	ROUND_MINUS = "ROUND_MINUS",
	ROUND_MINUS_DASHED = "ROUND_MINUS_DASHED",
	ROUND_NONE = "ROUND_NONE",
	ROUND_PAUSE = "ROUND_PAUSE",
	ROUND_PAUSE_DASHED = "ROUND_PAUSE_DASHED",
	ROUND_PERSON = "ROUND_PERSON",
	ROUND_PLUS = "ROUND_PLUS",
	ROUND_PLUS_DASHED = "ROUND_PLUS_DASHED",
	ROUND_STAR = "ROUND_STAR",
	SCISSORS = "SCISSORS",
	SCOREBOARD = "SCOREBOARD",
	SEARCH = "SEARCH",
	SELECT = "SELECT",
	SHARE = "SHARE",
	SHIELD = "SHIELD",
	SHIRT = "SHIRT",
	SLSHIELD = "SLSHIELD",
	SMARTPHONE = "SMARTPHONE",
	SMILEY_BAD = "SMILEY_BAD",
	SMILEY_GOOD = "SMILEY_GOOD",
	SMILEY_HAPPY = "SMILEY_HAPPY",
	SMILEY_NEUTRAL = "SMILEY_NEUTRAL",
	SMILEY_POOR = "SMILEY_POOR",
	SPARKLE = "SPARKLE",
	SPORTATLETIEK = "SPORTATLETIEK",
	SPORTBASKETBAL = "SPORTBASKETBAL",
	SPORTHANDBAL = "SPORTHANDBAL",
	SPORTHOCKEY = "SPORTHOCKEY",
	SPORTHONKBAL = "SPORTHONKBAL",
	SPORTJUDO = "SPORTJUDO",
	SPORTKORFBAL = "SPORTKORFBAL",
	SPORTKRACHT = "SPORTKRACHT",
	SPORTREDDINGSBRIGADE = "SPORTREDDINGSBRIGADE",
	SPORTVOETBAL = "SPORTVOETBAL",
	SPORTVOLLEYBAL = "SPORTVOLLEYBAL",
	SPORTZWEMMEN = "SPORTZWEMMEN",
	STAREMPTY = "STAREMPTY",
	STARFULL = "STARFULL",
	STARHALF = "STARHALF",
	SUBSTITUTE = "SUBSTITUTE",
	SUN = "SUN",
	SUPPORT = "SUPPORT",
	TIMER = "TIMER",
	TRANSPORT = "TRANSPORT",
	TRASHCAN = "TRASHCAN",
	TUTORIAL = "TUTORIAL",
	TV = "TV",
	TWITTER = "TWITTER",
	UNDO = "UNDO",
	USER = "USER",
	USERADD = "USERADD",
	USERCROSS = "USERCROSS",
	USERDOUBLE = "USERDOUBLE",
	USERDOUBLEADD = "USERDOUBLEADD",
	USERDOUBLECROSS = "USERDOUBLECROSS",
	USERDOUBLEREMOVE = "USERDOUBLEREMOVE",
	USERREMOVE = "USERREMOVE",
	VENDIAGRAM = "VENDIAGRAM",
	VIDEOCAMERA = "VIDEOCAMERA",
	VISIBILITYOFF = "VISIBILITYOFF",
	VISIBILITYON = "VISIBILITYON",
	WATER = "WATER",
	WEBSITE = "WEBSITE",
	WORLD = "WORLD"
}
export declare enum InputType {
	COLOR = "color",
	CURRENCY = "currency",
	EMAIL = "email",
	NUMBER = "number",
	PASSWORD = "password",
	TELEPHONE = "telephone",
	TEXT = "text",
	URI = "uri"
}
export declare enum InputVariant {
	COMPACT = "COMPACT",
	OUTLINE = "OUTLINE"
}
export declare enum Locale {
	BE = "BE",
	DE = "DE",
	EN = "EN",
	FR = "FR",
	GB = "GB",
	KZ = "KZ",
	NL = "NL",
	RU = "RU",
	UK = "UK",
	US = "US"
}
export declare enum ModalSize {
	FULL = "FULL",
	LARGE = "LARGE",
	MEDIUM = "MEDIUM",
	SMALL = "SMALL",
	XLARGE = "XLARGE"
}
export declare enum Placement {
	BOTTOM = "BOTTOM",
	LEFT = "LEFT",
	RIGHT = "RIGHT",
	TOP = "TOP"
}
export declare enum Position {
	BOTTOM_CENTER = "BOTTOM_CENTER",
	BOTTOM_LEFT = "BOTTOM_LEFT",
	BOTTOM_RIGHT = "BOTTOM_RIGHT",
	MIDDLE_CENTER = "MIDDLE_CENTER",
	MIDDLE_LEFT = "MIDDLE_LEFT",
	MIDDLE_RIGHT = "MIDDLE_RIGHT",
	TOP_CENTER = "TOP_CENTER",
	TOP_LEFT = "TOP_LEFT",
	TOP_RIGHT = "TOP_RIGHT"
}
export declare enum SelectionControlGroupVariant {
	COMPACT = "COMPACT",
	OUTLINE = "OUTLINE",
	OUTLINE_CHOICE = "OUTLINE_CHOICE"
}
export declare enum SelectionControlSize {
	DEFAULT = "DEFAULT",
	SMALL = "SMALL"
}
export declare enum SelectionControlType {
	CHECKBOX = "CHECKBOX",
	RADIO = "RADIO"
}
export declare enum SidePanelSize {
	FULL = "FULL",
	LARGE = "LARGE",
	MEDIUM = "MEDIUM",
	SMALL = "SMALL",
	XLARGE = "XLARGE"
}
export declare enum SingleDatePickerVariant {
	COMPACT = "COMPACT",
	OUTLINE = "OUTLINE"
}
export declare enum Size {
	LARGE = "LARGE",
	MEDIUM = "MEDIUM",
	SMALL = "SMALL",
	XLARGE = "XLARGE"
}
export declare enum Status {
	ALERT = "ALERT",
	DATA_ERROR = "DATA_ERROR",
	DEFAULT = "DEFAULT",
	DISABLED = "DISABLED",
	INVALID = "INVALID",
	NONE = "NONE",
	TIP = "TIP",
	VALID = "VALID"
}
export declare enum StatusIndicatorSize {
	LARGE = "LARGE",
	NONE = "NONE",
	SMALL = "SMALL"
}
export declare enum zIndex {
	DIALOG = 10000,
	MODAL = 9996,
	OVERLAY = 10,
	SIDEPANEL = 9997,
	TOOLTIP = 99999999
}
export declare function cloneArray<T = Record<string, unknown>>(data: T[]): T[];
export declare type AmountOfColumns = 1 | 2 | 3;
export declare type EditableInformationData<T extends DropdownSelectOption, U extends DropdownMultiSelectOption> = Array<EditableInformationDataType<T, U>>;
export declare type EditableInformationDataType<T extends DropdownSelectOption, U extends DropdownMultiSelectOption> = CheckboxDataProps | DatePickerDataProps | DropdownDataProps | DropdownMultiSelectDataProps<U> | DropdownSelectDataProps<T> | EditableCheckboxDataProps | EditableDatePickerDataProps | EditableDropdownDataProps | EditableDropdownMultiSelectDataProps<U> | EditableDropdownSelectDataProps<T> | EditableInputCurrencyDataProps | EditableInputDataProps | EditableInputNumberDataProps | EditableTimePickerDataProps | EditableScorePickerDataProps | EditableTextareaDataProps | ImmutableDataProps | InputColorDataProps | InputCurrencyDataProps | InputDataProps | InputNumberDataProps | ScorePickerDataProps | TextareaDataProps | TimePickerDataProps;
export declare type MenuItems = MenuItem[];
export declare type ThemeTextStylesMap = {
	[TextStyle in keyof Theme["textStyles"]]: TextStyle;
};
export declare type ValueTypes<T extends DropdownSelectOption, U extends DropdownMultiSelectOption> = EditableCheckboxDataProps["value"] | EditableDatePickerDataProps["value"] | EditableDropdownDataProps["value"] | EditableDropdownMultiSelectDataProps<U>["options"] | EditableDropdownSelectDataProps<T>["value"] | EditableInputCurrencyDataProps["value"] | EditableInputDataProps["value"] | EditableInputNumberDataProps["value"] | EditableScorePickerDataProps["value"] | EditableTextareaDataProps["value"] | EditableTimePickerDataProps["value"] | InputColorDataProps["value"];
export interface BaseDataProps {
	component: EditableDataComponent;
	errorMessage?: ReactNode;
	hasError?: boolean;
	isDisabled?: boolean;
	isEditable?: boolean;
	isRequired?: boolean;
	isVisibleOnlyOnEdit?: boolean;
	label: ReactNode;
}
export interface ButtonIconProps {
	children?: never;
	className?: string;
	iconType: IconType;
	isDisabled?: boolean;
	isInverted?: boolean;
	onClick?: MouseEventHandler;
	size?: Size;
}
export interface ButtonProps {
	autoFocus?: boolean;
	children?: ReactNode;
	className?: string;
	direction?: Direction;
	hasNoPadding?: boolean;
	iconType?: IconType;
	isCapitalized?: boolean;
	isDisabled?: boolean;
	isFullWidth?: boolean;
	isInverted?: boolean;
	isLoading?: boolean;
	isTruncatable?: boolean;
	onClick?: MouseEventHandler;
	size?: ButtonSize;
	transitionDuration?: number;
	transitionEasing?: Easing;
	variant?: ButtonVariant;
}
export interface CardNoResultsProps {
	children?: never;
	className?: string;
	elevation?: Elevation;
	header: ReactNode;
	iconType?: IconType;
	itemPrefix?: string;
	items?: ReactNode[];
	title?: ReactNode;
}
export interface CardProps {
	children?: ReactNode;
	className?: string;
	elevation?: Elevation;
	hasBorderRadius?: boolean;
	hasFullheightContent?: boolean;
}
export interface CardStatusProps extends CardProps {
	placement?: Placement;
	status?: Status;
}
export interface CheckboxDataProps extends BaseDataProps {
	component: EditableDataComponent.CHECKBOX;
	textValue: string;
	value: SelectionControlProps["isChecked"];
}
export interface ChipInfoProps {
	className?: string;
	iconType: IconType;
	text?: string;
}
export interface ChipProps {
	children?: ReactNode;
	className?: string;
	direction?: Direction;
	iconSize?: IconSize;
	iconType?: IconType;
	isDisabled?: boolean;
	isSelected?: boolean;
	onClick?: MouseEventHandler;
	transitionDuration?: number;
	transitionEasing?: Easing;
}
export interface ChipStatusProps {
	children?: ReactNode;
	className?: string;
	direction?: Direction;
	isDisabled?: boolean;
	onClick?: MouseEventHandler;
	variant?: ChipStatusVariant;
}
export interface CloseablePanelProps extends Omit<PanelHeaderProps, "children" | "options"> {
	children: ReactNode;
	iconClose?: IconType;
	iconOpen?: IconType;
	isOpenDefault?: boolean;
	onToggleIsOpen?: (isOpen: boolean) => void;
}
export interface ConfirmDialog {
	buttonCancelText: ReactNode;
	buttonConfirmText: ReactNode;
	iconType: IconType;
	status?: Status;
	text: ReactNode;
}
export interface ContentCellProps {
	hasLineThrough?: boolean;
	hasNegativeAmountColor?: boolean;
	hasTooltip?: boolean;
	isBold?: boolean;
	isCurrency?: boolean;
	isDisabled?: boolean;
	isImage?: boolean;
	isTime?: boolean;
	locale?: Locale;
	textColor?: string;
	textLinesLimit?: number;
	timeFormat?: string;
	value: string | number | Date | Moment | ReactNode | undefined;
}
export interface DatePickerDataProps extends BaseDataProps {
	component: EditableDataComponent.DATEPICKER;
	dateFormat?: string;
	value: SingleDatePickerProps["date"];
}
export interface DateRangePickerProps {
	buttonCancelText?: ReactNode;
	buttonConfirmText?: ReactNode;
	children?: never;
	className?: string;
	daySize?: number;
	displayFormat?: string;
	endDate: Moment | null;
	endDateId: string;
	endDatePlaceholderText?: string;
	focusedInput: FocusedInputShape | null;
	footerText?: DialogFooterProps["text"];
	hasError?: boolean;
	hasYearSelector?: boolean;
	isDayBlocked?: (day: Moment) => boolean;
	isDayHighlighted?: (day: Moment) => boolean;
	isDisabled?: boolean;
	isOutsideRange?: (day: Moment) => boolean;
	isRequired?: boolean;
	keepOpenOnDateSelect?: boolean;
	label: ReactNode;
	labelMonth?: ReactNode;
	labelYear?: ReactNode;
	minimumNights?: number;
	numberOfMonths?: number;
	onCancel?: MouseEventHandler;
	onConfirm?: MouseEventHandler;
	onDatesChange: DateRangePickerShape["onDatesChange"];
	onFocusChange: DateRangePickerShape["onFocusChange"];
	shortcuts?: Shortcut[];
	shortcutsText?: ReactNode;
	startDate: Moment | null;
	startDateId: string;
	startDatePlaceholderText?: string;
	yearCount?: number;
	yearCountFuture?: number;
}
export interface DialogFooterButtonProps extends ButtonProps {
	alignment?: Alignment;
}
export interface DialogFooterProps {
	alignLeft?: boolean;
	buttons?: DialogFooterButtonProps[];
	children?: never;
	className?: string;
	text?: ReactNode;
}
export interface DialogProps {
	buttonClosePosition?: DialogButtonClosePosition;
	children?: ReactNode;
	className?: string;
	elevation?: Elevation;
	footerButtons: DialogFooterProps["buttons"];
	footerText?: DialogFooterProps["text"];
	hasBodyPadding?: boolean;
	hasButtonClose?: boolean;
	hasHeaderPadding?: boolean;
	hasOverlay?: boolean;
	header?: ReactNode;
	iconPlacement?: IconPlacement;
	iconType?: IconProps["type"];
	isResizable?: boolean;
	isScrollable?: boolean;
	isVisible: boolean;
	onClose?: MouseEventHandler;
	size?: DialogSize;
	status?: Status;
	text?: ReactNode;
	title?: ReactNode;
	transitionDuration?: number;
	transitionEasing?: Easing;
}
export interface DropdownDataProps extends BaseDataProps {
	component: EditableDataComponent.DROPDOWN;
	textValue?: string;
	value: DropdownProps["value"];
}
export interface DropdownMultiSelectDataProps<T extends DropdownMultiSelectOption> extends BaseDataProps {
	component: EditableDataComponent.DROPDOWNMULTISELECT;
	value: T[];
}
export interface DropdownMultiSelectOption extends DropdownOption {
	isSelected: boolean;
}
export interface DropdownMultiSelectProps<T extends DropdownMultiSelectOption> {
	allSelectedLabel: ReactNode;
	buttonCancelText?: ReactNode;
	buttonConfirmText: ReactNode;
	children?: never;
	className?: string;
	deselectAllLabel: ReactNode;
	elevation?: Elevation;
	errorMessage?: ReactNode;
	hasError?: boolean;
	isDisabled?: boolean;
	isRequired?: boolean;
	isValid?: boolean;
	label?: ReactNode;
	maxHeight?: number;
	minHeight?: number;
	name: string;
	noOptionsText?: ReactNode;
	onCancel?: MouseEventHandler;
	onChange?: (options: T[]) => void;
	onClick?: MouseEventHandler;
	onConfirm: (event: SyntheticEvent, options: T[]) => void;
	options: T[];
	parentContainer?: HTMLDivElement;
	placeholder?: string;
	resetOnOutsideClick?: boolean;
	selectAllLabel: ReactNode;
	value?: string;
	variant?: DropdownVariant;
}
export interface DropdownOption extends OptionObject {
}
export interface DropdownProps {
	as?: keyof JSX.IntrinsicElements | ComponentType<any>;
	autoFocus?: boolean;
	children?: ReactNode;
	className?: string;
	errormessage?: ReactNode;
	hasError?: boolean;
	isDisabled?: boolean;
	isOpen?: boolean;
	isRequired?: boolean;
	isValid?: boolean;
	label?: ReactNode;
	name: string;
	noOptionsText?: string;
	onChange?: (event: ChangeEvent<HTMLSelectElement>) => void;
	onClick?: MouseEventHandler;
	options?: DropdownOption[];
	placeholder?: string;
	value: number | string;
	variant?: DropdownVariant;
}
export interface DropdownSelectDataProps<T extends DropdownSelectOption> extends BaseDataProps {
	component: EditableDataComponent.DROPDOWNSELECT;
	value: DropdownSelectProps<T>["value"];
}
export interface DropdownSelectOption extends DropdownOption {
	adornment?: ReactNode;
	searchValue?: string;
}
export interface DropdownSelectProps<T extends DropdownSelectOption> {
	autoFocus?: boolean;
	children?: never;
	className?: string;
	defaultValue?: string;
	elevation?: Elevation;
	errorMessage?: ReactNode;
	footerText?: ReactNode;
	hasError?: boolean;
	iconType: IconType;
	isDisabled?: boolean;
	isRequired?: boolean;
	isSearchAny?: boolean;
	isValid?: boolean;
	label?: ReactNode;
	maxHeight?: number;
	name: string;
	noResultsMessage: string;
	onChange?: (option: T) => void;
	onConfirm?: (event: SyntheticEvent, option: T) => void;
	optionLabel: ReactNode;
	options: T[];
	value: string;
	variant?: InputVariant;
}
export interface EditableCheckboxDataProps extends CheckboxDataProps {
	name: SelectionControlProps["name"];
	placeholder?: SelectionControlProps["label"];
}
export interface EditableDatePickerDataProps extends DatePickerDataProps {
	isOutsideRange?: SingleDatePickerProps["isOutsideRange"];
	name: string;
	parentContainer?: SingleDatePickerProps["parentContainer"];
	placeholder?: SingleDatePickerProps["placeholder"];
}
export interface EditableDropdownDataProps extends DropdownDataProps {
	name: DropdownProps["name"];
	nameTextValue?: string;
	options: DropdownProps["options"];
}
export interface EditableDropdownMultiSelectDataProps<T extends DropdownMultiSelectOption> extends DropdownMultiSelectDataProps<T> {
	allSelectedLabel: DropdownMultiSelectProps<T>["allSelectedLabel"];
	buttonCancelText?: DropdownMultiSelectProps<T>["buttonCancelText"];
	buttonConfirmText?: DropdownMultiSelectProps<T>["buttonConfirmText"];
	deselectAllLabel: DropdownMultiSelectProps<T>["deselectAllLabel"];
	maxHeight?: DropdownMultiSelectProps<T>["maxHeight"];
	minHeight?: DropdownMultiSelectProps<T>["minHeight"];
	name: DropdownMultiSelectProps<T>["name"];
	noOptionsText?: DropdownMultiSelectProps<T>["noOptionsText"];
	options: DropdownMultiSelectProps<T>["options"];
	placeholder: DropdownMultiSelectProps<T>["placeholder"];
	selectAllLabel: DropdownMultiSelectProps<T>["selectAllLabel"];
}
export interface EditableDropdownSelectDataProps<T extends DropdownSelectOption> extends DropdownSelectDataProps<T> {
	defaultValue?: string;
	footerText: DropdownSelectProps<T>["footerText"];
	iconType: DropdownSelectProps<T>["iconType"];
	name: DropdownSelectProps<T>["name"];
	nameId: string;
	noResultsMessage: DropdownSelectProps<T>["noResultsMessage"];
	optionLabel: string;
	options: DropdownSelectProps<T>["options"];
	type: string;
	valueId: string;
}
export interface EditableInformationProps<T extends DropdownOption, U extends DropdownMultiSelectOption> extends Omit<PanelHeaderProps, "children" | "options"> {
	amountOfColumns?: InformationTableProps["amountOfColumns"];
	amountOfRows?: InformationTableProps["amountOfRows"];
	cancelConfirmDialog?: ConfirmDialog;
	data: EditableInformationData<T, U>;
	dateFormat?: string;
	errors?: string[];
	hasAutoFocus?: boolean;
	iconCancel?: IconType;
	iconEdit?: IconType;
	iconSave?: IconType;
	iconType: IconType;
	isButtonDisabled?: boolean;
	isDisabled?: boolean;
	isEditing?: boolean;
	isLoading?: boolean;
	isSaving?: boolean;
	keepEditMode?: boolean;
	locale?: Locale;
	localeCurrency?: Locale;
	onCancel?: () => void;
	onChange?: (data: unknown, isDataChanged: boolean) => void;
	onEdit?: () => void;
	onSave?: (data: {
		[key: string]: ValueTypes<T, U>;
	}, isDataChanged: boolean) => void;
	onValidation?: (isValidData: boolean) => void;
	options?: ReactNode;
	saveConfirmDialog?: ConfirmDialog;
	status?: Status;
	textCancel?: string;
	textEdit?: string;
	textSave?: string;
	warnings?: string[];
}
export interface EditableInputCurrencyDataProps extends InputCurrencyDataProps {
	adornmentPosition?: InputCurrencyProps["adornmentPosition"];
	max?: InputCurrencyProps["max"];
	min?: InputCurrencyProps["min"];
	name: InputCurrencyProps["name"];
	onBlur?: InputCurrencyProps["onBlur"];
	onFocus?: InputCurrencyProps["onFocus"];
	onKeyDown?: InputCurrencyProps["onKeyDown"];
	placeholder?: InputCurrencyProps["label"];
}
export interface EditableInputDataProps extends InputDataProps {
	maxLength?: InputProps["maxLength"];
	minLength?: InputProps["minLength"];
	name: InputProps["name"];
	onBlur?: InputProps["onBlur"];
	onFocus?: InputProps["onFocus"];
	onKeyDown?: InputProps["onKeyDown"];
	placeholder?: InputProps["label"];
}
export interface EditableInputNumberDataProps extends InputNumberDataProps {
	max?: InputProps["max"];
	min?: InputProps["min"];
	name: InputProps["name"];
	onBlur?: InputProps["onBlur"];
	onFocus?: InputProps["onFocus"];
	onKeyDown?: InputProps["onKeyDown"];
	placeholder?: InputProps["label"];
}
export interface EditablePanelProps extends Omit<PanelHeaderProps, "children" | "options"> {
	cancelConfirmDialog?: ConfirmDialog;
	children: ReactNode;
	hasButtons?: boolean;
	hasError?: boolean;
	iconCancel?: IconType;
	iconEdit?: IconType;
	iconSave?: IconType;
	iconType: IconType;
	isButtonDisabled?: boolean;
	isDisabled?: boolean;
	isEditing?: boolean;
	isSaving?: boolean;
	keepEditMode?: boolean;
	onCancel: () => void;
	onEdit: () => void;
	onSave: () => void;
	options?: ReactNode;
	saveConfirmDialog?: ConfirmDialog;
	status?: Status;
	textCancel: string;
	textEdit: string;
	textSave: string;
}
export interface EditableScorePickerDataProps extends ScorePickerDataProps {
	name: ScorePickerProps["name"];
	placeholder: ScorePickerProps["label"];
}
export interface EditableTextareaDataProps extends TextareaDataProps {
	maxLength?: InputProps["maxLength"];
	name: InputProps["name"];
	onBlur?: InputProps["onBlur"];
	onFocus?: InputProps["onFocus"];
	onKeyDown?: InputProps["onKeyDown"];
	placeholder?: InputProps["label"];
}
export interface EditableTimePickerDataProps extends TimePickerDataProps {
	minuteStep?: TimePickerProps["minuteStep"];
	name: TimePickerProps["name"];
}
export interface ErrorMessageProps {
	children?: ReactNode;
	className?: string;
	isOutlineVariant: boolean;
}
export interface FileUploadDialogProps {
	description?: string;
	errors?: ReactNode;
	fileNameLength?: number;
	fileTypes: FileTypes[];
	fileUploaderData: FileUploaderTextData;
	iconCancel?: IconType;
	iconSave?: IconType;
	iconType?: IconType;
	isDescriptionRequired?: boolean;
	isLoading?: boolean;
	isNameRequired?: boolean;
	isVisible: boolean;
	labelInputDescription?: ReactNode;
	labelInputName: ReactNode;
	maxFileSize?: number;
	maxFiles: number;
	maxLengthDescription?: number;
	maxLengthName?: number;
	name?: string;
	onAlert(type: FileAlertType, fileSize?: number): void;
	onClose: () => void;
	onDrop?: (files: File[]) => void;
	onUpload: (files: File[], name?: string, description?: string) => void;
	text?: ReactNode;
	textCancel: string;
	textSave: string;
	title: ReactNode;
}
export interface FileUploaderProps {
	bottomText?: ReactNode;
	buttonText: ReactNode;
	className?: string;
	errors?: ReactNode;
	fileNameLength?: number;
	fileTypes: FileTypes[];
	isDescriptionRequired?: boolean;
	isLoading?: boolean;
	isNameRequired?: boolean;
	labelInputDescription?: ReactNode;
	labelInputName?: ReactNode;
	maxFileSize: number;
	maxFiles: number;
	maxLengthDescription?: number;
	maxLengthName?: number;
	onAlert(type?: FileAlertType, fileSize?: number): void;
	onChangeDescription?: (event: ChangeEvent<HTMLInputElement>) => void;
	onChangeName?: (event: ChangeEvent<HTMLInputElement>) => void;
	onDrop(files: File[]): void;
	topText: ReactNode;
	valueDescription?: string;
	valueName?: string;
}
export interface FileUploaderTextData {
	bottomText?: ReactNode;
	buttonText: ReactNode;
	topText: ReactNode;
}
export interface FormElementLabelProps {
	adornmentPosition?: AdornmentPosition;
	backgroundColor?: string;
	children?: ReactNode;
	className?: string;
	hasAdornment?: boolean;
	hasError?: boolean;
	isActive?: boolean;
	isDisabled?: boolean;
	isFocused?: boolean;
	isHovered?: boolean;
	isRequired?: boolean;
	isValid?: boolean;
	variant?: InputVariant;
}
export interface FullscreenLoaderProps {
	amount?: number;
	children?: never;
	className?: string;
	type?: FullscreenLoaderType;
}
export interface HeaderProps {
	buttons?: Omit<ButtonIconProps, "isInverted">[];
	children?: ReactNode;
	className?: string;
	elevation?: Elevation;
	isInverted?: boolean;
	title?: ReactNode;
}
export interface IconCustomizableProps {
	className?: string;
	iconColor?: string;
	iconSize: IconCustomizableSize;
	iconType: IconType;
	isDisabled?: boolean;
	isRotating?: boolean;
}
export interface IconProps {
	children?: never;
	className?: string;
	type: IconType;
}
export interface ImmutableDataProps extends BaseDataProps {
	component: EditableDataComponent.IMMUTABLE;
	value: ReactNode | null;
}
export interface InformationTableData {
	isDisabled?: boolean;
	isRequired?: boolean;
	isTextArea?: boolean;
	label: ReactNode;
	value: ReactNode;
}
export interface InformationTableProps {
	amountOfColumns?: AmountOfColumns;
	amountOfRows?: number;
	children?: ReactNode;
	data?: InformationTableData[];
	errors?: string[];
	isDisabled?: boolean;
	isLoading?: boolean;
	isSidePanel?: boolean;
	isTextArea?: boolean;
	warnings?: string[];
}
export interface InputColorDataProps extends BaseDataProps {
	component: EditableDataComponent.INPUTCOLOR;
	name: InputColorProps["name"];
	value: InputColorProps["value"];
}
export interface InputColorProps extends Pick<InputProps, "isDisabled" | "name" | "onChange"> {
	value?: string;
}
export interface InputCurrencyDataProps extends BaseDataProps {
	component: EditableDataComponent.INPUTCURRENCY;
	value: InputCurrencyProps["value"];
}
export interface InputCurrencyProps extends InputProps {
	adornmentPosition?: AdornmentPosition;
	children?: never;
	className?: string;
	errorMessage?: ReactNode;
	hasError?: boolean;
	hasNegativeAmountColor?: boolean;
	isDisabled?: boolean;
	isRequired?: boolean;
	isValid?: boolean;
	label?: ReactNode;
	locale: Locale;
	name: string;
	value?: string;
	variant?: InputVariant;
}
export interface InputDataProps extends BaseDataProps {
	component: EditableDataComponent.INPUT;
	type?: InputProps["type"];
	value: InputProps["value"];
}
export interface InputNumberDataProps extends BaseDataProps {
	component: EditableDataComponent.INPUTNUMBER;
	value: number | null;
}
export interface InputPasswordProps {
	children?: never;
	className?: string;
	errorMessage?: ReactNode;
	hasError?: boolean;
	isDisabled?: boolean;
	isRequired?: boolean;
	isValid?: boolean;
	isVisibleDefault?: boolean;
	label: ReactNode;
	maxLength?: number;
	minLength?: number;
	name: string;
	onChange: (event: ChangeEvent<HTMLInputElement>) => void;
	onKeyDown?: (event: KeyboardEvent<HTMLInputElement>) => void;
	value?: string;
	variant?: InputVariant;
}
export interface InputProps {
	adornment?: ReactNode;
	adornmentPosition?: AdornmentPosition;
	autoFocus?: boolean;
	children?: never;
	className?: string;
	errorMessage?: ReactNode;
	hasError?: boolean;
	hasNegativeAmountColor?: boolean;
	hasTransparentBackground?: boolean;
	ignoreOutlineVariant?: boolean;
	isDisabled?: boolean;
	isOnChangeRequired?: boolean;
	isRequired?: boolean;
	isTextarea?: boolean;
	isValid?: boolean;
	label?: ReactNode;
	locale?: Locale;
	max?: number;
	maxLength?: number;
	min?: number;
	minLength?: number;
	name: string;
	onBlur?: (event: FocusEvent<HTMLInputElement>) => void;
	onChange?: (event: ChangeEvent<HTMLInputElement>) => void;
	onClick?: MouseEventHandler;
	onFocus?: (event: FocusEvent<HTMLInputElement>) => void;
	onKeyDown?: (event: KeyboardEvent<HTMLInputElement>) => void;
	type?: InputType;
	value?: string | null;
	variant?: InputVariant;
}
export interface LabelProps {
	children?: ReactNode;
	className?: string;
	hasAlternativeTextStyle?: boolean;
	hasError?: boolean;
	isActive?: boolean;
	isDisabled?: boolean;
	isFocused?: boolean;
	isHovered?: boolean;
	isSelectionControlLabel?: boolean;
	isSmall?: boolean;
	isTruncatable?: boolean;
	isValid?: boolean;
}
export interface LinkProps {
	children: ReactNode;
	hasHoverEffect?: boolean;
	isDisabled?: boolean;
	onClick?: () => void;
}
export interface LoaderProps {
	children?: never;
	className?: string;
	isInverted?: boolean;
	size: Size;
	variant?: ButtonVariant;
}
export interface MenuItem extends MenuItemChild {
	children?: MenuItemChild[];
	iconType: IconType;
}
export interface MenuItemChild {
	exact?: boolean;
	isDisabled?: boolean;
	isVisible?: boolean;
	onClick?: () => void;
	path: string;
	text: ReactNode;
}
export interface MenuProps {
	children?: never;
	className?: string;
	defaultOpenItemPath?: string;
	items: MenuItems;
}
export interface ModalProps {
	children?: ReactNode;
	className?: string;
	isScrollable?: boolean;
	isVisible: boolean;
	onBack?: MouseEventHandler;
	onBackIconType?: IconType;
	options?: ReactNode;
	size?: ModalSize;
	title: ReactNode;
	transitionDuration?: number;
	transitionEasing?: Easing;
}
export interface NativeLinkProps extends LinkProps {
	as?: StyledComponent<"a", DefaultTheme> | "a";
	href: string;
	rel?: string;
	target?: string;
}
export interface OpenBinaryProps {
	base64Data: string;
	height?: number;
	isEncoded?: boolean;
	mimeType?: string;
	title?: string;
	width?: number;
}
export interface OptionObject {
	isDisabled?: boolean;
	label: string;
	value: string | number;
}
export interface OverlayProps {
	children?: never;
	className?: string;
	isModalSidePanel?: boolean;
	isVisible?: boolean;
	onClick?: MouseEventHandler;
}
export interface PaginatorProps<T extends object> {
	children?: never;
	className?: string;
	hasAllPagingButtons?: boolean;
	hasGoToPage?: boolean;
	hasPageSizeSelector?: boolean;
	instance: TableInstance<T>;
	isDisabled?: boolean;
	pageSizes?: (number | string)[];
	texts: PaginatorTexts;
	useResultsOfText?: boolean;
}
export interface PaginatorTexts {
	page: ReactNode;
	pageGoto: ReactNode;
	pageOf: ReactNode;
	resultsOf: ReactNode;
	rowsPerPage: ReactNode;
	show: ReactNode;
}
export interface PanelHeaderProps {
	children?: never;
	hasCapitalizedTitle?: boolean;
	hasMarginBottom?: boolean;
	hasTitleStatusAppearance?: boolean;
	iconType?: IconType;
	isDisabled?: boolean;
	isLoading?: boolean;
	isReversed?: boolean;
	options?: ReactNode;
	status?: Status;
	title: ReactNode;
}
export interface PanelStatusProps extends Omit<CardStatusProps, "className" | "placement">, Omit<PanelHeaderProps, "children"> {
}
export interface PicklistMultiSelectOption {
	id: string | number;
	isSelected: boolean;
}
export interface PicklistMultiSelectPanelProps {
	footer?: ReactNode;
	iconType: IconType;
	status?: Status;
	title: string;
}
export interface PicklistMultiSelectProps<T extends object, U extends T & PicklistMultiSelectOption> {
	addButtonText: string;
	availablePanelProps: PicklistMultiSelectPanelProps;
	columns: Column<T>[];
	data: U[];
	fitToScreen?: boolean;
	hasPaging?: boolean;
	isDisabled?: boolean;
	isLoading?: boolean;
	loadingNumberOfRows?: number;
	locale?: Locale;
	onChange?: (removed: T[], added: T[], updated: T[]) => void;
	options: Partial<TableState<T>>;
	paginatorTexts?: PaginatorTexts;
	removeButtonText: string;
	selectedPanelProps: PicklistMultiSelectPanelProps;
	tableTexts?: TableTexts;
}
export interface ProgressBarProps {
	isIndeterminate?: boolean;
}
export interface RouterLinkProps extends LinkProps {
	as?: StyledComponent<"button", DefaultTheme> | "button";
	to: string;
}
export interface ScorePickerDataProps extends BaseDataProps {
	component: EditableDataComponent.SCOREPICKER;
	value: ScorePickerProps["value"];
}
export interface ScorePickerProps {
	autoFocus?: boolean;
	errorMessage?: ReactNode;
	hasError?: boolean;
	isDisabled?: boolean;
	label: [
		ReactNode,
		ReactNode
	];
	name: string;
	onChange: (name: string, score: ScorePickerProps["value"]) => void;
	value: [
		string,
		string
	];
}
export interface SelectOptionProps {
	children?: ReactNode;
	className?: string;
	isDisabled?: boolean;
	isHidden?: boolean;
	value: string | number;
}
export interface SelectableRowObject {
	isRowSelected?: boolean;
}
export interface SelectionControlGroupProps {
	alignment?: Alignment;
	children?: never;
	className?: string;
	defaultValue?: string;
	direction?: Direction;
	groupName: string;
	hasError?: boolean;
	isDisabled?: boolean;
	isHorizontal?: boolean;
	isRequired?: boolean;
	onChange: (selectedValue: string) => void;
	options: OptionObject[];
	title?: ReactNode;
	variant?: SelectionControlGroupVariant;
}
export interface SelectionControlProps {
	children?: never;
	className?: string;
	direction?: Direction;
	errorMessage?: ReactNode;
	hasAlternativeTextStyle?: boolean;
	hasError?: boolean;
	hasHorizontalCorrection?: boolean;
	hasVerticalCorrection?: boolean;
	isChecked?: boolean;
	isDisabled?: boolean;
	isIndeterminate?: boolean;
	isTableElement?: boolean;
	isValid?: boolean;
	label: ReactNode;
	name: string;
	onChange?: (event: ChangeEvent<HTMLInputElement> | MouseEvent<HTMLButtonElement>) => void;
	size?: SelectionControlSize;
	transitionDuration?: number;
	transitionEasing?: Easing;
	type?: SelectionControlType;
	value: string | number;
}
export interface Shortcut {
	onClick: MouseEventHandler;
	text: ReactNode;
}
export interface SidePanelProps {
	buttons?: Omit<ButtonIconProps, "isInverted">[];
	children?: ReactNode;
	className?: string;
	isModalSidePanel?: boolean;
	isVisible: boolean;
	onBack?: MouseEventHandler;
	options?: ReactNode;
	size?: SidePanelSize;
	title: ReactNode;
	transitionDuration?: number;
	transitionEasing?: Easing;
}
export interface SingleDatePickerProps {
	buttonCancelText?: ReactNode;
	buttonConfirmText?: ReactNode;
	children?: never;
	className?: string;
	date?: SingleDatePickerShape["date"];
	daySize?: number;
	displayFormat?: string;
	errorMessage?: ReactNode;
	footerText?: DialogFooterProps["text"];
	hasError?: boolean;
	hasYearSelector?: boolean;
	id: string;
	isDayBlocked?: (day: Moment) => boolean;
	isDayHighlighted?: (day: Moment) => boolean;
	isDisabled?: boolean;
	isFocused: boolean;
	isOutsideRange?: (day: Moment) => boolean;
	isRequired?: boolean;
	keepOpenOnDateSelect?: boolean;
	label?: ReactNode;
	labelMonth?: ReactNode;
	labelYear?: ReactNode;
	numberOfMonths?: number;
	onCancel?: MouseEventHandler;
	onClose?: SingleDatePickerShape["onClose"];
	onConfirm?: MouseEventHandler;
	onDateChange: SingleDatePickerShape["onDateChange"];
	onFocusChange: SingleDatePickerShape["onFocusChange"];
	parentContainer?: HTMLDivElement;
	placeholder?: string;
	variant?: SingleDatePickerVariant;
	yearCount?: number;
	yearCountFuture?: number;
}
export interface SkeletonProps {
	children?: never;
	circle?: boolean;
	color?: string;
	count?: number;
	duration?: number;
	height?: string | number;
	highlightColor?: string;
	width?: string | number;
}
export interface StatusCellProps {
	hasStatusIndicator?: boolean;
	icon?: IconType;
	iconColor?: string;
	image?: string | ReactNode;
	status: Status;
	tooltipText?: string;
}
export interface StatusIndicatorProps {
	as?: keyof JSX.IntrinsicElements | ComponentType<any>;
	background?: string;
	children?: ReactNode;
	className?: string;
	placement?: Placement;
	size?: StatusIndicatorSize;
	status: Status;
	tooltipText?: string;
}
export interface Tab {
	content: ReactNode;
	isDisabled?: boolean;
	padding?: {
		bottom: number;
		left: number;
		right: number;
		top: number;
	};
	title: ReactNode;
}
export interface TabbPanelProps {
	padding: {
		bottom: number;
		left: number;
		right: number;
		top: number;
	};
}
export interface TableMultiSelectProps {
	isDisabled?: boolean;
	isMultiSelect: boolean;
	maximumSelected?: number;
	minimumSelected?: number;
	propNameRowSelectAllowed?: string;
}
export interface TableProps<T extends object> {
	caption?: ReactNode;
	children?: never;
	className?: string;
	elevation?: Elevation;
	footer?: ReactNode;
	footerTitleColumnSpan?: number;
	hasUnsortedStateIcon?: boolean;
	instance: TableInstance<T>;
	isDisabled?: boolean;
	isFullWidth?: boolean;
	noResults?: ReactNode | string;
	onClickFooter?: (event: SyntheticEvent) => void;
	onClickRow?: (event: SyntheticEvent, row: Row<T>, tableState: TableState<T>) => void;
	paginator?: ReactNode;
	texts?: TableTexts;
}
export interface TableSkeletonProps {
	isHeaderVisible?: boolean;
	numberOfRowsPerTable?: number;
	numberOfTables?: number;
	showRowsInCard?: boolean;
}
export interface TableTexts {
	sortByTooltip?: ReactNode;
}
export interface TabsProps {
	children?: never;
	className?: string;
	hasFullWidthTabHeaders?: boolean;
	hasPadding?: boolean;
	initiallyActiveTabIndex?: number;
	isChangeTabAllowed?: boolean;
	isSmall?: boolean;
	onClickTab?: (event: SyntheticEvent, tabIndex: number) => void;
	tabs: Tab[];
}
export interface TextIconProps {
	children?: never;
	className?: string;
	size?: Size;
	text: string;
}
export interface TextWithOptionalIconProps {
	children?: ReactNode;
	className?: string;
	direction?: Direction;
	iconSize?: IconSize;
	iconType?: IconType;
	isCapitalized?: boolean;
	isDisabled?: boolean;
	isSelectable?: boolean;
	isTruncatable?: boolean;
}
export interface TextareaDataProps extends BaseDataProps {
	component: EditableDataComponent.TEXTAREA;
	value: InputProps["value"];
}
export interface Theme {
	shades: {
		one: string;
		two: string;
		three: string;
		four: string;
		five: string;
		six: string;
		seven: string;
		eight: string;
		nine: string;
	};
	colorPrimary: string;
	colorSecondary: string;
	colorTertiary: string;
	colorAlert: string;
	colorDisabled: string;
	colorInvalid: string;
	colorValid: string;
	fontFamilyPrimary: string;
	fontFamilySecondary: string;
	colorTextContrast: {
		primary: string;
	};
	colorText: {
		primary: string;
		secondary: string;
	};
	colorTextBody: {
		primary: string;
		secondary: string;
	};
	background: {
		primary: string;
		secondary: string;
		tertiary: string;
	};
	button: {
		filled: {
			backgroundColor: {
				disabled: string;
				hover: string;
				hoverInverted: string;
				inverted: string;
				loader: string;
				loaderInverted: string;
				primary: string;
			};
			color: {
				disabled: string;
				hover: string;
				hoverInverted: string;
				inverted: string;
				primary: string;
			};
		};
		outline: {
			backgroundColor: {
				disabled: string;
				hover: string;
				hoverInverted: string;
				inverted: string;
				loader: string;
				loaderInverted: string;
				primary: string;
			};
			color: {
				disabled: string;
				hover: string;
				hoverInverted: string;
				inverted: string;
				primary: string;
			};
		};
		textOnly: {
			disabled: string;
			disabledInverted: string;
			hover: string;
			hoverInverted: string;
			inverted: string;
			loader: string;
			loaderInverted: string;
			primary: string;
		};
	};
	card: {
		backgroundColor: string;
	};
	datePicker: {
		backgroundColor: string;
		color: string;
		day: {
			accent: string;
			backgroundColor: string;
			color: string;
			disabled: {
				backgroundColor: string;
				color: string;
			};
			hover: {
				accent: string;
				backgroundColor: string;
				color: string;
			};
			selected: {
				backgroundColor: string;
				color: string;
			};
			selectionLimit: {
				backgroundColor: string;
				color: string;
			};
		};
	};
	header: {
		backgroundColor: {
			primary: string;
			secondary: string;
		};
	};
	hover: {
		backgroundColor: string;
	};
	loader: {
		primary: string;
		secondary: string;
	};
	table: {
		footer: {
			backgroundColor: string;
		};
		row: {
			backgroundColorEven: string;
			backgroundColorOdd: string;
			borderColorRowSelector: string;
			borderColorRowSelectorDisabled: string;
		};
	};
	textStyles: {
		body1: ThemeTextStyle;
		body2: ThemeTextStyle;
		buttonLarge: ThemeTextStyle;
		buttonMedium: ThemeTextStyle;
		buttonSmall: ThemeTextStyle;
		caption: ThemeTextStyle;
		caption2: ThemeTextStyle;
		h1: ThemeTextStyle;
		h2: ThemeTextStyle;
		h3: ThemeTextStyle;
	};
	spacingValue: number;
	availableTextStyles: () => ThemeTextStylesMap;
	spacing: (factor1: number, factor2?: number, factor3?: number, factor4?: number) => string;
	textStyling: (textStyleSelector: keyof Theme["textStyles"]) => string;
	[key: string]: any;
}
export interface ThemeTextStyle {
	fontFamily: string;
	fontSize: string;
	fontWeight: string;
	lineHeight: string;
}
export interface TimePickerDataProps extends BaseDataProps {
	component: EditableDataComponent.TIMEPICKER;
	value: TimePickerProps["value"];
}
export interface TimePickerProps {
	autoFocus?: boolean;
	errorMessage?: ReactNode;
	hasError?: boolean;
	isDisabled?: boolean;
	minuteStep?: number;
	name: string;
	onChange: (name: string, time: TimePickerProps["value"]) => void;
	value: [
		string,
		string
	];
}
export interface ToggleCheckboxProps {
	className?: string;
	iconOff?: IconType;
	iconOn?: IconType;
	isDisabled?: boolean;
	isInitialChecked?: boolean;
	onChange(value: boolean): void;
	size?: ButtonSize;
	textOff: ReactNode;
	textOn: ReactNode;
}
export interface ToolbarProps {
	children?: ReactNode;
	className?: string;
	isInverted?: boolean;
}
export interface TooltipProps {
	children?: never;
	className?: string;
	delay?: number;
	elevation?: Elevation;
	position?: Placement;
	transitionDuration?: number;
	transitionEasing?: Easing;
}

export as namespace DexelsUIKit;

export {};