@adatechnology/conversations-ui 0.1.0-rc.4 → 0.1.0-rc.41

package/dist/flows/index.d.ts

@@ -1,5 +1,6 @@
 import * as react from 'react';
-import { NodeProps } from '@xyflow/react';
+import { ReactNode } from 'react';
+import { NodeProps, EdgeProps } from '@xyflow/react';
 import { LucideIcon } from 'lucide-react';
 import { FlowConditionOperator, FlowGraphData, FlowNodeData, FlowNodeType, FlowQuestionType, FlowActionKind } from '@adatechnology/meta-whatsapp-contracts';
 export { FlowActionKind, FlowConditionOperator, FlowGraphData, FlowNodeData, FlowNodeNext, FlowNodeType, FlowQuestionType } from '@adatechnology/meta-whatsapp-contracts';
@@ -9,7 +10,17 @@ 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";
 };
+/**
+ * Ações depois das quais a conversa CONTINUA no grafo, em vez de terminar.
+ *
+ * A distinção não é estética: o motor do bot só anda para o `next` depois de `send_media` — as
+ * demais ações (handoff, encerrar, simular, catálogo) encerram o passo ali. Dar saída a uma ação
+ * que o motor não atravessa desenharia um fio que o bot ignora em produção, deixando a conversa
+ * parada sem ninguém entender por quê — o mesmo erro que `resolveConnection` recusa cometer.
+ */
+declare const PASS_THROUGH_ACTION_KINDS: readonly string[];
 declare const CROSS_FLOW_PREFIX = "flow:";
 declare const isCrossFlowTarget: (target: string) => boolean;
 declare const crossFlowKey: (target: string) => string;
@@ -48,6 +59,15 @@ declare function validateGraph(graph: FlowGraphData, issueText: {
     conditionIncomplete: (id: string) => string;
     conditionBranchMissing: (id: string, branch: string) => string;
 }): GraphIssue[];
