asma-ui-core 3.34.0 → 3.35.0

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>>;

package/dist/src/components/inputs/select/StyledSelect.d.ts

@@ -1,19 +1,42 @@
-import { SelectProps } from '@mui/material';
-export type StyledSelectProps = SelectProps & {
-    allowClear?: boolean;
-    errorText?: string;
+import { CSSProperties, ReactNode } from 'react';
+import { FieldSize } from '../field-styles';
+export interface SelectChangeEvent<T = unknown> {
+    target: {
+        value: T;
+        name?: string;
+    };
+}
+export interface StyledSelectProps {
     dataTest: string;
-};
+    value?: unknown;
+    defaultValue?: unknown;
+    onChange?: (event: SelectChangeEvent, child: ReactNode) => void;
+    size?: FieldSize;
+    error?: boolean;
+    errorText?: string;
+    allowClear?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    name?: string;
+    placeholder?: string;
+    displayEmpty?: boolean;
+    renderValue?: (value: unknown) => ReactNode;
+    fullWidth?: boolean;
+    className?: string;
+    style?: CSSProperties;
+    /** Accepted for API parity; the design always renders outlined. */
+    variant?: string;
+    sx?: unknown;
+    labelId?: string;
+    children?: ReactNode;
+    MenuProps?: {
+        className?: string;
+    };
+}
 /**
- *
- * @usage
- * use StyleSelect only inside StyledFormControl
- *
- * @size
- * control the size through StyledFormControl
- *
- * @inputRef
- * inputRef to get Node of Input Element inside
- *
+ * Single-select dropdown (replaces MUI `Select`) — a trigger styled as the outlined field plus a
+ * portalled `role="listbox"`. Reports open/filled into a surrounding `StyledFormControl` so its
+ * `StyledInputLabel` floats. Public props preserved (DEC-003). Use inside `StyledFormControl`.
+ * TASK-402.
  */
-export declare const StyledSelect: React.FC<StyledSelectProps>;
+export declare const StyledSelect: ({ dataTest, value, defaultValue, onChange, size, error, errorText, allowClear, disabled, readOnly, name, placeholder, displayEmpty, renderValue, fullWidth, className, style, sx, children, MenuProps, }: StyledSelectProps) => JSX.Element;

package/dist/src/components/inputs/select/StyledSelectItem.d.ts

@@ -1,2 +1,14 @@
-import { MenuItemProps } from '@mui/material';
-export declare const StyledSelectItem: (item: MenuItemProps) => JSX.Element;
+import { MouseEvent, ReactNode } from 'react';
+export interface StyledSelectItemProps {
+    value?: unknown;
+    children?: ReactNode;
+    selected?: boolean;
+    disabled?: boolean;
+    className?: string;
+    onClick?: (event: MouseEvent<HTMLLIElement>) => void;
+}
+/**
+ * Option row for `StyledSelect` (replaces MUI `MenuItem` in the select context). `role="option"`
+ * with a leading check column for the selected state. Public props preserved (DEC-003). TASK-402.
+ */
+export declare const StyledSelectItem: ({ children, selected, disabled, className, onClick, }: StyledSelectItemProps) => JSX.Element;

package/dist/src/components/inputs/select/index.d.ts

@@ -1,3 +1,2 @@
 export * from './StyledSelect';
 export * from './StyledSelectItem';
-export { type SelectChangeEvent } from '@mui/material';

package/dist/src/components/inputs/select-autocomplete/StyledSelectAutocomplete.d.ts

