ezux 1.0.0

package/dist/components/EzKanban/components/CardEditorModal.d.ts

@@ -0,0 +1,23 @@
+import { default as React } from 'react';
+import { KanbanCard, KanbanColumn } from '../EzKanban.types';
+export interface CardEditorModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    onSave: (card: Partial<KanbanCard>) => void;
+    onDelete?: (cardId: string) => void;
+    card?: Partial<KanbanCard>;
+    columns?: KanbanColumn[];
+    columnId?: string;
+    customFields?: {
+        id: string;
+        name: string;
+        type: 'text' | 'number' | 'date' | 'select' | 'checkbox';
+        options?: string[];
+    }[];
+    currentUser?: {
+        id: string;
+        name: string;
+        avatar?: string;
+    };
+}
+export declare const CardEditorModal: React.FC<CardEditorModalProps>;

package/dist/components/EzKanban/components/EzKanbanErrorFallback.d.ts

@@ -0,0 +1 @@
+export declare const EzKanbanErrorFallback: () => import("react/jsx-runtime").JSX.Element;

package/dist/components/EzKanban/components/FilterPopover.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+import { KanbanBoard, FilterConfig } from '../EzKanban.types';
+interface FilterPopoverProps {
+    board: KanbanBoard;
+    activeFilters: FilterConfig;
+    onFiltersChange: (filters: FilterConfig) => void;
+    onClearFilters: () => void;
+}
+export declare const FilterPopover: React.FC<FilterPopoverProps>;
+export {};

package/dist/components/EzKanban/components/KanbanBoard.d.ts

@@ -0,0 +1,62 @@
+import { default as React } from 'react';
+import { KanbanBoard, KanbanCard } from '../EzKanban.types';
+/**
+ * Props for the KanbanBoard component.
+ * @group Properties
+ */
+export interface KanbanBoardProps {
+    /** The board data object. @group Data */
+    board: KanbanBoard;
+    /** Callback when a card is clicked. @group Events */
+    onCardClick?: (card: KanbanCard) => void;
+    /** Callback when a card is double-clicked. @group Events */
+    onCardDoubleClick?: (card: KanbanCard) => void;
+    /** Callback when card drag starts. @group Events */
+    onCardDragStart?: (card: KanbanCard) => void;
+    /** Callback when card drag ends. @group Events */
+    onCardDragEnd?: () => void;
+    /** Callback when a card is dropped into a column/swimlane. @group Events */
+    onCardDrop?: (columnId: string, swimlaneId?: string) => void;
+    /** Callback to add a new card to a specific location. @group Events */
+    onAddCard?: (columnId: string, swimlaneId?: string) => void;
+    /** Callback to toggle column collapse state. @group Events */
+    onToggleColumnCollapse?: (columnId: string) => void;
+    /** Callback to toggle swimlane collapse state. @group Events */
+    onToggleSwimlaneCollapse?: (swimlaneId: string) => void;
+    /** Callback to add a new column. @group Events */
+    onAddColumn?: () => void;
+    /** Callback to delete a column. @group Events */
+    onDeleteColumn?: (columnId: string) => void;
+    /** Callback to update column settings. @group Events */
+    onUpdateColumn?: (columnId: string, updates: any) => void;
+    /** Callback when a column header is clicked. @group Events */
+    onColumnClick?: (columnId: string) => void;
+    /** Callback to create a new card from a draft. @group Events */
+    onCreateCard?: (card: Partial<KanbanCard>) => Promise<void> | void;
+    /** ID of the currently selected column. @group State */
+    selectedColumnId?: string | null;
+    /** ID of the card currently being dragged. @group State */
+    draggedCardId?: string | null;
+    /** ID of the card currently highlighted. @group State */
+    highlightedCardId?: string | null;
+    /** Optional list of filtered cards to display instead of all board cards. @group Data */
+    filteredCards?: KanbanCard[];
+    /** Custom renderers for board elements. @group Extensibility */
+    customRenderers?: {
+        card?: (card: KanbanCard, defaultContent: React.JSX.Element) => React.JSX.Element;
+        cardContent?: (card: KanbanCard) => React.JSX.Element;
+        column?: (column: any) => React.JSX.Element;
+    };
+    /** Custom class name for the board container. @group Appearance */
+    className?: string;
+    /** Current view mode of the board. @group State */
+    /** Current view mode of the board. @group State */
+    view?: 'standard' | 'swimlane' | 'timeline' | 'analytics';
+    /** Text direction. @group Appearance */
+    dir?: 'ltr' | 'rtl' | 'auto';
+}
+/**
+ * Renders the main Kanban board surface, supporting standard, swimlane, and timeline views.
+ * @group Components
+ */
+export declare const KanbanBoardComponent: React.FC<KanbanBoardProps>;

