@gyramais/gyra-design 0.2.48 → 0.2.50

package/dist/emails/balance-sheet-finalized/components/Button/Button.d.ts

@@ -12,6 +12,13 @@ export type ButtonProps = {
     loading?: boolean;
     icon?: React.ReactNode;
     fab?: boolean;
+    /**
+     * Nome do botao. Botao SO de icone nao tem texto para o leitor de tela
+     * anunciar nem dica para o mouse: sem um destes dois, ele e anunciado como
+     * "botao" e nada mais. Os dois chegam ao `<button>` pelo spread.
+     */
+    title?: string;
+    "aria-label"?: string;
     onClick?: (event: React.MouseEvent<HTMLButtonElement, MouseEvent>) => void;
     children?: React.ReactNode;
 };

package/dist/emails/balance-sheet-finalized/components/Card/Card.d.ts

@@ -15,12 +15,6 @@ type CardProps = {
     media?: React.ReactNode;
     disabled?: boolean;
     loading?: boolean;
-    /**
-     * Placeholder exibido no lugar do conteudo enquanto `loading`. O padrao e um
-     * skeleton de linhas de texto; passe um skeleton com a forma do conteudo real
-     * (grafico, tabela, lista) quando isso ajudar a evitar o pulo de layout.
-     */
-    loadingContent?: React.ReactNode;
     collapsible?: boolean;
     defaultCollapsed?: boolean;
     collapsed?: boolean;
@@ -29,5 +23,5 @@ type CardProps = {
     headerContent?: React.ReactNode;
     children?: React.ReactNode;
 };
-declare const Card: ({ id, type, className, title, subtitle, media, disabled, loading, loadingContent, collapsible, defaultCollapsed, collapsed, onCollapse, onClick, headerContent, children, }: CardProps) => React.JSX.Element;
+declare const Card: ({ id, type, className, title, subtitle, media, disabled, loading, collapsible, defaultCollapsed, collapsed, onCollapse, onClick, headerContent, children, }: CardProps) => React.JSX.Element;
 export { Card };

package/dist/emails/balance-sheet-finalized/components/Drawer/Drawer.d.ts

@@ -10,7 +10,31 @@ type DrawerProps = {
     onClose?: () => void;
     direction?: "left" | "top" | "right" | "bottom";
     width?: number | string;
+    /**
+     * Escape fecha a gaveta (chama `onClose`). Default: true. Nao vale quando
+     * `closable` e false. Um Escape que outra camada ja consumiu (menu de
+     * Select, Popover, SegmentedPicker, Modal) nao chega aqui: cada camada
+     * fecha a sua e a gaveta fica.
+     */
+    closeOnEscape?: boolean;
+    /**
+     * Prende o Tab dentro do painel enquanto a gaveta esta aberta. Default:
+     * true. Conteudo portalado para o `body` (menu do Select, Popover,
+     * SegmentedPicker, Modal, outra gaveta) continua alcancavel: o trap so
+     * age quando o foco esta no painel ou na borda de um desses portais.
+     */
+    trapFocus?: boolean;
+    /**
+     * Ao abrir, move o foco para dentro do painel (o proprio painel, ou
+     * `initialFocusRef`) e o devolve a quem o tinha ao fechar. Default: true.
+     */
+    autoFocus?: boolean;
+    /** Elemento que recebe o foco inicial em vez do painel. */
+    initialFocusRef?: React.RefObject<HTMLElement>;
+    /** Rotulo acessivel quando `title` nao e texto ou nao existe. */
+    ariaLabel?: string;
     children?: React.ReactNode;
 };
-declare const Drawer: ({ className, title, subtitle, footer, visible, closable, onClose, direction, width, children, }: DrawerProps) => React.JSX.Element;
+declare const Drawer: ({ className, title, subtitle, footer, visible, closable, onClose, direction, width, closeOnEscape, trapFocus, autoFocus, initialFocusRef, ariaLabel, children, }: DrawerProps) => React.JSX.Element;
 export { Drawer };
+export type { DrawerProps };

package/dist/emails/balance-sheet-finalized/components/Empty/Empty.d.ts

@@ -3,25 +3,8 @@ import "./index.css";
 type EmptyProps = {
     id?: string;
     className?: string;
-    /**
-     * Ilustracao opcional. Use SO em zero state de pagina ou area inteira, do
-     * tipo "primeiro uso, ainda nao ha nada aqui", onde ela vem acompanhada de
-     * um titulo e de uma acao.
-     *
-     * Dentro de card ou de tabela de seção o padrao e' texto puro, sem grafico:
-     * a mesma ilustracao repetida dezenas de vezes na mesma pagina vira ruido e
-     * compete com o dado que importa. E' o que Stripe e Linear fazem em tabela.
-     */
     icon?: React.ReactNode;
     text?: string;
 };
-/**
- * Estado vazio: diz que nao ha nada ali, sem roubar a atencao do que ha.
- *
- * Discreto de proposito, em texto secundario. Uma lista vazia raramente e' o
- * assunto da tela, e num relatorio de credito ela costuma ate ser boa noticia
- * ("nenhuma sanção encontrada"), entao nao deve parecer erro nem falha de
- * carregamento.
- */
-declare const Empty: ({ id, className, icon, text }: EmptyProps) => React.JSX.Element;
+declare const Empty: ({ id, className, icon, text, }: EmptyProps) => React.JSX.Element;
 export { Empty };

package/dist/emails/balance-sheet-finalized/components/Modal/Modal.d.ts

@@ -19,7 +19,17 @@ type ModalProps = {
     };
     onClose?: () => void;
     width?: number;
+    /**
+     * Escape fecha o modal (chama `onClose`). Default: true. Nao vale com
+     * `loading`. As camadas descascam uma por vez: com a lista de um Select,
+     * um Popover ou qualquer gatilho `aria-expanded` aberto dentro do modal,
+     * o Escape e dessa camada e o modal fica; o Escape seguinte fecha o modal.
+     */
+    closeOnEscape?: boolean;
+    /** Rotulo acessivel quando `title` nao e texto ou nao existe. */
+    ariaLabel?: string;
     children?: React.ReactNode;
 };
