@iress-oss/ids-components 5.20.2 → 5.20.3

package/dist/src/components/Popover/Popover.types.d.ts

@@ -0,0 +1,178 @@
+import { ReactElement, MutableRefObject, PropsWithChildren } from 'react';
+import { DisplayMode, FloatingUIAlign } from '../../enums';
+import { IressHTMLAttributes } from '../../interfaces';
+import { ElementProps, OpenChangeReason, UseFloatingReturn, useInteractions } from '@floating-ui/react';
+import { DisplayModes, FloatingUIAligns, FloatingUIContainer } from '../../types';
+export interface IressPopoverProps extends IressHTMLAttributes {
+    /**
+     * Content for an activator element, usually an `IressButton`.
+     */
+    activator: PopoverActivatorProps['children'];
+    /**
+     * Sets the alignment of the popover relative to the activator element.
+     * @default auto
+     */
+    align?: FloatingUIAlign | FloatingUIAligns;
+    /**
+     * The content to render within the popover.
+     */
+    children?: React.ReactNode;
+    /**
+     * The container element to render the popover into.
+     * By default, the popover will render where its parent is rendered.
+     *
+     * **Note:** If the `container` doesn’t exist when the popover is mounted, ensure you pass an element directly (not a ref) and specify null as the default value before it is set. This lets it wait for the root to be available. For example, if you reference the parent element of a popover.
+     */
+    container?: FloatingUIContainer;
+    /**
+     * Class name of the popover content
+     */
+    contentClassName?: string;
+    /**
+     * When set to `true` the popover will be visible by default. Use for uncontrolled popovers.
+     */
+    defaultShow?: boolean;
+    /**
+     * When set to `true`, popover toggling can only be done through the toggle method on the `ref`.
+     * @deprecated Use a controlled `show` prop instead.
+     */
+    disabledAutoToggle?: boolean;
+    /**
+     * Sets the display mode of popover.
+     * @default overlay
+     */
+    displayMode?: DisplayMode | DisplayModes;
+    /**
+     * Which index to start the focus on when the popover is opened. Only works with `type` listbox and menu.
+     * Note: The index must exist in the list of items, otherwise it will not work.
+     * @default 0
+     */
+    focusStartIndex?: number;
+    /**
+     * Sets the popover to match the width of the activator.
+     * Note: This only works when `displayMode="overlay"`.
+     */
+    matchActivatorWidth?: boolean;
+    /**
+     * Is called when popover is activated.
+     */
+    onActivated?: (e?: Event, reason?: OpenChangeReason, activeIndex?: number | null) => void;
+    /**
+     * Is called when popover is deactivated.
+     */
+    onDeactivated?: (e?: Event, reason?: OpenChangeReason, activeIndex?: number | null) => void;
+    /**
+     * Is called when registered popover items are navigated using arrow keys. Only works with `type` listbox and menu.
+     */
+    onNavigate?: (activeIndex: number | null) => void;
+    /**
+     * When set to `true` the modal will be visible. Use for controlled popovers.
+     */
+    show?: boolean;
+    /**
+     * Describes the type of content contained in the popover.
+     */
+    type?: PopoverType | PopoverTypes;
+    /**
+     * Sets the width of the popover
+     * @deprecated use the `--iress-max-width` design token instead.
+     */
+    width?: string;
+    /**
+     * Whether the focus is virtual (using `aria-activedescendant`).
+     * Use this if you need focus to remain on the reference element (such as an input), but allow arrow keys to navigate items.
+     * Note: This is only applicable when type is set to: `listbox` or `menu`, and only works out of the box with `IressMenu` and its subcomponents.
+     * @default false
+     */
+    virtualFocus?: boolean;
+}
+export interface PopoverActivatorProps extends IressHTMLAttributes {
+    children?: ReactElement;
+}
+export interface PopoverContentProps extends IressHTMLAttributes {
+    container?: FloatingUIContainer;
+    displayMode?: DisplayModes;
+    virtualFocus?: boolean;
+}
+export interface PopoverStateHookProps {
+    defaultShow?: boolean;
+    show?: boolean;
+}
+export interface PopoverStateHookReturn {
+    hasInnerRole: () => boolean;
+    isControlled: boolean;
+    setShow: (flag?: boolean) => void;
+    setHasInnerRole: (flag: boolean) => void;
+    show: boolean;
+}
+export interface PopoverAriaHookReturn {
+    getAriaControls: () => string[];
+    toggleAriaControls: (id: string, addOrRemove?: boolean) => void;
+}
+export interface PopoverItemHookReturn {
+    isActiveInPopover?: boolean;
+    id: string;
+    ref?: (node: HTMLElement | null) => void;
+    tabIndex?: number;
+}
+export interface PopoverNavigationHookReturn {
+    activeIndex: number | null;
+    list: React.MutableRefObject<(HTMLElement | null)[]>;
+    listNav: ElementProps;
+    setActiveIndex: (value: number | null) => void;
+}
+export interface PopoverProviderProps extends PropsWithChildren, PopoverStateHookProps {
+    align: FloatingUIAligns;
+    autoHighlight?: boolean;
+    disabledAutoToggle?: boolean;
+    focusStartIndex?: number;
+    matchActivatorWidth?: boolean;
+    onActivated?: (e?: Event, reason?: OpenChangeReason, activeIndex?: number | null) => void;
+    onDeactivated?: (e?: Event, reason?: OpenChangeReason, activeIndex?: number | null) => void;
+    onNavigate?: (activeIndex: number | null) => void;
+    type?: PopoverTypes;
+    virtualFocus?: boolean;
+}
+export interface PopoverContextValue extends PopoverStateHookReturn, PopoverAriaHookReturn {
+    activeIndex: number | null;
+    api: UseFloatingReturn;
+    disabledAutoToggle?: boolean;
+    getVirtualFocus?: () => PopoverVirtualNode | null;
+    getFocusableActivator: () => HTMLElement | undefined;
+    interactions: ReturnType<typeof useInteractions>;
+    list: MutableRefObject<(HTMLElement | null)[]>;
+    type?: PopoverTypes;
+    resetActiveIndex: () => void;
+    setActiveIndex: (value: number | null) => void;
+    setShowWithReason: (flag: boolean, e?: Event, reason?: OpenChangeReason) => void;
+    setVirtualFocus?: (node: PopoverVirtualNode | null) => void;
+}
+export interface PopoverRef extends Pick<PopoverContextValue, 'setShow' | 'show'>, Pick<PopoverAriaHookReturn, 'toggleAriaControls'> {
+    getActivator: () => HTMLElement | null;
+    getFocusableActivator?: () => HTMLElement | undefined;
+    getContent: () => HTMLElement | null;
+}
+export interface PopoverVirtualNode {
+    onBlur?: React.KeyboardEventHandler<HTMLElement>;
+    onKeyDown?: (e: React.KeyboardEvent<HTMLElement>, popover?: PopoverContextValue) => void;
+}
+/** @deprecated PopoverType enum is now deprecated and will be removed in a future version. Please use the PopoverTypes type instead. **/
+export declare enum PopoverType {
+    Menu = "menu",
+    Listbox = "listbox",
+    Tree = "tree",
+    Grid = "grid",
+    Dialog = "dialog"
+}
+export declare const POPOVER_TYPES: readonly ["menu", "listbox", "tree", "grid", "dialog"];
+export type PopoverTypes = (typeof POPOVER_TYPES)[number];
+export declare const POPOVER_USE_MAX_HEIGHT = 200;
+export declare enum PopoverCssClass {
+    Active = "iress--popover-active"
+}
+export interface PopoverWithEnums extends React.ForwardRefExoticComponent<IressPopoverProps & React.RefAttributes<PopoverRef>> {
+    /** @deprecated IressPopover.Align is now deprecated and will be removed in a future version. Please use the value directly instead. **/
+    Align: typeof FloatingUIAlign;
+    /** @deprecated IressPopover.Type is now deprecated and will be removed in a future version. Please use the value directly instead. **/
+    Type: typeof PopoverType;
+}

