@mosaicoo/kanban 0.1.0

package/types/mosaicoo-kanban-core.d.ts

@@ -0,0 +1,689 @@
+/**
+ * Versão do pacote em runtime.
+ *
+ * Mantida em sincronia com projects/kanban/package.json pelo processo de
+ * release (standard-version updater — mesmo mecanismo do @mosaicoo/svg-engine).
+ */
+declare const MKB_VERSION = "0.1.0";
+
+/**
+ * Modelo DECLARATIVO de cartão — serializável (docs/01 §4). O cartão é uma
+ * LISTA ORDENADA de blocos tipados; qualquer tipo pode repetir à vontade, em
+ * qualquer posição (três `date`, dois `text`… tudo válido). Nenhum campo do
+ * item é especial — até o título é só um bloco `text` apontando um campo.
+ *
+ * Estilo NÃO mora aqui (docs: decisão de F5.5): posicionamento/altura/tema são
+ * CSS externo. Cada bloco carrega apenas `class` (combinação de classes do
+ * host) e recebe classes-base estáveis (`mkb-block`, `mkb-block-<tipo>`…) que
+ * são o CONTRATO de estilo. `tone` é a exceção — carrega SIGNIFICADO
+ * (a11y/semântica), não só aparência, e vira `mkb-tone-<tom>`.
+ */
+type KanbanTone = 'neutral' | 'info' | 'success' | 'warning' | 'danger';
+/** Estilo aplicado a um VALOR (mapa valor→estilo em tag/badge). */
+interface KanbanValueStyle {
+    /** Rótulo exibido no lugar do valor cru. */
+    label?: string;
+    tone?: KanbanTone;
+    /** Nome de ícone resolvido no registry (`icon:<nome>`). */
+    icon?: string;
+}
+/** Um "fato" inline (ex.: 2 🛏, 3 🛁) — campo + ícone opcional. */
+interface KanbanFact {
+    field: string;
+    icon?: string;
+    prefix?: string;
+    suffix?: string;
+    label?: string;
+}
+/** Ação declarada no cartão; dispara pelo mesmo (itemAction) do menu. */
+interface KanbanCardAction {
+    id: string;
+    label: string;
+    icon?: string;
+    tone?: KanbanTone;
+    /** Mostra a ação só quando o item está na coluna/lane indicada. */
+    when?: {
+        column?: string | string[];
+        lane?: string | string[];
+    };
+}
+interface BlockBase {
+    /** Classes CSS extras do host (string ou lista) — combinadas às base. */
+    class?: string | string[];
+    /** Rótulo curto antes do valor (ex.: "criado em"). */
+    label?: string;
+}
+interface FieldBlockBase extends BlockBase {
+    /** Campo do item lido por este bloco. */
+    field: string;
+    /** Oculta o bloco quando o campo está vazio/ausente (default true). */
+    hideWhenEmpty?: boolean;
+}
+type DateStyle = 'short' | 'medium' | 'long' | 'full';
+type TimeStyle = 'short' | 'medium';
+/** Texto de um campo. `format` (opcional) aponta um formatador do registry
+ * (`format:<nome>`) para casos que fogem dos blocos estruturados. */
+interface TextBlock extends FieldBlockBase {
+    type: 'text';
+    variant?: 'title' | 'subtitle' | 'body' | 'caption' | 'highlight';
+    prefix?: string;
+    suffix?: string;
+    format?: string;
+    /** Nº máximo de linhas antes de truncar com reticências. */
+    clamp?: number;
+}
+/** Número formatado via Intl (decimal/moeda/percentual). */
+interface NumberBlock extends FieldBlockBase {
+    type: 'number';
+    variant?: 'body' | 'highlight';
+    style?: 'decimal' | 'currency' | 'percent';
+    /** Código ISO da moeda quando style='currency' (ex.: 'BRL'). */
+    currency?: string;
+    decimals?: number;
+    prefix?: string;
+    suffix?: string;
+}
+/** Data formatada via Intl; `relative` → "há 4 horas". */
+interface DateBlock extends FieldBlockBase {
+    type: 'date';
+    dateStyle?: DateStyle;
+    relative?: boolean;
+}
+/** Hora formatada via Intl. */
+interface TimeBlock extends FieldBlockBase {
+    type: 'time';
+    timeStyle?: TimeStyle;
+}
+/** Data + hora; `relative` tem precedência quando true. */
+interface DateTimeBlock extends FieldBlockBase {
+    type: 'datetime';
+    dateStyle?: DateStyle;
+    timeStyle?: TimeStyle;
+    relative?: boolean;
+}
+/** Imagem cujo src vem do campo. */
+interface ImageBlock extends FieldBlockBase {
+    type: 'image';
+    alt?: string;
+    rounded?: boolean;
+}
+/** Chip/etiqueta; `map` estiliza por valor (label/tom/ícone). */
+interface TagBlock extends FieldBlockBase {
+    type: 'tag';
+    tone?: KanbanTone;
+    map?: Record<string, KanbanValueStyle>;
+}
+/** Selo compacto (ícone + tom), tipicamente mapeado por valor. */
+interface BadgeBlock extends FieldBlockBase {
+    type: 'badge';
+    icon?: string;
+    tone?: KanbanTone;
+    map?: Record<string, KanbanValueStyle>;
+    /** Mostra o texto ao lado do ícone (default false). */
+    showText?: boolean;
+}
+/** Ícone estático (não lê campo) do registry. */
+interface IconBlock extends BlockBase {
+    type: 'icon';
+    icon: string;
+    tone?: KanbanTone;
+}
+/** Avatar (foto ou iniciais) + nome opcional. */
+interface AvatarBlock extends BlockBase {
+    type: 'avatar';
+    nameField?: string;
+    photoField?: string;
+    hideWhenEmpty?: boolean;
+}
+/** Lista inline de fatos (campo + ícone). */
+interface FactsBlock extends BlockBase {
+    type: 'facts';
+    items: KanbanFact[];
+}
+/**
+ * ENTRIES do card (docs/02 §7): renderiza `card[field]: KanbanEntry[]` como
+ * itens internos com capacidades configuráveis — nada de regra de domínio.
+ */
+interface ItemsBlock extends FieldBlockBase {
+    type: 'items';
+    /** Campo da entry exibido como rótulo (default 'label'). */
+    labelField?: string;
+    /** Campo booleano de conclusão — habilita 'check' e o progresso. */
+    checkField?: string;
+    /** Capacidades opt-in: 'check' (marcar/desmarcar via updateEntry),
+     * 'reorder' (arrastar dentro do card via moveEntry), 'move-across'
+     * (arrastar entre CARDS — listas do mesmo field se conectam; implica
+     * 'reorder'), 'action' (botões por entry → (entryAction)).
+     * Default: só exibição. */
+    capabilities?: Array<'check' | 'reorder' | 'move-across' | 'action'>;
+    /** Ações por entry (exige capability 'action'). */
+    actions?: KanbanCardAction[];
+    /** Mostra "N/M" + barra de progresso (exige checkField). */
+    showProgress?: boolean;
+    /** Exibe só as N primeiras entries (indicador "+k" para o resto). */
+    maxVisible?: number;
+}
+/** Faixa de alerta (a faixa amarela "Sem resposta há…" da referência). */
+interface AlertBlock extends FieldBlockBase {
+    type: 'alert';
+    tone?: KanbanTone;
+    icon?: string;
+}
+/** Barra de progresso (0..max). */
+interface ProgressBlock extends FieldBlockBase {
+    type: 'progress';
+    max?: number;
+    tone?: KanbanTone;
+}
+/** Divisor horizontal (não lê campo). */
+interface DividerBlock extends BlockBase {
+    type: 'divider';
+}
+/** Botões de ação no rodapé do cartão. */
+interface ActionsBlock extends BlockBase {
+    type: 'actions';
+    items: KanbanCardAction[];
+}
+/** Container horizontal para compor blocos lado a lado. */
+interface RowBlock extends BlockBase {
+    type: 'row';
+    blocks: KanbanBlock[];
+    align?: 'start' | 'center' | 'end' | 'between';
+    wrap?: boolean;
+}
+/** Escape hatch leve: renderer registrado (`renderer:<nome>`) que devolve
+ * conteúdo do host. Para UI pesada, prefira o <ng-template mosKanbanCard>. */
+interface CustomBlock extends BlockBase {
+    type: 'custom';
+    renderer: string;
+}
+/** União discriminada de todos os blocos. */
+type KanbanBlock = TextBlock | NumberBlock | DateBlock | TimeBlock | DateTimeBlock | ImageBlock | TagBlock | BadgeBlock | IconBlock | AvatarBlock | FactsBlock | ItemsBlock | AlertBlock | ProgressBlock | DividerBlock | ActionsBlock | RowBlock | CustomBlock;
+type KanbanBlockType = KanbanBlock['type'];
+/** Configuração do cartão: a árvore de blocos. */
+interface KanbanCardConfig {
+    blocks: KanbanBlock[];
+    /** true = o card só arrasta pela ALÇA ⠿ (recomendado quando o cartão tem
+     * muito conteúdo interativo, ex.: bloco items). Default: corpo inteiro
+     * com guarda de interativos. */
+    dragHandle?: boolean;
+}
+/** Todos os tipos de bloco conhecidos (usado pela validação). */
+declare const KANBAN_BLOCK_TYPES: readonly KanbanBlockType[];
+declare function isFieldBlock(type: KanbanBlockType): boolean;
+
+/**
+ * Modelo do board — TUDO aqui é serializável (JSON): é o que permite editar a
+ * configuração numa tela do host e persistir em banco (docs/01 §4). Código
+ * custom (regras, filtros programáticos) entra por NOME, via KanbanRegistry.
+ */
+
+/** Item do board: registro serializável com `id` obrigatório. Os demais
+ * campos são livres — são eles que posicionam o item nos eixos. */
+interface KanbanItem {
+    readonly id: string;
+    readonly [field: string]: unknown;
+}
+/**
+ * Item INTERNO de um card (checklist ágil, ações de negociação…): registro
+ * serializável que vive num ARRAY dentro de um campo do card
+ * (`card[field]: KanbanEntry[]`). Como no KanbanItem, os campos são livres —
+ * tipo/estado/responsável/prazo/prioridade são vocabulário do DOMÍNIO.
+ */
+interface KanbanEntry {
+    readonly id: string;
+    readonly [field: string]: unknown;
+}
+/** Endereço de uma entry: card + campo + posição. */
+interface EntryRef {
+    cardId: string;
+    field: string;
+    index: number;
+}
+/** Definição de um grupo (coluna ou lane) de eixo estático. */
+interface KanbanGroupDef {
+    id: string;
+    title?: string;
+    /** WIP limit: máximo de itens no grupo; mover/adicionar acima disso é rejeitado. */
+    limit?: number;
+    /** Grupo travado: itens não entram nem saem dele. */
+    locked?: boolean;
+    /** Metadados livres do host (ícone, cor…) — a lib não interpreta. */
+    meta?: Record<string, unknown>;
+}
+/**
+ * Um eixo (colunas ou lanes):
+ * - ESTÁTICO: `groups` declarados; o campo `field` do item aponta o grupo.
+ * - DERIVADO (agrupamento dinâmico): sem `groups`; os grupos são os valores
+ *   distintos de `field` nos itens.
+ */
+interface KanbanAxisConfig {
+    /** Campo do item que posiciona neste eixo (default: 'column' / 'lane'). */
+    field?: string;
+    groups?: Array<string | KanbanGroupDef>;
+    /** Ordenação dos grupos por id; ausente = ordem declarada/de aparição. */
+    sortGroups?: 'asc' | 'desc';
+    /** Opt-in: permite reordenar os grupos (comando moveGroup / drag do header).
+     * Só vale para eixo ESTÁTICO sem sortGroups. Default false — nenhum host
+     * ganha colunas/lanes arrastáveis sem pedir. */
+    reorderable?: boolean;
+}
+/** Açúcar: um array de grupos equivale a um eixo estático com field default. */
+type KanbanAxisInput = Array<string | KanbanGroupDef> | KanbanAxisConfig;
+/** Ordenação dos itens dentro da célula; ausente = ordem MANUAL (drag). */
+interface KanbanSortConfig {
+    field: string;
+    direction?: 'asc' | 'desc';
+}
+/** Filtros serializáveis; múltiplos filtros = AND. `rule` aponta um predicado
+ * de item registrado no registry: (item) => boolean. */
+type KanbanFilter = {
+    field: string;
+    equals: unknown;
+} | {
+    field: string;
+    oneOf: unknown[];
+} | {
+    text: string;
+    fields?: string[];
+} | {
+    rule: string;
+};
+/** Whitelist de transição entre colunas; lado omitido = qualquer. */
+interface KanbanTransition {
+    from?: string | string[];
+    to?: string | string[];
+}
+interface KanbanRulesConfig {
+    /** Presente = só as transições listadas são permitidas entre colunas. */
+    transitions?: KanbanTransition[];
+    /** Regras nomeadas no registry: (ctx: MoveRuleContext) => true | 'motivo'. */
+    rules?: string[];
+    /** Regras nomeadas para movimento de ENTRIES:
+     * (ctx: EntryMoveContext) => true | 'motivo'. */
+    entryRules?: string[];
+}
+/** A configuração COMPLETA do board — serializável de ponta a ponta. */
+interface BoardConfig {
+    columns: KanbanAxisInput;
+    lanes?: KanbanAxisInput;
+    items?: KanbanItem[];
+    sort?: KanbanSortConfig;
+    filters?: KanbanFilter[];
+    rules?: KanbanRulesConfig;
+    readOnly?: boolean;
+    /** Modelo declarativo do cartão; ausente = cartão default (título/id). */
+    card?: KanbanCardConfig;
+}
+/** Snapshot imutável do estado observável do board. */
+interface BoardState {
+    readonly items: readonly KanbanItem[];
+    readonly filters: readonly KanbanFilter[];
+    readonly selection: readonly string[];
+    readonly readOnly: boolean;
+    /** Ordem atual dos grupos ESTÁTICOS de cada eixo (ids). Vazio em eixo
+     * derivado (a ordem vem dos dados). Mutável via comando moveGroup. */
+    readonly columnOrder: readonly string[];
+    readonly laneOrder: readonly string[];
+}
+/** Qual eixo um comando/consulta de grupo endereça. */
+type KanbanAxis = 'columns' | 'lanes';
+/** Célula = interseção coluna × lane (lane ausente quando o eixo não existe). */
+interface CellRef {
+    column: string | undefined;
+    lane?: string | undefined;
+}
+/** Destino de movimento; lados omitidos mantêm a posição atual do item. */
+interface MoveTarget {
+    column?: string;
+    lane?: string;
+    /** Posição dentro da célula (ordem manual); ausente = fim da célula. */
+    index?: number;
+}
+type KanbanCommand = {
+    type: 'moveItem';
+    itemId: string;
+    to: MoveTarget;
+} | {
+    type: 'addItem';
+    item: KanbanItem;
+    to?: MoveTarget;
+} | {
+    type: 'updateItem';
+    itemId: string;
+    changes: Record<string, unknown>;
+} | {
+    type: 'removeItem';
+    itemId: string;
+} | {
+    type: 'moveGroup';
+    axis: KanbanAxis;
+    groupId: string;
+    index: number;
+} | {
+    type: 'moveEntry';
+    cardId: string;
+    field: string;
+    entryId: string;
+    /** Posição na lista de destino (SEM contar a entry movida). */
+    index: number;
+    /** Card/campo de destino; omitidos = mesmo card/campo. */
+    toCardId?: string;
+    toField?: string;
+} | {
+    type: 'addEntry';
+    cardId: string;
+    field: string;
+    entry: KanbanEntry;
+    index?: number;
+} | {
+    type: 'updateEntry';
+    cardId: string;
+    field: string;
+    entryId: string;
+    changes: Record<string, unknown>;
+} | {
+    type: 'removeEntry';
+    cardId: string;
+    field: string;
+    entryId: string;
+} | {
+    type: 'setFilters';
+    filters: KanbanFilter[];
+} | {
+    type: 'setSelection';
+    itemIds: string[];
+} | {
+    type: 'setReadOnly';
+    readOnly: boolean;
+};
+type CommandResult = {
+    ok: true;
+} | {
+    ok: false;
+    reason: string;
+};
+/** Grupo resolvido pelo query (estático ou derivado), com contagem. */
+interface KanbanGroup extends KanbanGroupDef {
+    count: number;
+    derived: boolean;
+}
+/** Contexto entregue às regras nomeadas de movimentação. As regras devem ser
+ * PURAS: elas rodam tanto no preview (canMove) quanto no commit — é isso que
+ * garante preview == commit. */
+interface MoveRuleContext {
+    item: KanbanItem;
+    from: CellRef;
+    to: CellRef;
+    /** Itens já presentes na célula de destino (sem contar o item movido). */
+    targetCount: number;
+    state: BoardState;
+}
+type KanbanRuleFn = (ctx: MoveRuleContext) => true | string;
+type KanbanItemPredicate = (item: KanbanItem) => boolean;
+/** Contexto entregue às regras nomeadas de movimento de ENTRY. Puras, rodam
+ * no preview (canMoveEntry) e no commit — preview == commit. */
+interface EntryMoveContext {
+    entry: KanbanEntry;
+    fromCard: KanbanItem;
+    toCard: KanbanItem;
+    from: EntryRef;
+    to: EntryRef;
+    /** Entries já presentes na lista de destino (sem contar a movida). */
+    targetCount: number;
+    state: BoardState;
+}
+type KanbanEntryRuleFn = (ctx: EntryMoveContext) => true | string;
+type KanbanAction = 'move' | 'add' | 'update' | 'remove' | 'entry-move' | 'entry-update';
+/**
+ * O que o HOST fornece à instância (docs/01 §8) — permissões e locale.
+ * Sem noção de tenant: o host entrega o adapter/contexto já contextualizados.
+ * `can` roda no preview E no commit (preview == commit) e também protege o
+ * undo/redo; NÃO se aplica a eventos remotos (applyRemote), que já
+ * aconteceram na origem.
+ */
+interface KanbanHostContext {
+    can?(action: KanbanAction, item?: KanbanItem): boolean;
+    locale?: string;
+}
+/** Evento cancelável (before:*). `cancel()` aborta o comando; o motivo vira o
+ * `reason` do CommandResult. Prefira validar em REGRAS (que rodam também no
+ * preview); before:* é veto de última instância / gancho de efeito. */
+interface CancelableEvent<T> {
+    readonly data: T;
+    readonly canceled: boolean;
+    readonly reason: string | undefined;
+    cancel(reason?: string): void;
+}
+interface MoveEventData {
+    item: KanbanItem;
+    from: CellRef;
+    to: CellRef;
+    index?: number;
+}
+interface AddEventData {
+    item: KanbanItem;
+}
+interface UpdateEventData {
+    item: KanbanItem;
+    previous: KanbanItem;
+    changes: Record<string, unknown>;
+}
+interface RemoveEventData {
+    item: KanbanItem;
+}
+interface GroupMoveEventData {
+    axis: KanbanAxis;
+    groupId: string;
+    from: number;
+    to: number;
+    /** Nova ordem completa dos ids do eixo (já aplicada nos after:*). */
+    order: readonly string[];
+}
+interface EntryMoveEventData {
+    entry: KanbanEntry;
+    from: EntryRef;
+    to: EntryRef;
+}
+/** add/update/remove de entry num só par de eventos, discriminado por `op`. */
+interface EntryUpdateEventData {
+    op: 'add' | 'update' | 'remove';
+    cardId: string;
+    field: string;
+    entry: KanbanEntry;
+    /** Presente em op='update': a entry ANTES das mudanças. */
+    previous?: KanbanEntry;
+    changes?: Record<string, unknown>;
+}
+type KanbanEvents = {
+    change: BoardState;
+    'before:move': CancelableEvent<MoveEventData>;
+    'after:move': MoveEventData;
+    'before:add': CancelableEvent<AddEventData>;
+    'after:add': AddEventData;
+    'before:update': CancelableEvent<UpdateEventData>;
+    'after:update': UpdateEventData;
+    'before:remove': CancelableEvent<RemoveEventData>;
+    'after:remove': RemoveEventData;
+    'before:group-move': CancelableEvent<GroupMoveEventData>;
+    'after:group-move': GroupMoveEventData;
+    'before:entry-move': CancelableEvent<EntryMoveEventData>;
+    'after:entry-move': EntryMoveEventData;
+    'before:entry-update': CancelableEvent<EntryUpdateEventData>;
+    'after:entry-update': EntryUpdateEventData;
+};
+interface ValidationIssue {
+    path: string;
+    message: string;
+}
+interface ValidationResult {
+    valid: boolean;
+    errors: ValidationIssue[];
+}
+
+/**
+ * Valida um BoardConfig vindo de fora (tela de configuração do host, banco,
+ * arquivo). Estrutural e barata — regras nomeadas NÃO são resolvidas aqui
+ * (o registry é runtime; a config só carrega nomes).
+ */
+declare function validateConfig(config: unknown): ValidationResult;
+
+/**
+ * Registro nomeado de código custom (docs/01 §4): a config serializável
+ * referencia funções por NOME ('rule:berco-livre', 'filter:atrasados'…) e o
+ * host registra as implementações aqui, uma vez.
+ *
+ * É uma INSTÂNCIA (injetada em createBoard), nunca um singleton de módulo —
+ * higiene de instância (docs/01 §8).
+ */
+declare class KanbanRegistry {
+    private readonly entries;
+    register(name: string, value: unknown): this;
+    get<T>(name: string): T | undefined;
+    has(name: string): boolean;
+    names(): string[];
+}
+
+/** Motivos padronizados de recusa (regras nomeadas retornam texto livre). */
+declare const MOVE_REASONS: {
+    readonly readOnly: "read-only";
+    readonly locked: "locked";
+    readonly transitionNotAllowed: "transition-not-allowed";
+    readonly wipLimit: "wip-limit";
+    readonly notFound: "not-found";
+    readonly unknownGroup: "unknown-group";
+    readonly forbidden: "forbidden";
+    readonly notReorderable: "not-reorderable";
+    readonly canceled: "canceled";
+    readonly destroyed: "destroyed";
+};
+
+/**
+ * Helpers PUROS de entries (itens internos de card) — docs/02 §7.
+ * Uma entry vive num array serializável dentro de um campo do card:
+ * `card[field]: KanbanEntry[]`. Nada aqui toca estado.
+ */
+/** Lê as entries de um campo do card; valor ausente/malformado → []. */
+declare function entriesOf(card: KanbanItem, field: string): KanbanEntry[];
+
+interface CreateBoardOptions {
+    /** Registro de código nomeado (regras, predicados de filtro). Sem ele, o
+     * board cria um registro próprio vazio. */
+    registry?: KanbanRegistry;
+    /** Contexto do host: permissões (can) e locale — docs/01 §8. */
+    host?: KanbanHostContext;
+}
+/**
+ * O board headless: estado imutável + comandos + regras + eventos + undo/redo.
+ * Instâncias são totalmente isoladas entre si (docs/01 §8) e nada aqui toca
+ * DOM, Angular ou persistência — a UI e os adapters consomem esta API.
+ */
+declare class KanbanBoard {
+    private readonly columnsAxis;
+    private readonly lanesAxis;
+    private readonly config;
+    private readonly store;
+    private readonly emitter;
+    private readonly host;
+    readonly registry: KanbanRegistry;
+    private undoStack;
+    private redoStack;
+    private destroyed;
+    constructor(config: BoardConfig, options?: CreateBoardOptions);
+    get state(): BoardState;
+    /** Modelo declarativo do cartão (docs/01 §4); undefined = cartão default. */
+    get cardConfig(): KanbanCardConfig | undefined;
+    /** Locale fornecido pelo host — usado por formatadores de data/número. */
+    get locale(): string | undefined;
+    subscribe(listener: (state: BoardState) => void): () => void;
+    on<K extends keyof KanbanEvents>(event: K, handler: (payload: KanbanEvents[K]) => void): () => void;
+    execute(command: KanbanCommand): CommandResult;
+    /**
+     * Aplica um comando de DADOS vindo de FORA (tempo real / rollback do
+     * adapter): não entra no histórico de undo, não dispara before:* e NÃO
+     * passa por readOnly/regras/permissões — o evento já aconteceu na origem
+     * (last-write-wins). A estrutura ainda é validada (item/grupo existem).
+     */
+    applyRemote(command: KanbanCommand): CommandResult;
+    get canUndo(): boolean;
+    get canRedo(): boolean;
+    /** Desfaz o último comando de DADOS. Regras são revalidadas (o mundo pode
+     * ter mudado); before:* não dispara — undo não é vetável, mas é auditável
+     * pelos after:*. */
+    undo(): CommandResult;
+    redo(): CommandResult;
+    private applyHistoryCmd;
+    /** Grupos resolvidos do eixo de colunas (estático ou derivado), com contagem. */
+    columns(): KanbanGroup[];
+    /** Grupos do eixo de lanes; null quando o board não tem lanes. */
+    lanes(): KanbanGroup[] | null;
+    /** Itens da célula (ordem manual ou `sort` da config). NÃO aplica filtros. */
+    itemsIn(columnId: string, laneId?: string): KanbanItem[];
+    /** Como itemsIn, mas só os itens visíveis pelos filtros ativos. */
+    visibleItemsIn(columnId: string, laneId?: string): KanbanItem[];
+    isVisible(item: KanbanItem): boolean;
+    getItem(id: string): KanbanItem | undefined;
+    find(predicate: KanbanItemPredicate): KanbanItem[];
+    /**
+     * Dry-run do moveItem: roda EXATAMENTE a mesma cadeia de regras do commit
+     * (preview == commit). Não dispara eventos nem altera estado — é o que a UI
+     * usa para indicar drop válido/inválido durante o arrasto.
+     */
+    canMove(itemId: string, to: MoveTarget): CommandResult;
+    destroy(): void;
+    private validateMove;
+    /**
+     * Nota: mover grava o ID DO GRUPO (string) no campo do eixo — um campo
+     * numérico agrupado dinamicamente passa a string após um movimento.
+     */
+    private applyMove;
+    private applyAdd;
+    private applyUpdate;
+    private applyRemove;
+    /** O eixo é reordenável? (estático, opt-in `reorderable`, sem sortGroups). */
+    isReorderable(axis: KanbanAxis): boolean;
+    /** Dry-run do moveGroup — mesma cadeia do commit (preview == commit). */
+    canMoveGroup(axis: KanbanAxis, groupId: string, index: number): CommandResult;
+    private validateMoveGroup;
+    private applyMoveGroup;
+    /** Entries de um campo do card ([] quando ausente/malformado). */
+    entries(cardId: string, field: string): KanbanEntry[];
+    /** Dry-run do moveEntry — mesma cadeia do commit (preview == commit). */
+    canMoveEntry(cmd: Omit<Extract<KanbanCommand, {
+        type: 'moveEntry';
+    }>, 'type'>): CommandResult;
+    private validateEntryMove;
+    private applyEntryMove;
+    private applyAddEntry;
+    private applyUpdateEntry;
+    private applyRemoveEntry;
+    /** Guardas comuns de escrita de entry (card existe, readOnly, permissão). */
+    private entryWriteGuard;
+    /** Aplica patches de campos a um ou mais cards num único snapshot. */
+    private patchCards;
+    private pushHistory;
+    private cellOf;
+    private inCell;
+    private countInCell;
+    private countInColumn;
+    private countInLane;
+    /** Posição do item entre os itens da própria célula (ordem manual). */
+    private indexInCell;
+    /** Insere `item` (já com os campos novos) na posição `index` da sua célula,
+     * mapeada para a posição global correspondente. `items` NÃO contém o item. */
+    private placeInCell;
+    private groupExists;
+    private groupDef;
+    private resolveGroups;
+    private countByField;
+    private applySort;
+}
+/**
+ * Cria um board a partir de uma config serializável. Falha RÁPIDO (throw) em
+ * config estruturalmente inválida — para validar sem lançar (ex.: config
+ * vinda do banco), use validateConfig antes.
+ */
+declare function createBoard(config: BoardConfig, options?: CreateBoardOptions): KanbanBoard;
+
+export { KANBAN_BLOCK_TYPES, KanbanBoard, KanbanRegistry, MKB_VERSION, MOVE_REASONS, createBoard, entriesOf, isFieldBlock, validateConfig };
+export type { ActionsBlock, AddEventData, AlertBlock, AvatarBlock, BadgeBlock, BoardConfig, BoardState, CancelableEvent, CellRef, CommandResult, CreateBoardOptions, CustomBlock, DateBlock, DateTimeBlock, DividerBlock, EntryMoveContext, EntryMoveEventData, EntryRef, EntryUpdateEventData, FactsBlock, GroupMoveEventData, IconBlock, ImageBlock, ItemsBlock, KanbanAction, KanbanAxis, KanbanAxisConfig, KanbanAxisInput, KanbanBlock, KanbanBlockType, KanbanCardAction, KanbanCardConfig, KanbanCommand, KanbanEntry, KanbanEntryRuleFn, KanbanEvents, KanbanFact, KanbanFilter, KanbanGroup, KanbanGroupDef, KanbanHostContext, KanbanItem, KanbanItemPredicate, KanbanRuleFn, KanbanRulesConfig, KanbanSortConfig, KanbanTone, KanbanTransition, KanbanValueStyle, MoveEventData, MoveRuleContext, MoveTarget, NumberBlock, ProgressBlock, RemoveEventData, RowBlock, TagBlock, TextBlock, TimeBlock, UpdateEventData, ValidationIssue, ValidationResult };