-declare const Modal: ({ className, title, subtitle, footer, visible, loading, okButton, cancelButton, onClose, width, children, }: ModalProps) => React.JSX.Element;
+declare const Modal: ({ className, title, subtitle, footer, visible, loading, okButton, cancelButton, onClose, width, closeOnEscape, ariaLabel, children, }: ModalProps) => React.JSX.Element;
 export { Modal };
+export type { ModalProps };

package/dist/emails/balance-sheet-finalized/components/Popover/Popover.d.ts

@@ -6,11 +6,28 @@ type PopoverProps = {
     align?: "start" | "center" | "end";
     side?: "top" | "right" | "bottom" | "left";
     sideOffset?: number;
+    /** Folga minima entre o popover e a borda da janela. Default: 8. */
+    collisionPadding?: number;
     visible?: boolean;
     content: React.ReactNode;
     children?: React.ReactNode;
     onPointerDownOutside?: () => void;
     onOpenAutoFocus?: (event: Event) => void;
+    /**
+     * Avisa que o Radix quer abrir/fechar (clique no gatilho, clique fora,
+     * Escape). Sem isto, `visible` controlado nao tem como reagir ao Escape:
+     * o Radix fecha no vazio. Quem ja alterna `visible` no onClick do gatilho
+     * deve preferir `onEscapeKeyDown`, senao o clique alterna duas vezes.
+     */
+    onOpenChange?: (open: boolean) => void;
+    /**
+     * Escape com o foco dentro do conteudo. O evento chega ja consumido pelo
+     * Radix (`defaultPrevented`), entao uma gaveta ou modal por baixo nao
+     * fecha junto. Feche o `visible` aqui; o foco volta ao gatilho sozinho.
+     */
+    onEscapeKeyDown?: (event: KeyboardEvent) => void;
+    /** Ao fechar, antes de o foco voltar ao gatilho. `preventDefault` cancela a volta. */
+    onCloseAutoFocus?: (event: Event) => void;
 };
-declare const Popover: ({ id, className, align, side, sideOffset, visible, content, children, onPointerDownOutside, onOpenAutoFocus, }: PopoverProps) => React.JSX.Element;
+declare const Popover: ({ id, className, align, side, sideOffset, collisionPadding, visible, content, children, onPointerDownOutside, onOpenAutoFocus, onOpenChange, onEscapeKeyDown, onCloseAutoFocus, }: PopoverProps) => React.JSX.Element;
 export { Popover };

package/dist/emails/balance-sheet-finalized/components/Rail/Rail.d.ts

