reactigoded 1.0.0-beta.26

package/dist/components/Card/CardBody.d.ts

@@ -0,0 +1,8 @@
+import { HTMLAttributes, Ref } from 'react';
+export interface CardBodyProps extends HTMLAttributes<HTMLDivElement> {
+    ref?: Ref<HTMLDivElement> | undefined;
+}
+/** CardBody — cuerpo principal de una `Card`.  *
+ * @server-safe
+ */
+export declare function CardBody({ className, children, ref, ...rest }: CardBodyProps): import("react").JSX.Element;

package/dist/components/Card/CardDivider.d.ts

@@ -0,0 +1,8 @@
+import { HTMLAttributes, Ref } from 'react';
+export interface CardDividerProps extends HTMLAttributes<HTMLHRElement> {
+    ref?: Ref<HTMLHRElement> | undefined;
+}
+/** CardDivider — separador horizontal entre secciones de una `Card`.  *
+ * @server-safe
+ */
+export declare function CardDivider({ className, ref, ...rest }: CardDividerProps): import("react").JSX.Element;

package/dist/components/Card/CardFooter.d.ts

@@ -0,0 +1,8 @@
+import { HTMLAttributes, Ref } from 'react';
+export interface CardFooterProps extends HTMLAttributes<HTMLDivElement> {
+    ref?: Ref<HTMLDivElement> | undefined;
+}
+/** CardFooter — pie de una `Card`. Típicamente acciones o metadata.  *
+ * @server-safe
+ */
+export declare function CardFooter({ className, children, ref, ...rest }: CardFooterProps): import("react").JSX.Element;

package/dist/components/Card/CardHeader.d.ts

@@ -0,0 +1,8 @@
+import { HTMLAttributes, Ref } from 'react';
+export interface CardHeaderProps extends HTMLAttributes<HTMLDivElement> {
+    ref?: Ref<HTMLDivElement> | undefined;
+}
+/** CardHeader — cabecera de una `Card`. Suele contener título + acciones.  *
+ * @server-safe
+ */
+export declare function CardHeader({ className, children, ref, ...rest }: CardHeaderProps): import("react").JSX.Element;

package/dist/components/Card/CardImage.d.ts

@@ -0,0 +1,15 @@
+import { ImgHTMLAttributes, Ref } from 'react';
+export interface CardImageProps extends ImgHTMLAttributes<HTMLImageElement> {
+    /** Si la imagen va en la parte superior de la card (esquinas top redondeadas). */
+    top?: boolean | undefined;
+    /** Texto alternativo obligatorio para a11y. */
+    alt: string;
+    ref?: Ref<HTMLImageElement> | undefined;
+}
+/**
+ * CardImage — imagen integrada en una `Card`. Con `top=true` se renderiza
+ * pegada al borde superior con esquinas redondeadas a juego.
+  *
+ * @server-safe
+ */
+export declare function CardImage({ top, alt, className, ref, ...rest }: CardImageProps): import("react").JSX.Element;

package/dist/components/Card/index.d.ts

@@ -0,0 +1,12 @@
+export { Card } from './Card.js';
+export type { CardProps, CardVariant } from './Card.js';
+export { CardHeader } from './CardHeader.js';
+export type { CardHeaderProps } from './CardHeader.js';
+export { CardBody } from './CardBody.js';
+export type { CardBodyProps } from './CardBody.js';
+export { CardFooter } from './CardFooter.js';
+export type { CardFooterProps } from './CardFooter.js';
+export { CardImage } from './CardImage.js';
+export type { CardImageProps } from './CardImage.js';
+export { CardDivider } from './CardDivider.js';
+export type { CardDividerProps } from './CardDivider.js';

package/dist/components/Checkbox/Checkbox.d.ts

