suomifi-ui-components/dist/types/index.d.ts

Suomi.fi UI component library

import React$1, { HTMLProps, ReactNode, ButtonHTMLAttributes, ReactElement, FocusEvent, RefObject, CSSProperties, ChangeEvent } from 'react';
import { ColorDesignTokens, TypographyDesignTokens, SpacingDesignTokens, GradientDesignTokens, FocusDesignTokens, RadiusDesignTokens, ShadowDesignTokens, TransitionDesignTokens, RawDesignTokens, BreakpointDesignTokens } from 'suomifi-design-tokens';
export { ColorDesignTokens, ColorToken, DesignTokens, RawColorDesignTokens, RawDesignTokens, RawSpacingDesignTokens, RawTypographyDesignTokens, SpacingDesignTokens, TypographyDesignTokens, TypographyToken, ValueUnit, suomifiDesignTokens } from 'suomifi-design-tokens';
export * from 'suomifi-icons';

type asPropType = keyof JSX.IntrinsicElements | React.ComponentType<any>;

interface HtmlAProps extends Omit<HTMLProps<HTMLAnchorElement>, 'ref' | 'as'> {
    children: ReactNode;
    as?: asPropType;
}

interface HtmlButtonProps extends Omit<HTMLProps<HTMLButtonElement>, 'ref' | 'as'> {
    as?: asPropType;
    type?: ButtonHTMLAttributes<HTMLButtonElement>['type'];
    forwardedRef?: React$1.Ref<HTMLButtonElement>;
}

interface HtmlDivProps extends Omit<HTMLProps<HTMLDivElement>, 'ref' | 'as'> {
    asProp?: asPropType;
}
interface HtmlDivWithRefProps extends HtmlDivProps {
    forwardedRef?: React$1.Ref<HTMLDivElement>;
}

type hLevels = 'h1' | 'h2' | 'h3' | 'h4' | 'h5';
interface HtmlHProps extends Omit<HTMLProps<HTMLHeadingElement>, 'ref' | 'as'> {
    as?: asPropType;
}

interface HtmlInputProps extends Omit<HTMLProps<HTMLInputElement>, 'ref' | 'as'> {
    as?: asPropType;
    type?: string;
    forwardedRef?: React$1.Ref<HTMLInputElement> | React$1.RefObject<HTMLInputElement>;
}

interface HtmlLiProps extends Omit<HTMLProps<HTMLLIElement>, 'as'> {
    as?: asPropType;
    forwardedRef?: React$1.Ref<HTMLLIElement>;
}

interface HtmlNavProps extends Omit<HTMLProps<HTMLElement>, 'ref' | 'as'> {
    as?: asPropType;
    forwardedRef?: React$1.Ref<HTMLElement>;
}

interface HtmlSpanProps extends Omit<HTMLProps<HTMLSpanElement>, 'ref' | 'as'> {
    asProp?: asPropType;
}

interface HtmlTextareaProps extends Omit<HTMLProps<HTMLTextAreaElement>, 'ref' | 'as'> {
    as?: asPropType;
    forwardedRef?: React$1.Ref<HTMLTextAreaElement>;
}

interface HtmlUlProps extends Omit<HTMLProps<HTMLUListElement>, 'type' | 'as'> {
    as?: asPropType;
}

interface HtmlTableProps extends Omit<HTMLProps<HTMLTableElement>, 'ref' | 'as' | 'data' | 'children'> {
    forwardedRef?: React$1.Ref<HTMLTableElement>;
    children?: React$1.ReactNode;
}

type SpacingWithoutInsetProp = 'xxs' | 'xs' | 's' | 'm' | 'l' | 'xl' | 'xxl' | 'xxxl' | 'xxxxl' | '0';
interface PaddingProps {
    padding?: SpacingWithoutInsetProp;
    pt?: SpacingWithoutInsetProp;
    pr?: SpacingWithoutInsetProp;
    pb?: SpacingWithoutInsetProp;
    pl?: SpacingWithoutInsetProp;
    px?: SpacingWithoutInsetProp;
    py?: SpacingWithoutInsetProp;
}
interface MarginProps {
    margin?: SpacingWithoutInsetProp;
    mt?: SpacingWithoutInsetProp;
    mr?: SpacingWithoutInsetProp;
    mb?: SpacingWithoutInsetProp;
    ml?: SpacingWithoutInsetProp;
    mx?: SpacingWithoutInsetProp;
    my?: SpacingWithoutInsetProp;
}
type GlobalMargins = {
    all?: MarginProps;
    alert?: MarginProps;
    actionMenu?: MarginProps;
    block?: MarginProps;
    button?: MarginProps;
    breadcrumb?: MarginProps;
    checkbox?: MarginProps;
    checkboxGroup?: MarginProps;
    chip?: MarginProps;
    dateInput?: MarginProps;
    dropdown?: MarginProps;
    expander?: MarginProps;
    expanderGroup?: MarginProps;
    externalLink?: MarginProps;
    fileInput?: MarginProps;
    heading?: MarginProps;
    hintText?: MarginProps;
    inlineAlert?: MarginProps;
    label?: MarginProps;
    languageMenu?: MarginProps;
    link?: MarginProps;
    linkList?: MarginProps;
    loadingSpinner?: MarginProps;
    multiSelect?: MarginProps;
    notification?: MarginProps;
    pagination?: MarginProps;
    paragraph?: MarginProps;
    radioButton?: MarginProps;
    radioButtonGroup?: MarginProps;
    routerLink?: MarginProps;
    searchInput?: MarginProps;
    serviceNavigation?: MarginProps;
    sideNavigation?: MarginProps;
    singleSelect?: MarginProps;
    staticChip?: MarginProps;
    statusText?: MarginProps;
    table?: MarginProps;
    text?: MarginProps;
    textarea?: MarginProps;
    textInput?: MarginProps;
    timeInput?: MarginProps;
    toast?: MarginProps;
    toggleInput?: MarginProps;
    toggleButton?: MarginProps;
    tooltip?: MarginProps;
    wizardNavigation?: MarginProps;
};
interface SpacingProps extends PaddingProps, MarginProps {
}

type ButtonVariant = 'default' | 'inverted' | 'secondary' | 'secondaryNoBorder' | 'secondaryLight';
type ForcedAccessibleNameProps = {
    children: ReactNode;
    'aria-label'?: string;
} | {
    children?: never;
    'aria-label': string;
};
type LoadingProps$2 = {
    loading?: false;
    ariaLoadingText?: never;
} | {
    loading?: true;
    ariaLoadingText: string;
};
interface InternalButtonProps extends Omit<HtmlButtonProps, 'aria-disabled' | 'onClick'>, MarginProps {
    variant?: ButtonVariant;
    disabled?: boolean;
    'aria-disabled'?: boolean;
    className?: string;
    fullWidth?: boolean;
    icon?: ReactElement;
    iconRight?: ReactElement;
    onClick?: (event: React$1.MouseEvent) => void;
    forwardedRef?: React$1.RefObject<HTMLButtonElement>;
}
type ButtonProps = InternalButtonProps & ForcedAccessibleNameProps & LoadingProps$2 & {
    globalMargins?: GlobalMargins;
};
declare const Button: React$1.ForwardRefExoticComponent<ButtonProps & React$1.RefAttributes<HTMLButtonElement>>;

