reactigoded 1.0.0-beta.26

package/dist/components/Navbar/Navbar.d.ts

@@ -0,0 +1,46 @@
+import { HTMLAttributes, Ref } from 'react';
+export type NavbarPosition = "sticky" | "fixed";
+export interface NavbarProps extends HTMLAttributes<HTMLElement> {
+    /**
+     * Posición del navbar.
+     * - `"sticky"`: pegado en top mientras scrolleas dentro de su contenedor.
+     * - `"fixed"`: anclado en top fuera del flujo (overlay).
+     *
+     * Antes existían dos booleans `sticky` y `fixed`; eran mutuamente
+     * excluyentes solo en docs. Ahora la elección es una sola prop con
+     * unión discriminada — el typing impide pasar ambas a la vez.
+     */
+    position?: NavbarPosition | undefined;
+    /** Estilo glassmorphism (fondo translúcido + blur). */
+    glass?: boolean | undefined;
+    ref?: Ref<HTMLElement> | undefined;
+}
+/**
+ * Navbar — barra de navegación horizontal superior (`<header>`).
+ *
+ * Compón con `NavbarLogo`, `NavbarNav`, `NavbarLink` y `NavbarActions`.
+ * `position` controla el comportamiento sticky/fixed; `glass` se puede
+ * combinar con cualquier `position`.
+ *
+ * **A11y dev warn**: `<header>` es role banner por defecto. Axe rule
+ * `landmark-no-duplicate-banner` solo permite UN banner top-level por
+ * documento. Si se montan dos `<Navbar>` top-level (típico en galerías
+ * `AllStates`), se emite warn (capa 1.3 debt doc). Mitigación
+ * documentada en `docs/STORY_CATALOG_CONVENTIONS.md`: envolver cada
+ * instancia en `<section aria-label="Demo X">` que la despromueve a
+ * `region`.
+ *
+ * @example
+ * <Navbar position="sticky">
+ *   <NavbarLogo href="/">Mi App</NavbarLogo>
+ *   <NavbarNav>
+ *     <NavbarLink href="/" active>Inicio</NavbarLink>
+ *     <NavbarLink href="/precios">Precios</NavbarLink>
+ *   </NavbarNav>
+ *   <NavbarActions>
+ *     <Button appearance="ghost">Login</Button>
+ *     <Button variant="brand">Sign Up</Button>
+ *   </NavbarActions>
+ * </Navbar>
+ */
+export declare function Navbar({ className, position, glass, ref, ...rest }: NavbarProps): import("react").JSX.Element;

package/dist/components/Navbar/NavbarActions.d.ts

@@ -0,0 +1,10 @@
+import { HTMLAttributes, Ref } from 'react';
+export interface NavbarActionsProps extends HTMLAttributes<HTMLDivElement> {
+    ref?: Ref<HTMLDivElement> | undefined;
+}
+/**
+ * NavbarActions — contenedor de acciones globales (botones, menús de cuenta).
+  *
+ * @server-safe
+ */
+export declare function NavbarActions({ className, ref, ...rest }: NavbarActionsProps): import("react").JSX.Element;

package/dist/components/Navbar/NavbarLink.d.ts

@@ -0,0 +1,13 @@
+import { AnchorHTMLAttributes, Ref } from 'react';
+export interface NavbarLinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
+    /** Marca el link como activo (`aria-current="page"`). */
+    active?: boolean | undefined;
+    ref?: Ref<HTMLAnchorElement> | undefined;
+}
+/**
+ * NavbarLink — link de navegación dentro de `NavbarNav`. Aplica
+ * `aria-current="page"` cuando `active` es true.
+  *
+ * @server-safe
+ */
+export declare function NavbarLink({ className, active, ref, ...rest }: NavbarLinkProps): import("react").JSX.Element;

package/dist/components/Navbar/NavbarLogo.d.ts