@@ -0,0 +1,68 @@
+import React from "react";
+import "./index.css";
+import type { RailGateCondition, RailLeaf, RailMode, RailStepData } from "./types";
+/**
+ * Rail, a esteira Gyra+: uma lista ordenada e vertical de etapas, com um
+ * conector condicional entre elas.
+ *
+ * Uma linha, nao um grafo: le de cima para baixo na mesma ordem em que a
+ * decisao acontece. A referencia e o Atalhos da Apple, nao um editor de
+ * diagramas. O rail e a unica fonte de verdade da esteira na UI: a primeira
+ * etapa de Analise E a politica principal, e o conector acima de cada etapa
+ * E a condicao para ela rodar. Nao existe conector acima da primeira etapa.
+ *
+ * Dois modos, uma arvore so:
+ *   - `edit`: inserir etapa entre etapas, trocar a condicao do conector,
+ *     reordenar.
+ *   - `run`: a mesma linha com estado por etapa. Etapa que nao disparou fica
+ *     translucida com o motivo a vista.
+ *
+ * Teclado: a esteira e UM ponto de tabulacao (roving tabindex). Setas
+ * cima/baixo andam entre etapas, Home/End vao para a primeira/ultima, e
+ * Alt+setas reordenam no modo edit. Todo controle dentro da etapa (conector,
+ * abrir relatorio, remover, folhas) e um botao ou link de verdade.
+ */
+type RailProps = {
+    id?: string;
+    className?: string;
+    /** Default: "edit". */
+    mode?: RailMode;
+    steps: Array<RailStepData>;
+    /** Rotulo acessivel da lista. Default: "Esteira". */
+    ariaLabel?: string;
+    /** Etapa em foco na execucao ao vivo (modo run). */
+    activeStepId?: string;
+    /** Etapa selecionada no construtor (modo edit). */
+    selectedStepId?: string;
+    /** Condicoes oferecidas nos conectores. Default: as quatro. */
+    gateOptions?: Array<RailGateCondition>;
+    /** Folhas abertas (controlado). Sem isto, a expansao e interna. */
+    expandedStepIds?: Array<string>;
+    /** Folhas abertas na primeira renderizacao (nao controlado). */
+    defaultExpandedStepIds?: Array<string>;
+    /** Rotulo do botao que acrescenta etapa no fim. Default: "Adicionar etapa". */
+    addLabel?: string;
+    /**
+     * Texto da esteira vazia. E AQUI que mora o tutorial ("Comece pela
+     * análise: a primeira etapa é a política principal"), nunca no cartao.
+     */
+    emptyText?: string;
+    onSelectStep?: (step: RailStepData) => void;
+    onOpenStep?: (step: RailStepData) => void;
+    onOpenLeaf?: (leaf: RailLeaf, step: RailStepData) => void;
+    /** Trocar a condicao do conector que fica ACIMA da etapa `stepId`. */
+    onChangeGate?: (stepId: string, condition: RailGateCondition) => void;
+    /**
+     * Inserir etapa na posicao `index`. O construtor oferece inserir ENTRE
+     * etapas (index >= 1, no conector) e no fim; a posicao 0 so acontece na
+     * esteira vazia, porque a primeira etapa e a politica principal.
+     */
+    onInsertStep?: (index: number) => void;
+    onRemoveStep?: (step: RailStepData) => void;
+    /** Reordenar. `toIndex` ja vem calculado e dentro dos limites. */
+    onMoveStep?: (step: RailStepData, direction: "up" | "down", toIndex: number) => void;
+    onExpandStep?: (stepId: string, expanded: boolean) => void;
+};
+declare const Rail: ({ id, className, mode, steps, ariaLabel, activeStepId, selectedStepId, gateOptions, expandedStepIds, defaultExpandedStepIds, addLabel, emptyText, onSelectStep, onOpenStep, onOpenLeaf, onChangeGate, onInsertStep, onRemoveStep, onMoveStep, onExpandStep, }: RailProps) => React.JSX.Element;
+export { Rail };
+export type { RailProps };

package/dist/emails/balance-sheet-finalized/components/Rail/RailGate.d.ts

@@ -0,0 +1,22 @@
+import React from "react";
+import "./index.css";
+import type { RailGateCondition } from "./types";
+type RailGateState = "default" | "passed" | "blocked";
+type RailGateProps = {
+    id?: string;
+    className?: string;
+    value?: RailGateCondition;
+    /** Quando falso, o conector e so leitura (modo run, ou etapa travada). */
+    editable?: boolean;
+    disabled?: boolean;
+    /** Quais condicoes oferecer. Default: as quatro, na ordem canonica. */
+    options?: Array<RailGateCondition>;
+    /** No modo run: se a condicao foi atendida, bloqueou, ou nem chegou a valer. */
+    state?: RailGateState;
+    /** Rotulo acessivel do grupo, ex: "Conector antes da etapa 2". */
+    ariaLabel?: string;
+    onChange?: (value: RailGateCondition) => void;
+};
+declare const RailGate: ({ id, className, value, editable, disabled, options, state, ariaLabel, onChange, }: RailGateProps) => React.JSX.Element;
+export { RailGate };
+export type { RailGateProps, RailGateState };