@@ -0,0 +1,47 @@
+import { InputHTMLAttributes, Ref } from 'react';
+export type CheckboxVariant = "brand" | "secondary" | "success" | "warning" | "danger" | "info";
+export interface CheckboxProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "size"> {
+    /** Color del check cuando está activo. */
+    variant?: CheckboxVariant | undefined;
+    /** Etiqueta visible junto al checkbox. */
+    children?: React.ReactNode | undefined;
+    /**
+     * Activa el tercer estado visual del checkbox (línea horizontal en
+     * lugar del tick). Se aplica vía `el.indeterminate = true` en el
+     * `<input>` nativo (la única forma soportada por la plataforma) y
+     * añade `aria-checked="mixed"` para lectores de pantalla.
+     *
+     * Nota: `indeterminate` es estado del DOM, no del modelo de datos.
+     * El `value` del checkbox sigue siendo `checked`/`unchecked`. Mantén
+     * tú la sincronización con los hijos cuyo estado lo justifique.
+     */
+    indeterminate?: boolean | undefined;
+    /**
+     * Ids extra para `aria-describedby`. Pasar string para un único id o
+     * array para varios. Se concatenan con cualquier `aria-describedby`
+     * que el consumer pase por rest. Patrón canónico del DS para enlazar
+     * `Helper` / `ErrorText` / live-regions con tecnologías asistivas.
+     *
+     * @example
+     * const helperId = useId();
+     * <Checkbox describedBy={helperId}>Acepto</Checkbox>
+     * <Helper id={helperId}>Solo email; no spam.</Helper>
+     */
+    describedBy?: string | string[] | undefined;
+    ref?: Ref<HTMLInputElement> | undefined;
+}
+/**
+ * Checkbox — `<input type="checkbox">` con marca visual personalizada.
+ * Wrappeado en `<label>` para que click en el texto active el input.
+ *
+ * Soporta tri-state vía `indeterminate` prop (desde 1.0.0-beta.8) o via
+ * `ref` manual (`ref.current.indeterminate = true`).
+ *
+ * @example
+ * <Checkbox defaultChecked>Acepto los términos</Checkbox>
+ * <Checkbox indeterminate>Selección parcial</Checkbox>
+ * <Checkbox checked={on} onChange={(e) => setOn(e.target.checked)}>
+ *   Recibir newsletter
+ * </Checkbox>
+ */
+export declare function Checkbox({ variant, className, children, ref, disabled, indeterminate, describedBy, onChange, ...rest }: CheckboxProps): import("react").JSX.Element;

package/dist/components/Checkbox/index.d.ts

@@ -0,0 +1,2 @@
+export { Checkbox } from './Checkbox.js';
+export type { CheckboxProps, CheckboxVariant } from './Checkbox.js';

package/dist/components/Chip/Chip.d.ts

@@ -0,0 +1,38 @@
+import { ButtonHTMLAttributes, HTMLAttributes, Ref } from 'react';
+export type ChipVariant = "brand" | "secondary" | "success" | "warning" | "danger" | "info";
+export type ChipSize = "sm" | "md" | "lg";
+interface ChipBase {
+    variant?: ChipVariant | undefined;
+    size?: ChipSize | undefined;
+    /** Si está marcado como seleccionable + seleccionado, aplica el estado activo. */
+    selected?: boolean | undefined;
+    /** Callback opcional para mostrar la X de eliminación. */
+    onRemove?: (() => void) | undefined;
+    /** Texto a11y para el botón de eliminación. */
+    removeLabel?: string | undefined;
+    children?: React.ReactNode | undefined;
+}
+export type ChipProps = (ChipBase & {
+    selectable: true;
+} & Omit<ButtonHTMLAttributes<HTMLButtonElement>, keyof ChipBase> & {
+    ref?: Ref<HTMLButtonElement>;
+}) | (ChipBase & {
+    selectable?: false;
+} & Omit<HTMLAttributes<HTMLSpanElement>, keyof ChipBase> & {
+    ref?: Ref<HTMLSpanElement>;
+});
+/**
+ * Chip — etiqueta compacta. Por defecto inline (`<span>`); con `selectable`
+ * se renderiza como `<button>` clickeable. `onRemove` añade una X cerrar.
+ *
+ * @example
+ * <Chip variant="info">Tag</Chip>
+ * <Chip selectable selected={picked} onClick={() => setPicked(p => !p)}>
+ *   React
+ * </Chip>
+ * <Chip variant="success" onRemove={() => removeTag(id)}>Removible</Chip>
+ *
+ * @server-safe
+ */
+export declare function Chip(props: ChipProps): import("react").JSX.Element;
+export {};

package/dist/components/Chip/index.d.ts

@@ -0,0 +1,2 @@
+export { Chip } from './Chip.js';
+export type { ChipProps, ChipVariant, ChipSize } from './Chip.js';