package/dist/components/EzKanban/components/KanbanCard.d.ts

@@ -0,0 +1,38 @@
+import { default as React } from 'react';
+import { KanbanCard as KanbanCardType, CustomFieldDefinition } from '../EzKanban.types';
+/**
+ * Props for the KanbanCard component.
+ * @group Properties
+ */
+export interface KanbanCardProps {
+    /** The card data object. @group Data */
+    card: KanbanCardType;
+    /** Callback when the card is clicked. @group Events */
+    onClick?: (card: KanbanCardType) => void;
+    /** Callback when the card is double-clicked. @group Events */
+    onDoubleClick?: (card: KanbanCardType) => void;
+    /** Callback when card drag starts. @group Events */
+    onDragStart?: (card: KanbanCardType) => void;
+    /** Callback when card drag ends. @group Events */
+    onDragEnd?: () => void;
+    /** Whether the card is currently being dragged. @group State */
+    isDragging?: boolean;
+    /** Whether the card is currently highlighted. @group State */
+    isHighlighted?: boolean;
+    /** Whether to enable tooltips for the card. @group Appearance */
+    enableTooltip?: boolean;
+    /** Custom template for the card tooltip. @group Extensibility */
+    tooltipTemplate?: (data: KanbanCardType) => React.ReactNode;
+    /** Custom field definitions for rendering values. @group Data */
+    customFields?: CustomFieldDefinition[];
+    /** Custom renderers for card elements. @group Extensibility */
+    customRenderers?: {
+        card?: (card: KanbanCardType, defaultContent: React.JSX.Element) => React.JSX.Element;
+        cardContent?: (card: KanbanCardType) => React.JSX.Element;
+    };
+    /** Custom class name for the card container. @group Appearance */
+    className?: string;
+    /** Text direction. @group Appearance */
+    dir?: 'ltr' | 'rtl' | 'auto';
+}
+export declare const KanbanCard: React.NamedExoticComponent<KanbanCardProps>;

package/dist/components/EzKanban/components/KanbanColumn.d.ts

@@ -0,0 +1,55 @@
+import { default as React } from 'react';
+import { KanbanColumn as KanbanColumnType, KanbanCard, CustomFieldDefinition } from '../EzKanban.types';
+/**
+ * Props for the KanbanColumn component.
+ * @group Properties
+ */
+export interface KanbanColumnProps {
+    /** The column definition object. @group Data */
+    column: KanbanColumnType;
+    /** List of cards in this column. @group Data */
+    cards: KanbanCard[];
+    /** Callback when a card is clicked. @group Events */
+    onCardClick?: (card: KanbanCard) => void;
+    /** Callback when a card is double-clicked. @group Events */
+    onCardDoubleClick?: (card: KanbanCard) => void;
+    /** Callback when card drag starts. @group Events */
+    onCardDragStart?: (card: KanbanCard) => void;
+    /** Callback when card drag ends. @group Events */
+    onCardDragEnd?: () => void;
+    /** Callback when a card is dropped into this column. @group Events */
+    onDrop?: (columnId: string) => void;
+    /** Callback to add a new card to this column. @group Events */
+    onAddCard?: (columnId: string) => void;
+    /** Callback to toggle column collapse state. @group Events */
+    onToggleCollapse?: (columnId: string) => void;
+    /** Callback to delete this column. @group Events */
+    onDeleteColumn?: (columnId: string) => void;
+    /** Callback to update column settings. @group Events */
+    onUpdateColumn?: (columnId: string, updates: Partial<KanbanColumnType>) => void;
+    /** Callback when the column is clicked. @group Events */
+    onColumnClick?: (columnId: string) => void;
+    /** ID of the currently selected column. @group State */
+    selectedColumnId?: string | null;
+    /** ID of the card currently being dragged. @group State */
+    draggedCardId?: string | null;
+    /** ID of the card currently highlighted. @group State */
+    highlightedCardId?: string | null;
+    /** Custom field definitions for card rendering. @group Data */
+    customFields?: CustomFieldDefinition[];
+    /** Custom renderers for column elements. @group Extensibility */
+    customRenderers?: {
+        card?: (card: KanbanCard, defaultContent: React.JSX.Element) => React.JSX.Element;
+        cardContent?: (card: KanbanCard) => React.JSX.Element;
+        column?: (column: KanbanColumnType) => React.JSX.Element;
+    };
+    /** Custom class name for the column container. @group Appearance */
+    className?: string;
+    /** Text direction. @group Appearance */
+    dir?: 'ltr' | 'rtl' | 'auto';
+}
+/**
+ * Renders a single Kanban column containing a list of cards.
+ * @group Components
+ */
+export declare const KanbanColumn: React.FC<KanbanColumnProps>;