package/dist/emails/balance-sheet-finalized/components/Rail/RailInlineSelect.d.ts

@@ -0,0 +1,44 @@
+import React from "react";
+import "./index.css";
+/**
+ * RailInlineSelect, o gatilho "inline select" da linha 2 do cartao: texto +
+ * chevron, sem borda, no corpo do texto. E o que a politica de uma etapa usa
+ * no modo edit (clicou, vira picker), no lugar de um Input de rotulo
+ * flutuante de 40px.
+ *
+ * Nao abre nada sozinho: e um botao. O consumer o usa como trigger de um
+ * Popover/Select (por isso o forwardRef e o repasse das props restantes,
+ * que o `asChild` do Radix precisa).
+ */
+type RailInlineSelectProps = {
+    id?: string;
+    className?: string;
+    /** O valor escolhido. Sem valor, mostra o `placeholder` em tom terciario. */
+    label?: React.ReactNode;
+    /** Default: "Escolher política". */
+    placeholder?: string;
+    /** Avisa que o valor salvo nao esta disponivel (ex: politica desativada). */
+    tone?: "default" | "warning";
+    disabled?: boolean;
+    /** Estado do picker que este gatilho abre (aria-expanded). */
+    open?: boolean;
+    /** Rotulo acessivel. Default: "Política da etapa: {label ou placeholder}". */
+    ariaLabel?: string;
+} & Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "id" | "className" | "disabled">;
+declare const RailInlineSelect: React.ForwardRefExoticComponent<{
+    id?: string;
+    className?: string;
+    /** O valor escolhido. Sem valor, mostra o `placeholder` em tom terciario. */
+    label?: React.ReactNode;
+    /** Default: "Escolher política". */
+    placeholder?: string;
+    /** Avisa que o valor salvo nao esta disponivel (ex: politica desativada). */
+    tone?: "default" | "warning";
+    disabled?: boolean;
+    /** Estado do picker que este gatilho abre (aria-expanded). */
+    open?: boolean;
+    /** Rotulo acessivel. Default: "Política da etapa: {label ou placeholder}". */
+    ariaLabel?: string;
+} & Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "className" | "id" | "disabled"> & React.RefAttributes<HTMLButtonElement>>;
+export { RailInlineSelect };
+export type { RailInlineSelectProps };

package/dist/emails/balance-sheet-finalized/components/Rail/RailMini.d.ts

@@ -0,0 +1,29 @@
+import React from "react";
+import "./index.css";
+import type { RailStepData } from "./types";
+/**
+ * RailMini, a MESMA esteira, do tamanho de uma celula de lista.
+ *
+ * Uma bolinha de 6px por etapa, ligadas por um fio de 1px, no maximo ~120px
+ * de largura. O resumo ("Parou na etapa 2 de 4: reprovada") vai no
+ * `aria-label` e no `title`; na tela ele so aparece com `showSummary`,
+ * porque a linha da lista ja tem a coluna de status e nao precisa dizer a
+ * mesma coisa duas vezes.
+ *
+ * Nao e clicavel de proposito. Quem quer detalhe abre a linha; a miniatura e
+ * um indicador, e um alvo de clique dentro de outro alvo de clique so cria
+ * ambiguidade.
+ */
+type RailMiniProps = {
+    className?: string;
+    steps: Array<RailStepData>;
+    /** Rotulo acessivel. Default: "Progresso da esteira". */
+    ariaLabel?: string;
+    /** Mostra o resumo em texto ao lado das bolinhas. Default: false. */
+    showSummary?: boolean;
+};
+/** O resumo em texto de uma execucao: exportado para a lista reutilizar. */
+export declare const railMiniSummary: (steps: Array<RailStepData>) => string;
+declare const RailMini: ({ className, steps, ariaLabel, showSummary }: RailMiniProps) => React.JSX.Element | null;
+export { RailMini };
+export type { RailMiniProps };

package/dist/emails/balance-sheet-finalized/components/Rail/RailStep.d.ts