interface ActionMenuItemProps {
    className?: string;
    children: ReactNode;
    disabled?: boolean;
    icon?: ReactElement;
    onClick?: (event: React$1.MouseEvent) => void;
}
declare const ActionMenuItem: {
    (props: ActionMenuItemProps): React$1.JSX.Element;
    displayName: string;
};

interface ActionMenuDividerProps {
    className?: string;
}
declare const ActionMenuDivider: {
    (props: ActionMenuDividerProps): React$1.JSX.Element;
    displayName: string;
};

type MenuContent$1 = Array<ReactElement<ActionMenuItemProps> | ReactElement<ActionMenuDividerProps>> | ReactElement<ActionMenuItemProps> | ReactElement<ActionMenuDividerProps>;
type ActionMenuProps = MarginProps & Omit<ButtonProps, keyof ForcedAccessibleNameProps | keyof LoadingProps$2> & {
    buttonText?: ReactNode;
    buttonVariant?: ButtonVariant;
    'aria-label'?: string;
    children?: MenuContent$1;
    className?: string;
    menuClassName?: string;
    disabled?: boolean;
    forwardedRef?: React$1.RefObject<HTMLButtonElement>;
    fullWidth?: boolean;
    id?: string;
    name?: string;
    onBlur?: (event: FocusEvent<HTMLButtonElement>) => void;
    onClose?: () => void;
    onOpen?: () => void;
};
declare const ActionMenu: React$1.ForwardRefExoticComponent<MarginProps & Omit<ButtonProps, "aria-label" | "children" | "loading" | "ariaLoadingText"> & {
    buttonText?: ReactNode;
    buttonVariant?: ButtonVariant | undefined;
    'aria-label'?: string | undefined;
    children?: MenuContent$1 | undefined;
    className?: string | undefined;
    menuClassName?: string | undefined;
    disabled?: boolean | undefined;
    forwardedRef?: React$1.RefObject<HTMLButtonElement> | undefined;
    fullWidth?: boolean | undefined;
    id?: string | undefined;
    name?: string | undefined;
    onBlur?: ((event: FocusEvent<HTMLButtonElement>) => void) | undefined;
    onClose?: (() => void) | undefined;
    onOpen?: (() => void) | undefined;
} & React$1.RefAttributes<HTMLButtonElement>>;

interface BreadcrumbProps extends HtmlNavProps, MarginProps {
    'aria-label': string;
    className?: string;
    children?: ReactNode;
}
declare const Breadcrumb: {
    (props: BreadcrumbProps): React$1.JSX.Element;
    displayName: string;
};

type UnderlineVariant = 'initial' | 'hover';
interface BaseLinkProps extends HtmlAProps {
    href: string;
    className?: string;
    children: ReactNode;
    underline?: UnderlineVariant;
    variant?: 'default' | 'accent';
    asProp?: asPropType;
    smallScreen?: boolean;
}

interface LinkProps extends BaseLinkProps, MarginProps {
    forwardedRef?: React$1.Ref<HTMLAnchorElement>;
}
declare const Link: React$1.ForwardRefExoticComponent<LinkProps & React$1.RefAttributes<HTMLAnchorElement>>;

type newWindowProps = {
    toNewWindow: false;
    labelNewWindow?: never;
} | {
    toNewWindow?: true;
    labelNewWindow: string;
};
interface InternalExternalLinkProps extends BaseLinkProps, MarginProps {
    hideIcon?: boolean;
    toNewWindow?: boolean;
    labelNewWindow?: string;
    forwardedRef?: React$1.Ref<HTMLAnchorElement>;
}
type ExternalLinkProps = newWindowProps & InternalExternalLinkProps;
declare const ExternalLink: React$1.ForwardRefExoticComponent<ExternalLinkProps & React$1.RefAttributes<HTMLAnchorElement>>;

interface SkipLinkProps extends BaseLinkProps {
    forwardedRef?: React$1.Ref<HTMLAnchorElement>;
}
declare const SkipLink: React$1.ForwardRefExoticComponent<SkipLinkProps & React$1.RefAttributes<HTMLAnchorElement>>;

type PropsOf<C extends keyof JSX.IntrinsicElements | React$1.JSXElementConstructor<any>> = JSX.LibraryManagedAttributes<C, React$1.ComponentPropsWithoutRef<C>>;
type AsProp<C extends React$1.ElementType> = {
    asComponent?: C;
};
type ExtendableProps<ExtendedProps = {}, OverrideProps = {}> = OverrideProps & Omit<ExtendedProps, keyof OverrideProps>;
type InheritableElementProps<C extends React$1.ElementType, Props = {}> = ExtendableProps<PropsOf<C>, Props>;
type PolymorphicRef<C extends React$1.ElementType> = React$1.ComponentPropsWithRef<C>['ref'];
type ForwardedRef<C extends React$1.ElementType> = {
    forwardedRef?: PolymorphicRef<C>;
};
type PolymorphicComponentProps<C extends React$1.ElementType, Props = {}> = InheritableElementProps<C, Props & AsProp<C> & ForwardedRef<C>>;
interface Props extends MarginProps {
    className?: string;
    children: ReactNode;
    underline?: UnderlineVariant;
}
type RouterLinkProps<C extends React$1.ElementType> = PolymorphicComponentProps<C, Props>;
declare const RouterLinkInner: <C extends React$1.ElementType<any, keyof React$1.JSX.IntrinsicElements> = "a">(props: RouterLinkProps<C>, ref?: PolymorphicRef<C> | undefined) => React$1.JSX.Element;
declare const RouterLink: <C extends React$1.ElementType<any, keyof React$1.JSX.IntrinsicElements> = "a">(props: Props & AsProp<C> & ForwardedRef<C> & Omit<JSX.LibraryManagedAttributes<C, React$1.PropsWithoutRef<React$1.ComponentProps<C>>>, "forwardedRef" | "asComponent" | keyof Props> & {
    ref?: PolymorphicRef<C> | undefined;
}) => ReturnType<typeof RouterLinkInner>;

interface LinkListItemProps extends Omit<HtmlLiProps, 'className'> {
    forwardedRef?: React$1.Ref<HTMLLIElement>;
    icon?: ReactElement;
    children: ReactElement<LinkProps | ExternalLinkProps | RouterLinkProps<React$1.ElementType>>;
    className?: string;
}
declare const LinkListItem: React$1.ForwardRefExoticComponent<Omit<LinkListItemProps, "ref"> & React$1.RefAttributes<HTMLElement>>;

interface LinkListProps extends HtmlUlProps, MarginProps {
    forwardedRef?: React$1.Ref<HTMLUListElement>;
    ariaLabelledBy: string;
    smallScreen?: boolean;
}
declare const LinkList: React$1.ForwardRefExoticComponent<Omit<LinkListProps, "ref"> & React$1.RefAttributes<HTMLUListElement>>;

interface BreadcrumbLinkProps extends Omit<LinkProps, 'href' | 'margin' | 'mx' | 'my' | 'mt' | 'mr' | 'mb' | 'ml'> {
    current?: boolean;
    href?: string;
}
declare const BreadcrumbLink: (props: BreadcrumbLinkProps) => React$1.JSX.Element;

