@snksergio/design-system 0.58.0 → 0.60.0

package/dist-lib/src/components/ui/Gantt/gantt.styles.d.ts

@@ -0,0 +1,2985 @@
+/**
+ * Estilos do `Gantt`.
+ *
+ * ## A pele é do DS, a estrutura é das referências
+ *
+ * As 13 referências visuais decidiram **estrutura**: grade à esquerda, eixo em
+ * dois níveis, divisor arrastável, setas ortogonais, losango pro marco. Nenhuma
+ * decidiu **pele** — fonte, cor, espaçamento, radius e foco vêm dos tokens,
+ * conforme `.ai/context/referencia-visual.md`.
+ *
+ * ⛔ Nenhum hex saiu de pixel de print. Os prints trazem roxo, laranja e
+ * azul-royal de outros produtos; o DS tem 5 chaves de chart e as famílias
+ * semânticas, e é só isso que existe aqui.
+ *
+ * ## Por que a barra é TINGIDA e não sólida com texto branco
+ *
+ * As referências mostram barra saturada com texto branco. O DS não faz isso, e a
+ * razão foi **medida** na v0.56.0 ao especificar o `Scheduler`: texto colorido
+ * ou branco sobre pílula tingida dá contraste de **1.72–4.49 no light** e
+ * 2.97–4.31 no dark — nenhuma família passa AA, e `warning` chega a 1.72:1.
+ *
+ * A receita do DS é: fundo tingido + `fg-default` no texto + a cor viva num
+ * **acento** (aqui, a borda esquerda de 3px) e no preenchimento de progresso.
+ * A cor segue dizendo qual frente é; ela só não carrega o texto.
+ *
+ * ⛔ Nada aqui é importado do `Scheduler` — só a gramática visual foi copiada,
+ * pelo mesmo motivo que ele copiou a do `TableToolbar` em vez de importar
+ * (L-049): cross-import entre pastas de `ui/` gera `registryDependency`
+ * pendente e o `igreen:add` estreia quebrado.
+ */
+/**
+ * Altura da linha, em px — **fonte ÚNICA, consumida pelos dois painéis**.
+ *
+ * ⚠️ É constante e não classe utilitária de propósito. A grade da esquerda e o
+ * canvas da direita têm que concordar **ao pixel**: a barra é posicionada em
+ * `top` absoluto calculado a partir do índice da linha, e a célula da esquerda é
+ * um elemento de fluxo. Se as duas derivassem a altura de lugares diferentes —
+ * uma de `min-h-comp-2xl`, outra de um `--var` — bastaria um `line-height`
+ * herdado pra desalinhar, e o desalinho cresce linha a linha.
+ *
+ * É a classe de defeito da L-038: default resolvido em dois render-sites que
+ * divergem. Aqui há um número só, e um teste compara os dois `getBoundingClientRect`.
+ *
+ * 48px: os 44 de `comp-2xl` (alvo de toque WCAG) + 2px de respiro em cima e
+ * 2 embaixo. Em 44 exatos a linha ficava com o texto encostado nas divisórias.
+ */
+export declare const GANTT_ROW_HEIGHT_PX = 48;
+/**
+ * Altura da barra dentro da linha.
+ *
+ * 26 e não 18: em 44px de linha, 18px de barra deixava 13px de folga em cima e
+ * embaixo, e o card parecia flutuar solto na faixa. A barra é CENTRADA
+ * verticalmente — `(rowHeight - barHeight) / 2` —, não colada no topo.
+ */
+export declare const GANTT_BAR_HEIGHT_PX = 26;
+/** Barra-resumo: mais fina de propósito, ela agrega e não é trabalho. */
+export declare const GANTT_SUMMARY_BAR_HEIGHT_PX = 12;
+/** Altura de uma lane dentro de uma linha com N barras (`lanePacking: "stack"`). */
+export declare const GANTT_LANE_HEIGHT_PX = 30;
+/**
+ * Altura do cabeçalho — dois níveis empilhados.
+ *
+ * 68 e não 56: com 28+28 o rótulo do dia ficava colado na divisória, e o eixo
+ * lia como uma faixa comprimida ao lado de linhas de 44px. 30 no grupo (mês) +
+ * 38 na unidade (dia), que é onde mora o par `S 21`.
+ */
+export declare const GANTT_HEAD_HEIGHT_PX = 84;
+/**
+ * Faixa do mês/ano — **42px, igual à faixa da unidade**.
+ *
+ * Passou por 30 (o rótulo encostava na divisória) e 38 (melhor, mas a faixa
+ * ainda lia como subordinada à de baixo). Em 42 as duas têm o mesmo peso, que é
+ * o correto: são dois NÍVEIS do mesmo eixo, não um cabeçalho e um sub-cabeçalho.
+ *
+ * ⚠️ **Não há token de 42px, e isso é deliberado.** A escala `form` do DS pula
+ * de 40 (`form-lg`) pra 44 (`form-xl`, alvo WCAG); nenhum tier cai em 42. Toda a
+ * família `GANTT_HEAD_*`/`GANTT_ROW_HEIGHT_PX` é geometria DE COMPONENTE em px,
+ * pela mesma razão: são medidas que os dois painéis têm que casar ao pixel, não
+ * alturas de controle interativo. Criar token semântico pra a faixa de
+ * cabeçalho de UM componente violaria a Regra 1 (só criar se nenhum servir E
+ * for reutilizável).
+ *
+ * Se em algum momento isto tiver que virar token, o tier honesto é `form-xl`
+ * (44) — e aí as duas faixas vão junto, não só esta.
+ */
+export declare const GANTT_HEAD_GROUP_PX = 42;
+/** Faixa da unidade — empilha a abreviação do dia sobre o número (#10). */
+export declare const GANTT_HEAD_UNIT_PX = 42;
+/**
+ * Largura mínima de rótulo de GRUPO, em px.
+ *
+ * 96px porque o pior caso real é "novembro 2026" em `caption-md`, que mede
+ * ~85px de texto: em 92px ele encostava nas duas bordas.
+ *
+ * Abaixo disso o rótulo não é renderizado — a célula fica, pra o alinhamento
+ * não quebrar, mas vazia. Medido no exemplo de tela cheia: a janela começava em
+ * 31/ago e o grupo "agosto 2026" saía com **46px** (um dia só), com o texto
+ * transbordando por cima do vizinho.
+ *
+ * Esconder é melhor que abreviar: "ago" em 46px ainda encosta nas duas bordas,
+ * e o mês já está implícito no grupo seguinte, que é grande.
+ */
+export declare const GANTT_GROUP_LABEL_MIN_PX = 96;
+/** Largura de coluna por granularidade, em px por dia. */
+/**
+ * Largura por dia, em px — derivada da largura-alvo da UNIDADE.
+ *
+ * ⚠️ A largura-alvo NÃO é "o que o rótulo precisa". Era, e foi o erro: "set"
+ * cabe em 60px, então o mês nasceu com 150 e o trimestre com 190 — larguras
+ * suficientes pro CABEÇALHO e insuficientes pro CONTEÚDO. Quem ocupa a coluna
+ * é a barra, e ela mede em dias:
+ *
+ *   escala     antes            uma tarefa de 6 dias   uma de 12
+ *   month      150px (4.93/d)   → 30px                 → 59px
+ *   quarter    190px (2.09/d)   → 13px                 → 25px
+ *
+ * Em 30px não cabe rótulo nem o acento de 3px lê como acento; em 13px a barra
+ * é um traço. O cronograma inteiro virava uma tira achatada, que é justamente
+ * o que se vai olhar quando se escolhe uma escala grossa.
+ *
+ *   escala     agora            6 dias    12 dias
+ *   month      240px (7.89/d)   → 47px    → 95px
+ *   quarter    320px (3.52/d)   → 21px    → 42px
+ *
+ * O custo é largura total do trilho — com `GANTT_WINDOW_DAYS`, mês vai a
+ * ~5.760px e trimestre a ~6.420px. É rolagem, e rolagem é o preço certo:
+ * conteúdo ilegível não tem preço de troco.
+ *
+ * `day` fica em 46 porque lá a coluna carrega duas informações empilhadas (a
+ * abreviação do dia e o número) e a barra já tem 46px por dia.
+ */
+export declare const GANTT_PX_PER_DAY: {
+    readonly day: 46;
+    readonly week: number;
+    readonly month: number;
+    readonly quarter: number;
+};
+/**
+ * Quantos dias a janela cobre em cada escala, quando o consumidor NÃO controla.
+ *
+ * ⚠️ Sem isto, trocar pra trimestre mantinha a janela de ~60 dias e o
+ * cronograma inteiro colapsava numa tira de **128px** — medido. Escolher uma
+ * escala mais grossa é pedir pra ver MAIS TEMPO, não a mesma janela comprimida.
+ */
+export declare const GANTT_WINDOW_DAYS: {
+    readonly day: 60;
+    readonly week: 180;
+    readonly month: 730;
+    readonly quarter: 1825;
+};
+/**
+ * A raiz — toolbar em cima, os dois painéis embaixo.
+ *
+ * ⚠️ `gap-gp-3xl` (20px) e não `gap-gp-xl` (12px): em 12px a toolbar encostava
+ * na moldura do cronograma e as duas liam como uma caixa só, com os controles
+ * parecendo parte do cabeçalho da grade. 20px é a distância que separa
+ * "controles DA tela" de "a tela".
+ */
+export declare const ganttRoot: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, string[], {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, string[], unknown, unknown, undefined>>;
+/**
+ * Duas linhas abaixo de `lg`, uma a partir dele — mesma decisão que a toolbar do
+ * `Scheduler` tomou na v0.58.0, e pelo mesmo motivo medido: `flex-wrap` puro
+ * deixa a quebra a cargo do espaço que sobrar, e em 375px os controles disputam
+ * largura com a busca.
+ */
+export declare const ganttToolbar: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, string[], {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, string[], unknown, unknown, undefined>>;
+/**
+ * Os dois lados da toolbar.
+ *
+ * O lado esquerdo usa o gap do `toolbarLeft` do `TableToolbar` —
+ * `gap-gp-sm md:gap-gp-lg` (6px → 10px) —, e não um valor próprio. Ele tem a
+ * mesma anatomia da toolbar da tabela: seletor de visão, DIVISOR, e o que a
+ * visão governa. O divisor carrega `mx-sp-sm`, então o gap do grupo é metade do
+ * respiro que aparece em volta dele; com 16px ali o divisor ficava com 22px de
+ * cada lado contra os 16px da tabela, e era isso que fazia as abas, o divisor e
+ * a data parecerem soltos entre si. À direita o gap é 8px: lá é tudo controle,
+ * e agrupar é o que se quer.
+ *
+ * ⛔ Três classes da receita da tabela ficaram FORA de propósito:
+ *   - `max-md:hidden` — na tabela o grupo esquerdo desaparece no mobile porque
+ *     toggle, abas e "adicionar" colapsam pro menu de Configurações. Aqui o
+ *     grupo carrega o título do mês e o `‹ Hoje ›`, que são a ÚNICA navegação do
+ *     componente; não há menu pra onde colapsar, então esconder equivale a
+ *     travar o Gantt no mês em que abriu.
+ *   - `[&>*]:shrink-0` — o título é TEXTO, e o `ganttTitleText` trunca de
+ *     propósito ("31 ago – 2 nov 2026" é longo). `shrink-0` no filho impede o
+ *     truncate e o texto vaza a toolbar. Na tabela todos os filhos são
+ *     controles de largura própria, e ali a classe está certa.
+ *   - `flex-1` — a raiz (`ganttToolbar`) já é `justify-between`, então o lado
+ *     esquerdo já recebe a sobra sem precisar disputá-la.
+ *
+ * ⚠️ O `gap` está NAS VARIANTES e não na base, e isso não é estilo — é
+ * necessidade. MEDIDO: `tailwind-merge` **não colapsa** `gap-gp-*`. Um elemento
+ * com `gap-gp-md gap-gp-2xl` mantém as DUAS classes e quem decide é a ordem no
+ * CSS gerado — que entregou 8px, o valor da base. Sozinha, `gap-gp-2xl` dá 16.
+ *
+ * O motivo: o grupo `gap` do tailwind-merge valida o sufixo como número ou
+ * valor arbitrário, e `gp-md` não é nem um nem outro — então ele nem reconhece
+ * as duas como conflitantes. É a mesma armadilha da L-016 (preset tipográfico
+ * invisível pro merge), na família de espaçamento: falha em silêncio, com `tsc`
+ * e testes verdes.
+ *
+ * ⛔ Regra prática: com prefixo DS (`gp-`, `sp-`, `pad-`, `form-`, `icon-`),
+ * NÃO conte com variante sobrescrevendo a base. Declare o valor em UM lugar só.
+ */
+export declare const ganttToolbarSide: import('tailwind-variants').TVReturnType<{
+    slot: {
+        leading: string[];
+        trailing: string;
+    };
+}, undefined, "flex min-w-0 items-center", {
+    slot: {
+        leading: string[];
+        trailing: string;
+    };
+}, undefined, import('tailwind-variants').TVReturnType<{
+    slot: {
+        leading: string[];
+        trailing: string;
+    };
+}, undefined, "flex min-w-0 items-center", unknown, unknown, undefined>>;
+/**
+ * Título do período. `<span>` e não heading — ele rotula a toolbar, não abre
+ * seção de documento; como `h2` entraria no índice da página no mesmo nível das
+ * seções (medido na doc page do `Scheduler`).
+ */
+export declare const ganttTitle: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, string[], {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, string[], unknown, unknown, undefined>>;
+/**
+ * O texto do período. `truncate` mora AQUI e não na raiz do título.
+ *
+ * Na raiz, o `truncate` (que é `overflow:hidden` + `text-overflow`) se aplicava
+ * ao flex container e cortava o ícone junto quando o espaço apertava — o ícone
+ * é o primeiro filho, então sumia primeiro. No texto, quem encurta é só o texto.
+ */
+export declare const ganttTitleText: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, "min-w-0 truncate first-letter:uppercase", {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, "min-w-0 truncate first-letter:uppercase", unknown, unknown, undefined>>;
+/**
+ * Controle segmentado de VISÃO — trilho com pílula ativa.
+ *
+ * ⚠️ Isto é o `toolbarSegmented`/`toolbarSegmentedButton` do `TableToolbar`,
+ * token por token. É o mesmo controle que troca Tabela/Lista/Kanban na
+ * `DataTable`, e trocar de visão é a mesma ação nas duas telas — o usuário não
+ * deve aprender dois controles pro mesmo gesto.
+ *
+ * ⛔ Minha primeira versão eram dois `Button` de texto unidos pelo
+ * `ganttNavGroup`. Funcionava e estava ERRADO: eu disse que ia seguir o modelo
+ * do DS e inventei um controle, quando o modelo existia a um arquivo de
+ * distância. Trilho `bg-bg-muted` com pílula `bg-bg-accent` é uma gramática
+ * diferente de dois botões `outline` colados — não é detalhe de estilo, é outro
+ * componente visual.
+ *
+ * ⛔ Copiado e não importado: `ToolbarSegmented` vive em `ui/TableToolbar/`, e
+ * cross-import entre pastas de `ui/` gera `registryDependency` pendente (L-049).
+ */
+export declare const ganttViewSwitch: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, string[], {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, string[], unknown, unknown, undefined>>;
+export declare const ganttViewSwitchButton: import('tailwind-variants').TVReturnType<{
+    isActive: {
+        true: string;
+        false: string;
+    };
+}, undefined, string[], {
+    isActive: {
+        true: string;
+        false: string;
+    };
+}, undefined, import('tailwind-variants').TVReturnType<{
+    isActive: {
+        true: string;
+        false: string;
+    };
+}, undefined, string[], unknown, unknown, undefined>>;
+/**
+ * Divisor vertical entre grupos da toolbar.
+ *
+ * ⛔ Cópia do `toolbarDivider` do `TableToolbar` (1px × 24px, `border-default`,
+ * 6px de respiro, centrado). Mesma medida e mesmo token: é o mesmo separador
+ * lógico — "acabou um grupo de controles, começa outro" — e duas espessuras
+ * diferentes pra isso no mesmo produto é ruído.
+ */
+export declare const ganttToolbarDivider: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, "max-md:hidden mx-sp-sm h-[24px] w-sp-px shrink-0 self-center bg-border-default", {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, "max-md:hidden mx-sp-sm h-[24px] w-sp-px shrink-0 self-center bg-border-default", unknown, unknown, undefined>>;
+/**
+ * `‹ Hoje ›` — três botões `soft` colados, com moldura e divisórias de 1px.
+ *
+ * ## A borda é pintada por LADO, não por botão
+ *
+ * O `Button` já nasce com `border border-transparent` (padrão do DS, pra
+ * transição suave). Então não se acrescenta borda aqui — só se dá COR: topo e
+ * base em todos, ESQUERDA em todos, direita só no último. Lendo da esquerda pra
+ * direita isso desenha moldura e divisórias de uma vez — a esquerda do primeiro
+ * é o lado do quadro, a dos outros dois é a divisória com o vizinho.
+ *
+ * Três consequências de fazer assim, e as três importam:
+ *   - **A altura não muda.** O 1px já estava reservado nos quatro lados de cada
+ *     botão; colorir não empurra layout. Uma borda no CONTAINER somaria 2px e o
+ *     grupo ficaria mais alto que o seletor de visão (40px) ao lado.
+ *   - **Toda linha tem a MESMA espessura e a mesma cor.** Cada junção recebe
+ *     exatamente uma face colorida (a esquerda do botão da direita); a face que
+ *     encosta nela fica transparente. Sem isso, duas bordas de 1px encostadas
+ *     desenhariam uma divisória de 2px, o dobro da moldura.
+ *   - **Sem `-ml-px`.** No segmentado clássico ele existe pra colapsar essas duas
+ *     bordas em uma; aqui não há o que colapsar, e o overlap seria ATIVAMENTE
+ *     ruim: `border-input` é `oklch(1 0 0 / 0.08)` e `bg-bg-muted` é
+ *     `oklch(1 0 0 / 0.03)` — cores com ALPHA. Sobrepor 1px empilharia as duas
+ *     camadas e a divisória sairia ~2× mais forte que a moldura.
+ *
+ * Os cantos retos no miolo (`!rounded-none`, meio-raio nas pontas) completam o
+ * efeito: sem eles, três retângulos arredondados encostados desenham entalhes.
+ *
+ * A cor é a do botão secundário `outline` — `border-subtle` no light,
+ * `border-input` no dark —, porque é o mesmo papel: moldura de controle neutro.
+ *
+ * O `z-[1]` no foco fica: o `ring-4` de um botão do meio seria coberto pelos
+ * vizinhos, que encostam nele.
+ */
+export declare const ganttNavGroup: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, string[], {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, string[], unknown, unknown, undefined>>;
+/**
+ * Menu de opções da toolbar — o `md:hidden` do Gantt.
+ *
+ * ## Por que existe
+ *
+ * Medido a 375px ANTES dele: a barra ocupava duas linhas de 40px, o campo de
+ * busca era espremido a **51px** (o ícone e nada mais, impossível digitar) e o
+ * título do período saía cortado no meio ("3…"). Cinco controles disputando
+ * 335px não cabem, e `flex-wrap` só empilha o problema.
+ *
+ * ## A regra é a da `TableToolbar`, não uma invenção
+ *
+ * Lá o grupo esquerdo inteiro sai em <md (`max-md:hidden`) e o que ele
+ * continha reaparece no menu de Configurações, em seções inline marcadas
+ * `md:hidden`; a barra fica com **busca + ícones**. Aqui é o mesmo: seletor de
+ * visão, `‹ Hoje ›`, escala e caminho crítico saem da barra e viram seções
+ * deste menu.
+ *
+ * ⛔ **O título do período FICA.** É a única diferença, e é de conteúdo: a
+ * toolbar da tabela não tem rótulo de contexto pra preservar — a do Gantt tem,
+ * e "outubro 2026" é o que diz o que a tela está mostrando. Escondê-lo pra
+ * seguir a regra ao pé da letra deixaria o usuário sem saber que mês vê.
+ *
+ * A gramática visual é cópia do `toolbar-settings-menu`: `p-pad-sm` com
+ * `gap-px`, rótulo `caption-sm` maiúsculo em `fg-subtle`, separador `h-px`,
+ * item `px-pad-lg py-pad-md` de `fg-muted` pra `fg-default` no hover.
+ */
+export declare const ganttMobileMenu: import('tailwind-variants').TVReturnType<{
+    active: {
+        true: {
+            item: string;
+        };
+        false: {};
+    };
+}, {
+    trigger: string;
+    content: string;
+    label: string;
+    separator: string;
+    field: string;
+    item: string[];
+}, undefined, {
+    active: {
+        true: {
+            item: string;
+        };
+        false: {};
+    };
+}, {
+    trigger: string;
+    content: string;
+    label: string;
+    separator: string;
+    field: string;
+    item: string[];
+}, import('tailwind-variants').TVReturnType<{
+    active: {
+        true: {
+            item: string;
+        };
+        false: {};
+    };
+}, {
+    trigger: string;
+    content: string;
+    label: string;
+    separator: string;
+    field: string;
+    item: string[];
+}, undefined, unknown, unknown, undefined>>;
+/**
+ * Dentro do menu, os dois grupos de controle ocupam a LARGURA CHEIA.
+ *
+ * Na barra eles são `shrink-0` e do tamanho do conteúdo; num painel de 280px
+ * isso os deixaria encolhidos à esquerda com um vazio à direita. `fluid` é a
+ * mesma ideia do `ToolbarSegmented fluid` que a tabela passa pro menu dela.
+ */
+export declare const ganttMenuGroupFluid: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, "flex w-full [&>*]:flex-1", {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, "flex w-full [&>*]:flex-1", unknown, unknown, undefined>>;
+/**
+ * Esqueleto de carregamento.
+ *
+ * ## A silhueta é a mesma do conteúdo, e isso é a regra
+ *
+ * Copiada do `DataTableLoading`: o esqueleto usa o MESMO container do estado
+ * carregado (mesma borda, mesmo raio, mesma altura de linha) pra que a
+ * chegada do dado não desloque nada. Esqueleto de silhueta diferente troca
+ * "espera" por um salto de layout, que é pior que a espera.
+ *
+ * Por isso há três variantes, uma por visão: as três têm geometrias
+ * diferentes, e um esqueleto genérico saltaria em duas delas.
+ *
+ * `animate-pulse` é do Tailwind e não a `ds-pulse` da L-067 — esta última é a
+ * animação de ATENÇÃO do DS (um realce que chama), e aqui o pulso é de
+ * espera. São dois significados, e usar o de atenção pra espera faria o
+ * carregamento gritar.
+ */
+export declare const ganttSkeleton: import('tailwind-variants').TVReturnType<{
+    [key: string]: {
+        [key: string]: import('tailwind-merge').ClassNameValue | {
+            canvas?: import('tailwind-merge').ClassNameValue;
+            head?: import('tailwind-merge').ClassNameValue;
+            cell?: import('tailwind-merge').ClassNameValue;
+            grid?: import('tailwind-merge').ClassNameValue;
+            row?: import('tailwind-merge').ClassNameValue;
+            root?: import('tailwind-merge').ClassNameValue;
+            bar?: import('tailwind-merge').ClassNameValue;
+            pane?: import('tailwind-merge').ClassNameValue;
+        };
+    };
+} | {
+    [x: string]: {
+        [x: string]: import('tailwind-merge').ClassNameValue | {
+            canvas?: import('tailwind-merge').ClassNameValue;
+            head?: import('tailwind-merge').ClassNameValue;
+            cell?: import('tailwind-merge').ClassNameValue;
+            grid?: import('tailwind-merge').ClassNameValue;
+            row?: import('tailwind-merge').ClassNameValue;
+            root?: import('tailwind-merge').ClassNameValue;
+            bar?: import('tailwind-merge').ClassNameValue;
+            pane?: import('tailwind-merge').ClassNameValue;
+        };
+    };
+} | {}, {
+    root: string;
+    /** A faixa do cabeçalho do eixo — mesma altura do `ganttHead`. */
+    head: string;
+    /** Linha do corpo — a MESMA altura de `GANTT_ROW_HEIGHT_PX`. */
+    row: string;
+    /** O retângulo cinza que faz as vezes de texto ou de barra. */
+    bar: string;
+    /** Painel esquerdo da timeline — só ele tem borda de separação. */
+    pane: string;
+    canvas: string;
+    /** Célula da grade de mês. */
+    cell: string;
+    grid: string;
+}, undefined, {
+    [key: string]: {
+        [key: string]: import('tailwind-merge').ClassNameValue | {
+            canvas?: import('tailwind-merge').ClassNameValue;
+            head?: import('tailwind-merge').ClassNameValue;
+            cell?: import('tailwind-merge').ClassNameValue;
+            grid?: import('tailwind-merge').ClassNameValue;
+            row?: import('tailwind-merge').ClassNameValue;
+            root?: import('tailwind-merge').ClassNameValue;
+            bar?: import('tailwind-merge').ClassNameValue;
+            pane?: import('tailwind-merge').ClassNameValue;
+        };
+    };
+} | {}, {
+    root: string;
+    /** A faixa do cabeçalho do eixo — mesma altura do `ganttHead`. */
+    head: string;
+    /** Linha do corpo — a MESMA altura de `GANTT_ROW_HEIGHT_PX`. */
+    row: string;
+    /** O retângulo cinza que faz as vezes de texto ou de barra. */
+    bar: string;
+    /** Painel esquerdo da timeline — só ele tem borda de separação. */
+    pane: string;
+    canvas: string;
+    /** Célula da grade de mês. */
+    cell: string;
+    grid: string;
+}, import('tailwind-variants').TVReturnType<unknown, {
+    root: string;
+    /** A faixa do cabeçalho do eixo — mesma altura do `ganttHead`. */
+    head: string;
+    /** Linha do corpo — a MESMA altura de `GANTT_ROW_HEIGHT_PX`. */
+    row: string;
+    /** O retângulo cinza que faz as vezes de texto ou de barra. */
+    bar: string;
+    /** Painel esquerdo da timeline — só ele tem borda de separação. */
+    pane: string;
+    canvas: string;
+    /** Célula da grade de mês. */
+    cell: string;
+    grid: string;
+}, undefined, unknown, unknown, undefined>>;
+export declare const ganttSearch: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, string[], {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, string[], unknown, unknown, undefined>>;
+export declare const ganttSearchInput: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, string[], {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, string[], unknown, unknown, undefined>>;
+/**
+ * Linha dos filtros APLICADOS, abaixo da toolbar.
+ *
+ * ⚠️ Estes estilos são uma reprodução do `toolbarApplied*` do `TableToolbar`,
+ * token por token. A anatomia do chip da tabela não é preferência estética —
+ * é a experiência que o usuário já aprendeu em outra tela do mesmo produto.
+ * A minha primeira versão divergia em três pontos (× à direita, borda sólida
+ * brand, sem operador) e cada divergência era uma coisa a reaprender.
+ *
+ * O que documenta CADA decisão é o JSDoc de `gantt-applied-filters.tsx`.
+ *
+ * ## O divisor
+ *
+ * `16px → border-top → 16px → chips`, igual ao `toolbarApplied`. A linha
+ * importa porque a fileira de chips não é um controle da toolbar — é o resumo
+ * de um estado que ela produziu. Sem o divisor os chips liam como uma segunda
+ * fileira de botões.
+ *
+ * ⚠️ O espaçamento mora AQUI (`mt`/`pt`) e não como `gap` do pai: a linha só
+ * existe quando há filtro aplicado, e um `gap` no pai cobraria margem por uma
+ * linha ausente na maior parte do tempo.
+ *
+ * Rola na horizontal no mobile em vez de quebrar linha: no celular, 4 chips
+ * empilhados empurrariam a grade pra fora da tela.
+ *
+ * ⛔ Gramática copiada, não importada — cross-import entre pastas de `ui/` gera
+ * `registryDependency` pendente (L-049).
+ */
+export declare const ganttAppliedRow: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, string[], {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, string[], unknown, unknown, undefined>>;
+/**
+ * O chip. Borda **tracejada e neutra**, como na tabela.
+ *
+ * ⚠️ Era `border-solid border-border-brand bg-bg-brand-subtle` na minha versão,
+ * e estava errado: chip aplicado não precisa gritar — ele já É a prova de que
+ * algo está ligado. Sólido em brand fazia a linha competir com a grade, que é o
+ * conteúdo, e ainda colidia com o verde que aqui significa "hoje"/"selecionado".
+ *
+ * `shrink-0` porque no scroll horizontal do mobile (`flex-nowrap`) os chips não
+ * podem comprimir.
+ */
+export declare const ganttAppliedChip: import('tailwind-variants').TVReturnType<{
+    /** Clicável (abre as opções do campo). Sempre `true` hoje; ver o part. */
+    interactive: {
+        true: string[];
+        false: string;
+    };
+}, undefined, string[], {
+    /** Clicável (abre as opções do campo). Sempre `true` hoje; ver o part. */
+    interactive: {
+        true: string[];
+        false: string;
+    };
+}, undefined, import('tailwind-variants').TVReturnType<{
+    /** Clicável (abre as opções do campo). Sempre `true` hoje; ver o part. */
+    interactive: {
+        true: string[];
+        false: string;
+    };
+}, undefined, string[], unknown, unknown, undefined>>;
+/**
+ * O `⊗` de remover — à ESQUERDA do chip.
+ *
+ * ⚠️ Posição copiada da tabela, e ela tem razão de ser: à direita o alvo fica
+ * depois de um valor de largura variável e "dança" de posição entre chips; à
+ * esquerda todos ficam alinhados numa coluna, e limpar três filtros são três
+ * cliques sem reposicionar a mira.
+ */
+export declare const ganttAppliedChipRemove: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, string[], {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, string[], unknown, unknown, undefined>>;
+/** O nome do campo — "Frente", "Responsável". */
+export declare const ganttAppliedChipName: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, "font-semibold text-fg-default", {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, "font-semibold text-fg-default", unknown, unknown, undefined>>;
+/**
+ * O operador — "é".
+ *
+ * ⚠️ Minha versão não tinha. Sem ele o chip lê "Status Ativo", uma justaposição
+ * ambígua; com ele lê "Status é Ativo", que é a frase que o filtro executa.
+ */
+export declare const ganttAppliedChipOp: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, "text-caption-sm text-fg-muted", {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, "text-caption-sm text-fg-muted", unknown, unknown, undefined>>;
+/** Cada valor, em pílula própria. Um por valor até o limite do part. */
+export declare const ganttAppliedChipValue: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, string[], {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, string[], unknown, unknown, undefined>>;
+/**
+ * "Limpar todos" no fim da linha.
+ *
+ * Link e não `Button`: é a saída de um estado, não ação de primeira ordem — um
+ * botão de 40px ali competiria com os próprios chips.
+ */
+export declare const ganttClearLink: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, string[], {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, string[], unknown, unknown, undefined>>;
+/** Ponto no canto do botão de filtro — portador NÃO-cromático de "tem filtro". */
+export declare const ganttFilterDot: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, string[], {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, string[], unknown, unknown, undefined>>;
+/**
+ * Grupo de opções — um por campo, COLAPSÁVEL.
+ *
+ * Seção inteiriça com padding próprio e divisória de ponta a ponta: o painel
+ * não tem padding, quem paga o respiro é o grupo. É o que faz a linha chegar
+ * até as bordas, do jeito que se espera de uma lista de categorias — mesma
+ * anatomia do `schedulerAsideSection`.
+ */
+export declare const ganttFilterGroup: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, string[], {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, string[], unknown, unknown, undefined>>;
+/** Cabeçalho clicável do grupo — o alvo é a linha inteira, não só o chevron. */
+export declare const ganttFilterGroupHead: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, string[], {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, string[], unknown, unknown, undefined>>;
+export declare const ganttFilterGroupTitle: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, string[], {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, string[], unknown, unknown, undefined>>;
+/**
+ * Chevron do grupo. Rotação e não dois ícones: com dois, o nó troca no DOM e a
+ * transição não acontece — o chevron pisca em vez de girar.
+ */
+export declare const ganttFilterGroupChevron: import('tailwind-variants').TVReturnType<{
+    open: {
+        true: string;
+        false: string;
+    };
+}, undefined, "size-icon-sm shrink-0 text-fg-subtle transition-transform duration-200", {
+    open: {
+        true: string;
+        false: string;
+    };
+}, undefined, import('tailwind-variants').TVReturnType<{
+    open: {
+        true: string;
+        false: string;
+    };
+}, undefined, "size-icon-sm shrink-0 text-fg-subtle transition-transform duration-200", unknown, unknown, undefined>>;
+/**
+ * "Selecionar todas" / "Limpar" do grupo.
+ *
+ * Link e não `Button`: são ações de ajuste fino dentro de um grupo, e dois
+ * botões de 32px empilhados sobre a lista competiriam com as próprias opções
+ * pela atenção. Mesma decisão do `schedulerClearLink`.
+ */
+export declare const ganttFilterGroupActions: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, string[], {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, string[], unknown, unknown, undefined>>;
+/** Busca dentro do grupo — mesma gramática da busca da toolbar, menor. */
+export declare const ganttFilterSearch: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, string[], {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, string[], unknown, unknown, undefined>>;
+export declare const ganttFilterSearchInput: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, string[], {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, string[], unknown, unknown, undefined>>;
+/**
+ * Input de filtro de VALOR — `text`, `number`, `date`.
+ *
+ * Mesma gramática de campo do `ganttFilterSearch` (altura `form-md`, borda
+ * `border-subtle`/`border-input` no dark, anel de foco do DS), mas sem o ícone
+ * de lupa: aqui não se busca na lista, se declara um valor.
+ *
+ * ⛔ Não é `<Input>` do DS importado: `ui/Input` é outra pasta de `ui/`, e
+ * cross-import entre elas gera `registryDependency` pendente (L-049). O
+ * `FormField`/`Input` do DS entrariam se este fosse um formulário — é um
+ * controle de filtro dentro do próprio componente.
+ */
+export declare const ganttFilterInput: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, string[], {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, string[], unknown, unknown, undefined>>;
+/**
+ * A dupla de campos de uma FAIXA (`number`, `date`).
+ *
+ * Dois campos e não um só com máscara: "entre 3 e 10" tem dois valores
+ * independentes, e um deles pode ficar vazio (">= 3", "até 10"). Máscara única
+ * obrigaria a preencher os dois pra o filtro valer.
+ */
+export declare const ganttFilterRange: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, "flex items-center gap-gp-sm px-pad-xl pb-pad-sm", {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, "flex items-center gap-gp-sm px-pad-xl pb-pad-sm", unknown, unknown, undefined>>;
+/** O "e" entre os dois campos da faixa. */
+export declare const ganttFilterRangeSep: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, "shrink-0 text-caption-sm text-fg-muted", {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, "shrink-0 text-caption-sm text-fg-muted", unknown, unknown, undefined>>;
+/** Nenhuma opção casou com a busca do grupo. */
+export declare const ganttFilterEmpty: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, "px-pad-xl py-pad-md text-body-sm text-fg-muted", {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, "px-pad-xl py-pad-md text-body-sm text-fg-muted", unknown, unknown, undefined>>;
+/**
+ * Linha de opção do painel.
+ *
+ * `<label htmlFor>` nativo (L-025) — o alvo é o rótulo inteiro, e o clique
+ * propaga pro `Checkbox` real sem `onClick` intermediário.
+ */
+export declare const ganttFilterOption: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, string[], {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, string[], unknown, unknown, undefined>>;
+/**
+ * `className` aplicada no `Checkbox` REAL do DS — não uma caixa desenhada.
+ *
+ * ⚠️ A primeira versão pintava um `<span>` com um ícone de check dentro. Saía
+ * fora do padrão: sem o anel de foco do DS, sem os `data-state` do Radix, sem
+ * indeterminate, e com a marcação num tom que não era o do componente real.
+ *
+ * Aqui a cor da opção entra só na BORDA e no fundo do estado marcado, e o
+ * comportamento continua sendo o do `Checkbox`. É o mesmo recurso que o
+ * `schedulerOptionBox` usa, e a razão de o `Checkbox` aceitar `className`.
+ *
+ * A cor da caixa é a cor com que a barra aparece na grade — dispensa legenda.
+ */
+export declare const ganttFilterOptionBox: import('tailwind-variants').TVReturnType<{
+    colorKey: {
+        "chart-1": string;
+        "chart-2": string;
+        "chart-3": string;
+        "chart-4": string;
+        "chart-5": string;
+        brand: string;
+        success: string;
+        warning: string;
+        danger: string;
+        info: string;
+        neutral: string;
+    };
+}, undefined, "shrink-0 transition-colors duration-150", {
+    colorKey: {
+        "chart-1": string;
+        "chart-2": string;
+        "chart-3": string;
+        "chart-4": string;
+        "chart-5": string;
+        brand: string;
+        success: string;
+        warning: string;
+        danger: string;
+        info: string;
+        neutral: string;
+    };
+}, undefined, import('tailwind-variants').TVReturnType<{
+    colorKey: {
+        "chart-1": string;
+        "chart-2": string;
+        "chart-3": string;
+        "chart-4": string;
+        "chart-5": string;
+        brand: string;
+        success: string;
+        warning: string;
+        danger: string;
+        info: string;
+        neutral: string;
+    };
+}, undefined, "shrink-0 transition-colors duration-150", unknown, unknown, undefined>>;
+export declare const ganttFilterOptionLabel: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, "min-w-0 flex-1 truncate text-body-sm text-fg-default", {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, "min-w-0 flex-1 truncate text-body-sm text-fg-default", unknown, unknown, undefined>>;
+/** Contagem por opção, e o "Todas" do título do grupo. */
+export declare const ganttFilterOptionCount: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, "shrink-0 text-caption-sm tabular-nums text-fg-subtle", {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, "shrink-0 text-caption-sm tabular-nums text-fg-subtle", unknown, unknown, undefined>>;
+/**
+ * A área abaixo da toolbar.
+ *
+ * ⚠️ A moldura é VARIANTE porque as duas visões a resolvem em lugares
+ * diferentes. Na `timeline` quem molda é este contêiner (os dois painéis vivem
+ * dentro dele e o divisor os separa). Na `calendar` quem molda é o
+ * `ganttMonthFrame`, que traz borda e radius próprios — deixar as duas ligadas
+ * desenhava **duas bordas concêntricas** separadas por 1px.
+ */
+export declare const ganttBody: import('tailwind-variants').TVReturnType<{
+    framed: {
+        true: string;
+        false: string;
+    };
+}, undefined, "flex min-h-0 flex-1 overflow-hidden", {
+    framed: {
+        true: string;
+        false: string;
+    };
+}, undefined, import('tailwind-variants').TVReturnType<{
+    framed: {
+        true: string;
+        false: string;
+    };
+}, undefined, "flex min-h-0 flex-1 overflow-hidden", unknown, unknown, undefined>>;
+/** Painel esquerdo: a grade de linhas. */
+export declare const ganttGridPane: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, string[], {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, string[], unknown, unknown, undefined>>;
+/**
+ * Divisor arrastável entre os painéis.
+ *
+ * ## `w-[3px]`, e o alvo do ponteiro é maior que a linha
+ *
+ * Esta é a ÚNICA linha entre os dois painéis — o `ganttGridPane` não tem borda
+ * direita de propósito (ver a nota lá). Então a espessura dela é a espessura da
+ * separação.
+ *
+ * ⚠️ 3px, e a ordem em que chegamos aqui importa: passamos por 5px enquanto a
+ * cor ainda era `border-default`. Com a cor certa, 5px viraram excesso — era
+ * **contraste** que faltava, e espessura tinha sido usada como substituto. Se
+ * alguém for engrossar esta linha de novo, cheque primeiro se o problema não é
+ * a cor: foi duas vezes.
+ *
+ * O `after` estende o alvo do ponteiro 4px pra cada lado — 11px de área contra
+ * 3px de linha. Alvo do tamanho da linha é frustrante mesmo com mouse, e aqui a
+ * linha é fina por decisão visual, não por ser pequena de propósito.
+ *
+ * ## `bg-scrollbar-thumb` e não `border-default`
+ *
+ * Este componente tem TRÊS degraus de linha, e eles precisam ser distinguíveis
+ * por cor, não só por espessura. ΔL contra a superfície onde cada uma vive:
+ *
+ *   papel                    token                  dark    light
+ *   coluna do dia (1px)      border-subtle          0.031   0.069
+ *   virada de mês (2px)      border-input           0.062   0.124
+ *   os dois painéis (3px)    bg-scrollbar-thumb/70  0.132   0.171
+ *
+ * ⚠️ O `/70` é diluição DELIBERADA, não descuido. Em 24% cheios (0.186/0.240) a
+ * linha ficou forte demais — ela é estrutura de fundo, e competia com a barra,
+ * que é conteúdo. E não há degrau intermediário no vocabulário neutro: entre
+ * `scrollbar-thumb` (24%) e `border-input` (8%) só existe `bg-accent-hover`
+ * (16%), cujo nome é de ESTADO — usar um token `-hover` como preenchimento em
+ * repouso engana quem lê depois.
+ *
+ * Diluir o token certo é mais honesto que apropriar o token errado, e o DS já
+ * faz isso em `bg-bg-subtle/50` e `bg-bg-brand/30` neste mesmo arquivo. ⛔ Não
+ * confundir com a L-001, que proíbe alpha em token de **ring** (lá o alpha já
+ * vem embutido).
+ *
+ * Era `border-default`, que dá **0.040 no dark** — praticamente a linha de
+ * coluna (0.031). Um separador de painel que some é pior que uma linha de 1px
+ * que se vê: a espessura promete estrutura e a cor não entrega.
+ *
+ * ⚠️ `bg-scrollbar-thumb` NÃO é oportunismo de valor — é o token cujo papel
+ * casa: "barra neutra fina que o usuário agarra". É literalmente o que este
+ * divisor é. Descartei `border-input` (viraria a MESMA cor da virada de mês,
+ * achatando o sistema em dois degraus) e `bg-accent-hover` (número bom, mas
+ * usar um token `-hover` como preenchimento em repouso engana quem lê depois).
+ *
+ * ⚠️ Não existe degrau neutro mais forte que sirva nos dois modos: os tokens de
+ * `bg-emphasis`/`bg-accent` sobem no dark e DESCEM no light (0.060 contra os
+ * 0.092 de hoje). Se precisar de mais, o próximo passo é `fg-disabled`
+ * (0.135/0.298) — e aí já é uma barra cinza, não uma divisória.
+ */
+export declare const ganttSplitter: import('tailwind-variants').TVReturnType<{
+    active: {
+        true: string;
+        false: string;
+    };
+}, undefined, string[], {
+    active: {
+        true: string;
+        false: string;
+    };
+}, undefined, import('tailwind-variants').TVReturnType<{
+    active: {
+        true: string;
+        false: string;
+    };
+}, undefined, string[], unknown, unknown, undefined>>;
+/** Painel direito: cabeçalho fixo + canvas rolável. */
+export declare const ganttTimelinePane: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, "flex min-w-0 min-h-0 flex-1 flex-col", {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, "flex min-w-0 min-h-0 flex-1 flex-col", unknown, unknown, undefined>>;
+/**
+ * Cabeçalho do eixo.
+ *
+ * ⚠️ **Vive DENTRO do scroller horizontal**, não fora dele.
+ *
+ * Fora, ele ficava imóvel enquanto o canvas rolava para o lado — as colunas do
+ * eixo desalinhavam das colunas da grade, e o rótulo "12" passava a ficar em
+ * cima do dia 20. Foi o defeito #5 reportado.
+ *
+ * `sticky top-0` prende só na VERTICAL: rolando pra baixo o cabeçalho fica,
+ * rolando pra o lado ele acompanha. É o comportamento que as 13 referências
+ * têm, e ele só é possível com o cabeçalho e o canvas no mesmo contêiner
+ * rolável.
+ */
+export declare const ganttHead: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, string[], {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, string[], unknown, unknown, undefined>>;
+/**
+ * Faixa do cabeçalho — `relative`, e as células dentro são ABSOLUTAS.
+ *
+ * ⚠️ Era `flex`, e é o defeito #5b: com `pxPerDay` fracionário (trimestre =
+ * 190/91 ≈ 2.088px/dia) o fluxo do flex acumula a largura item a item e o
+ * navegador arredonda cada caixa ao pixel do dispositivo, enquanto as colunas
+ * do canvas são posicionadas por `left` absoluto. As duas contas dão o mesmo
+ * número em ponto flutuante e pixels DIFERENTES na tela — as divisórias do
+ * grupo, da unidade e do conteúdo saíam desalinhadas ao longo do eixo.
+ *
+ * Em `day` o efeito não aparecia porque 46px/dia é inteiro. É a L-038 outra
+ * vez: a mesma posição derivada em dois lugares. Agora as TRÊS camadas leem
+ * `dateToX`.
+ */
+export declare const ganttHeadRow: import('tailwind-variants').TVReturnType<{
+    level: {
+        /** Nível de cima: mês/ano. Divisória mais forte entre grupos. */
+        group: string;
+        /** Nível de baixo: a unidade da grade. */
+        unit: string;
+    };
+}, undefined, "relative", {
+    level: {
+        /** Nível de cima: mês/ano. Divisória mais forte entre grupos. */
+        group: string;
+        /** Nível de baixo: a unidade da grade. */
+        unit: string;
+    };
+}, undefined, import('tailwind-variants').TVReturnType<{
+    level: {
+        /** Nível de cima: mês/ano. Divisória mais forte entre grupos. */
+        group: string;
+        /** Nível de baixo: a unidade da grade. */
+        unit: string;
+    };
+}, undefined, "relative", unknown, unknown, undefined>>;
+export declare const ganttHeadCell: import('tailwind-variants').TVReturnType<{
+    level: {
+        group: string;
+        /**
+         * #10 — a unidade EMPILHA: abreviação do dia em cima, número embaixo e
+         * maior. Lado a lado (`S 21`), o par competia por largura com a
+         * divisória; empilhado, a data ganha peso e a abreviação vira legenda.
+         */
+        unit: string;
+    };
+    /** Fim de semana: coluna sombreada, e o rótulo desce um tom. */
+    weekend: {
+        true: string;
+        false: string;
+    };
+    today: {
+        true: string;
+        false: string;
+    };
+    /** #2 — coluna selecionada por clique: cabeçalho no verde da marca. */
+    selected: {
+        true: string;
+        false: string;
+    };
+    /**
+     * #1 — última unidade de um grupo (o último dia do mês, em `day`).
+     *
+     * Divisória mais grossa e mais clara, atravessando o cabeçalho inteiro e o
+     * conteúdo: é o que faz o mês ler como um BLOCO em vez de uma fileira
+     * contínua de dias. O limite vem de `axis.groups`, então acompanha a escala
+     * — vira mês em `day`/`week` e ano em `month`/`quarter`.
+     *
+     * ⚠️ `border-input` foi ESCOLHIDO por medição, não por nome. ΔL de cada
+     * candidato contra a superfície onde a linha vive:
+     *
+     *   token                  dark (bg 0.225)   light (bg 1.0)   × a linha comum
+     *   border-subtle (comum)      0.031             0.069            1.0×
+     *   border-default             0.040             0.092            1.3× / 1.3×
+     *   border-input               0.062             0.124            2.0× / 1.8×
+     *   chart-grid                 0.093             0.092            3.0× / 1.3×
+     *
+     * Três voltas até aqui, e cada uma ensinou algo:
+     *
+     * 1. `border-default` a 2px ficou **invisível** — 0.040 contra 0.031 é a MESMA
+     *    linha. Eu tinha medido que o valor do token mudou, não que a mudança se
+     *    vê; espessura não compra o que falta em contraste.
+     * 2. `chart-grid` a 3px resolveu o contraste e passou do ponto nos dois
+     *    eixos: 3px vira moldura, e 3× a linha comum vira estrutura competindo
+     *    com a barra.
+     * 3. `border-input` a 2px é o degrau do meio, e é o único candidato que fica
+     *    em ~2× nos DOIS modos — por isso não precisa de par `dark:`. Menos
+     *    classe e sem risco de os dois modos divergirem na próxima edição.
+     *
+     * ⛔ Não meça isto durante a transição: a coluna tem `transition-colors`, e
+     * ler no meio dela devolve o valor interpolado (serializado em `oklab`, que é
+     * a pista). Já me enganou uma vez nesta mesma linha.
+     *
+     * ⛔ Não troque por um token de marca: o verde já significa "hoje" e
+     * "selecionado" aqui, e a virada de mês não é nem uma nem outra.
+     */
+    boundary: {
+        true: string;
+        false: string;
+    };
+}, undefined, string[], {
+    level: {
+        group: string;
+        /**
+         * #10 — a unidade EMPILHA: abreviação do dia em cima, número embaixo e
+         * maior. Lado a lado (`S 21`), o par competia por largura com a
+         * divisória; empilhado, a data ganha peso e a abreviação vira legenda.
+         */
+        unit: string;
+    };
+    /** Fim de semana: coluna sombreada, e o rótulo desce um tom. */
+    weekend: {
+        true: string;
+        false: string;
+    };
+    today: {
+        true: string;
+        false: string;
+    };
+    /** #2 — coluna selecionada por clique: cabeçalho no verde da marca. */
+    selected: {
+        true: string;
+        false: string;
+    };
+    /**
+     * #1 — última unidade de um grupo (o último dia do mês, em `day`).
+     *
+     * Divisória mais grossa e mais clara, atravessando o cabeçalho inteiro e o
+     * conteúdo: é o que faz o mês ler como um BLOCO em vez de uma fileira
+     * contínua de dias. O limite vem de `axis.groups`, então acompanha a escala
+     * — vira mês em `day`/`week` e ano em `month`/`quarter`.
+     *
+     * ⚠️ `border-input` foi ESCOLHIDO por medição, não por nome. ΔL de cada
+     * candidato contra a superfície onde a linha vive:
+     *
+     *   token                  dark (bg 0.225)   light (bg 1.0)   × a linha comum
+     *   border-subtle (comum)      0.031             0.069            1.0×
+     *   border-default             0.040             0.092            1.3× / 1.3×
+     *   border-input               0.062             0.124            2.0× / 1.8×
+     *   chart-grid                 0.093             0.092            3.0× / 1.3×
+     *
+     * Três voltas até aqui, e cada uma ensinou algo:
+     *
+     * 1. `border-default` a 2px ficou **invisível** — 0.040 contra 0.031 é a MESMA
+     *    linha. Eu tinha medido que o valor do token mudou, não que a mudança se
+     *    vê; espessura não compra o que falta em contraste.
+     * 2. `chart-grid` a 3px resolveu o contraste e passou do ponto nos dois
+     *    eixos: 3px vira moldura, e 3× a linha comum vira estrutura competindo
+     *    com a barra.
+     * 3. `border-input` a 2px é o degrau do meio, e é o único candidato que fica
+     *    em ~2× nos DOIS modos — por isso não precisa de par `dark:`. Menos
+     *    classe e sem risco de os dois modos divergirem na próxima edição.
+     *
+     * ⛔ Não meça isto durante a transição: a coluna tem `transition-colors`, e
+     * ler no meio dela devolve o valor interpolado (serializado em `oklab`, que é
+     * a pista). Já me enganou uma vez nesta mesma linha.
+     *
+     * ⛔ Não troque por um token de marca: o verde já significa "hoje" e
+     * "selecionado" aqui, e a virada de mês não é nem uma nem outra.
+     */
+    boundary: {
+        true: string;
+        false: string;
+    };
+}, undefined, import('tailwind-variants').TVReturnType<{
+    level: {
+        group: string;
+        /**
+         * #10 — a unidade EMPILHA: abreviação do dia em cima, número embaixo e
+         * maior. Lado a lado (`S 21`), o par competia por largura com a
+         * divisória; empilhado, a data ganha peso e a abreviação vira legenda.
+         */
+        unit: string;
+    };
+    /** Fim de semana: coluna sombreada, e o rótulo desce um tom. */
+    weekend: {
+        true: string;
+        false: string;
+    };
+    today: {
+        true: string;
+        false: string;
+    };
+    /** #2 — coluna selecionada por clique: cabeçalho no verde da marca. */
+    selected: {
+        true: string;
+        false: string;
+    };
+    /**
+     * #1 — última unidade de um grupo (o último dia do mês, em `day`).
+     *
+     * Divisória mais grossa e mais clara, atravessando o cabeçalho inteiro e o
+     * conteúdo: é o que faz o mês ler como um BLOCO em vez de uma fileira
+     * contínua de dias. O limite vem de `axis.groups`, então acompanha a escala
+     * — vira mês em `day`/`week` e ano em `month`/`quarter`.
+     *
+     * ⚠️ `border-input` foi ESCOLHIDO por medição, não por nome. ΔL de cada
+     * candidato contra a superfície onde a linha vive:
+     *
+     *   token                  dark (bg 0.225)   light (bg 1.0)   × a linha comum
+     *   border-subtle (comum)      0.031             0.069            1.0×
+     *   border-default             0.040             0.092            1.3× / 1.3×
+     *   border-input               0.062             0.124            2.0× / 1.8×
+     *   chart-grid                 0.093             0.092            3.0× / 1.3×
+     *
+     * Três voltas até aqui, e cada uma ensinou algo:
+     *
+     * 1. `border-default` a 2px ficou **invisível** — 0.040 contra 0.031 é a MESMA
+     *    linha. Eu tinha medido que o valor do token mudou, não que a mudança se
+     *    vê; espessura não compra o que falta em contraste.
+     * 2. `chart-grid` a 3px resolveu o contraste e passou do ponto nos dois
+     *    eixos: 3px vira moldura, e 3× a linha comum vira estrutura competindo
+     *    com a barra.
+     * 3. `border-input` a 2px é o degrau do meio, e é o único candidato que fica
+     *    em ~2× nos DOIS modos — por isso não precisa de par `dark:`. Menos
+     *    classe e sem risco de os dois modos divergirem na próxima edição.
+     *
+     * ⛔ Não meça isto durante a transição: a coluna tem `transition-colors`, e
+     * ler no meio dela devolve o valor interpolado (serializado em `oklab`, que é
+     * a pista). Já me enganou uma vez nesta mesma linha.
+     *
+     * ⛔ Não troque por um token de marca: o verde já significa "hoje" e
+     * "selecionado" aqui, e a virada de mês não é nem uma nem outra.
+     */
+    boundary: {
+        true: string;
+        false: string;
+    };
+}, undefined, string[], unknown, unknown, undefined>>;
+/**
+ * Abreviação do dia da semana — a linha de cima da célula.
+ *
+ * `caption-xs` e cor `subtle`: é legenda da data, não a informação. Com o mesmo
+ * peso do número, os dois competiam e a coluna virava um bloco de texto.
+ */
+export declare const ganttHeadWeekday: import('tailwind-variants').TVReturnType<{
+    weekend: {
+        true: string;
+        false: string;
+    };
+}, undefined, "text-caption-xs leading-none text-fg-subtle", {
+    weekend: {
+        true: string;
+        false: string;
+    };
+}, undefined, import('tailwind-variants').TVReturnType<{
+    weekend: {
+        true: string;
+        false: string;
+    };
+}, undefined, "text-caption-xs leading-none text-fg-subtle", unknown, unknown, undefined>>;
+/** O número do dia. `tabular-nums` pra a coluna não dançar entre 9 e 10. */
+export declare const ganttHeadDayNumber: import('tailwind-variants').TVReturnType<{
+    today: {
+        true: string;
+        false: string;
+    };
+}, undefined, "mt-[2px] text-body-sm leading-none tabular-nums", {
+    today: {
+        true: string;
+        false: string;
+    };
+}, undefined, import('tailwind-variants').TVReturnType<{
+    today: {
+        true: string;
+        false: string;
+    };
+}, undefined, "mt-[2px] text-body-sm leading-none tabular-nums", unknown, unknown, undefined>>;
+/** Cabeçalho da grade esquerda — alinha com os dois níveis da direita. */
+/**
+ * Cabeçalho da grade esquerda.
+ *
+ * ⚠️ `items-center` e não `items-end`.
+ *
+ * O cabeçalho tem a altura dos DOIS níveis do eixo da direita (68px), mas do
+ * lado esquerdo existe um nível só. Alinhado embaixo, ele deixava ~38px de área
+ * branca acima dos rótulos, e a grade parecia começar torta em relação ao eixo.
+ * Centrado, o espaço se distribui e os dois lados leem como o mesmo cabeçalho.
+ */
+export declare const ganttGridHead: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, string[], {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, string[], unknown, unknown, undefined>>;
+export declare const ganttGridHeadCell: import('tailwind-variants').TVReturnType<{
+    align: {
+        left: string;
+        center: string;
+        right: string;
+    };
+}, undefined, string[], {
+    align: {
+        left: string;
+        center: string;
+        right: string;
+    };
+}, undefined, import('tailwind-variants').TVReturnType<{
+    align: {
+        left: string;
+        center: string;
+        right: string;
+    };
+}, undefined, string[], unknown, unknown, undefined>>;
+/** Linha da grade esquerda. */
+export declare const ganttGridRow: import('tailwind-variants').TVReturnType<{
+    type: {
+        task: string;
+        /** `summary` é agrupador: peso maior e fundo levemente destacado. */
+        summary: string;
+        milestone: string;
+    };
+    /**
+     * #7 — linha selecionada, no verde da marca.
+     *
+     * Mesma leitura da linha selecionada do `DataTable`: a cor da marca diz "é
+     * esta que estou olhando". Vence o hover no `compoundVariant` abaixo —
+     * senão passar o mouse sobre a linha selecionada a apagava.
+     */
+    selected: {
+        true: string;
+        false: string;
+    };
+    /**
+     * #3 — hover CRUZADO, controlado por estado e não por `:hover` do CSS.
+     *
+     * `:hover` só acende o elemento sob o cursor, e aqui a linha vive em DOIS
+     * painéis irmãos: passar o mouse no nome tem que acender a faixa da barra e
+     * vice-versa. Nenhum seletor CSS alcança um irmão de outro contêiner, então
+     * o índice da linha sob o cursor é estado do React.
+     *
+     * ⚠️ `bg-bg-muted` e não `bg-bg-subtle`: no dark, `subtle` é
+     * `oklch(1 0 0 / 0.01)` — 1% de branco, que é **invisível** na prática.
+     * Medi o hover e o antes/depois diferiam em 1 centésimo de alfa. `muted` é
+     * 3%, e ainda foi preciso somar a borda pra o realce se ler.
+     */
+    hovered: {
+        true: string;
+        false: string;
+    };
+}, undefined, string[], {
+    type: {
+        task: string;
+        /** `summary` é agrupador: peso maior e fundo levemente destacado. */
+        summary: string;
+        milestone: string;
+    };
+    /**
+     * #7 — linha selecionada, no verde da marca.
+     *
+     * Mesma leitura da linha selecionada do `DataTable`: a cor da marca diz "é
+     * esta que estou olhando". Vence o hover no `compoundVariant` abaixo —
+     * senão passar o mouse sobre a linha selecionada a apagava.
+     */
+    selected: {
+        true: string;
+        false: string;
+    };
+    /**
+     * #3 — hover CRUZADO, controlado por estado e não por `:hover` do CSS.
+     *
+     * `:hover` só acende o elemento sob o cursor, e aqui a linha vive em DOIS
+     * painéis irmãos: passar o mouse no nome tem que acender a faixa da barra e
+     * vice-versa. Nenhum seletor CSS alcança um irmão de outro contêiner, então
+     * o índice da linha sob o cursor é estado do React.
+     *
+     * ⚠️ `bg-bg-muted` e não `bg-bg-subtle`: no dark, `subtle` é
+     * `oklch(1 0 0 / 0.01)` — 1% de branco, que é **invisível** na prática.
+     * Medi o hover e o antes/depois diferiam em 1 centésimo de alfa. `muted` é
+     * 3%, e ainda foi preciso somar a borda pra o realce se ler.
+     */
+    hovered: {
+        true: string;
+        false: string;
+    };
+}, undefined, import('tailwind-variants').TVReturnType<{
+    type: {
+        task: string;
+        /** `summary` é agrupador: peso maior e fundo levemente destacado. */
+        summary: string;
+        milestone: string;
+    };
+    /**
+     * #7 — linha selecionada, no verde da marca.
+     *
+     * Mesma leitura da linha selecionada do `DataTable`: a cor da marca diz "é
+     * esta que estou olhando". Vence o hover no `compoundVariant` abaixo —
+     * senão passar o mouse sobre a linha selecionada a apagava.
+     */
+    selected: {
+        true: string;
+        false: string;
+    };
+    /**
+     * #3 — hover CRUZADO, controlado por estado e não por `:hover` do CSS.
+     *
+     * `:hover` só acende o elemento sob o cursor, e aqui a linha vive em DOIS
+     * painéis irmãos: passar o mouse no nome tem que acender a faixa da barra e
+     * vice-versa. Nenhum seletor CSS alcança um irmão de outro contêiner, então
+     * o índice da linha sob o cursor é estado do React.
+     *
+     * ⚠️ `bg-bg-muted` e não `bg-bg-subtle`: no dark, `subtle` é
+     * `oklch(1 0 0 / 0.01)` — 1% de branco, que é **invisível** na prática.
+     * Medi o hover e o antes/depois diferiam em 1 centésimo de alfa. `muted` é
+     * 3%, e ainda foi preciso somar a borda pra o realce se ler.
+     */
+    hovered: {
+        true: string;
+        false: string;
+    };
+}, undefined, string[], unknown, unknown, undefined>>;
+/**
+ * Célula da grade.
+ *
+ * ⚠️ `text-body-sm` na base NÃO é redundante com o `ganttGridLabelText`.
+ *
+ * Só a PRIMEIRA célula usa aquele estilo; as outras (data, duração, %) não
+ * tinham preset nenhum e herdavam os **16px do body** — medido: numa linha de
+ * 44px a data renderizava em 16px, quase o dobro do vizinho, e a coluna parecia
+ * outro componente. É a L-007 na prática: tipografia avulsa por omissão.
+ */
+export declare const ganttGridCell: import('tailwind-variants').TVReturnType<{
+    align: {
+        left: string;
+        center: string;
+        right: string;
+    };
+    /** Coluna de número/data: `tabular-nums` pra alinhar dígito com dígito. */
+    numeric: {
+        true: string;
+        false: string;
+    };
+    /**
+     * #6 — hierarquia dentro da linha.
+     *
+     * O nome da tarefa é a informação; data, duração e responsável são apoio.
+     * Com todos em `fg-default` e o mesmo peso, as quatro colunas disputavam a
+     * atenção e a grade lia como um bloco de texto. `muted` + `font-normal`
+     * recua o apoio sem escondê-lo.
+     */
+    tone: {
+        default: string;
+        muted: string;
+    };
+}, undefined, string[], {
+    align: {
+        left: string;
+        center: string;
+        right: string;
+    };
+    /** Coluna de número/data: `tabular-nums` pra alinhar dígito com dígito. */
+    numeric: {
+        true: string;
+        false: string;
+    };
+    /**
+     * #6 — hierarquia dentro da linha.
+     *
+     * O nome da tarefa é a informação; data, duração e responsável são apoio.
+     * Com todos em `fg-default` e o mesmo peso, as quatro colunas disputavam a
+     * atenção e a grade lia como um bloco de texto. `muted` + `font-normal`
+     * recua o apoio sem escondê-lo.
+     */
+    tone: {
+        default: string;
+        muted: string;
+    };
+}, undefined, import('tailwind-variants').TVReturnType<{
+    align: {
+        left: string;
+        center: string;
+        right: string;
+    };
+    /** Coluna de número/data: `tabular-nums` pra alinhar dígito com dígito. */
+    numeric: {
+        true: string;
+        false: string;
+    };
+    /**
+     * #6 — hierarquia dentro da linha.
+     *
+     * O nome da tarefa é a informação; data, duração e responsável são apoio.
+     * Com todos em `fg-default` e o mesmo peso, as quatro colunas disputavam a
+     * atenção e a grade lia como um bloco de texto. `muted` + `font-normal`
+     * recua o apoio sem escondê-lo.
+     */
+    tone: {
+        default: string;
+        muted: string;
+    };
+}, undefined, string[], unknown, unknown, undefined>>;
+/**
+ * #1 — a linha `summary` é um CABEÇALHO de grupo, não uma linha de dados.
+ *
+ * Ela atravessa a grade inteira em vez de caber na primeira coluna. Confinada,
+ * "1. Descoberta e escopo" truncava em "1. Desco…" com as colunas de Duração e
+ * Resp. vazias ao lado — texto cortado por causa de espaço que estava logo ali,
+ * sem uso. É o mesmo tratamento que linha de grupo recebe em data grid.
+ */
+export declare const ganttGridGroupCell: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, string[], {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, string[], unknown, unknown, undefined>>;
+/**
+ * Conectores de árvore — o "├" e o "└" que ligam a linha ao pai.
+ *
+ * ## Por que virou conector e não guia
+ *
+ * A primeira versão desenhava só a vertical por nível ("guia"), e ficou ruim:
+ * a linha passava ao lado do nome sem tocá-lo, então lia como divisória de
+ * coluna, não como vínculo. O que diz "sou filho DESTE" é o **cotovelo** — a
+ * vertical que desce do pai e vira à direita na altura do meu texto.
+ *
+ * ## Anatomia de uma coluna de recuo
+ *
+ * Cada nível de profundidade tem uma coluna de 16px. Numa linha em `depth d`:
+ *
+ *   colunas 0 .. d-2   →  PASS-THROUGH: só a vertical, e só se o ancestral
+ *                          daquele nível ainda tiver irmão abaixo
+ *   coluna  d-1        →  o COTOVELO desta linha:
+ *                          vertical do topo até o meio (sempre)
+ *                          + vertical do meio até a base (só se NÃO for o último)
+ *                          + horizontal do meio até a direita (sempre)
+ *
+ * Anatomia copiada do `hierarchicalLayout` do `List`, que é a implementação
+ * que já pagou o preço de acertar o índice (L-045).
+ */
+export declare const ganttTreeRail: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, "pointer-events-none absolute inset-y-0 left-pad-2xl", {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, "pointer-events-none absolute inset-y-0 left-pad-2xl", unknown, unknown, undefined>>;
+/**
+ * Uma coluna de recuo. `relative` porque os segmentos se posicionam dentro dela.
+ *
+ * ⚠️ A largura tem que ser a MESMA do `paddingLeft: depth * 16` do rótulo. As
+ * duas medidas são a mesma coisa em lugares diferentes — se divergirem, o
+ * cotovelo aponta pro vazio ao lado do texto (L-038).
+ */
+export declare const ganttTreeColumn: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, "absolute inset-y-0 w-[16px]", {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, "absolute inset-y-0 w-[16px]", unknown, unknown, undefined>>;
+/**
+ * Um segmento de linha do conector.
+ *
+ * ⚠️ `border-input`, e cheguei nele **errando duas vezes o mesmo raciocínio**.
+ * ΔL sobre a superfície da grade, no dark:
+ *
+ *   border-subtle    0.031   = a divisória de linha. O conector se dissolvia
+ *                              DENTRO da grade — virava mais uma linha da malha.
+ *   border-default   0.040   1ª tentativa. Escrevi aqui que "a linha é curta e o
+ *                              olho segue o desenho, o degrau basta" — afirmação
+ *                              que eu NÃO verifiquei. Na tela não se via nada.
+ *   border-input     0.062   2× a divisória. O conector é um GRAFO deliberado,
+ *                              não fundo: tem que ganhar da malha que atravessa.
+ *
+ * A lição é a mesma que já me pegou na virada de mês e no divisor dos painéis:
+ * trocar de token e conferir que o VALOR mudou não é conferir que a mudança se
+ * VÊ. Aqui eu ainda por cima escrevi a garantia no comentário (L-060).
+ */
+export declare const ganttTreeSegment: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, "absolute bg-border-input", {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, "absolute bg-border-input", unknown, unknown, undefined>>;
+export declare const ganttGridLabel: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, "flex min-w-0 flex-col justify-center", {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, "flex min-w-0 flex-col justify-center", unknown, unknown, undefined>>;
+export declare const ganttGridLabelText: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, "truncate text-body-sm text-fg-default", {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, "truncate text-body-sm text-fg-default", unknown, unknown, undefined>>;
+export declare const ganttGridSublabel: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, "truncate text-caption-sm font-normal text-fg-muted", {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, "truncate text-caption-sm font-normal text-fg-muted", unknown, unknown, undefined>>;
+/**
+ * Chevron do collapse.
+ *
+ * Rotação e não dois ícones: com dois ícones o nó troca no DOM e a transição
+ * não acontece — o chevron "pisca" em vez de girar.
+ */
+export declare const ganttChevron: import('tailwind-variants').TVReturnType<{
+    open: {
+        true: string;
+        false: string;
+    };
+    /** Folha: reserva o espaço sem desenhar o chevron, pra o rótulo alinhar. */
+    hidden: {
+        true: string;
+        false: string;
+    };
+}, undefined, string[], {
+    open: {
+        true: string;
+        false: string;
+    };
+    /** Folha: reserva o espaço sem desenhar o chevron, pra o rótulo alinhar. */
+    hidden: {
+        true: string;
+        false: string;
+    };
+}, undefined, import('tailwind-variants').TVReturnType<{
+    open: {
+        true: string;
+        false: string;
+    };
+    /** Folha: reserva o espaço sem desenhar o chevron, pra o rótulo alinhar. */
+    hidden: {
+        true: string;
+        false: string;
+    };
+}, undefined, string[], unknown, unknown, undefined>>;
+export declare const ganttCanvasScroll: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, string[], {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, string[], unknown, unknown, undefined>>;
+/** Camada de posicionamento — `relative`, e é a origem de todo `top`/`left`. */
+export declare const ganttCanvas: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, "relative", {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, "relative", unknown, unknown, undefined>>;
+/** Linha de fundo do canvas — o par visual da linha da grade esquerda. */
+export declare const ganttCanvasRow: import('tailwind-variants').TVReturnType<{
+    type: {
+        task: string;
+        summary: string;
+        milestone: string;
+    };
+    hovered: {
+        true: string;
+        false: string;
+    };
+    selected: {
+        true: string;
+        false: string;
+    };
+}, undefined, string[], {
+    type: {
+        task: string;
+        summary: string;
+        milestone: string;
+    };
+    hovered: {
+        true: string;
+        false: string;
+    };
+    selected: {
+        true: string;
+        false: string;
+    };
+}, undefined, import('tailwind-variants').TVReturnType<{
+    type: {
+        task: string;
+        summary: string;
+        milestone: string;
+    };
+    hovered: {
+        true: string;
+        false: string;
+    };
+    selected: {
+        true: string;
+        false: string;
+    };
+}, undefined, string[], unknown, unknown, undefined>>;
+/** Coluna vertical de grade, sombreando fim de semana. */
+export declare const ganttGridColumn: import('tailwind-variants').TVReturnType<{
+    weekend: {
+        true: string;
+        false: string;
+    };
+    /** Coluna sob o cursor — a outra metade da mira. */
+    hovered: {
+        true: string;
+        false: string;
+    };
+    /** #7 — coluna da linha selecionada, no verde da marca. */
+    selected: {
+        true: string;
+        false: string;
+    };
+    /**
+     * #1 — virada de mês/ano: o par da divisória do cabeçalho, MESMAS classes.
+     * A tabela de ΔL que justifica a escolha do token está no `ganttHeadCell`.
+     */
+    boundary: {
+        true: string;
+        false: string;
+    };
+}, undefined, string[], {
+    weekend: {
+        true: string;
+        false: string;
+    };
+    /** Coluna sob o cursor — a outra metade da mira. */
+    hovered: {
+        true: string;
+        false: string;
+    };
+    /** #7 — coluna da linha selecionada, no verde da marca. */
+    selected: {
+        true: string;
+        false: string;
+    };
+    /**
+     * #1 — virada de mês/ano: o par da divisória do cabeçalho, MESMAS classes.
+     * A tabela de ΔL que justifica a escolha do token está no `ganttHeadCell`.
+     */
+    boundary: {
+        true: string;
+        false: string;
+    };
+}, undefined, import('tailwind-variants').TVReturnType<{
+    weekend: {
+        true: string;
+        false: string;
+    };
+    /** Coluna sob o cursor — a outra metade da mira. */
+    hovered: {
+        true: string;
+        false: string;
+    };
+    /** #7 — coluna da linha selecionada, no verde da marca. */
+    selected: {
+        true: string;
+        false: string;
+    };
+    /**
+     * #1 — virada de mês/ano: o par da divisória do cabeçalho, MESMAS classes.
+     * A tabela de ΔL que justifica a escolha do token está no `ganttHeadCell`.
+     */
+    boundary: {
+        true: string;
+        false: string;
+    };
+}, undefined, string[], unknown, unknown, undefined>>;
+/**
+ * A barra.
+ *
+ * `absolute` porque a posição vem de `left`/`width` calculados em px a partir da
+ * data — não de grid nem de flex. Grid de N colunas parece mais limpo até a
+ * primeira barra que começa às 14h de um dia: ela não cai em limite de coluna.
+ */
+export declare const ganttBar: import('tailwind-variants').TVReturnType<{
+    /**
+     * ⚠️ A cor entra no fundo TINGIDO e no acento, nunca no texto — ver a nota
+     * do topo. As chaves de chart usam `/14`, que é a mesma proporção do
+     * `color-mix(… 14%, transparent)` com que o DS deriva os `-subtle`.
+     */
+    colorKey: {
+        "chart-1": {
+            root: string;
+            accent: string;
+            progress: string;
+        };
+        "chart-2": {
+            root: string;
+            accent: string;
+            progress: string;
+        };
+        "chart-3": {
+            root: string;
+            accent: string;
+            progress: string;
+        };
+        "chart-4": {
+            root: string;
+            accent: string;
+            progress: string;
+        };
+        "chart-5": {
+            root: string;
+            accent: string;
+            progress: string;
+        };
+        brand: {
+            root: string;
+            accent: string;
+            progress: string;
+        };
+        success: {
+            root: string;
+            accent: string;
+            progress: string;
+        };
+        warning: {
+            root: string;
+            accent: string;
+            progress: string;
+        };
+        danger: {
+            root: string;
+            accent: string;
+            progress: string;
+        };
+        info: {
+            root: string;
+            accent: string;
+            progress: string;
+        };
+        neutral: {
+            root: string;
+            accent: string;
+            progress: string;
+        };
+    };
+    /**
+     * `summary` é mais baixa e sem acento: ela agrega, não é trabalho. As
+     * referências desenham as pontas viradas pra baixo; aqui o sinal é a altura
+     * reduzida e o radius menor, que sobrevive em 4px de largura por dia.
+     */
+    type: {
+        task: {
+            root: string;
+        };
+        summary: {
+            root: string;
+            accent: string;
+        };
+        milestone: {
+            root: string;
+            accent: string;
+            label: string;
+        };
+    };
+    /** Barra que atravessa a janela: perde o canto e a borda daquele lado. */
+    continuesBefore: {
+        true: {
+            root: string;
+        };
+        false: {};
+    };
+    continuesAfter: {
+        true: {
+            root: string;
+        };
+        false: {};
+    };
+    /** Vínculo violado — marcação não-cromática somada à cor. */
+    conflict: {
+        true: {
+            root: string;
+        };
+        false: {};
+    };
+    /** No caminho crítico: anel externo, sem trocar a cor da categoria. */
+    critical: {
+        true: {
+            root: string;
+        };
+        false: {};
+    };
+    dragging: {
+        true: {
+            root: string;
+        };
+        false: {};
+    };
+    movable: {
+        true: {
+            root: string;
+        };
+        false: {
+            root: string;
+        };
+    };
+}, {
+    root: string[];
+    /** Acento sólido na borda esquerda — é AQUI que a cor viva mora. */
+    accent: string;
+    /** Preenchimento de progresso, sobre o tingido. */
+    progress: string;
+    label: string;
+}, undefined, {
+    /**
+     * ⚠️ A cor entra no fundo TINGIDO e no acento, nunca no texto — ver a nota
+     * do topo. As chaves de chart usam `/14`, que é a mesma proporção do
+     * `color-mix(… 14%, transparent)` com que o DS deriva os `-subtle`.
+     */
+    colorKey: {
+        "chart-1": {
+            root: string;
+            accent: string;
+            progress: string;
+        };
+        "chart-2": {
+            root: string;
+            accent: string;
+            progress: string;
+        };
+        "chart-3": {
+            root: string;
+            accent: string;
+            progress: string;
+        };
+        "chart-4": {
+            root: string;
+            accent: string;
+            progress: string;
+        };
+        "chart-5": {
+            root: string;
+            accent: string;
+            progress: string;
+        };
+        brand: {
+            root: string;
+            accent: string;
+            progress: string;
+        };
+        success: {
+            root: string;
+            accent: string;
+            progress: string;
+        };
+        warning: {
+            root: string;
+            accent: string;
+            progress: string;
+        };
+        danger: {
+            root: string;
+            accent: string;
+            progress: string;
+        };
+        info: {
+            root: string;
+            accent: string;
+            progress: string;
+        };
+        neutral: {
+            root: string;
+            accent: string;
+            progress: string;
+        };
+    };
+    /**
+     * `summary` é mais baixa e sem acento: ela agrega, não é trabalho. As
+     * referências desenham as pontas viradas pra baixo; aqui o sinal é a altura
+     * reduzida e o radius menor, que sobrevive em 4px de largura por dia.
+     */
+    type: {
+        task: {
+            root: string;
+        };
+        summary: {
+            root: string;
+            accent: string;
+        };
+        milestone: {
+            root: string;
+            accent: string;
+            label: string;
+        };
+    };
+    /** Barra que atravessa a janela: perde o canto e a borda daquele lado. */
+    continuesBefore: {
+        true: {
+            root: string;
+        };
+        false: {};
+    };
+    continuesAfter: {
+        true: {
+            root: string;
+        };
+        false: {};
+    };
+    /** Vínculo violado — marcação não-cromática somada à cor. */
+    conflict: {
+        true: {
+            root: string;
+        };
+        false: {};
+    };
+    /** No caminho crítico: anel externo, sem trocar a cor da categoria. */
+    critical: {
+        true: {
+            root: string;
+        };
+        false: {};
+    };
+    dragging: {
+        true: {
+            root: string;
+        };
+        false: {};
+    };
+    movable: {
+        true: {
+            root: string;
+        };
+        false: {
+            root: string;
+        };
+    };
+}, {
+    root: string[];
+    /** Acento sólido na borda esquerda — é AQUI que a cor viva mora. */
+    accent: string;
+    /** Preenchimento de progresso, sobre o tingido. */
+    progress: string;
+    label: string;
+}, import('tailwind-variants').TVReturnType<{
+    /**
+     * ⚠️ A cor entra no fundo TINGIDO e no acento, nunca no texto — ver a nota
+     * do topo. As chaves de chart usam `/14`, que é a mesma proporção do
+     * `color-mix(… 14%, transparent)` com que o DS deriva os `-subtle`.
+     */
+    colorKey: {
+        "chart-1": {
+            root: string;
+            accent: string;
+            progress: string;
+        };
+        "chart-2": {
+            root: string;
+            accent: string;
+            progress: string;
+        };
+        "chart-3": {
+            root: string;
+            accent: string;
+            progress: string;
+        };
+        "chart-4": {
+            root: string;
+            accent: string;
+            progress: string;
+        };
+        "chart-5": {
+            root: string;
+            accent: string;
+            progress: string;
+        };
+        brand: {
+            root: string;
+            accent: string;
+            progress: string;
+        };
+        success: {
+            root: string;
+            accent: string;
+            progress: string;
+        };
+        warning: {
+            root: string;
+            accent: string;
+            progress: string;
+        };
+        danger: {
+            root: string;
+            accent: string;
+            progress: string;
+        };
+        info: {
+            root: string;
+            accent: string;
+            progress: string;
+        };
+        neutral: {
+            root: string;
+            accent: string;
+            progress: string;
+        };
+    };
+    /**
+     * `summary` é mais baixa e sem acento: ela agrega, não é trabalho. As
+     * referências desenham as pontas viradas pra baixo; aqui o sinal é a altura
+     * reduzida e o radius menor, que sobrevive em 4px de largura por dia.
+     */
+    type: {
+        task: {
+            root: string;
+        };
+        summary: {
+            root: string;
+            accent: string;
+        };
+        milestone: {
+            root: string;
+            accent: string;
+            label: string;
+        };
+    };
+    /** Barra que atravessa a janela: perde o canto e a borda daquele lado. */
+    continuesBefore: {
+        true: {
+            root: string;
+        };
+        false: {};
+    };
+    continuesAfter: {
+        true: {
+            root: string;
+        };
+        false: {};
+    };
+    /** Vínculo violado — marcação não-cromática somada à cor. */
+    conflict: {
+        true: {
+            root: string;
+        };
+        false: {};
+    };
+    /** No caminho crítico: anel externo, sem trocar a cor da categoria. */
+    critical: {
+        true: {
+            root: string;
+        };
+        false: {};
+    };
+    dragging: {
+        true: {
+            root: string;
+        };
+        false: {};
+    };
+    movable: {
+        true: {
+            root: string;
+        };
+        false: {
+            root: string;
+        };
+    };
+}, {
+    root: string[];
+    /** Acento sólido na borda esquerda — é AQUI que a cor viva mora. */
+    accent: string;
+    /** Preenchimento de progresso, sobre o tingido. */
+    progress: string;
+    label: string;
+}, undefined, unknown, unknown, undefined>>;
+/** Losango do marco. Ponto no tempo, não intervalo — duração é ignorada. */
+export declare const ganttMilestone: import('tailwind-variants').TVReturnType<{
+    colorKey: {
+        "chart-1": string;
+        "chart-2": string;
+        "chart-3": string;
+        "chart-4": string;
+        "chart-5": string;
+        brand: string;
+        success: string;
+        warning: string;
+        danger: string;
+        info: string;
+        neutral: string;
+    };
+}, undefined, string[], {
+    colorKey: {
+        "chart-1": string;
+        "chart-2": string;
+        "chart-3": string;
+        "chart-4": string;
+        "chart-5": string;
+        brand: string;
+        success: string;
+        warning: string;
+        danger: string;
+        info: string;
+        neutral: string;
+    };
+}, undefined, import('tailwind-variants').TVReturnType<{
+    colorKey: {
+        "chart-1": string;
+        "chart-2": string;
+        "chart-3": string;
+        "chart-4": string;
+        "chart-5": string;
+        brand: string;
+        success: string;
+        warning: string;
+        danger: string;
+        info: string;
+        neutral: string;
+    };
+}, undefined, string[], unknown, unknown, undefined>>;
+/** Punho de resize nas pontas. Revelado no hover da barra. */
+export declare const ganttResizeHandle: import('tailwind-variants').TVReturnType<{
+    side: {
+        start: string;
+        end: string;
+    };
+}, undefined, string[], {
+    side: {
+        start: string;
+        end: string;
+    };
+}, undefined, import('tailwind-variants').TVReturnType<{
+    side: {
+        start: string;
+        end: string;
+    };
+}, undefined, string[], unknown, unknown, undefined>>;
+/**
+ * Conector de vínculo — o pontinho de onde se arrasta pra criar a seta.
+ *
+ * Fora da barra (`-left-*`/`-right-*`) e não dentro: dentro, ele competiria com
+ * o punho de resize pelo mesmo pixel, e o usuário acertaria o errado.
+ */
+export declare const ganttLinkPort: import('tailwind-variants').TVReturnType<{
+    side: {
+        start: string;
+        end: string;
+    };
+}, undefined, string[], {
+    side: {
+        start: string;
+        end: string;
+    };
+}, undefined, import('tailwind-variants').TVReturnType<{
+    side: {
+        start: string;
+        end: string;
+    };
+}, undefined, string[], unknown, unknown, undefined>>;
+/**
+ * Camada SVG dos vínculos.
+ *
+ * ⚠️ **Irmã do canvas, não filha da célula** — e `pointer-events-none` na
+ * camada, reativado só nos paths.
+ *
+ * Filha da célula, ela seria recortada pelo `overflow` de qualquer ancestral, e
+ * a seta desapareceria ao sair da linha de origem. É o mesmo defeito que o
+ * `DragOverlay` resolveu no `Scheduler` — lá o bloco arrastado sumia atrás das
+ * grades, por clipping de 3 ancestrais.
+ */
+export declare const ganttLinksLayer: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, "pointer-events-none absolute inset-0 z-[3] overflow-visible", {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, "pointer-events-none absolute inset-0 z-[3] overflow-visible", unknown, unknown, undefined>>;
+/**
+ * A linha-fantasma enquanto o usuário arrasta pra criar um vínculo.
+ *
+ * Tracejada e na cor da marca: tracejado diz "ainda não existe" (vínculo real
+ * é sólido) e a marca diz "isto é o seu gesto", separando-a das setas já
+ * desenhadas. Sem ela o usuário arrasta no vazio e não sabe se o gesto pegou.
+ */
+export declare const ganttLinkGhost: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, string[], {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, string[], unknown, unknown, undefined>>;
+export declare const ganttLinkPath: import('tailwind-variants').TVReturnType<{
+    state: {
+        default: string;
+        /** Violado: tracejado + cor de perigo. Duplo canal, não só cor. */
+        conflict: string;
+        critical: string;
+    };
+}, undefined, string[], {
+    state: {
+        default: string;
+        /** Violado: tracejado + cor de perigo. Duplo canal, não só cor. */
+        conflict: string;
+        critical: string;
+    };
+}, undefined, import('tailwind-variants').TVReturnType<{
+    state: {
+        default: string;
+        /** Violado: tracejado + cor de perigo. Duplo canal, não só cor. */
+        conflict: string;
+        critical: string;
+    };
+}, undefined, string[], unknown, unknown, undefined>>;
+/** Ponta de seta. `context-stroke` herda a cor do path sem duplicar variante. */
+export declare const ganttLinkArrow: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, "fill-[context-stroke]", {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, "fill-[context-stroke]", unknown, unknown, undefined>>;
+export declare const ganttNowLine: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, "pointer-events-none absolute inset-y-0 z-[2] w-0", {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, "pointer-events-none absolute inset-y-0 z-[2] w-0", unknown, unknown, undefined>>;
+export declare const ganttNowStroke: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, "absolute inset-y-0 left-0 w-px -translate-x-1/2 bg-bg-danger", {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, "absolute inset-y-0 left-0 w-px -translate-x-1/2 bg-bg-danger", unknown, unknown, undefined>>;
+/**
+ * Ponta da linha do "hoje".
+ *
+ * ⚠️ Sem `-translate-y-1/2`. A primeira versão tinha, e a bolinha saía
+ * **cortada pela metade**: a metade de cima caía fora do contêiner, que tem
+ * `overflow`. Não era z-index — era recorte, o mesmo diagnóstico que eu errei
+ * primeiro no `DragOverlay` do Scheduler.
+ *
+ * ⛔ Houve aqui uma etiqueta com a data ("17 set") ancorada no cabeçalho.
+ * REMOVIDA a pedido (#2): no cabeçalho ela cobria justamente o par
+ * abreviação+número da coluna de hoje — trocava uma informação por outra em
+ * cima da mesma. A linha vermelha basta pra localizar o dia, e a data já está
+ * na própria coluna do eixo, embaixo dela.
+ */
+export declare const ganttNowDot: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, string[], {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, string[], unknown, unknown, undefined>>;
+/**
+ * ⚠️ Grade de mês PRÓPRIA do `Gantt`, não a do `Scheduler`.
+ *
+ * A spec §5 registra a decisão e o preço: delegar criaria acoplamento por
+ * herança de propósito — necessidade nova do Gantt viraria mudança numa API
+ * publicada que serve outros consumidores. O preço é haver duas grades no repo,
+ * com consistência garantida por revisão e não por construção.
+ */
+export declare const ganttMonthFrame: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, string[], {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, string[], unknown, unknown, undefined>>;
+export declare const ganttWeekdayRow: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, "grid shrink-0 grid-cols-7 border-b border-border-default bg-bg-table-head", {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, "grid shrink-0 grid-cols-7 border-b border-border-default bg-bg-table-head", unknown, unknown, undefined>>;
+export declare const ganttWeekdayCell: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, string[], {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, string[], unknown, unknown, undefined>>;
+/**
+ * A grade do mês — 6 linhas, com **altura mínima por linha e rolagem**.
+ *
+ * ⚠️ Era `grid-rows-6` puro, e o defeito foi medido: com 409px disponíveis a
+ * linha saía com **68px**, que depois do número do dia (14) e dos paddings (12)
+ * deixa 42px — **2 fatias de chip**. Numa célula com 4 tarefas o resultado era 1
+ * chip visível e um "+3 mais".
+ *
+ * `minmax(88px, 1fr)`: 88 é 26 de cabeçalho + 3 fatias de 20 + folga, o mínimo
+ * pra a célula responder "o que acontece neste dia" em vez de "tem coisa aqui".
+ * Em viewport alta as linhas crescem com o `1fr`; em viewport curta a grade
+ * **rola**, que é o que um calendário de mês faz.
+ *
+ * ⛔ Não troque por `grid-rows-6` "pra caber sem rolar": caber sem rolar aqui
+ * significa não mostrar o conteúdo.
+ */
+export declare const ganttMonthGrid: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, string[], {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, string[], unknown, unknown, undefined>>;
+/**
+ * Uma LINHA de semana — o contêiner que tornou o segmento contínuo possível.
+ *
+ * ⚠️ Antes a grade era 42 células soltas num `grid-cols-7 auto-rows-*`, e nessa
+ * estrutura uma barra de 6 dias **não tem como** ser um elemento só: ela viraria
+ * 6 chips, um por célula, cada um repetindo o nome. Lê como seis tarefas de um
+ * dia em vez de uma de seis — o oposto do que um cronograma diz.
+ *
+ * Agora cada semana é uma linha `relative` com DUAS camadas:
+ *
+ *   ganttWeekDays      → as 7 células (fundo, número do dia, "+N mais", o "+")
+ *   ganttWeekSegments  → camada absoluta com as barras atravessando colunas
+ *
+ * O `minmax(88px,1fr)` virou `min-h`: 88 é o mínimo pra a célula responder "o
+ * que acontece neste dia" em vez de "tem coisa aqui", e em viewport alta a linha
+ * cresce com o `flex-1`.
+ */
+export declare const ganttWeekRow: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, "relative flex min-h-[88px] shrink-0 flex-1 flex-col", {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, "relative flex min-h-[88px] shrink-0 flex-1 flex-col", unknown, unknown, undefined>>;
+/** As 7 células de fundo da semana. */
+export declare const ganttWeekDays: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, "grid min-h-0 flex-1 grid-cols-7", {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, "grid min-h-0 flex-1 grid-cols-7", unknown, unknown, undefined>>;
+/**
+ * Camada dos segmentos.
+ *
+ * `pointer-events-none` na camada e reativado em cada segmento: senão ela
+ * cobriria as células e o hover do "+" nunca disparava. Mesmo padrão do
+ * `ganttLinksLayer` na timeline, e pela mesma razão.
+ */
+export declare const ganttWeekSegments: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, "pointer-events-none absolute inset-x-0", {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, "pointer-events-none absolute inset-x-0", unknown, unknown, undefined>>;
+/**
+ * Um segmento — a barra atravessando as colunas que ocupa.
+ *
+ * As pontas cortadas usam o MESMO vocabulário da timeline
+ * (`continuesBefore`/`continuesAfter`): perdem o canto e a borda daquele lado,
+ * pra o corte na virada de semana parecer intencional em vez de bug.
+ */
+export declare const ganttDaySegment: import('tailwind-variants').TVReturnType<{
+    colorKey: {
+        "chart-1": {
+            root: string;
+            dot: string;
+        };
+        "chart-2": {
+            root: string;
+            dot: string;
+        };
+        "chart-3": {
+            root: string;
+            dot: string;
+        };
+        "chart-4": {
+            root: string;
+            dot: string;
+        };
+        "chart-5": {
+            root: string;
+            dot: string;
+        };
+        brand: {
+            root: string;
+            dot: string;
+        };
+        success: {
+            root: string;
+            dot: string;
+        };
+        warning: {
+            root: string;
+            dot: string;
+        };
+        danger: {
+            root: string;
+            dot: string;
+        };
+        info: {
+            root: string;
+            dot: string;
+        };
+        neutral: {
+            root: string;
+            dot: string;
+        };
+    };
+    continuesBefore: {
+        true: {
+            root: string;
+        };
+        false: {};
+    };
+    continuesAfter: {
+        true: {
+            root: string;
+        };
+        false: {};
+    };
+    conflict: {
+        true: {
+            root: string;
+        };
+        false: {};
+    };
+    critical: {
+        true: {
+            root: string;
+        };
+        false: {};
+    };
+}, {
+    root: string[];
+    dot: string;
+    label: string;
+}, undefined, {
+    colorKey: {
+        "chart-1": {
+            root: string;
+            dot: string;
+        };
+        "chart-2": {
+            root: string;
+            dot: string;
+        };
+        "chart-3": {
+            root: string;
+            dot: string;
+        };
+        "chart-4": {
+            root: string;
+            dot: string;
+        };
+        "chart-5": {
+            root: string;
+            dot: string;
+        };
+        brand: {
+            root: string;
+            dot: string;
+        };
+        success: {
+            root: string;
+            dot: string;
+        };
+        warning: {
+            root: string;
+            dot: string;
+        };
+        danger: {
+            root: string;
+            dot: string;
+        };
+        info: {
+            root: string;
+            dot: string;
+        };
+        neutral: {
+            root: string;
+            dot: string;
+        };
+    };
+    continuesBefore: {
+        true: {
+            root: string;
+        };
+        false: {};
+    };
+    continuesAfter: {
+        true: {
+            root: string;
+        };
+        false: {};
+    };
+    conflict: {
+        true: {
+            root: string;
+        };
+        false: {};
+    };
+    critical: {
+        true: {
+            root: string;
+        };
+        false: {};
+    };
+}, {
+    root: string[];
+    dot: string;
+    label: string;
+}, import('tailwind-variants').TVReturnType<{
+    colorKey: {
+        "chart-1": {
+            root: string;
+            dot: string;
+        };
+        "chart-2": {
+            root: string;
+            dot: string;
+        };
+        "chart-3": {
+            root: string;
+            dot: string;
+        };
+        "chart-4": {
+            root: string;
+            dot: string;
+        };
+        "chart-5": {
+            root: string;
+            dot: string;
+        };
+        brand: {
+            root: string;
+            dot: string;
+        };
+        success: {
+            root: string;
+            dot: string;
+        };
+        warning: {
+            root: string;
+            dot: string;
+        };
+        danger: {
+            root: string;
+            dot: string;
+        };
+        info: {
+            root: string;
+            dot: string;
+        };
+        neutral: {
+            root: string;
+            dot: string;
+        };
+    };
+    continuesBefore: {
+        true: {
+            root: string;
+        };
+        false: {};
+    };
+    continuesAfter: {
+        true: {
+            root: string;
+        };
+        false: {};
+    };
+    conflict: {
+        true: {
+            root: string;
+        };
+        false: {};
+    };
+    critical: {
+        true: {
+            root: string;
+        };
+        false: {};
+    };
+}, {
+    root: string[];
+    dot: string;
+    label: string;
+}, undefined, unknown, unknown, undefined>>;
+/**
+ * O "+" de adicionar, revelado no hover da célula.
+ *
+ * ⚠️ Só renderiza quando o consumidor passa `onDayAdd`. Um "+" que não
+ * adiciona nada é pior que a ausência dele — é a mesma regra do toggle de
+ * caminho crítico sem vínculo.
+ *
+ * `opacity-0` + `group-hover` e não `hidden`: com `hidden` o nó entra e sai do
+ * fluxo no hover, e a célula muda de altura embaixo do cursor.
+ */
+export declare const ganttDayAdd: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, string[], {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, string[], unknown, unknown, undefined>>;
+export declare const ganttMonthCell: import('tailwind-variants').TVReturnType<{
+    /** Dia de fora do mês âncora: presente, mas recuado. */
+    /**
+     * ## O mês é UNIFORME. O que se destaca é o que não é dele.
+     *
+     * Todo dia do mês âncora tem o mesmo fundo — útil ou fim de semana, tanto
+     * faz. Só as células de OUTRO mês recebem `bg-canvas`, e a grade passa a
+     * responder uma pergunta só: onde este mês começa e onde acaba.
+     *
+     * ⛔ **Não existe variante de fim de semana aqui, e isso é decisão.**
+     * Sombrear sábado e domingo divide o mês em blocos verticais e compete com
+     * a única distinção que a grade precisa fazer. Num calendário de agenda o
+     * fim de semana importa (não se marca reunião); num CRONOGRAMA a barra
+     * atravessa o fim de semana de qualquer jeito, e listrar as colunas só
+     * atrapalha a leitura do segmento contínuo que passa por cima.
+     *
+     * ## Por que `bg-canvas` e não escurecer com `/NN`
+     *
+     * O dia de outro mês não é uma SOBREPOSIÇÃO sobre a grade: é o buraco por
+     * onde se vê o fundo da página. O token que significa isso é `bg-canvas`
+     * (0.205), e contra a superfície da grade (`bg-surface`, 0.225) ele dá
+     * ΔL 0.020.
+     *
+     * ⚠️ 0.020 é pouco pra uma LINHA e suficiente pra uma ÁREA — contraste de
+     * área grande é muito mais perceptível que de traço fino. É por isso que
+     * aqui 0.020 lê enquanto na virada de mês do eixo 0.040 não lia.
+     *
+     * ## O histórico, porque ele explica as duas variantes que sumiram
+     *
+     *   outside  `bg-bg-subtle/40`  → branco 1% × 40% = 0.004 de alfa
+     *   weekend  `bg-bg-subtle/30`  → branco 1% × 30% = 0.003 de alfa
+     *
+     * As duas abaixo do limiar de percepção: existiam no CSS e não pintavam
+     * nada — 20 das 42 células com estilo que ninguém via. Ao consertar, eu
+     * tornei o fim de semana visível TAMBÉM, e aí ele virou o defeito oposto:
+     * as colunas de sábado e domingo escuras de ponta a ponta, com o mês
+     * parecendo quatro blocos. O conserto certo era **remover**, não calibrar.
+     *
+     * ⛔ E o `text-fg-subtle` que morava na variante `outside` era CÓDIGO MORTO:
+     * medido, o `ganttDayNumber` põe a própria cor no `<span>` e vence a
+     * herança. Quem dim o número do dia de fora é a variante `outside` DELE.
+     */
+    outside: {
+        true: string;
+        false: string;
+    };
+    today: {
+        true: string;
+        false: string;
+    };
+}, undefined, string[], {
+    /** Dia de fora do mês âncora: presente, mas recuado. */
+    /**
+     * ## O mês é UNIFORME. O que se destaca é o que não é dele.
+     *
+     * Todo dia do mês âncora tem o mesmo fundo — útil ou fim de semana, tanto
+     * faz. Só as células de OUTRO mês recebem `bg-canvas`, e a grade passa a
+     * responder uma pergunta só: onde este mês começa e onde acaba.
+     *
+     * ⛔ **Não existe variante de fim de semana aqui, e isso é decisão.**
+     * Sombrear sábado e domingo divide o mês em blocos verticais e compete com
+     * a única distinção que a grade precisa fazer. Num calendário de agenda o
+     * fim de semana importa (não se marca reunião); num CRONOGRAMA a barra
+     * atravessa o fim de semana de qualquer jeito, e listrar as colunas só
+     * atrapalha a leitura do segmento contínuo que passa por cima.
+     *
+     * ## Por que `bg-canvas` e não escurecer com `/NN`
+     *
+     * O dia de outro mês não é uma SOBREPOSIÇÃO sobre a grade: é o buraco por
+     * onde se vê o fundo da página. O token que significa isso é `bg-canvas`
+     * (0.205), e contra a superfície da grade (`bg-surface`, 0.225) ele dá
+     * ΔL 0.020.
+     *
+     * ⚠️ 0.020 é pouco pra uma LINHA e suficiente pra uma ÁREA — contraste de
+     * área grande é muito mais perceptível que de traço fino. É por isso que
+     * aqui 0.020 lê enquanto na virada de mês do eixo 0.040 não lia.
+     *
+     * ## O histórico, porque ele explica as duas variantes que sumiram
+     *
+     *   outside  `bg-bg-subtle/40`  → branco 1% × 40% = 0.004 de alfa
+     *   weekend  `bg-bg-subtle/30`  → branco 1% × 30% = 0.003 de alfa
+     *
+     * As duas abaixo do limiar de percepção: existiam no CSS e não pintavam
+     * nada — 20 das 42 células com estilo que ninguém via. Ao consertar, eu
+     * tornei o fim de semana visível TAMBÉM, e aí ele virou o defeito oposto:
+     * as colunas de sábado e domingo escuras de ponta a ponta, com o mês
+     * parecendo quatro blocos. O conserto certo era **remover**, não calibrar.
+     *
+     * ⛔ E o `text-fg-subtle` que morava na variante `outside` era CÓDIGO MORTO:
+     * medido, o `ganttDayNumber` põe a própria cor no `<span>` e vence a
+     * herança. Quem dim o número do dia de fora é a variante `outside` DELE.
+     */
+    outside: {
+        true: string;
+        false: string;
+    };
+    today: {
+        true: string;
+        false: string;
+    };
+}, undefined, import('tailwind-variants').TVReturnType<{
+    /** Dia de fora do mês âncora: presente, mas recuado. */
+    /**
+     * ## O mês é UNIFORME. O que se destaca é o que não é dele.
+     *
+     * Todo dia do mês âncora tem o mesmo fundo — útil ou fim de semana, tanto
+     * faz. Só as células de OUTRO mês recebem `bg-canvas`, e a grade passa a
+     * responder uma pergunta só: onde este mês começa e onde acaba.
+     *
+     * ⛔ **Não existe variante de fim de semana aqui, e isso é decisão.**
+     * Sombrear sábado e domingo divide o mês em blocos verticais e compete com
+     * a única distinção que a grade precisa fazer. Num calendário de agenda o
+     * fim de semana importa (não se marca reunião); num CRONOGRAMA a barra
+     * atravessa o fim de semana de qualquer jeito, e listrar as colunas só
+     * atrapalha a leitura do segmento contínuo que passa por cima.
+     *
+     * ## Por que `bg-canvas` e não escurecer com `/NN`
+     *
+     * O dia de outro mês não é uma SOBREPOSIÇÃO sobre a grade: é o buraco por
+     * onde se vê o fundo da página. O token que significa isso é `bg-canvas`
+     * (0.205), e contra a superfície da grade (`bg-surface`, 0.225) ele dá
+     * ΔL 0.020.
+     *
+     * ⚠️ 0.020 é pouco pra uma LINHA e suficiente pra uma ÁREA — contraste de
+     * área grande é muito mais perceptível que de traço fino. É por isso que
+     * aqui 0.020 lê enquanto na virada de mês do eixo 0.040 não lia.
+     *
+     * ## O histórico, porque ele explica as duas variantes que sumiram
+     *
+     *   outside  `bg-bg-subtle/40`  → branco 1% × 40% = 0.004 de alfa
+     *   weekend  `bg-bg-subtle/30`  → branco 1% × 30% = 0.003 de alfa
+     *
+     * As duas abaixo do limiar de percepção: existiam no CSS e não pintavam
+     * nada — 20 das 42 células com estilo que ninguém via. Ao consertar, eu
+     * tornei o fim de semana visível TAMBÉM, e aí ele virou o defeito oposto:
+     * as colunas de sábado e domingo escuras de ponta a ponta, com o mês
+     * parecendo quatro blocos. O conserto certo era **remover**, não calibrar.
+     *
+     * ⛔ E o `text-fg-subtle` que morava na variante `outside` era CÓDIGO MORTO:
+     * medido, o `ganttDayNumber` põe a própria cor no `<span>` e vence a
+     * herança. Quem dim o número do dia de fora é a variante `outside` DELE.
+     */
+    outside: {
+        true: string;
+        false: string;
+    };
+    today: {
+        true: string;
+        false: string;
+    };
+}, undefined, string[], unknown, unknown, undefined>>;
+/**
+ * O número do dia na célula do mês.
+ *
+ * ⚠️ A variante `outside` existe porque o FUNDO deixou de distinguir dia de
+ * outro mês de fim de semana deste — os dois são `bg-canvas` agora. Quem carrega
+ * essa diferença é o número: `fg-disabled` (0.36 no dark) contra `fg-muted`
+ * (0.7025) é meio tom de luminosidade, e lê imediatamente.
+ *
+ * `fg-disabled` e não um `fg-subtle` qualquer: um dia de outro mês não é
+ * acionável nesta grade — não recebe `+`, não recebe segmento próprio, e clicar
+ * nele não faz nada. O token que significa isso é o de desabilitado.
+ */
+export declare const ganttDayNumber: import('tailwind-variants').TVReturnType<{
+    outside: {
+        true: string;
+        false: string;
+    };
+    today: {
+        true: string[];
+        false: string;
+    };
+}, undefined, "text-caption-sm tabular-nums text-fg-muted", {
+    outside: {
+        true: string;
+        false: string;
+    };
+    today: {
+        true: string[];
+        false: string;
+    };
+}, undefined, import('tailwind-variants').TVReturnType<{
+    outside: {
+        true: string;
+        false: string;
+    };
+    today: {
+        true: string[];
+        false: string;
+    };
+}, undefined, "text-caption-sm tabular-nums text-fg-muted", unknown, unknown, undefined>>;
+/** Chip de barra dentro da célula do mês. */
+export declare const ganttDayChip: import('tailwind-variants').TVReturnType<{
+    colorKey: {
+        "chart-1": {
+            root: string;
+            dot: string;
+        };
+        "chart-2": {
+            root: string;
+            dot: string;
+        };
+        "chart-3": {
+            root: string;
+            dot: string;
+        };
+        "chart-4": {
+            root: string;
+            dot: string;
+        };
+        "chart-5": {
+            root: string;
+            dot: string;
+        };
+        brand: {
+            root: string;
+            dot: string;
+        };
+        success: {
+            root: string;
+            dot: string;
+        };
+        warning: {
+            root: string;
+            dot: string;
+        };
+        danger: {
+            root: string;
+            dot: string;
+        };
+        info: {
+            root: string;
+            dot: string;
+        };
+        neutral: {
+            root: string;
+            dot: string;
+        };
+    };
+}, {
+    root: string[];
+    dot: string;
+    label: string;
+}, undefined, {
+    colorKey: {
+        "chart-1": {
+            root: string;
+            dot: string;
+        };
+        "chart-2": {
+            root: string;
+            dot: string;
+        };
+        "chart-3": {
+            root: string;
+            dot: string;
+        };
+        "chart-4": {
+            root: string;
+            dot: string;
+        };
+        "chart-5": {
+            root: string;
+            dot: string;
+        };
+        brand: {
+            root: string;
+            dot: string;
+        };
+        success: {
+            root: string;
+            dot: string;
+        };
+        warning: {
+            root: string;
+            dot: string;
+        };
+        danger: {
+            root: string;
+            dot: string;
+        };
+        info: {
+            root: string;
+            dot: string;
+        };
+        neutral: {
+            root: string;
+            dot: string;
+        };
+    };
+}, {
+    root: string[];
+    dot: string;
+    label: string;
+}, import('tailwind-variants').TVReturnType<{
+    colorKey: {
+        "chart-1": {
+            root: string;
+            dot: string;
+        };
+        "chart-2": {
+            root: string;
+            dot: string;
+        };
+        "chart-3": {
+            root: string;
+            dot: string;
+        };
+        "chart-4": {
+            root: string;
+            dot: string;
+        };
+        "chart-5": {
+            root: string;
+            dot: string;
+        };
+        brand: {
+            root: string;
+            dot: string;
+        };
+        success: {
+            root: string;
+            dot: string;
+        };
+        warning: {
+            root: string;
+            dot: string;
+        };
+        danger: {
+            root: string;
+            dot: string;
+        };
+        info: {
+            root: string;
+            dot: string;
+        };
+        neutral: {
+            root: string;
+            dot: string;
+        };
+    };
+}, {
+    root: string[];
+    dot: string;
+    label: string;
+}, undefined, unknown, unknown, undefined>>;
+/**
+ * O "+N mais" da célula do mês.
+ *
+ * ⚠️ `absolute`, e isto é conserto de um defeito medido: no fluxo do flex ele
+ * caía logo depois do número do dia — **na mesma faixa vertical dos
+ * segmentos** — e como os segmentos vivem numa camada absoluta por cima, o
+ * botão aparecia atravessado pelas barras. Posicionado, ele fica exatamente
+ * abaixo da última faixa visível (o `top` vem da view, que sabe quantas são).
+ */
+export declare const ganttOverflowButton: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, string[], {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, string[], unknown, unknown, undefined>>;
+/**
+ * A agenda.
+ *
+ * ⛔ Gramática copiada do `schedulerList*`, não importada (L-049). A moldura é
+ * própria e por isso o `ganttBody` entra sem `framed` nesta visão — duas
+ * bordas concêntricas separadas por 1px é o que sai de deixar as duas.
+ */
+export declare const ganttListFrame: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, string[], {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, string[], unknown, unknown, undefined>>;
+export declare const ganttListDay: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, "flex flex-col gap-gp-md border-b border-border-subtle p-sp-xl last:border-b-0", {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, "flex flex-col gap-gp-md border-b border-border-subtle p-sp-xl last:border-b-0", unknown, unknown, undefined>>;
+/**
+ * Cabeçalho do dia.
+ *
+ * `sticky` com fundo OPACO: numa agenda longa, saber "que dia é este que estou
+ * lendo" é justamente o que se perde ao rolar. Fundo translúcido deixaria o
+ * conteúdo passar por baixo do rótulo.
+ *
+ * As margens negativas existem porque o `p-sp-xl` do dia já recuou o conteúdo:
+ * sem elas o sticky grudaria 20px abaixo do topo do scroller.
+ */
+export declare const ganttListDayHead: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, string[], {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, string[], unknown, unknown, undefined>>;
+export declare const ganttListDayNumber: import('tailwind-variants').TVReturnType<{
+    today: {
+        true: string;
+        false: string;
+    };
+}, undefined, "text-title-sm font-semibold tabular-nums", {
+    today: {
+        true: string;
+        false: string;
+    };
+}, undefined, import('tailwind-variants').TVReturnType<{
+    today: {
+        true: string;
+        false: string;
+    };
+}, undefined, "text-title-sm font-semibold tabular-nums", unknown, unknown, undefined>>;
+export declare const ganttListDayName: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, "text-body-sm text-fg-muted first-letter:uppercase", {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, "text-body-sm text-fg-muted first-letter:uppercase", unknown, unknown, undefined>>;
+export declare const ganttListItems: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, "flex flex-col gap-gp-sm", {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, "flex flex-col gap-gp-sm", unknown, unknown, undefined>>;
+/**
+ * Uma tarefa na agenda — linha larga com sublinha e metadado à direita.
+ *
+ * Mesma anatomia do `schedulerEvent` variante `row`, e a cor segue a receita
+ * do resto deste componente: fundo TINGIDO + `fg-default` no texto + a cor viva
+ * num ponto. Ver a nota do topo do arquivo — texto colorido sobre pílula
+ * tingida dá 1.72–4.49 de contraste no light, e nenhuma família passa AA.
+ */
+export declare const ganttListItem: import('tailwind-variants').TVReturnType<{
+    colorKey: {
+        "chart-1": {
+            root: string;
+            dot: string;
+        };
+        "chart-2": {
+            root: string;
+            dot: string;
+        };
+        "chart-3": {
+            root: string;
+            dot: string;
+        };
+        "chart-4": {
+            root: string;
+            dot: string;
+        };
+        "chart-5": {
+            root: string;
+            dot: string;
+        };
+        brand: {
+            root: string;
+            dot: string;
+        };
+        success: {
+            root: string;
+            dot: string;
+        };
+        warning: {
+            root: string;
+            dot: string;
+        };
+        danger: {
+            root: string;
+            dot: string;
+        };
+        info: {
+            root: string;
+            dot: string;
+        };
+        neutral: {
+            root: string;
+            dot: string;
+        };
+    };
+    conflict: {
+        true: {
+            root: string;
+        };
+        false: {};
+    };
+    critical: {
+        true: {
+            root: string;
+        };
+        false: {};
+    };
+}, {
+    root: string[];
+    dot: string;
+    body: string;
+    title: string;
+    sub: string;
+    meta: string;
+}, undefined, {
+    colorKey: {
+        "chart-1": {
+            root: string;
+            dot: string;
+        };
+        "chart-2": {
+            root: string;
+            dot: string;
+        };
+        "chart-3": {
+            root: string;
+            dot: string;
+        };
+        "chart-4": {
+            root: string;
+            dot: string;
+        };
+        "chart-5": {
+            root: string;
+            dot: string;
+        };
+        brand: {
+            root: string;
+            dot: string;
+        };
+        success: {
+            root: string;
+            dot: string;
+        };
+        warning: {
+            root: string;
+            dot: string;
+        };
+        danger: {
+            root: string;
+            dot: string;
+        };
+        info: {
+            root: string;
+            dot: string;
+        };
+        neutral: {
+            root: string;
+            dot: string;
+        };
+    };
+    conflict: {
+        true: {
+            root: string;
+        };
+        false: {};
+    };
+    critical: {
+        true: {
+            root: string;
+        };
+        false: {};
+    };
+}, {
+    root: string[];
+    dot: string;
+    body: string;
+    title: string;
+    sub: string;
+    meta: string;
+}, import('tailwind-variants').TVReturnType<{
+    colorKey: {
+        "chart-1": {
+            root: string;
+            dot: string;
+        };
+        "chart-2": {
+            root: string;
+            dot: string;
+        };
+        "chart-3": {
+            root: string;
+            dot: string;
+        };
+        "chart-4": {
+            root: string;
+            dot: string;
+        };
+        "chart-5": {
+            root: string;
+            dot: string;
+        };
+        brand: {
+            root: string;
+            dot: string;
+        };
+        success: {
+            root: string;
+            dot: string;
+        };
+        warning: {
+            root: string;
+            dot: string;
+        };
+        danger: {
+            root: string;
+            dot: string;
+        };
+        info: {
+            root: string;
+            dot: string;
+        };
+        neutral: {
+            root: string;
+            dot: string;
+        };
+    };
+    conflict: {
+        true: {
+            root: string;
+        };
+        false: {};
+    };
+    critical: {
+        true: {
+            root: string;
+        };
+        false: {};
+    };
+}, {
+    root: string[];
+    dot: string;
+    body: string;
+    title: string;
+    sub: string;
+    meta: string;
+}, undefined, unknown, unknown, undefined>>;
+export declare const ganttEmpty: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, string[], {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, string[], unknown, unknown, undefined>>;
+export declare const ganttEmptyText: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, "text-body-sm text-fg-muted", {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, "text-body-sm text-fg-muted", unknown, unknown, undefined>>;
+/** Aviso de largura insuficiente — declarado, não escondido. */
+export declare const ganttNarrowNotice: import('tailwind-variants').TVReturnType<{} | {} | {}, undefined, string[], {} | {}, undefined, import('tailwind-variants').TVReturnType<unknown, undefined, string[], unknown, unknown, undefined>>;
+//# sourceMappingURL=gantt.styles.d.ts.map