@@ -0,0 +1,40 @@
+import React from "react";
+import "./index.css";
+import type { RailLeaf, RailMode, RailStepData, RailTone } from "./types";
+type RailStepProps = {
+    id?: string;
+    className?: string;
+    step: RailStepData;
+    mode?: RailMode;
+    /** Posicao 1-based na esteira. */
+    index?: number;
+    /** Total de etapas, para o "Etapa 2 de 5" lido pelo leitor de tela. */
+    total?: number;
+    /** Etapa em foco na execucao ao vivo. */
+    active?: boolean;
+    /** Etapa selecionada no construtor. */
+    selected?: boolean;
+    /** Folhas visiveis. */
+    expanded?: boolean;
+    canMoveUp?: boolean;
+    canMoveDown?: boolean;
+    /** Roving tabindex: o Rail decide qual etapa esta na ordem de tabulacao. */
+    tabIndex?: number;
+    onExpand?: (expanded: boolean) => void;
+    onOpen?: () => void;
+    onSelect?: () => void;
+    onRemove?: () => void;
+    onMove?: (direction: "up" | "down") => void;
+    onOpenLeaf?: (leaf: RailLeaf) => void;
+    onKeyDown?: (event: React.KeyboardEvent<HTMLDivElement>) => void;
+    onFocus?: (event: React.FocusEvent<HTMLDivElement>) => void;
+};
+/** Ponto de 6px + texto: o unico jeito de dizer estado dentro do cartao. */
+declare const StatusDot: ({ label, tone, className, }: {
+    label: string;
+    tone: RailTone;
+    className?: string;
+}) => React.JSX.Element;
+declare const RailStep: React.ForwardRefExoticComponent<RailStepProps & React.RefAttributes<HTMLDivElement>>;
+export { RailStep, StatusDot as RailStatusDot };
+export type { RailStepProps };

package/dist/emails/balance-sheet-finalized/components/Rail/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./Rail";
+export * from "./RailStep";
+export * from "./RailMini";
+export * from "./RailGate";
+export * from "./RailInlineSelect";
+export * from "./labels";
+export * from "./types";

package/dist/emails/balance-sheet-finalized/components/Rail/labels.d.ts

@@ -0,0 +1,54 @@
+import type { RailDecision, RailGateCondition, RailStepData, RailStepKind, RailStepStatus, RailTone } from "./types";
+import type { StatusTagVariant } from "../StatusTag";
+/**
+ * Vocabulario em portugues da esteira. Fica num arquivo so para que o rail, o
+ * conector, a miniatura e o modo frase leiam exatamente os mesmos rotulos:
+ * dois vocabularios para o mesmo enum ja e um debito conhecido do
+ * gyra-operation.
+ */
+export declare const KIND_LABEL: Record<RailStepKind, string>;
+/** Glifo textual do card GYR-1623: ◉ análise · ⊕ aprofundar · ✋ checkpoint · ⌘ vínculos. */
+export declare const KIND_GLYPH: Record<RailStepKind, string>;
+/**
+ * O que cada tipo FAZ, na voz da frase ("1. Analisa com X · 2. se aprovada,
+ * pede decisão do analista"). E o mesmo vocabulario do KIND_LABEL, conjugado.
+ */
+export declare const KIND_SENTENCE: Record<RailStepKind, (subject?: string) => string>;
+/** Frase curta da linha 2 do checkpoint quando o consumer nao manda `subtitle`. */
+export declare const CHECKPOINT_HINT = "Pausa e pergunta ao analista";
+export declare const GATE_LABEL: Record<RailGateCondition, string>;
+export declare const GATE_DESCRIPTION: Record<RailGateCondition, string>;
+export declare const GATE_ORDER: Array<RailGateCondition>;
+/** Estado da etapa, na voz do analista ("aguardando você", "não rodou"). */
+export declare const STATUS_LABEL: Record<RailStepStatus, string>;
+export declare const DECISION_LABEL: Record<RailDecision, string>;
+export declare const DECISION_TONE: Record<RailDecision, RailTone>;
+export declare const STATUS_TONE: Record<RailStepStatus, RailTone>;
+/** Mantidos por compatibilidade com quem lia a pilula (StatusTag) da v1. */
+export declare const DECISION_VARIANT: Record<RailDecision, StatusTagVariant>;
+export declare const STATUS_VARIANT: Record<RailStepStatus, StatusTagVariant>;
+/**
+ * O que o ponto de estado mostra: quando a etapa terminou e registrou uma
+ * decisao, a decisao vence o "concluida" (e o que o analista quer ler).
+ */
+export declare const resolveStatusDot: (status?: RailStepStatus, decision?: RailDecision) => {
+    label: string;
+    tone: RailTone;
+} | undefined;
+/** Compatibilidade com a v1 (mesma regra, no formato do StatusTag). */
+export declare const resolveStatusTag: (status?: RailStepStatus, decision?: RailDecision) => {
+    title: string;
+    variant: StatusTagVariant;
+} | undefined;
+/**
+ * Modo frase: a esteira lida em uma linha, para a pessoa confirmar o que vai
+ * disparar antes de gastar dinheiro.
+ *
+ *   "1. Analisa com PJ Essencial v4 · 2. se aprovada, pede decisão do
+ *    analista · 3. se aprovada, deriva para sócios"
+ *
+ * A primeira etapa nunca tem conector. Nas demais, o conector vem do
+ * GATE_LABEL: "sempre" entra sem virgula ("2. sempre deriva para sócios"),
+ * as condicoes entram com virgula ("2. se aprovada, deriva para sócios").
+ */
+export declare const railToSentence: (steps: Array<RailStepData>) => string;