package/dist/components/EzKanban/components/KanbanSwimlane.d.ts

@@ -0,0 +1,46 @@
+import { default as React } from 'react';
+import { KanbanSwimlane as KanbanSwimlaneType, KanbanColumn, KanbanCard, CustomFieldDefinition } from '../EzKanban.types';
+/**
+ * Props for the KanbanSwimlane component.
+ * @group Properties
+ */
+export interface KanbanSwimlaneProps {
+    /** The swimlane definition object. @group Data */
+    swimlane: KanbanSwimlaneType;
+    /** List of columns to display within the swimlane. @group Data */
+    columns: KanbanColumn[];
+    /** List of cards belonging to this swimlane. @group Data */
+    cards: KanbanCard[];
+    /** Callback when a card is clicked. @group Events */
+    onCardClick?: (card: KanbanCard) => void;
+    /** Callback when a card is double-clicked. @group Events */
+    onCardDoubleClick?: (card: KanbanCard) => void;
+    /** Callback when card drag starts. @group Events */
+    onCardDragStart?: (card: KanbanCard) => void;
+    /** Callback when card drag ends. @group Events */
+    onCardDragEnd?: () => void;
+    /** Callback when a card is dropped into a cell. @group Events */
+    onDrop?: (columnId: string, swimlaneId: string) => void;
+    /** Callback to toggle swimlane collapse state. @group Events */
+    onToggleCollapse?: (swimlaneId: string) => void;
+    /** ID of the card currently being dragged. @group State */
+    draggedCardId?: string | null;
+    /** ID of the card currently highlighted. @group State */
+    highlightedCardId?: string | null;
+    /** Custom field definitions for card rendering. @group Data */
+    customFields?: CustomFieldDefinition[];
+    /** Custom renderers for elements within the swimlane. @group Extensibility */
+    customRenderers?: {
+        card?: (card: KanbanCard, defaultContent: React.JSX.Element) => React.JSX.Element;
+        cardContent?: (card: KanbanCard) => React.JSX.Element;
+    };
+    /** Custom class name for the swimlane container. @group Appearance */
+    className?: string;
+    /** Text direction. @group Appearance */
+    dir?: 'ltr' | 'rtl' | 'auto';
+}
+/**
+ * Renders a swimlane grouping, displaying a horizontal row of columns for cards.
+ * @group Components
+ */
+export declare const KanbanSwimlane: React.FC<KanbanSwimlaneProps>;

package/dist/components/EzKanban/components/KanbanToolbar.d.ts