interface AlertProps extends HtmlDivProps, MarginProps {
    status?: 'neutral' | 'warning' | 'error';
    children?: ReactNode;
    smallScreen?: boolean;
    closeText: string;
    onCloseButtonClick?: () => void;
    closeButtonProps?: Omit<HtmlButtonProps, 'onClick' | 'aria-label'>;
    forwardedRef?: React$1.RefObject<HTMLDivElement>;
}
declare const Alert: React$1.ForwardRefExoticComponent<AlertProps & React$1.RefAttributes<HTMLDivElement>>;

interface InlineAlertProps extends HtmlDivProps, MarginProps {
    status?: 'neutral' | 'warning' | 'error';
    children?: ReactNode;
    smallScreen?: boolean;
    labelText?: ReactNode;
    forwardedRef?: React$1.RefObject<HTMLDivElement>;
}
declare const InlineAlert: React$1.ForwardRefExoticComponent<InlineAlertProps & React$1.RefAttributes<HTMLDivElement>>;

type CloseButtonProps$1 = {
    showCloseButton: false;
    closeText?: string;
    onCloseButtonClick?: () => void;
    closeButtonProps?: Omit<ButtonProps, 'onClick' | keyof LoadingProps$2>;
} | {
    showCloseButton?: true;
    closeText: string;
    onCloseButtonClick?: () => void;
    closeButtonProps?: Omit<ButtonProps, 'onClick'>;
};
type NotificationProps = HtmlDivProps & MarginProps & CloseButtonProps$1 & {
    status?: 'neutral' | 'error';
    headingText?: string;
    children?: ReactNode;
    actionElements?: ReactNode;
    headingVariant?: Exclude<hLevels, 'h1'>;
    smallScreen?: boolean;
    regionAriaLabel?: string;
};
declare const Notification: React$1.ForwardRefExoticComponent<NotificationProps & React$1.RefAttributes<HTMLDivElement>>;

type InternalToastProps = MarginProps & HtmlDivWithRefProps & {
    headingText?: string;
    children?: ReactNode;
    className?: string;
    headingVariant?: Exclude<hLevels, 'h1'>;
    id?: string;
    forwardedRef?: RefObject<HTMLDivElement>;
};
type CloseButtonProps = {
    showCloseButton?: false;
    closeText?: string;
    onCloseButtonClick?: () => void;
    closeButtonProps?: Omit<ButtonProps, 'onClick' | keyof LoadingProps$2>;
} | {
    showCloseButton: true;
    closeText: string;
    onCloseButtonClick?: () => void;
    closeButtonProps?: Omit<ButtonProps, 'onClick'>;
};
type ToastProps = InternalToastProps & CloseButtonProps;
declare const Toast: React$1.ForwardRefExoticComponent<ToastProps & React$1.RefAttributes<HTMLDivElement>>;

type BlockVariant = 'default' | 'div' | 'span' | 'section' | 'header' | 'nav' | 'main' | 'footer';
interface BlockProps extends HtmlDivProps, SpacingProps {
    variant?: BlockVariant;
    forwardedRef?: React$1.Ref<any>;
}
declare const Block: React$1.ForwardRefExoticComponent<BlockProps & React$1.RefAttributes<any>>;

interface HtmlDetailsProps extends Omit<HTMLProps<HTMLDetailsElement>, 'ref' | 'as' | 'children'> {
    forwardedRef?: React$1.Ref<HTMLDetailsElement>;
    children?: React$1.ReactNode;
}

interface DetailsProps extends HtmlDetailsProps, MarginProps {
    className?: string;
    children: ReactNode;
    onClick?: (event: React$1.MouseEvent) => void;
    forwardedRef?: React$1.RefObject<HTMLDetailsElement>;
    summaryLabel: ReactNode;
    open?: boolean;
}
declare const Details: React$1.ForwardRefExoticComponent<DetailsProps & React$1.RefAttributes<HTMLDetailsElement>>;

interface BaseChipProps {
    children: ReactNode;
    className?: string;
    disabled?: boolean;
}

interface StaticChipProps extends BaseChipProps, MarginProps, Omit<HtmlSpanProps, 'children'> {
    forwardedRef?: React$1.Ref<HTMLSpanElement>;
}
declare const StaticChip: React$1.ForwardRefExoticComponent<StaticChipProps & React$1.RefAttributes<HTMLSpanElement>>;

interface ChipProps extends BaseChipProps, MarginProps, Omit<HtmlButtonProps, 'forwardedRef' | 'disabled' | 'onClick' | 'children' | 'as'> {
    onClick?: () => void;
    removable?: boolean;
    actionLabel?: string;
    'aria-disabled'?: boolean;
    forwardedRef?: React$1.RefObject<HTMLButtonElement>;
}
declare const Chip: React$1.ForwardRefExoticComponent<ChipProps & React$1.RefAttributes<HTMLButtonElement>>;

type LoadingSpinnerStatus = 'loading' | 'success' | 'failed';
interface LoadingSpinnerProps extends MarginProps, HtmlDivProps {
    className?: string;
    id?: string;
    text: string;
    textAlign?: 'bottom' | 'right';
    textVisibility?: 'visible' | 'hidden';
    status?: LoadingSpinnerStatus;
    variant?: 'normal' | 'small';
    forwardedRef?: React$1.Ref<HTMLDivElement>;
}
declare const LoadingSpinner: React$1.ForwardRefExoticComponent<LoadingSpinnerProps & React$1.RefAttributes<HTMLDivElement>>;

interface ToggleBaseProps {
    checked?: boolean;
    defaultChecked?: boolean;
    className?: string;
    disabled?: boolean;
    children?: ReactNode;
    'aria-label'?: string;
    'aria-labelledby'?: string;
    id?: string;
}

interface ToggleInputProps extends ToggleBaseProps, MarginProps, Omit<HtmlInputProps, 'onChange' | 'type'> {
    name?: string;
    onChange?: (checked: boolean) => void;
    forwardedRef?: React$1.RefObject<HTMLInputElement>;
}
declare const ToggleInput: React$1.ForwardRefExoticComponent<ToggleInputProps & React$1.RefAttributes<HTMLInputElement>>;

interface ToggleButtonProps extends ToggleBaseProps, MarginProps, Omit<HtmlButtonProps, 'onClick' | 'type'> {
    onClick?: (checked: boolean) => void;
    forwardedRef?: React$1.RefObject<HTMLButtonElement>;
}
declare const ToggleButton: React$1.ForwardRefExoticComponent<ToggleButtonProps & React$1.RefAttributes<HTMLButtonElement>>;

type LabelMode = 'hidden' | 'visible';
interface LabelProps extends Omit<HtmlSpanProps, 'as'>, MarginProps {
    id?: string;
    className?: string;
    children: ReactNode;
    contentClassName?: string;
    contentStyle?: CSSProperties;
    labelMode?: LabelMode;
    asProp?: asPropType;
    optionalText?: string;
    tooltipComponent?: ReactElement;
    forceTooltipRerender?: boolean;
}
declare const Label: {
    (props: LabelProps): React$1.JSX.Element;
    displayName: string;
};

type InputStatus = 'default' | 'error' | 'success';
type AriaLiveMode = 'assertive' | 'polite' | 'off';
interface StatusTextCommonProps {
    statusText?: string;
    statusTextAriaLiveMode?: AriaLiveMode;
}
type characterCounterProps = {
    characterLimit?: never;
    ariaCharactersRemainingText?: never;
    ariaCharactersExceededText?: never;
} | {
    characterLimit?: number;
    ariaCharactersRemainingText: (amount: number) => string;
    ariaCharactersExceededText: (amount: number) => string;
};