@@ -0,0 +1,22 @@
+import { AnchorHTMLAttributes, HTMLAttributes, Ref } from 'react';
+type CommonProps = {
+    className?: string | undefined;
+};
+type AsAnchor = CommonProps & AnchorHTMLAttributes<HTMLAnchorElement> & {
+    /** Si se proporciona `href`, se renderiza como `<a>`. */
+    href: string;
+    ref?: Ref<HTMLAnchorElement> | undefined;
+};
+type AsDiv = CommonProps & HTMLAttributes<HTMLDivElement> & {
+    href?: undefined;
+    ref?: Ref<HTMLDivElement> | undefined;
+};
+export type NavbarLogoProps = AsAnchor | AsDiv;
+/**
+ * NavbarLogo — área del logo y nombre. Por defecto es `<div>`; si se pasa
+ * `href` se renderiza como `<a>` (clicable).
+  *
+ * @server-safe
+ */
+export declare function NavbarLogo(props: NavbarLogoProps): import("react").JSX.Element;
+export {};

package/dist/components/Navbar/NavbarMenuButton.d.ts

@@ -0,0 +1,15 @@
+import { ButtonHTMLAttributes, Ref } from 'react';
+export interface NavbarMenuButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    /** Si el menú asociado está expandido. */
+    expanded?: boolean | undefined;
+    /** ID del elemento que controla (para `aria-controls`). */
+    controlsId?: string | undefined;
+    ref?: Ref<HTMLButtonElement> | undefined;
+}
+/**
+ * NavbarMenuButton — botón hamburguesa que sólo se muestra en mobile vía CSS
+ * (`@media max-width: 768px`). Pensado para abrir un menú lateral o drawer.
+  *
+ * @server-safe
+ */
+export declare function NavbarMenuButton({ className, expanded, controlsId, children, "aria-label": ariaLabel, ref, ...rest }: NavbarMenuButtonProps): import("react").JSX.Element;

package/dist/components/Navbar/NavbarNav.d.ts

@@ -0,0 +1,14 @@
+import { HTMLAttributes, Ref } from 'react';
+export interface NavbarNavProps extends HTMLAttributes<HTMLElement> {
+    ref?: Ref<HTMLElement> | undefined;
+}
+/**
+ * NavbarNav — `<nav>` que contiene los `NavbarLink`s del navbar. `aria-label`
+ * por defecto "Principal"; sobreescribible vía atributo HTML estándar.
+ *
+ * **A11y dev warn**: si dos NavbarNav (u otro `<nav>` con role
+ * navigation) comparten `aria-label` vivos al mismo tiempo, se emite
+ * warn `[reactigoded] dos landmarks role="navigation" comparten…`
+ * (capa 1.2 debt doc).
+ */
+export declare function NavbarNav({ className, ref, ...rest }: NavbarNavProps): import("react").JSX.Element;

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

@@ -0,0 +1,12 @@
+export { Navbar } from './Navbar.js';
+export type { NavbarProps } from './Navbar.js';
+export { NavbarLogo } from './NavbarLogo.js';
+export type { NavbarLogoProps } from './NavbarLogo.js';
+export { NavbarNav } from './NavbarNav.js';
+export type { NavbarNavProps } from './NavbarNav.js';
+export { NavbarLink } from './NavbarLink.js';
+export type { NavbarLinkProps } from './NavbarLink.js';
+export { NavbarActions } from './NavbarActions.js';
+export type { NavbarActionsProps } from './NavbarActions.js';
+export { NavbarMenuButton } from './NavbarMenuButton.js';
+export type { NavbarMenuButtonProps } from './NavbarMenuButton.js';

package/dist/components/Pagination/Pagination.d.ts

