@studiolxd/brand 38.12.4

package/dist/_types/sections/SiteHeader/SiteHeader.d.ts

@@ -0,0 +1,58 @@
+import { type ReactNode } from 'react';
+import { type ContainerWidth } from '../../atoms/Container/Container';
+import { type LogoSize } from '../../atoms/Logo/Logo';
+import './SiteHeader.css';
+export type SiteHeaderLogoLinkProps = {
+    href: string;
+    className: string;
+    'aria-label': string;
+    children: ReactNode;
+};
+export interface SiteHeaderProps {
+    /** Destino del logotipo. */
+    logoHref?: string;
+    /** Texto accesible del enlace del logotipo. */
+    logoLabel?: string;
+    /** aria-label del botón de menú. */
+    menuLabel?: string;
+    /** aria-label del botón de menú cuando está abierto («Cerrar menú»). */
+    menuCloseLabel?: string;
+    /** La marca. Por defecto el `Logo` de Studio LXD a `logoSize`; un producto de la suite pone la suya. */
+    logo?: ReactNode;
+    /** Talla del logotipo por defecto. `xxl` (85px): la cabecera es el sitio de la marca. */
+    logoSize?: LogoSize;
+    /** Talla del botón de menú. `lg` (48px) acompaña al logotipo grande. */
+    menuButtonSize?: 'sm' | 'md' | 'lg';
+    /**
+     * Enlace del logotipo para el router del producto. Recibe `href`, `className`,
+     * `aria-label` y `children`, y debe reenviarlos todos.
+     */
+    renderLogoLink?: (props: SiteHeaderLogoLinkProps) => ReactNode;
+    /** Ancho del contenido; el fondo siempre llega de lado a lado. */
+    width?: ContainerWidth;
+    /** Estado del menú cuando lo gobierna el producto. Si se omite, es interno. */
+    open?: boolean;
+    /** Notifica el cambio de estado del menú. */
+    onOpenChange?: (open: boolean) => void;
+    /** Índice del sitio dentro del panel: normalmente un `SiteNav`. */
+    children?: ReactNode;
+    /** Ajustes del sitio al final del panel (el selector de tema). */
+    settings?: ReactNode;
+    /** id del panel — `aria-controls` del botón de menú. */
+    panelId?: string;
+    /** Controles del producto en la barra (acceso, CTA…). */
+    actions?: ReactNode;
+    /** El selector de idioma (`LanguageSwitcher` compacto): en los ajustes del panel, delante del tema. */
+    language?: ReactNode;
+}
+/**
+ * Cabecera de las páginas públicas: logotipo, controles del producto y botón
+ * de menú: la barra se monta a sangre —el fondo llega de lado a lado y el
+ * alto es suyo (`--site-header-height`, más compacto en móvil)— con el
+ * contenido acotado por su `Container` interior. El
+ * menú es siempre un panel a pantalla completa bajo la barra —no hay
+ * navegación en línea— con el índice del sitio y, al final, sus ajustes.
+ * El enlace de salto al contenido no va aquí: lo pone `AppRoot`, una vez por
+ * documento.
+ */
+export declare function SiteHeader({ logoHref, logoLabel, menuLabel, menuCloseLabel, logoSize, logo, menuButtonSize, renderLogoLink, width, open, onOpenChange, children, settings, panelId, actions, language, }: SiteHeaderProps): import("react/jsx-runtime").JSX.Element;

package/dist/_types/sections/SiteShell/SiteShell.d.ts

@@ -0,0 +1,26 @@
+import { type ReactNode } from 'react';
+import './SiteShell.css';
+export interface SiteShellProps {
+    /** La cabecera del sitio (`SiteHeader` o la del producto). */
+    header?: ReactNode;
+    /** El pie (`LegalFooter`, el del producto…). Siempre queda abajo del todo. */
+    footer?: ReactNode;
+    /** El contenido de la página: normalmente el `main` con `id="main-content"`. */
+    children?: ReactNode;
+    className?: string;
+}
+/**
+ * El marco de una página pública: cabecera, contenido y pie en columna,
+ * con la altura mínima de la pantalla. Con poco contenido, el pie se queda
+ * pegado al borde inferior; con mucho, la página entera hace scroll. Es la
+ * norma del sistema: ningún producto necesita CSS propio para sujetar el pie.
+ * Para las aplicaciones con barra y sidebar está `AppShell`.
+ */
+/**
+ * Reenvía el `ref` al nodo raíz (`.site-shell`): un `Modal`/`Sheet` abierto
+ * desde dentro necesita apuntar su `container` aquí para heredar los tokens
+ * de la superficie pública — el portal por defecto monta en `document.body`,
+ * que no es descendiente de `.site-shell` (a diferencia del tema oscuro, que
+ * se activa en `<html>` y sí llega a cualquier portal sin configuración).
+ */
+export declare const SiteShell: import("react").ForwardRefExoticComponent<SiteShellProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/_types/templates/ChatShell/ChatShell.d.ts

