@heliux-org/design-system-core 0.0.49 → 0.0.50

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

@@ -0,0 +1,152 @@
+import * as React from "react";
+import type { Placement } from "@floating-ui/react";
+import type { PolymorphicForwardRefComponent } from "../utils/index";
+import type { PortalProps } from "../utils/components/Portal";
+type PopoverOptions = {
+    /**
+     * Placement of the popover content.
+     * @default 'bottom-start'
+     */
+    placement?: Placement;
+    /**
+     * Controlled flag for whether the popover is visible.
+     */
+    visible?: boolean;
+    /**
+     * Callback invoked every time the popover visibility changes as a result
+     * of internal logic. Should be used alongside `visible` prop.
+     */
+    onVisibleChange?: (visible: boolean) => void;
+    /**
+     * If true, the popover will close when clicking outside it.
+     *
+     * @default true
+     */
+    closeOnOutsideClick?: boolean;
+    /**
+     * Middleware options.
+     *
+     * By default, `flip` and `shift` are enabled.
+     *
+     * @see https://floating-ui.com/docs/middleware
+     */
+    middleware?: {
+        offset?: number;
+        flip?: boolean;
+        shift?: boolean;
+        autoPlacement?: boolean;
+        hide?: boolean;
+        inline?: boolean;
+    };
+};
+type PopoverInternalProps = {
+    /**
+     * autoUpdate options that recalculates position
+     * to ensure the floating element remains anchored
+     * to its reference element, such as when scrolling
+     * and resizing the screen
+     *
+     * https://floating-ui.com/docs/autoUpdate#options
+     */
+    autoUpdateOptions?: {
+        ancestorScroll?: boolean;
+        ancestorResize?: boolean;
+        elementResize?: boolean;
+        /**
+         * Use this if you want popover to follow moving trigger element
+         */
+        animationFrame?: boolean;
+        layoutShift?: boolean;
+    };
+    /**
+     * By default, the popover will only open on click.
+     * `hover` and `focus` can be manually specified as triggers.
+     */
+    trigger?: Partial<Record<"hover" | "click" | "focus", boolean>>;
+    role?: "dialog" | "menu" | "listbox";
+    /**
+     * Whether the popover should match the width of the trigger.
+     */
+    matchWidth?: boolean;
+};
+export declare const usePopover: (options: PopoverOptions & PopoverInternalProps) => {
+    placement: Placement;
+    strategy: import("@floating-ui/utils").Strategy;
+    middlewareData: import("@floating-ui/core").MiddlewareData;
+    x: number;
+    y: number;
+    isPositioned: boolean;
+    update: () => void;
+    floatingStyles: React.CSSProperties;
+    refs: {
+        reference: React.MutableRefObject<import("@floating-ui/react-dom").ReferenceType>;
+        floating: React.MutableRefObject<HTMLElement>;
+        setReference: (node: import("@floating-ui/react-dom").ReferenceType) => void;
+        setFloating: (node: HTMLElement) => void;
+    } & import("@floating-ui/react").ExtendedRefs<import("@floating-ui/react").ReferenceType>;
+    elements: {
+        reference: import("@floating-ui/react-dom").ReferenceType;
+        floating: HTMLElement;
+    } & import("@floating-ui/react").ExtendedElements<import("@floating-ui/react").ReferenceType>;
+    context: {
+        x: number;
+        y: number;
+        placement: Placement;
+        strategy: import("@floating-ui/utils").Strategy;
+        middlewareData: import("@floating-ui/core").MiddlewareData;
+        isPositioned: boolean;
+        update: () => void;
+        floatingStyles: React.CSSProperties;
+        open: boolean;
+        onOpenChange: (open: boolean, event?: Event, reason?: import("@floating-ui/react").OpenChangeReason) => void;
+        events: import("@floating-ui/react").FloatingEvents;
+        dataRef: React.MutableRefObject<import("@floating-ui/react").ContextData>;
+        nodeId: string;
+        floatingId: string;
+        refs: import("@floating-ui/react").ExtendedRefs<import("@floating-ui/react").ReferenceType>;
+        elements: import("@floating-ui/react").ExtendedElements<import("@floating-ui/react").ReferenceType>;
+    };
+    getFloatingProps: (userProps?: React.HTMLProps<HTMLElement>) => Record<string, unknown>;
+    getReferenceProps: (userProps?: React.HTMLProps<Element>) => Record<string, unknown>;
+    getItemProps: (userProps?: Omit<React.HTMLProps<HTMLElement>, "active" | "selected"> & {
+        active?: boolean;
+        selected?: boolean;
+    }) => Record<string, unknown>;
+    open: boolean;
+    onOpenChange: React.Dispatch<React.SetStateAction<boolean>>;
+};
+type PopoverPublicProps = {
+    /**
+     * Content displayed inside the popover.
+     */
+    content?: React.ReactNode;
+    /**
+     * Element that triggers the popover. Should usually be a button.
+     */
+    children?: React.ReactNode;
+    /**
+     * Whether the popover adds recommended CSS (background-color, box-shadow, etc.) to itself.
+     *
+     * @default false
+     */
+    applyBackground?: boolean;
+    /**
+     * This is used to position the popover relative to a different element than the trigger.
+     *
+     * Recommended to use state to store this element, rather than a ref.
+     */
+    positionReference?: HTMLElement;
+} & PortalProps & PopoverOptions;
+/**
+ * A utility component to help with positioning of floating content relative to a trigger.
+ * Built on top of [`floating-ui`](https://floating-ui.com/).
+ *
+ * @see https://itwinui.bentley.com/docs/popover
+ *
+ * @example
+ * <Popover content='This is a popover'>
+ *   <Button>Show popover</Button>
+ * </Popover>
+ */
+export declare const Popover: PolymorphicForwardRefComponent<"div", PopoverPublicProps>;
+export {};