@@ -0,0 +1,77 @@
+import { HTMLAttributes, ReactNode, Ref } from 'react';
+export type PaginationVariant = "brand" | "secondary" | "success" | "warning" | "danger" | "info";
+export interface PaginationProps extends Omit<HTMLAttributes<HTMLElement>, "onChange"> {
+    /**
+     * Página actual (1-based) en modo **controlled**. Si se pasa, el
+     * consumer es responsable de actualizar la prop en respuesta a
+     * `onPageChange`. Si se omite, el componente arranca en `defaultPage`
+     * y maneja el state internamente.
+     */
+    page?: number | undefined;
+    /**
+     * Página inicial (1-based) en modo **uncontrolled**. Default `1`.
+     * Ignorado si `page` está definido.
+     */
+    defaultPage?: number | undefined;
+    /** Número total de páginas (>=1). */
+    totalPages: number;
+    /** Cuántas páginas mostrar a cada lado de la actual antes de elipsis. Por defecto 1. */
+    siblingCount?: number | undefined;
+    /**
+     * Callback al cambiar de página. Opcional en modo uncontrolled (el
+     * componente actualiza su state interno) y útil para reaccionar al
+     * cambio (fetch de datos, sync con URL, etc.).
+     */
+    onPageChange?: ((page: number) => void) | undefined;
+    /** Color de la página activa. */
+    variant?: PaginationVariant | undefined;
+    /**
+     * Contenido del botón anterior. Si es string también se usa como
+     * `aria-label` (a menos que se pase `prevAriaLabel` explícito).
+     * Si es ReactNode (p.ej. un icono), pasa `prevAriaLabel` con el texto
+     * legible para SR.
+     */
+    prevLabel?: ReactNode | undefined;
+    /**
+     * Contenido del botón siguiente. Mismas reglas que `prevLabel`.
+     */
+    nextLabel?: ReactNode | undefined;
+    /**
+     * `aria-label` del botón anterior. Override explícito; si se omite y
+     * `prevLabel` es string se usa éste, en otro caso "Página anterior".
+     */
+    prevAriaLabel?: string | undefined;
+    /**
+     * `aria-label` del botón siguiente. Override explícito; si se omite y
+     * `nextLabel` es string se usa éste, en otro caso "Página siguiente".
+     */
+    nextAriaLabel?: string | undefined;
+    /**
+     * Genera el `aria-label` de cada botón de página. Por defecto
+     * `(p) => "Página N"` en español. Útil para i18n: pasar
+     * `(p) => \`Page ${p}\`` para inglés, `(p) => \`Seite ${p}\`` para
+     * alemán, etc. (L-12 gate review).
+     */
+    getPageLabel?: ((page: number) => string) | undefined;
+    ref?: Ref<HTMLElement> | undefined;
+}
+/**
+ * Pagination — navegación paginada accesible.
+ *
+ * Renderiza un `<nav>` con `aria-label`, botón "anterior", páginas (con
+ * elipsis cuando hay muchas) y botón "siguiente". La página activa lleva
+ * `aria-current="page"`. Cada página tiene `aria-label="Página N"`.
+ *
+ * Soporta **controlled** (`page` + `onPageChange`) y **uncontrolled**
+ * (`defaultPage`, opcional `onPageChange` para reaccionar). Idéntico
+ * patrón a otros componentes con state del DS (Tabs, Accordion, etc.).
+ *
+ * @example
+ * // Uncontrolled — el componente maneja el state internamente
+ * <Pagination totalPages={20} defaultPage={1} onPageChange={fetchPage} />
+ *
+ * // Controlled — el consumer mantiene page
+ * const [page, setPage] = useState(1);
+ * <Pagination totalPages={20} page={page} onPageChange={setPage} />
+ */
+export declare function Pagination({ page: pageProp, defaultPage, totalPages, siblingCount, onPageChange, variant, prevLabel, nextLabel, prevAriaLabel, nextAriaLabel, getPageLabel, className, ref, ...rest }: PaginationProps): import("react").JSX.Element;

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

@@ -0,0 +1,2 @@
+export { Pagination } from './Pagination.js';
+export type { PaginationProps, PaginationVariant } from './Pagination.js';

package/dist/components/Progress/Progress.d.ts