@@ -0,0 +1,53 @@
+import { type ReactNode } from 'react';
+import './ChatShell.css';
+export interface ChatShellProps extends React.ComponentPropsWithoutRef<'div'> {
+    /**
+     * La columna de conversaciones, normalmente un `ConversationList`. Sin ella,
+     * el armazón es solo hilo y composer — que es como se monta dentro de un
+     * `AppShell`, donde la columna vive en el `Sidebar`.
+     *
+     * Por debajo del punto de ruptura no desaparece ni se encoge: se pliega a un
+     * cajón (`Sheet`) que abre un botón en la cabecera.
+     */
+    list?: ReactNode;
+    /** La cabecera del hilo: el título de la conversación y sus controles. */
+    header?: ReactNode;
+    /** El hilo: un `ConversationThread`. */
+    children: ReactNode;
+    /** La caja de escribir: un `MessageComposer`. */
+    composer?: ReactNode;
+    /**
+     * `aria-label` de la columna de conversaciones y título del cajón en
+     * pantallas estrechas. Default: "Conversaciones" (castellano). Solo se usa
+     * si hay `list`.
+     */
+    listLabel?: string;
+    /**
+     * Nombre accesible del botón que abre el cajón de conversaciones. Default:
+     * "Abrir conversaciones" (castellano).
+     */
+    listTriggerLabel?: string;
+    /**
+     * Estado controlado del cajón de conversaciones. Sin él, el armazón lo lleva
+     * por dentro; con él, el producto puede cerrarlo al abrir una conversación.
+     * En escritorio no se usa: ahí la lista es columna y siempre está a la vista.
+     */
+    listOpen?: boolean;
+    /** Avisa de cada apertura y cierre del cajón de conversaciones. */
+    onListOpenChange?: (open: boolean) => void;
+    /** Se añade DESPUÉS de las clases propias del componente (el consumidor añade, no sustituye). */
+    className?: string;
+}
+/**
+ * El armazón de una pantalla de chat: tres zonas —la columna de
+ * conversaciones, el hilo y la caja de escribir— colocadas y con el scroll en
+ * el sitio correcto.
+ *
+ * Es **solo maqueta**: no lleva estado de producto ni sabe nada de mensajes.
+ * Quién habla, qué se manda y qué conversación está abierta lo lleva el
+ * producto y entra por los slots. Lo único que sí lleva es el cajón de
+ * conversaciones de las pantallas estrechas, que es maqueta también.
+ *
+ * Reenvía el resto de props del `<div>` (`data-*`, `id`…) y el `ref`.
+ */
+export declare const ChatShell: import("react").ForwardRefExoticComponent<ChatShellProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/_types/templates/ConnectorAuth/ConnectorAuthShell.d.ts

