asma-ui-core 3.33.0 → 3.35.0

package/dist/src/api-surface.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/components/data-display/badge/StyledBadge.d.ts

@@ -1,8 +1,32 @@
-import { BadgeProps } from '@mui/material';
+import { ElementType, HTMLAttributes, ReactNode } from 'react';
 type StyledBadgeSize = 'medium' | 'small';
+interface BadgeProps extends Omit<HTMLAttributes<HTMLSpanElement>, 'color'> {
+    badgeContent?: ReactNode;
+    color?: string;
+    max?: number;
+    showZero?: boolean;
+    variant?: 'standard' | 'dot';
+    invisible?: boolean;
+    anchorOrigin?: {
+        vertical: 'top' | 'bottom';
+        horizontal: 'left' | 'right';
+    };
+    overlap?: 'rectangular' | 'circular';
+    component?: ElementType;
+    classes?: Record<string, string>;
+    slots?: Record<string, unknown>;
+    slotProps?: unknown;
+    sx?: unknown;
+}
 type StyledBadgeProps = BadgeProps & {
     dataTest: string;
     size?: StyledBadgeSize;
 };
-export declare const StyledBadge: React.FC<StyledBadgeProps>;
+/**
+ * Native, MUI-free reimplementation of the previous `Badge` passthrough. Reproduces MUI v9 badge
+ * metrics/positioning via Tailwind, this library's custom `primary` green, and the `small` size.
+ * The established styling API `sx={{ '& .MuiBadge-badge': {...} }}` is preserved by extracting that
+ * slot and applying `resolveSx` to the badge span (DEC-007 slot-sx). Signature unchanged (DEC-003).
+ */
+export declare const StyledBadge: ({ color, dataTest, size, badgeContent, max, showZero, variant, invisible, anchorOrigin, children, className, sx, overlap: _overlap, classes: _classes, slots: _slots, slotProps: _slotProps, component: _component, ...props }: StyledBadgeProps) => JSX.Element;
 export {};

package/dist/src/components/data-display/chip/StyledChip.d.ts

@@ -1,7 +1,41 @@
-import { ChipProps } from '@mui/material';
-import { default as React } from 'react';
-export type StyledChipProps = ChipProps & {
+import { MouseEvent, ReactElement, ReactNode } from 'react';
+interface ChipClasses {
+    root?: string;
+    label?: string;
+    avatar?: string;
+    icon?: string;
+    deleteIcon?: string;
+}
+export interface StyledChipProps {
     dataTest: string;
+    label?: ReactNode;
+    /** Cosmetic only — the design always renders a white body with a delta border (kept from the MUI original). */
+    variant?: 'filled' | 'outlined';
+    color?: string;
+    size?: 'small' | 'medium';
+    disabled?: boolean;
     readOnly?: boolean;
-};
-export declare const StyledChip: React.ForwardRefExoticComponent<Omit<StyledChipProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    clickable?: boolean;
+    icon?: ReactElement;
+    avatar?: ReactElement;
+    deleteIcon?: ReactElement;
+    onDelete?: (event: MouseEvent<HTMLElement>) => void;
+    onClick?: (event: MouseEvent<HTMLElement>) => void;
+    className?: string;
+    classes?: ChipClasses;
+    sx?: unknown;
+    tabIndex?: number;
+    'aria-label'?: string;
+    /** Forces the hover visual (used by stories / state tables). */
+    'data-hovered'?: string;
+    /** Forces the focus visual (used by stories / state tables). */
+    'data-focus'?: string;
+}
+/**
+ * Native replacement for MUI `Chip` — a styled element with optional avatar/icon start slot, a
+ * label, and a delete button. Interactive hover/focus/active visuals also respond to the
+ * `data-hovered`/`data-focus` attributes MUI set (state tables rely on them). Public props +
+ * `classes`/`sx` slots preserved (DEC-003). TASK-101a.
+ */
+export declare const StyledChip: import('node_modules/@types/react').ForwardRefExoticComponent<StyledChipProps & import('node_modules/@types/react').RefAttributes<HTMLDivElement>>;
+export {};

package/dist/src/components/data-display/interactive-chip/StyledInteractiveChip.d.ts

@@ -1,10 +1,17 @@
-import { ComponentProps, FC } from 'react';
+import { ComponentProps } from 'react';
 import { StyledChip } from '../chip';