package/dist/types/components/new/ProgressIndicators/ProgressRadial.d.ts

@@ -0,0 +1,45 @@
+import * as React from "react";
+import type { PolymorphicForwardRefComponent } from "../utils/index";
+type ProgressRadialProps = {
+    /**
+     * Progress percentage. Should be a number between 0 and 100.
+     */
+    value?: number;
+    /**
+     * Progress variant. If true, value will be ignored.
+     *
+     * @default false if value is provided, true otherwise
+     */
+    indeterminate?: boolean;
+    /**
+     * Status of Progress. Positive status always has 100% value.
+     */
+    status?: "positive" | "negative" | "warning";
+    /**
+     * Size of the progress indicator. Defaults to medium size.
+     * @default ''
+     */
+    size?: "" | "x-small" | "small" | "large";
+    /**
+     * Content shown inside progress indicator.
+     */
+    children?: React.ReactNode;
+};
+/**
+ * Circular Progress Indicator
+ * @example
+ * Basic
+ * <ProgressRadial value={50} />
+ * Indeterminate
+ * <ProgressRadial indeterminate />
+ * // Positive / Negative / Warning
+ * <ProgressRadial status='positive' />
+ * <ProgressRadial status='negative' />
+ * <ProgressRadial status='warning' />
+ * Centered Content
+ * <ProgressRadial value={63}>63</ProgressRadial>
+ * Small
+ * <ProgressRadial size={'small'} indeterminate/>
+ */
+export declare const ProgressRadial: PolymorphicForwardRefComponent<"div", ProgressRadialProps>;
+export {};

package/dist/types/components/new/ThemeProvider/ThemeContext.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import type { ThemeOptions, ThemeType } from './ThemeProvider';
+export declare const ThemeContext: React.Context<{
+    theme?: ThemeType;
+    themeOptions?: ThemeOptions;
+    portalContainer?: HTMLElement | null;
+}>;

package/dist/types/components/new/ThemeProvider/ThemeProvider.d.ts

