import React$1, { HTMLProps, ReactNode, ButtonHTMLAttributes, ReactElement, FocusEvent, RefObject, CSSProperties, ChangeEvent } from 'react';
import { ColorDesignTokens, TypographyDesignTokens, SpacingDesignTokens, GradientDesignTokens, FocusDesignTokens, RadiusDesignTokens, ShadowDesignTokens, TransitionDesignTokens, RawDesignTokens } 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?: string;
    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?: string | undefined;
    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;
    ariaLiveMode?: 'polite' | 'assertive' | 'off';
    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 & {
    ariaLiveMode?: 'polite' | 'assertive' | 'off';
    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 SearchInputValue = string | number | undefined;
type SearchInputStatus = Exclude<InputStatus, 'success'>;
interface SearchInputProps extends StatusTextCommonProps, MarginProps, 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?: SearchInputValue;
    defaultValue?: SearchInputValue;
    onChange?: (value: SearchInputValue) => void;
    onBlur?: (event: FocusEvent<HTMLInputElement>) => void;
    onSearch?: (value: SearchInputValue) => void;
    debounce?: number;
    forwardedRef?: React$1.RefObject<HTMLInputElement>;
}
declare const SearchInput: React$1.ForwardRefExoticComponent<SearchInputProps & React$1.RefAttributes<HTMLInputElement>>;

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>;
}
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>;
}
declare const RadioButton: React$1.ForwardRefExoticComponent<RadioButtonProps & React$1.RefAttributes<HTMLInputElement>>;

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

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>;
    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>;
    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'> {
    id?: string;
    name?: string;
    defaultValue?: T;
    value?: T;
    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;
    fullWidth?: boolean;
    forwardedRef?: React$1.RefObject<HTMLButtonElement>;
}
declare const DropdownInner: {
    <T extends string = string>(props: DropdownProps<T>, ref: React$1.RefObject<HTMLButtonElement>): React$1.JSX.Element;
    displayName: string;
};
declare const Dropdown: <T extends string = string>(props: DropdownProps<T>, ref: React$1.RefObject<HTMLButtonElement>) => ReturnType<typeof DropdownInner>;

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;
    fileURL?: 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;
}
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;
};
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>;
}

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.ForwardRefExoticComponent<TooltipProps & React$1.RefAttributes<HTMLButtonElement>>;

interface TableColumn {
    key: string;
    labelText: string;
    textAlign?: 'left' | 'center' | 'right';
    sortable?: boolean;
    sortIcon?: 'alphabetical' | 'generic';
    className?: string;
}
type TableRow<TColumns extends readonly TableColumn[]> = {
    [K in TColumns[number]['key']]: string | number | React$1.ReactElement<any, string | React$1.JSXElementConstructor<any>>;
} & {
    id: string;
    rowSelectionCheckboxLabel?: string;
};
interface BaseTableProps<TColumns extends readonly TableColumn[]> extends MarginProps, HtmlTableProps {
    id?: string;
    columns: TColumns;
    data: TableRow<TColumns>[];
    condensed?: boolean;
    enableRowSelection?: boolean;
    enableSingleRowSelection?: boolean;
    onSelectedRowsChange?: (selectedRowIds: string[]) => void;
    controlledSelectedRowIds?: string[];
    tableSortedAriaLiveText?: (columnLabel: string, direction: 'asc' | 'desc') => string;
    tableSortCallback?: (columnLabel: string, direction: 'asc' | 'desc') => void;
    loading?: boolean;
    loadingRowAmount?: number;
    forwardedRef?: React$1.Ref<HTMLTableElement>;
}
type TableHeadingProps = {
    caption: string;
    'aria-labelledby'?: never;
} | {
    caption?: never;
    'aria-labelledby': string;
};
type TableProps<TColumns extends readonly TableColumn[]> = BaseTableProps<TColumns> & TableHeadingProps;
declare const Table: React$1.ForwardRefExoticComponent<TableProps<readonly TableColumn[]> & React$1.RefAttributes<HTMLTableElement>>;