@@ -0,0 +1,73 @@
+import { type ReactNode } from 'react';
+/**
+ * El chrome que las cuatro pantallas del conector reenvían al marco público.
+ * Va aparte para que cada plantilla lo extienda sin volver a escribirlo: son
+ * las mismas ranuras que ya tiene `PublicPageShell`, ni una más.
+ *
+ * Quien cablee estas pantallas **tiene que rellenarlas**. El servidor de
+ * autorización sirve el consentimiento fuera de la aplicación —sin su chasis—,
+ * así que la cabecera pública, el pie legal y la banda de preferencias no le
+ * llegan de ningún layout: entran por aquí o no existen.
+ */
+export interface ConnectorAuthChromeProps {
+    /** Cabecera pública (`SiteHeader`). Va dentro de un `ErrorBoundary` del marco. */
+    header?: ReactNode;
+    /** Pie legal (`LegalFooter`). Ídem. */
+    footer?: ReactNode;
+    /**
+     * Idioma y tema, en la banda de preferencias del marco. En estas pantallas
+     * el idioma no es un adorno: el servidor de autorización lo saca de la
+     * cookie `NEXT_LOCALE` o de `Accept-Language`, y quien llegue en el idioma
+     * equivocado necesita poder cambiarlo **aquí**, porque no hay ninguna otra
+     * pantalla de la suite alrededor donde hacerlo.
+     */
+    preferences?: ReactNode;
+    /** Nombre accesible de la banda de preferencias. Default castellano: «Preferencias». */
+    preferencesLabel?: string;
+    /** `id` del `main` (`main-content` por defecto, destino del `SkipLink`). */
+    id?: string;
+    /**
+     * Con `false` no monta el marco público ni el `main`: solo las dos columnas,
+     * para pintarlas dentro de una aplicación que ya tiene su `main`. Por
+     * defecto `true`. Sin marco, `header`, `footer`, `preferences` e `id` no
+     * aplican —ni el `ref`, porque no hay marco al que engancharlo.
+     */
+    shell?: boolean;
+}
+export interface ConnectorAuthShellProps extends ConnectorAuthChromeProps {
+    /** El título de la pantalla: `Heading` de nivel 1 vía `PageIntro`, columna izquierda. */
+    title: ReactNode;
+    /** La frase bajo el título, columna izquierda. Es una frase y termina en punto. */
+    description?: ReactNode;
+    /** Más texto bajo la frase, misma columna. */
+    intro?: ReactNode;
+    /** Bajo la cabecera, en su misma columna: un enlace de vuelta. El aire lo pone el `PageIntro`. */
+    aside?: ReactNode;
+    /** La columna de la derecha: la decisión —el formulario, la ficha, los botones—. */
+    children: ReactNode;
+    /** Se añade DESPUÉS de las clases propias. */
+    className?: string;
+}
+/**
+ * El marco de las pantallas del conector: **el mismo que el de acceso**.
+ *
+ * Conectar una herramienta es una pantalla pública de una sola decisión, de la
+ * familia de iniciar sesión, recuperar la contraseña o verificar el correo:
+ * cuelga de `PublicPageShell` —cabecera pública, `main` acotado, banda de
+ * preferencias y pie legal—, se maqueta en dos columnas (`Columns`, la
+ * cabecera a la izquierda y la decisión a la derecha) y reparte talla `lg` a
+ * todo lo que lleve dentro, que es la talla de la superficie pública. Ninguna
+ * de las cuatro pantallas inventa su propio contenedor.
+ *
+ * La consecuencia de esa decisión es de cableado, no de diseño: el servidor de
+ * autorización **sirve el consentimiento fuera de la aplicación**, así que
+ * quien lo monte tiene que pasar el chrome por props (`header`, `footer`,
+ * `preferences`) — no le va a llegar de ningún layout. Por eso las ranuras
+ * están en la plantilla y no dentro de ella.
+ *
+ * **Reenvía el `ref` al nodo del marco** (`.site-shell`), que es el
+ * `container` que pide un panel flotante abierto desde la página (el de
+ * cookies, un `Modal`): su portal monta en `document.body`, que no hereda el
+ * remapeo de superficie pública.
+ */
+export declare const ConnectorAuthShell: import("react").ForwardRefExoticComponent<ConnectorAuthShellProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/_types/templates/ConnectorAuth/ConnectorConsentPage.d.ts