@@ -0,0 +1,63 @@
+import { HTMLAttributes, Ref } from 'react';
+export type ProgressVariant = "brand" | "secondary" | "success" | "warning" | "danger" | "info";
+export type ProgressSize = "sm" | "md" | "lg";
+export interface ProgressProps extends HTMLAttributes<HTMLDivElement> {
+    /** Valor actual (0..max). Ignorado si `indeterminate`. */
+    value?: number | undefined;
+    /** Valor máximo. Por defecto 100. */
+    max?: number | undefined;
+    /** Color del progress bar. */
+    variant?: ProgressVariant | undefined;
+    /** Altura del track. */
+    size?: ProgressSize | undefined;
+    /** Modo indeterminado: barra animada sin valor concreto. */
+    indeterminate?: boolean | undefined;
+    /**
+     * Etiqueta accesible (aria-label) cuando el componente no recibe
+     * `aria-label` explícito. Default `"Cargando"` (ES intencional —
+     * audience inicial hispanohablante; ver Storybook → *Fundamentos /
+     * CSS API pública* (renderizada desde `docs/CSSAPI.mdx`) sección
+     * "i18n y a11y strings").
+     *
+     * Override para apps en otros idiomas:
+     * ```tsx
+     * <Progress loadingLabel="Loading" indeterminate />
+     * ```
+     *
+     * Si pasas `aria-label` como prop HTML estándar, gana sobre
+     * `loadingLabel` y `formatLabel`.
+     */
+    loadingLabel?: string | undefined;
+    /**
+     * Función opcional para formatear el `aria-label` con el porcentaje
+     * actual. Útil con sistemas i18n con interpolación. No aplica en
+     * `indeterminate` (no hay porcentaje).
+     *
+     * @example
+     * ```tsx
+     * <Progress value={75} formatLabel={(p) => `${p}% done`} />
+     * // i18n:
+     * <Progress
+     *   value={percent}
+     *   formatLabel={(p) => t("progress.format", { percent: p })}
+     * />
+     * ```
+     */
+    formatLabel?: ((percent: number) => string) | undefined;
+    ref?: Ref<HTMLDivElement> | undefined;
+}
+/**
+ * Progress — barra de progreso lineal.
+ *
+ * Expone `role="progressbar"` con `aria-valuenow/min/max` (o sin `valuenow`
+ * en modo `indeterminate`). El relleno es un `<div>` interno cuya `width`
+ * se calcula a partir de `value/max`.
+ *
+ * @example
+ * <Progress value={70} variant="success" />
+ * <Progress indeterminate aria-label="Subiendo archivo" />
+ * <Progress value={3} max={5} size="lg" />
+  *
+ * @server-safe
+ */
+export declare function Progress({ value, max, variant, size, indeterminate, loadingLabel, formatLabel, className, ref, ...rest }: ProgressProps): import("react").JSX.Element;

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

@@ -0,0 +1,2 @@
+export { Progress } from './Progress.js';
+export type { ProgressProps, ProgressVariant, ProgressSize } from './Progress.js';

package/dist/components/Radio/Radio.d.ts

@@ -0,0 +1,28 @@
+import { InputHTMLAttributes, Ref } from 'react';
+export type RadioVariant = "brand" | "secondary" | "success" | "warning" | "danger" | "info";
+export interface RadioProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "size"> {
+    /** Color del punto cuando está seleccionado. */
+    variant?: RadioVariant | undefined;
+    /** Etiqueta visible junto al radio. */
+    children?: React.ReactNode | 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.
+     */
+    describedBy?: string | string[] | undefined;
+    ref?: Ref<HTMLInputElement> | undefined;
+}
+/**
+ * Radio — `<input type="radio">` con punto visual personalizado.
+ * Recuerda agrupar varios con el mismo `name`.
+ *
+ * @example
+ * <Radio name="plan" value="free" defaultChecked>Free</Radio>
+ * <Radio name="plan" value="pro" variant="success">Pro</Radio>
+ * <Radio name="plan" value="enterprise" disabled>Enterprise</Radio>
+  *
+ * @server-safe
+ */
+export declare function Radio({ variant, className, children, ref, disabled, describedBy, ...rest }: RadioProps): import("react").JSX.Element;

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

@@ -0,0 +1,2 @@
+export { Radio } from './Radio.js';
+export type { RadioProps, RadioVariant } from './Radio.js';

package/dist/components/Rating/Rating.d.ts