package/dist/components/Dialog/Dialog.d.ts

@@ -0,0 +1,80 @@
+import { ReactNode } from 'react';
+export interface DialogProps {
+    /**
+     * Estado abierto/cerrado en **modo controlled**. Tu app gestiona el
+     * estado y debe actualizarlo en respuesta a `onOpenChange`.
+     *
+     * **D6 (beta.24)**: `open` ahora es opcional. Patrón controlled/
+     * uncontrolled DS-wide:
+     *
+     *   - Pasas `open` → controlled.
+     *   - Omites `open` (y opcionalmente pasas `defaultOpen`) → uncontrolled.
+     *     El Dialog gestiona su estado interno; `DialogTrigger` y `DialogClose`
+     *     llaman al setter del provider sin necesidad de useState externo.
+     */
+    open?: boolean | undefined;
+    /**
+     * Valor inicial en **modo uncontrolled** (cuando `open` es undefined).
+     * Por defecto `false` (cerrado). Ignorado en modo controlled.
+     */
+    defaultOpen?: boolean | undefined;
+    /**
+     * Callback cuando el estado cambia. Dispara en ambos modos:
+     * - Controlled: único mecanismo para que el consumer actualice `open`.
+     * - Uncontrolled: actúa como observer.
+     */
+    onOpenChange?: ((open: boolean) => void) | undefined;
+    /**
+     * @deprecated B-02: usa `onOpenChange`. Eliminado en 2.0. Solo dispara
+     * con `open=false` (cierres). Para apertura programática usa el state
+     * del Dialog (`<DialogTrigger>` en uncontrolled, o `open` prop en
+     * controlled).
+     */
+    onClose?: (() => void) | undefined;
+    children: ReactNode;
+}
+/**
+ * Dialog — Provider para el patrón compound canónico (D6 beta.24).
+ *
+ * Renderiza solo un contexto; no produce DOM por sí mismo. El modal real
+ * vive en `<DialogContent>` (el `<dialog>` HTML nativo) y opcionalmente
+ * un `<DialogTrigger>` para abrir desde la UI.
+ *
+ * Pre-D6 `Dialog` era el `<dialog>` mismo. Migración mecánica: envolver
+ * los children actuales en `<DialogContent>`:
+ *
+ * ```diff
+ * - <Dialog open={x} onOpenChange={fn}>
+ * -   <DialogHeader />
+ * -   <DialogBody>...</DialogBody>
+ * - </Dialog>
+ * + <Dialog open={x} onOpenChange={fn}>
+ * +   <DialogContent>
+ * +     <DialogHeader />
+ * +     <DialogBody>...</DialogBody>
+ * +   </DialogContent>
+ * + </Dialog>
+ * ```
+ *
+ * @example
+ * // Uncontrolled (nuevo en D6):
+ * <Dialog defaultOpen={false}>
+ *   <DialogTrigger>Abrir</DialogTrigger>
+ *   <DialogContent>
+ *     <DialogHeader>Confirmar <DialogClose /></DialogHeader>
+ *     <DialogBody>¿Seguro?</DialogBody>
+ *     <DialogFooter><Button>Aceptar</Button></DialogFooter>
+ *   </DialogContent>
+ * </Dialog>
+ *
+ * @example
+ * // Controlled (backward-compat con la API pre-D6 + DialogContent):
+ * const [open, setOpen] = useState(false);
+ * <Dialog open={open} onOpenChange={setOpen}>
+ *   <DialogContent>
+ *     <DialogHeader>Confirmar <DialogClose /></DialogHeader>
+ *     ...
+ *   </DialogContent>
+ * </Dialog>
+ */
+export declare function Dialog({ open, defaultOpen, onOpenChange, onClose, children, }: DialogProps): import("react").JSX.Element;

package/dist/components/Dialog/DialogBody.d.ts

@@ -0,0 +1,8 @@
+import { HTMLAttributes, Ref } from 'react';
+export interface DialogBodyProps extends HTMLAttributes<HTMLDivElement> {
+    ref?: Ref<HTMLDivElement> | undefined;
+}
+/** DialogBody — cuerpo scrollable del modal.  *
+ * @server-safe
+ */
+export declare function DialogBody({ className, children, ref, ...rest }: DialogBodyProps): import("react").JSX.Element;