@@ -0,0 +1,129 @@
+import type { ReactNode } from 'react';
+import { type ConnectorAuthChromeProps } from './ConnectorAuthShell';
+import { ConnectorRequestSummary, type ConnectorScope } from './ConnectorRequestSummary';
+export interface ConnectorConsentPageProps extends ConnectorAuthChromeProps {
+    /** El nombre con el que la herramienta se registró. **Dato de fuera**: ver `ConnectorRequestSummary`. */
+    clientName: string;
+    /** El producto de la suite al que se pide acceso. */
+    productName?: ReactNode;
+    /** La cuenta con la que se está decidiendo. */
+    accountEmail: string;
+    /** Qué se concede. Default: `'read'`. */
+    scope?: ConnectorScope;
+    /** El host al que se enviará el acceso, sacado del `redirect_uri` ya validado. */
+    redirectHost: string;
+    /**
+     * Destino del envío nativo. **Con `action` la pantalla funciona sin una
+     * línea de JavaScript**: el bloque de decisión es un `<form method="post">`
+     * de verdad y los dos botones son `submit`. Es el modo que necesita el
+     * servidor de autorización, que la sirve con
+     * `Content-Security-Policy: default-src 'none'` —ni un script, ni una hoja
+     * de estilos externa— y por tanto no puede depender de un `onClick`.
+     *
+     * Sin `action`, los botones son botones y la decisión sale por `onApprove` /
+     * `onDeny`: el modo de montarla dentro de una aplicación React.
+     */
+    action?: string | ((formData: FormData) => void | Promise<void>);
+    /**
+     * Los parámetros de OAuth que tienen que viajar con la decisión —`client_id`,
+     * `redirect_uri`, `code_challenge`, `state`, `scope`, `consent_nonce`—, como
+     * `<input type="hidden">`. Son **datos en tránsito, no interfaz**: la
+     * plantilla no los lee ni los valida, solo los devuelve intactos.
+     */
+    hiddenFields?: Record<string, string>;
+    /** Nombre del campo que distingue la decisión en el envío nativo. Default: `'decision'`. */
+    decisionName?: string;
+    /** Valor que envía el botón de permitir. Default: `'approve'`. */
+    approveValue?: string;
+    /** Valor que envía el botón de denegar. Default: `'deny'`. */
+    denyValue?: string;
+    /** La decisión afirmativa, en modo React (sin `action`). */
+    onApprove?: () => void;
+    /** La negativa, en modo React (sin `action`). */
+    onDeny?: () => void;
+    /**
+     * Denegar como enlace en vez de como envío: la vuelta a la herramienta con
+     * `error=access_denied`, ya compuesta por el servidor. Manda sobre
+     * `onDeny` y sobre el envío nativo.
+     */
+    denyHref?: string;
+    /**
+     * Dónde empieza el foco. Default `'none'`: **la pantalla no enfoca nada**, y
+     * el primer tabulador cae en denegar porque es el primero del DOM. Con
+     * `'deny'` se enfoca denegar al cargar. Permitir no es una opción, y no se
+     * va a añadir: conceder acceso no puede estar a un Intro de distancia de
+     * abrir la página.
+     */
+    initialFocus?: 'none' | 'deny';
+    /** Título de la pantalla. Default castellano: «Conectar una herramienta». */
+    title?: ReactNode;
+    /**
+     * La frase de la cabecera. Recibe las tres piezas ya compuestas —la
+     * herramienta y la cuenta en negrita, el permiso en texto corriente— porque
+     * el orden cambia con el idioma (en alemán la cuenta va antes del permiso).
+     * Default castellano.
+     */
+    intro?: (parts: {
+        client: ReactNode;
+        what: ReactNode;
+        email: ReactNode;
+    }) => ReactNode;
+    /**
+     * El aviso de a dónde se enviará el acceso, bajo la ficha. Recibe el host ya
+     * en negrita. Va a tamaño de cuerpo, no de nota al pie: es la señal que
+     * convierte una suplantación en visible y no puede leerse como letra
+     * pequeña. Default castellano.
+     */
+    redirectNotice?: (parts: {
+        host: ReactNode;
+    }) => ReactNode;
+    /** Etiqueta del botón que concede. Default castellano: «Permitir acceso». */
+    approveLabel?: string;
+    /** Etiqueta del botón que deniega. Default castellano: «Denegar». */
+    denyLabel?: string;
+    /** Alcance en texto, para la frase y para la ficha. Default castellano. */
+    scopeReadLabel?: string;
+    /** Ídem, lectura y escritura. Default castellano. */
+    scopeWriteLabel?: string;
+    /** Etiqueta del desplegador de un valor de fuera recortado. Default castellano: «Ver el valor completo». */
+    expandLabel?: string;
+    /** Etiqueta del desplegador abierto. Default castellano: «Ver menos». */
+    collapseLabel?: string;
+    /**
+     * Las comillas que enmarcan los datos de fuera —la herramienta, la cuenta, el
+     * host—, aquí y en la ficha. Default castellano: `['«', '»']`.
+     */
+    valueQuotes?: [string, string];
+    /** Rótulos de la ficha. Ver `ConnectorRequestSummary`. */
+    summaryLabels?: Pick<React.ComponentProps<typeof ConnectorRequestSummary>, 'clientLabel' | 'productLabel' | 'accountLabel' | 'scopeLabel' | 'redirectLabel'>;
+    /** Bajo las acciones: un enlace de ayuda, la política de la suite. Se pinta en `links` del `Form`. */
+    links?: ReactNode;
+}
+/**
+ * **La pantalla principal del flujo**: una herramienta pide acceso a un
+ * producto de la suite y hay que concederlo o denegarlo.
+ *
+ * La cabecera cuenta la petición en una frase; la columna de la decisión la
+ * repite como ficha verificable (`ConnectorRequestSummary`), avisa de a dónde
+ * saldrá el acceso y ofrece las dos salidas. Nada más: no hay recordar la
+ * decisión, ni elegir alcance a la carta, ni ver qué se llevó la última vez.
+ * Una pantalla de una sola decisión.
+ *
+ * ### Las dos acciones
+ *
+ * Denegar va **primera en el DOM** y permitir después, como el `Cancelar` de
+ * un diálogo del sistema: el recorrido del teclado abre por la salida segura.
+ * Visualmente permitir es la principal —es la que ejecuta— y denegar va en
+ * `outline`; apiladas (`blockActions`, como el resto de la familia de acceso)
+ * permitir queda arriba, que es donde el pulgar espera la acción del
+ * formulario. Lo que **no** pasa en ninguna talla es que conceder acceso se
+ * lleve el foco al cargar: ver `initialFocus`.
+ *
+ * ### Sin JavaScript
+ *
+ * Con `action` la pantalla es un formulario nativo y funciona con los scripts
+ * desactivados, que es como la sirve hoy el servidor de autorización. Sin
+ * `action` es una pantalla de React con dos callbacks. Las dos formas pintan
+ * exactamente lo mismo.
+ */
+export declare function ConnectorConsentPage({ clientName, productName, accountEmail, scope, redirectHost, action, hiddenFields, decisionName, approveValue, denyValue, onApprove, onDeny, denyHref, initialFocus, title, intro, redirectNotice, approveLabel, denyLabel, scopeReadLabel, scopeWriteLabel, expandLabel, collapseLabel, valueQuotes, summaryLabels, links, header, footer, preferences, preferencesLabel, id, shell, }: ConnectorConsentPageProps): import("react/jsx-runtime").JSX.Element;

