@adatechnology/conversations-ui 0.1.0-rc.3 → 0.1.0-rc.31

package/dist/chunk-DXPSPUWF.js

@@ -0,0 +1,110 @@
+// src/Tooltip.tsx
+import { useEffect, useRef, useState } from "react";
+import { createPortal } from "react-dom";
+import { jsx } from "react/jsx-runtime";
+var TOOLTIP_ATTRIBUTE = "data-cv-tooltip";
+var TOOLTIP_DELAY_MS = 120;
+var TOOLTIP_GAP_PX = 8;
+var TOOLTIP_EDGE_PX = 72;
+function tooltipPositionOf({ targetRect, viewportWidth }) {
+  const placement = targetRect.top < TOOLTIP_EDGE_PX ? "bottom" : "top";
+  const centerX = targetRect.left + targetRect.width / 2;
+  return {
+    left: Math.min(Math.max(centerX, TOOLTIP_EDGE_PX), viewportWidth - TOOLTIP_EDGE_PX),
+    top: placement === "top" ? targetRect.top - TOOLTIP_GAP_PX : targetRect.bottom + TOOLTIP_GAP_PX,
+    placement
+  };
+}
+function tooltipStateFor(target, text) {
+  const position = tooltipPositionOf({
+    targetRect: target.getBoundingClientRect(),
+    viewportWidth: window.innerWidth
+  });
+  return { text, ...position };
+}
+var layerOwner;
+function TooltipLayer() {
+  const identity = useRef({});
+  const [isOwner, setIsOwner] = useState(false);
+  const [tooltip, setTooltip] = useState(void 0);
+  useEffect(() => {
+    const owned = identity.current;
+    if (layerOwner && layerOwner !== owned) return void 0;
+    layerOwner = owned;
+    setIsOwner(true);
+    return () => {
+      if (layerOwner === owned) layerOwner = void 0;
+    };
+  }, []);
+  useEffect(() => {
+    if (!isOwner) return void 0;
+    let timer;
+    function cancelPending() {
+      if (timer) clearTimeout(timer);
+      timer = void 0;
+    }
+    function hide() {
+      cancelPending();
+      setTooltip(void 0);
+    }
+    function handleEnter(event) {
+      const origin = event.target;
+      if (!(origin instanceof Element)) return;
+      const target = origin.closest(`[${TOOLTIP_ATTRIBUTE}]`);
+      if (!(target instanceof HTMLElement)) {
+        hide();
+        return;
+      }
+      const text = target.getAttribute(TOOLTIP_ATTRIBUTE);
+      if (!text) {
+        hide();
+        return;
+      }
+      cancelPending();
+      timer = setTimeout(() => setTooltip(tooltipStateFor(target, text)), TOOLTIP_DELAY_MS);
+    }
+    function handleLeaveWindow(event) {
+      if (!event.relatedTarget) hide();
+    }
+    function handleKeyDown(event) {
+      if (event.key === "Escape") hide();
+    }
+    document.addEventListener("pointerover", handleEnter);
+    document.addEventListener("pointerout", handleLeaveWindow);
+    document.addEventListener("focusin", handleEnter);
+    document.addEventListener("pointerdown", hide);
+    document.addEventListener("focusout", hide);
+    document.addEventListener("keydown", handleKeyDown);
+    window.addEventListener("scroll", hide, true);
+    window.addEventListener("resize", hide);
+    return () => {
+      cancelPending();
+      document.removeEventListener("pointerover", handleEnter);
+      document.removeEventListener("pointerout", handleLeaveWindow);
+      document.removeEventListener("focusin", handleEnter);
+      document.removeEventListener("pointerdown", hide);
+      document.removeEventListener("focusout", hide);
+      document.removeEventListener("keydown", handleKeyDown);
+      window.removeEventListener("scroll", hide, true);
+      window.removeEventListener("resize", hide);
+    };
+  }, [isOwner]);
+  if (!tooltip) return null;
+  return createPortal(
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        role: "tooltip",
+        className: `cv-tooltip cv-tooltip--${tooltip.placement}`,
+        style: { left: tooltip.left, top: tooltip.top },
+        children: tooltip.text
+      }
+    ),
+    document.body
+  );
+}
+
+export {
+  TOOLTIP_ATTRIBUTE,
+  TooltipLayer
+};

