asma-ui-core 3.33.0 → 3.35.0

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

package/dist/src/components/inputs/slider/StyledSlider.d.ts

@@ -1,8 +1,60 @@
-import { SliderProps } from '@mui/material';
-export interface StyledSliderProps extends SliderProps {
+import { ReactNode, SyntheticEvent } from 'react';
+export interface SliderMark {
+    value: number;
+    label?: ReactNode;
+}
+type SliderValue = number | number[];
+interface SliderClasses {
+    root?: string;
+    rail?: string;
+    track?: string;
+    thumb?: string;
+    mark?: string;
+    markActive?: string;
+    markLabel?: string;
+    markLabelActive?: string;
+}
+interface SliderSlotProps {
+    thumb?: {
+        className?: string;
+    };
+    rail?: {
+        className?: string;
+    };
+    markLabel?: {
+        className?: string;
+    };
+}
+export interface StyledSliderProps {
     dataTest: string;
+    min?: number;
+    max?: number;
+    step?: number;
+    value?: SliderValue;
+    defaultValue?: SliderValue;
+    disabled?: boolean;
+    size?: 'small' | 'medium';
+    orientation?: 'horizontal' | 'vertical';
+    marks?: boolean | SliderMark[];
+    name?: string;
+    className?: string;
+    classes?: SliderClasses;
+    slotProps?: SliderSlotProps;
     error?: boolean;
     errorText?: string;
     helperText?: string;
+    onChange?: (event: SyntheticEvent, value: SliderValue, activeThumb: number) => void;
+    onChangeCommitted?: (event: SyntheticEvent, value: SliderValue) => void;
 }
-export declare const StyledSlider: ({ dataTest, error, errorText, helperText, ...props }: StyledSliderProps) => JSX.Element;
+/**
+ * Native range-input slider (replaces MUI `Slider`). Single value uses one `<input type="range">`;
+ * a two-element `value` renders two stacked inputs (each thumb independently grabbable via
+ * pointer-events on the thumb only). Marks, vertical orientation, `classes`/`slotProps` slots and
+ * `onChange`/`onChangeCommitted` are preserved (DEC-003).
+ *
+ * ponytail: exact-pixel parity with MUI's thumb travel/animation is a known ceiling — Chromatic in
+ * CI is the visual gate. Upgrade path: tune the 8px thumb inset if a diff shows misalignment.
+ * TASK-204.
+ */
+export declare const StyledSlider: ({ dataTest, min, max, step, value, defaultValue, disabled, size, orientation, marks, name, className, classes, slotProps, error, errorText, helperText, onChange, onChangeCommitted, }: StyledSliderProps) => JSX.Element;
+export {};

package/dist/src/components/inputs/switch/base-ui/StyledSwitch.d.ts

@@ -1,5 +1,4 @@
-import { default as React } from 'react';
-import { Switch } from '@base-ui/react/switch';
+import { default as React, ButtonHTMLAttributes } from 'react';
 type StyledSwitchProps = {
     checked?: boolean;
     defaultChecked?: boolean;
@@ -9,7 +8,24 @@ type StyledSwitchProps = {
     required?: boolean;
     id?: string;
     dataTest?: string;
-} & Omit<React.ComponentProps<typeof Switch.Root>, 'children'>;
+    className?: string;
+} & Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'onChange' | 'type'>;
 export type SwitchProps = StyledSwitchProps;
-export declare const StyledSwitch: React.ForwardRefExoticComponent<Omit<StyledSwitchProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+/**
+ * Native `<button role="switch">` toggle (replaces `@base-ui/react`). Drives the SCSS module's
+ * `data-checked`/`data-unchecked`/`data-disabled` selectors from React; the visual track/thumb stay
+ * in SCSS (transitions/pseudo-elements — GUD-003). Public props + `onChange(event, checked)`
+ * unchanged. TASK-201.
+ */
+export declare const StyledSwitch: React.ForwardRefExoticComponent<{
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onChange?: (event: React.ChangeEvent<HTMLInputElement>, checked: boolean) => void;
+    disabled?: boolean;
+    readOnly?: boolean;
+    required?: boolean;
+    id?: string;
+    dataTest?: string;
+    className?: string;
+} & Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "onChange" | "type"> & React.RefAttributes<HTMLButtonElement>>;
 export {};

package/dist/src/components/miscellaneous/FormControlContext.d.ts

@@ -0,0 +1,14 @@
+import { FieldSize } from '../inputs/field-styles';
+export interface FormControlContextValue {
+    focused: boolean;
+    filled: boolean;
+    error: boolean;
+    disabled: boolean;
+    required: boolean;
+    size: FieldSize;
+    labelId?: string;
+    setFocused: (value: boolean) => void;
+    setFilled: (value: boolean) => void;
+}
+export declare const FormControlContext: import('node_modules/@types/react').Context<FormControlContextValue | null>;
+export declare const useFormControlContext: () => FormControlContextValue | null;

package/dist/src/components/miscellaneous/StyledFormControl.d.ts

@@ -1,2 +1,22 @@
-import { FormControlProps } from '@mui/material';
-export declare const StyledFormControl: (props: FormControlProps) => JSX.Element;
+import { CSSProperties, ReactNode } from 'react';
+import { FieldSize } from '../inputs/field-styles';
+export interface FormControlProps {
+    children?: ReactNode;
+    error?: boolean;
+    disabled?: boolean;
+    required?: boolean;
+    size?: FieldSize;
+    fullWidth?: boolean;
+    /** Accepted for API parity; the design always renders outlined. */
+    variant?: string;
+    className?: string;
+    style?: CSSProperties;
+    sx?: unknown;
+    id?: string;
+}
+/**
+ * Form-field context provider + positioned container (replaces MUI `FormControl`). Tracks
+ * focus/filled state so `StyledInputLabel` can float and `StyledFormHelperText` can colour itself;
+ * `StyledSelect` reports its state into this context. Public props preserved (DEC-003). TASK-401.
+ */
+export declare const StyledFormControl: ({ children, error, disabled, required, size, fullWidth, className, style, sx, id, }: FormControlProps) => JSX.Element;

package/dist/src/components/miscellaneous/StyledFormControlLabel.d.ts

@@ -1,2 +1,21 @@
-import { FormControlLabelProps } from '@mui/material';
-export declare const StyledFormControlLabel: ({ sx, ...props }: FormControlLabelProps) => JSX.Element;
+import { ChangeEvent, ReactElement, ReactNode } from 'react';
+export type LabelPlacement = 'end' | 'start' | 'top' | 'bottom';
+export interface FormControlLabelProps {
+    /** The control element (a checkbox, radio, or switch). Receives `checked`/`onChange`/`disabled`/`name`/`value` unless already set. */
+    control: ReactElement;
+    label?: ReactNode;
+    checked?: boolean;
+    disabled?: boolean;
+    name?: string;
+    value?: unknown;
+    labelPlacement?: LabelPlacement;
+    className?: string;
+    sx?: unknown;
+    onChange?: (event: ChangeEvent<HTMLInputElement>, checked: boolean) => void;
+}
+/**
+ * Native replacement for MUI `FormControlLabel` — a `<label>` that pairs a form control with a
+ * text label and forwards `checked`/`onChange`/`disabled`/`name`/`value` into the control (MUI's
+ * clone behavior). Public props preserved (DEC-003). TASK-203.
+ */
+export declare const StyledFormControlLabel: ({ control, label, checked, disabled, name, value, labelPlacement, className, sx, onChange, }: FormControlLabelProps) => JSX.Element;

package/dist/src/components/miscellaneous/StyledFormGroup.d.ts

@@ -1,2 +1,11 @@
-import { FormGroupProps } from '@mui/material';
-export declare const StyledFormGroup: React.FC<FormGroupProps>;
+import { HTMLAttributes } from 'react';
+interface FormGroupProps extends HTMLAttributes<HTMLDivElement> {
+    row?: boolean;
+    sx?: unknown;
+    classes?: Record<string, string>;
+}
+/**
+ * MUI-free `FormGroup`: a flex container, column by default or `row`. TASK-101.
+ */
+export declare const StyledFormGroup: ({ row, className, sx, style, children, classes: _classes, ...rest }: FormGroupProps) => JSX.Element;
+export {};

package/dist/src/components/miscellaneous/StyledFormHelperText.d.ts

@@ -1,2 +1,12 @@
-import { FormHelperTextProps } from '@mui/material';
-export declare const StyledFormHelperText: (props: FormHelperTextProps) => JSX.Element;
+import { HTMLAttributes, ReactNode } from 'react';
+export interface FormHelperTextProps extends Omit<HTMLAttributes<HTMLParagraphElement>, 'children'> {
+    children?: ReactNode;
+    error?: boolean;
+    disabled?: boolean;
+}
+/**
+ * Helper/validation text under a field (replaces MUI `FormHelperText`). Inherits `error`/`disabled`
+ * from a surrounding `StyledFormControl` when present, else from props. Public props preserved
+ * (DEC-003). TASK-401.
+ */
+export declare const StyledFormHelperText: ({ children, error, disabled, className, ...rest }: FormHelperTextProps) => JSX.Element;

package/dist/src/components/miscellaneous/StyledInputLabel.d.ts

@@ -1,2 +1,20 @@
-import { InputLabelProps } from '@mui/material';
-export declare const StyledInputLabel: (props: InputLabelProps) => JSX.Element;
+import { ReactNode } from 'react';
+import { FieldSize } from '../inputs/field-styles';
+export interface InputLabelProps {
+    children?: ReactNode;
+    htmlFor?: string;
+    id?: string;
+    required?: boolean;
+    disabled?: boolean;
+    error?: boolean;
+    size?: FieldSize;
+    /** Force the shrunk (floated) state; otherwise derived from the surrounding FormControl. */
+    shrink?: boolean;
+    className?: string;
+}
+/**
+ * Floating field label (replaces MUI `InputLabel`). Reads focus/filled/error/size from the
+ * surrounding `StyledFormControl`; `shrink` lifts it onto the border. Public props preserved
+ * (DEC-003). TASK-401.
+ */
+export declare const StyledInputLabel: ({ children, htmlFor, id, required, disabled, error, size, shrink, className, }: InputLabelProps) => JSX.Element;

package/dist/src/components/mui-compat/Avatar.d.ts

@@ -0,0 +1,6 @@
+import { AvatarProps } from './types';
+/**
+ * MUI-free `Avatar`: 40×40 flex box showing an image (`src`) or fallback children/initials on a
+ * grey background. Reproduces MUI default metrics + `variant`. TASK-102.
+ */
+export declare const Avatar: ({ src, srcSet, alt, variant, sizes, className, sx, style, children, classes: _classes, component: _component, ...rest }: AvatarProps) => JSX.Element;

package/dist/src/components/mui-compat/ClickAwayListener.d.ts

@@ -0,0 +1,19 @@
+import { ReactElement } from 'react';
+type MouseEventName = 'onClick' | 'onMouseDown' | 'onMouseUp';
+type TouchEventName = 'onTouchStart' | 'onTouchEnd';
+export interface ClickAwayListenerProps {
+    children: ReactElement;
+    onClickAway: (event: MouseEvent | TouchEvent) => void;
+    mouseEvent?: MouseEventName | false;
+    touchEvent?: TouchEventName | false;
+    disableReactTree?: boolean;
+}
+/**
+ * MUI-free `ClickAwayListener`: fires `onClickAway` when a pointer event lands outside the single
+ * child element. Matches the MUI API subset this library uses (`onClickAway`, `mouseEvent`,
+ * `touchEvent`). The child must forward a ref to its root DOM node.
+ *
+ * @see asma-modules/_docs/frontend/plans/2026-07-10-19-12-plan-asma-ui-core-mui-removal.md — TASK-102
+ */
+export declare const ClickAwayListener: ({ children, onClickAway, mouseEvent, touchEvent, }: ClickAwayListenerProps) => ReactElement;
+export {};

package/dist/src/components/mui-compat/Container.d.ts

@@ -0,0 +1,6 @@
+import { ContainerProps } from './types';
+/**
+ * MUI-free `Container`: full-width, horizontally centred, with default 16px gutters and a
+ * breakpoint `maxWidth` (default `lg`). `fixed` is not reproduced (rare). TASK-102.
+ */
+export declare const Container: ({ maxWidth, disableGutters, className, sx, style, component, children, fixed: _fixed, ...rest }: ContainerProps) => JSX.Element;

package/dist/src/components/mui-compat/Fade.d.ts

@@ -0,0 +1,21 @@
+import { CSSProperties, ReactElement } from 'react';
+type Timeout = number | {
+    enter?: number;
+    exit?: number;
+};
+export interface FadeProps {
+    in?: boolean;
+    timeout?: Timeout;
+    appear?: boolean;
+    children: ReactElement;
+    onEnter?: () => void;
+    onExited?: () => void;
+    style?: CSSProperties;
+}
+/**
+ * Opacity transition (replaces MUI `Fade`). Clones its single child and runs a CSS keyframe on
+ * enter/exit, keeping the child mounted through the exit tween before calling `onExited` (so a
+ * parent `Popper` can unmount it). Public props preserved (DEC-003). TASK-403.
+ */
+export declare const Fade: ({ in: inProp, timeout, children, onExited, style, }: FadeProps) => JSX.Element | null;
+export {};

package/dist/src/components/mui-compat/FormLabel.d.ts

@@ -0,0 +1,6 @@
+import { FormLabelProps } from './types';
+/**
+ * MUI-free `FormLabel`: a `<label>` with MUI's default form-label typography/colour. Distinct from
+ * this library's `StyledFormLabel` (data-display); this is the raw MUI passthrough. TASK-102.
+ */
+export declare const FormLabel: ({ required, className, sx, style, children, classes: _classes, component: _component, error: _error, focused: _focused, filled: _filled, color: _color, ...rest }: FormLabelProps) => JSX.Element;

package/dist/src/components/mui-compat/Paper.d.ts

@@ -0,0 +1,6 @@
+import { PaperProps } from './types';
+/**
+ * MUI-free `Paper`: white surface with border-radius and an elevation shadow (default 1) or an
+ * outlined border (`variant="outlined"`). Reproduces the MUI default-theme shadow scale (TASK-102).
+ */
+export declare const Paper: ({ elevation, square, variant, className, sx, style, component, children, classes: _classes, ...rest }: PaperProps) => JSX.Element;

package/dist/src/components/mui-compat/Popper.d.ts

@@ -0,0 +1,29 @@
+import { CSSProperties, ReactNode } from 'react';
+import { Placement } from '@floating-ui/react';
+export interface PopperTransitionProps {
+    in: boolean;
+    onExited: () => void;
+}
+type PopperChildren = ReactNode | ((props: {
+    TransitionProps: PopperTransitionProps;
+    placement: Placement;
+}) => ReactNode);
+export interface PopperProps {
+    open?: boolean;
+    anchorEl?: Element | null;
+    id?: string;
+    placement?: Placement;
+    transition?: boolean;
+    disablePortal?: boolean;
+    className?: string;
+    style?: CSSProperties;
+    children?: PopperChildren;
+}
+/**
+ * Positioning primitive (replaces MUI `Popper`) built on `@floating-ui/react`. Positions its
+ * content against `anchorEl`; with `transition`, renders children as a function receiving
+ * `TransitionProps` (`in`/`onExited`) so a child `Fade` can animate and unmount. Public props
+ * preserved (DEC-003). TASK-403.
+ */
+export declare const Popper: ({ open, anchorEl, id, placement, transition, disablePortal, className, style, children, }: PopperProps) => JSX.Element | null;
+export {};

package/dist/src/components/mui-compat/Skeleton.d.ts

@@ -0,0 +1,7 @@
+import { SkeletonProps } from './types';
+/**
+ * MUI-free `Skeleton`: grey placeholder with the pulse animation (default). Reproduces MUI's
+ * variants (`text`/`circular`/`rectangular`/`rounded`), `width`/`height`, and background. `wave`
+ * animation degrades to `pulse` (Tailwind-first). TASK-102.
+ */
+export declare const Skeleton: ({ variant, width, height, animation, className, sx, style, children, classes: _classes, component: _component, ...rest }: SkeletonProps) => JSX.Element;

package/dist/src/components/mui-compat/Stack.d.ts

@@ -0,0 +1,7 @@
+import { StackProps } from './types';
+/**
+ * MUI-free `Stack`: a flex container with `direction` and `spacing` (× 8px gap) and optional
+ * `divider` between children. Scalar direction/spacing only — responsive breakpoint objects are not
+ * reproduced (rare on this library's usage). TASK-102.
+ */
+export declare const Stack: ({ direction, spacing, divider, className, sx, style, component, children, useFlexGap: _useFlexGap, ...rest }: StackProps) => JSX.Element;

package/dist/src/components/mui-compat/index.d.ts

@@ -0,0 +1,9 @@
+export { ClickAwayListener } from './ClickAwayListener';
+export { Paper } from './Paper';
+export { Stack } from './Stack';
+export { Container } from './Container';
+export { Avatar } from './Avatar';
+export { Skeleton } from './Skeleton';
+export { FormLabel } from './FormLabel';
+export { Fade } from './Fade';
+export { Popper } from './Popper';

package/dist/src/components/mui-compat/types.d.ts

@@ -0,0 +1,46 @@
+import { ElementType, HTMLAttributes, ReactNode } from 'react';
+interface BaseShimProps extends HTMLAttributes<HTMLElement> {
+    sx?: unknown;
+    component?: ElementType;
+    classes?: Record<string, string>;
+}
+export interface PaperProps extends BaseShimProps {
+    elevation?: number;
+    square?: boolean;
+    variant?: 'elevation' | 'outlined';
+}
+export interface StackProps extends BaseShimProps {
+    direction?: 'row' | 'row-reverse' | 'column' | 'column-reverse';
+    spacing?: number | string;
+    divider?: ReactNode;
+    useFlexGap?: boolean;
+}
+export interface AvatarProps extends BaseShimProps {
+    src?: string;
+    srcSet?: string;
+    alt?: string;
+    sizes?: string;
+    variant?: 'circular' | 'rounded' | 'square';
+}
+export interface SkeletonProps extends BaseShimProps {
+    variant?: 'text' | 'rectangular' | 'rounded' | 'circular';
+    width?: number | string;
+    height?: number | string;
+    animation?: 'pulse' | 'wave' | false;
+}
+export interface ContainerProps extends BaseShimProps {
+    maxWidth?: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | false;
+    disableGutters?: boolean;
+    fixed?: boolean;
+}
+export interface FormLabelProps extends HTMLAttributes<HTMLLabelElement> {
+    sx?: unknown;
+    component?: ElementType;
+    classes?: Record<string, string>;
+    required?: boolean;
+    error?: boolean;
+    focused?: boolean;
+    filled?: boolean;
+    color?: string;
+}
+export {};

package/dist/src/components/navigation/drawer/StyledDrawer.d.ts

@@ -1,3 +1,22 @@
-import { DrawerProps } from '@mui/material';
-import { FC } from 'react';
+import { FC, ReactNode } from 'react';
+export type DrawerAnchor = 'left' | 'right' | 'top' | 'bottom';
+export type DrawerCloseReason = 'backdropClick' | 'escapeKeyDown';
+export interface DrawerProps {
+    open?: boolean;
+    onClose?: (event: Event | React.SyntheticEvent, reason: DrawerCloseReason) => void;
+    anchor?: DrawerAnchor;
+    variant?: 'temporary' | 'persistent' | 'permanent';
+    hideBackdrop?: boolean;
+    className?: string;
+    sx?: unknown;
+    PaperProps?: {
+        className?: string;
+        sx?: unknown;
+    };
+    children?: ReactNode;
+}
+/**
+ * Sliding edge panel (replaces MUI `Drawer`). Portalled, slides from `anchor`, temporary variant
+ * shows a backdrop and closes on backdrop-click / Escape. Public props preserved (DEC-003). TASK-304.
+ */
 export declare const StyledDrawer: FC<DrawerProps>;