@gyramais/gyra-design 0.2.48 → 0.2.49

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/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/Popover/Popover.d.ts

@@ -6,11 +6,13 @@ 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;
 };
-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, }: PopoverProps) => React.JSX.Element;
 export { Popover };

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

@@ -0,0 +1,59 @@
+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.
+ *
+ * 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. */
+    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` (0 = antes da primeira). */
+    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/RailMini.d.ts

@@ -0,0 +1,25 @@
+import React from "react";
+import "./index.css";
+import type { RailStepData } from "./types";
+/**
+ * RailMini — a MESMA esteira, do tamanho de uma linha de lista.
+ *
+ * Existe porque o progresso da esteira e a informacao que a listagem de
+ * execucoes precisa dar de graca: sem isto, saber que a esteira parou na
+ * etapa 1 de 4 custa um clique e uma expansao. E uma miniatura, nao um
+ * componente novo: le o mesmo `RailStepData` do `Rail`, so que como uma fila
+ * de marcas horizontais.
+ *
+ * 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;
+};
+declare const RailMini: ({ className, steps, ariaLabel }: RailMiniProps) => React.JSX.Element | null;
+export { RailMini };
+export type { RailMiniProps };

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

@@ -0,0 +1,45 @@
+import React from "react";
+import "./index.css";
+import type { RailLeaf, RailMode, RailStepData } from "./types";
+/**
+ * RailStep — o cartao de uma etapa.
+ *
+ * E o mesmo cartao nos dois modos: no `edit` ele mostra a barra de ordenacao e
+ * o slot de configuracao; no `run` ele mostra o estado e as acoes. Nada de
+ * duas arvores: se construir e acompanhar exigissem componentes diferentes, o
+ * desenho teria falhado.
+ *
+ * Etapa que nao disparou fica translucida, mas o MOTIVO fica fora do cartao,
+ * em contraste cheio: e a informacao que o analista precisa ler.
+ */
+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;
+};
+declare const RailStep: React.ForwardRefExoticComponent<RailStepProps & React.RefAttributes<HTMLDivElement>>;
+export { RailStep };
+export type { RailStepProps };

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

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

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

@@ -0,0 +1,25 @@
+import type { RailDecision, RailGateCondition, RailStepKind, RailStepStatus } from "./types";
+import type { StatusTagVariant } from "../StatusTag";
+/**
+ * Vocabulario em portugues da esteira. Fica num arquivo so para que o rail, o
+ * conector e o (futuro) 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 do card GYR-1623: ◉ análise · ⊕ aprofundar · ✋ checkpoint · ⌘ vínculos. */
+export declare const KIND_GLYPH: Record<RailStepKind, string>;
+export declare const GATE_LABEL: Record<RailGateCondition, string>;
+export declare const GATE_DESCRIPTION: Record<RailGateCondition, string>;
+export declare const GATE_ORDER: Array<RailGateCondition>;
+export declare const STATUS_LABEL: Record<RailStepStatus, string>;
+export declare const DECISION_LABEL: Record<RailDecision, string>;
+export declare const DECISION_VARIANT: Record<RailDecision, StatusTagVariant>;
+export declare const STATUS_VARIANT: Record<RailStepStatus, StatusTagVariant>;
+/**
+ * O que a pilula 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 resolveStatusTag: (status?: RailStepStatus, decision?: RailDecision) => {
+    title: string;
+    variant: StatusTagVariant;
+} | undefined;

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

@@ -0,0 +1,75 @@
+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";
+/**
+ * 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 em IBM Plex Mono. */
+    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). */
+export type RailStepData = {
+    id: string;
+    kind: RailStepKind;
+    title: string;
+    /** Politica, camada, niveis de vinculo... */
+    subtitle?: 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/tags extras no header (camada, custo, tier...). */
+    meta?: React.ReactNode;
+    /** Acoes da etapa no modo run (ex: "Decidir agora"). */
+    actions?: React.ReactNode;
+    /** Slot livre de conteudo: seletor de politica, niveis, o que o consumer quiser. */
+    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 };

package/dist/emails/email/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/email/components/Popover/Popover.d.ts

@@ -6,11 +6,13 @@ 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;
 };
-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, }: PopoverProps) => React.JSX.Element;
 export { Popover };

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

@@ -0,0 +1,59 @@
+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.
+ *
+ * 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. */
+    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` (0 = antes da primeira). */
+    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/email/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/email/components/Rail/RailMini.d.ts

@@ -0,0 +1,25 @@
+import React from "react";
+import "./index.css";
+import type { RailStepData } from "./types";
+/**
+ * RailMini — a MESMA esteira, do tamanho de uma linha de lista.
+ *
+ * Existe porque o progresso da esteira e a informacao que a listagem de
+ * execucoes precisa dar de graca: sem isto, saber que a esteira parou na
+ * etapa 1 de 4 custa um clique e uma expansao. E uma miniatura, nao um
+ * componente novo: le o mesmo `RailStepData` do `Rail`, so que como uma fila
+ * de marcas horizontais.
+ *
+ * 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;
+};
+declare const RailMini: ({ className, steps, ariaLabel }: RailMiniProps) => React.JSX.Element | null;
+export { RailMini };
+export type { RailMiniProps };

package/dist/emails/email/components/Rail/RailStep.d.ts

@@ -0,0 +1,45 @@
+import React from "react";
+import "./index.css";
+import type { RailLeaf, RailMode, RailStepData } from "./types";
+/**
+ * RailStep — o cartao de uma etapa.
+ *
+ * E o mesmo cartao nos dois modos: no `edit` ele mostra a barra de ordenacao e
+ * o slot de configuracao; no `run` ele mostra o estado e as acoes. Nada de
+ * duas arvores: se construir e acompanhar exigissem componentes diferentes, o
+ * desenho teria falhado.
+ *
+ * Etapa que nao disparou fica translucida, mas o MOTIVO fica fora do cartao,
+ * em contraste cheio: e a informacao que o analista precisa ler.
+ */
+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;
+};
+declare const RailStep: React.ForwardRefExoticComponent<RailStepProps & React.RefAttributes<HTMLDivElement>>;
+export { RailStep };
+export type { RailStepProps };