package/dist/components/Dialog/DialogClose.d.ts

@@ -0,0 +1,61 @@
+import { ButtonHTMLAttributes, Ref } from 'react';
+export interface DialogCloseProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    ref?: Ref<HTMLButtonElement> | undefined;
+    /**
+     * Slot pattern (D14): si `true`, clona el child del consumer y le aplica
+     * close semantics (`onClick` que cierra el dialog + `aria-label`
+     * default "Cerrar") sin renderizar un `<button>` propio ni aplicar
+     * `ig-dialog-close` (consumer trae su propio styling).
+     *
+     * Cubre el caso de CTAs del footer del Dialog: en lugar del antiguo
+     * `<DialogAction>` (eliminado en beta.27, D14), el patrón canónico
+     * ahora es `<DialogClose asChild><Button>...</Button></DialogClose>`.
+     * Esto cierra la asimetría léxica DialogClose styled / DialogAction
+     * unstyled / AlertDialogClose clónico que era deuda heredada pre-D14.
+     *
+     * Sin `asChild`, DialogClose renderiza el icon-button "×" tradicional
+     * con clase `ig-dialog-close` — comportamiento backwards-compat para
+     * uso como × del header.
+     *
+     * @example
+     * // Header X icon (default, backwards-compat):
+     * <DialogHeader>
+     *   <h2>Confirmar</h2>
+     *   <DialogClose />
+     * </DialogHeader>
+     *
+     * @example
+     * // Footer CTA (Slot pattern, reemplaza el viejo DialogAction):
+     * <DialogFooter>
+     *   <DialogClose asChild>
+     *     <Button variant="brand">Aceptar</Button>
+     *   </DialogClose>
+     * </DialogFooter>
+     */
+    asChild?: boolean | undefined;
+}
+/**
+ * DialogClose — botón que cierra el modal. Dos modos:
+ *
+ * - **Default** (`asChild=false`): renderiza el icon-button "×" tradicional
+ *   con clase `ig-dialog-close` (fuerza dimensiones 2rem × 2rem, sin
+ *   padding). Para la × del header.
+ *
+ * - **Slot pattern** (`asChild=true`, D14): clona el child del consumer
+ *   y le aplica el close handler + aria-label. **No aplica
+ *   `ig-dialog-close`** — el consumer trae su propio styling. Reemplaza
+ *   el antiguo `<DialogAction>` para CTAs del footer.
+ *
+ * **D6 (beta.24)**: si vive dentro de `<Dialog>` consume el contexto y
+ * llama a `setOpen(false)` automáticamente — el consumer no necesita
+ * conectar `onClick` para cerrar. Si pasa un `onClick` propio, se
+ * chainea (consumer primero; si hace `preventDefault`, no cerramos).
+ *
+ * Tolerante a uso fuera de `<Dialog>`: si no hay contexto, el componente
+ * sigue siendo un botón pero el click NO cierra nada (responsabilidad
+ * del consumer via `onClick`).
+ *
+ * Es client-component (`"use client"`) porque consume el `DialogContext`
+ * via hook — NO marcado server-safe.
+ */
+export declare function DialogClose({ asChild, className, children, type, "aria-label": consumerAriaLabel, onClick: consumerOnClick, ref, ...rest }: DialogCloseProps): import("react").JSX.Element;

package/dist/components/Dialog/DialogContent.d.ts