@@ -0,0 +1,41 @@
+import { default as React } from 'react';
+import { FilterConfig, KanbanBoard } from '../EzKanban.types';
+/**
+ * Props for the KanbanToolbar component.
+ * @group Properties
+ */
+export interface KanbanToolbarProps {
+    /** The current search query string. @group State */
+    searchQuery: string;
+    /** Callback when the search query changes. @group Events */
+    onSearchChange: (query: string) => void;
+    /** Callback to open the card creation dialog. @group Events */
+    onAddCardClick?: () => void;
+    /** Callback to add a new column. @group Events */
+    onAddColumn?: () => void;
+    /** The current active filter configuration. @group State */
+    activeFilters?: FilterConfig;
+    /** Callback when filters are modified. @group Events */
+    onFiltersChange?: (filters: FilterConfig) => void;
+    /** The current board data (for exports). @group Data */
+    board?: KanbanBoard;
+    /** Custom class name for the toolbar. @group Appearance */
+    className?: string;
+    /** Current view mode selected in the toolbar. @group State */
+    view?: 'standard' | 'swimlane' | 'timeline';
+    /** Callback when the view mode is changed. @group Events */
+    onViewChange?: (view: 'standard' | 'swimlane' | 'timeline') => void;
+    /** Callback to undo the last action. @group Events */
+    onUndo?: () => void;
+    /** Callback to redo the previously undone action. @group Events */
+    onRedo?: () => void;
+    /** Whether undo is currently possible. @group State */
+    canUndo?: boolean;
+    /** Whether redo is currently possible. @group State */
+    canRedo?: boolean;
+}
+/**
+ * Renders the toolbar for the Kanban board, providing search, filtering, view switching, and history controls.
+ * @group Components
+ */
+export declare const KanbanToolbar: React.FC<KanbanToolbarProps>;

package/dist/components/EzKanban/exports.d.ts

@@ -0,0 +1,4 @@
+export * from './EzKanban.types';
+export { default as EzKanban } from './index';
+export { useEzKanban } from './useEzKanban';
+export { KanbanService } from './services/KanbanService';

package/dist/components/EzKanban/hooks/useKanbanCards.d.ts

@@ -0,0 +1,36 @@
+import { EzKanbanProps, KanbanBoard, KanbanCard } from '../EzKanban.types';
+/**
+ * Hook for managing Kanban card operations with optimistic updates.
+ *
+ * Supports CRUD, movements across columns, duplication, archiving, and restoration.
+ * Integrates with KanbanService or component-level event handlers.
+ *
+ * @param props Props for the EzKanban component.
+ * @param board The current board state.
+ * @group Hooks
+ */
+export declare const useKanbanCards: (props: EzKanbanProps, board: KanbanBoard) => {
+    /** Create a new card. @group Methods */
+    createCard: (draft: Partial<KanbanCard>) => Promise<KanbanCard>;
+    /** Update an existing card. @group Methods */
+    updateCard: (cardId: string, updates: Partial<KanbanCard>) => Promise<{
+        cardId: string;
+        updates: Partial<KanbanCard>;
+    }>;
+    /** Delete a card by ID. @group Methods */
+    deleteCard: (cardId: string) => Promise<string>;
+    /** Move a card to a new column/swimlane. @group Methods */
+    moveCard: (cardId: string, targetColumnId: string, targetSwimlaneId?: string, targetPosition?: number) => Promise<void>;
+    /** Duplicate an existing card. @group Methods */
+    duplicateCard: (cardId: string) => Promise<KanbanCard>;
+    /** Archive a card. @group Methods */
+    archiveCard: (cardId: string) => Promise<{
+        cardId: string;
+        updates: Partial<KanbanCard>;
+    }>;
+    /** Restore an archived card. @group Methods */
+    restoreCard: (cardId: string) => Promise<{
+        cardId: string;
+        updates: Partial<KanbanCard>;
+    }>;
+};

package/dist/components/EzKanban/hooks/useKanbanColumns.d.ts