@@ -0,0 +1,107 @@
+import * as React from 'react';
+import type { PolymorphicForwardRefComponent } from '../utils/index';
+export type ThemeOptions = {
+    /**
+     * Whether to apply high-contrast versions of light and dark themes.
+     * Will default to user preference if browser supports it.
+     */
+    highContrast?: boolean;
+};
+export type ThemeType = 'light' | 'dark' | 'os';
+type RootProps = {
+    /**
+     * Theme to be applied. Can be 'light' or 'dark' or 'os'.
+     *
+     * Note that 'os' will respect the system preference on client but will fallback to 'light'
+     * in SSR environments because it is not possible detect system preference on the server.
+     * This can cause a flash of incorrect theme on first render.
+     *
+     * The 'inherit' option is intended to be used by packages, to enable incremental adoption
+     * of iTwinUI while respecting the theme set by the consuming app. It will fall back to 'light'
+     * if no parent theme is found. Additionally, it will attempt to inherit `themeOptions.highContrast`
+     * and `portalContainer` (if possible).
+     *
+     * @default 'inherit'
+     */
+    theme?: ThemeType | 'inherit';
+    themeOptions?: Pick<ThemeOptions, 'highContrast'> & {
+        /**
+         * Whether or not the element should apply the recommended `background-color` on itself.
+         *
+         * When not specified, the default behavior is to apply a background-color only
+         * if it is the topmost `ThemeProvider` in the tree. Nested `ThemeProvider`s will
+         * be detected using React Context and will not apply a background-color.
+         *
+         * Additionally, if theme is set to `'inherit'`, then this will default to false.
+         *
+         * When set to true or false, it will override the default behavior.
+         */
+        applyBackground?: boolean;
+    };
+    /**
+     * This will be used to determine if background will be applied.
+     */
+    shouldApplyBackground?: boolean;
+};
+type ThemeProviderOwnProps = Pick<RootProps, 'theme'> & {
+    themeOptions?: RootProps['themeOptions'];
+    children: Required<React.ReactNode>;
+    /**
+     * The element used as the portal for floating elements (Tooltip, Toast, DropdownMenu, Dialog, etc).
+     *
+     * Defaults to a `<div>` rendered at the end of the ThemeProvider.
+     *
+     * When passing an element, it is recommended to use state.
+     *
+     * @example
+     * const [myPortal, setMyPortal] = React.useState(null);
+     *
+     * <div ref={setMyPortal} />
+     * <ThemeProvider
+     *   portalContainer={myPortal}
+     * >
+     *   ...
+     * </ThemeProvider>
+     */
+    portalContainer?: HTMLElement;
+    /**
+     * This prop will be used to determine if `styles.css` should be automatically imported at runtime (if not already found).
+     *
+     * By default, this is enabled when using `theme='inherit'`.
+     * This default behavior is useful for packages that want to support incremental adoption of latest iTwinUI,
+     * without requiring consuming applications (that might still be using an older version) to manually import the CSS.
+     *
+     * If true or false is passed, it will override the default behavior.
+     */
+    includeCss?: boolean;
+};
+/**
+ * This component provides global state and applies theme to the entire tree
+ * that it is wrapping around.
+ *
+ * The `theme` prop defaults to "inherit", which looks upwards for closest ThemeProvider
+ * and falls back to "light" theme if one is not found.
+ *
+ * If you want to theme the entire app, you should use this component at the root. You can also
+ * use this component to apply a different theme to only a part of the tree.
+ *
+ * By default, the topmost `ThemeProvider` in the tree will apply the recommended
+ * `background-color`. You can override this behavior using `themeOptions.applyBackground`.
+ *
+ * @example
+ * <ThemeProvider theme='os'>
+ *  <App />
+ * </ThemeProvider>
+ *
+ * @example
+ * <ThemeProvider as='body'>
+ *   <App />
+ * </ThemeProvider>
+ *
+ * @example
+ * <ThemeProvider theme='dark' themeOptions={{ applyBackground: false }}>
+ *  <App />
+ * </ThemeProvider>
+ */
+export declare const ThemeProvider: PolymorphicForwardRefComponent<"div", ThemeProviderOwnProps>;
+export {};

package/dist/types/components/new/Toast/Toast.d.ts

