@mt-gloss/ui 0.0.9 → 0.0.10

package/lib/presets/PresetFileUpload/PresetFileUpload.d.ts

@@ -0,0 +1,35 @@
+import { default as React } from 'react';
+import { SharedSize } from '../types';
+export interface FileUploadFile {
+    file: File;
+    id: string;
+    progress?: number;
+    error?: string;
+    preview?: string;
+}
+export declare const FILEUPLOAD_VARIANTS: readonly ["default", "error"];
+export type PresetFileUploadVariant = (typeof FILEUPLOAD_VARIANTS)[number];
+export interface PresetFileUploadProps {
+    variant?: PresetFileUploadVariant;
+    size?: SharedSize;
+    value?: FileUploadFile[];
+    onChange?: (files: FileUploadFile[]) => void;
+    accept?: string;
+    maxFiles?: number;
+    maxSize?: number;
+    multiple?: boolean;
+    disabled?: boolean;
+    showPreview?: boolean;
+    onRemove?: (fileId: string) => void;
+    dropzoneText?: string;
+    label?: string;
+    helperText?: string;
+    onError?: (error: string) => void;
+    id?: string;
+    name?: string;
+}
+/**
+ * FileUpload with drag-and-drop, file list, variant styling, size scale.
+ * Re-exports FileUploadFile type.
+ */
+export declare const PresetFileUpload: React.ForwardRefExoticComponent<PresetFileUploadProps & React.RefAttributes<HTMLInputElement>>;

package/lib/presets/PresetForm/PresetForm.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @deprecated Moved to containers/ tier (Phase 25.1).
+ * Use `import * as UI from '@mt-gloss/ui/catalog'` -> `<UI.Form>` instead.
+ */
+export { ContainerForm as PresetForm, useFormContext } from '../../containers/ContainerForm/ContainerForm';
+export type { ContainerFormProps as PresetFormProps, FormContextValue, FormErrors, FormTouched } from '../../containers/ContainerForm/ContainerForm';

package/lib/presets/PresetFormField/PresetFormField.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @deprecated Moved to containers/ tier (Phase 25.1).
+ * Use `import * as UI from '@mt-gloss/ui/catalog'` -> `<UI.FormField>` instead.
+ */
+export { ContainerFormField as PresetFormField } from '../../containers/ContainerFormField/ContainerFormField';
+export type { ContainerFormFieldProps as PresetFormFieldProps } from '../../containers/ContainerFormField/ContainerFormField';

package/lib/presets/PresetInput/PresetInput.d.ts

@@ -0,0 +1,24 @@
+import { default as React } from 'react';
+import { SharedSize } from '../types';
+export type PresetInputVariant = 'default' | 'error' | 'success';
+export interface PresetInputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'className' | 'style' | 'size' | 'onCopy'> {
+    variant?: PresetInputVariant;
+    size?: SharedSize;
+    label?: string;
+    helperText?: string;
+    status?: 'default' | 'error' | 'success';
+    clearable?: boolean;
+    /** Callback when the clear button is clicked */
+    onClear?: () => void;
+    copyable?: boolean;
+    /** Callback after copying the input value */
+    onCopy?: (value: string) => void;
+    /** Show character counter (requires maxLength) */
+    showCounter?: boolean;
+    leftIcon?: React.ReactNode;
+    rightIcon?: React.ReactNode;
+}
+/**
+ * Input with semantic variant/size API. Wraps BaseInput.
+ */
+export declare const PresetInput: React.ForwardRefExoticComponent<PresetInputProps & React.RefAttributes<HTMLInputElement>>;

package/lib/presets/PresetInputGroup/PresetInputGroup.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @deprecated Moved to wrappers/ tier (Phase 25.1).
+ * Use `import * as UI from '@mt-gloss/ui/catalog'` -> `<UI.InputGroup>` instead.
+ */
+export { InputGroup as PresetInputGroup, InputAddon as PresetInputAddon } from '../../wrappers/InputGroup/InputGroup';
+export type { InputGroupProps as PresetInputGroupProps, InputAddonProps as PresetInputAddonProps } from '../../wrappers/InputGroup/InputGroup';