interface VisuallyHiddenProps extends HtmlSpanProps {
    className?: string;
    forwardedRef?: React$1.Ref<HTMLSpanElement>;
}
declare const VisuallyHidden: React$1.ForwardRefExoticComponent<VisuallyHiddenProps & React$1.RefAttributes<HTMLSpanElement>>;

type LogFunction = (...args: any[]) => void;
interface Logger {
    log: LogFunction;
    warn: LogFunction;
    error: LogFunction;
}
declare function getLogger(): Logger;
declare function setLogger(newLogger: Logger): void;

export { ActionMenu, ActionMenuDivider, ActionMenuItem, type ActionMenuItemProps, type ActionMenuProps, Alert, type AlertProps, Block, type BlockProps, Breadcrumb, BreadcrumbLink, type BreadcrumbLinkProps, type BreadcrumbProps, Button, type ButtonProps, Checkbox, CheckboxGroup, type CheckboxGroupProps, type CheckboxProps, Chip, type ChipProps, type CloseButtonProps$1 as CloseButtonProps, type ColorProp, type ControlledFileItem, DateInput, type DateInputProps, type DatePickerTextProps, Details, type DetailsProps, Dropdown, DropdownItem, type DropdownItemProps, type DropdownProps, ErrorSummary, type ErrorSummaryItemProps, type ErrorSummaryProps, Expander, ExpanderContent, type ExpanderContentProps, ExpanderGroup, type ExpanderGroupProps, type ExpanderProps, ExpanderTitle, ExpanderTitleButton, type ExpanderTitleButtonProps, type ExpanderTitleProps, ExternalLink, type ExternalLinkProps, FileInput, type FileInputProps, type ForcedAccessibleNameProps, type GlobalMargins, Heading, type HeadingProps, HintText, type HintTextProps, InlineAlert, type InlineAlertProps, Label, type LabelProps, LanguageMenu, LanguageMenuItem, type LanguageMenuItemProps, type LanguageMenuProps, Link, LinkList, LinkListItem, type LinkListItemProps, type LinkListProps, type LinkProps, LoadingSpinner, type LoadingSpinnerProps, type LoadingSpinnerStatus, type Logger, type MarginProps, type Metadata, Modal, ModalContent, type ModalContentProps, ModalFooter, type ModalFooterProps, type ModalProps, ModalTitle, type ModalTitleProps, MultiSelect, type MultiSelectData, type MultiSelectProps, type MultiSelectStatus, type NextPreviousButtonProps, Notification, type NotificationProps, type PaddingProps, type PageInputProps, Pagination, type PaginationProps, Paragraph, type ParagraphProps, type PartialSuomifiTheme, RadioButton, RadioButtonGroup, type RadioButtonGroupProps, type RadioButtonProps, RouterLink, type RouterLinkProps, SearchInput, type SearchInputProps, ServiceNavigation, ServiceNavigationItem, type ServiceNavigationItemProps, type ServiceNavigationProps, type ShowInputProps, SideNavigation, SideNavigationItem, type SideNavigationItemProps, type SideNavigationProps, SingleSelect, type SingleSelectData, type SingleSelectProps, type SingleSelectStatus, SkipLink, type SkipLinkProps, SpacingConsumer, type SpacingProp, type SpacingProps, SpacingProvider, type SpacingProviderProps, type SpacingWithoutInsetProp, StaticChip, type StaticChipProps, StatusText, type StatusTextProps, type SuomifiDesignTokens, type SuomifiTheme, SuomifiThemeConsumer, SuomifiThemeContext, SuomifiThemeProvider, type SuomifiThemeProviderProps, Table, type TableColumn, type TableProps, type TableRow, Text, TextInput, type TextInputProps, type TextInputValue, type TextProps, Textarea, type TextareaProps, TimeInput, type TimeInputProps, Toast, type ToastProps, ToggleButton, type ToggleButtonProps, ToggleInput, type ToggleInputProps, Tooltip, type TooltipProps, type TypographyProp, VisuallyHidden, type VisuallyHiddenProps, WizardNavigation, WizardNavigationItem, type WizardNavigationItemProps, type WizardNavigationProps, type ZIndexDesignTokens, autocompleteTimeString, type characterCounterProps, defaultSuomifiTheme, getLogger, setLogger };