@@ -0,0 +1,27 @@
+import { EzKanbanProps, KanbanBoard, KanbanColumn } from '../EzKanban.types';
+/**
+ * Hook for managing Kanban column operations with optimistic updates.
+ *
+ * Supports CRUD, reordering, and collapse/expand functionality.
+ *
+ * @param props Props for the EzKanban component.
+ * @param board The current board state.
+ * @group Hooks
+ */
+export declare const useKanbanColumns: (props: EzKanbanProps, board: KanbanBoard) => {
+    /** Create a new column. @group Methods */
+    createColumn: (draft: Partial<KanbanColumn>) => Promise<KanbanColumn>;
+    /** Update an existing column. @group Methods */
+    updateColumn: (columnId: string, updates: Partial<KanbanColumn>) => Promise<{
+        columnId: string;
+        updates: Partial<KanbanColumn>;
+    }>;
+    /** Delete a column by ID. @group Methods */
+    deleteColumn: (columnId: string) => Promise<string>;
+    /** Reorder columns by providing new ordered IDs. @group Methods */
+    reorderColumns: (columnIds: string[]) => Promise<string[]>;
+    /** Collapse a column. @group Methods */
+    collapseColumn: (columnId: string) => void;
+    /** Expand a column. @group Methods */
+    expandColumn: (columnId: string) => void;
+};

package/dist/components/EzKanban/hooks/useKanbanDragDrop.d.ts

@@ -0,0 +1,31 @@
+import { KanbanBoard, KanbanCard, EzKanbanProps } from '../EzKanban.types';
+type DragEvents = Pick<EzKanbanProps, 'onCardDragStart' | 'onCardDragStop' | 'onCardDragEnter' | 'onCardDragLeave'>;
+/**
+ * Hook for managing Kanban drag-and-drop state and logic.
+ *
+ * Tracks the dragged card, columns/swimlanes being dragged over,
+ * and handles WIP limit checks and event propagation.
+ *
+ * @param board The current board state.
+ * @param onCardMove Callback to commit a card move.
+ * @param wipStrict Whether to enforce hard WIP limits.
+ * @param events Optional drag-and-drop events from props.
+ * @group Hooks
+ */
+export declare const useKanbanDragDrop: (board: KanbanBoard, onCardMove: (cardId: string, targetColumnId: string, targetSwimlaneId?: string) => void, wipStrict?: boolean, events?: DragEvents) => {
+    /** The card currently being dragged. @group State */
+    draggedCard: KanbanCard | null;
+    /** ID of the column being dragged over. @group State */
+    dragOverColumn: string | null;
+    /** ID of the swimlane being dragged over. @group State */
+    dragOverSwimlane: string | null;
+    /** Handler for drag start. @group Events */
+    handleDragStart: (card: KanbanCard) => void;
+    /** Handler for drag over. @group Events */
+    handleDragOver: (columnId: string, swimlaneId?: string) => void;
+    /** Handler for drag end (cancel/finish). @group Events */
+    handleDragEnd: () => void;
+    /** Handler for drop (commit move). @group Events */
+    handleDrop: (targetColumnId: string, targetSwimlaneId?: string) => void;
+};
+export {};

package/dist/components/EzKanban/hooks/useKanbanFilters.d.ts

@@ -0,0 +1,23 @@
+import { KanbanBoard, FilterConfig } from '../EzKanban.types';
+/**
+ * Hook for managing Kanban board filtering and search logic.
+ *
+ * Computes the filtered list of cards based on search query and active filter config.
+ *
+ * @param board The current board state.
+ * @group Hooks
+ */
+export declare const useKanbanFilters: (board: KanbanBoard) => {
+    /** List of cards after applying search and filters. @group State */
+    filteredCards: import('../EzKanban.types').KanbanCard[];
+    /** Current search query string. @group State */
+    searchQuery: string;
+    /** Handler to update the search query. @group Methods */
+    setSearchQuery: import('react').Dispatch<import('react').SetStateAction<string>>;
+    /** Current active filter configuration. @group State */
+    activeFilters: FilterConfig;
+    /** Handler to update active filters. @group Methods */
+    setActiveFilters: import('react').Dispatch<import('react').SetStateAction<FilterConfig>>;
+    /** Clear all active filters and search query. @group Methods */
+    clearFilters: () => void;
+};

package/dist/components/EzKanban/hooks/useKanbanState.d.ts