package/dist/emails/balance-sheet-finalized/components/Rail/types.d.ts

@@ -0,0 +1,110 @@
+import React from "react";
+/**
+ * Rail, vocabulario da esteira Gyra+.
+ *
+ * O modelo espelha 1:1 o `OperationStep` do gyra-operation (kind + runIf +
+ * order), de proposito: o construtor e o acompanhamento ao vivo leem o MESMO
+ * array. Quem consome so troca `mode`.
+ */
+/** edit = construtor. run = acompanhamento ao vivo. Mesma arvore. */
+export type RailMode = "edit" | "run";
+/** Os 4 tipos de etapa. Espelha `StepKind` do gyra-operation. */
+export type RailStepKind = "ANALYSIS" | "DEEPEN" | "CHECKPOINT" | "RELATIONSHIPS";
+/**
+ * A condicao do conector: sempre avaliada contra a ULTIMA decisao registrada
+ * na esteira. Espelha `Gate` do gyra-operation.
+ */
+export type RailGateCondition = "ALWAYS" | "IF_APPROVED" | "IF_APPROVED_OR_ALERT" | "IF_REPROVED";
+/** Estado de execucao de uma etapa (so tem significado no modo run). */
+export type RailStepStatus = "PENDING" | "RUNNING" | "WAITING" | "DONE" | "SKIPPED" | "ERROR";
+/** A decisao que a etapa registrou (nem toda etapa decide). */
+export type RailDecision = "APPROVED" | "ALERT" | "REPROVED";
+/** Tom semantico de um ponto de estado (6px + texto). */
+export type RailTone = "neutral" | "info" | "success" | "warning" | "danger";
+/**
+ * Folha de uma etapa de Vinculos: um relatorio derivado (socio, 1o nivel,
+ * filial...). Cada folha e linkavel.
+ */
+export type RailLeaf = {
+    id: string;
+    title: string;
+    /** Ex: "Socia · Socio PF v3". */
+    subtitle?: string;
+    /** CPF/CNPJ. Renderizado com tabular-nums. */
+    document?: string;
+    status?: RailStepStatus;
+    decision?: RailDecision;
+    /** Quando presente, a folha vira ancora. Senao, botao com `onOpen`. */
+    href?: string;
+    onOpen?: () => void;
+    disabled?: boolean;
+};
+/**
+ * Uma etapa da esteira (o dado; o componente que a desenha se chama RailStep).
+ *
+ * Anatomia do cartao, nas duas linhas que ele tem:
+ *   linha 1: glifo do tipo (chip neutro, tooltip com o nome do tipo) + `title`
+ *            + `meta` (chips pequenos) e, a direita, o estado (run) ou as
+ *            acoes de ordenar/remover (edit, so no hover).
+ *   linha 2: `policyControl` (edit) ou `policyName` (run) para Analise e
+ *            Aprofundar; `subtitle` para Vinculos (o resumo dos niveis) e para
+ *            o Checkpoint (uma frase curta; default "Pausa e pergunta ao
+ *            analista").
+ * O tipo NUNCA aparece como texto no cartao: so como glifo com tooltip. Quem
+ * precisa do nome do tipo em texto usa `KIND_LABEL` ou `railToSentence`.
+ */
+export type RailStepData = {
+    id: string;
+    kind: RailStepKind;
+    /** O nome que o usuario deu a etapa (default no consumer: nome da politica, "Checkpoint" ou "Vinculos"). */
+    title: string;
+    /**
+     * Linha 2 quando a etapa nao e uma politica: o resumo dos vinculos
+     * ("Sócios · 1º nível · PF: Sócio PF v3") ou a frase do checkpoint. Em
+     * Analise/Aprofundar so aparece se nao houver `policyControl`/`policyName`.
+     */
+    subtitle?: React.ReactNode;
+    /**
+     * O nome da politica desta etapa (Analise/Aprofundar). No modo run vira a
+     * linha 2; no modo frase (`railToSentence`) vira "analisa com {policyName}".
+     */
+    policyName?: string;
+    /**
+     * Seletor inline da politica, injetado pelo consumer no modo edit (ex: um
+     * `RailInlineSelect` abrindo o picker). Ocupa a linha 2 no lugar do
+     * `policyName`. Ignorado no modo run.
+     */
+    policyControl?: React.ReactNode;
+    /**
+     * A condicao do conector que fica ACIMA desta etapa. A primeira etapa da
+     * esteira nao tem conector, entao o campo e ignorado nela.
+     */
+    runIf?: RailGateCondition;
+    status?: RailStepStatus;
+    decision?: RailDecision;
+    /**
+     * Por que a etapa nao disparou. Renderizado FORA do cartao translucido, em
+     * contraste cheio: etapa pulada mostra o motivo a vista.
+     */
+    reason?: string;
+    /** Chips pequenos ao lado do nome (score, custo, camada...). */
+    meta?: React.ReactNode;
+    /** Acoes da etapa no modo run (ex: o botao "Decidir" do checkpoint aguardando). */
+    actions?: React.ReactNode;
+    /**
+     * Slot livre abaixo das duas linhas. Mantido por compatibilidade; na v2 a
+     * configuracao da etapa mora na linha 2 (`policyControl`/`subtitle`), e
+     * este slot fica para o que nao cabe la.
+     */
+    content?: React.ReactNode;
+    /** Folhas (relatorios derivados). So faz sentido em RELATIONSHIPS. */
+    leaves?: RailLeaf[];
+    /** Rotulo da lista de folhas. Default: "Relatorios derivados". */
+    leavesLabel?: string;
+    /** Quando presente, o titulo vira link para o relatorio da etapa. */
+    href?: string;
+    /** Etapa desabilitada (nao editavel, nao clicavel). */
+    disabled?: boolean;
+    /** Trava so o conector desta etapa (ex: etapa herdada de um modelo). */
+    gateLocked?: boolean;
+};