package/dist/src/components/Popover/PopoverProvider.d.ts

@@ -0,0 +1,3 @@
+import { PopoverContextValue, PopoverProviderProps, PopoverRef } from './Popover.types';
+export declare const PopoverContext: import('react').Context<PopoverContextValue | undefined>;
+export declare const PopoverProvider: import('react').ForwardRefExoticComponent<PopoverProviderProps & import('react').RefAttributes<PopoverRef>>;

package/dist/src/components/Popover/components/NestedPopoverActivator.d.ts

@@ -0,0 +1,5 @@
+import { PropsWithChildren } from 'react';
+import { PopoverContextValue } from '../Popover.types';
+export declare const NestedPopoverActivator: ({ children, parentPopover, }: PropsWithChildren & {
+    parentPopover?: PopoverContextValue;
+}) => string | number | boolean | Iterable<import('react').ReactNode> | import("react/jsx-runtime").JSX.Element | null | undefined;

package/dist/src/components/Popover/components/PopoverActivator.d.ts

@@ -0,0 +1,2 @@
+import { PopoverActivatorProps } from '../Popover.types';
+export declare const PopoverActivator: ({ children, ...restProps }: PopoverActivatorProps) => import("react/jsx-runtime").JSX.Element;

package/dist/src/components/Popover/components/PopoverContent.d.ts