package/dist/_types/templates/ConnectorAuth/ConnectorExternalSignInPage.d.ts

@@ -0,0 +1,87 @@
+import type { ReactNode } from 'react';
+import { type ConnectorAuthChromeProps } from './ConnectorAuthShell';
+export interface ConnectorExternalSignInPageProps extends ConnectorAuthChromeProps {
+    /**
+     * Cómo se llama la instalación de la que es el conector, para la frase y
+     * para el botón. Default castellano: «tu Moodle», que hoy es el único
+     * conector de esta forma; cambiarlo sirve a cualquier otra instalación
+     * ajena a la suite.
+     */
+    platformName?: ReactNode;
+    /**
+     * La organización a la que se va a entrar, **ya resuelta**: el conector vive
+     * en un subdominio y el servidor la saca del `resource` de la petición. Con
+     * ella, la pantalla solo la confirma. Sin ella pinta el campo para
+     * escribirla, que es el caso de una conexión al dominio pelado.
+     */
+    organization?: ReactNode;
+    /** Valor inicial del campo de organización, cuando hay que escribirla. */
+    organizationDefaultValue?: string;
+    /** `name` del campo de organización en el envío. Default: `'org'`. */
+    organizationName?: string;
+    /**
+     * Destino del envío. Una URL, o la acción de servidor que arranca el salto a
+     * la instalación: el `<form>` de React 19 acepta las dos, y el flujo de
+     * lmsmcp necesita la segunda (2026-09-14).
+     */
+    action?: string | ((formData: FormData) => void | Promise<void>);
+    /** El envío, en modo React (sin `action`). */
+    onSubmit?: React.FormEventHandler<HTMLFormElement>;
+    /** Los parámetros de OAuth que tienen que sobrevivir al salto, como `<input type="hidden">`. */
+    hiddenFields?: Record<string, string>;
+    /** Un fallo del intento anterior —«no hay ninguna conexión para esa organización»—, sobre el formulario. */
+    error?: ReactNode;
+    /** Título de la pantalla. Default castellano: «Autorizar la conexión». */
+    title?: ReactNode;
+    /** La frase de la cabecera. Recibe el nombre de la instalación. Default castellano. */
+    intro?: (parts: {
+        platform: ReactNode;
+    }) => ReactNode;
+    /** La frase que confirma a dónde se entra, con `organization`. Default castellano. */
+    signingInTo?: (parts: {
+        organization: ReactNode;
+    }) => ReactNode;
+    /**
+     * Las comillas que enmarcan la organización en la frase de confirmación:
+     * viene de la petición, así que es dato de fuera y se pinta como tal. Default
+     * castellano: `['«', '»']`.
+     */
+    valueQuotes?: [string, string];
+    /** Etiqueta del campo de organización. Default castellano: «Tu organización». */
+    organizationLabel?: string;
+    /** Etiqueta de la acción. Recibe el nombre de la instalación. Default castellano. */
+    submitLabel?: (parts: {
+        platform: ReactNode;
+    }) => ReactNode;
+    /**
+     * Debajo del formulario: lo que no es del sistema de diseño. Es la ranura
+     * donde el producto cuelga su andamio de desarrollo —pegar una clave de MCP,
+     * detrás de un `Accordion`— sin que el DS tenga que conocerlo.
+     */
+    extra?: ReactNode;
+    /** Bajo la acción: ayuda, un enlace de vuelta. Se pinta en `links` del `Form`. */
+    links?: ReactNode;
+}
+/**
+ * **El caso del conector de Moodle**, que no se parece a los otros tres y por
+ * eso tiene pantalla propia.
+ *
+ * En los conectores de la suite, quien concede es la suite: hay sesión, hay
+ * consentimiento y el acceso sale de aquí. En el de Moodle **el conector es de
+ * la instalación del cliente**, así que no hay nada que consentir en la suite:
+ * la pantalla solo confirma a qué organización se entra y manda a
+ * identificarse a su Moodle, que es quien decide. De ahí que no lleve ni ficha
+ * de permisos ni botón de denegar — denegar, aquí, es no seguir.
+ *
+ * Es la única de la familia que **pide un dato**: cuando la organización no
+ * viene en la petición (una conexión al dominio pelado), hay que escribirla.
+ * Con la organización resuelta, el campo desaparece y queda una frase de
+ * confirmación: la pantalla no pregunta lo que ya sabe.
+ *
+ * Lleva el marco y la talla del resto de la familia —`PublicPageShell`, dos
+ * columnas, controles `lg`—, que es lo que hace que las dos familias de
+ * conector se lean como hermanas. En el producto esta pantalla vive hoy en una
+ * `Card` dentro de una columna estrecha, sin cabecera pública ni pie: al
+ * cablearla, ese molde propio se retira y lo pone la plantilla.
+ */
+export declare function ConnectorExternalSignInPage({ platformName, organization, organizationDefaultValue, organizationName, action, onSubmit, hiddenFields, error, title, intro, signingInTo, valueQuotes, organizationLabel, submitLabel, extra, links, header, footer, preferences, preferencesLabel, id, shell, }: ConnectorExternalSignInPageProps): import("react/jsx-runtime").JSX.Element;