@@ -0,0 +1,85 @@
+import { HTMLAttributes, Ref } from 'react';
+export type RatingSize = "sm" | "md" | "lg" | "xl";
+export interface RatingProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange"> {
+    /** Valor actual (modo controlado, 0..max). */
+    value?: number | undefined;
+    /** Valor inicial (modo no controlado). Por defecto 0. */
+    defaultValue?: number | undefined;
+    /** Máximo de estrellas. Por defecto 5. */
+    max?: number | undefined;
+    /** Sólo lectura: no responde a interacción. */
+    readOnly?: boolean | undefined;
+    /**
+     * Si se proporciona, Rating participa en form submission nativo
+     * renderizando un `<input type="hidden" name={name} value={value}>`
+     * adyacente al `radiogroup`. El value del hidden input espeja el
+     * valor efectivo (clamped, controlled o uncontrolled), por lo que un
+     * `new FormData(form)` recoge la puntuación sin necesidad de librería
+     * de forms. Sin `name`, Rating es display-only para form submission y
+     * el consumer debe leer el valor vía `onValueChange` + state.
+     *
+     * Cierra la asimetría con los otros inputs del DS (Checkbox/Switch/
+     * Radio/Slider/NativeSelect serializan vía el `<input>` nativo
+     * heredado de `InputHTMLAttributes`). Rating usa buttons en
+     * `role="radiogroup"` por el canal-de-forma WCAG (#102), así que
+     * añadimos el bridge nativo sin tocar el patrón APG visible.
+     *
+     * @example
+     * <form action="/rate" method="post">
+     *   <Rating name="score" defaultValue={3} max={5} />
+     *   <button type="submit">Enviar</button>
+     * </form>
+     */
+    name?: string | undefined;
+    /** Tamaño visual. */
+    size?: RatingSize | undefined;
+    /** Callback al elegir un valor. */
+    onValueChange?: ((value: number) => void) | undefined;
+    /**
+     * Ids extra para `aria-describedby` del radiogroup. 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.
+     */
+    describedBy?: string | string[] | undefined;
+    /**
+     * Override del `aria-label` por estrella individual. Recibe el valor
+     * 1..max y devuelve la cadena. Default ES: `"1 estrella"` / `"N estrellas"`.
+     * Cierra el hueco i18n del componente — el grupo ya era overrideable
+     * vía `aria-label`, los hijos no lo eran (ver `docs/decisions/D12-es-defaults-i18n.md`).
+     *
+     * @example
+     * <Rating max={5} getStarLabel={(n) => `${n} of 5 stars`} />
+     */
+    getStarLabel?: ((value: number) => string) | undefined;
+    ref?: Ref<HTMLDivElement> | undefined;
+}
+/**
+ * Rating — N estrellas clicables con preview por hover y navegación
+ * completa por teclado siguiendo el patrón WAI-ARIA APG de radiogroup:
+ *
+ * - El contenedor es `role="radiogroup"`.
+ * - Cada estrella es `<button role="radio">` con `aria-checked`.
+ * - **Roving tabindex**: solo la estrella seleccionada (o la primera si
+ *   no hay selección) tiene `tabIndex=0`; el resto `tabIndex=-1`.
+ * - **Keyboard**:
+ *   - `ArrowRight` / `ArrowDown` → siguiente estrella + selecciona (clamp en `max`).
+ *   - `ArrowLeft`  / `ArrowUp`   → anterior estrella + selecciona (clamp en 1).
+ *   - `Home` → primera estrella (valor 1).
+ *   - `End`  → última estrella (valor `max`).
+ *   - `Space` / `Enter` → selecciona la estrella focuseada.
+ *
+ * Soporta controlled (`value`+`onValueChange`) y uncontrolled (`defaultValue`).
+ *
+ * **Robustez frente a inputs inválidos** (desde `1.0.0-beta.4`):
+ * - `value` o `defaultValue` fuera de `[0, max]` se clampa silenciosamente.
+ * - `max` no entero se redondea hacia abajo, mínimo 1.
+ * - Las flechas no envuelven (clamp, no wrap) — patrón estándar APG.
+ *
+ * @example
+ * <Rating defaultValue={3} max={5} />
+ * <Rating value={r} onValueChange={setR} aria-label="Puntuación del producto" />
+ * <Rating value={4} readOnly />
+ */
+export declare function Rating({ value: valueProp, defaultValue, max, readOnly, size, onValueChange, describedBy, getStarLabel, name, className, ref, ...rest }: RatingProps): import("react").JSX.Element;

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