@@ -0,0 +1,78 @@
+import * as React from "react";
+import type { PolymorphicForwardRefComponent } from "../utils/index";
+export type ToastCategory = "informational" | "negative" | "positive" | "warning";
+export type ToastProps = {
+    /**
+     * Internal id of the toast. Used for closing the toasts.
+     */
+    id: number;
+    /**
+     * Content of the Toast message
+     */
+    content: React.ReactNode;
+    /**
+     * Passes props to toast and content
+     */
+    domProps?: {
+        toastProps?: React.ComponentProps<"div">;
+        contentProps?: React.ComponentProps<"div">;
+    };
+    /**
+     * Category of the Toast, which controls the border color, as well as the category icon.
+     */
+    category: ToastCategory;
+    /**
+     * The Type of the Toast.
+     * Persisting Toasts will not be closed automatically, and will contain a close button.
+     * Temporary Toasts will automatically close after 7 seconds and will not contain a close button.
+     * @default 'temporary'
+     */
+    type?: "persisting" | "temporary";
+    /**
+     * Controlled boolean prop indicating whether the toast is visible.
+     */
+    isVisible?: boolean;
+    /**
+     * Duration of the toast in millisecond.
+     * @default 7000
+     */
+    duration?: number;
+    /**
+     * Boolean indicating when the close button is visible.
+     * When false, the toast will not have any close button.
+     */
+    hasCloseButton?: boolean;
+    /**
+     * Props for a button/link that can be used to perform an action
+     * (e.g. to show additional information).
+     */
+    link?: {
+        title: string;
+    } & Omit<React.ComponentPropsWithoutRef<"button">, "children">;
+    /**
+     * Function called when the toast is all the way closed.
+     */
+    onRemove?: () => void;
+    /**
+     * Element to which the toast will animate out to.
+     */
+    animateOutTo?: HTMLElement | null;
+};
+/**
+ * Generic Toast Component
+ * @example
+ * <Toast type='persisting' content='Job processing completed.' category='positive' link={{onClick:() => {alert('Link callback')}, title:'View the report'}} />
+ * <Toast type='temporary' content='Processing completed.' category='positive' />
+ * <Toast type='temporary' content='26 files are available for synchronization.' category='informational' />
+ * <Toast type='persisting' content='Job processing error.' category='negative' />
+ */
+export declare const Toast: (props: ToastProps) => import("react/jsx-runtime").JSX.Element;
+export type ToastPresentationProps = Omit<ToastProps, "duration" | "id" | "isVisible" | "onRemove" | "domProps"> & {
+    onClose?: () => void;
+    contentProps?: React.ComponentProps<"div">;
+};
+/**
+ * The presentational part of a toast, without any animation or logic.
+ * @private
+ */
+export declare const ToastPresentation: PolymorphicForwardRefComponent<"div", ToastPresentationProps>;

package/dist/types/components/new/Toast/Toaster.d.ts