package/lib/presets/PresetLabel/PresetLabel.d.ts

@@ -0,0 +1,18 @@
+import { default as React } from 'react';
+import { PolymorphicProps } from '../../base/types';
+export declare const LABEL_VARIANTS: readonly ["default", "required", "optional"];
+export type PresetLabelVariant = (typeof LABEL_VARIANTS)[number];
+export interface PresetLabelProps {
+    variant?: PresetLabelVariant;
+    htmlFor?: string;
+    children?: React.ReactNode;
+}
+/**
+ * Label with semantic variant API. Wraps BaseLabel.
+ * Required variant adds asterisk via CSS pseudo-element.
+ * Optional variant adds "(optional)" text via CSS pseudo-element.
+ */
+export declare const PresetLabel: {
+    <C extends React.ElementType = "label">(props: PolymorphicProps<C, PresetLabelProps>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/lib/presets/PresetLink/PresetLink.d.ts

@@ -0,0 +1,21 @@
+import { default as React } from 'react';
+import { SharedSize } from '../types';
+export type PresetLinkVariant = 'default' | 'muted' | 'destructive';
+export interface PresetLinkProps {
+    variant?: PresetLinkVariant;
+    size?: SharedSize;
+    external?: boolean;
+    leftIcon?: React.ReactNode;
+    rightIcon?: React.ReactNode;
+    underline?: 'always' | 'hover' | 'none';
+    disabled?: boolean;
+    href?: string;
+    as?: React.ElementType;
+    children?: React.ReactNode;
+    onClick?: React.MouseEventHandler;
+}
+/**
+ * Link with semantic variant/size API. Wraps BaseLink.
+ * Navigation element with consistent styling and icon support.
+ */
+export declare const PresetLink: React.ForwardRefExoticComponent<PresetLinkProps & React.RefAttributes<HTMLAnchorElement>>;

package/lib/presets/PresetMaskedInput/PresetMaskedInput.d.ts

@@ -0,0 +1,41 @@
+import { default as React } from 'react';
+import { SharedSize } from '../types';
+export interface MaskConfig {
+    mask: string | RegExp | NumberConstructor | Array<string | RegExp | {
+        mask: string;
+        [key: string]: unknown;
+    }>;
+    placeholderChar?: string;
+    lazy?: boolean;
+    definitions?: Record<string, RegExp>;
+    unmask?: boolean | 'typed';
+    [key: string]: unknown;
+}
+export declare const MaskPresets: Record<string, MaskConfig>;
+export type MaskPresetName = keyof typeof MaskPresets;
+export declare const MASKEDINPUT_VARIANTS: readonly ["default", "error", "success"];
+export type PresetMaskedInputVariant = (typeof MASKEDINPUT_VARIANTS)[number];
+export interface PresetMaskedInputProps {
+    variant?: PresetMaskedInputVariant;
+    size?: SharedSize;
+    mask: MaskConfig | MaskPresetName;
+    value?: string;
+    onAccept?: (value: string) => void;
+    onComplete?: (value: string) => void;
+    onChange?: (event: React.ChangeEvent<HTMLInputElement>) => void;
+    onBlur?: (event: React.FocusEvent<HTMLInputElement>) => void;
+    label?: string;
+    helperText?: string;
+    status?: 'default' | 'error' | 'success';
+    disabled?: boolean;
+    guide?: boolean;
+    placeholder?: string;
+    required?: boolean;
+    id?: string;
+    name?: string;
+}
+/**
+ * MaskedInput with imask integration, variant styling, size scale.
+ * Re-exports MaskConfig, MaskPresetName, and MaskPresets.
+ */
+export declare const PresetMaskedInput: React.ForwardRefExoticComponent<PresetMaskedInputProps & React.RefAttributes<HTMLInputElement>>;

package/lib/presets/PresetMenu/PresetMenu.d.ts

@@ -0,0 +1,33 @@
+import { default as React } from 'react';
+export type PresetMenuSize = 'sm' | 'md';
+export interface PresetMenuProps {
+    size?: PresetMenuSize;
+    children: React.ReactNode;
+}
+/**
+ * Menu container with semantic size API. Wraps BaseMenu.
+ */
+export declare const PresetMenu: React.ForwardRefExoticComponent<PresetMenuProps & Omit<React.HTMLAttributes<HTMLDivElement>, "style" | "className"> & React.RefAttributes<HTMLDivElement>>;
+export interface PresetMenuGroupProps {
+    label?: string;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    showCount?: 'always' | 'collapsed-only' | 'never';
+    children: React.ReactNode;
+}
+export declare function PresetMenuGroup({ label, open, onOpenChange, showCount, children, ...rest }: PresetMenuGroupProps & Omit<React.HTMLAttributes<HTMLDivElement>, 'className' | 'style'>): import("react/jsx-runtime").JSX.Element;
+export declare namespace PresetMenuGroup {
+    var displayName: string;
+}
+export interface PresetMenuItemProps {
+    disabled?: boolean;
+    active?: boolean;
+    as?: React.ElementType;
+    icon?: React.ReactNode;
+    children: React.ReactNode;
+}
+export declare const PresetMenuItem: React.ForwardRefExoticComponent<PresetMenuItemProps & Omit<React.HTMLAttributes<HTMLElement>, "style" | "className"> & React.RefAttributes<HTMLElement>>;
+export declare function PresetMenuDivider(): import("react/jsx-runtime").JSX.Element;
+export declare namespace PresetMenuDivider {
+    var displayName: string;
+}

package/lib/presets/PresetNumberInput/PresetNumberInput.d.ts

@@ -0,0 +1,26 @@
+import { default as React } from 'react';
+import { SharedSize } from '../types';
+export declare const NUMBERINPUT_VARIANTS: readonly ["default", "error", "success"];
+export type PresetNumberInputVariant = (typeof NUMBERINPUT_VARIANTS)[number];
+export interface PresetNumberInputProps {
+    variant?: PresetNumberInputVariant;
+    size?: SharedSize;
+    value?: number;
+    defaultValue?: number;
+    onChange?: (value: number) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    precision?: number;
+    label?: string;
+    helperText?: string;
+    disabled?: boolean;
+    allowNegative?: boolean;
+    placeholder?: string;
+    showStepper?: boolean;
+    formatValue?: (value: number) => string;
+}
+/**
+ * NumberInput with increment/decrement buttons, variant styling, size scale.
+ */
+export declare const PresetNumberInput: React.ForwardRefExoticComponent<PresetNumberInputProps & React.RefAttributes<HTMLInputElement>>;

package/lib/presets/PresetPopover/PresetPopover.d.ts

@@ -0,0 +1,17 @@
+import { default as React } from 'react';
+export type PresetPopoverPlacement = 'top' | 'bottom' | 'left' | 'right' | 'top-start' | 'top-end' | 'bottom-start' | 'bottom-end';
+export interface PresetPopoverProps {
+    open: boolean;
+    onDismiss?: () => void;
+    anchorRef: React.RefObject<HTMLElement | null>;
+    placement?: PresetPopoverPlacement;
+    showArrow?: boolean;
+    children?: React.ReactNode;
+}
+/**
+ * Anchored floating content panel with preset styling. Wraps BasePopover.
+ */
+export declare function PresetPopover({ open, onDismiss, anchorRef, placement, showArrow, children, }: PresetPopoverProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace PresetPopover {
+    var displayName: string;
+}

package/lib/presets/PresetProgressBar/PresetProgressBar.d.ts

@@ -0,0 +1,19 @@
+import { default as React } from 'react';
+export declare const PROGRESS_BAR_VARIANTS: readonly ["default", "success", "warning", "error"];
+export type PresetProgressBarVariant = (typeof PROGRESS_BAR_VARIANTS)[number];
+export interface PresetProgressBarProps {
+    variant?: PresetProgressBarVariant;
+    value?: number;
+    max?: number;
+    indeterminate?: boolean;
+    label?: string;
+    labelPosition?: 'none' | 'right' | 'top';
+}
+/**
+ * Progress bar with semantic variant API. Wraps BaseProgressBar.
+ * Supports determinate/indeterminate modes and optional label.
+ */
+export declare function PresetProgressBar(props: PresetProgressBarProps & Omit<React.HTMLAttributes<HTMLDivElement>, keyof PresetProgressBarProps | 'className' | 'style' | 'role'>): import("react/jsx-runtime").JSX.Element;
+export declare namespace PresetProgressBar {
+    var displayName: string;
+}

package/lib/presets/PresetRadio/PresetRadio.d.ts

@@ -0,0 +1,21 @@
+import { default as React } from 'react';
+import { SharedSize } from '../types';
+export type PresetRadioVariant = 'default' | 'error';
+export interface PresetRadioProps {
+    variant?: PresetRadioVariant;
+    size?: SharedSize;
+    label?: React.ReactNode;
+    description?: React.ReactNode;
+    helperText?: string;
+    checked?: boolean;
+    onChange?: (event: React.ChangeEvent<HTMLInputElement>) => void;
+    disabled?: boolean;
+    required?: boolean;
+    name?: string;
+    value?: string;
+    id?: string;
+}
+/**
+ * Radio with semantic variant/size API. Wraps BaseRadio.
+ */
+export declare const PresetRadio: React.ForwardRefExoticComponent<PresetRadioProps & React.RefAttributes<HTMLInputElement>>;

package/lib/presets/PresetRadioGroup/PresetRadioGroup.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @deprecated Moved to wrappers/ tier (Phase 25.1).
+ * Use `import * as UI from '@mt-gloss/ui/catalog'` -> `<UI.RadioGroup>` instead.
+ */
+export { RadioGroup as PresetRadioGroup, useRadioGroupContext, GroupRadio } from '../../wrappers/RadioGroup/RadioGroup';
+export type { RadioGroupProps as PresetRadioGroupProps, RadioGroupOption, RadioGroupContextValue, GroupRadioProps } from '../../wrappers/RadioGroup/RadioGroup';

package/lib/presets/PresetRangeSlider/PresetRangeSlider.d.ts

@@ -0,0 +1,30 @@
+import { default as React } from 'react';
+import { SharedSize } from '../types';
+export interface SliderMark {
+    value: number;
+    label?: React.ReactNode;
+}
+export interface PresetRangeSliderProps {
+    size?: SharedSize;
+    value?: [number, number];
+    defaultValue?: [number, number];
+    onChange?: (value: [number, number]) => void;
+    onChangeEnd?: (value: [number, number]) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    minDistance?: number;
+    marks?: boolean | SliderMark[];
+    showValue?: boolean;
+    formatValue?: (value: number) => string;
+    orientation?: 'horizontal' | 'vertical';
+    disabled?: boolean;
+    label?: string;
+    helperText?: string;
+    id?: string;
+    name?: string;
+}
+/**
+ * RangeSlider with dual thumbs, semantic size API. Wraps BaseRangeSlider.
+ */
+export declare const PresetRangeSlider: React.ForwardRefExoticComponent<PresetRangeSliderProps & React.RefAttributes<HTMLInputElement>>;

package/lib/presets/PresetRating/PresetRating.d.ts

@@ -0,0 +1,19 @@
+import { default as React } from 'react';
+import { SharedSize } from '../types';
+export interface PresetRatingProps {
+    size?: SharedSize;
+    value?: number;
+    defaultValue?: number;
+    onChange?: (value: number) => void;
+    max?: number;
+    allowHalf?: boolean;
+    readOnly?: boolean;
+    disabled?: boolean;
+    icon?: string;
+    emptyIcon?: string;
+    children?: React.ReactNode;
+}
+/**
+ * Rating with semantic size API. Wraps BaseRating.
+ */
+export declare const PresetRating: React.ForwardRefExoticComponent<PresetRatingProps & Omit<React.HTMLAttributes<HTMLDivElement>, "style" | "className"> & React.RefAttributes<HTMLDivElement>>;

package/lib/presets/PresetSegmentedControl/PresetSegmentedControl.d.ts

@@ -0,0 +1,28 @@
+import { default as React } from 'react';
+import { SharedSize } from '../types';
+import { IconValue } from '../../types/icon';
+export type PresetSegmentedControlVariant = 'default' | 'filled';
+export interface SegmentedControlOption {
+    value: string;
+    label: React.ReactNode;
+    icon?: IconValue;
+    disabled?: boolean;
+}
+export interface PresetSegmentedControlProps {
+    variant?: PresetSegmentedControlVariant;
+    size?: SharedSize;
+    options?: SegmentedControlOption[];
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    disabled?: boolean;
+    fullWidth?: boolean;
+    children?: React.ReactNode;
+}
+/**
+ * SegmentedControl with semantic variant/size API. Wraps BaseSegmentedControl.
+ */
+export declare function PresetSegmentedControl(props: PresetSegmentedControlProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace PresetSegmentedControl {
+    var displayName: string;
+}

package/lib/presets/PresetSelect/PresetSelect.d.ts

@@ -0,0 +1,63 @@
+import { default as React } from 'react';
+import { SharedSize } from '../types';
+import { IconValue } from '../../types/icon';
+export interface SelectOption<T = string> {
+    value: T;
+    label: React.ReactNode;
+    triggerLabel?: React.ReactNode;
+    icon?: IconValue;
+    description?: React.ReactNode;
+    disabled?: boolean;
+}
+export interface SelectTriggerRenderProps<T = string> {
+    selectedOption: SelectOption<T> | undefined;
+    isOpen: boolean;
+    placeholder: React.ReactNode;
+}
+export interface SelectOptionRenderProps<T = string> {
+    option: SelectOption<T>;
+    isSelected: boolean;
+    isDisabled: boolean;
+}
+export interface SelectOptionGroup<T = string> {
+    label: string;
+    options: SelectOption<T>[];
+}
+export declare const SELECT_VARIANTS: readonly ["default", "error", "success"];
+export type PresetSelectVariant = (typeof SELECT_VARIANTS)[number];
+export interface PresetSelectProps<T = string> {
+    variant?: PresetSelectVariant;
+    size?: SharedSize;
+    options: SelectOption<T>[] | SelectOptionGroup<T>[];
+    value?: T | T[];
+    onChange?: (value: T | T[], option: SelectOption<T> | SelectOption<T>[]) => void;
+    placeholder?: React.ReactNode;
+    renderTrigger?: (props: SelectTriggerRenderProps<T>) => React.ReactNode;
+    renderOption?: (props: SelectOptionRenderProps<T>) => React.ReactNode;
+    searchable?: boolean;
+    searchPlaceholder?: string;
+    clearable?: boolean;
+    onClear?: () => void;
+    multiple?: boolean;
+    multiDisplayMode?: 'chips' | 'count' | 'text';
+    maxChips?: number;
+    creatable?: boolean;
+    onCreate?: (value: string) => void;
+    disabled?: boolean;
+    maxSelections?: number;
+    onSearch?: (query: string) => void;
+    showSelectionIndicator?: boolean;
+    children?: React.ReactNode;
+}
+/**
+ * Select with semantic variant/size API. Wraps BaseSelect structural container.
+ * The full search/multi/keyboard state machine is preserved from the original Select.
+ */
+export declare function PresetSelect<T = string>(props: PresetSelectProps<T>): import("react/jsx-runtime").JSX.Element;
+export declare namespace PresetSelect {
+    var displayName: string;
+}
+export { BaseSelectTrigger as SelectTrigger } from '../../base/BaseSelect/BaseSelect';
+export { BaseSelectDropdown as SelectDropdown } from '../../base/BaseSelect/BaseSelect';
+export { BaseSelectOption as SelectOption_ } from '../../base/BaseSelect/BaseSelect';
+export { BaseSelectGroup as SelectGroup } from '../../base/BaseSelect/BaseSelect';

package/lib/presets/PresetSlider/PresetSlider.d.ts

@@ -0,0 +1,29 @@
+import { default as React } from 'react';
+import { SharedSize } from '../types';
+export interface SliderMark {
+    value: number;
+    label?: React.ReactNode;
+}
+export interface PresetSliderProps {
+    size?: SharedSize;
+    min?: number;
+    max?: number;
+    step?: number;
+    value?: number;
+    defaultValue?: number;
+    onChange?: (value: number) => void;
+    onChangeEnd?: (value: number) => void;
+    marks?: boolean | SliderMark[];
+    showValue?: boolean;
+    formatValue?: (value: number) => string;
+    orientation?: 'horizontal' | 'vertical';
+    disabled?: boolean;
+    children?: React.ReactNode;
+}
+/**
+ * Slider with semantic size API. Wraps BaseSlider.
+ */
+export declare function PresetSlider(props: PresetSliderProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace PresetSlider {
+    var displayName: string;
+}

package/lib/presets/PresetSplitButton/PresetSplitButton.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @deprecated Moved to composites/overlay/ tier (Phase 25.1).
+ * Use `import * as UI from '@mt-gloss/ui/catalog'` -> `<UI.SplitButton>` instead.
+ */
+export { SplitButton as PresetSplitButton } from '../../composites/overlay/SplitButton/SplitButton';
+export type { SplitButtonProps as PresetSplitButtonProps, SplitButtonMenuItem } from '../../composites/overlay/SplitButton/SplitButton';

package/lib/presets/PresetSwatchRow/PresetSwatchRow.d.ts

@@ -0,0 +1,28 @@
+export interface SwatchOption {
+    value: string;
+    colorToken?: string;
+    color?: string;
+    label?: string;
+    disabled?: boolean;
+}
+export interface PresetSwatchRowProps {
+    swatches: SwatchOption[];
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    disabled?: boolean;
+    name: string;
+}
+/**
+ * PresetSwatchRow — Preset-tier wrapper around RadioGroup.
+ * Conceptually equivalent to createPreset(RadioGroup, swatchVariants) — hand-written
+ * because RadioGroup is Wrapper-tier. Per D-02.
+ *
+ * Renders a horizontal row of circular color swatches with radio-group semantics.
+ * All colors derive from design tokens — no hardcoded palette values.
+ * Generic: no reptime domain strings in props. D-10, D-11 compliant.
+ */
+export declare function PresetSwatchRow({ swatches, value, defaultValue, onChange, disabled, name, }: PresetSwatchRowProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace PresetSwatchRow {
+    var displayName: string;
+}

package/lib/presets/PresetSwatchRow/index.d.ts

@@ -0,0 +1,2 @@
+export { PresetSwatchRow } from './PresetSwatchRow';
+export type { PresetSwatchRowProps, SwatchOption } from './PresetSwatchRow';

package/lib/presets/PresetText/PresetText.d.ts

@@ -0,0 +1,17 @@
+import { default as React } from 'react';
+import { PolymorphicProps } from '../../base/types';
+import { SharedSize } from '../types';
+export declare const TEXT_VARIANTS: readonly ["body", "caption", "overline"];
+export type PresetTextVariant = (typeof TEXT_VARIANTS)[number];
+export interface PresetTextProps {
+    variant?: PresetTextVariant;
+    size?: SharedSize;
+    children?: React.ReactNode;
+}
+/**
+ * Text with semantic variant/size API. Wraps BaseText.
+ */
+export declare const PresetText: {
+    <C extends React.ElementType = "span">(props: PolymorphicProps<C, PresetTextProps>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/lib/presets/PresetTextarea/PresetTextarea.d.ts

@@ -0,0 +1,25 @@
+import { default as React } from 'react';
+import { SharedSize } from '../types';
+export type PresetTextareaVariant = 'default' | 'error' | 'success';
+export interface PresetTextareaProps extends Omit<React.TextareaHTMLAttributes<HTMLTextAreaElement>, 'className' | 'style'> {
+    variant?: PresetTextareaVariant;
+    size?: SharedSize;
+    label?: string;
+    helperText?: string;
+    status?: 'default' | 'error' | 'success';
+    /** Show character counter (requires maxLength) */
+    showCounter?: boolean;
+    /** Custom counter renderer */
+    renderCounter?: (current: number, max: number) => React.ReactNode;
+    /** @deprecated Use showCounter instead */
+    showCount?: boolean;
+    /** Auto-grow/shrink the textarea based on content */
+    autoResize?: boolean;
+    minRows?: number;
+    maxRows?: number;
+    resize?: 'none' | 'vertical' | 'both';
+}
+/**
+ * Textarea with semantic variant/size API. Wraps BaseTextarea.
+ */
+export declare const PresetTextarea: React.ForwardRefExoticComponent<PresetTextareaProps & React.RefAttributes<HTMLTextAreaElement>>;

package/lib/presets/PresetTimePicker/PresetTimePicker.d.ts

@@ -0,0 +1,27 @@
+import { default as React } from 'react';
+import { SharedSize } from '../types';
+export declare const TIMEPICKER_VARIANTS: readonly ["default", "error", "success"];
+export type PresetTimePickerVariant = (typeof TIMEPICKER_VARIANTS)[number];
+export interface PresetTimePickerProps {
+    variant?: PresetTimePickerVariant;
+    size?: SharedSize;
+    value?: string;
+    defaultValue?: string;
+    onChange?: (time: string) => void;
+    format?: '12h' | '24h';
+    showSeconds?: boolean;
+    step?: number;
+    minTime?: string;
+    maxTime?: string;
+    placeholder?: string;
+    label?: string;
+    helperText?: string;
+    disabled?: boolean;
+    clearable?: boolean;
+    id?: string;
+    name?: string;
+}
+/**
+ * TimePicker with scrollable time options, variant styling, and size scale.
+ */
+export declare const PresetTimePicker: React.ForwardRefExoticComponent<PresetTimePickerProps & React.RefAttributes<HTMLInputElement>>;

package/lib/presets/PresetTitle/PresetTitle.d.ts

@@ -0,0 +1,19 @@
+import { default as React } from 'react';
+import { PolymorphicProps } from '../../base/types';
+export declare const TITLE_VARIANTS: readonly ["page", "section", "subsection", "card"];
+export type PresetTitleVariant = (typeof TITLE_VARIANTS)[number];
+type HeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
+export interface PresetTitleProps {
+    variant?: PresetTitleVariant;
+    level?: HeadingLevel;
+    children?: React.ReactNode;
+}
+/**
+ * Title with semantic variant/level API. Wraps BaseTitle.
+ * `level` controls the HTML element (h1-h6), `variant` controls visual styling.
+ */
+export declare const PresetTitle: {
+    <C extends React.ElementType = "h2">(props: PolymorphicProps<C, PresetTitleProps>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export {};

package/lib/presets/PresetToast/PresetToast.d.ts

@@ -0,0 +1,19 @@
+import { default as React } from 'react';
+export type PresetToastVariant = 'info' | 'success' | 'warning' | 'error';
+export type PresetToastPosition = 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left' | 'top-center' | 'bottom-center';
+export interface PresetToastProps {
+    open: boolean;
+    onDismiss?: () => void;
+    variant?: PresetToastVariant;
+    position?: PresetToastPosition;
+    /** Auto-dismiss duration in ms. Default 5000. Set 0 to disable. */
+    duration?: number;
+    children?: React.ReactNode;
+}
+/**
+ * Notification toast with semantic variant and auto-dismiss. Wraps BaseToast.
+ */
+export declare function PresetToast({ open, onDismiss, variant, position, duration, children, }: PresetToastProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace PresetToast {
+    var displayName: string;
+}

package/lib/presets/PresetToggle/PresetToggle.d.ts

@@ -0,0 +1,21 @@
+import { default as React } from 'react';
+import { SharedSize } from '../types';
+export type PresetToggleVariant = 'default' | 'success' | 'error';
+export interface PresetToggleProps {
+    variant?: PresetToggleVariant;
+    size?: SharedSize;
+    label?: React.ReactNode;
+    onLabel?: React.ReactNode;
+    offLabel?: React.ReactNode;
+    helperText?: string;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onChange?: (event: React.ChangeEvent<HTMLInputElement>) => void;
+    onCheckedChange?: (checked: boolean) => void;
+    disabled?: boolean;
+    id?: string;
+}
+/**
+ * Toggle/Switch with semantic variant/size API. Wraps BaseToggle.
+ */
+export declare const PresetToggle: React.ForwardRefExoticComponent<PresetToggleProps & React.RefAttributes<HTMLInputElement>>;