@@ -0,0 +1,36 @@
+import { DialogHTMLAttributes, Ref } from 'react';
+export type DialogContentSize = "sm" | "md" | "lg" | "xl" | "full";
+export type DialogContentBackdrop = "default" | "blur" | "dark" | "light" | "none";
+export interface DialogContentProps extends Omit<DialogHTMLAttributes<HTMLDialogElement>, "open" | "id"> {
+    /** Tamaño del modal. Por defecto `"md"`. */
+    size?: DialogContentSize | undefined;
+    /** Estilo del backdrop. Por defecto `"default"`. */
+    backdrop?: DialogContentBackdrop | undefined;
+    /** Cerrar al hacer click fuera del contenido. Por defecto `true`. */
+    closeOnBackdrop?: boolean | undefined;
+    /** Permitir cerrar con la tecla ESC. Por defecto `true`. */
+    closeOnEsc?: boolean | undefined;
+    /** Estado de carga (aplica `ig-dialog-loading`). */
+    loading?: boolean | undefined;
+    ref?: Ref<HTMLDialogElement> | undefined;
+}
+/**
+ * DialogContent — el `<dialog>` HTML nativo gestionado por el Provider
+ * `Dialog`. Sale en top-layer (sobre cualquier z-index/overflow ancestro),
+ * aplica `role="dialog"` + `aria-modal` automáticos del browser, y reusa
+ * el focus trap + restauración nativos.
+ *
+ * Debe usarse dentro de `<Dialog>`. Si necesitas componer header / body /
+ * footer, mete `<DialogHeader>` / `<DialogBody>` / `<DialogFooter>` como
+ * children de este componente.
+ *
+ * @example
+ * <Dialog defaultOpen>
+ *   <DialogTrigger>Abrir</DialogTrigger>
+ *   <DialogContent size="md">
+ *     <DialogHeader>Título <DialogClose /></DialogHeader>
+ *     <DialogBody>Contenido</DialogBody>
+ *   </DialogContent>
+ * </Dialog>
+ */
+export declare function DialogContent({ size, backdrop, closeOnBackdrop, closeOnEsc, loading, className, children, ref, onPointerDown: consumerOnPointerDown, onClick: consumerOnClick, onClose: consumerOnClose, ...rest }: DialogContentProps): import("react").JSX.Element;

package/dist/components/Dialog/DialogContext.d.ts

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

package/dist/components/Dialog/DialogFooter.d.ts

@@ -0,0 +1,8 @@
+import { HTMLAttributes, Ref } from 'react';
+export interface DialogFooterProps extends HTMLAttributes<HTMLDivElement> {
+    ref?: Ref<HTMLDivElement> | undefined;
+}
+/** DialogFooter — pie del modal con acciones alineadas a la derecha.  *
+ * @server-safe
+ */
+export declare function DialogFooter({ className, children, ref, ...rest }: DialogFooterProps): import("react").JSX.Element;

package/dist/components/Dialog/DialogHeader.d.ts

@@ -0,0 +1,13 @@
+import { HTMLAttributes, Ref } from 'react';
+export interface DialogHeaderProps extends HTMLAttributes<HTMLDivElement> {
+    ref?: Ref<HTMLDivElement> | undefined;
+}
+/**
+ * DialogHeader — cabecera del modal. Suele contener título + `DialogClose`.
+ *
+ * Genera un `id` único y lo registra en el `Dialog` padre, que lo aplica como
+ * `aria-labelledby` para que los lectores de pantalla anuncien el título.
+ * Si el consumer pasa `id` propio, ese tiene prioridad. Si pasa
+ * `aria-labelledby` directamente al `Dialog`, ese gana sobre el del header.
+ */
+export declare function DialogHeader({ className, children, id: idProp, ref, ...rest }: DialogHeaderProps): import("react").JSX.Element;

package/dist/components/Dialog/DialogTrigger.d.ts

@@ -0,0 +1,44 @@
+import { ButtonHTMLAttributes, Ref } from 'react';
+export interface DialogTriggerProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    ref?: Ref<HTMLButtonElement> | undefined;
+    /**
+     * Slot pattern (D14): si `true`, clona el child del consumer y le aplica
+     * trigger semantics (`aria-haspopup="dialog"`, `aria-expanded`,
+     * `aria-controls={contentId}` + `onClick` que abre el dialog) sin
+     * renderizar un `<button>` propio. Permite usar cualquier element como
+     * trigger (`<Button>`, `<a>`, custom component) preservando su tipo,
+     * styling y eventos.
+     *
+     * Sin `asChild`, DialogTrigger renderiza un `<button>` plano que envuelve
+     * los children — comportamiento backwards-compat con 1.0.0-beta.26.
+     *
+     * @example
+     * // Slot pattern (recomendado para Buttons del DS):
+     * <DialogTrigger asChild>
+     *   <Button variant="brand">Abrir modal</Button>
+     * </DialogTrigger>
+     *
+     * @example
+     * // Default (backwards-compat):
+     * <DialogTrigger>Abrir</DialogTrigger>
+     */
+    asChild?: boolean | undefined;
+}
+/**
+ * DialogTrigger — botón que abre el `DialogContent` asociado. Anuncia la
+ * relación al SR via `aria-haspopup="dialog"` + `aria-controls={contentId}` +
+ * `aria-expanded={open}` (estándar APG para disclosure de dialog).
+ *
+ * Dos modos de render:
+ *
+ * - **Default** (`asChild=false`): renderiza un `<button>` plano que envuelve
+ *   los children. Comportamiento idéntico al de 1.0.0-beta.26.
+ *
+ * - **Slot pattern** (`asChild=true`, D14): clona el child del consumer y
+ *   le aplica los aria props + onClick handler. El child es renderizado
+ *   directamente (no wrapper). Patrón canónico Radix/shadcn.
+ *
+ * Debe usarse dentro de `<Dialog>`. Es client-component (`"use client"`)
+ * porque consume el `DialogContext` via hook — NO marcado server-safe.
+ */
+export declare function DialogTrigger({ asChild, type, onClick: consumerOnClick, children, ref, ...rest }: DialogTriggerProps): import("react").JSX.Element;