@@ -1,25 +1,96 @@
-import { AutocompleteProps, ChipTypeMap } from '@mui/material';
-type StyledSelectAutocompleteBaseProps<T, Multiple extends boolean | undefined, DisableClearable extends boolean | undefined, FreeSolo extends boolean | undefined, ChipComponent extends React.ElementType> = Omit<AutocompleteProps<T, Multiple, DisableClearable, FreeSolo, ChipComponent>, 'multiple'> & {
+import { HTMLAttributes, KeyboardEvent, ReactNode, SyntheticEvent } from 'react';
+export type AutocompleteChangeReason = 'createOption' | 'selectOption' | 'removeOption' | 'clear' | 'blur';
+export type AutocompleteInputChangeReason = 'input' | 'reset' | 'clear';
+export interface AutocompleteRenderOptionState {
+    selected: boolean;
+    index: number;
+    inputValue: string;
+}
+/** Props the combobox hands to `renderInput`; spread straight onto `StyledInputField`. */
+export interface AutocompleteRenderInputParams {
+    disabled?: boolean;
+    size?: 'small' | 'medium';
+    fullWidth?: boolean;
+    value: string;
+    onChange: (event: React.ChangeEvent<HTMLInputElement>) => void;
+    onFocus: () => void;
+    onKeyDown: (event: KeyboardEvent<HTMLInputElement>) => void;
+    slotProps: {
+        htmlInput: Record<string, unknown> & {
+            ref: React.Ref<HTMLInputElement>;
+        };
+        input: {
+            startAdornment?: ReactNode;
+            endAdornment?: ReactNode;
+        };
+    };
+}
+type OptionLiProps = HTMLAttributes<HTMLLIElement> & {
+    key?: string;
+    ref?: React.Ref<HTMLLIElement>;
+    [dataAttr: `data-${string}`]: unknown;
+};
+type SingleValue<T> = T | null;
+type MultiValue<T> = T[];
+type AutocompleteValue<T, Multiple, DisableClearable, FreeSolo> = Multiple extends true ? MultiValue<T> : FreeSolo extends true ? T | string | null : DisableClearable extends true ? T : SingleValue<T>;
+export interface StyledSelectAutocompleteProps<T, Multiple extends boolean | undefined = false, DisableClearable extends boolean | undefined = false, FreeSolo extends boolean | undefined = false> {
     dataTest: string;
-    autoHeight?: boolean;
+    options: readonly T[];
+    renderInput: (params: AutocompleteRenderInputParams) => ReactNode;
+    value?: SingleValue<T> | MultiValue<T> | string | undefined;
+    defaultValue?: SingleValue<T> | MultiValue<T> | string | undefined;
+    onChange?: (event: SyntheticEvent, value: AutocompleteValue<T, Multiple, DisableClearable, FreeSolo>, reason: AutocompleteChangeReason, details?: {
+        option: T;
+    }) => void;
     getOptionLabel?: (option: T) => string;
-    wrapperClassName?: string;
-};
-type StyledSelectAutocompleteConditionalProps<Multiple extends boolean | undefined> = Multiple extends true ? {
-    multiple: true;
+    isOptionEqualToValue?: (option: T, value: T) => boolean;
+    renderOption?: (props: OptionLiProps, option: T, state: AutocompleteRenderOptionState) => ReactNode;
+    renderValue?: (value: MultiValue<T>, getItemProps: (opts: {
+        index: number;
+    }) => OptionLiProps) => ReactNode;
+    filterOptions?: (options: T[], state: {
+        inputValue: string;
+    }) => T[];
+    groupBy?: (option: T) => string;
+    loading?: boolean;
+    loadingText?: ReactNode;
+    noOptionsText?: ReactNode;
+    disabled?: boolean;
+    readOnly?: boolean;
+    size?: 'small' | 'medium';
+    disableClearable?: boolean;
+    freeSolo?: boolean;
+    open?: boolean;
+    onOpen?: (event?: SyntheticEvent) => void;
+    onClose?: (event?: SyntheticEvent, reason?: string) => void;
+    disableCloseOnSelect?: boolean;
+    inputValue?: string;
+    onInputChange?: (event: SyntheticEvent | null, value: string, reason: AutocompleteInputChangeReason) => void;
+    popupIcon?: ReactNode;
+    autoHeight?: boolean;
+    multiple?: Multiple;
     allowSelectAll?: boolean;
     selectAllLabel?: string;
-} : {
-    multiple?: Multiple;
-    allowSelectAll?: never;
-    selectAllLabel?: never;
-};
-export type StyledSelectAutocompleteProps<T, Multiple extends boolean | undefined, DisableClearable extends boolean | undefined, FreeSolo extends boolean | undefined, ChipComponent extends React.ElementType = ChipTypeMap['defaultComponent']> = StyledSelectAutocompleteBaseProps<T, Multiple, DisableClearable, FreeSolo, ChipComponent> & StyledSelectAutocompleteConditionalProps<Multiple>;
+    fullWidth?: boolean;
+    /** Accepted for MUI parity; single-select already omits selected options via filtering. */
+    filterSelectedOptions?: boolean;
+    classes?: {
+        root?: string;
+        paper?: string;
+        listbox?: string;
+    };
+    className?: string;
+    wrapperClassName?: string;
+    sx?: unknown;
+}
 /**
+ * Custom combobox (replaces MUI `Autocomplete`, DEC-002) built on `@floating-ui/react`. Supports
+ * single + multiple selection (with tag chips + optional select-all), type-ahead filtering,
+ * async `loading`, grouping, and the MUI `renderInput`/`renderOption`/`renderValue` callback
+ * contracts. Public props/generics preserved (DEC-003). TASK-401.
  *
- * @inputRef
- * inputRef to get Node of Input Element inside
- *
+ * ponytail: `freeSolo` is accepted (arbitrary input is emitted via onInputChange) but not turned
+ * into option values; exact keyboard-parity edge cases are Chromatic/axe-gated.
  */
-export declare function StyledSelectAutocomplete<T, Multiple extends boolean | undefined = false, DisableClearable extends boolean | undefined = false, FreeSolo extends boolean | undefined = false, ChipComponent extends React.ElementType = ChipTypeMap['defaultComponent']>({ dataTest, autoHeight, getOptionLabel, wrapperClassName, multiple, allowSelectAll, selectAllLabel, className, defaultValue, isOptionEqualToValue, onChange, options, popupIcon, readOnly, renderOption, renderValue, sx, value, ...props }: StyledSelectAutocompleteProps<T, Multiple, DisableClearable, FreeSolo, ChipComponent>): JSX.Element;
+export declare function StyledSelectAutocomplete<T, Multiple extends boolean | undefined = false, DisableClearable extends boolean | undefined = false, FreeSolo extends boolean | undefined = false>({ dataTest, options, renderInput, value, onChange, getOptionLabel, isOptionEqualToValue, renderOption, renderValue, filterOptions, loading, loadingText, noOptionsText, disabled, readOnly, size, disableClearable, popupIcon, multiple, fullWidth, classes, inputValue: controlledInput, onInputChange, open: controlledOpen, onOpen, onClose, className, wrapperClassName, }: StyledSelectAutocompleteProps<T, Multiple, DisableClearable, FreeSolo>): JSX.Element;
 export {};