@@ -0,0 +1,2 @@
+export { Rating } from './Rating.js';
+export type { RatingProps, RatingSize } from './Rating.js';

package/dist/components/Sidebar/Sidebar.d.ts

@@ -0,0 +1,28 @@
+import { HTMLAttributes, Ref } from 'react';
+export interface SidebarProps extends HTMLAttributes<HTMLElement> {
+    /** Estado colapsado (modo controlado). */
+    collapsed?: boolean | undefined;
+    /** Estado inicial (modo no controlado). Por defecto `false`. */
+    defaultCollapsed?: boolean | undefined;
+    /** Callback al cambiar collapsed. */
+    onCollapsedChange?: ((collapsed: boolean) => void) | undefined;
+    ref?: Ref<HTMLElement> | undefined;
+}
+/**
+ * Sidebar — barra lateral persistente tipo "rail" con modo colapsado.
+ *
+ * Provee context a `SidebarToggle`, `SidebarItem`, etc. Compón con
+ * `SidebarHeader`, `SidebarNav`, `SidebarItem`, `SidebarSection`,
+ * `SidebarDivider`, `SidebarFooter`, `SidebarToggle`. En modo colapsado el
+ * CSS oculta automáticamente `.ig-sidebar-text` y `.ig-sidebar-section`.
+ *
+ * @example
+ * <Sidebar>
+ *   <SidebarHeader>Mi App</SidebarHeader>
+ *   <SidebarNav>
+ *     <SidebarItem href="/" icon="🏠" active>Inicio</SidebarItem>
+ *   </SidebarNav>
+ *   <SidebarFooter><SidebarToggle /></SidebarFooter>
+ * </Sidebar>
+ */
+export declare function Sidebar({ collapsed: collapsedProp, defaultCollapsed, onCollapsedChange, className, children, ref, ...rest }: SidebarProps): import("react").JSX.Element;

package/dist/components/Sidebar/SidebarContext.d.ts

@@ -0,0 +1,32 @@
+export interface SidebarContextValue {
+    /** Si la sidebar está colapsada (modo "rail" sólo iconos). */
+    collapsed: boolean;
+    /** Cambia el estado y dispara `onCollapsedChange`. */
+    setCollapsed: (next: boolean) => void;
+    /**
+     * Id del `<aside>` (útil para que `<SidebarToggle>` referencie su
+     * panel via `aria-controls`). Si el consumer pasó `id` al
+     * `<Sidebar>`, ese id se respeta; si no, viene de `useId()`.
+     */
+    asideId: string;
+}
+export declare const SidebarContext: import('react').Context<SidebarContextValue | null>;
+/**
+ * Hook **interno** consumido por sub-componentes del DS (`SidebarToggle`,
+ * `SidebarItem` para auto-derivar `aria-label` cuando text se oculta en
+ * estado colapsado). NO está re-exportado en el barrel público de Sidebar
+ * — el bundle del DS no lo expone (`B-04 RC1` retiro confirmado, D4 RC1
+ * gate review).
+ *
+ * Si necesitas persist state en localStorage o sincronizar con router,
+ * usa **controlled mode external** desde tu app — pasa `collapsed` +
+ * `onCollapsedChange` a `<Sidebar>` desde un `useState` que tú manejes.
+ * Ver README sección "Persisting Sidebar state" para el patrón completo
+ * con guard SSR-safe en el initializer del useState (necesario porque
+ * `localStorage` no existe en server-render).
+ *
+ * @throws Error si se usa fuera de `<Sidebar>` desde un sub-componente.
+ *   Esto es regla DS-wide D11.4: hooks que requieren ancestor lanzan
+ *   (consistent con `useMenu`, `useTabs`, `useAccordion`, `useDialog`).
+ */
+export declare function useSidebar(): SidebarContextValue;