@@ -0,0 +1,46 @@
+import * as React from "react";
+import type { ToastProps } from "./Toast";
+export type ToasterSettings = {
+    /**
+     * Order of toasts.
+     * When set to 'descending', most recent toasts are on top. When set to 'ascending', most recent toasts are on bottom.
+     *
+     * When set to `auto`, it will behave like 'descending' when `placement` is set to a top value, otherwise 'ascending'.
+     *
+     * @default 'auto'
+     */
+    order: "descending" | "ascending" | "auto";
+    /**
+     * Placement of toasts.
+     * Changes placement of toasts. Start indicates left side of viewport. End - right side of viewport.
+     * @default 'top'
+     */
+    placement: "top" | "top-start" | "top-end" | "bottom" | "bottom-start" | "bottom-end";
+};
+export type ToastOptions = Omit<ToastProps, "category" | "isVisible" | "id" | "content">;
+export declare const useToaster: () => {
+    positive: (content: React.ReactNode, options?: ToastOptions) => {
+        close: () => void;
+    };
+    informational: (content: React.ReactNode, options?: ToastOptions) => {
+        close: () => void;
+    };
+    negative: (content: React.ReactNode, options?: ToastOptions) => {
+        close: () => void;
+    };
+    warning: (content: React.ReactNode, options?: ToastOptions) => {
+        close: () => void;
+    };
+    closeAll: () => void;
+    setSettings: (settings: Partial<ToasterSettings>) => void;
+};
+export declare const Toaster: () => import("react/jsx-runtime").JSX.Element;
+export declare const ToastProvider: ({ children }: {
+    children: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const ToasterStateContext: React.Context<ToasterState>;
+type ToasterState = {
+    toasts: ToastProps[];
+    settings: ToasterSettings;
+};
+export {};

package/dist/types/components/new/VisuallyHidden/VisuallyHidden.d.ts

@@ -0,0 +1,22 @@
+import type { PolymorphicForwardRefComponent } from "../utils/props";
+type VisuallyHiddenOwnProps = {
+    /**
+     * When VisuallyHidden is used with an interactive element (e.g. button),
+     * that element will "unhide" (become visible again) when focused.
+     *
+     * @default true
+     */
+    unhideOnFocus?: boolean;
+};
+/**
+ * Hides content visually but keeps it still accessible to screen readers
+ * and other assistive technologies.
+ *
+ * @example
+ * <div aria-hidden='true'>★★★☆☆</div>
+ * <VisuallyHidden>3 stars out of 5</VisuallyHidden>
+ *
+ * @see https://www.scottohara.me/blog/2017/04/14/inclusively-hidden.html
+ */
+export declare const VisuallyHidden: PolymorphicForwardRefComponent<"span", VisuallyHiddenOwnProps>;
+export {};

package/dist/types/components/new/utils/color/ColorValue.d.ts

@@ -0,0 +1,180 @@
+/**
+ * A color defined by Red, Green, and Blue
+ */
+export type RgbColor = {
+    /** 0-255 */
+    r: number;
+    /** 0-255 */
+    g: number;
+    /** 0-255 */
+    b: number;
+    /** 0-1 */
+    a?: number;
+};
+/**
+ * A color defined by Hue, Saturation, and Lightness.
+ */
+export type HslColor = {
+    /** 0-360 */
+    h: number;
+    /** 0-100 */
+    s: number;
+    /** 0-100 */
+    l: number;
+    /** 0-1 */
+    a?: number;
+};
+/**
+ * A color defined by Hue, Saturation, and Value
+ */
+export type HsvColor = {
+    /** 0-360 */
+    h: number;
+    /** 0-100 */
+    s: number;
+    /** 0-100 */
+    v: number;
+    /** 0-1 */
+    a?: number;
+};
+/**
+ * All supported color specifications.
+ */
+export type ColorType = string | RgbColor | HslColor | HsvColor;
+/**
+ * isRgbValue type guard.
+ */
+export declare const isRgbColor: (value: ColorType) => value is RgbColor;
+/**
+ * isHslValue type guard.
+ */
+export declare const isHslColor: (value: ColorType) => value is HslColor;
+/**
+ * isHsvValue type guard.
+ */
+export declare const isHsvColor: (value: ColorType) => value is HsvColor;
+/**
+ * An immutable integer representation of a color.
+ *
+ * Colors are stored as 4 components: Red, Blue, Green, and Transparency (0=fully opaque). Each is an 8-bit integer between 0-255.
+ * ColorValue uses `0xTTBBGGRR` (red in the low byte. 0==fully opaque in high byte) internally, but it also provides methods
+ * to return colors in popular web formats.
+ *
+ * The `create` method accepts any ColorType format.
+ *
+ * @public
+ */
+export declare class ColorValue {
+    private readonly _tbgr;
+    /** hue value provided by user */
+    private readonly _hue?;
+    private constructor();
+    /**
+     * Create a new ColorValue.
+     * @param val value to use.
+     *
+     * If a string, must be in one of the following forms:
+     * *"rgb(255,0,0)"*
+     * *"rgba(255,0,0,.2)"*
+     * *"rgb(100%,0%,0%)"*
+     * *"hsl(120,50%,50%)"*
+     * *"#rrggbb"*
+     */
+    static create(val?: ColorType): ColorValue;
+    /**
+     * Convert this ColorValue to an unsigned 32 bit integer representing the 0xTTBBGGRR value
+     */
+    toTbgr(): number;
+    /**
+     * Create a ColorValue from its 0xTTBBGGRR representation.
+     */
+    static fromTbgr(tbgr: number): ColorValue;
+    /**
+     * Create a ColorValue from Red, Green, Blue, Transparency values. All inputs should be integers between 0-255.
+     */
+    private static fromRgbt;
+    /**
+     * Compute the 0xTTBBGGRR value corresponding to the specified Red, Green, Blue, Transparency components.
+     *  All inputs should be integers between 0-255.
+     */
+    private static computeTbgrFromComponents;
+    /**
+     * Create a ColorValue from a string representation. The following representations are supported:
+     * *"rgb(255,0,0)"*
+     * *"rgba(255,0,0,.2)"*
+     * *"rgb(100%,0%,0%)"*
+     * *"hsl(120,50%,50%)"*
+     * *"#rrggbb"*
+     * NOTE: If defaultColorIfNotParsed is not defined and string is invalid then error is thrown.
+     * This allows component builders to know if they received bad input from user.
+     */
+    static fromString(val: string, defaultColorIfNotParsed?: ColorValue): ColorValue;
+    /** Create a ColorValue from hue, saturation, lightness values.  */
+    private static fromHSL;
+    /** Create a ColorValue from an RgbColor */
+    private static fromRGB;
+    /**
+     * Create a ColorValue from an HsvColor
+     */
+    private static fromHSV;
+    /**
+     * Compute the 0xTTBBGGRR value corresponding to a string representation of a color. The following representations are supported:
+     * *"rgb(255,0,0)"*
+     * *"rgba(255,0,0,.2)"*
+     * *"rgb(100%,0%,0%)"*
+     * *"hsl(120,50%,50%)"*
+     * *"#rrggbb"*
+     */
+    private static computeTbgrFromString;
+    /**
+     * Get the r,g,b,t values encoded in an 0xTTBBGGRR value. Values will be integers between 0-255.
+     */
+    private static getColors;
+    /**
+     * Get the RGB value of the 0xTTBBGGRR color as a number in 0xRRGGBB or 0xRRGGBBAA format
+     */
+    private getRgb;
+    /**
+     * Get the alpha value for this ColorDef. Will be between 0-255
+     */
+    getAlpha(): number;
+    /**
+     * Extract the alpha value from a 0xTTBBGGRR color.
+     */
+    private static getAlpha;
+    /**
+     * Convert this ColorValue to a string in the form "#rrggbb" or "#rrggbbaa" where values are hex digits of the respective colors
+     */
+    toHexString(includeAlpha?: boolean): string;
+    /**
+     * Compute the 0xTTBBGGRR color corresponding to the specified hue, saturation, lightness values.
+     */
+    private static computeTbgrFromHSL;
+    /**
+     * Return HslColor from this ColorValue
+     */
+    toHslColor(): HslColor;
+    /** Create an HslColor from this ColorValue */
+    private static toHsl;
+    /**
+     * Create an RgbColor from this ColorValue
+     */
+    toRgbColor(): RgbColor;
+    /**
+     * Return HsvColor from this ColorValue
+     */
+    toHsvColor(): HsvColor;
+    /**
+     * Create an HsvColor from this ColorValue
+     */
+    private static toHsv;
+    /** True if the value of this ColorValue is the same as another ColorValue. */
+    equals(other: ColorValue): boolean;
+    static getFormattedColorNumber(value: number, precision?: number): string;
+    /** Convert the 0xTTBBGGRR color to a string of the form "rgba(r,g,b,a)" where the color components are specified in decimal and the alpha component is a fraction. */
+    toRgbString(includeAlpha?: boolean): string;
+    /** Convert this ColorValue to a string in the form "hsl(h,s,l) or hsla(h,s,l,a)" - i.e hsl(120,50%,50%). */
+    toHslString(includeAlpha?: boolean): string;
+    /** Convert this ColorValue to a string in the form "hsv(h,s,v) or hsva(h,s,v,a)" - i.e hsv(120,50%,50%). */
+    toHsvString(includeAlpha?: boolean): string;
+}

package/dist/types/components/new/utils/color/index.d.ts

@@ -0,0 +1 @@
+export * from "./ColorValue";

package/dist/types/components/new/utils/components/AutoclearingHiddenLiveRegion.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Visually-hidden polite live region that automatically clears itself after 5 seconds.
+ *
+ * Should only be used for small updates and user-initiated actions (e.g. when _updating_ the selection),
+ * otherwise it could cause too many announcements every time an instance of this component is mounted.
+ *
+ * @private
+ */
+export declare const AutoclearingHiddenLiveRegion: ({ text }: {
+    text?: string;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/types/components/new/utils/components/Box.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Polymorphic component that renders a div element by default.
+ * Intended to be used as a base for other components.
+ * @private
+ */
+export declare const Box: import("..").PolymorphicForwardRefComponent<"div", {}>;

package/dist/types/components/new/utils/components/ButtonBase.d.ts

@@ -0,0 +1,14 @@
+import type { PolymorphicForwardRefComponent } from "../props";
+export declare const ButtonBase: PolymorphicForwardRefComponent<"button", ButtonBaseProps>;
+type ButtonBaseProps = {
+    /**
+     * Custom `disabled` prop that keeps the button focusable, prevents
+     * clicks, applied disabled styling, and adds `aria-disabled`.
+     */
+    disabled?: boolean;
+    /**
+     * Built-in html `disabled` attribute
+     */
+    htmlDisabled?: boolean;
+};
+export {};