@@ -0,0 +1,2 @@
+import { PopoverContentProps } from '../Popover.types';
+export declare const PopoverContent: (props: PopoverContentProps) => import("react/jsx-runtime").JSX.Element;

package/dist/src/components/Popover/helpers/composeFloatingProps.d.ts

@@ -0,0 +1,15 @@
+import { default as React } from 'react';
+import { PopoverContextValue } from '../Popover.types';
+import { DisplayModes, IressHTMLAttributes } from '../../../main';
+/**
+ * This adds additional props to the Floating UI floatingProps to better suit the requirements of IressPopover.
+ * Some are slight tweaks to the UX to ensure it behaves according to IDS standards, as well as fix some issues found when using Floating UI.
+ *
+ * See: https://floating-ui.com/docs/useFloating#floatingstyles
+ *
+ * @param {PopoverContextValue} popover the popover context
+ * @param {DisplayModes} displayMode how the content is to be displayed, whether inline (static, underneath activator) or overlay (floating, anchored to the activator)
+ * @param {React.CSSProperties} style any custom styles for the popover, it will be appended to the Floating UI styles
+ * @returns {IressHTMLAttributes} the props to be passed to the floating content
+ */
+export declare const composePopoverFloatingProps: (popover: PopoverContextValue, displayMode?: DisplayModes, style?: React.CSSProperties) => IressHTMLAttributes;

package/dist/src/components/Popover/helpers/composePopoverWidth.d.ts

@@ -0,0 +1,2 @@
+import { CSSProperties } from 'react';
+export declare const composePopoverWidth: (width?: string, matchActivatorWidth?: boolean) => CSSProperties;

package/dist/src/components/Popover/helpers/handlePopoverTabKey.d.ts

@@ -0,0 +1,8 @@
+import { PopoverContextValue } from '../Popover.types';
+import { KeyboardEvent } from 'react';
+/**
+ * This helper function is used to handle the tab key press event when the popover is open, as Floating UI sometimes does not focus on the next element when the user tabs from the popover contents.
+ * @param popover {PopoverContextValue} The popover context value, usually retrieved from the usePopover hook.
+ * @param e {KeyboardEvent} The keyboard event object that triggered the tab key press.
+ */
+export declare const handlePopoverTabKey: (popover: PopoverContextValue, e: KeyboardEvent) => Promise<void>;

package/dist/src/components/Popover/helpers/hasFocus.d.ts

@@ -0,0 +1 @@
+export declare const hasFocus: (el: HTMLElement) => boolean;

package/dist/src/components/Popover/helpers/waitUntilTrue.d.ts

@@ -0,0 +1 @@
+export declare const waitUntilTrue: (condition: () => boolean, timeout?: number, interval?: number) => Promise<void>;

package/dist/src/components/Popover/hooks/usePopover.d.ts