-import { CheckboxProps, RadioProps } from '@mui/material';
 export interface StyledInteractiveChipProps extends ComponentProps<typeof StyledChip> {
     type?: 'checkbox' | 'radio';
-    checked?: (CheckboxProps | RadioProps)['checked'];
+    checked?: boolean;
     size?: 'small' | 'medium';
     ariaLabel?: string;
 }
-export declare const StyledInteractiveChip: FC<StyledInteractiveChipProps>;
+/**
+ * A `StyledChip` whose avatar is a native checkbox or radio (base-ui controls now render their own
+ * checked/read-only colours, so the old nested `.MuiChip-avatar .Mui*` `sx` is gone). Public props
+ * preserved (DEC-003). TASK-101a.
+ *
+ * ponytail: a selected radio chip uses inline style for its border, so it shows no hover recolour
+ * while selected — a minor known ceiling; upgrade path is REFACTOR-001 (className-based slots).
+ */
+export declare const StyledInteractiveChip: import('node_modules/@types/react').ForwardRefExoticComponent<Omit<StyledInteractiveChipProps, "ref"> & import('node_modules/@types/react').RefAttributes<HTMLDivElement>>;

package/dist/src/components/data-display/tooltip/StyledTooltip.d.ts

@@ -1,2 +1,36 @@
-import { TooltipProps } from '@mui/material';
-export declare const StyledTooltip: (props: TooltipProps) => JSX.Element;
+import { CSSProperties, ReactElement, ReactNode } from 'react';
+import { Placement } from '@floating-ui/react';
+interface TooltipSlotProps {
+    tooltip?: {
+        sx?: unknown;
+        className?: string;
+        style?: CSSProperties;
+    };
+    popper?: unknown;
+    transition?: unknown;
+    arrow?: unknown;
+}
+export interface TooltipProps {
+    title: ReactNode;
+    children: ReactElement;
+    placement?: Placement;
+    arrow?: boolean;
+    enterDelay?: number;
+    leaveDelay?: number;
+    open?: boolean;
+    onOpen?: () => void;
+    onClose?: () => void;
+    disableHoverListener?: boolean;
+    disableFocusListener?: boolean;
+    disableTouchListener?: boolean;
+    className?: string;
+    slotProps?: TooltipSlotProps;
+}
+/**
+ * Tooltip built on `@floating-ui/react` (replaces MUI `Tooltip`) — hover(+`enterDelay`)/focus open,
+ * dismiss on blur/esc, `flip`/`shift` collision handling, optional arrow, portalled. Empty `title`
+ * renders the child alone (MUI parity). Preserves the `#363E4A` design and the `title`/`placement`/
+ * `arrow`/`enterDelay`/`open`/`slotProps` surface (DEC-003). TASK-301.
+ */
+export declare const StyledTooltip: ({ title, children, placement, arrow, enterDelay, leaveDelay, open: controlledOpen, onOpen, onClose, disableHoverListener, disableFocusListener, className, slotProps, }: TooltipProps) => JSX.Element;
+export {};

package/dist/src/components/data-display/typography/StyledTypography.d.ts

@@ -1,2 +1,20 @@
-import { TypographyProps } from '@mui/material';
+import { CSSProperties, ElementType, HTMLAttributes, ReactNode } from 'react';
+export interface TypographyProps extends Omit<HTMLAttributes<HTMLElement>, 'color'> {
+    variant?: string;
+    variantMapping?: Record<string, string>;
+    align?: CSSProperties['textAlign'];
+    noWrap?: boolean;
+    gutterBottom?: boolean;
+    color?: string;
+    component?: ElementType;
+    sx?: unknown;
+    classes?: Record<string, string>;
+    children?: ReactNode;
+}
+/**
+ * Native, MUI-free reimplementation of the previous `Typography` passthrough. Reproduces MUI v9's
+ * default typography scale via Tailwind utilities, the variant→element mapping, and the
+ * `align`/`noWrap`/`gutterBottom`/`color` props. `sx` is honoured via `resolveSx` (DEC-007).
+ * Signature unchanged: still accepts `TypographyProps` (DEC-003).
+ */
 export declare const StyledTypography: (props: TypographyProps) => JSX.Element;

package/dist/src/components/feedback/dialog/StyledDialog.d.ts