type TextInputValue = string | number | undefined;
interface BaseTextInputProps extends StatusTextCommonProps, MarginProps, Omit<HtmlInputProps, 'type' | 'onChange' | 'onClick' | 'onBlur'> {
    className?: string;
    disabled?: boolean;
    onClick?: () => void;
    onChange?: (value: TextInputValue) => void;
    onBlur?: (event: FocusEvent<HTMLInputElement>) => void;
    labelText: ReactNode;
    labelMode?: LabelMode;
    visualPlaceholder?: string;
    hintText?: string;
    status?: InputStatus;
    type?: 'text' | 'email' | 'number' | 'password' | 'tel' | 'url';
    name?: string;
    value?: TextInputValue;
    fullWidth?: boolean;
    optionalText?: string;
    debounce?: number;
    icon?: ReactElement;
    tooltipComponent?: ReactElement;
}
type TextInputProps = characterCounterProps & BaseTextInputProps;
declare const TextInput: React$1.ForwardRefExoticComponent<TextInputProps & React$1.RefAttributes<HTMLInputElement>>;

interface TimeInputProps extends StatusTextCommonProps, MarginProps, Omit<HtmlInputProps, 'type' | 'onChange' | 'onBlur' | 'defaultValue' | 'onClick'> {
    className?: string;
    disabled?: boolean;
    onClick?: () => void;
    onChange?: (value: string) => void;
    onBlur?: (inputValue: string | null) => void;
    labelText: ReactNode;
    labelMode?: LabelMode;
    visualPlaceholder?: string;
    hintText?: string;
    status?: InputStatus;
    name?: string;
    defaultValue?: string;
    value?: string;
    optionalText?: string;
    debounce?: number;
    tooltipComponent?: ReactElement;
}
declare const TimeInput: React$1.ForwardRefExoticComponent<TimeInputProps & React$1.RefAttributes<HTMLInputElement>>;

type SearchInputStatus = Exclude<InputStatus, 'success'>;
type SearchSuggestionItem = {
    uniqueId: string;
    label: string;
    [key: string]: any;
};
type AutoSuggestProps = {
    autosuggest?: false | never;
    onSuggestionSelected?: (suggestionId: string) => void;
    suggestionHintText?: string;
    ariaOptionsAvailableText?: string;
    suggestions?: SearchSuggestionItem[];
    popoverClassName?: string;
} | {
    autosuggest: true;
    onSuggestionSelected: (suggestionId: string) => void;
    suggestionHintText: string;
    ariaOptionsAvailableText: string;
    suggestions?: SearchSuggestionItem[];
    popoverClassName?: string;
};
type SearchInputProps = StatusTextCommonProps & MarginProps & AutoSuggestProps & Omit<HtmlInputProps, 'type' | 'disabled' | 'onChange' | 'onBlur' | 'onSearch' | 'onClick' | 'value' | 'defaultValue'> & {
    className?: string;
    labelText: ReactNode;
    labelMode?: LabelMode;
    visualPlaceholder?: string;
    clearButtonLabel: string;
    searchButtonLabel: string;
    searchButtonProps?: Omit<HtmlButtonProps, 'onClick' | 'tabIndex'>;
    status?: SearchInputStatus;
    name?: string;
    fullWidth?: boolean;
    value?: string;
    defaultValue?: string;
    onChange?: (value: string) => void;
    onBlur?: (event: FocusEvent<HTMLInputElement>, value: string) => void;
    onSearch?: (value: string) => void;
    debounce?: number;
    forwardedRef?: React$1.RefObject<HTMLInputElement>;
    showSearchButtonLabel?: boolean;
    showSearchIcon?: boolean;
};
declare const SearchInput: React$1.ForwardRefExoticComponent<SearchInputProps & React$1.RefAttributes<HTMLInputElement>>;

declare const autocompleteTimeString: (timeStr: string) => string | null;
interface HTMLAttributesIncludingDataAttributes<T> extends React$1.HTMLAttributes<T> {
    [dataAttribute: `data-${string}`]: any;
}

type CheckboxStatus = Exclude<InputStatus, 'success'>;
interface CheckboxProps extends StatusTextCommonProps, MarginProps, Omit<HtmlInputProps, 'onClick' | 'value'> {
    checked?: boolean;
    defaultChecked?: boolean;
    className?: string;
    disabled?: boolean;
    onClick?: ({ checkboxState }: {
        checkboxState: boolean;
    }) => void;
    children?: ReactNode;
    variant?: 'small' | 'large';
    status?: CheckboxStatus;
    hintText?: string;
    'aria-label'?: string;
    'aria-labelledby'?: string;
    'aria-describedby'?: string;
    id?: string;
    name?: string;
    value?: string;
    forwardedRef?: React$1.RefObject<HTMLInputElement>;
    labelProps?: Omit<HTMLAttributesIncludingDataAttributes<HTMLLabelElement>, 'htmlFor' | 'id'>;
}
declare const Checkbox: React$1.ForwardRefExoticComponent<CheckboxProps & React$1.RefAttributes<HTMLInputElement>>;

type CheckboxGroupStatus = Exclude<InputStatus, 'success'>;
interface CheckboxGroupProps extends MarginProps, HtmlDivWithRefProps {
    className?: string;
    children: Array<React$1.ReactElement<CheckboxProps> | ReactNode>;
    groupHintText?: string;
    labelText: ReactNode;
    labelMode?: 'hidden' | 'visible';
    optionalText?: string;
    id?: string;
    groupStatus?: CheckboxGroupStatus;
    groupStatusText?: string;
    tooltipComponent?: ReactElement;
    forwardedRef?: React$1.Ref<HTMLDivElement>;
}
declare const CheckboxGroup: React$1.ForwardRefExoticComponent<CheckboxGroupProps & React$1.RefAttributes<HTMLDivElement>>;

type RadioButtonGroupStatus = Exclude<InputStatus, 'success'>;
interface RadioButtonGroupProps extends MarginProps, Omit<HtmlDivWithRefProps, 'onChange'> {
    className?: string;
    children: Array<React$1.ReactElement<RadioButtonProps> | ReactNode>;
    groupHintText?: string;
    groupStatus?: RadioButtonGroupStatus;
    groupStatusText?: string;
    labelText: ReactNode;
    labelMode?: 'hidden' | 'visible';
    optionalText?: string;
    id?: string;
    name: string;
    value?: string;
    defaultValue?: string;
    onChange?: (value: string) => void;
    tooltipComponent?: ReactElement;
    forwardedRef?: React$1.RefObject<HTMLDivElement>;
}
declare const RadioButtonGroup: React$1.ForwardRefExoticComponent<RadioButtonGroupProps & React$1.RefAttributes<HTMLDivElement>>;

interface RadioButtonProps extends MarginProps, Omit<HtmlInputProps, 'onChange'> {
    className?: string;
    children?: ReactNode;
    name?: string;
    value: string;
    id?: string;
    hintText?: string;
    disabled?: boolean;
    variant?: 'small' | 'large';
    status?: RadioButtonGroupStatus;
    checked?: boolean;
    defaultChecked?: boolean;
    onChange?: (event: React$1.ChangeEvent<HTMLInputElement>) => void;
    'aria-labelledby'?: string;
    forwardedRef?: React$1.RefObject<HTMLInputElement>;
    labelProps?: Omit<HTMLAttributesIncludingDataAttributes<HTMLLabelElement>, 'htmlFor'>;
}
declare const RadioButton: React$1.ForwardRefExoticComponent<RadioButtonProps & React$1.RefAttributes<HTMLInputElement>>;