package/dist/_types/templates/ConnectorAuth/ConnectorRejectionPage.d.ts

@@ -0,0 +1,69 @@
+import type { ReactNode } from 'react';
+import { type ConnectorAuthChromeProps } from './ConnectorAuthShell';
+/**
+ * Por qué no se ha conectado nada. Son los cinco errores que el servidor de
+ * autorización devuelve hoy en crudo —`invalid_client`,
+ * `invalid_redirect_uri`, `access_denied`, `invalid_request`,
+ * `login_required`—, uno por uno y con el nombre que entiende quien los lee.
+ */
+export type ConnectorRejectionReason = 'invalid-client' | 'invalid-redirect-uri' | 'invalid-request' | 'access-denied' | 'session-expired';
+export interface ConnectorRejectionPageProps extends ConnectorAuthChromeProps {
+    /** Por qué no se ha conectado nada. De él salen el título, la explicación y el texto de la salida. */
+    reason: ConnectorRejectionReason;
+    /** Título, si el producto quiere el suyo. Default: el de la variante, en castellano. */
+    title?: ReactNode;
+    /** La frase bajo el título. Default: la de la variante, en castellano. */
+    description?: ReactNode;
+    /** Qué se puede hacer, en la columna de la derecha. Default: el de la variante, en castellano. */
+    hint?: ReactNode;
+    /**
+     * El código técnico tal cual lo devuelve el servidor (`invalid_client`…),
+     * bajo la explicación. No es para quien lee la pantalla: es para que pueda
+     * copiarlo en un correo a soporte sin tener que describir el error con sus
+     * palabras. Sin él, no se pinta.
+     */
+    code?: string;
+    /** Rótulo del código. Default castellano: «Código». */
+    codeLabel?: string;
+    /** La salida, como enlace: la vuelta a la herramienta o al acceso. */
+    retryHref?: string;
+    /** La salida, en modo React (sin `retryHref`). */
+    onRetry?: () => void;
+    /** Etiqueta de la salida. Default: la de la variante, en castellano. */
+    retryLabel?: string;
+    /**
+     * La salida entera, ya montada, cuando no basta con un botón (el `Link` del
+     * router, dos acciones). Manda sobre `retryHref` / `onRetry`.
+     */
+    retryAction?: ReactNode;
+    /** Bajo la cabecera, en su columna: un enlace de vuelta al producto. */
+    aside?: ReactNode;
+}
+/**
+ * **Una sola plantilla para los cinco rechazos**, que hoy son cinco respuestas
+ * JSON en crudo sin ninguna pantalla detrás.
+ *
+ * Son cinco variantes y no cinco plantillas porque lo único que cambia entre
+ * ellas es el texto. La maqueta es idéntica —la explicación a la izquierda, qué
+ * hacer y la salida a la derecha—, y sobre todo lo es la postura: **ninguna
+ * ofrece reintentar en el sitio**. Ni un botón que repita la petición ni un
+ * formulario que la arregle; la conexión se empieza donde se empezó, en la
+ * herramienta. Un rechazo de autorización que se pueda reintentar a golpes
+ * desde la propia pantalla de rechazo es un fallo de seguridad, no una
+ * comodidad, y por eso la salida por defecto es «volver» y no «reintentar».
+ *
+ * Los cinco se agrupan en tres causas, y el texto de cada uno lo dice sin
+ * jerga:
+ *
+ * | Causa | Variantes | Qué se le ofrece |
+ * | --- | --- | --- |
+ * | La petición no vale | `invalid-client`, `invalid-redirect-uri`, `invalid-request` | Volver a la herramienta: el arreglo está allí |
+ * | No se ha concedido | `access-denied` | Cerrar, o pedir la conexión otra vez |
+ * | La sesión se ha acabado | `session-expired` | Identificarse y repetir |
+ *
+ * No lleva `Alert` ni color de error. Un rechazo aquí no es un fallo del
+ * sistema del que avisar: es el resultado normal de una comprobación que ha
+ * hecho su trabajo —y en `access-denied`, ni siquiera eso: es lo que se ha
+ * pedido—. La página lo cuenta como cuenta cualquier otra cosa.
+ */
+export declare function ConnectorRejectionPage({ reason, title, description, hint, code, codeLabel, retryHref, onRetry, retryLabel, retryAction, aside, header, footer, preferences, preferencesLabel, id, shell, }: ConnectorRejectionPageProps): import("react/jsx-runtime").JSX.Element;