@@ -0,0 +1 @@
+export declare const usePopover: () => import('..').PopoverContextValue | undefined;

package/dist/src/components/Popover/hooks/usePopoverActivatorInteractions.d.ts

@@ -0,0 +1,15 @@
+import { HTMLAttributes, KeyboardEvent, FocusEvent } from 'react';
+import { PopoverContextValue } from '../Popover.types';
+import { IressHTMLAttributes } from '../../../main';
+/**
+ * This adds additional props to the activator to handle keyboard interactions with a virtually focused item.
+ *
+ * @param {PopoverContextValue} popover the popover context
+ * @param {HTMLAttributes<HTMLElement>} referenceProps the props of the activator, allowing them to be drilled down to the virtual reference
+ *
+ * @returns {IressHTMLAttributes} the props to be passed to the floating content
+ */
+export declare const usePopoverActivatorInteractions: <TElement extends HTMLElement = HTMLElement, TProps extends HTMLAttributes<TElement> = IressHTMLAttributes<TElement>>(popover?: PopoverContextValue, referenceProps?: TProps) => {
+    onBlur: (e: FocusEvent<TElement>) => void;
+    onKeyDown: (e: KeyboardEvent<TElement>) => void;
+};

package/dist/src/components/Popover/hooks/usePopoverAria.d.ts

@@ -0,0 +1,6 @@
+import { PopoverAriaHookReturn } from '../Popover.types';
+/**
+ * This is a hook that manages the aria controls for the popover, allowing the popover activator to control multiple items.
+ * @returns getAriaControls and toggleAriaControls functions
+ */
+export declare function usePopoverAria(): PopoverAriaHookReturn;

package/dist/src/components/Popover/hooks/usePopoverImperativeHandle.d.ts

@@ -0,0 +1,4 @@
+import { ForwardedRef } from 'react';
+import { PopoverAriaHookReturn, PopoverContextValue, PopoverRef, PopoverStateHookReturn } from '../Popover.types';
+import { UseFloatingReturn } from '@floating-ui/react';
+export declare const usePopoverImperativeHandle: (ref: ForwardedRef<PopoverRef>, api: UseFloatingReturn, aria: PopoverAriaHookReturn, state: PopoverStateHookReturn, context?: PopoverContextValue) => void;

package/dist/src/components/Popover/hooks/usePopoverItem.d.ts

@@ -0,0 +1,12 @@
+import { PopoverItemHookReturn, PopoverVirtualNode } from '../Popover.types';
+/**
+ * This is a wrapper around the useListItem hook from Floating UI, which is used to manage the focus state of the popover items.
+ * It provides the necessary props to the popover items to manage their focus state, and sets virtual focus if required.
+ *
+ * See: https://floating-ui.com/docs/FloatingList#uselistitem
+ *
+ * @param {string} typeAheadLabel the label to be used when the user is typing to navigate the activator (currently unused in IDS)
+ * @param {PopoverVirtualNode | null} virtualNode the virtual node to use when the item is focused. This contains some interactions to emulate keydown and blur on the popover item.
+ * @returns {IressHTMLAttributes} the props to be passed to the floating content
+ */
+export declare const usePopoverItem: (typeAheadLabel?: string, virtualNode?: PopoverVirtualNode | null) => PopoverItemHookReturn;

package/dist/src/components/Popover/hooks/usePopoverNavigation.d.ts

@@ -0,0 +1,16 @@
+import { FloatingContext, UseListNavigationProps, VirtualElement } from '@floating-ui/react';
+import { PopoverNavigationHookReturn, PopoverTypes } from '../Popover.types';
+/**
+ * This is a wrapper around the useListNavigation hook from Floating UI, which is used to manage the keyboard navigation of popover items.
+ * It stores the active index of the popover items, and provides the necessary props to the popover context to manage the focus state of the popover items.
+ *
+ * See: https://floating-ui.com/docs/useListNavigation
+ *
+ * @param {FloatingContext<RT>} context the popover context
+ * @param {PopoverTypes} type the type of popover, whether it is a menu, listbox, etc.
+ * @param {Partial<UseListNavigationProps>} props props that are passed to the useListNavigation hook
+ * @param {(activeIndex: number | null) => void} onNavigate called when the useListNavigation onNavigate is called
+ * @param {number} startIndex Which index to start the focus on when the popover is opened. The index must exist in the list of items, otherwise it will not work.
+ * @returns {PopoverNavigationHookReturn} activeIndex setters, and the list and listProps passed to other Floating UI hooks
+ */
+export declare const usePopoverNavigation: <RT extends VirtualElement = HTMLButtonElement>(context: FloatingContext<RT>, type?: PopoverTypes, props?: Partial<UseListNavigationProps>, onNavigate?: (activeIndex: number | null) => void, startIndex?: number) => PopoverNavigationHookReturn;