type FilterInputStatus = Exclude<InputStatus, 'success'>;

interface SingleSelectData {
    labelText: string;
    disabled?: boolean;
    uniqueItemId: string;
    listItemProps?: HTMLAttributesIncludingDataAttributes<HTMLLIElement>;
}
type SingleSelectStatus = FilterInputStatus & {};
type AriaOptionsAvailableProps$1 = {
    ariaOptionsAvailableText?: never;
    ariaOptionsAvailableTextFunction: (length: number) => string;
} | {
    ariaOptionsAvailableText: string;
    ariaOptionsAvailableTextFunction?: never;
};
interface InternalSingleSelectProps<T extends SingleSelectData> {
    className?: string;
    items: Array<T & SingleSelectData>;
    id?: string;
    labelText: ReactNode;
    optionalText?: string;
    hintText?: string;
    clearButtonLabel: string;
    onItemSelectionChange?: (selectedItem: (T & SingleSelectData) | null) => void;
    visualPlaceholder?: string;
    defaultSelectedItem?: T & SingleSelectData;
    onChange?: (value: string) => void;
    onChangeWithoutDebounce?: (value: string) => void;
    onBlur?: () => void;
    debounce?: number;
    status?: SingleSelectStatus;
    statusText?: string;
    selectedItem?: (T & SingleSelectData) | null;
    onItemSelect?: (uniqueItemId: string | null) => void;
    disabled?: boolean;
    tooltipComponent?: ReactElement;
    forwardedRef?: React$1.RefObject<HTMLInputElement>;
    listProps?: HTMLAttributesIncludingDataAttributes<HTMLUListElement>;
    popoverClassName?: string;
    fullWidth?: boolean;
}
type LoadingProps$1 = {
    loading?: false;
    loadingText?: string;
} | {
    loading?: true;
    loadingText: string;
};
type AllowItemAdditionProps$1 = {
    allowItemAddition?: false;
    itemAdditionHelpText?: never;
    noItemsText: string;
} | {
    allowItemAddition?: true;
    itemAdditionHelpText: string;
    noItemsText?: never;
};
type SingleSelectProps<T> = InternalSingleSelectProps<T & SingleSelectData> & Omit<HtmlDivProps, 'onChange' | 'onBlur'> & AllowItemAdditionProps$1 & AriaOptionsAvailableProps$1 & MarginProps & LoadingProps$1;
declare function SingleSelectInner<T>(props: SingleSelectProps<T & SingleSelectData>, ref: React$1.RefObject<HTMLInputElement>): React$1.JSX.Element;
declare const SingleSelect: <T>(props: SingleSelectProps<T & SingleSelectData> & {
    ref?: React$1.ForwardedRef<HTMLInputElement> | undefined;
}) => ReturnType<typeof SingleSelectInner>;

interface MultiSelectData {
    labelText: string;
    chipText?: string;
    disabled?: boolean;
    uniqueItemId: string;
    listItemProps?: HTMLAttributesIncludingDataAttributes<HTMLLIElement>;
}
type MultiSelectStatus = FilterInputStatus & {};
type AriaOptionsAvailableProps = {
    ariaOptionsAvailableText?: never;
    ariaOptionsAvailableTextFunction: (length: number) => string;
} | {
    ariaOptionsAvailableText: string;
    ariaOptionsAvailableTextFunction?: never;
};
type AriaOptionChipRemovedProps = {
    ariaOptionChipRemovedText: string;
    ariaOptionChipRemovedTextFunction?: never;
} | {
    ariaOptionChipRemovedText?: never;
    ariaOptionChipRemovedTextFunction: (option: string) => string;
};
type AriaSelectedAmountProps = {
    ariaSelectedAmountText: string;
    ariaSelectedAmountTextFunction?: never;
} | {
    ariaSelectedAmountText?: never;
    ariaSelectedAmountTextFunction: (amount: number) => string;
};
type LoadingProps = {
    loading?: false;
    loadingText?: string;
} | {
    loading?: true;
    loadingText: string;
};
interface InternalMultiSelectProps<T extends MultiSelectData> {
    className?: string;
    items: Array<T & MultiSelectData>;
    id?: string;
    labelText: ReactNode;
    optionalText?: string;
    hintText?: string;
    onItemSelectionsChange?: (selectedItems: Array<T & MultiSelectData>) => void;
    chipListVisible?: boolean;
    ariaChipActionLabel?: string;
    removeAllButtonLabel?: string;
    visualPlaceholder?: string;
    defaultSelectedItems?: Array<T & MultiSelectData>;
    onChange?: (value: string) => void;
    onChangeWithoutDebounce?: (value: string) => void;
    onBlur?: () => void;
    debounce?: number;
    status?: MultiSelectStatus;
    statusText?: string;
    selectedItems?: Array<T & MultiSelectData>;
    onItemSelect?: (uniqueItemId: string) => void;
    onRemoveAll?: () => void;
    disabled?: boolean;
    tooltipComponent?: ReactElement;
    forwardedRef?: React$1.RefObject<HTMLInputElement>;
    listProps?: HTMLAttributesIncludingDataAttributes<HTMLUListElement>;
    popoverClassName?: string;
    fullWidth?: boolean;
}
type AllowItemAdditionProps = {
    allowItemAddition?: false;
    itemAdditionHelpText?: never;
    noItemsText: string;
} | {
    allowItemAddition?: true;
    itemAdditionHelpText: string;
    noItemsText?: never;
};
type MultiSelectProps<T> = InternalMultiSelectProps<T & MultiSelectData> & AllowItemAdditionProps & AriaOptionsAvailableProps & AriaOptionChipRemovedProps & AriaSelectedAmountProps & MarginProps & Omit<HtmlDivProps, 'onChange' | 'onBlur'> & LoadingProps;
declare function MultiSelectInner<T>(props: MultiSelectProps<T & MultiSelectData>, ref: React$1.RefObject<HTMLInputElement>): React$1.JSX.Element;
declare const MultiSelect: <T>(props: MultiSelectProps<T & MultiSelectData> & {
    ref?: React$1.ForwardedRef<HTMLInputElement> | undefined;
}) => ReturnType<typeof MultiSelectInner>;

interface StatusTextProps extends HtmlSpanProps, MarginProps {
    id?: string;
    children?: ReactNode;
    className?: string;
    disabled?: boolean;
    status?: InputStatus;
    ariaLiveMode?: AriaLiveMode;
    forwardedRef?: React$1.Ref<HTMLSpanElement>;
}
declare const StatusText: React$1.ForwardRefExoticComponent<StatusTextProps & React$1.RefAttributes<HTMLSpanElement>>;

interface HintTextProps extends HtmlSpanProps, MarginProps {
    id?: string;
    children?: ReactNode;
    className?: string;
    forwardedRef?: React$1.Ref<HTMLSpanElement>;
}
declare const HintText: React$1.ForwardRefExoticComponent<HintTextProps & React$1.RefAttributes<HTMLSpanElement>>;