@@ -1,11 +1,44 @@
-import { DialogProps } from '@mui/material/Dialog';
-import { ReactNode } from 'react';
-export interface IStyledDialogProps extends DialogProps {
+import { CSSProperties, ReactNode, SyntheticEvent } from 'react';
+export type DialogCloseReason = 'escapeKeyDown' | 'backdropClick';
+export type DialogMaxWidth = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | false;
+interface DialogPaperProps {
+    className?: string;
+    sx?: unknown;
+    ref?: React.Ref<HTMLDialogElement>;
+}
+export interface IStyledDialogProps {
+    open: boolean;
+    onClose?: (event: SyntheticEvent | Event, reason: DialogCloseReason) => void;
+    children?: ReactNode;
+    dataTest: string;
+    maxWidth?: DialogMaxWidth;
+    fullWidth?: boolean;
+    fullScreen?: boolean;
+    scroll?: 'paper' | 'body';
+    disableEscapeKeyDown?: boolean;
+    className?: string;
+    style?: CSSProperties;
+    sx?: unknown;
+    PaperProps?: DialogPaperProps;
+    slotProps?: {
+        paper?: DialogPaperProps;
+        backdrop?: Record<string, unknown>;
+    };
     onCloseText?: ReactNode;
     showCloseIcon?: boolean;
-    dataTest: string;
     dialogLabel?: ReactNode;
     dialogTitle?: ReactNode;
     dialogHeaderNode?: ReactNode;
 }
+/**
+ * Modal dialog built on the native `<dialog>` element (replaces MUI `Dialog`) — backdrop, focus
+ * trap and ESC handling come from `showModal()` for free. The `<dialog>` element is the "paper",
+ * so `PaperProps`/`slotProps.paper` and `className` style it directly; `::backdrop` is the overlay.
+ * Public props preserved (DEC-003). TASK-205.
+ *
+ * ponytail: open/close is instant (no MUI fade) and body-scroll behind the modal isn't locked —
+ * both known ceilings; Chromatic in CI is the visual gate. Upgrade path: add `@starting-style`
+ * transitions and a scroll-lock effect if a diff calls for it.
+ */
 export declare const StyledDialog: React.FC<IStyledDialogProps>;
+export {};

package/dist/src/components/feedback/dialog/StyledDialogActions.d.ts

@@ -1,2 +1,12 @@
-import { DialogActionsProps } from '@mui/material';
-export declare const StyledDialogActions: (props: DialogActionsProps) => JSX.Element;
+import { HTMLAttributes } from 'react';
+interface DialogActionsProps extends HTMLAttributes<HTMLDivElement> {
+    sx?: unknown;
+    classes?: Record<string, string>;
+    disableSpacing?: boolean;
+}
+/**
+ * MUI-free dialog actions: a right-aligned flex row of buttons; on mobile each button wrapper
+ * stretches full width (was a SCSS media query, now Tailwind `max-md:` arbitrary variant). TASK-101.
+ */
+export declare const StyledDialogActions: ({ children, className, sx, style, classes: _classes, disableSpacing: _disableSpacing, ...rest }: DialogActionsProps) => JSX.Element;
+export {};

package/dist/src/components/feedback/dialog/StyledDialogContent.d.ts

@@ -1,2 +1,12 @@
-import { DialogContentProps } from '@mui/material';
-export declare const StyledDialogContent: ({ children, classes, className, ...rest }: DialogContentProps) => JSX.Element;
+import { HTMLAttributes } from 'react';
+interface DialogContentProps extends HTMLAttributes<HTMLDivElement> {
+    sx?: unknown;
+    classes?: Record<string, string>;
+    dividers?: boolean;
+}
+/**
+ * MUI-free dialog content: a scrollable `<div>` with the previous SCSS metrics as Tailwind,
+ * plus MUI's optional `dividers` borders. TASK-101.
+ */
+export declare const StyledDialogContent: ({ children, className, sx, style, dividers, classes: _classes, ...rest }: DialogContentProps) => JSX.Element;
+export {};

package/dist/src/components/feedback/dialog/StyledDialogTitle.d.ts

@@ -1,2 +1,10 @@
-import { DialogTitleProps } from '@mui/material/DialogTitle';
-export declare const StyledDialogTitle: ({ children, ...rest }: DialogTitleProps) => JSX.Element | null;
+import { HTMLAttributes } from 'react';
+interface DialogTitleProps extends HTMLAttributes<HTMLHeadingElement> {
+    sx?: unknown;
+    classes?: Record<string, string>;
+}
+/**
+ * MUI-free dialog title: a semantic `<h2>` with the previous SCSS metrics as Tailwind. TASK-101.
+ */
+export declare const StyledDialogTitle: ({ children, className, sx, style, classes: _classes, ...rest }: DialogTitleProps) => JSX.Element | null;
+export {};

package/dist/src/components/feedback/snack-bar/SnackbarProvider.d.ts

@@ -1,4 +1,4 @@
-import { AlertColor } from '@mui/material';
+import { AlertColor } from './StyledAlert';
 import { SnackbarProviderProps } from 'notistack';
 export declare const SnackbarProvider: (props: SnackbarProviderProps) => JSX.Element;
 declare module 'notistack' {

package/dist/src/components/feedback/snack-bar/StyledAlert.d.ts

@@ -1,2 +1,24 @@
-import { AlertProps } from '@mui/material';
-export declare const StyledAlert: (props: AlertProps) => JSX.Element;
+import { MouseEvent, ReactNode } from 'react';
+export type AlertColor = 'success' | 'info' | 'warning' | 'error';
+export type AlertVariant = 'standard' | 'filled' | 'outlined';
+export interface AlertProps {
+    severity?: AlertColor;
+    variant?: AlertVariant;
+    icon?: ReactNode | false;
+    iconMapping?: Partial<Record<AlertColor, ReactNode>>;
+    action?: ReactNode;
+    onClose?: (event: MouseEvent<HTMLButtonElement>) => void;
+    children?: ReactNode;
+    className?: string;
+    sx?: unknown;
+    role?: string;
+}
+/**
+ * Alert banner (replaces MUI `Alert`). Native `role="alert"` with a leading severity icon, message
+ * and optional action/close button; `standard`/`filled`/`outlined` variants. Public props preserved
+ * (DEC-003). TASK-402.
+ *
+ * ponytail: severity uses the semantic `success`/`info`/`warning`/`error` token families —
+ * Chromatic in CI is the visual gate for exact shades.
+ */
+export declare const StyledAlert: ({ severity, variant, icon, iconMapping, action, onClose, children, className, sx, role, }: AlertProps) => JSX.Element;

package/dist/src/components/feedback/snack-bar/StyledAlertSnackbar.d.ts

@@ -1,4 +1,4 @@
-import { AlertColor } from '@mui/material';
+import { AlertColor } from './StyledAlert';
 import { CustomContentProps } from 'notistack';
 interface StyledAlertSnackbarProps extends CustomContentProps {
     severity?: AlertColor;

package/dist/src/components/feedback/snack-bar/StyledSnackbar.d.ts

@@ -1,2 +1,21 @@
-import { SnackbarProps } from '@mui/material';
-export declare const StyledSnackbar: ({ children, ...props }: SnackbarProps) => JSX.Element;
+import { ReactNode } from 'react';
+export interface SnackbarOrigin {
+    vertical: 'top' | 'bottom';
+    horizontal: 'left' | 'center' | 'right';
+}
+export interface SnackbarProps {
+    open?: boolean;
+    autoHideDuration?: number | null;
+    onClose?: (event: Event | null, reason: 'timeout' | 'clickaway') => void;
+    anchorOrigin?: SnackbarOrigin;
+    message?: ReactNode;
+    action?: ReactNode;
+    children?: ReactNode;
+    className?: string;
+}
+/**
+ * Positioned auto-hiding toast (replaces MUI `Snackbar`). Portalled, fixed to the `anchorOrigin`
+ * corner; auto-hides after `autoHideDuration` (null disables). Public props preserved (DEC-003).
+ * TASK-402.
+ */
+export declare const StyledSnackbar: ({ open, autoHideDuration, onClose, anchorOrigin, message, action, children, className, }: SnackbarProps) => JSX.Element | null;

package/dist/src/components/feedback/snack-bar/components/StyledDefaultSnackbar.d.ts

@@ -1,4 +1,4 @@
-import { AlertColor } from '@mui/material';
+import { AlertColor } from '../StyledAlert';
 import { CustomContentProps, SnackbarMessage } from 'notistack';
 export interface StyledDefaultSnackbarProps extends CustomContentProps {
     severity: AlertColor;

package/dist/src/components/feedback/snack-bar/components/StyledInfoSnackbar.d.ts

@@ -1,4 +1,4 @@
-import { AlertColor } from '@mui/material';
+import { AlertColor } from '../StyledAlert';
 import { CustomContentProps } from 'notistack';
 interface StyledInfoSnackbarProps extends CustomContentProps {
     severity?: AlertColor;

package/dist/src/components/feedback/snack-bar/components/types.d.ts

@@ -1,4 +1,4 @@
-import { AlertColor } from '@mui/material';
+import { AlertColor } from '../StyledAlert';
 import { SnackbarProviderProps } from 'notistack';
 export type MessageProps = SnackbarProviderProps & {
     severity?: AlertColor;

package/dist/src/components/inputs/checkbox/base-ui/StyledCheckbox.d.ts

@@ -1,5 +1,4 @@
-import { default as React, SVGProps } from 'react';
-import { Checkbox } from '@base-ui/react/checkbox';
+import { default as React, ChangeEvent, SVGProps } from 'react';
 type StyledCheckboxProps = {
     dataTest: string;
     size?: 'small' | 'medium';
@@ -9,9 +8,15 @@ type StyledCheckboxProps = {
     hideWrapper?: boolean;
     className?: string;
     checkboxClassName?: string;
-    onChange?: (event: React.ChangeEvent<HTMLInputElement>, checked: boolean) => void;
-} & Omit<React.ComponentProps<typeof Checkbox.Root>, 'children'>;
+    onChange?: (event: ChangeEvent<HTMLInputElement>, checked: boolean) => void;
+} & Omit<React.InputHTMLAttributes<HTMLInputElement>, 'onChange' | 'size' | 'checked' | 'type'>;
 export declare const IndeterminateIcon: (props: SVGProps<SVGSVGElement>) => JSX.Element;
 export declare const CheckIcon: (props: SVGProps<SVGSVGElement>) => JSX.Element;
+/**
+ * Native `<input type="checkbox">` checkbox (replaces `@base-ui/react`). A visually-hidden input
+ * carries state + a11y; the visual box, ripple, and indeterminate bar come from the SCSS module
+ * (kept: `@keyframes`/pseudo-elements aren't Tailwind-expressible — GUD-003), whose `data-*`
+ * selectors are driven from React here. Public props unchanged. TASK-201.
+ */
 export declare const StyledCheckbox: React.FC<StyledCheckboxProps>;
 export {};

package/dist/src/components/inputs/dynamic-select/types.d.ts

@@ -1,4 +1,4 @@
-import { AutocompleteProps } from '@mui/material';
+import { StyledSelectAutocompleteProps } from '../select-autocomplete';
 import { default as React } from 'react';
 export type DynamicSelectOptionPrimitive = string | number | boolean;
 export type DynamicSelectOptionObject = {
@@ -70,7 +70,7 @@ interface DynamicSelectCommonProps<TOption extends DynamicSelectOption> {
     /** Node prepended inside the autocomplete text input (e.g. a search icon). */
     startAdornment?: React.ReactNode;
     /** Escape hatch to pass any MUI `Autocomplete` prop directly. Applied on top of internal defaults in the autocomplete variant. */
-    autocompleteProps?: Partial<AutocompleteProps<TOption, boolean | undefined, boolean | undefined, boolean | undefined>>;
+    autocompleteProps?: Partial<StyledSelectAutocompleteProps<TOption, boolean | undefined, boolean | undefined, boolean | undefined>>;
     /**
      * When `true`, renders loading skeletons (chip group) or disables the input (autocomplete)
      * while data is being fetched.

package/dist/src/components/inputs/field-styles.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Shared outlined-field styling so `StyledInputField`, `StyledInputLabel` (+ `StyledFormControl`)
+ * and `StyledSelect` render an identical border + floating label without MUI. TASK-401.
+ */
+export type FieldSize = 'small' | 'medium';
+interface FieldState {
+    focused?: boolean;
+    error?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+}
+/** The border overlay (an absolutely-positioned sibling so width changes never reflow the input). */
+export declare const outlineClass: ({ focused, error, disabled, readOnly }: FieldState) => string;
+/**
+ * The floating label. `shrink` lifts it onto the top border (white background masks the line —
+ * the technique the old FormControl `sx` used, so no fieldset/legend notch is needed).
+ */
+export declare const floatingLabelClass: ({ shrink, focused, error, disabled, size, }: FieldState & {
+    shrink: boolean;
+    size?: FieldSize;
+}) => string;
+export {};

package/dist/src/components/inputs/input-field/StyledInputField.d.ts

@@ -1,14 +1,70 @@
-import { TextFieldProps } from '@mui/material';
+import { ChangeEvent, CSSProperties, FocusEvent, HTMLAttributes, ReactNode, Ref, InputHTMLAttributes } from 'react';
+import { FieldSize } from '../field-styles';
+interface InputSlot {
+    startAdornment?: ReactNode;
+    endAdornment?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+    ref?: Ref<HTMLInputElement | HTMLDivElement>;
+    [key: string]: unknown;
+}
+type HtmlInputSlot = InputHTMLAttributes<HTMLInputElement> & {
+    ref?: Ref<HTMLInputElement>;
+};
+export interface StyledInputFieldProps {
+    dataTest: string;
+    label?: ReactNode;
+    value?: string | number;
+    defaultValue?: string | number;
+    onChange?: (event: ChangeEvent<HTMLInputElement>) => void;
+    onBlur?: (event: FocusEvent<HTMLInputElement>) => void;
+    onFocus?: (event: FocusEvent<HTMLInputElement>) => void;
+    error?: boolean;
+    helperText?: ReactNode;
+    disabled?: boolean;
+    readOnly?: boolean;
+    required?: boolean;
+    allowClear?: boolean;
+    onClear?: () => void;
+    type?: string;
+    placeholder?: string;
+    name?: string;
+    id?: string;
+    autoComplete?: string;
+    autoFocus?: boolean;
+    multiline?: boolean;
+    rows?: number;
+    minRows?: number;
+    maxRows?: number;
+    size?: FieldSize;
+    /** Accepted for API parity; the design always renders outlined. */
+    variant?: string;
+    fullWidth?: boolean;
+    className?: string;
+    style?: CSSProperties;
+    sx?: unknown;
+    inputRef?: Ref<HTMLInputElement | HTMLTextAreaElement>;
+    slotProps?: {
+        input?: InputSlot;
+        htmlInput?: HtmlInputSlot;
+        inputLabel?: HTMLAttributes<HTMLLabelElement> & Record<string, unknown>;
+        formHelperText?: {
+            sx?: unknown;
+            className?: string;
+        };
+    };
+    /** Legacy MUI adornment slot (still used by ~22 call sites). */
+    InputProps?: InputSlot;
+    onKeyDown?: (event: React.KeyboardEvent<HTMLInputElement>) => void;
+}
 /**
+ * Outlined text field with a floating label (replaces MUI `TextField`). Self-contained: manages its
+ * own focus/value state to drive the shared field styling ([[field-styles]]); supports multiline,
+ * start/end adornments, an optional clear button, and error/helper text. Public props preserved
+ * (DEC-003). TASK-401.
  *
- * @inputRef
- * inputRef to get Node of Input Element inside
- *
- * type='mui-input' is temporary, remove it after deleting antd from all projects. Antd lib overwrites styles for type[text]
+ * ponytail: `variant` is accepted but always renders outlined, and multiline uses fixed `rows`
+ * (no auto-grow to `maxRows`) — known ceilings; Chromatic in CI is the visual gate.
  */
-export declare const StyledInputField: React.FC<TextFieldProps & {
-    allowClear?: boolean;
-    onClear?: () => void;
-    readOnly?: boolean;
-    dataTest: string;
-}>;
+export declare const StyledInputField: ({ dataTest, label, value, defaultValue, onChange, onBlur, onFocus, error, helperText, disabled, readOnly, required, allowClear, onClear, type, placeholder, name, id, autoComplete, autoFocus, multiline, rows, minRows, maxRows: _maxRows, size, fullWidth, className, style, sx, inputRef, slotProps, InputProps, onKeyDown, variant: _variant, }: StyledInputFieldProps) => JSX.Element;
+export {};

package/dist/src/components/inputs/input-field/index.d.ts

@@ -1,2 +1,2 @@
 export * from './StyledInputField';
-export { type TextFieldProps } from '@mui/material';
+export type { StyledInputFieldProps as TextFieldProps } from './StyledInputField';

package/dist/src/components/inputs/radio-button/base-ui/RadioGroupContext.d.ts

@@ -0,0 +1,10 @@
+export type RadioValue = string | number | boolean | null;
+export interface RadioGroupContextValue {
+    name: string;
+    value?: RadioValue;
+    disabled?: boolean;
+    onSelect: (value: RadioValue) => void;
+}
+/** Shared state for the native radio group (replaces `@base-ui/react`'s RadioGroup context). */
+export declare const RadioGroupContext: import('node_modules/@types/react').Context<RadioGroupContextValue | null>;
+export declare const useRadioGroupContext: () => RadioGroupContextValue | null;

package/dist/src/components/inputs/radio-button/base-ui/StyledRadio.d.ts

@@ -1,10 +1,25 @@
-import { default as React } from 'react';
-import { Radio } from '@base-ui/react/radio';
+import { default as React, ChangeEvent, InputHTMLAttributes } from 'react';
+import { RadioValue } from './RadioGroupContext';
 export type StyledRadioProps = {
-    value?: string | number | boolean;
+    value?: RadioValue;
     dataTest?: string;
     className?: string;
     size?: 'small' | 'medium';
     error?: boolean;
-} & Omit<React.ComponentProps<typeof Radio.Root>, 'value' | 'className'>;
-export declare const StyledRadio: React.ForwardRefExoticComponent<Omit<StyledRadioProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+    checked?: boolean;
+    onChange?: (event: ChangeEvent<HTMLInputElement>, checked: boolean) => void;
+} & Omit<InputHTMLAttributes<HTMLInputElement>, 'value' | 'className' | 'size' | 'checked' | 'onChange' | 'type'>;
+/**
+ * Native `<input type="radio">` (replaces `@base-ui/react`). Uses the surrounding
+ * `StyledRadioGroup` context for name/selection when present, else the standalone `checked` prop.
+ * SCSS module (ripple/pseudo-elements — GUD-003) is driven via `data-*` from React. TASK-201.
+ */
+export declare const StyledRadio: React.ForwardRefExoticComponent<{
+    value?: RadioValue;
+    dataTest?: string;
+    className?: string;
+    size?: "small" | "medium";
+    error?: boolean;
+    checked?: boolean;
+    onChange?: (event: ChangeEvent<HTMLInputElement>, checked: boolean) => void;
+} & Omit<React.InputHTMLAttributes<HTMLInputElement>, "value" | "className" | "onChange" | "size" | "type" | "checked"> & React.RefAttributes<HTMLInputElement>>;

package/dist/src/components/inputs/radio-button/base-ui/StyledRadioGroup.d.ts

@@ -1,14 +1,31 @@
-import { default as React } from 'react';
-import { RadioGroup } from '@base-ui/react/radio-group';
+import { default as React, HTMLAttributes } from 'react';
+import { RadioValue } from './RadioGroupContext';
 export type StyledRadioGroupProps = {
-    value?: string | number | boolean | null;
-    defaultValue?: string | number | boolean | null;
-    onValueChange?: (value: string | number | boolean | null) => void;
+    value?: RadioValue;
+    defaultValue?: RadioValue;
+    onValueChange?: (value: RadioValue) => void;
     disabled?: boolean;
     dataTest?: string;
     error?: boolean;
     errorText?: string;
     helperText?: string;
     children: React.ReactNode;
-} & Omit<React.ComponentProps<typeof RadioGroup>, 'children' | 'defaultValue' | 'value'>;
-export declare const StyledRadioGroup: React.ForwardRefExoticComponent<Omit<StyledRadioGroupProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    name?: string;
+} & Omit<HTMLAttributes<HTMLDivElement>, 'defaultValue' | 'onChange'>;
+/**
+ * Native radio group (replaces `@base-ui/react`): a `role="radiogroup"` container that shares
+ * name/selection with its `StyledRadio` children via context, controlled or uncontrolled, plus the
+ * error/helper text row. TASK-201.
+ */
+export declare const StyledRadioGroup: React.ForwardRefExoticComponent<{
+    value?: RadioValue;
+    defaultValue?: RadioValue;
+    onValueChange?: (value: RadioValue) => void;
+    disabled?: boolean;
+    dataTest?: string;
+    error?: boolean;
+    errorText?: string;
+    helperText?: string;
+    children: React.ReactNode;
+    name?: string;
+} & Omit<React.HTMLAttributes<HTMLDivElement>, "defaultValue" | "onChange"> & React.RefAttributes<HTMLDivElement>>;