+/**
+ * Auto-layout em cascata: avança para a direita a cada passo do fluxo e desce a cada card.
+ *
+ * **Um card por linha, sempre.** Empilhar por camada — todos do mesmo nível na mesma coluna, todas
+ * as colunas começando na mesma altura — deixava os fios correndo na horizontal, e um fio horizontal
+ * passa por trás de qualquer card que esteja entre a origem e o destino. Descendo um degrau por
+ * card, toda ligação vira uma diagonal curta e visível, e o caminho da conversa se lê de cima para
+ * baixo enquanto avança da esquerda para a direita.
+ */
 declare function computeAutoLayout(graph: FlowGraphData): Record<string, {
     x: number;
     y: number;
@@ -62,11 +82,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 +96,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 +135,27 @@ interface FlowEditorLabels {
         conditionTrue: string;
         conditionFalse: string;
         conditionVariableMissing: string;
+        media: string;
+        mediaUnavailable: string;
+    };
+    quickAdd: {
+        fromHandle: string;
+        title: string;
+        disconnect: string;
+    };
+    /** Legenda do canvas: o que cada traço e cada contorno querem dizer. */
+    legendPanel: {
+        title: string;
+        nodes: string;
+        connections: string;
+        linear: string;
+        branch: string;
+        fallback: string;
+        crossFlow: string;
+        live: string;
+        selfLoop: string;
+        detached: string;
+        startNode: string;
     };
     palette: {
         title: string;
@@ -121,6 +168,8 @@ interface FlowEditorLabels {
     flowMap: {
         nodeCount: (count: number) => string;
         openFlow: string;
+        toggleToMap: string;
+        toggleToDetail: string;
     };
     flowGroup: {
         focus: string;
@@ -130,6 +179,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,10 +249,28 @@ 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>;
     onSelect: (id: string) => void;
+    /**
+     * Criar o próximo nó já ligado nesta saída. Capacidade por ausência: sem o callback, o "+" não
+     * aparece — puxar o fio à mão continua funcionando igual.
+     */
+    onQuickAdd?: ((params: {
+        nodeId: string;
+        handle: string;
+        anchor: {
+            x: number;
+            y: number;
+        };
+    }) => void) | undefined;
 };
 declare function FlowNodeCard({ data }: NodeProps): react.JSX.Element;
 declare const flowNodeTypes: {
@@ -219,8 +346,41 @@ interface FlowPaletteProps {
     labels?: Partial<FlowEditorLabels>;
     actionOptions?: FlowPaletteActionOption[];
 }
+interface FlowPaletteMenuProps {
+    onSelect: (spec: NewNodeSpec) => void;
+    labels: FlowEditorLabels;
+    actionOptions?: FlowPaletteActionOption[];
+}
+/**
+ * A lista de tipos de nó, sem o botão que a abre.
+ *
+ * Separada porque o "+" do card abre exatamente esta lista: duplicar os itens era garantir que um
+ * tipo novo aparecesse num caminho e faltasse no outro.
+ */
+declare function FlowPaletteMenu({ onSelect, labels, actionOptions }: FlowPaletteMenuProps): react.JSX.Element;
 declare function FlowPalette({ onAdd, labels: labelsOverride, actionOptions }: FlowPaletteProps): react.JSX.Element;
 
+type FlowLegendEdgeSample = {
+    readonly color: string;
+    readonly dash?: string | undefined;
+    readonly label: string;
+};
+type FlowLegendProps = {
+    readonly labels: FlowEditorLabels;
+    readonly edgeSamples: readonly FlowLegendEdgeSample[];
+    /** Classe de cor por tipo de card — a mesma que o `FlowNodeCard` usa, para a chave bater. */
+    readonly nodeSwatches: readonly {
+        readonly type: FlowNodeType;
+        readonly className: string;
+    }[];
+};
+declare function FlowLegend({ labels, edgeSamples, nodeSwatches }: FlowLegendProps): react.JSX.Element;
+
+declare function FlowConnectionEdge({ id, sourceX, sourceY, targetX, targetY, sourcePosition, targetPosition, markerEnd, style, data, interactionWidth, }: EdgeProps): react.JSX.Element;
+declare const flowEdgeTypes: {
+    flowConnection: typeof FlowConnectionEdge;
+};
+
 interface FlowNodePanelProps {
     graph: FlowGraphData;
     node: FlowNodeData;
@@ -233,14 +393,271 @@ 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, na mesma cascata do fluxo
+ * único: um passo para a direita a cada avanço da conversa, um degrau para baixo a cada card.
+ *
+ * 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 a travessia 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, FlowConnectionEdge, type FlowEdgeKind, type FlowEdgeSpec, type FlowEditorLabels, FlowGroupFrame, type FlowGroupFrameData, FlowGroupHeader, type FlowGroupHeaderData, FlowLegend, type FlowLiveNodeCount, type FlowLivePosition, type FlowLivePositionInput, FlowMapCanvas, type FlowMapCanvasProps, FlowMapNode, type FlowMapNodeData, FlowNodeCard, type FlowNodeCardData, FlowNodePanel, type FlowNodePanelProps, type FlowNodePosition, FlowPalette, type FlowPaletteActionOption, FlowPaletteMenu, 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, PASS_THROUGH_ACTION_KINDS, type ResolvedConnection, WHATSAPP_LIMITS, applyConnection, buildFlowEdges, chainFrameBounds, chainFrameNodeId, computeAutoLayout, computeFlowMapLayout, computeMergedLayout, countLiveByNode, crossFlowKey, crossFlowTargetsOf, detachedNodeIds, estimateNodeHeight, findCollectionChains, flowEdgeTypes, flowGroupFrameNodeTypes, flowGroupHeaderNodeTypes, flowMapNodeTypes, flowNodeTypes, flowPortalNodeTypes, isCrossFlowTarget, isGraphDirty, mergeFlowEditorLabels, mergedFlowKeysFrom, namespaceNodeId, newNodeFromSpec, nodeLabel, parseNamespacedId, portalNodeId, removeNodeAndCleanRefs, rendersAsButtons, resolveConnection, slugifyNodeId, targetsOf, validateGraph };