package/dist/components/Sidebar/SidebarDivider.d.ts

@@ -0,0 +1,8 @@
+import { HTMLAttributes, Ref } from 'react';
+export interface SidebarDividerProps extends HTMLAttributes<HTMLDivElement> {
+    ref?: Ref<HTMLDivElement> | undefined;
+}
+/** SidebarDivider — separador horizontal entre grupos de items.  *
+ * @server-safe
+ */
+export declare function SidebarDivider({ className, ref, ...rest }: SidebarDividerProps): import("react").JSX.Element;

package/dist/components/Sidebar/SidebarFooter.d.ts

@@ -0,0 +1,8 @@
+import { HTMLAttributes, Ref } from 'react';
+export interface SidebarFooterProps extends HTMLAttributes<HTMLDivElement> {
+    ref?: Ref<HTMLDivElement> | undefined;
+}
+/** SidebarFooter — sección inferior de la sidebar (suele alojar `SidebarToggle`).  *
+ * @server-safe
+ */
+export declare function SidebarFooter({ className, children, ref, ...rest }: SidebarFooterProps): import("react").JSX.Element;

package/dist/components/Sidebar/SidebarHeader.d.ts

@@ -0,0 +1,13 @@
+import { HTMLAttributes, ReactNode, Ref } from 'react';
+export interface SidebarHeaderProps extends HTMLAttributes<HTMLDivElement> {
+    /** Icono / logo a la izquierda. Visible incluso colapsada. */
+    icon?: ReactNode | undefined;
+    ref?: Ref<HTMLDivElement> | undefined;
+}
+/**
+ * SidebarHeader — cabecera de la sidebar. El icono/logo permanece visible
+ * en modo colapsado; el texto (children) lo oculta el CSS automáticamente.
+  *
+ * @server-safe
+ */
+export declare function SidebarHeader({ icon, className, children, ref, ...rest }: SidebarHeaderProps): import("react").JSX.Element;

package/dist/components/Sidebar/SidebarItem.d.ts

@@ -0,0 +1,42 @@
+import { AnchorHTMLAttributes, ButtonHTMLAttributes, ReactNode, Ref } from 'react';
+interface CommonProps {
+    /** Icono al inicio (siempre visible, incluso colapsada). */
+    icon?: ReactNode | undefined;
+    /** Marca el item como ruta/sección actual. Aplica `aria-current="page"`. */
+    active?: boolean | undefined;
+}
+type AnchorItemProps = CommonProps & AnchorHTMLAttributes<HTMLAnchorElement> & {
+    href: string;
+    ref?: Ref<HTMLAnchorElement> | undefined;
+};
+type ButtonItemProps = CommonProps & ButtonHTMLAttributes<HTMLButtonElement> & {
+    href?: undefined;
+    ref?: Ref<HTMLButtonElement> | undefined;
+};
+export type SidebarItemProps = AnchorItemProps | ButtonItemProps;
+/**
+ * SidebarItem — entrada navegable. Renderiza `<a>` si recibe `href`,
+ * `<button>` si no. El icono permanece visible en modo colapsado y el texto
+ * lo oculta el CSS automáticamente.
+ *
+ * **D4 (RC1 gate review)**: `aria-label` se aplica condicionalmente:
+ * - **Sidebar expandida**: el texto del item está en el a11y tree
+ *   (visible + parseado por SR como nombre accesible). NO se aplica
+ *   `aria-label` automático — duplicaría el nombre (anti-pattern ARIA
+ *   APG: "if visible text serves as accessible name, do not add
+ *   aria-label").
+ * - **Sidebar colapsada**: CSS `.ig-sidebar-collapsed .ig-sidebar-text`
+ *   con `display: none` saca el texto del a11y tree. SIN `aria-label`,
+ *   el item queda sin nombre accesible (icono es `aria-hidden`). Por
+ *   eso aplicamos `aria-label = children` cuando collapsed y children
+ *   es string.
+ *
+ * Override explícito de `aria-label` siempre tiene prioridad sobre
+ * cualquier fallback automático.
+ *
+ * SidebarItem es client component porque consume `useSidebar()` para
+ * detectar el estado collapsed. Debe estar dentro de `<Sidebar>` —
+ * `useSidebar` lanza si no hay ancestor (D11.4 regla DS-wide).
+ */
+export declare function SidebarItem(props: SidebarItemProps): import("react").JSX.Element;
+export {};