@@ -0,0 +1,79 @@
+import { EzKanbanProps } from '../EzKanban.types';
+/**
+ * Hook for managing Kanban board state using a centralized store.
+ *
+ * Handles board data, selection, view modes, and history (undo/redo).
+ *
+ * @param props Props for the EzKanban component.
+ * @group Hooks
+ */
+export declare const useKanbanState: (props: EzKanbanProps) => {
+    /** The current board data. @group State */
+    board: import('../EzKanban.types').KanbanBoard;
+    /** Currently selected card IDs. @group State */
+    selectedCards: string[];
+    /** ID of the currently selected column. @group State */
+    selectedColumnId: string | null;
+    /** Current view mode. @group State */
+    view: "standard" | "timeline" | "swimlane";
+    /** Current search query. @group State */
+    searchQuery: string;
+    /** Currently active filters. @group State */
+    activeFilters: import('../EzKanban.types').FilterConfig;
+    /** Replace the board data. @group Methods */
+    setBoard: (board: import('../EzKanban.types').KanbanBoard) => void;
+    /** Set selected card IDs. @group Methods */
+    setSelectedCards: (cardIds: string[]) => void;
+    /** Set the selected column ID. @group Methods */
+    setSelectedColumnId: (columnId: string | null) => void;
+    /** Change the view mode. @group Methods */
+    setView: (view: "standard" | "swimlane" | "timeline") => void;
+    /** Set the search query. @group Methods */
+    setSearchQuery: (query: string) => void;
+    /** Set active filters. @group Methods */
+    setActiveFilters: (filters: import('../EzKanban.types').FilterConfig) => void;
+    /** Add a card. @group Methods */
+    addCard: (card: import('../EzKanban.types').KanbanCard) => void;
+    /** Update a card. @group Methods */
+    updateCard: (cardId: string, updates: Partial<import('../EzKanban.types').KanbanCard>) => void;
+    /** Delete a card. @group Methods */
+    deleteCard: (cardId: string) => void;
+    /** Move a card. @group Methods */
+    moveCard: (cardId: string, targetColumnId: string) => void;
+    /** Add a column. @group Methods */
+    addColumn: (column: import('../EzKanban.types').KanbanColumn) => void;
+    /** Update a column. @group Methods */
+    updateColumn: (columnId: string, updates: Partial<import('../EzKanban.types').KanbanColumn>) => void;
+    /** Delete a column. @group Methods */
+    deleteColumn: (columnId: string) => void;
+    /** Undo the last action. @group Methods */
+    undo: () => void;
+    /** Redo the previously undone action. @group Methods */
+    redo: () => void;
+    /** Whether undo is available. @group State */
+    canUndo: boolean;
+    /** Whether redo is available. @group State */
+    canRedo: boolean;
+    /** The underlying store instance. @group Internal */
+    store: import('@tanstack/store').Store<import('../state/kanban.store').KanbanState, (cb: import('../state/kanban.store').KanbanState) => import('../state/kanban.store').KanbanState>;
+    /** The compiled actions for the store. @group Internal */
+    actions: {
+        setBoard: (board: import('../EzKanban.types').KanbanBoard) => void;
+        addCard: (card: import('../EzKanban.types').KanbanCard) => void;
+        updateCard: (cardId: string, updates: Partial<import('../EzKanban.types').KanbanCard>) => void;
+        deleteCard: (cardId: string) => void;
+        moveCard: (cardId: string, targetColumnId: string) => void;
+        addColumn: (column: import('../EzKanban.types').KanbanColumn) => void;
+        updateColumn: (columnId: string, updates: Partial<import('../EzKanban.types').KanbanColumn>) => void;
+        deleteColumn: (columnId: string) => void;
+        setSelectedCards: (cardIds: string[]) => void;
+        setSelectedColumnId: (columnId: string | null) => void;
+        setView: (view: "standard" | "swimlane" | "timeline") => void;
+        setSearchQuery: (query: string) => void;
+        setActiveFilters: (filters: import('../EzKanban.types').FilterConfig) => void;
+        undo: () => void;
+        redo: () => void;
+        canUndo: () => boolean;
+        canRedo: () => boolean;
+    };
+};

package/dist/components/EzKanban/hooks/useKanbanSwimlanes.d.ts