package/dist/src/components/Popover/hooks/usePopoverState.d.ts

@@ -0,0 +1,10 @@
+import { PopoverStateHookProps, PopoverStateHookReturn } from '../Popover.types';
+/**
+ * This stores the popover states into its own hook, and manages the controlled state of the popover.
+ * - hasInnerRole: whether the popover has an inner role. If there is an inner role that matches popover, the popover itself will render with no role.
+ * - show: whether the popover is open or not. this can be controlled/uncontrolled.
+ *
+ * @param {PopoverStateHookProps} props initial props passed by the consumer. This will set whether the popover is controlled or not.
+ * @returns hasInnerRole, isControlled, setShow, setHasInnerRole, show
+ */
+export declare const usePopoverState: ({ defaultShow, show: showProp, }: PopoverStateHookProps) => PopoverStateHookReturn;

package/dist/src/components/Popover/index.d.ts

@@ -0,0 +1,5 @@
+export * from './Popover.types';
+export * from './Popover';
+export * from './hooks/usePopoverItem';
+export * from './InputPopover/InputPopover.types';
+export * from './InputPopover/InputPopover';

package/dist/src/components/Progress/Progress.d.ts

@@ -0,0 +1,2 @@
+import { IressProgressProps } from './Progress.types';
+export declare const IressProgress: ({ className, max, min, sectionTitle, value, "data-testid": dataTestId, ...restProps }: IressProgressProps) => import("react/jsx-runtime").JSX.Element;

package/dist/src/components/Progress/Progress.types.d.ts

@@ -0,0 +1,23 @@
+import { IressHTMLAttributes } from '../../interfaces';
+export interface IressProgressProps extends IressHTMLAttributes<HTMLDivElement> {
+    /**
+     * The maximum value of the progress indicator.
+     * @default 100
+     **/
+    max?: number;
+    /**
+     * The minimum value of the progress indicator.
+     * @default 0
+     **/
+    min?: number;
+    /**
+     * The text that is announced by the screen reader. Should contain a description of the section the progress is being measured for. You can use {{current}} and {{max}} as string replacers for the current value and maximum value respectively..
+     * @default "Progress is {{current}} of {{max}}"
+     */
+    sectionTitle?: string;
+    /**
+     * The current value of the progress indicator.
+     * @default 0
+     **/
+    value?: number;
+}

package/dist/src/components/Progress/index.d.ts

@@ -0,0 +1 @@
+export { IressProgress } from './Progress';

package/dist/src/components/Provider/Provider.d.ts

@@ -0,0 +1,20 @@
+import { FloatingUIContainer } from '../../types';
+import { ReactNode } from 'react';
+import { IressToasterProviderProps } from '../Toaster';
+import { IressSlideoutProviderProps } from '../Slideout';
+export interface IressProviderProps extends Pick<IressSlideoutProviderProps, 'injectPushStyles'>, Pick<IressToasterProviderProps, 'position'> {
+    /**
+     * The contents of your application, and/or the components which will be calling slideouts, modals and toasts.
+     */
+    children?: ReactNode;
+    /**
+     * Container to render modal, slideouts and toasts into.
+     * If not provided, will render into the body of the document.
+     */
+    container?: FloatingUIContainer;
+    /**
+     * If you don't want to load the Iress Icon CSS from the CDN, set this to true.
+     */
+    noIcons?: boolean;
+}
+export declare const IressProvider: ({ children, container, injectPushStyles, noIcons, position, ...restProps }: IressProviderProps) => import("react/jsx-runtime").JSX.Element;