package/dist/emails/balance-sheet-finalized/components/SegmentedPicker/SegmentedPicker.d.ts

@@ -21,7 +21,13 @@ type SegmentedPickerProps = {
     /** primary: solid filled trigger; secondary: outlined/ghost trigger. */
     variant?: "primary" | "secondary";
     disabled?: boolean;
+    /**
+     * Alinhamento do menu em relacao ao gatilho. Default `start`: o menu e mais
+     * largo que a pilula, e alinhado pelo fim ele cresce para a ESQUERDA — de
+     * dentro de uma gaveta ou de um card, isso o joga para fora do container.
+     */
+    align?: "start" | "center" | "end";
 };
-declare const SegmentedPicker: ({ id, className, value, options, onChange, variant, disabled, }: SegmentedPickerProps) => React.JSX.Element | null;
+declare const SegmentedPicker: ({ id, className, value, options, onChange, variant, disabled, align, }: SegmentedPickerProps) => React.JSX.Element | null;
 export { SegmentedPicker };
 export type { SegmentedPickerProps, SegmentedPickerOption };

package/dist/emails/balance-sheet-finalized/components/Switch/Switch.d.ts

@@ -5,7 +5,13 @@ type SwitchProps = {
     className?: string;
     disabled?: boolean;
     checked?: boolean;
+    /**
+     * Nome do controle. Um switch sozinho numa linha de tabela nao tem rotulo
+     * visivel nenhum: sem isto o leitor de tela anuncia so "alternar".
+     */
+    title?: string;
+    "aria-label"?: string;
     onCheckedChange?: (checked: boolean) => void;
 };
-declare const Switch: ({ id, className, disabled, checked, onCheckedChange, }: SwitchProps) => React.JSX.Element;
+declare const Switch: ({ id, className, disabled, checked, onCheckedChange, ...props }: SwitchProps) => React.JSX.Element;
 export { Switch };