@@ -0,0 +1,27 @@
+import { EzKanbanProps, KanbanBoard, KanbanSwimlane } from '../EzKanban.types';
+/**
+ * Hook for managing Kanban swimlane operations with optimistic updates.
+ *
+ * Supports CRUD, reordering, and collapse/expand functionality.
+ *
+ * @param props Props for the EzKanban component.
+ * @param board The current board state.
+ * @group Hooks
+ */
+export declare const useKanbanSwimlanes: (props: EzKanbanProps, board: KanbanBoard) => {
+    /** Create a new swimlane. @group Methods */
+    createSwimlane: (draft: Partial<KanbanSwimlane>) => Promise<KanbanSwimlane>;
+    /** Update an existing swimlane. @group Methods */
+    updateSwimlane: (swimlaneId: string, updates: Partial<KanbanSwimlane>) => Promise<{
+        swimlaneId: string;
+        updates: Partial<KanbanSwimlane>;
+    }>;
+    /** Delete a swimlane by ID. @group Methods */
+    deleteSwimlane: (swimlaneId: string) => Promise<string>;
+    /** Reorder swimlanes by providing new ordered IDs. @group Methods */
+    reorderSwimlanes: (swimlaneIds: string[]) => Promise<string[]>;
+    /** Collapse a swimlane. @group Methods */
+    collapseSwimlane: (swimlaneId: string) => void;
+    /** Expand a swimlane. @group Methods */
+    expandSwimlane: (swimlaneId: string) => void;
+};

package/dist/components/EzKanban/hooks/useKanbanVirtualization.d.ts

@@ -0,0 +1,16 @@
+import { KanbanCard } from '../EzKanban.types';
+export interface UseKanbanVirtualizationProps {
+    cards: KanbanCard[];
+    estimateSize?: number;
+    overscan?: number;
+}
+/**
+ * Hook for virtualizing Kanban cards in a column
+ * Enables smooth scrolling with 10,000+ cards
+ */
+export declare const useKanbanVirtualization: ({ cards, estimateSize, overscan, }: UseKanbanVirtualizationProps) => {
+    parentRef: import('react').RefObject<HTMLDivElement | null>;
+    virtualizer: import('@tanstack/virtual-core').Virtualizer<HTMLDivElement, Element>;
+    virtualItems: import('@tanstack/virtual-core').VirtualItem[];
+    totalSize: number;
+};

package/dist/components/EzKanban/index.d.ts

@@ -0,0 +1,45 @@
+import { EzKanbanProps, EzKanbanRef, KanbanCard } from './EzKanban.types';
+export * from './components/KanbanSwimlane';
+export * from './views/KanbanTimelineView';
+/**
+ * EzKanban is a powerful, flexible board management system designed for
+ * agile workflows and task visualization. It features a robust drag-and-drop
+ * engine and supports multiple viewing modes.
+ *
+
+ * ### Key Features
+ * - **Modular Architecture**: Built on `@dnd-kit` for performant and accessible drag-and-drop.
+ * - **Multi-View Engine**: Switch between `standard` (basic columns), `swimlane` (grouped by team/priority), and `timeline` views.
+ * - **Dynamic Columns**: Support for collapsible columns, WIP limits, and custom header rendering.
+ * - **Enterprise Editing**: Integrated card editor modal with support for custom field extensions.
+ * - **Change Tracking**: Built-in undo/redo stack for all board operations.
+ * - **Extensibility**: Inversion of Control (IoC) via custom renderers for cards, headers, and editors.
+ *
+ * ### Minimal Example
+ * ```tsx
+ * import { EzKanban } from 'ezux';
+ *
+ * function TaskBoard() {
+ *   return (
+ *     <EzKanban
+ *       board={initialBoardData}
+ *       onBoardChange={(newBoard) => saveBoard(newBoard)}
+ *     />
+ *   );
+ * }
+ * ```
+ *
+ * ### Advanced Config: Swimlanes & Timeline
+ * ```tsx
+ * <EzKanban
+ *   board={engineeringBoard}
+ *   view="swimlane"
+ *   swimlaneSettings={{ collapsible: true }}
+ *   onCardDoubleClick={(card) => openDetails(card)}
+ * />
+ * ```
+ *
+ * @group Core Components
+ */
+export declare const EzKanban: import('react').ForwardRefExoticComponent<EzKanbanProps & import('react').RefAttributes<EzKanbanRef<KanbanCard>>>;
+export default EzKanban;