package/dist/{chunk-OGRRHQQW.js → chunk-WCBDXZ3X.js}

@@ -69,9 +69,12 @@ function parseInlineTokens(text) {
       if (remaining) result.push({ type: "text", content: remaining });
       break;
     }
-    if (nextSpecial > 0) {
-      result.push({ type: "text", content: remaining.slice(0, nextSpecial) });
+    if (nextSpecial === 0) {
+      result.push({ type: "text", content: remaining.slice(0, 1) });
+      remaining = remaining.slice(1);
+      continue;
     }
+    result.push({ type: "text", content: remaining.slice(0, nextSpecial) });
     remaining = remaining.slice(nextSpecial);
   }
   return result;
@@ -103,6 +106,9 @@ function unescapeHtml(text) {
 }
 var CODE_TOKEN_MARK = String.fromCharCode(57344);
 var CODE_TOKEN_REGEX = new RegExp(`${CODE_TOKEN_MARK}(\\d+)${CODE_TOKEN_MARK}`, "g");
+var ZERO_WIDTH_SPACE = String.fromCharCode(8203);
+var EMPTY_CODE_REGEX = new RegExp(`<code[^>]*>[${ZERO_WIDTH_SPACE}\\s]*</code>`, "gi");
+var ZERO_WIDTH_SPACE_REGEX = new RegExp(ZERO_WIDTH_SPACE, "g");
 function waToHTML(text) {
   if (!text) return "";
   const codeTokens = [];
@@ -117,7 +123,7 @@ function waToHTML(text) {
   let html = escapeHtml(working);
   html = html.replace(/\*([^*\n]+)\*/g, "<strong>$1</strong>");
   html = html.replace(/_([^_\n]+)_/g, "<em>$1</em>");
-  html = html.replace(/~([^~\n]+)~/g, "<del>$1</del>");
+  html = html.replace(/~([^~\n]+)~/g, "<s>$1</s>");
   html = html.replace(/\n/g, "<br>");
   html = html.replace(CODE_TOKEN_REGEX, (_match, indexStr) => {
     const token = codeTokens[Number(indexStr)];
@@ -132,6 +138,7 @@ function waToHTML(text) {
 function htmlToWA(html) {
   if (!html) return "";
   let text = html;
+  text = text.replace(EMPTY_CODE_REGEX, "");
   text = text.replace(/<code data-wa="block"[^>]*>([\s\S]*?)<\/code>/gi, (_match, inner) => `\`\`\`${unescapeHtml(inner.replace(/<br\s*\/?>/gi, "\n"))}\`\`\``);
   text = text.replace(/<code data-wa="inline"[^>]*>([\s\S]*?)<\/code>/gi, (_match, inner) => `\`${unescapeHtml(inner)}\``);
   text = text.replace(/<br\s*\/?>/gi, "\n").replace(/<div>/gi, "\n").replace(/<\/div>/gi, "").replace(/<\/p>/gi, "\n").replace(/<p[^>]*>/gi, "");
@@ -141,9 +148,11 @@ function htmlToWA(html) {
   text = text.replace(/<i>(.*?)<\/i>/gi, "_$1_");
   text = text.replace(/<del>(.*?)<\/del>/gi, "~$1~");
   text = text.replace(/<s>(.*?)<\/s>/gi, "~$1~");
+  text = text.replace(/<strike>(.*?)<\/strike>/gi, "~$1~");
   text = text.replace(/<code[^>]*>(.*?)<\/code>/gi, "`$1`");
   text = text.replace(/<[^>]+>/g, "");
   text = unescapeHtml(text);
+  text = text.replace(ZERO_WIDTH_SPACE_REGEX, "");
   return text.trim();
 }
 function waToHTMLInline(text) {
@@ -151,9 +160,64 @@ function waToHTMLInline(text) {
   return escapeHtml(text).replace(/\*([^*\n]+)\*/g, "<strong>$1</strong>").replace(/_([^_\n]+)_/g, "<em>$1</em>").replace(/~([^~\n]+)~/g, "<del>$1</del>").replace(/`([^`\n]+)`/g, "<code>$1</code>");
 }
 
+// src/useDarkMode.ts
+import { useState, useEffect, useCallback } from "react";
+var STORAGE_KEY = "conversations-ui-dark-mode";
+function getInitialDark() {
+  if (typeof window === "undefined") return false;
+  const stored = localStorage.getItem(STORAGE_KEY);
+  if (stored !== null) {
+    return stored === "true";
+  }
+  return window.matchMedia("(prefers-color-scheme: dark)").matches;
+}
+function useIsDarkTheme() {
+  const [isDark, setIsDark] = useState(
+    () => typeof document !== "undefined" && document.documentElement.classList.contains("dark")
+  );
+  useEffect(() => {
+    const root = document.documentElement;
+    const observer = new MutationObserver(() => setIsDark(root.classList.contains("dark")));
+    observer.observe(root, { attributes: true, attributeFilter: ["class"] });
+    setIsDark(root.classList.contains("dark"));
+    return () => observer.disconnect();
+  }, []);
+  return isDark;
+}
+function useDarkMode() {
+  const [isDark, setIsDark] = useState(getInitialDark);
+  useEffect(() => {
+    const root = document.documentElement;
+    if (isDark) {
+      root.classList.add("dark");
+    } else {
+      root.classList.remove("dark");
+    }
+    localStorage.setItem(STORAGE_KEY, String(isDark));
+  }, [isDark]);
+  useEffect(() => {
+    const mediaQuery = window.matchMedia("(prefers-color-scheme: dark)");
+    const handleChange = (event) => {
+      const stored = localStorage.getItem(STORAGE_KEY);
+      if (stored === null) {
+        setIsDark(event.matches);
+      }
+    };
+    mediaQuery.addEventListener("change", handleChange);
+    return () => mediaQuery.removeEventListener("change", handleChange);
+  }, []);
+  const toggle = useCallback(() => {
+    setIsDark((prev) => !prev);
+  }, []);
+  return { isDark, toggle };
+}
+
 export {
   parseWhatsAppFormatting,
+  ZERO_WIDTH_SPACE,
   waToHTML,
   htmlToWA,
-  waToHTMLInline
+  waToHTMLInline,
+  useIsDarkTheme,
+  useDarkMode
 };

package/dist/flows/index.d.ts

@@ -1,4 +1,5 @@
 import * as react from 'react';
+import { ReactNode } from 'react';
 import { NodeProps } from '@xyflow/react';
 import { LucideIcon } from 'lucide-react';
 import { FlowConditionOperator, FlowGraphData, FlowNodeData, FlowNodeType, FlowQuestionType, FlowActionKind } from '@adatechnology/meta-whatsapp-contracts';
@@ -9,6 +10,7 @@ declare const BUILT_IN_ACTION_KINDS: {
     readonly HANDOFF: "handoff";
     readonly RATE_LIMITED_HANDOFF: "rate_limited_handoff";
     readonly SEND_PRODUCT_LIST: "send_product_list";
+    readonly SEND_MEDIA: "send_media";
 };
 declare const CROSS_FLOW_PREFIX = "flow:";
 declare const isCrossFlowTarget: (target: string) => boolean;
@@ -62,11 +64,12 @@ type CollectionChain = {
     actionNodeId: string;
 };
 declare function findCollectionChains(graph: FlowGraphData): CollectionChain[];
-declare function slugifyNodeId(label: string, existing: Set<string>): string;
+declare function slugifyNodeId(label: string, existing: ReadonlySet<string>): string;
 
 interface FlowEditorLabels {
     legend: Record<FlowNodeType, string>;
     startNodeTooltip: string;
+    detachedNodeTooltip: string;
     liveCountTooltip: (count: number) => string;
     edgeFallbackLabel: string;
     actionKindLabels: Record<string, string>;
@@ -75,10 +78,15 @@ interface FlowEditorLabels {
     nodePanel: {
         title: string;
         contextKey: string;
+        nodeName: string;
+        nodeNamePlaceholder: string;
+        nodeNameHint: string;
         questionType: string;
         question: string;
         options: string;
         addOption: string;
+        removeOption: string;
+        close: string;
         optionId: string;
         optionLabel: string;
         next: string;
@@ -109,6 +117,8 @@ interface FlowEditorLabels {
         conditionTrue: string;
         conditionFalse: string;
         conditionVariableMissing: string;
+        media: string;
+        mediaUnavailable: string;
     };
     palette: {
         title: string;
@@ -121,6 +131,8 @@ interface FlowEditorLabels {
     flowMap: {
         nodeCount: (count: number) => string;
         openFlow: string;
+        toggleToMap: string;
+        toggleToDetail: string;
     };
     flowGroup: {
         focus: string;
@@ -130,6 +142,66 @@ interface FlowEditorLabels {
         tooltip: string;
         goesTo: (label: string) => string;
     };
+    collectionChain: {
+        feeds: (label: string) => string;
+    };
+    /**
+     * Texto dos problemas encontrados por `validateGraph`. Vive aqui, e não no host, porque a tela
+     * composta é quem valida — deixar de fora obrigaria todo produto a repassar o mesmo mapa de
+     * funções só para a barra de erros aparecer.
+     */
+    validation: FlowValidationLabels;
+    /** Barra de cima, estados de carregamento e ações do editor inteiro. */
+    workspace: {
+        title: string;
+        subtitle: string;
+        loading: string;
+        loadError: string;
+        saveGraph: string;
+        saving: string;
+        saveSuccess: string;
+        saveError: string;
+        organize: string;
+        organizeTooltip: string;
+        discardChanges: string;
+        discardTooltip: string;
+        discardConfirm: string;
+        unsavedChangesConfirm: string;
+    };
+    flowManager: {
+        newFlow: string;
+        createTitle: string;
+        key: string;
+        keyHint: string;
+        keyInvalid: string;
+        label: string;
+        showInMenu: string;
+        menuOptionLabel: string;
+        create: string;
+        creating: string;
+        deleteFlow: string;
+        deleteConfirm: (label: string) => string;
+        createError: string;
+        deleteError: string;
+    };
+}
+interface FlowValidationLabels {
+    title: string;
+    errors: (count: number) => string;
+    warnings: (count: number) => string;
+    noStart: string;
+    brokenRef: (from: string, to: string) => string;
+    choiceWithoutOptions: (id: string) => string;
+    duplicatedOptionId: (id: string, optionId: string) => string;
+    optionWithoutTarget: (id: string, optionLabel: string) => string;
+    tooManyOptions: (id: string, count: number) => string;
+    buttonTitleTooLong: (id: string, label: string) => string;
+    listTitleTooLong: (id: string, label: string) => string;
+    bodyTooLong: (id: string) => string;
+    unreachable: (id: string) => string;
+    deadEndQuestion: (id: string) => string;
+    conditionIncomplete: (id: string) => string;
+    conditionBranchMissing: (id: string, branch: string) => string;
 }
 declare const DEFAULT_FLOW_EDITOR_LABELS: FlowEditorLabels;
 declare function mergeFlowEditorLabels(override?: Partial<FlowEditorLabels>): FlowEditorLabels;
@@ -140,6 +212,12 @@ type FlowNodeCardData = {
     liveCount: number;
     isStart: boolean;
     isSelected: boolean;
+    /**
+     * Nó sem nenhuma ligação de entrada — o bot nunca chega nele. Contorno tracejado e pulso: sem
+     * isso, desconectar um fio ou criar um card solto passa despercebido até o fluxo quebrar em
+     * produção.
+     */
+    isDetached?: boolean;
     issues: GraphIssue[];
     labels: FlowEditorLabels;
     actionKindIcons?: Record<string, LucideIcon>;
@@ -233,14 +311,270 @@ interface FlowNodePanelProps {
     onChange: (updated: FlowNodeData) => void;
     onDelete: (nodeId: string) => void;
     labels?: Partial<FlowEditorLabels>;
+    /**
+     * Seletor de arquivos do nó `send_media`, renderizado no lugar da mensagem direta.
+     *
+     * Slot, e não uma lista de arquivos por prop, porque a biblioteca é do host: upload, permissão e
+     * URL assinada são dele, e o painel não tem como buscar nada. Ausente, o nó continua editável —
+     * só não dá para anexar por aqui.
+     */
+    renderMediaPicker?: (node: FlowNodeData, graph: FlowGraphData) => ReactNode;
 }
-declare function FlowNodePanel({ graph, node, issues, otherFlows, onClose, onChange, onDelete, labels: labelsOverride, }: FlowNodePanelProps): react.JSX.Element;
+declare function FlowNodePanel({ graph, node, issues, otherFlows, onClose, onChange, onDelete, labels: labelsOverride, renderMediaPicker, }: FlowNodePanelProps): react.JSX.Element;
 
 interface FlowWhatsAppPreviewProps {
     body: string;
     options?: [string, string][];
     labels?: FlowEditorLabels['nodePanel'];
 }
-declare function FlowWhatsAppPreview({ body, options, labels }: FlowWhatsAppPreviewProps): react.JSX.Element;
+declare function FlowWhatsAppPreview({ body, options, labels, }: FlowWhatsAppPreviewProps): react.JSX.Element;
+
+/**
+ * Derivações puras do canvas do editor: posições, arestas, contagem de conversas vivas e o nó que
+ * nasce de cada item da paleta.
+ *
+ * Viviam dentro do componente, e é ali que estava o risco. Uma aresta com destino errado não pinta
+ * errado — ela leva a conversa do cliente para o lugar errado, e o sintoma aparece longe de quem
+ * editou. Um card que o layout joga para fora da área visível se lê como "apaguei sem querer".
+ *
+ * A topologia sai daqui em forma neutra (`FlowEdgeSpec`) e o estilo fica no componente: o teste cobra
+ * o que importa e roda sem navegador nem `@xyflow/react`. Cor de traço ninguém quebra sem ver.
+ */
+
+type FlowNodePosition = {
+    readonly x: number;
+    readonly y: number;
+};
+/** Onde cada conversa viva está parada agora — uma linha por sessão. */
+type FlowLivePosition = {
+    readonly currentState: string;
+    readonly flow: string | null;
+    readonly nodeId: string | null;
+    readonly menuNodeId: string | null;
+};
+/**
+ * Quantas conversas estão paradas num nó — o formato que o servidor já agrega.
+ *
+ * `meta-whatsapp-module` responde `GROUP BY (flowKey, currentNodeId)`, e trazer uma linha por
+ * sessão só para o editor recontar em memória seria pior em toda base grande. Os dois formatos
+ * valem porque produto que já implementou o de sessão não deve quebrar numa release de correção.
+ */
+type FlowLiveNodeCount = {
+    readonly flowKey: string;
+    readonly nodeId: string;
+    readonly count: number;
+};
+type FlowLivePositionInput = FlowLivePosition | FlowLiveNodeCount;
+/**
+ * Pseudo-nó que representa um fluxo alvo ainda não mesclado no canvas.
+ *
+ * Um portal por (nó de origem, fluxo alvo): duas opções do mesmo nó indo para o mesmo fluxo
+ * compartilham o portal, senão o card ficaria cercado de caixas idênticas.
+ */
+declare function portalNodeId(sourceNodeId: string, target: string): string;
+declare function chainFrameNodeId(actionNodeId: string): string;
+declare const GROUP_HEADER_NODE_ID = "__group_header__";
+/**
+ * Quantas conversas estão paradas em cada nó de um fluxo.
+ *
+ * A raiz é caso à parte no formato por sessão: o servidor guarda o passo do menu em `menuNodeId`,
+ * num campo próprio, e uma conversa no menu não carrega `flow`. Ler `nodeId` ali daria contagem
+ * zero na tela mais visitada do editor. No formato agregado a chave do fluxo já vem na linha,
+ * então a raiz não tem exceção.
+ */
+declare function countLiveByNode(params: {
+    readonly flowKey: string;
+    readonly rootFlowKey: string;
+    readonly positions: readonly FlowLivePositionInput[] | undefined;
+}): Record<string, number>;
+/**
+ * Um layout só para TODOS os nós de TODOS os fluxos abertos juntos.
+ *
+ * Posicionar cada fluxo à parte e deslocar não resolve: nada impede dois fluxos de ocuparem o mesmo
+ * espaço, e a altura real de cada card é ignorada. Aqui o ranqueamento por BFS roda sobre o grafo
+ * mesclado inteiro, com os saltos `flow:<key>` já resolvidos para o nó inicial do alvo.
+ */
+declare function computeMergedLayout(params: {
+    readonly openKeys: readonly string[];
+    readonly graphs: Readonly<Record<string, FlowGraphData>>;
+    readonly primaryFlowKey: string;
+}): Map<string, FlowNodePosition>;
+/** Papel visual da aresta. O componente traduz em traço, cor e seta; o modelo só decide qual é. */
+type FlowEdgeKind = 'linear' | 'branch' | 'fallback';
+type FlowEdgeSpec = {
+    readonly id: string;
+    readonly source: string;
+    readonly target: string;
+    readonly sourceHandle?: string;
+    readonly kind: FlowEdgeKind;
+    /** Salto entre fluxos — tracejado, esteja o alvo mesclado ou num portal. */
+    readonly crossFlow: boolean;
+    readonly live: boolean;
+};
+/**
+ * Arestas de todos os fluxos abertos.
+ *
+ * A regra que não é óbvia: um salto `flow:<key>` vira ligação real até o nó inicial do alvo quando
+ * esse fluxo já está no canvas, e só cai no portal quando não está. Sem isso, abrir dois fluxos
+ * ligados mostrava uma caixa de portal entre dois cards que já estavam ali do lado.
+ */
+declare function buildFlowEdges(params: {
+    readonly openKeys: readonly string[];
+    readonly graphs: Readonly<Record<string, FlowGraphData>>;
+    readonly rootFlowKey: string;
+    readonly livePositions?: readonly FlowLivePositionInput[] | undefined;
+}): FlowEdgeSpec[];
+/** Nós de um fluxo que ninguém aponta — o card ganha contorno tracejado para cobrar a ligação. */
+declare function detachedNodeIds(graph: FlowGraphData): Set<string>;
+/** Retângulo que envolve uma cadeia de coleta, em coordenadas do canvas. */
+declare function chainFrameBounds(params: {
+    readonly nodeIds: readonly string[];
+    readonly graph: FlowGraphData;
+    readonly positionOf: (nodeId: string) => FlowNodePosition;
+    readonly padding: number;
+}): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+/**
+ * O nó que nasce de cada item da paleta.
+ *
+ * `contextKey` igual ao id porque é o que o motor usa para guardar a resposta: deixá-lo vazio faria a
+ * pergunta ser feita e a resposta descartada, sem erro em lugar nenhum.
+ */
+declare function newNodeFromSpec(spec: NewNodeSpec, existingIds: ReadonlySet<string>): FlowNodeData;
+
+interface CreateFlowInput {
+    key: string;
+    label: string;
+    showInMenu: boolean;
+    /** Ausente quando `showInMenu` é falso — não há opção de menu para rotular. */
+    menuOptionLabel?: string;
+}
+/**
+ * Backend de fluxos do host. Funções cruas em vez de um cliente HTTP: o pacote roda em produtos com
+ * axios, fetch e react-query, e nenhum deles precisa entrar como dependência daqui.
+ */
+interface FlowsWorkspaceApi {
+    getGraphs(): Promise<Record<string, FlowGraphData>>;
+    saveGraph(key: string, graph: FlowGraphData): Promise<void>;
+    /**
+     * Criar e excluir fluxo são **opcionais por capacidade**: produto cujos fluxos vêm de um seed
+     * versionado não expõe rota para isso, e a tela simplesmente não desenha os botões — em vez de
+     * oferecer uma ação que estoura no clique.
+     */
+    createFlow?(input: CreateFlowInput): Promise<void>;
+    deleteFlow?(key: string): Promise<void>;
+    /**
+     * Onde estão as conversas vivas. Ausente, os cards não pulsam e nada é consultado.
+     *
+     * Aceita a linha por sessão e a linha já agregada por nó — `meta-whatsapp-module` responde a
+     * segunda, e exigir a primeira deixava os cards parados em todo produto que usa o módulo.
+     */
+    getLivePositions?(): Promise<readonly FlowLivePositionInput[]>;
+}
+interface FlowsWorkspaceProps {
+    readonly api: FlowsWorkspaceApi;
+    /** Fluxo raiz — o que abre por padrão e o único que não pode ser excluído. */
+    readonly rootFlowKey?: string;
+    readonly labels?: Partial<FlowEditorLabels>;
+    /** Kinds de ação do produto oferecidos na paleta (`trigger_simulation`, `abrir_comanda`…). */
+    readonly actionOptions?: readonly FlowPaletteActionOption[];
+    /** Seletor de arquivos do nó `send_media` — a biblioteca é do host, então entra por slot. */
+    readonly renderMediaPicker?: (node: FlowNodeData, graph: FlowGraphData) => ReactNode;
+    /** Intervalo do polling de posições vivas. Só tem efeito com `getLivePositions`. */
+    readonly livePollIntervalMs?: number;
+    /**
+     * Título e subtítulo do editor. `false` deixa só a barra de ações.
+     *
+     * Produto cuja navegação já nomeia a tela mostrava o nome duas vezes, em dois tamanhos, porque a
+     * tipografia daqui é do pacote e a de lá é do host. Esconder é a única saída que não força o
+     * pacote a adivinhar a escala tipográfica de cada produto.
+     */
+    readonly showHeader?: boolean;
+    readonly className?: string;
+}
+/**
+ * Editor de fluxograma completo — barra de ações, abas de fluxo, paleta, canvas com fusão
+ * editável, painel de nó, mapa de fluxos e diálogos de criar/excluir.
+ *
+ * É a tela inteira, não as peças: cada produto que remontava esse grid à mão acabava com uma
+ * versão diferente do mesmo editor. Customização entra por `labels`, `actionOptions` e
+ * `renderMediaPicker` — nunca por cópia do arquivo.
+ */
+declare function FlowsWorkspace({ api, rootFlowKey, labels: labelsOverride, actionOptions, renderMediaPicker, livePollIntervalMs, showHeader, className, }: FlowsWorkspaceProps): react.JSX.Element;
+
+/**
+ * Copyright (c) 2026 Ada Technology. MIT License.
+ *
+ * Operações puras de grafo que o editor de fluxo precisa, e que viviam soltas dentro da página de
+ * 973 linhas do financiamento.
+ *
+ * Puras e separadas do hook de propósito: são a parte que dá para testar sem navegador, sem React e
+ * sem estado — e três delas (`removeNodeAndCleanRefs`, `resolveConnection`, `mergedFlowKeysFrom`)
+ * decidem o que acontece com o fluxo que alguém desenhou. Errar ali não dá erro; dá aresta apontando
+ * para nó que não existe mais, ou fluxo que some do canvas.
+ */
+
+/**
+ * Id de nó no canvas mesclado: vários fluxos dividem o mesmo espaço, e `boas-vindas` pode existir em
+ * dois deles. Sem o prefixo, arrastar um card moveria o homônimo do outro fluxo.
+ */
+declare function namespaceNodeId(flowKey: string, nodeId: string): string;
+declare function parseNamespacedId(value: string): {
+    flowKey: string;
+    nodeId: string;
+};
+/**
+ * Apaga o nó E as referências a ele.
+ *
+ * A limpeza não é cortesia: uma aresta apontando para nó inexistente faz o motor do bot parar a
+ * conversa no meio, e o sintoma aparece para o cliente, não para quem editou.
+ */
+declare function removeNodeAndCleanRefs(nodes: Readonly<Record<string, FlowNodeData>>, removedId: string): Record<string, FlowNodeData>;
+/**
+ * O fecho transitivo dos fluxos alcançáveis a partir de um — é o conjunto que o canvas abre junto.
+ *
+ * BFS e não recursão: fluxo que referencia a si mesmo (menu que volta ao menu) é comum, e recursão
+ * ingênua estouraria a pilha no caso mais banal que existe.
+ */
+declare function mergedFlowKeysFrom(rootKey: string, graphs: Readonly<Record<string, FlowGraphData>>): readonly string[];
+type ConnectionRequest = {
+    readonly source: string;
+    readonly target: string;
+    readonly sourceHandle?: string | null | undefined;
+};
+type ResolvedConnection = {
+    readonly flowKey: string;
+    readonly nodeId: string;
+    readonly handle: string;
+    /** O que gravar no `next`: id de nó local, ou `flow:<key>` quando atravessa fluxo. */
+    readonly targetValue: string;
+};
+/**
+ * Traduz um arraste de aresta no valor que vai para o `next` — e recusa o que o motor do bot não
+ * sabe executar.
+ *
+ * A regra que não é óbvia: conectar num nó de OUTRO fluxo só funciona se for o nó inicial dele,
+ * porque o motor só sabe pular para o começo de um fluxo, não para um nó do meio. Conectar no meio
+ * devolve `undefined` — recusa silenciosa é melhor que gravar um salto que o bot vai ignorar em
+ * produção, deixando a conversa parada sem ninguém entender por quê.
+ */
+declare function resolveConnection(params: {
+    readonly connection: ConnectionRequest;
+    readonly graphs: Readonly<Record<string, FlowGraphData>>;
+}): ResolvedConnection | undefined;
+/** Aplica a conexão resolvida no nó. `next` string para saída única, objeto para ramificação. */
+declare function applyConnection(node: FlowNodeData, resolved: ResolvedConnection): FlowNodeData;
+/**
+ * Um fluxo está sujo quando o rascunho difere do publicado.
+ *
+ * Comparação estrutural por JSON: é grosseira, e é suficiente porque o grafo é dado serializável sem
+ * ordem significativa de chave — o servidor devolve o que gravou. Comparar campo a campo daria a
+ * mesma resposta com mais código para errar.
+ */
+declare function isGraphDirty(working: FlowGraphData | undefined, published: FlowGraphData | undefined): boolean;
 
-export { BUILT_IN_ACTION_KINDS, CONDITION_OPERATORS, CROSS_FLOW_PREFIX, type CollectionChain, DEFAULT_FLOW_EDITOR_LABELS, type FlowEditorLabels, FlowGroupFrame, type FlowGroupFrameData, FlowGroupHeader, type FlowGroupHeaderData, FlowMapCanvas, type FlowMapCanvasProps, FlowMapNode, type FlowMapNodeData, FlowNodeCard, type FlowNodeCardData, FlowNodePanel, type FlowNodePanelProps, FlowPalette, type FlowPaletteActionOption, type FlowPaletteProps, FlowPortalNode, type FlowPortalNodeData, FlowWhatsAppPreview, type FlowWhatsAppPreviewProps, type GraphIssue, NODE_CARD_WIDTH, type NewNodeSpec, WHATSAPP_LIMITS, computeAutoLayout, computeFlowMapLayout, crossFlowKey, crossFlowTargetsOf, estimateNodeHeight, findCollectionChains, flowGroupFrameNodeTypes, flowGroupHeaderNodeTypes, flowMapNodeTypes, flowNodeTypes, flowPortalNodeTypes, isCrossFlowTarget, mergeFlowEditorLabels, nodeLabel, rendersAsButtons, slugifyNodeId, targetsOf, validateGraph };
+export { BUILT_IN_ACTION_KINDS, CONDITION_OPERATORS, CROSS_FLOW_PREFIX, type CollectionChain, type ConnectionRequest, type CreateFlowInput, DEFAULT_FLOW_EDITOR_LABELS, type FlowEdgeKind, type FlowEdgeSpec, type FlowEditorLabels, FlowGroupFrame, type FlowGroupFrameData, FlowGroupHeader, type FlowGroupHeaderData, type FlowLiveNodeCount, type FlowLivePosition, type FlowLivePositionInput, FlowMapCanvas, type FlowMapCanvasProps, FlowMapNode, type FlowMapNodeData, FlowNodeCard, type FlowNodeCardData, FlowNodePanel, type FlowNodePanelProps, type FlowNodePosition, FlowPalette, type FlowPaletteActionOption, type FlowPaletteProps, FlowPortalNode, type FlowPortalNodeData, type FlowValidationLabels, FlowWhatsAppPreview, type FlowWhatsAppPreviewProps, FlowsWorkspace, type FlowsWorkspaceApi, type FlowsWorkspaceProps, GROUP_HEADER_NODE_ID, type GraphIssue, NODE_CARD_WIDTH, type NewNodeSpec, type ResolvedConnection, WHATSAPP_LIMITS, applyConnection, buildFlowEdges, chainFrameBounds, chainFrameNodeId, computeAutoLayout, computeFlowMapLayout, computeMergedLayout, countLiveByNode, crossFlowKey, crossFlowTargetsOf, detachedNodeIds, estimateNodeHeight, findCollectionChains, flowGroupFrameNodeTypes, flowGroupHeaderNodeTypes, flowMapNodeTypes, flowNodeTypes, flowPortalNodeTypes, isCrossFlowTarget, isGraphDirty, mergeFlowEditorLabels, mergedFlowKeysFrom, namespaceNodeId, newNodeFromSpec, nodeLabel, parseNamespacedId, portalNodeId, removeNodeAndCleanRefs, rendersAsButtons, resolveConnection, slugifyNodeId, targetsOf, validateGraph };