package/dist/src/components/Provider/index.d.ts

@@ -0,0 +1 @@
+export * from './Provider';

package/dist/src/components/Radio/Radio.d.ts

@@ -0,0 +1,2 @@
+import { IressRadioProps } from './Radio.types';
+export declare const IressRadio: import('react').ForwardRefExoticComponent<IressRadioProps & import('react').RefAttributes<HTMLInputElement>>;

package/dist/src/components/Radio/Radio.types.d.ts

@@ -0,0 +1,45 @@
+import { ReactNode } from 'react';
+import { IressInputHTMLAttributes } from '../../interfaces';
+import { FormControlValue } from '../../types';
+export interface IressRadioProps extends Omit<IressInputHTMLAttributes<HTMLInputElement>, 'defaultValue' | 'value'> {
+    /**
+     * Sets the checked state of the radio.
+     * If it is within a radio group, it will be overridden by the radio group's value
+     * and whether it matches this radio's value.
+     */
+    checked?: boolean;
+    /**
+     * Label of the radio
+     */
+    children?: ReactNode;
+    /**
+     * Sets whether the control is hidden. If it is within a radio group,
+     * it will be overridden with the radio group's hiddenControl setting.
+     */
+    hiddenControl?: boolean;
+    /**
+     * Sets the name attribute on the radio input. If it is within a radio group,
+     * it will be overridden with the radio group's name.
+     */
+    name?: string;
+    /**
+     * Handles the onChange event of the radio input.
+     * If you pass in a non-string value, you can access it using the second parameter of the function.
+     */
+    onChange?: (e: React.ChangeEvent<HTMLInputElement>, value?: FormControlValue) => void;
+    /**
+     * If `true`, the radio is a required field and will be validated as such.
+     * If it is within a radio group, it will be overridden with the radio group's
+     * required state.
+     */
+    required?: boolean;
+    /**
+     * The value which is submitted with the form data when this radio button is checked.
+     * To set this radio as checked by default, use the `checked` property.
+     */
+    value?: FormControlValue;
+    /**
+     * Add the button-like border and padding to radio when `touch` is true.
+     */
+    touch?: boolean;
+}

package/dist/src/components/Radio/helpers/mapRadioGroupOptions.d.ts

@@ -0,0 +1,5 @@
+import { LabelValue } from '../../../interfaces';
+/**
+ *  @deprecated This function has been deprecated and will be removed in a future version of IDS, please map and render the items array directly in your application instead
+ */
+export declare const mapRadioGroupOptions: (items: LabelValue[]) => React.ReactNode[] | null;

package/dist/src/components/Radio/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Radio.types';
+export * from './Radio';

package/dist/src/components/RadioGroup/RadioGroup.d.ts

@@ -0,0 +1,7 @@
+import { RadioGroupWithEnums } from './RadioGroup.types';
+/**
+ * Determines whether the RadioGroup's onBlur handler should fire.
+ * Returns false if focus stays inside the group, true otherwise.
+ */
+export declare function shouldFireRadioGroupBlur(radioGroupElement: HTMLElement | null, newFocusTarget: Node | null, eventTarget: EventTarget | null): boolean;
+export declare const IressRadioGroup: RadioGroupWithEnums;

package/dist/src/components/RadioGroup/RadioGroup.types.d.ts