package/dist/components/EzKanban/services/KanbanService.d.ts

@@ -0,0 +1,30 @@
+import { IKanbanService, KanbanBoard, KanbanCard, KanbanColumn, KanbanSwimlane } from '../EzKanban.types';
+/**
+ * Kanban service implementation following the ServiceRegistry pattern.
+ * Uses a static mock database to simulate persistence across component lifecycles.
+ */
+export declare class KanbanService implements IKanbanService {
+    name: string;
+    init(): Promise<void>;
+    cleanup(): Promise<void>;
+    /**
+     * Seeds the mock database with initial data.
+     * Useful for demos and tests.
+     */
+    initializeWithData(boards: KanbanBoard[]): void;
+    getBoard(boardId: string): Promise<KanbanBoard>;
+    createBoard(board: Partial<KanbanBoard>): Promise<KanbanBoard>;
+    updateBoard(boardId: string, updates: Partial<KanbanBoard>): Promise<void>;
+    deleteBoard(boardId: string): Promise<void>;
+    createCard(boardId: string, card: Partial<KanbanCard>): Promise<KanbanCard>;
+    updateCard(cardId: string, updates: Partial<KanbanCard>): Promise<void>;
+    deleteCard(cardId: string): Promise<void>;
+    moveCard(cardId: string, targetColumnId: string, targetSwimlaneId?: string, targetPosition?: number): Promise<void>;
+    createColumn(boardId: string, column: Partial<KanbanColumn>): Promise<KanbanColumn>;
+    updateColumn(columnId: string, updates: Partial<KanbanColumn>): Promise<void>;
+    deleteColumn(columnId: string): Promise<void>;
+    createSwimlane(boardId: string, swimlane: Partial<KanbanSwimlane>): Promise<KanbanSwimlane>;
+    updateSwimlane(swimlaneId: string, updates: Partial<KanbanSwimlane>): Promise<void>;
+    deleteSwimlane(swimlaneId: string): Promise<void>;
+    private simulateLatency;
+}

package/dist/components/EzKanban/state/kanban.store.d.ts

@@ -0,0 +1,33 @@
+import { Store } from '@tanstack/store';
+import { KanbanBoard, KanbanCard, KanbanColumn, FilterConfig } from '../EzKanban.types';
+export interface KanbanState {
+    board: KanbanBoard;
+    selectedCards: string[];
+    selectedColumnId: string | null;
+    view: 'standard' | 'swimlane' | 'timeline';
+    searchQuery: string;
+    activeFilters: FilterConfig;
+    history: KanbanBoard[];
+    historyIndex: number;
+}
+export declare const createKanbanStore: (initialBoard: KanbanBoard, initialView?: "standard" | "swimlane" | "timeline") => Store<KanbanState, (cb: KanbanState) => KanbanState>;
+export declare const createKanbanActions: (store: Store<KanbanState>) => {
+    setBoard: (board: KanbanBoard) => void;
+    addCard: (card: KanbanCard) => void;
+    updateCard: (cardId: string, updates: Partial<KanbanCard>) => void;
+    deleteCard: (cardId: string) => void;
+    moveCard: (cardId: string, targetColumnId: string) => void;
+    addColumn: (column: KanbanColumn) => void;
+    updateColumn: (columnId: string, updates: Partial<KanbanColumn>) => void;
+    deleteColumn: (columnId: string) => void;
+    setSelectedCards: (cardIds: string[]) => void;
+    setSelectedColumnId: (columnId: string | null) => void;
+    setView: (view: "standard" | "swimlane" | "timeline") => void;
+    setSearchQuery: (query: string) => void;
+    setActiveFilters: (filters: FilterConfig) => void;
+    undo: () => void;
+    redo: () => void;
+    canUndo: () => boolean;
+    canRedo: () => boolean;
+};
+export type KanbanActions = ReturnType<typeof createKanbanActions>;