package/dist/_types/templates/ConnectorAuth/ConnectorRequestSummary.d.ts

@@ -0,0 +1,74 @@
+import type { ReactNode } from 'react';
+import './ConnectorRequestSummary.css';
+/** Qué se le concede al conector: leer, o leer y modificar. Son los dos únicos alcances que emite el servidor de autorización (`mcp:read` y `mcp:write`). */
+export type ConnectorScope = 'read' | 'write';
+export interface ConnectorRequestSummaryProps {
+    /**
+     * El nombre con el que la herramienta se registró.
+     *
+     * **Es dato de quien registró el cliente, no de la suite.** El registro es
+     * abierto: cualquiera puede darse de alta con el nombre que quiera, así que
+     * un «Claude» falso es indistinguible del real. Pásalo como **cadena**: así
+     * lo pinta `UntrustedText` —texto plano entrecomillado, con los caracteres
+     * invisibles a la vista, aislado de dirección y recortado si es larguísimo—.
+     * Un `ReactNode` se pinta tal cual, sin ese tratamiento, porque ya no es
+     * texto de fuera sino algo que compusiste tú. Nunca lo pases por
+     * `dangerouslySetInnerHTML` ni lo uses para componer una URL.
+     */
+    clientName: ReactNode;
+    /** El producto de la suite al que se pide acceso: bricks, lmsmcp, lrs, sharescorm, tender. */
+    productName?: ReactNode;
+    /** La cuenta con la que se está decidiendo. Sin sesión —la pantalla de identificarse— no se pasa. */
+    accountEmail?: ReactNode;
+    /** El alcance concedido. Sin él, la fila no se pinta. */
+    scope?: ConnectorScope;
+    /**
+     * El host al que se enviará el acceso, sacado del `redirect_uri` ya validado
+     * contra lo registrado.
+     *
+     * **Es la única parte de la ficha que quien ataca NO elige**, y por eso está
+     * aquí y no en un párrafo suelto: el nombre lo puso quien registró, el host
+     * lo impone el registro.
+     */
+    redirectHost?: ReactNode;
+    /** Rótulo de la herramienta. Default castellano: «Herramienta». */
+    clientLabel?: string;
+    /** Rótulo del producto. Default castellano: «Producto». */
+    productLabel?: string;
+    /** Rótulo de la cuenta. Default castellano: «Cuenta». */
+    accountLabel?: string;
+    /** Rótulo del permiso. Default castellano: «Permiso». */
+    scopeLabel?: string;
+    /** Rótulo del destino. Default castellano: «Destino». */
+    redirectLabel?: string;
+    /** Valor del permiso de solo lectura. Default castellano, el del servidor de autorización. */
+    scopeReadLabel?: ReactNode;
+    /** Valor del permiso de lectura y escritura. Default castellano, el del servidor de autorización. */
+    scopeWriteLabel?: ReactNode;
+    /** Etiqueta del desplegador de un valor recortado. Default castellano: «Ver el valor completo». */
+    expandLabel?: string;
+    /** Etiqueta del desplegador abierto. Default castellano: «Ver menos». */
+    collapseLabel?: string;
+    /** Las comillas que enmarcan los valores de fuera. Default castellano: `['«', '»']`. */
+    valueQuotes?: [string, string];
+    /** Se añade DESPUÉS de las clases propias. */
+    className?: string;
+}
+/**
+ * La ficha de la petición: los cinco hechos que hay que mirar antes de
+ * conceder nada —qué herramienta, a qué producto, con qué cuenta, con qué
+ * permiso y a dónde va el acceso—, en una `DescriptionList`.
+ *
+ * Es una **lista de datos, no una frase**, a propósito. La frase de la
+ * cabecera («X quiere leer los datos de este producto como tú@ejemplo.com»)
+ * se lee de corrido y se cree entera; una ficha obliga a que cada dato tenga
+ * su rótulo y se pueda comparar con lo que uno esperaba. Los dos textos dicen
+ * lo mismo y conviven: la frase explica, la ficha verifica.
+ *
+ * Los tres valores que vienen de fuera —el nombre de la herramienta, la cuenta
+ * y el host— pasan por `UntrustedText`: texto plano entrecomillado, con los
+ * caracteres invisibles a la vista, aislados de dirección y recortados con
+ * desplegador si son larguísimos. Ver ahí el porqué de cada una de las tres
+ * cosas.
+ */
+export declare function ConnectorRequestSummary({ clientName, productName, accountEmail, scope, redirectHost, clientLabel, productLabel, accountLabel, scopeLabel, redirectLabel, scopeReadLabel, scopeWriteLabel, expandLabel, collapseLabel, valueQuotes, className, }: ConnectorRequestSummaryProps): import("react/jsx-runtime").JSX.Element;