package/dist/components/Dialog/index.d.ts

@@ -0,0 +1,16 @@
+export { Dialog } from './Dialog.js';
+export type { DialogProps } from './Dialog.js';
+export { DialogContent } from './DialogContent.js';
+export type { DialogContentProps, DialogContentSize, DialogContentBackdrop, } from './DialogContent.js';
+export type { DialogContentSize as DialogSize } from './DialogContent.js';
+export type { DialogContentBackdrop as DialogBackdrop } from './DialogContent.js';
+export { DialogTrigger } from './DialogTrigger.js';
+export type { DialogTriggerProps } from './DialogTrigger.js';
+export { DialogHeader } from './DialogHeader.js';
+export type { DialogHeaderProps } from './DialogHeader.js';
+export { DialogBody } from './DialogBody.js';
+export type { DialogBodyProps } from './DialogBody.js';
+export { DialogFooter } from './DialogFooter.js';
+export type { DialogFooterProps } from './DialogFooter.js';
+export { DialogClose } from './DialogClose.js';
+export type { DialogCloseProps } from './DialogClose.js';

package/dist/components/Divider/Divider.d.ts

@@ -0,0 +1,34 @@
+import { HTMLAttributes, ReactNode, Ref } from 'react';
+export type DividerVariant = "default" | "brand" | "secondary" | "success" | "warning" | "danger" | "info";
+export interface DividerProps extends HTMLAttributes<HTMLElement> {
+    /** Orientación. Vertical renderiza un `<span>` inline-block; horizontal un `<hr>`. */
+    vertical?: boolean | undefined;
+    /** Borde discontinuo. */
+    dashed?: boolean | undefined;
+    /** Color del separador. `default` usa el color neutro de borde. */
+    variant?: DividerVariant | undefined;
+    /** Si se pasan, renderiza un divider con texto centrado en lugar de la línea. */
+    children?: ReactNode | undefined;
+    ref?: Ref<HTMLElement> | undefined;
+}
+/**
+ * Divider — línea separadora horizontal o vertical, con o sin texto.
+ *
+ * - Sin `children` y horizontal → `<hr class="ig-divider">`.
+ * - Sin `children` y vertical → `<span class="ig-divider-vertical">`.
+ * - Con `children` → `<div class="ig-divider-with-text">` con texto centrado.
+ *
+ * Como el elemento renderizado depende de las props, `ref` se tipa como
+ * `Ref<HTMLElement>` (común a los 3). Si necesitas un ref más concreto en tu
+ * código, narrow con `as RefObject<HTMLHRElement>` cuando uses la variante
+ * por defecto.
+ *
+ * @example
+ * <Divider />
+ * <Divider variant="brand" dashed />
+ * <Divider>o</Divider>
+ * <Divider vertical aria-orientation="vertical" />
+ *
+ * @server-safe
+ */
+export declare function Divider({ vertical, dashed, variant, children, className, ref, ...rest }: DividerProps): import("react").JSX.Element;

package/dist/components/Divider/index.d.ts

@@ -0,0 +1,2 @@
+export { Divider } from './Divider.js';
+export type { DividerProps, DividerVariant } from './Divider.js';