@@ -0,0 +1,70 @@
+import { ReactNode } from 'react';
+import { IressHTMLAttributes } from '../../interfaces';
+import { FormControlValue } from '../../types';
+export interface IressRadioGroupProps extends Omit<IressHTMLAttributes, 'onChange' | 'defaultValue'> {
+    /**
+     * Content of the radio group, usually multiple `IressRadio` components.
+     */
+    children?: ReactNode;
+    /**
+     * Hides the radio control to allow the creation of custom radio buttons.
+     */
+    hiddenRadio?: boolean;
+    /**
+     * Sets which of the block / inline layout options apply.
+     * @default 'stack'
+     */
+    layout?: RadioGroupLayout | RadioGroupLayouts;
+    /**
+     * Name to be applied to all radios in the group.
+     */
+    name?: string;
+    /**
+     * Called when a user selects one of its children radio buttons.
+     * If you pass in a non-string value, you can access it using the second parameter of the function.
+     */
+    onChange?: (e: React.ChangeEvent<HTMLInputElement>, value?: FormControlValue) => void;
+    /**
+     * When true, marks the field as required
+     */
+    required?: boolean;
+    /**
+     * Initial value of radio group when in uncontrolled mode.
+     */
+    defaultValue?: FormControlValue;
+    /**
+     * Renders a readonly radio group.
+     */
+    readonly?: boolean;
+    /**
+     * Value of radio group when in controlled mode.
+     */
+    value?: FormControlValue;
+    /**
+     * Add the button-like border and padding to radio when `touch` is true.
+     */
+    touch?: boolean;
+}
+export type RadioGroupContextValue = Pick<IressRadioGroupProps, 'name' | 'value' | 'hiddenRadio' | 'required' | 'onChange' | 'readonly' | 'touch'>;
+export interface RadioGroupRef {
+    input?: HTMLDivElement | null;
+    reset: () => void;
+    focus: () => void;
+    blur: () => void;
+}
+export interface RadioGroupWithEnums extends React.ForwardRefExoticComponent<IressRadioGroupProps & React.RefAttributes<HTMLElement>> {
+    /** @deprecated IressRadioGroup.Layout will be removed in future versions of IDS. Please use the value directly. */
+    Layout: typeof RadioGroupLayout;
+}
+/**
+ * @deprecated The RadioGroupLayout enum will be removed in future versions of IDS. Please use the value directly.
+ */
+export declare enum RadioGroupLayout {
+    Stack = "stack",
+    Block = "block",
+    Inline = "inline",
+    InlineFlex = "inlineFlex",
+    InlineEqualWidth = "inlineEqualWidth"
+}
+export declare const RADIO_GROUP_LAYOUTS: readonly ["stack", "block", "inline", "inlineFlex", "inlineEqualWidth"];
+export type RadioGroupLayouts = (typeof RADIO_GROUP_LAYOUTS)[number];

package/dist/src/components/RadioGroup/RadioGroupContext.d.ts

@@ -0,0 +1,2 @@
+import { RadioGroupContextValue } from './RadioGroup.types';
+export declare const RadioGroupContext: import('react').Context<RadioGroupContextValue>;

package/dist/src/components/RadioGroup/index.d.ts

@@ -0,0 +1,2 @@
+export * from './RadioGroup.types';
+export * from './RadioGroup';

package/dist/src/components/Readonly/Readonly.d.ts

@@ -0,0 +1,3 @@
+import { IressReadonlyProps } from './Readonly.types';
+import { FormControlValue } from '../../main';
+export declare const IressReadonly: <T extends FormControlValue>(props: IressReadonlyProps<T> & React.RefAttributes<HTMLInputElement | null>) => React.ReactElement;

package/dist/src/components/Readonly/Readonly.types.d.ts

@@ -0,0 +1,10 @@
+import { ReactNode } from 'react';
+import { IressInputProps } from '../Input';
+import { FormControlValue } from '../../types';
+export interface IressReadonlyProps<T extends FormControlValue = FormControlValue> extends Omit<IressInputProps<T>, 'clearable' | 'onClear' | 'onChange' | 'onInput' | 'placeholder' | 'rows'> {
+    /**
+     * The formatted value. If not provided, the value will be displayed.
+     */
+    children?: ReactNode;
+    inline?: boolean;
+}

package/dist/src/components/Readonly/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Readonly';
+export * from './Readonly.types';

package/dist/src/components/RichSelect/RichSelect.d.ts

@@ -0,0 +1,2 @@
+import { IressRichSelectProps, RichSelectRef } from './RichSelect.types';
+export declare const IressRichSelect: import('react').ForwardRefExoticComponent<IressRichSelectProps & import('react').RefAttributes<RichSelectRef>>;