package/dist/emails/balance-sheet-finalized/components/Table/Table.d.ts

@@ -19,24 +19,11 @@ type TableProps = {
         text?: string;
     };
     headlesss?: boolean;
-    /**
-     * Estado de carregamento da tabela. O desenho depende de JA existir dado:
-     *
-     * - **sem linhas** (primeira carga): linhas de skeleton na forma das
-     *   `columns`, entao a tabela nao muda de largura quando o dado chega.
-     * - **com linhas** (refetch por filtro, busca ou acao de linha): as linhas
-     *   ficam, esmaecidas, com uma barra fina de progresso no topo. Apagar o
-     *   que o usuario esta lendo para mostrar um placeholder e' pior do que
-     *   deixar o dado velho a vista por um instante.
-     */
-    loading?: boolean;
-    /** Quantas linhas de skeleton desenhar na primeira carga. Padrao 5. */
-    loadingRows?: number;
     onRowClick?: (e: React.MouseEvent<HTMLTableRowElement, MouseEvent>, data: any) => void;
     /** Optional per-row className. Receives the row's data object and its
      *  zero-based index. Useful for transient state highlights (e.g. a row
      *  that just finished processing in real-time). */
     rowClassName?: (data: any, index: number) => string | undefined;
 };
-declare const Table: ({ id, className, height, type, columns, data, empty, headlesss, loading, loadingRows, onRowClick, rowClassName, }: TableProps) => React.JSX.Element;
+declare const Table: ({ id, className, height, type, columns, data, empty, headlesss, onRowClick, rowClassName, }: TableProps) => React.JSX.Element;
 export { Table };

package/dist/emails/balance-sheet-finalized/index.d.ts

@@ -37,6 +37,7 @@ import "./components/Popover/index.css";
 import "./components/ProcessingChip/index.css";
 import "./components/Progress/index.css";
 import "./components/RadioGroup/index.css";
+import "./components/Rail/index.css";
 import "./components/RichInput/index.css";
 import "./components/Row/index.css";
 import "./components/ScoreBar/index.css";
@@ -45,7 +46,6 @@ import "./components/SegmentedToggle/index.css";
 import "./components/Select/index.css";
 import "./components/Selector/index.css";
 import "./components/SelectTree/index.css";
-import "./components/Skeleton/index.css";
 import "./components/PickerPopover/index.css";
 import "./components/MultiSelectPicker/index.css";
 import "./components/RuleSearchPicker/index.css";

package/dist/emails/email/components/Button/Button.d.ts

@@ -12,6 +12,13 @@ export type ButtonProps = {
     loading?: boolean;
     icon?: React.ReactNode;
     fab?: boolean;
+    /**
+     * Nome do botao. Botao SO de icone nao tem texto para o leitor de tela
+     * anunciar nem dica para o mouse: sem um destes dois, ele e anunciado como
+     * "botao" e nada mais. Os dois chegam ao `<button>` pelo spread.
+     */
+    title?: string;
+    "aria-label"?: string;
     onClick?: (event: React.MouseEvent<HTMLButtonElement, MouseEvent>) => void;
     children?: React.ReactNode;
 };

package/dist/emails/email/components/Card/Card.d.ts

@@ -15,12 +15,6 @@ type CardProps = {
     media?: React.ReactNode;
     disabled?: boolean;
     loading?: boolean;
-    /**
-     * Placeholder exibido no lugar do conteudo enquanto `loading`. O padrao e um
-     * skeleton de linhas de texto; passe um skeleton com a forma do conteudo real
-     * (grafico, tabela, lista) quando isso ajudar a evitar o pulo de layout.
-     */
-    loadingContent?: React.ReactNode;
     collapsible?: boolean;
     defaultCollapsed?: boolean;
     collapsed?: boolean;
@@ -29,5 +23,5 @@ type CardProps = {
     headerContent?: React.ReactNode;
     children?: React.ReactNode;
 };
-declare const Card: ({ id, type, className, title, subtitle, media, disabled, loading, loadingContent, collapsible, defaultCollapsed, collapsed, onCollapse, onClick, headerContent, children, }: CardProps) => React.JSX.Element;
+declare const Card: ({ id, type, className, title, subtitle, media, disabled, loading, collapsible, defaultCollapsed, collapsed, onCollapse, onClick, headerContent, children, }: CardProps) => React.JSX.Element;
 export { Card };