declare const languages: readonly ["fi", "en", "sv"];
type Language = (typeof languages)[number];
interface DatePickerTextProps {
    openButtonLabel?: string;
    selectedDateLabel?: string;
    closeButtonText?: string;
    selectButtonText?: string;
    yearSelectLabel?: string;
    monthSelectLabel?: string;
    nextMonthButtonLabel?: string;
    prevMonthButtonLabel?: string;
    monthNames?: [
        string,
        string,
        string,
        string,
        string,
        string,
        string,
        string,
        string,
        string,
        string,
        string
    ];
    weekDays?: [string, string, string, string, string, string, string];
    weekDayAbbreviations?: [
        string,
        string,
        string,
        string,
        string,
        string,
        string
    ];
}

interface DateAdapter {
    format: (date: Date) => string;
    parse: (value: string) => Date;
}

type datePickerAlignment = 'center' | 'left' | 'right';
interface DatePickerProps {
    datePickerEnabled?: boolean;
    datePickerProps?: Omit<HTMLAttributesIncludingDataAttributes<HTMLDivElement>, 'onChange' | 'style' | 'aria-hidden' | 'ref'>;
    datePickerPosition?: datePickerAlignment;
    smallScreen?: boolean;
    datePickerTexts?: DatePickerTextProps;
    language?: Language;
    minDate?: Date;
    maxDate?: Date;
    initialDate?: Date;
    shouldDisableDate?: (date: Date) => boolean;
    dateAdapter?: DateAdapter;
    onDatePickerButtonBlur?: (event: FocusEvent<HTMLButtonElement>) => void;
}
interface DateInputProps extends DatePickerProps, MarginProps, StatusTextCommonProps, Omit<HtmlInputProps, 'type' | 'onChange' | 'onClick' | 'onBlur'> {
    className?: string;
    disabled?: boolean;
    onClick?: (event?: React$1.MouseEvent<HTMLInputElement>) => void;
    onChange?: (change: {
        value: string;
        date: Date;
    }) => void;
    onBlur?: (event: FocusEvent<HTMLInputElement>) => void;
    labelText: ReactNode;
    labelMode?: LabelMode;
    visualPlaceholder?: string;
    hintText?: string;
    status?: InputStatus;
    value?: string;
    fullWidth?: boolean;
    optionalText?: string;
    debounce?: number;
    tooltipComponent?: ReactElement;
}
declare const DateInput: React$1.ForwardRefExoticComponent<DateInputProps & React$1.RefAttributes<HTMLInputElement>>;

interface BasicErrorSummaryItemProps {
    text: string;
}
type InputReferenceProps = {
    inputId: string;
    inputRef?: never;
} | {
    inputId?: never;
    inputRef: React$1.RefObject<HTMLElement>;
};
type ErrorSummaryItemProps = BasicErrorSummaryItemProps & InputReferenceProps;
interface ErrorSummaryProps extends HtmlDivProps, MarginProps {
    items?: Array<ErrorSummaryItemProps>;
    smallScreen?: boolean;
    headingText: ReactNode;
    headingVariant?: Exclude<hLevels, 'h1'>;
    headingRef: React$1.Ref<HTMLHeadingElement>;
    forwardedRef?: React$1.Ref<HTMLDivElement>;
}
declare const ErrorSummary: React$1.ForwardRefExoticComponent<ErrorSummaryProps & React$1.RefAttributes<HTMLDivElement>>;

interface DropdownItemProps<T extends string = string> extends HtmlLiProps {
    value: T;
    children: ReactNode;
    className?: string;
    disabled?: boolean;
}
declare const DropdownItem: {
    <T extends string = string>(props: DropdownItemProps<T>): React$1.JSX.Element;
    displayName: string;
};

interface DropdownProps<T extends string = string> extends StatusTextCommonProps, MarginProps, Omit<HtmlButtonProps, 'onChange' | 'value'> {
    id?: string;
    name?: string;
    defaultValue?: T;
    value?: T | null;
    labelText: ReactNode;
    hintText?: string;
    visualPlaceholder?: ReactNode;
    alwaysShowVisualPlaceholder?: boolean;
    labelMode?: LabelMode;
    optionalText?: string;
    'aria-labelledby'?: string;
    status?: 'default' | 'error';
    statusText?: string;
    className?: string;
    disabled?: boolean;
    children?: Array<ReactElement<DropdownItemProps<T>> | Array<ReactElement<DropdownItemProps<T>>>> | ReactElement<DropdownItemProps<T>>;
    onChange?(value: T): void;
    onBlur?: () => void;
    tooltipComponent?: ReactElement;
    portal?: boolean;
    popoverClassName?: string;
    fullWidth?: boolean;
    forwardedRef?: React$1.Ref<HTMLButtonElement>;
}
declare const Dropdown: <T extends string = string>(props: DropdownProps<T> & {
    ref?: React$1.Ref<HTMLButtonElement> | undefined;
}) => React$1.ReactElement | null;

interface BaseFileInputProps extends StatusTextCommonProps, MarginProps, Omit<HtmlInputProps, 'type' | 'onChange' | 'onClick' | 'onBlur' | 'value'> {
    className?: string;
    labelText: ReactNode;
    labelMode?: LabelMode;
    inputButtonText: ReactNode;
    dragAreaText: ReactNode;
    removeFileText: ReactNode;
    filePreview?: boolean;
    addedFileAriaText: string;
    onClick?: () => void;
    onChange?: (value: FileList) => void;
    onBlur?: () => void;
    value?: ControlledFileItem[];
    hintText?: string;
    status?: InputStatus;
    smallScreen?: boolean;
    id?: string;
    name?: string;
    'aria-describedby'?: string;
    fullWidth?: boolean;
    optionalText?: string;
    style?: React$1.CSSProperties;
    tooltipComponent?: ReactElement;
}
type MultiFileProps = {
    multiFile?: false;
    multiFileListHeadingText?: string;
} | {
    multiFile?: true;
    multiFileListHeadingText: string;
};
type FileInputProps = BaseFileInputProps & MultiFileProps;
interface ControlledFileItem {
    file?: File;
    metadata?: Metadata;
    status?: 'default' | 'error' | 'loading';
    errorText?: string;
    ariaLoadingText?: string;
    buttonText?: string;
    buttonIcon?: ReactElement;
    buttonOnClick?: () => void;
    filePreviewOnClick?: () => void;
    fileURL?: string;
}
interface Metadata {
    fileSize: number;
    fileName: string;
    fileType: string;
    id?: string;
}
declare const FileInput: React$1.ForwardRefExoticComponent<FileInputProps & React$1.RefAttributes<HTMLInputElement>>;

declare const zindexes: {
    menu: number;
    focus: number;
};