package/dist/components/Input/ErrorText.d.ts

@@ -0,0 +1,13 @@
+import { HTMLAttributes, Ref } from 'react';
+export interface ErrorTextProps extends HTMLAttributes<HTMLParagraphElement> {
+    ref?: Ref<HTMLParagraphElement> | undefined;
+}
+/**
+ * ErrorText — mensaje de error bajo un input. Usa `role="alert"` y
+ * `aria-live="polite"` para anunciar el error a tecnologías asistivas.
+ *
+ * (Nombrado `ErrorText` en lugar de `Error` para evitar shadow del global.)
+  *
+ * @server-safe
+ */
+export declare function ErrorText({ className, children, ref, ...rest }: ErrorTextProps): import("react").JSX.Element;

package/dist/components/Input/Helper.d.ts

@@ -0,0 +1,11 @@
+import { HTMLAttributes, Ref } from 'react';
+export interface HelperProps extends HTMLAttributes<HTMLParagraphElement> {
+    ref?: Ref<HTMLParagraphElement> | undefined;
+}
+/**
+ * Helper — texto de ayuda discreto bajo un input. Usa `id` y `aria-describedby`
+ * en el input para que los lectores de pantalla lo asocien.
+  *
+ * @server-safe
+ */
+export declare function Helper({ className, children, ref, ...rest }: HelperProps): import("react").JSX.Element;

package/dist/components/Input/Input.d.ts

@@ -0,0 +1,35 @@
+import { InputHTMLAttributes, Ref } from 'react';
+export type InputSize = "sm" | "md" | "lg";
+export type InputState = "default" | "invalid" | "valid";
+export interface InputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "size"> {
+    /** Tamaño del input. `md` no añade clase. */
+    size?: InputSize | undefined;
+    /** Estado de validación visual. `error` y `success` aplican color y borde. */
+    state?: InputState | undefined;
+    /**
+     * IDs de elementos descriptivos (típicamente `Helper`/`ErrorText`) que se
+     * combinan en `aria-describedby`. Acepta un id o lista de ids.
+     *
+     * Si pasas también `aria-describedby` directo (vía rest), AMBOS se
+     * concatenan en el atributo final — desde `1.0.0-beta.3`.
+     *
+     * @example
+     * const helperId = useId();
+     * const errorId = useId();
+     * <Input describedBy={[helperId, errorId]} ... />
+     * <Helper id={helperId}>...</Helper>
+     * <ErrorText id={errorId}>...</ErrorText>
+     */
+    describedBy?: string | string[] | undefined;
+    ref?: Ref<HTMLInputElement> | undefined;
+}
+/**
+ * Input — `<input>` estilizado con tamaños y estados de validación visual.
+ * Acepta cualquier `type` válido de input nativo. Para enlazar `Helper` y
+ * `ErrorText` a tecnologías asistivas, pasa sus `id` en `describedBy`.
+ *
+ * **A11y dev warn**: si en desarrollo se monta sin `<Label htmlFor>`,
+ * `aria-label`, `aria-labelledby` ni `placeholder`, se emite warn
+ * `[reactigoded] <Input> sin label asociado.` (capa 1.1 debt doc).
+ */
+export declare function Input({ size, state, describedBy, className, ref, ...rest }: InputProps): import("react").JSX.Element;

package/dist/components/Input/InputAddon.d.ts

@@ -0,0 +1,8 @@
+import { HTMLAttributes, Ref } from 'react';
+export interface InputAddonProps extends HTMLAttributes<HTMLSpanElement> {
+    ref?: Ref<HTMLSpanElement> | undefined;
+}
+/** InputAddon — prefijo/sufijo decorativo dentro de un `InputGroup`.  *
+ * @server-safe
+ */
+export declare function InputAddon({ className, children, ref, ...rest }: InputAddonProps): import("react").JSX.Element;

package/dist/components/Input/InputGroup.d.ts

@@ -0,0 +1,17 @@
+import { HTMLAttributes, Ref } from 'react';
+export interface InputGroupProps extends HTMLAttributes<HTMLDivElement> {
+    ref?: Ref<HTMLDivElement> | undefined;
+}
+/**
+ * InputGroup — agrupa un input con `InputAddon`s (prefijo/sufijo).
+ *
+ * @example
+ * <InputGroup>
+ *   <InputAddon>$</InputAddon>
+ *   <Input type="number" />
+ *   <InputAddon>USD</InputAddon>
+ * </InputGroup>
+  *
+ * @server-safe
+ */
+export declare function InputGroup({ className, children, ref, ...rest }: InputGroupProps): import("react").JSX.Element;