package/dist/components/Sidebar/SidebarNav.d.ts

@@ -0,0 +1,13 @@
+import { HTMLAttributes, Ref } from 'react';
+export interface SidebarNavProps extends HTMLAttributes<HTMLElement> {
+    ref?: Ref<HTMLElement> | undefined;
+}
+/**
+ * SidebarNav — `<nav>` que envuelve los items de navegación. `aria-label`
+ * por defecto "Principal"; sobreescribible vía rest.
+ *
+ * **A11y dev warn**: si dos SidebarNav (u otro `<nav>` con role
+ * navigation) comparten `aria-label`, se emite warn (capa 1.2 debt
+ * doc).
+ */
+export declare function SidebarNav({ className, children, ref, ...rest }: SidebarNavProps): import("react").JSX.Element;

package/dist/components/Sidebar/SidebarSection.d.ts

@@ -0,0 +1,11 @@
+import { HTMLAttributes, Ref } from 'react';
+export interface SidebarSectionProps extends HTMLAttributes<HTMLDivElement> {
+    ref?: Ref<HTMLDivElement> | undefined;
+}
+/**
+ * SidebarSection — etiqueta de grupo (estilo "Principal", "Herramientas").
+ * Oculta automáticamente cuando la sidebar está colapsada (vía CSS).
+  *
+ * @server-safe
+ */
+export declare function SidebarSection({ className, children, ref, ...rest }: SidebarSectionProps): import("react").JSX.Element;

package/dist/components/Sidebar/SidebarToggle.d.ts

@@ -0,0 +1,17 @@
+import { ButtonHTMLAttributes, ReactNode, Ref } from 'react';
+export interface SidebarToggleProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    /** Contenido del botón. Por defecto `"☰"`. */
+    children?: ReactNode | undefined;
+    /** Texto a11y al expandir. Por defecto `"Expandir sidebar"`. */
+    expandLabel?: string | undefined;
+    /** Texto a11y al colapsar. Por defecto `"Colapsar sidebar"`. */
+    collapseLabel?: string | undefined;
+    ref?: Ref<HTMLButtonElement> | undefined;
+}
+/**
+ * SidebarToggle — botón que alterna el estado colapsado de la `Sidebar`.
+ * Aplica `aria-expanded` (true cuando expandida), `aria-controls`
+ * apuntando al `<aside>` del Sidebar, y un `aria-label` distinto según
+ * el estado para que los lectores de pantalla anuncien la acción.
+ */
+export declare function SidebarToggle({ className, children, type, expandLabel, collapseLabel, onClick, ref, ...rest }: SidebarToggleProps): import("react").JSX.Element;

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

@@ -0,0 +1,16 @@
+export { Sidebar } from './Sidebar.js';
+export type { SidebarProps } from './Sidebar.js';
+export { SidebarHeader } from './SidebarHeader.js';
+export type { SidebarHeaderProps } from './SidebarHeader.js';
+export { SidebarNav } from './SidebarNav.js';
+export type { SidebarNavProps } from './SidebarNav.js';
+export { SidebarItem } from './SidebarItem.js';
+export type { SidebarItemProps } from './SidebarItem.js';
+export { SidebarFooter } from './SidebarFooter.js';
+export type { SidebarFooterProps } from './SidebarFooter.js';
+export { SidebarToggle } from './SidebarToggle.js';
+export type { SidebarToggleProps } from './SidebarToggle.js';
+export { SidebarDivider } from './SidebarDivider.js';
+export type { SidebarDividerProps } from './SidebarDivider.js';
+export { SidebarSection } from './SidebarSection.js';
+export type { SidebarSectionProps } from './SidebarSection.js';