@mosaicoo/kanban 0.1.0

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

@@ -0,0 +1,538 @@
+import * as _mosaicoo_kanban_core from '@mosaicoo/kanban/core';
+import { KanbanItem, KanbanBoard, CommandResult, KanbanEntry, KanbanBlock, KanbanRegistry, KanbanValueStyle, KanbanFact, KanbanCardAction, KanbanCardConfig, MoveEventData, KanbanGroup } from '@mosaicoo/kanban/core';
+import * as _angular_core from '@angular/core';
+import { TemplateRef } from '@angular/core';
+import { CdkDrag, CdkDragDrop } from '@angular/cdk/drag-drop';
+import { SafeHtml } from '@angular/platform-browser';
+
+/** Contexto do template de cartão custom. */
+interface KanbanCardContext {
+    $implicit: KanbanItem;
+}
+/**
+ * Template de cartão custom, projetado no board:
+ *
+ *   <mos-kanban-board [board]="board">
+ *     <ng-template mosKanbanCard let-item>{{ item['title'] }}</ng-template>
+ *   </mos-kanban-board>
+ *
+ * Sem o template, o board renderiza o cartão default.
+ */
+declare class MosKanbanCardDef {
+    readonly template: TemplateRef<any>;
+    static ngTemplateContextGuard(_dir: MosKanbanCardDef, ctx: unknown): ctx is KanbanCardContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MosKanbanCardDef, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MosKanbanCardDef, "ng-template[mosKanbanCard]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Cancelamento por Esc (spike D0/E4): o CDK não cancela drag nativamente.
+ * Workaround: Esc arma este flag e dispara um mouseup sintético — o drop
+ * acontece, mas os handlers CONSOMEM o flag e não executam comando algum;
+ * como a UI renderiza do estado (inalterado), o elemento volta à origem.
+ * Instância por board (provider do componente), nunca singleton de módulo.
+ */
+declare class DragCancelFlag {
+    private canceled;
+    arm(): void;
+    /** Lê E limpa (check-and-clear em todo handler de drop). */
+    consume(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DragCancelFlag, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DragCancelFlag>;
+}
+/**
+ * Costura entre o GESTO de arrasto e os COMANDOS do core — deliberadamente
+ * agnóstica de CDK (docs/01 §6): os componentes traduzem eventos do CDK para
+ * estas funções; trocar a engine de drag no futuro não toca em regra alguma.
+ *
+ * Preview e commit usam o MESMO caminho (board.canMove / moveItem): o que o
+ * indicador de drop mostra é exatamente o que o solto faz.
+ *
+ * Uma "célula" é a interseção coluna × lane; sem eixo de lanes, a célula é a
+ * coluna inteira (laneId undefined).
+ */
+/**
+ * Id DOM estável da drop list de uma célula (spike D0/E1): as células são
+ * conectadas entre si por `cdkDropListConnectedTo` EXPLÍCITO — nada de
+ * `cdkDropListGroup`, que auto-conectaria também as listas de reorder de
+ * colunas/lanes (ancestrais) e corromperia a detecção de alvo do CDK.
+ * encodeURIComponent: ids de grupo podem ter espaço (inválido em id de DOM).
+ */
+declare function cellListId(columnId: string, laneId?: string): string;
+/** Id DOM estável da drop list de ENTRIES de um card (bloco items): listas
+ * do MESMO field conectam-se entre cards quando 'move-across' está ligado —
+ * mesma topologia explícita das células. */
+declare function entriesListId(cardId: string, field: string): string;
+/** Fase de um gesto de arraste (outputs de ciclo do board — docs/02 §9). */
+interface KanbanDragLifecycle {
+    phase: 'start' | 'end';
+    kind: 'card' | 'column' | 'lane' | 'entry';
+    id: string;
+}
+/** Identificação do gesto nos outputs (dragStarted/dragEnded/dragCanceled). */
+interface KanbanDragInfo {
+    kind: 'card' | 'column' | 'lane' | 'entry';
+    id: string;
+}
+/** Pergunta de preview para drop de entry entre cards (preview == commit:
+ * a célula fornece esta função a partir do board.canMoveEntry). */
+type CanDropEntryFn = (req: {
+    fromCardId: string;
+    toCardId: string;
+    field: string;
+    entryId: string;
+}) => boolean;
+/** O item pode ENTRAR na célula? (indicador durante o arrasto) */
+declare function canEnterCell(board: KanbanBoard, itemId: string, columnId: string, laneId?: string): boolean;
+/**
+ * Converte o índice VISUAL do drop (posição na lista visível, sem o item
+ * arrastado) para o índice da célula no core (ordem manual entre TODOS os
+ * itens da célula, sem o movido) — os dois divergem quando há filtro ativo.
+ */
+declare function resolveDropIndex(board: KanbanBoard, itemId: string, columnId: string, visibleIndex: number, laneId?: string): number | undefined;
+/** Executa o drop como comando do core. */
+declare function executeDrop(board: KanbanBoard, itemId: string, columnId: string, visibleIndex: number, laneId?: string): CommandResult;
+
+interface KanbanBlockActionEvent {
+    item: KanbanItem;
+    actionId: string;
+}
+/** Toggle do check de uma entry (bloco items, capability 'check'). */
+interface KanbanEntryCheckEvent {
+    cardId: string;
+    field: string;
+    entryId: string;
+    checkField: string;
+    value: boolean;
+}
+/** Ação disparada numa entry (bloco items, capability 'action'). */
+interface KanbanEntryActionEvent {
+    card: KanbanItem;
+    entry: KanbanEntry;
+    actionId: string;
+}
+/** Pedido de movimentação de entry (bloco items, capabilities 'reorder'/
+ * 'move-across'). `cardId` é a ORIGEM; `toCardId` presente = entre cards. */
+interface KanbanEntryMoveRequest {
+    cardId: string;
+    field: string;
+    entryId: string;
+    index: number;
+    toCardId?: string;
+}
+/**
+ * Renderiza a árvore de blocos DECLARATIVOS de um cartão (docs/01 §4; F5.5).
+ * Recursivo (o bloco `row` reentra no próprio componente). Estilo é CSS
+ * externo: cada bloco recebe classes-base estáveis (`mkb-block-*`,
+ * `mkb-variant-*`, `mkb-tone-*`) + as classes do host (atributo `class`).
+ */
+declare class MosKanbanCardBlocks {
+    readonly blocks: _angular_core.InputSignal<KanbanBlock[]>;
+    readonly item: _angular_core.InputSignal<KanbanItem>;
+    readonly registry: _angular_core.InputSignal<KanbanRegistry | undefined>;
+    readonly locale: _angular_core.InputSignal<string | undefined>;
+    readonly column: _angular_core.InputSignal<string | undefined>;
+    readonly lane: _angular_core.InputSignal<string | undefined>;
+    /** Ids de TODOS os cards do board — conexões do 'move-across'. */
+    readonly allCardIds: _angular_core.InputSignal<string[]>;
+    /** Preview de drop de entry entre cards (vem do board.canMoveEntry). */
+    readonly canDropEntry: _angular_core.InputSignal<CanDropEntryFn | null>;
+    readonly action: _angular_core.OutputEmitterRef<KanbanBlockActionEvent>;
+    readonly entryCheck: _angular_core.OutputEmitterRef<KanbanEntryCheckEvent>;
+    readonly entryAction: _angular_core.OutputEmitterRef<KanbanEntryActionEvent>;
+    readonly entryMove: _angular_core.OutputEmitterRef<KanbanEntryMoveRequest>;
+    /** Ciclo do gesto de arraste de entry (docs/02 §9). */
+    readonly lifecycle: _angular_core.OutputEmitterRef<KanbanDragLifecycle>;
+    private readonly sanitizer;
+    private readonly ctx;
+    protected readonly String: StringConstructor;
+    protected raw(field: string | undefined): unknown;
+    protected text(block: Extract<KanbanBlock, {
+        type: 'text';
+    }>): string;
+    protected num(block: Extract<KanbanBlock, {
+        type: 'number';
+    }>): string;
+    protected dateVal(block: Extract<KanbanBlock, {
+        type: 'date' | 'time' | 'datetime';
+    }>): string;
+    protected valueStyle(block: Extract<KanbanBlock, {
+        type: 'tag' | 'badge';
+    }>): KanbanValueStyle;
+    protected factText(fact: KanbanFact): string;
+    protected avatarName(block: Extract<KanbanBlock, {
+        type: 'avatar';
+    }>): string;
+    protected ini(name: string): string;
+    protected progressValue(block: Extract<KanbanBlock, {
+        type: 'progress';
+    }>): number;
+    protected progressPct(block: Extract<KanbanBlock, {
+        type: 'progress';
+    }>): number;
+    protected visibleActions(block: Extract<KanbanBlock, {
+        type: 'actions';
+    }>): KanbanCardAction[];
+    protected entryList(block: Extract<KanbanBlock, {
+        type: 'items';
+    }>): KanbanEntry[];
+    protected visibleEntries(block: Extract<KanbanBlock, {
+        type: 'items';
+    }>): KanbanEntry[];
+    protected hiddenCount(block: Extract<KanbanBlock, {
+        type: 'items';
+    }>): number;
+    protected hasCap(block: Extract<KanbanBlock, {
+        type: 'items';
+    }>, cap: 'check' | 'reorder' | 'move-across' | 'action'): boolean;
+    /** 'move-across' implica 'reorder'. */
+    protected reorderEnabled(block: Extract<KanbanBlock, {
+        type: 'items';
+    }>): boolean;
+    protected entriesId(block: Extract<KanbanBlock, {
+        type: 'items';
+    }>): string;
+    /** Conexões do move-across: listas do MESMO field nos outros cards. */
+    protected entryConnections(block: Extract<KanbanBlock, {
+        type: 'items';
+    }>): string[];
+    /** enterPredicate por bloco (identidade cacheada p/ o CDK). */
+    private readonly predicateCache;
+    protected entryPredicate(block: Extract<KanbanBlock, {
+        type: 'items';
+    }>): (drag: CdkDrag<string>) => boolean;
+    /** Ctrl+↑/↓ move a entry focada (índice entre as remanescentes). */
+    protected onEntryKeydown(block: Extract<KanbanBlock, {
+        type: 'items';
+    }>, entry: KanbanEntry, event: KeyboardEvent): void;
+    protected isDone(block: Extract<KanbanBlock, {
+        type: 'items';
+    }>, entry: KanbanEntry): boolean;
+    protected entryLabel(block: Extract<KanbanBlock, {
+        type: 'items';
+    }>, entry: KanbanEntry): string;
+    protected doneCount(block: Extract<KanbanBlock, {
+        type: 'items';
+    }>): number;
+    protected toggleEntry(block: Extract<KanbanBlock, {
+        type: 'items';
+    }>, entry: KanbanEntry): void;
+    protected emitEntryAction(_block: Extract<KanbanBlock, {
+        type: 'items';
+    }>, entry: KanbanEntry, actionId: string, event: Event): void;
+    /** CDK: currentIndex == posição entre as REMANESCENTES (mesma semântica do
+     * índice do comando moveEntry); cross-container → move entre cards. */
+    protected onEntryDrop(block: Extract<KanbanBlock, {
+        type: 'items';
+    }>, event: CdkDragDrop<string, string, string>): void;
+    private matchesWhen;
+    protected emitAction(action: KanbanCardAction, event: Event): void;
+    protected icon(name: string | undefined): SafeHtml | string;
+    protected customHtml(renderer: string): SafeHtml | string;
+    protected classes(block: KanbanBlock, tone?: string): string[];
+    protected rowClasses(block: Extract<KanbanBlock, {
+        type: 'row';
+    }>): string[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MosKanbanCardBlocks, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MosKanbanCardBlocks, "mos-kanban-card-blocks", never, { "blocks": { "alias": "blocks"; "required": true; "isSignal": true; }; "item": { "alias": "item"; "required": true; "isSignal": true; }; "registry": { "alias": "registry"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "column": { "alias": "column"; "required": false; "isSignal": true; }; "lane": { "alias": "lane"; "required": false; "isSignal": true; }; "allCardIds": { "alias": "allCardIds"; "required": false; "isSignal": true; }; "canDropEntry": { "alias": "canDropEntry"; "required": false; "isSignal": true; }; }, { "action": "action"; "entryCheck": "entryCheck"; "entryAction": "entryAction"; "entryMove": "entryMove"; "lifecycle": "lifecycle"; }, never, never, true, never>;
+}
+
+interface KanbanDropRejection {
+    itemId: string;
+    columnId: string;
+    laneId?: string;
+    reason: string;
+}
+/** Ativação de cartão (clique/Enter); ctrl/meta pedem toggle de seleção. */
+interface KanbanCardActivation {
+    item: KanbanItem;
+    toggle: boolean;
+}
+/** Pedido de menu contextual sobre um cartão. */
+interface KanbanCardContextRequest {
+    item: KanbanItem;
+    x: number;
+    y: number;
+}
+/** Tecla de seta sobre um cartão focado — o board decide (navegar/mover). */
+interface KanbanCardKeyEvent {
+    item: KanbanItem;
+    key: 'ArrowUp' | 'ArrowDown' | 'ArrowLeft' | 'ArrowRight';
+    /** Ctrl (ou Cmd): MOVE o cartão em vez de navegar o foco. */
+    ctrl: boolean;
+    /** Shift junto com Ctrl: move entre LANES. */
+    shift: boolean;
+}
+/**
+ * Uma CÉLULA do board (coluna × lane; sem lanes, a coluna inteira): drop list
+ * do CDK + cartões. É a unidade de drop — toda decisão de movimento é
+ * delegada ao core via drag-controller (preview == commit).
+ */
+declare class MosKanbanCell {
+    readonly board: _angular_core.InputSignal<KanbanBoard>;
+    readonly columnId: _angular_core.InputSignal<string>;
+    readonly laneId: _angular_core.InputSignal<string | undefined>;
+    readonly items: _angular_core.InputSignal<KanbanItem[]>;
+    readonly cardTemplate: _angular_core.InputSignal<TemplateRef<KanbanCardContext> | null>;
+    /** Modelo declarativo do cartão (do board.cardConfig); usado quando não há
+     * template custom. */
+    readonly cardConfig: _angular_core.InputSignal<KanbanCardConfig | null>;
+    readonly readOnly: _angular_core.InputSignal<boolean>;
+    readonly selection: _angular_core.InputSignal<readonly string[]>;
+    /** Ids das drop lists de células conectadas (fornecidos pelo board). */
+    readonly connectedTo: _angular_core.InputSignal<string[]>;
+    /** Ids de todos os cards (conexões do move-across de entries). */
+    readonly allCardIds: _angular_core.InputSignal<string[]>;
+    readonly cardActivate: _angular_core.OutputEmitterRef<KanbanCardActivation>;
+    readonly cardContext: _angular_core.OutputEmitterRef<KanbanCardContextRequest>;
+    readonly cardKey: _angular_core.OutputEmitterRef<KanbanCardKeyEvent>;
+    readonly cardAction: _angular_core.OutputEmitterRef<KanbanBlockActionEvent>;
+    readonly entryCheck: _angular_core.OutputEmitterRef<KanbanEntryCheckEvent>;
+    readonly entryAction: _angular_core.OutputEmitterRef<KanbanEntryActionEvent>;
+    readonly entryMove: _angular_core.OutputEmitterRef<KanbanEntryMoveRequest>;
+    /** Ciclo de gesto (card/entry) — o board traduz em dragStarted/Ended. */
+    readonly lifecycle: _angular_core.OutputEmitterRef<KanbanDragLifecycle>;
+    readonly dropRejected: _angular_core.OutputEmitterRef<KanbanDropRejection>;
+    /** Preview de drop de entry entre cards — MESMO caminho do commit. */
+    protected readonly canDropEntryFn: CanDropEntryFn;
+    /** Toque segura 250ms antes de iniciar o drag — o scroll da lista continua
+     * natural no touch; mouse arrasta imediatamente. */
+    protected readonly dragStartDelay: {
+        touch: number;
+        mouse: number;
+    };
+    /** Id DOM da própria drop list (conectada às demais pelo board). */
+    protected readonly cellId: _angular_core.Signal<string>;
+    protected label(): string;
+    /** O CDK pergunta se o item pode ENTRAR — a resposta vem do core. Drags de
+     * grupo (coluna/lane, data = objeto) NÃO entram em célula: só cartões
+     * (data = id string). */
+    protected readonly enterPredicate: (drag: CdkDrag<unknown>) => boolean;
+    /** Flag de cancelamento por Esc (provider do board; null fora dele). */
+    private readonly cancelFlag;
+    protected onDrop(event: CdkDragDrop<unknown, unknown, string>): void;
+    protected activate(item: KanbanItem, event: Event): void;
+    protected onKeydown(item: KanbanItem, event: KeyboardEvent): void;
+    protected onContextMenu(item: KanbanItem, event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MosKanbanCell, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MosKanbanCell, "mos-kanban-cell", never, { "board": { "alias": "board"; "required": true; "isSignal": true; }; "columnId": { "alias": "columnId"; "required": true; "isSignal": true; }; "laneId": { "alias": "laneId"; "required": false; "isSignal": true; }; "items": { "alias": "items"; "required": true; "isSignal": true; }; "cardTemplate": { "alias": "cardTemplate"; "required": false; "isSignal": true; }; "cardConfig": { "alias": "cardConfig"; "required": false; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "selection": { "alias": "selection"; "required": false; "isSignal": true; }; "connectedTo": { "alias": "connectedTo"; "required": false; "isSignal": true; }; "allCardIds": { "alias": "allCardIds"; "required": false; "isSignal": true; }; }, { "cardActivate": "cardActivate"; "cardContext": "cardContext"; "cardKey": "cardKey"; "cardAction": "cardAction"; "entryCheck": "entryCheck"; "entryAction": "entryAction"; "entryMove": "entryMove"; "lifecycle": "lifecycle"; "dropRejected": "dropRejected"; }, never, never, true, never>;
+}
+
+interface ColumnVM {
+    column: KanbanGroup;
+    items: KanbanItem[];
+}
+interface LaneVM {
+    lane: KanbanGroup;
+    cells: ColumnVM[];
+}
+/** Ação de item para o menu contextual (serializável — pode vir da config
+ * do host junto com o BoardConfig). */
+interface KanbanItemAction {
+    id: string;
+    label: string;
+    disabled?: boolean;
+}
+interface KanbanItemActionEvent {
+    item: KanbanItem;
+    actionId: string;
+}
+interface MenuState {
+    item: KanbanItem;
+    x: number;
+    y: number;
+}
+/**
+ * <mos-kanban-board> — raiz da camada visual.
+ *
+ * Recebe um KanbanBoard do core e o REFLETE: nenhuma regra vive aqui. Dois
+ * layouts: colunas (sem lanes) e grade coluna × lane (swimlanes) — nos dois,
+ * a unidade de drop é a CÉLULA. A ponte de reatividade é um signal de versão
+ * incrementado a cada `change` do board (zoneless-friendly, OnPush).
+ */
+declare class MosKanbanBoard {
+    /** Instância criada com createBoard() do core. */
+    readonly board: _angular_core.InputSignal<KanbanBoard | null>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly error: _angular_core.InputSignal<string | null>;
+    /** Caixa de pesquisa embutida (gerencia o filtro de texto do board,
+     * preservando os demais filtros do host). */
+    readonly showSearch: _angular_core.InputSignal<boolean>;
+    /** Ações do menu contextual dos cartões; vazio = sem menu. */
+    readonly itemActions: _angular_core.InputSignal<KanbanItemAction[]>;
+    readonly itemClick: _angular_core.OutputEmitterRef<KanbanItem>;
+    /** Espelha o after:move do core (qualquer origem: drag, comando, undo). */
+    readonly itemMove: _angular_core.OutputEmitterRef<MoveEventData>;
+    /** Drop recusado pelas regras — gancho para toast/feedback do host. */
+    readonly moveRejected: _angular_core.OutputEmitterRef<KanbanDropRejection>;
+    readonly itemAction: _angular_core.OutputEmitterRef<KanbanItemActionEvent>;
+    /** Ação disparada numa ENTRY (bloco items, capability 'action'). */
+    readonly entryAction: _angular_core.OutputEmitterRef<KanbanEntryActionEvent>;
+    /** Ciclo do gesto (qualquer nível): início / fim / cancelado por Esc.
+     * `dragCanceled` é emitido ADICIONALMENTE ao `dragEnded` (docs/02 §9). */
+    readonly dragStarted: _angular_core.OutputEmitterRef<KanbanDragInfo>;
+    readonly dragEnded: _angular_core.OutputEmitterRef<KanbanDragInfo>;
+    readonly dragCanceled: _angular_core.OutputEmitterRef<KanbanDragInfo>;
+    protected readonly version = "0.1.0";
+    protected readonly cardDef: _angular_core.Signal<MosKanbanCardDef | undefined>;
+    protected readonly menu: _angular_core.WritableSignal<MenuState | null>;
+    /** Mensagem do aria-live (movimentos por teclado e recusas). */
+    protected readonly announcement: _angular_core.WritableSignal<string>;
+    private readonly elementRef;
+    /** Flag de cancelamento por Esc (compartilhado com as células via DI). */
+    private readonly cancelFlag;
+    /** Incrementado a cada mudança do board — invalida os computed. */
+    private readonly revision;
+    constructor();
+    protected readonly readOnly: _angular_core.Signal<boolean>;
+    protected readonly selection: _angular_core.Signal<readonly string[]>;
+    protected readonly columnVMs: _angular_core.Signal<ColumnVM[]>;
+    /** null = sem eixo de lanes (layout de colunas). */
+    protected readonly laneVMs: _angular_core.Signal<LaneVM[] | null>;
+    /** Modelo declarativo do cartão (da config do board); null = cartão default. */
+    protected readonly cardConfig: _angular_core.Signal<_mosaicoo_kanban_core.KanbanCardConfig | null>;
+    /** Ids de todos os cards (conexões do move-across de entries). */
+    protected readonly allCardIds: _angular_core.Signal<string[]>;
+    protected readonly columnsReorderable: _angular_core.Signal<boolean>;
+    protected readonly lanesReorderable: _angular_core.Signal<boolean>;
+    protected isFull(group: KanbanGroup): boolean;
+    /** Cor de group.meta.color (cabeçalhos de coluna da grade com swimlanes). */
+    protected colColor(group: KanbanGroup): string | null;
+    /** Ids das drop lists de TODAS as células (para o connectedTo). */
+    private readonly cellIds;
+    /** Conexões de uma célula = todas as demais células (nunca listas de grupo). */
+    protected connectedFor(columnId: string, laneId?: string): string[];
+    protected onColumnDrop(event: CdkDragDrop<unknown>): void;
+    protected onLaneDrop(event: CdkDragDrop<unknown>): void;
+    /** Linhas-fantasma do preview de fatia de coluna (grade de swimlanes). */
+    protected ghostRows(count: number): unknown[];
+    /** Traduz o ciclo dos cdkDrag* nos outputs públicos e memoriza o gesto
+     * ativo (para o dragCanceled do Esc). */
+    private lastDrag;
+    protected onLifecycle(ev: KanbanDragLifecycle): void;
+    /** Check de entry (bloco items): vira comando updateEntry no core. */
+    protected onEntryCheck(ev: KanbanEntryCheckEvent): void;
+    /** Movimentação de entry (bloco items): vira comando moveEntry no core —
+     * dentro do card ou entre cards (move-across). */
+    protected onEntryMove(ev: KanbanEntryMoveRequest): void;
+    /** Esc durante um drag: arma o flag e encerra o gesto com mouseup sintético
+     * — o drop dispara, os handlers consomem o flag e nenhum comando executa. */
+    protected onEscape(): void;
+    /** Ctrl+←/→ na coluna (layout de colunas, via componente). */
+    protected onColumnReorderKey(id: string, dir: 'left' | 'right'): void;
+    protected onColumnHeaderKeydown(id: string, event: KeyboardEvent): void;
+    protected onLaneHeaderKeydown(id: string, event: KeyboardEvent): void;
+    private nudgeGroup;
+    private moveGroup;
+    private focusHeaderSoon;
+    protected onActivate({ item, toggle }: KanbanCardActivation): void;
+    protected onCardContext(request: KanbanCardContextRequest): void;
+    protected invoke(item: KanbanItem, actionId: string): void;
+    protected closeMenu(): void;
+    /** Setas navegam o foco entre cartões; Ctrl+setas MOVEM o cartão
+     * (Ctrl+Shift+↑/↓ move entre lanes). Mesmo caminho de comando do mouse. */
+    protected onCardKey(ev: KanbanCardKeyEvent): void;
+    protected onDropRejected(rejection: KanbanDropRejection): void;
+    /** Localiza o cartão nas VMs atuais (índices de coluna/lane + posição
+     * visível na célula). */
+    private locate;
+    private cellItems;
+    private focusByKey;
+    private moveByKey;
+    private getTitle;
+    private announce;
+    private focusCard;
+    /** Após um movimento o DOM re-renderiza — refoca no próximo tick. */
+    private focusCardSoon;
+    protected onSearch(text: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MosKanbanBoard, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MosKanbanBoard, "mos-kanban-board", never, { "board": { "alias": "board"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "showSearch": { "alias": "showSearch"; "required": false; "isSignal": true; }; "itemActions": { "alias": "itemActions"; "required": false; "isSignal": true; }; }, { "itemClick": "itemClick"; "itemMove": "itemMove"; "moveRejected": "moveRejected"; "itemAction": "itemAction"; "entryAction": "entryAction"; "dragStarted": "dragStarted"; "dragEnded": "dragEnded"; "dragCanceled": "dragCanceled"; }, ["cardDef"], never, true, never>;
+}
+
+/** Cartão DEFAULT (usado quando o consumidor não projeta um template
+ * mosKanbanCard): título + id discreto. Visual 100% por tokens. */
+declare class MosKanbanCard {
+    readonly item: _angular_core.InputSignal<KanbanItem>;
+    protected title(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MosKanbanCard, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MosKanbanCard, "mos-kanban-card", never, { "item": { "alias": "item"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** Contexto de formatação: locale do host + registry (formatadores custom). */
+interface FormatContext {
+    locale?: string;
+    registry?: KanbanRegistry;
+}
+type CustomFormatter = (value: unknown, item: KanbanItem) => string;
+/** Texto simples com prefixo/sufixo; `format` (registry) tem precedência. */
+declare function formatText(value: unknown, opts: {
+    prefix?: string;
+    suffix?: string;
+    format?: string;
+}, item: KanbanItem, ctx: FormatContext): string;
+declare function formatNumber(value: unknown, opts: {
+    style?: 'decimal' | 'currency' | 'percent';
+    currency?: string;
+    decimals?: number;
+    prefix?: string;
+    suffix?: string;
+}, ctx: FormatContext): string;
+declare function formatDate(value: unknown, opts: {
+    dateStyle?: 'short' | 'medium' | 'long' | 'full';
+    timeStyle?: 'short' | 'medium';
+    relative?: boolean;
+    withTime?: boolean;
+    withDate?: boolean;
+}, ctx: FormatContext): string;
+/** "há 4 horas" / "em 2 dias" via Intl.RelativeTimeFormat, maior unidade. */
+declare function formatRelative(date: Date, locale?: string): string;
+/**
+ * Resolve um ícone pelo nome no registry (`icon:<nome>`, valor registrado pelo
+ * host). Retorna { markup } quando o valor é SVG/HTML (host-confiável → seguro
+ * dar bypass) ou { text } para emoji/rótulo curto. Nome não registrado cai no
+ * próprio nome como texto (fallback visível, não quebra o layout).
+ */
+declare function resolveIcon(name: string | undefined, registry?: KanbanRegistry): {
+    markup?: string;
+    text?: string;
+};
+/** Iniciais para o avatar sem foto (ex.: "Ana Paula" → "AP"). */
+declare function initials(name: unknown): string;
+
+/** Uma coluna do board SEM lanes: cabeçalho (título/contagem/WIP) + uma única
+ * célula ocupando a coluna inteira. Com lanes, o board monta a grade de
+ * células diretamente. */
+declare class MosKanbanColumn {
+    readonly board: _angular_core.InputSignal<KanbanBoard>;
+    readonly column: _angular_core.InputSignal<KanbanGroup>;
+    readonly items: _angular_core.InputSignal<KanbanItem[]>;
+    readonly cardTemplate: _angular_core.InputSignal<TemplateRef<KanbanCardContext> | null>;
+    readonly cardConfig: _angular_core.InputSignal<KanbanCardConfig | null>;
+    readonly readOnly: _angular_core.InputSignal<boolean>;
+    readonly reorderable: _angular_core.InputSignal<boolean>;
+    readonly selection: _angular_core.InputSignal<readonly string[]>;
+    /** Ids das drop lists de células conectadas (repasse para a célula). */
+    readonly connectedTo: _angular_core.InputSignal<string[]>;
+    readonly allCardIds: _angular_core.InputSignal<string[]>;
+    readonly cardActivate: _angular_core.OutputEmitterRef<KanbanCardActivation>;
+    readonly cardContext: _angular_core.OutputEmitterRef<KanbanCardContextRequest>;
+    readonly cardKey: _angular_core.OutputEmitterRef<KanbanCardKeyEvent>;
+    readonly cardAction: _angular_core.OutputEmitterRef<KanbanBlockActionEvent>;
+    readonly entryCheck: _angular_core.OutputEmitterRef<KanbanEntryCheckEvent>;
+    readonly entryAction: _angular_core.OutputEmitterRef<KanbanEntryActionEvent>;
+    readonly entryMove: _angular_core.OutputEmitterRef<KanbanEntryMoveRequest>;
+    readonly lifecycle: _angular_core.OutputEmitterRef<KanbanDragLifecycle>;
+    readonly dropRejected: _angular_core.OutputEmitterRef<KanbanDropRejection>;
+    /** Ctrl+←/→ no cabeçalho: pedido de reordenação (o board executa). */
+    readonly reorderKey: _angular_core.OutputEmitterRef<"left" | "right">;
+    protected readonly isFull: _angular_core.Signal<boolean>;
+    /** Cor do cabeçalho vinda de group.meta.color (a lib não interpreta meta
+     * além disto). */
+    protected readonly color: _angular_core.Signal<string | null>;
+    protected onHeaderKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MosKanbanColumn, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MosKanbanColumn, "mos-kanban-column", never, { "board": { "alias": "board"; "required": true; "isSignal": true; }; "column": { "alias": "column"; "required": true; "isSignal": true; }; "items": { "alias": "items"; "required": true; "isSignal": true; }; "cardTemplate": { "alias": "cardTemplate"; "required": false; "isSignal": true; }; "cardConfig": { "alias": "cardConfig"; "required": false; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "reorderable": { "alias": "reorderable"; "required": false; "isSignal": true; }; "selection": { "alias": "selection"; "required": false; "isSignal": true; }; "connectedTo": { "alias": "connectedTo"; "required": false; "isSignal": true; }; "allCardIds": { "alias": "allCardIds"; "required": false; "isSignal": true; }; }, { "cardActivate": "cardActivate"; "cardContext": "cardContext"; "cardKey": "cardKey"; "cardAction": "cardAction"; "entryCheck": "entryCheck"; "entryAction": "entryAction"; "entryMove": "entryMove"; "lifecycle": "lifecycle"; "dropRejected": "dropRejected"; "reorderKey": "reorderKey"; }, never, ["[mkbColHandle]"], true, never>;
+}
+
+export { DragCancelFlag, MosKanbanBoard, MosKanbanCard, MosKanbanCardBlocks, MosKanbanCardDef, MosKanbanCell, MosKanbanColumn, canEnterCell, cellListId, entriesListId, executeDrop, formatDate, formatNumber, formatRelative, formatText, initials, resolveDropIndex, resolveIcon };
+export type { CanDropEntryFn, CustomFormatter, FormatContext, KanbanBlockActionEvent, KanbanCardActivation, KanbanCardContext, KanbanCardContextRequest, KanbanCardKeyEvent, KanbanDragInfo, KanbanDragLifecycle, KanbanDropRejection, KanbanEntryActionEvent, KanbanEntryCheckEvent, KanbanEntryMoveRequest, KanbanItemAction, KanbanItemActionEvent };

package/types/mosaicoo-kanban.d.ts

@@ -0,0 +1,2 @@
+export * from '@mosaicoo/kanban/core';
+export * from '@mosaicoo/kanban/ui';