package/dist/components/Input/Label.d.ts

@@ -0,0 +1,12 @@
+import { LabelHTMLAttributes, Ref } from 'react';
+export interface LabelProps extends LabelHTMLAttributes<HTMLLabelElement> {
+    /** Marca el label como obligatorio (añade asterisco). */
+    required?: boolean | undefined;
+    ref?: Ref<HTMLLabelElement> | undefined;
+}
+/**
+ * Label — etiqueta para campos de formulario. Asocia con un input via `htmlFor`.
+  *
+ * @server-safe
+ */
+export declare function Label({ required, className, children, ref, ...rest }: LabelProps): import("react").JSX.Element;

package/dist/components/Input/index.d.ts

@@ -0,0 +1,12 @@
+export { Input } from './Input.js';
+export type { InputProps, InputSize, InputState } from './Input.js';
+export { Label } from './Label.js';
+export type { LabelProps } from './Label.js';
+export { Helper } from './Helper.js';
+export type { HelperProps } from './Helper.js';
+export { ErrorText } from './ErrorText.js';
+export type { ErrorTextProps } from './ErrorText.js';
+export { InputGroup } from './InputGroup.js';
+export type { InputGroupProps } from './InputGroup.js';
+export { InputAddon } from './InputAddon.js';
+export type { InputAddonProps } from './InputAddon.js';

package/dist/components/NativeSelect/NativeSelect.d.ts

@@ -0,0 +1,41 @@
+import { Ref, SelectHTMLAttributes } from 'react';
+export type NativeSelectState = "default" | "invalid" | "valid";
+export interface NativeSelectProps extends SelectHTMLAttributes<HTMLSelectElement> {
+    /** Estado de validación visual. */
+    state?: NativeSelectState | undefined;
+    /**
+     * IDs de elementos descriptivos (`Helper`/`ErrorText`) combinados en
+     * `aria-describedby`. Acepta un id o lista de ids. Si pasas también
+     * `aria-describedby` directo (vía rest), AMBOS se concatenan.
+     */
+    describedBy?: string | string[] | undefined;
+    ref?: Ref<HTMLSelectElement> | undefined;
+}
+/**
+ * NativeSelect — `<select>` nativo estilizado. Pasa `<option>` como children.
+ *
+ * **Limitación de plataforma**: la apariencia depende de
+ * `appearance: none` + un caret SVG inyectado en CSS. Cubre Chrome,
+ * Firefox, Safari y Edge modernos (los del browserslist). En motores
+ * antiguos sin soporte de `appearance: none` el `<select>` cae al chrome
+ * nativo del navegador (caret nativo, sin el icono igoded). El menú de
+ * opciones siempre lo pinta el sistema operativo — la librería no
+ * intenta reemplazarlo (un combobox custom requeriría un componente
+ * separado, fuera del alcance del DS).
+ *
+ * **A11y dev warn**: si en desarrollo se monta sin `<Label htmlFor>`,
+ * `aria-label` ni `aria-labelledby`, se emite warn
+ * `[reactigoded] <NativeSelect> sin label asociado.` (capa 1.1 debt doc).
+ * Nota: `<select>` no tiene `placeholder`.
+ *
+ * @example
+ * <NativeSelect value={country} onChange={(e) => setCountry(e.target.value)}>
+ *   <option value="es">España</option>
+ *   <option value="mx">México</option>
+ *   <option value="ar">Argentina</option>
+ * </NativeSelect>
+ * <NativeSelect state="invalid" describedBy={errorId}>
+ *   <option value="">Selecciona…</option>
+ * </NativeSelect>
+ */
+export declare function NativeSelect({ state, describedBy, className, children, ref, ...rest }: NativeSelectProps): import("react").JSX.Element;

package/dist/components/NativeSelect/index.d.ts

@@ -0,0 +1,2 @@
+export { NativeSelect } from './NativeSelect.js';
+export type { NativeSelectProps, NativeSelectState } from './NativeSelect.js';