package/dist/_types/templates/ConnectorAuth/ConnectorSignInPage.d.ts

@@ -0,0 +1,69 @@
+import type { ReactNode } from 'react';
+import { type ConnectorAuthChromeProps } from './ConnectorAuthShell';
+import { ConnectorRequestSummary, type ConnectorScope } from './ConnectorRequestSummary';
+export interface ConnectorSignInPageProps extends ConnectorAuthChromeProps {
+    /** El nombre con el que la herramienta se registró. **Dato de fuera**: ver `ConnectorRequestSummary`. */
+    clientName: string;
+    /** El producto de la suite al que se pide acceso. */
+    productName?: ReactNode;
+    /** Qué pide la herramienta. Se enseña ya aquí: quien se identifica tiene derecho a saber para qué. */
+    scope?: ConnectorScope;
+    /** El host al que se enviaría el acceso. */
+    redirectHost?: string;
+    /**
+     * A dónde se va a identificar: el acceso de la suite, con la vuelta a esta
+     * misma petición ya compuesta por el servidor. Con él, la acción es un
+     * enlace y la pantalla **no necesita JavaScript**.
+     */
+    signInHref?: string;
+    /** La acción, en modo React (sin `signInHref`). */
+    onSignIn?: () => void;
+    /** Destino del envío nativo, para reanudar la petición por POST en vez de por enlace. */
+    action?: string;
+    /** Los parámetros de OAuth que tienen que sobrevivir al acceso, como `<input type="hidden">`. */
+    hiddenFields?: Record<string, string>;
+    /** Título de la pantalla. Default castellano. */
+    title?: ReactNode;
+    /**
+     * La frase de la cabecera. Recibe la herramienta y el producto ya
+     * compuestos. Default castellano.
+     */
+    intro?: (parts: {
+        client: ReactNode;
+        product: ReactNode;
+    }) => ReactNode;
+    /** Nombre del producto cuando no se pasa `productName`, para la frase. Default castellano: «este producto». */
+    fallbackProductName?: ReactNode;
+    /** Etiqueta de la acción. Default castellano: «Iniciar sesión». */
+    signInLabel?: string;
+    /** Alcance en texto. Default castellano. */
+    scopeReadLabel?: string;
+    /** Ídem, lectura y escritura. Default castellano. */
+    scopeWriteLabel?: string;
+    /** Etiqueta del desplegador de un valor de fuera recortado. Default castellano: «Ver el valor completo». */
+    expandLabel?: string;
+    /** Etiqueta del desplegador abierto. Default castellano: «Ver menos». */
+    collapseLabel?: string;
+    /** Las comillas que enmarcan los datos de fuera. Default castellano: `['«', '»']`. */
+    valueQuotes?: [string, string];
+    /** Rótulos de la ficha. Ver `ConnectorRequestSummary`. */
+    summaryLabels?: Pick<React.ComponentProps<typeof ConnectorRequestSummary>, 'clientLabel' | 'productLabel' | 'scopeLabel' | 'redirectLabel'>;
+    /** Bajo la acción: «¿No tienes cuenta?», ayuda. Se pinta en `links` del `Form`. */
+    links?: ReactNode;
+}
+/**
+ * Se ha llegado al conector **sin sesión**: no hay con qué cuenta conceder
+ * nada, así que primero hay que identificarse y luego se vuelve a la pantalla
+ * de consentimiento.
+ *
+ * Enseña ya la ficha de la petición —menos la cuenta, que es justo lo que
+ * falta—. Es deliberado: quien va a teclear una contraseña tiene derecho a
+ * saber antes qué herramienta está detrás y a dónde va a salir el acceso, y no
+ * enterarse dos pantallas más tarde. Y no concede nada: la única acción es
+ * identificarse, así que aquí sí es la principal y puede llevarse el foco.
+ *
+ * Es la pantalla que hoy no existe —el servidor redirige directamente al
+ * refresco de sesión del hub— y la que hace falta en cuanto la vuelta falla o
+ * el usuario se planta en medio del camino.
+ */
+export declare function ConnectorSignInPage({ clientName, productName, scope, redirectHost, signInHref, onSignIn, action, hiddenFields, title, intro, fallbackProductName, signInLabel, scopeReadLabel, scopeWriteLabel, expandLabel, collapseLabel, valueQuotes, summaryLabels, links, header, footer, preferences, preferencesLabel, id, shell, }: ConnectorSignInPageProps): import("react/jsx-runtime").JSX.Element;