type ZIndexDesignTokens = typeof zindexes;
type SuomifiDesignTokens = typeof designTokens;
type ColorProp = keyof ColorDesignTokens;
type TypographyProp = keyof TypographyDesignTokens;
type SpacingProp = keyof SpacingDesignTokens | '0';
interface SuomifiTheme {
    colors: ColorDesignTokens;
    gradients: GradientDesignTokens;
    focuses: FocusDesignTokens;
    radiuses: RadiusDesignTokens;
    shadows: ShadowDesignTokens;
    spacing: SpacingDesignTokens;
    transitions: TransitionDesignTokens;
    typography: TypographyDesignTokens;
    values: RawDesignTokens;
    zindexes: ZIndexDesignTokens;
    breakpoints: BreakpointDesignTokens;
}
declare const designTokens: {
    zindexes: {
        menu: number;
        focus: number;
    };
    shadows: ShadowDesignTokens;
    focuses: FocusDesignTokens;
    transitions: TransitionDesignTokens;
    radiuses: RadiusDesignTokens;
    colors: ColorDesignTokens;
    spacing: SpacingDesignTokens;
    typography: TypographyDesignTokens;
    gradients: GradientDesignTokens;
    values: RawDesignTokens;
    breakpoints: BreakpointDesignTokens;
};
declare const defaultSuomifiTheme: SuomifiTheme;
interface PartialSuomifiTheme {
    colors?: Partial<ColorDesignTokens>;
    gradients?: Partial<GradientDesignTokens>;
    focuses?: Partial<FocusDesignTokens>;
    radiuses?: Partial<RadiusDesignTokens>;
    shadows?: Partial<ShadowDesignTokens>;
    spacing?: Partial<SpacingDesignTokens>;
    transitions?: Partial<TransitionDesignTokens>;
    typography?: Partial<TypographyDesignTokens>;
    zindexes?: Partial<ZIndexDesignTokens>;
    breakpoints?: Partial<BreakpointDesignTokens>;
}

declare const SuomifiThemeContext: React$1.Context<{
    suomifiTheme: SuomifiTheme;
}>;
declare const SuomifiThemeConsumer: React$1.Consumer<{
    suomifiTheme: SuomifiTheme;
}>;
interface SuomifiThemeProviderProps {
    theme: PartialSuomifiTheme;
    children?: ReactNode;
}
declare const SuomifiThemeProvider: (props: SuomifiThemeProviderProps) => React$1.JSX.Element | null;

declare const SpacingConsumer: React$1.Consumer<{
    margins: {};
}>;
interface SpacingProviderProps {
    margins: GlobalMargins;
    children?: ReactNode;
}
declare const SpacingProvider: (props: SpacingProviderProps) => React$1.JSX.Element | null;

type styleVariants = hLevels | 'h1hero';
interface HeadingProps extends HtmlHProps, MarginProps {
    variant: styleVariants;
    smallScreen?: boolean;
    color?: ColorProp;
    className?: string;
    as?: asPropType;
    forwardedRef?: React$1.RefObject<HTMLHeadingElement>;
}
declare const Heading: React$1.ForwardRefExoticComponent<HeadingProps & React$1.RefAttributes<HTMLHeadingElement>>;

interface LanguageMenuItemProps {
    lang: string;
    className?: string;
    children: ReactNode;
    onSelect: () => void;
    selected?: boolean;
}
declare const LanguageMenuItem: {
    (props: LanguageMenuItemProps): React$1.JSX.Element;
    displayName: string;
};

type MenuContent = Array<ReactElement<LanguageMenuItemProps> | Array<ReactElement<LanguageMenuItemProps>>> | Array<ReactElement<LanguageMenuItemProps>> | ReactElement<LanguageMenuItemProps>;
interface LanguageMenuProps extends MarginProps, Omit<HtmlButtonProps, 'onBlur'> {
    buttonText: ReactNode;
    'aria-label': string;
    children?: MenuContent;
    className?: string;
    menuClassName?: string;
    forwardedRef?: React$1.RefObject<HTMLButtonElement>;
    id?: string;
    onBlur?: (event: FocusEvent<HTMLButtonElement>) => void;
    onClose?: () => void;
    onOpen?: () => void;
}
declare const LanguageMenu: React$1.ForwardRefExoticComponent<LanguageMenuProps & React$1.RefAttributes<HTMLButtonElement>>;

interface ModalFooterProps extends HtmlDivProps {
}
declare const ModalFooter: {
    (props: ModalFooterProps): React$1.JSX.Element;
    displayName: string;
};

interface ModalContentProps extends Omit<HtmlDivProps, 'children' | 'className'> {
    className?: string;
    children: ReactNode;
}
declare const ModalContent: {
    (props: ModalContentProps): React$1.JSX.Element;
    displayName: string;
};

type ModalVariant = 'smallScreen' | 'default';
interface ModalProps {
    visible: boolean;
    appElementId: string;
    className?: string;
    style?: React$1.CSSProperties;
    children: ReactElement<ModalContentProps | ModalFooterProps> | ReactNode;
    variant?: ModalVariant;
    scrollable?: boolean;
    focusOnOpenRef?: React$1.RefObject<any>;
    focusOnCloseRef?: React$1.RefObject<any>;
    onEscKeyDown?: () => void;
    ariaLabelledBy?: string;
}
declare const Modal: {
    (props: ModalProps): React$1.JSX.Element;
    displayName: string;
};

interface ModalTitleProps extends Omit<HeadingProps, 'className' | 'variant' | 'margin' | 'mx' | 'my' | 'mt' | 'mr' | 'mb' | 'ml'> {
    children: ReactNode;
    className?: string;
    variant?: hLevels | 'h1hero';
}
declare const ModalTitle: {
    (props: ModalTitleProps): React$1.JSX.Element;
    displayName: string;
};

interface WizardNavigationProps extends MarginProps, HtmlDivProps {
    children: ReactNode;
    'aria-label': string;
    id?: string;
    variant?: 'default' | 'smallScreen';
    initiallyExpanded?: boolean;
    heading: string;
    className?: string;
    forwardedRef?: React$1.Ref<HTMLElement>;
}
declare const WizardNavigation: React$1.ForwardRefExoticComponent<WizardNavigationProps & React$1.RefAttributes<HTMLElement>>;

interface WizardNavigationItemProps {
    className?: string;
    children: ReactNode;
    status: 'default' | 'current' | 'current-completed' | 'completed' | 'coming' | 'disabled';
}
declare const WizardNavigationItem: {
    (props: WizardNavigationItemProps): React$1.JSX.Element;
    displayName: string;
};

interface ServiceNavigationProps extends MarginProps, HtmlDivProps {
    children: ReactNode;
    'aria-label': string;
    id?: string;
    variant?: 'default' | 'smallScreen';
    initiallyExpanded?: boolean;
    smallScreenExpandButtonText?: string | ReactNode;
    className?: string;
    forwardedRef?: React$1.Ref<HTMLElement>;
}
declare const ServiceNavigation: React$1.ForwardRefExoticComponent<ServiceNavigationProps & React$1.RefAttributes<HTMLElement>>;

interface ServiceNavigationItemProps {
    className?: string;
    children: ReactNode;
    selected?: boolean;
    disabled?: boolean;
}
declare const ServiceNavigationItem: {
    (props: ServiceNavigationItemProps): React$1.JSX.Element;
    displayName: string;
};

interface SideNavigationProps extends MarginProps, HtmlDivProps {
    children: ReactNode;
    'aria-label': string;
    id?: string;
    variant?: 'default' | 'smallScreen';
    initiallyExpanded?: boolean;
    heading: string;
    icon?: ReactElement;
    className?: string;
    forwardedRef?: React$1.Ref<HTMLElement>;
}
declare const SideNavigation: React$1.ForwardRefExoticComponent<SideNavigationProps & React$1.RefAttributes<HTMLElement>>;

interface SideNavigationItemProps {
    className?: string;
    content: ReactNode;
    children?: ReactNode;
    subLevel: 1 | 2 | 3;
    selected?: boolean;
    disabled?: boolean;
    expanded?: boolean;
}
declare const SideNavigationItem: {
    (props: SideNavigationItemProps): React$1.JSX.Element;
    displayName: string;
};

interface ExpanderProps extends MarginProps, HtmlDivWithRefProps {
    children: ReactNode;
    className?: string;
    id?: string;
    defaultOpen?: boolean;
    open?: boolean;
    onOpenChange?: (open: boolean) => void;
    forwardedRef?: React$1.Ref<HTMLDivElement>;
}
declare const Expander: React$1.ForwardRefExoticComponent<ExpanderProps & React$1.RefAttributes<HTMLDivElement>>;

interface PartialExpanderGroupProps extends HtmlDivProps, MarginProps {
    children: ReactNode;
    ariaOpenAllText?: string;
    ariaCloseAllText?: string;
    className?: string;
    toggleAllButtonProps?: Omit<HTMLAttributesIncludingDataAttributes<HTMLButtonElement>, 'onClick' | 'onMouseDown' | 'onMouseUp' | 'onKeyPress' | 'onKeyUp' | 'onKeyDown'>;
    forwardedRef?: React$1.Ref<HTMLButtonElement>;
}
type ToggleAllProps = {
    openAllText?: string;
    closeAllText?: string;
    showToggleAllButton?: false | never;
} | {
    openAllText: string;
    closeAllText: string;
    showToggleAllButton: true;
};
type ExpanderGroupProps = PartialExpanderGroupProps & ToggleAllProps;
declare const ExpanderGroup: React$1.ForwardRefExoticComponent<ExpanderGroupProps & React$1.RefAttributes<HTMLButtonElement>>;

interface ExpanderContentProps extends Omit<HtmlDivProps, 'id'> {
    children: ReactNode;
    noPadding?: boolean;
}
declare const ExpanderContent: {
    (props: ExpanderContentProps): React$1.JSX.Element;
    displayName: string;
};

interface ExpanderTitleButtonProps extends HtmlDivProps {
    className?: string;
    children?: ReactNode;
    asHeading?: 'h2' | 'h3' | 'h4' | 'h5' | 'h6';
    toggleButtonProps?: Omit<HTMLAttributesIncludingDataAttributes<HTMLButtonElement>, 'onClick' | 'onMouseDown' | 'onMouseUp' | 'onKeyPress' | 'onKeyUp' | 'onKeyDown'>;
    forwardedRef?: React$1.RefObject<HTMLButtonElement>;
}
declare const ExpanderTitleButton: React$1.ForwardRefExoticComponent<ExpanderTitleButtonProps & React$1.RefAttributes<HTMLButtonElement>>;

interface ExpanderTitleProps extends Omit<HtmlDivProps, 'className'> {
    className?: string;
    children?: ReactNode;
    toggleButtonAriaLabel: string;
    toggleButtonAriaDescribedBy: string;
    toggleButtonProps?: Omit<HTMLAttributesIncludingDataAttributes<HTMLButtonElement>, 'onClick' | 'onMouseDown' | 'onMouseUp' | 'onKeyPress' | 'onKeyUp' | 'onKeyDown'>;
}
declare const ExpanderTitle: {
    (props: ExpanderTitleProps): React$1.JSX.Element;
    displayName: string;
};

interface HtmlPProps extends Omit<HTMLProps<HTMLParagraphElement>, 'ref' | 'as'> {
    as?: asPropType;
}

interface ParagraphProps extends HtmlPProps, MarginProps {
    color?: ColorProp;
    forwardedRef?: React$1.Ref<HTMLParagraphElement>;
}
declare const Paragraph: React$1.ForwardRefExoticComponent<ParagraphProps & React$1.RefAttributes<HTMLParagraphElement>>;

type PageInputValue = number | string | undefined;

interface PageInputProps {
    buttonText: string;
    inputPlaceholderText: string;
    invalidValueErrorText: (value: PageInputValue) => string;
    labelText: string;
}
type NextPreviousButtonProps = {
    nextButtonAriaLabel: string;
    previousButtonAriaLabel: string;
    customPreviousButton?: never;
    customNextButton?: never;
} | {
    nextButtonAriaLabel?: never;
    previousButtonAriaLabel?: never;
    customPreviousButton: React$1.ReactNode;
    customNextButton: React$1.ReactNode;
};
type ShowInputProps = {
    pageInput: false;
    pageInputProps?: never;
} | {
    pageInput?: true;
    pageInputProps: PageInputProps;
};
interface InternalPaginationProps {
    className?: string;
    'aria-label': string;
    id?: string;
    pageIndicatorText: (currentPage: number, lastPage: number) => string;
    ariaPageIndicatorText: (currentPage: number, lastPage: number) => string;
    smallScreen?: boolean;
    currentPage?: number;
    lastPage: number;
    onChange: (page: number) => void;
    forwardedRef?: React$1.RefObject<HTMLElement>;
}
type PaginationProps = ShowInputProps & InternalPaginationProps & NextPreviousButtonProps & Omit<HtmlNavProps, 'onChange'> & MarginProps;
declare const Pagination: React$1.ForwardRefExoticComponent<PaginationProps & React$1.RefAttributes<HTMLElement>>;

interface TextProps extends HtmlSpanProps, MarginProps {
    smallScreen?: boolean;
    color?: ColorProp;
    variant?: 'body' | 'lead' | 'bold';
    forwardedRef?: React$1.Ref<HTMLSpanElement>;
}
declare const Text: React$1.ForwardRefExoticComponent<TextProps & React$1.RefAttributes<HTMLSpanElement>>;

type TextareaStatus = Exclude<InputStatus, 'success'>;
interface BaseTextareaProps extends StatusTextCommonProps, MarginProps, Omit<HtmlTextareaProps, 'placeholder' | 'forwardedRef' | 'onChange' | 'onBlur'> {
    className?: string;
    disabled?: boolean;
    onClick?: () => void;
    onChange?: (event: ChangeEvent<HTMLTextAreaElement>) => void;
    onBlur?: (event: FocusEvent<HTMLTextAreaElement>) => void;
    labelText: ReactNode;
    labelMode?: 'hidden' | 'visible';
    visualPlaceholder?: string;
    children?: string;
    hintText?: string;
    status?: TextareaStatus;
    resize?: 'both' | 'vertical' | 'horizontal' | 'none';
    optionalText?: string;
    id?: string;
    name?: string;
    fullWidth?: boolean;
    tooltipComponent?: ReactElement;
    forwardedRef?: React$1.Ref<HTMLTextAreaElement>;
}
type TextareaProps = characterCounterProps & BaseTextareaProps;
declare const Textarea: React$1.ForwardRefExoticComponent<TextareaProps & React$1.RefAttributes<HTMLTextAreaElement>>;

interface TooltipProps extends MarginProps, HtmlButtonProps {
    children: ReactNode;
    ariaToggleButtonLabelText: string;
    ariaCloseButtonLabelText: string;
    open?: boolean;
    toggleButtonClassName?: string;
    contentClassName?: string | undefined;
    anchorElement?: HTMLElement | null;
    onToggleButtonClick?: (event: React$1.MouseEvent) => void;
    onCloseButtonClick?: (event: React$1.MouseEvent) => void;
    forwardedRef?: React$1.RefObject<HTMLButtonElement>;
}
declare const Tooltip: React$1.Forward