apexgantt 3.14.0 → 3.14.1

package/apexgantt.d.ts

@@ -1,4 +1,14 @@
-import { TextDirection } from '@apex/commons';
+declare abstract class BaseChart {
+  /** @internal */
+  protected element: HTMLElement;
+  /** Destroys the chart instance and cleans up DOM resources. */
+  destroy(): void;
+  /** Returns the unique identifier for this chart instance. */
+  getInstanceId(): string;
+}
+
+declare type TextDirection = 'ltr' | 'rtl' | 'auto';
+
 
 declare interface AccessibilityOptions {
     readonly taskListAriaLabel?: string;
@@ -82,6 +92,34 @@ declare class ApexGantt extends BaseChart {
     private needsAutoFitZoom;
     private arrowLink;
     private dataManager;
+    /** Active sort criteria. Empty array = natural (input) order. */
+    private sortCriteria;
+    /** Active filter predicate, or null when no filter is applied. */
+    private activeFilter;
+    /** Current text in the built-in quick-filter box; preserved across re-renders. */
+    private quickFilterQuery;
+    /** Caret position to restore in the quick-filter box after a filter re-render. */
+    private quickFilterCaret;
+    /** Active structured filter rules (advanced filter builder), or null. */
+    private filterRuleSet;
+    /** Open/closed state of the filter-builder popover, preserved across re-renders. */
+    private filterBuilderOpen;
+    /** In-progress (uncommitted) rule set being edited in the filter-builder popover (mutable working copy). */
+    private filterBuilderDraft;
+    /** Active grouping criterion (normalized), or null when not grouping. */
+    private groupCriterion;
+    /** Manual per-column pixel widths set by resizing a header (or `setColumnWidth`); empty = all auto. */
+    private columnWidthOverrides;
+    /** User-chosen column order (keys left-to-right) from a header drag or `setColumnOrder`; null = configured order. */
+    private columnOrder;
+    /** Pending debounce timer for the opt-in localStorage state-persistence layer. */
+    private persistTimer;
+    /** Listener (shared by selection + scroll) that schedules a persist; null until attached. */
+    private persistChangeHandler;
+    /** Whether we've attempted the one-time restore of persisted state on first render. */
+    private stateRestoreAttempted;
+    /** True while `setState()` is applying state, so nested renders don't re-persist mid-flight. */
+    private isApplyingState;
     private stateManager;
     private history;
     /**
@@ -96,6 +134,19 @@ declare class ApexGantt extends BaseChart {
      * since the rewriters can't tell which columns are custom.
      */
     private buildColumnRefreshContext;
+    /**
+     * Fit-to-content pixel widths per column when `autoSizeColumns` is on, else
+     * `undefined` (columns fall back to `minWidth` + `flexGrow`). Measured against
+     * the resolved fonts so the estimate matches what the browser will render.
+     */
+    private computeAutoColumnWidths;
+    /**
+     * Task-list panel width: the configured `tasksContainerWidth`, grown to the
+     * total of the auto-sized columns (+ checkbox + borders) so content never
+     * clips. Never shrinks below the configured width, so wider layouts keep
+     * distributing the extra space via `flexGrow`.
+     */
+    private effectivePanelWidth;
     /**
      * Project date span padded for the current bar-label leading pad. When the
      * `barLabel.position` is `'left'` (or the user sets an explicit
@@ -156,6 +207,8 @@ declare class ApexGantt extends BaseChart {
     private selectionManager;
     private dependencyEditManager;
     private dependencyDrawManager;
+    private drawTaskManager;
+    private scrollButtonsManager;
     private virtualScrollCoordinator;
     private readonly columnRenderManager;
     /** MediaQueryList for prefers-reduced-motion. Updated dynamically. */
@@ -317,6 +370,22 @@ declare class ApexGantt extends BaseChart {
      * ```
      */
     updateTask(taskId: string, updatedTask: Partial<Task>): void;
+    /**
+     * Split a task into separate worked segments at `at`, producing a gap on the
+     * timeline. The segment containing `at` is cut so its first piece ends at `at`
+     * and the rest resumes at `resumeAt` (default: the next day — pass a later
+     * `resumeAt` to open a wider gap). A task with no segments yet is treated as a
+     * single span. Routed through `updateTask`, so it is validated, undoable, and
+     * emits `taskUpdate`. No-op on milestones, summary bars, or when `at` does not
+     * fall strictly inside a worked span.
+     *
+     * @example gantt.splitTask('t3', '2026-06-10', { resumeAt: '2026-06-14' });
+     */
+    splitTask(taskId: string, at: string, options?: {
+        resumeAt?: string;
+    }): void;
+    /** Whether a task is currently split into multiple worked segments. */
+    isSplit(taskId: string): boolean;
     /**
      * Insert a new task into the chart and re-render. The operation is
      * recorded in the undo history.
@@ -481,6 +550,258 @@ declare class ApexGantt extends BaseChart {
         undo: number;
         redo: number;
     };
+    /**
+     * Normalize the `sortBy` option into a criteria array. `undefined` →
+     * start-time ascending (preserves historical load behaviour); an explicit
+     * `[]` → natural (input) order.
+     */
+    private normalizeSortBy;
+    /** Build the active comparator from `sortCriteria` and push it to the data layer. */
+    private rebuildSort;
+    /** Apply the initial `sortBy` / `filterBy` / `filterRules` options at construction. */
+    private applyInitialSortAndFilter;
+    /**
+     * Re-apply the active filter after an `update()` rebuilt the data + options.
+     * Precedence: a new option in this call wins; otherwise rules > quick-filter >
+     * predicate. The predicate is recompiled so changed columns/format apply.
+     */
+    private reapplyFilterAfterUpdate;
+    /** Shared filter-evaluation context (date format + calendar). */
+    private filterContext;
+    /** Compile a structured rule set into a predicate using the current columns/context. */
+    private compileRules;
+    /** Normalize the `groupBy` option/argument into a {@link GroupCriterion} or null. */
+    private normalizeGroupBy;
+    /** Push the active grouping criterion (with its resolved column + none-label) to the data layer. */
+    private rebuildGrouping;
+    /** Apply the initial `groupBy` option at construction. */
+    private applyInitialGrouping;
+    /** Re-apply grouping after an `update()` rebuilt the data + options. */
+    private reapplyGroupingAfterUpdate;
+    /**
+     * Group the task list by a field. While grouping is active the parent/child
+     * tree is suspended and every task appears flat under a collapsible group
+     * header (label + member count). Pass a {@link GroupCriterion} for custom value
+     * extraction / labelling / order, or a bare column key. Re-renders and emits
+     * `groupChange`.
+     *
+     * @example gantt.groupBy(ColumnKey.Progress);
+     * @example gantt.groupBy({ field: 'status', direction: 'desc' });
+     */
+    groupBy(criterion: GroupCriterion | ColumnKey | string): void;
+    /** Clear the active grouping and restore the parent/child tree view. Emits `groupChange`. */
+    clearGrouping(): void;
+    /** The active grouping criterion, or `null` when not grouping. */
+    getGroupBy(): GroupCriterion | null;
+    /** Whether grouping is currently active. */
+    isGrouping(): boolean;
+    private dispatchGroupChange;
+    /**
+     * Apply a sort to the task list. Hierarchy-preserving: siblings are reordered
+     * within each parent (a child never leaves its parent). Pass one or more
+     * {@link SortCriterion}; an empty array clears the sort (natural input order).
+     * Re-renders and emits `sortChange`.
+     *
+     * @example gantt.sort({ key: ColumnKey.Name, direction: 'asc' });
+     */
+    sort(criteria: SortCriterion | SortCriterion[]): void;
+    /** Clear the active sort and return to natural (input) order. Emits `sortChange`. */
+    clearSort(): void;
+    /** The currently active sort criteria (empty array = natural order). */
+    getSort(): SortCriterion[];
+    /**
+     * Toggle the sort on a column through ascending → descending → none. Backs the
+     * column-header click UX. No-op when the column is not sortable. Emits
+     * `sortChange`.
+     *
+     * With `append: true` (Shift+click) the column is added as an additional sort
+     * key — the existing keys are kept and this key cycles ascending → descending
+     * → removed, so you can sort by several columns at once (first key wins, ties
+     * break on the next). Without it, the sort is replaced by this single key.
+     */
+    toggleSort(key: ColumnKey | string, opts?: {
+        append?: boolean;
+    }): void;
+    /**
+     * Apply a filter to the task list. A task is kept when it matches the
+     * predicate or has a matching descendant, so ancestors of matches stay
+     * visible. Filtering is view-only — it changes which rows render but not the
+     * tree, WBS, or task data. Re-renders and emits `filterChange`.
+     *
+     * @example gantt.filter((task) => task.progress < 100);
+     */
+    filter(predicate: TaskFilterPredicate): void;
+    /** Clear the active filter so every row is shown again. Emits `filterChange`. */
+    clearFilter(): void;
+    /** Whether a filter is currently active. */
+    isFiltered(): boolean;
+    /**
+     * Apply a structured filter (advanced filter builder): a {@link FilterRuleSet}
+     * of conditions combined with `'all'` (AND) or `'any'` (OR), compiled to the
+     * same view-only filter as `gantt.filter()`. Pass `null` (or an empty rule
+     * list) to clear. Re-renders and emits `filterChange`.
+     *
+     * @example gantt.setFilterRules({ match: 'all', rules: [{ field: ColumnKey.Progress, operator: 'lt', value: 100 }] });
+     */
+    setFilterRules(ruleSet: FilterRuleSet | null): void;
+    /** The active structured filter rules, or `null` when none are set. */
+    getFilterRules(): FilterRuleSet | null;
+    /**
+     * Commit a column resize coming from a header-handle drag. The `Tasks` view
+     * already updated the live grid template during the drag, so we only sync the
+     * authoritative override map (so it survives the next full render), persist,
+     * and emit `columnResize`. `width` is `null` when the column was reset.
+     */
+    private handleColumnResize;
+    private dispatchColumnResize;
+    /**
+     * Pin a task-list column to an exact pixel width (the other columns absorb the
+     * remaining panel space). Mirrors dragging the column-header resize handle.
+     * Re-renders and emits `columnResize`.
+     *
+     * @example gantt.setColumnWidth(ColumnKey.Name, 260);
+     */
+    setColumnWidth(key: ColumnKey | string, width: number): void;
+    /**
+     * Clear the manual width of one column (pass its `key`) or of every column
+     * (omit the argument), returning them to their auto/flex width. Re-renders and
+     * emits `columnResize`.
+     */
+    resetColumnWidths(key?: ColumnKey | string): void;
+    /** The active manual column-width overrides as a plain object (key → pixels). */
+    getColumnWidths(): Record<string, number>;
+    /**
+     * Commit a column reorder coming from a header drag: store the new key order,
+     * re-render so the grid reflects it, persist, and emit `columnReorder`.
+     */
+    private handleColumnReorder;
+    private dispatchColumnReorder;
+    /**
+     * Set the left-to-right order of the task-list columns by key. Keys you list
+     * are placed first in that order; any visible columns you omit keep their
+     * relative position at the end. Mirrors dragging a column header. Re-renders
+     * and emits `columnReorder`.
+     *
+     * @example gantt.setColumnOrder([ColumnKey.Name, ColumnKey.Progress, ColumnKey.StartTime]);
+     */
+    setColumnOrder(order: Array<ColumnKey | string>): void;
+    /** The current column order as an array of keys (left-to-right), reflecting any reorder. */
+    getColumnOrder(): string[];
+    /**
+     * Scroll the timeline (and, if needed, the row list) so a task's bar is in
+     * view, using nearest-edge alignment (the minimum scroll that reveals it).
+     * Backs the per-row scroll chevrons; call it directly to "locate" a task from
+     * search results, selection, or your own toolbar button.
+     *
+     * @returns `true` when a scroll was applied, `false` when the task is unknown
+     *   or already fully visible.
+     *
+     * @example gantt.scrollToTask('task-42');
+     */
+    scrollToTask(taskId: string): boolean;
+    /**
+     * Capture the current UI view state — zoom, scroll, collapse, selection, sort,
+     * and filter — as a serializable object. Pair with {@link setState} to save
+     * and restore "where the user left off" (e.g. to your own backend), or set the
+     * `persistState` option to have the Gantt do it via localStorage.
+     *
+     * @example const saved = gantt.getState(); // JSON-serializable
+     */
+    getState(): GanttUiState;
+    /**
+     * Restore a UI view state produced by {@link getState}. Any omitted field is
+     * left untouched, so a partial state (e.g. `{ sort: [...] }`) applies just that
+     * slice. Re-renders once, then emits `sortChange` / `filterChange` for the
+     * parts that changed (pass `{ silent: true }` to suppress those events).
+     *
+     * @example gantt.setState(savedState);
+     */
+    setState(state: Partial<GanttUiState>, opts?: {
+        silent?: boolean;
+    }): void;
+    /** Apply the `sort` slice of a {@link GanttUiState} to the data layer (no render). */
+    private applySortState;
+    /** Apply the `columnWidths` slice of a {@link GanttUiState} (no render). Omitted → untouched; `{}` → cleared. */
+    private applyColumnWidthsState;
+    /** Apply the `group` slice of a {@link GanttUiState} to the data layer (no render). */
+    private applyGroupState;
+    /** Apply the `filterRules` / `quickFilter` slice of a {@link GanttUiState} (no render). */
+    private applyFilterState;
+    /** Restore scroll offsets after a render (deferred so the DOM has laid out). */
+    private applyScrollState;
+    /** Resolve the persistence config, or `null` when disabled / storage is unavailable (SSR). */
+    private resolvePersistence;
+    /** Debounced write of the current state to storage; no-op when persistence is off. */
+    private schedulePersist;
+    /** Serialize and store the current state immediately (used by the debounce). */
+    private writePersistedState;
+    /**
+     * Read and apply any persisted state. Returns `true` when state was restored
+     * (the caller's render pass is superseded by the one inside `setState`).
+     */
+    private restorePersistedState;
+    /**
+     * Attach the persistence listeners once. Selection and scroll change without a
+     * full `render()`, so we save on those directly; `this.element` persists across
+     * renders and scroll bubbles in the capture phase, so a single set suffices.
+     */
+    private attachPersistenceListeners;
+    /** One-time restore + listener attach on the first render. Returns true when state was restored. */
+    private maybeRestorePersistedStateOnce;
+    /** Remove persistence listeners and cancel the pending write. Called from `destroy()`. */
+    private detachPersistence;
+    /**
+     * Auto-fit zoom on first render: once the container has a measurable width and
+     * (usually) data, pick a zoom that shows the whole project span.
+     */
+    private applyAutoFitZoomIfNeeded;
+    /**
+     * Diff the previously-visible and now-visible task IDs so only rows whose
+     * visibility changed (collapse/expand) get their arrows delayed. Returns
+     * `undefined` on the first render (no previous set) to fade the whole SVG.
+     */
+    private computeChangedVisibleIds;
+    /** Localized label for the toolbar export button, matching the active `exportFormat`. */
+    private exportButtonLabel;
+    /**
+     * Export the chart and trigger a download. `svg` is vector; `png` and `pdf`
+     * rasterize the chart (the PDF embeds the raster on a single page). Defaults
+     * to the configured `exportFormat`. Under row virtualization the full dataset
+     * is expanded for the snapshot and restored afterward.
+     *
+     * @param format Output format; defaults to `options.exportFormat` (`'svg'`).
+     * @returns Resolves once the download has been triggered.
+     *
+     * @example await gantt.exportChart('png');
+     */
+    exportChart(format?: GanttExportFormat): Promise<void>;
+    private dispatchSortChange;
+    private dispatchFilterChange;
+    /** Build the built-in quick-filter search input for the toolbar. */
+    private buildQuickFilterInput;
+    /**
+     * Apply the quick-filter query: set the matching predicate (or clear it when
+     * empty), re-render, and restore focus + caret to the search box (a full
+     * re-render rebuilds the toolbar, so the input is recreated each keystroke).
+     */
+    private applyQuickFilter;
+    /** Build a name/field-contains predicate from the quick-filter query (null when blank). */
+    private buildQuickFilterPredicate;
+    private restoreQuickFilterFocus;
+    /**
+     * Build the "Filter" toolbar control: a button (with an active-rule count
+     * badge) and, when open, the rule-composer popover. Rebuilt on every toolbar
+     * render from `filterBuilderOpen` / `filterBuilderDraft`, so its state
+     * survives re-renders.
+     */
+    private buildFilterBuilder;
+    /** Toggle the popover, seeding the draft from the committed rules when opening. */
+    private toggleFilterBuilder;
+    private cloneRuleSet;
+    /** Build the popover body: match selector, rule rows, add button, and footer. */
+    private buildFilterPopover;
+    /** Build one condition row: field select, operator select, and a typed value input. */
+    private buildFilterRow;
     /**
      * Wire a global keydown listener on the root element so Ctrl/Cmd+Z and
      * Ctrl+Y / Ctrl/Cmd+Shift+Z work anywhere inside the chart (timeline body,
@@ -516,6 +837,17 @@ declare class ApexGantt extends BaseChart {
      * entries. Picks placeholder dates from the current project span so the
      * bar is visible at the default zoom.
      */
+    /** Snap step in ms for the active snap unit/value (day / hour / minute). */
+    private snapStepMs;
+    /**
+     * Create a task from a draw-on-empty-timeline gesture. `startX` / `endX` are
+     * content-space pixel offsets (the gesture's two edges); we reverse them
+     * through the current geometry to dates, snap to the snap unit, and add a task
+     * spanning that range. Day-only formats render the end inclusive, so an
+     * N-unit sweep lands `end = start + (N-1)` units. Row index is not used for
+     * placement — the new root task sorts into position by its dates like any add.
+     */
+    private commitDrawnTask;
     private addPlaceholderTask;
     /**
      * Toolbar "+ Add task" handler. Inserts a new root-level placeholder task.
@@ -658,6 +990,34 @@ export declare interface Assignee {
     readonly color?: string;
 }
 
+/**
+ * Built-in column renderer that shows a stacked row of circular avatars for a
+ * task's assignees, with an overflow indicator (`+N`) when the count exceeds
+ * `max`. Falls back to colored initials when an assignee has no `avatarUrl`.
+ *
+ * @example
+ * ```ts
+ * import { ApexGantt, ColumnKey, renderers } from '@apexcharts/apexgantt';
+ *
+ * new ApexGantt('#chart', {
+ *   series,
+ *   columnConfig: [
+ *     { key: ColumnKey.Name, title: 'Task' },
+ *     {
+ *       key: 'assignees',
+ *       title: 'Assigned',
+ *       render: renderers.avatars({
+ *         accessor: (task) => task.assignees,
+ *         max: 4,
+ *         size: 24,
+ *       }),
+ *     },
+ *   ],
+ * });
+ * ```
+ */
+declare function avatars(options: AvatarsRendererOptions): ColumnRenderer;
+
 /**
  * Configuration for the {@link avatars} column renderer.
  */
@@ -733,14 +1093,6 @@ export declare type BarLabelPosition = 'inside' | 'left' | 'right' | 'auto';
  */
 export declare type BarLabelRenderer = (task: Task) => string | HTMLElement | null | undefined;
 
-declare abstract class BaseChart {
-    /* Excluded from this release type: element */
-    /** Destroys the chart instance and cleans up DOM resources. */
-    destroy(): void;
-    /** Returns the unique identifier for this chart instance. */
-    getInstanceId(): string;
-}
-
 /**
  * Planned (baseline) dates for a task, used to visualise schedule variance.
  *
@@ -768,11 +1120,13 @@ export declare interface BaselineOptions {
      */
     readonly enabled: boolean;
     /**
-     * Primary baseline color. When `striped` is true this paints the stripes;
-     * otherwise it fills the whole bar.
-     * @default '#9E9E9E'
+     * Baseline color. When `striped` is true this paints the stripes; otherwise
+     * it fills the whole bar. When omitted, the baseline uses the task bar's
+     * progress shade (the darker tone of the bar drawn above), so a baseline
+     * reads as the planned twin of its bar. Set an explicit color to override.
+     * @default the bar's progress color (task `barBackgroundColor`, darkened)
      */
-    readonly color: string;
+    readonly color?: string;
     /**
      * Fill the baseline bar with thick diagonal stripes that alternate between
      * `color` and `stripeColor`, instead of a flat fill.
@@ -913,12 +1267,18 @@ export declare interface CalendarOptions {
  * and in what order.
  */
 export declare enum ColumnKey {
+    Assignees = "assignees",
+    BaselineEnd = "baselineEnd",
+    BaselineStart = "baselineStart",
+    BaselineVariance = "baselineVariance",
     Duration = "duration",
     EndTime = "endTime",
     Name = "name",
+    Predecessors = "predecessors",
     Progress = "progress",
     ProgressRing = "progressRing",
     StartTime = "startTime",
+    Successors = "successors",
     Wbs = "wbs"
 }
 
@@ -944,22 +1304,77 @@ export declare interface ColumnListItem {
     readonly key: ColumnKey | string;
     readonly title: string;
     readonly minWidth?: string;
+    /**
+     * Upper bound for auto-sized column width (e.g. `'240px'`). Caps how wide the
+     * column grows to fit content when `autoSizeColumns` is on, so one long value
+     * can't dominate the panel. Ignored when auto-sizing is off. @default '320px'
+     */
+    readonly maxWidth?: string;
     readonly flexGrow?: number;
     readonly visible?: boolean;
+    /**
+     * Whether this column can be resized by dragging the handle at its header's
+     * trailing edge (requires the `resizableColumns` option). Set `false` to lock
+     * a single column at its auto/configured width. @default true
+     */
+    readonly resizable?: boolean;
     /**
      * Custom cell renderer. Required for custom columns; ignored for built-in
      * columns (built-ins use the library's internal renderer).
      */
     readonly render?: ColumnRenderer;
     /**
-     * Extracts the underlying value of the cell from the task. Used by future
-     * sort/filter features and by SVG export. Optional.
+     * Extracts the underlying value of the cell from the task. Used by sorting,
+     * filtering, and SVG export. Optional for built-in columns (they have native
+     * extractors); for a custom column it is what makes the column sortable.
      */
     readonly accessor?: (task: Task) => unknown;
+    /**
+     * Whether the column participates in sorting (header click + the `sortBy`
+     * option / `gantt.sort()` API). Defaults to `true` for built-in value
+     * columns, `false` for the `Wbs` column, and `true` for custom columns only
+     * when an `accessor` or `comparator` is supplied.
+     */
+    readonly sortable?: boolean;
+    /**
+     * Custom sort comparator for this column. When provided it takes precedence
+     * over `accessor`-based comparison. Receives two tasks and returns a negative
+     * / zero / positive number (ascending order); the active sort direction is
+     * applied on top. Stable: equal results fall back to natural (input) order.
+     */
+    readonly comparator?: TaskComparator;
 }
 
 declare interface ColumnOptions {
     readonly columnConfig?: ColumnListItem[];
+    /**
+     * Initial sort applied to the task list. One or more {@link SortCriterion}
+     * (or a single criterion). Sorting is hierarchy-preserving: siblings are
+     * reordered within each parent, never flattened. Omit for the default
+     * (start-time ascending); pass `[]` for natural (input) order.
+     * @default [{ key: ColumnKey.StartTime, direction: 'asc' }]
+     */
+    readonly sortBy?: SortCriterion | SortCriterion[];
+    /**
+     * Initial filter applied to the task list. A predicate run against each task;
+     * a task is kept when it matches or has a matching descendant (ancestors of
+     * matches stay visible). Omit for no filter. @default undefined
+     */
+    readonly filterBy?: TaskFilterPredicate;
+    /**
+     * Initial structured filter (advanced filter builder). A {@link FilterRuleSet}
+     * of conditions combined with `'all'` (AND) / `'any'` (OR), compiled to the
+     * same view-only filter as `filterBy`. Takes precedence over `filterBy` when
+     * both are set. @default undefined
+     */
+    readonly filterRules?: FilterRuleSet;
+    /**
+     * Initial grouping applied to the task list. A {@link GroupCriterion} (or a
+     * bare column key). When set, the parent/child tree is suspended and tasks are
+     * bucketed under collapsible group headers. Omit for no grouping.
+     * @default undefined
+     */
+    readonly groupBy?: GroupCriterion | ColumnKey | string;
 }
 
 /**
@@ -1005,16 +1420,59 @@ export declare interface ColumnRenderContext {
  */
 export declare type ColumnRenderer = (ctx: ColumnRenderContext, el: HTMLElement) => void | string | (() => void);
 
+/**
+ * Detail for the `columnReorder` event, fired when task-list columns are
+ * reordered by dragging a column header, or via `gantt.setColumnOrder()`.
+ */
+export declare interface ColumnReorderEventDetail {
+    /** Column keys in their new left-to-right order (visible columns only). */
+    order: string[];
+    /** Key of the column that was moved (the dragged column); `null` for a bulk `setColumnOrder`. */
+    movedKey: string | null;
+    timestamp: number;
+}
+
+/**
+ * Detail for the `columnResize` event, fired when a task-list column is resized
+ * by dragging its header handle, via `gantt.setColumnWidth()`, or reset via
+ * `gantt.resetColumnWidths()`.
+ */
+export declare interface ColumnResizeEventDetail {
+    /** Key of the column that changed. */
+    key: string;
+    /** New pixel width, or `null` when the column was reset to its auto width. */
+    width: number | null;
+    /** All active manual column-width overrides after the change (key → pixels). */
+    widths: Record<string, number>;
+    timestamp: number;
+}
+
 declare interface CommonOptions {
     readonly backgroundColor: string;
     readonly borderColor: string;
     readonly canvasStyle: string;
     readonly enableExport: boolean;
+    /** Format the toolbar export button produces. @default 'svg' */
+    readonly exportFormat: GanttExportFormat;
     readonly enableResize: boolean;
     readonly headerBackground: string;
     readonly height: number | string;
     readonly inputDateFormat: string;
     readonly pixelsPerDay?: number;
+    /**
+     * Persist the UI view state (zoom, scroll, sort, filter, collapse, selection)
+     * to `localStorage` and restore it on load. `true` uses the default key;
+     * an object customizes it. @default false
+     */
+    readonly persistState: boolean | GanttStatePersistenceOptions;
+    /**
+     * Auto-size task-list columns to fit their header + cell content, growing the
+     * panel so nothing clips. Set `false` to distribute the panel width by
+     * `flexGrow` (legacy behavior). @default true
+     */
+    readonly autoSizeColumns: boolean;
+    readonly resizableColumns: boolean;
+    readonly reorderableColumns: boolean;
     readonly tasksContainerWidth: number;
     readonly width: number | string;
 }
@@ -1233,6 +1691,49 @@ export declare type DependencyType = 'FF' | 'FS' | 'SF' | 'SS';
  */
 export declare function escapeHtml(value: unknown): string;
 
+/**
+ * Detail for the `filterChange` event, fired when the active filter changes via
+ * `gantt.filter()` / `gantt.clearFilter()`.
+ */
+export declare interface FilterChangeEventDetail {
+    /** Whether a filter is active after the change. */
+    active: boolean;
+    /** Number of rows visible under the active filter (visible task count). */
+    visibleCount: number;
+    timestamp: number;
+}
+
+/**
+ * Comparison operators for a structured {@link FilterRule}. Which operators are
+ * valid depends on the column's value type (text / number / date); see the
+ * filter builder. `isEmpty` / `notEmpty` apply to any type and ignore `value`.
+ */
+export declare type FilterOperator = 'contains' | 'notContains' | 'equals' | 'notEquals' | 'startsWith' | 'endsWith' | 'gt' | 'gte' | 'lt' | 'lte' | 'before' | 'after' | 'on' | 'isEmpty' | 'notEmpty';
+
+/** A single structured filter condition: compare a column's value with `value`. */
+export declare interface FilterRule {
+    /** Column key whose value is tested (a `ColumnKey` or a custom column id). */
+    readonly field: ColumnKey | string;
+    /** Comparison operator. */
+    readonly operator: FilterOperator;
+    /**
+     * Comparison operand. A number for number columns, a `YYYY-MM-DD` string for
+     * date columns, free text otherwise. Ignored by `isEmpty` / `notEmpty`.
+     */
+    readonly value?: string | number;
+}
+
+/**
+ * A set of {@link FilterRule}s combined with boolean logic. Compiles to a
+ * {@link TaskFilterPredicate} and backs the advanced filter builder.
+ */
+export declare interface FilterRuleSet {
+    /** `'all'` = every rule must match (AND); `'any'` = at least one (OR). */
+    readonly match: 'all' | 'any';
+    /** The rules to evaluate. An empty list means "no filter". */
+    readonly rules: FilterRule[];
+}
+
 declare interface FontOptions {
     readonly fontColor: string;
     readonly fontFamily: string;
@@ -1356,6 +1857,16 @@ export declare interface GanttEventMap {
     dependencyArrowUpdate: CustomEvent<DependencyArrowUpdateDetail>;
     /** Fires after a record/undo/redo/clear mutates the history stack. */
     historyChange: CustomEvent<HistoryChangeEventDetail>;
+    /** Fires after the active sort changes (API or header click). */
+    sortChange: CustomEvent<SortChangeEventDetail>;
+    /** Fires after the active filter changes. */
+    filterChange: CustomEvent<FilterChangeEventDetail>;
+    /** Fires after the active grouping changes (API). */
+    groupChange: CustomEvent<GroupChangeEventDetail>;
+    /** Fires after a task-list column is resized (header drag or API). */
+    columnResize: CustomEvent<ColumnResizeEventDetail>;
+    /** Fires after task-list columns are reordered (header drag or API). */
+    columnReorder: CustomEvent<ColumnReorderEventDetail>;
 }
 
 export declare const GanttEvents: {
@@ -1419,8 +1930,31 @@ export declare const GanttEvents: {
      * emits after the undo/redo stack changes — record, undo, redo, or clear
      */
     readonly HISTORY_CHANGE: "historyChange";
+    /**
+     * emits after the active sort changes (via API or column-header click)
+     */
+    readonly SORT_CHANGE: "sortChange";
+    /**
+     * emits after the active filter changes
+     */
+    readonly FILTER_CHANGE: "filterChange";
+    /**
+     * emits after the active grouping changes (via API)
+     */
+    readonly GROUP_CHANGE: "groupChange";
+    /**
+     * emits after a task-list column is resized (header drag or API)
+     */
+    readonly COLUMN_RESIZE: "columnResize";
+    /**
+     * emits after task-list columns are reordered (header drag or API)
+     */
+    readonly COLUMN_REORDER: "columnReorder";
 };
 
+/** Supported export formats. `svg` is vector; `png`/`pdf` rasterize the SVG. */
+export declare type GanttExportFormat = 'svg' | 'png' | 'pdf';
+
 /**
  * Every user-facing string the Gantt generates internally (toolbar, context
  * menu, task form, validation, baseline tooltip, add-task row, and bar
@@ -1437,8 +1971,40 @@ export declare interface GanttMessages {
     readonly undo: string;
     /** Redo toolbar button. @default 'Redo (Ctrl+Y)' */
     readonly redo: string;
-    /** Export toolbar button. @default 'Export as SVG' */
+    /** Export toolbar button (SVG format). @default 'Export as SVG' */
     readonly exportAsSvg: string;
+    /** Export toolbar button (PNG format). @default 'Export as PNG' */
+    readonly exportAsPng: string;
+    /** Export toolbar button (PDF format). @default 'Export as PDF' */
+    readonly exportAsPdf: string;
+    /** Placeholder for the built-in quick-filter search box. @default 'Search tasks…' */
+    readonly quickFilterPlaceholder: string;
+    /** Advanced filter builder: toolbar button label. @default 'Filter' */
+    readonly filterButton: string;
+    /** Filter builder: popover heading. @default 'Filter tasks' */
+    readonly filterHeading: string;
+    /** Filter builder: match-mode label. @default 'Match' */
+    readonly filterMatchLabel: string;
+    /** Filter builder: match-all (AND) option. @default 'All' */
+    readonly filterMatchAll: string;
+    /** Filter builder: match-any (OR) option. @default 'Any' */
+    readonly filterMatchAny: string;
+    /** Filter builder: add-condition button. @default '+ Add condition' */
+    readonly filterAddCondition: string;
+    /** Filter builder: apply button. @default 'Apply' */
+    readonly filterApply: string;
+    /** Filter builder: clear button. @default 'Clear' */
+    readonly filterClear: string;
+    /** Filter builder: remove-condition button aria-label. @default 'Remove condition' */
+    readonly filterRemoveCondition: string;
+    /** Filter builder: empty-state text shown when no conditions exist. @default 'No conditions yet.' */
+    readonly filterNoConditions: string;
+    /** Filter builder: human-readable label for a comparison operator. */
+    readonly filterOperatorLabel: (operator: FilterOperator) => string;
+    /** Group header label for tasks whose group value is empty. @default '(None)' */
+    readonly groupNone: string;
+    /** Group header member-count label, e.g. `(3)`. @default `(n)` => `(${n})` */
+    readonly groupCountLabel: (count: number) => string;
     /** Alert when export cannot find the chart. @default 'Export failed: Chart not found. Please refresh and try again.' */
     readonly exportFailedNoChart: string;
     /** Generic export-failure alert. @default 'Export failed. Please check the console for details.' */
@@ -1524,6 +2090,15 @@ declare interface GanttRowOptions {
     readonly rowHeight: number;
 }
 
+/**
+ * Configuration for opt-in localStorage persistence of the {@link GanttUiState}.
+ * Pass `persistState: true` for the defaults, or an object to customize the key.
+ */
+export declare interface GanttStatePersistenceOptions {
+    /** localStorage key under which the state is saved. @default 'apexgantt-state' */
+    key?: string;
+}
+
 /**
  * Complete color palette for the chart UI.
  *
@@ -1580,6 +2155,62 @@ export declare interface GanttTheme {
     readonly splitBarHandleColor: string;
 }
 
+/**
+ * A serializable snapshot of the Gantt's view state: everything that is a
+ * user's "where I left off" rather than the task data itself. Produced by
+ * `gantt.getState()` and consumed by `gantt.setState()`; also what the opt-in
+ * localStorage persistence layer reads and writes.
+ *
+ * Every field is optional on input to `setState()` so a partial state (e.g.
+ * only `sort`) applies just that slice and leaves the rest untouched.
+ */
+export declare interface GanttUiState {
+    /** Schema version; set to {@link GANTT_STATE_VERSION} by `getState()`. */
+    version: number;
+    /** Zoom level as pixels-per-day (same unit as the `pixelsPerDay` option). */
+    zoom?: number;
+    /** Scroll offsets in pixels: `horizontal` = timeline, `vertical` = grid rows. */
+    scroll?: {
+        horizontal: number;
+        vertical: number;
+    };
+    /** IDs of collapsed summary rows. Rows not listed are expanded. */
+    collapsed?: string[];
+    /** IDs of selected task rows (requires `enableSelection`). */
+    selected?: string[];
+    /** Active sort criteria; an empty array means natural (input) order. */
+    sort?: Array<{
+        key: string;
+        direction: 'asc' | 'desc';
+    }>;
+    /** Active advanced-filter rule set, or `null` when no structured filter is set. */
+    filterRules?: FilterRuleSet | null;
+    /** Text in the built-in quick-filter box. */
+    quickFilter?: string;
+    /**
+     * Active grouping: the field grouped by and header order, or `null` when not
+     * grouping. Only the serializable parts are stored — a custom `accessor` /
+     * `label` on the criterion is not persisted (restore falls back to the
+     * column's own accessor).
+     */
+    group?: {
+        field: string;
+        direction?: 'asc' | 'desc';
+    } | null;
+    /**
+     * Manual per-column pixel widths set by resizing a column header (or
+     * `gantt.setColumnWidth()`), keyed by column key. Columns not listed keep
+     * their auto/flex width. Omitted (or empty) when no column has been resized.
+     */
+    columnWidths?: Record<string, number>;
+    /**
+     * Column keys in their user-chosen left-to-right order (from dragging a
+     * column header or `gantt.setColumnOrder()`). Omitted when the order has not
+     * been changed from the configured/default order.
+     */
+    columnOrder?: string[];
+}
+
 /**
  * Top-level configuration object for `ApexGantt`.
  *
@@ -1648,7 +2279,7 @@ export declare interface GanttUserOptions {
     /**
      * Fill color for summary (group) bars. Renders distinct from regular task
      * bars to make the parent/child hierarchy visually obvious.
-     * @default '#B9CECE' (light) / '#8FBCBC' (dark)
+     * @default '#94A3B8' (light) / '#8FBCBC' (dark)
      */
     readonly summaryBarColor?: string;
     /**
@@ -1670,7 +2301,7 @@ export declare interface GanttUserOptions {
      * and HTML hover tooltip (`tooltipTemplate`).
      */
     readonly dependencies?: DependencyOptions;
-    /** Color of the cell and row divider lines. @default '#eff0f0' */
+    /** Color of the cell and row divider lines. @default '#E5E7EB' (light) / '#3A3A3A' (dark) */
     readonly borderColor?: string;
     /** Arbitrary CSS injected onto the root container element. */
     readonly canvasStyle?: string;
@@ -1687,7 +2318,7 @@ export declare interface GanttUserOptions {
      * @default false
      */
     readonly enableCrosshair?: boolean;
-    /** Color of the crosshair line and label background. @default '#87B7FE' (light) / '#818CF8' (dark) */
+    /** Color of the crosshair line and label background. @default '#3B82F6' (light) / '#818CF8' (dark) */
     readonly crosshairColor?: string;
     /**
      * Custom formatter for the crosshair label text. Receives the date under the
@@ -1696,12 +2327,44 @@ export declare interface GanttUserOptions {
      * month/quarter/year tiers and `'MM/DD HH:mm'` for hour/minute tiers.
      */
     readonly crosshairLabelFormat?: CrosshairLabelFormatter;
-    /** Border color for all cells in the task table and timeline grid. @default '#D0D7DE' */
+    /** Border color for all cells in the task table and timeline grid. @default '#EDEFF2' (light) / '#3A3A3A' (dark) */
     readonly cellBorderColor?: string;
     /** CSS border-width for all cell lines, e.g. `'1px'`. @default '1px' */
     readonly cellBorderWidth?: string;
     /** Custom column definitions for the task-list panel. When omitted, all default columns are shown. */
     readonly columnConfig?: ColumnListItem[];
+    /**
+     * Initial sort for the task list. One or more {@link SortCriterion}.
+     * Hierarchy-preserving: siblings are sorted within each parent. Omit for the
+     * default (start-time ascending); pass `[]` for natural (input) order.
+     * @default [{ key: ColumnKey.StartTime, direction: 'asc' }]
+     */
+    readonly sortBy?: SortCriterion | SortCriterion[];
+    /**
+     * Initial filter for the task list. A predicate run against each task; a task
+     * is kept when it matches or has a matching descendant. @default undefined
+     */
+    readonly filterBy?: TaskFilterPredicate;
+    /**
+     * Initial structured filter (advanced filter builder): a {@link FilterRuleSet}
+     * of conditions combined with `'all'` / `'any'`. Takes precedence over
+     * `filterBy` when both are set. @default undefined
+     */
+    readonly filterRules?: FilterRuleSet;
+    /**
+     * Initial grouping: a {@link GroupCriterion} or a bare column key. When set,
+     * the parent/child tree is suspended and tasks are bucketed under collapsible
+     * group headers, ordered and labelled by the criterion. Also available at
+     * runtime via `gantt.groupBy()` / `gantt.clearGrouping()`. @default undefined
+     */
+    readonly groupBy?: GroupCriterion | ColumnKey | string;
+    /**
+     * Show a built-in advanced filter builder in the toolbar — a "Filter" button
+     * that opens a popover for composing field/operator/value conditions combined
+     * with All (AND) / Any (OR). Drives the same view-only filter as
+     * `gantt.setFilterRules()`. @default false
+     */
+    readonly enableFilterBuilder?: boolean;
     /**
      * Whether to draw vertical lines between timeline columns (the cell
      * dividers in the header and body grid). Set to `false` for a cleaner
@@ -1730,8 +2393,48 @@ export declare interface GanttUserOptions {
     readonly enableInlineEdit?: boolean;
     /** Enable row selection (click, Ctrl+Click, Shift+Click, keyboard). @default false */
     readonly enableSelection?: boolean;
-    /** Show the SVG export button in the toolbar. @default true */
+    /** Show the export button in the toolbar. @default true */
     readonly enableExport?: boolean;
+    /**
+     * Format produced by the toolbar export button: `'svg'` (vector), `'png'`
+     * (raster), or `'pdf'` (single-page, image-based). Any format is also
+     * available programmatically via `gantt.exportChart(format)`. @default 'svg'
+     */
+    readonly exportFormat?: GanttExportFormat;
+    /**
+     * Persist and restore the UI view state (zoom, scroll, sort, filter, collapse,
+     * selection) via `localStorage`. Pass `true` to enable with the default key
+     * (`'apexgantt-state'`), or an object to set a custom key. Restored on the
+     * first `render()`; saved (debounced) whenever the view changes. State is also
+     * available programmatically via `gantt.getState()` / `gantt.setState()`.
+     * @default false
+     */
+    readonly persistState?: boolean | GanttStatePersistenceOptions;
+    /**
+     * Auto-size each task-list column to fit its header title and cell content,
+     * growing the task-list panel (never below `tasksContainerWidth`) so nothing
+     * is clipped. `flexGrow` still distributes any extra width, `minWidth` is a
+     * floor, and `maxWidth` (per column, default `320px`) is the ceiling. Set to
+     * `false` for the legacy behavior where the panel width is split purely by
+     * `flexGrow`. @default true
+     */
+    readonly autoSizeColumns?: boolean;
+    /**
+     * Allow individual task-list columns to be resized by dragging the handle at
+     * the trailing edge of each column header. A resized column is pinned to its
+     * chosen pixel width (the other columns absorb the remaining space), so users
+     * can keep some columns wide and others thin. Double-click a handle to reset
+     * that column to its auto width. Opt a single column out with
+     * `columnConfig[].resizable: false`. @default true
+     */
+    readonly resizableColumns?: boolean;
+    /**
+     * Allow columns to be reordered by dragging a column header left or right onto
+     * another column. The new order is reflected in the grid, included in
+     * `getState()` / `setState()`, and emitted as a `columnReorder` event. Also
+     * available programmatically via `gantt.setColumnOrder()`. @default true
+     */
+    readonly reorderableColumns?: boolean;
     /** Allow the task-list panel to be resized by dragging the divider. @default true */
     readonly enableResize?: boolean;
     /** Allow tasks to be reordered by dragging rows in the task list. @default true */
@@ -1798,6 +2501,22 @@ export declare interface GanttUserOptions {
      * @default false
      */
     readonly enableAddTaskRow?: boolean;
+    /**
+     * Allow creating a task by dragging across an empty stretch of the timeline:
+     * press on an empty row, drag horizontally to sweep out the date range, and
+     * release to add a task with those (snapped) start/end dates. Off by default
+     * so an existing chart's empty-area drags stay inert; enable it to match
+     * "draw a new bar" from dedicated project tools. Respects `beforeTaskAdd` and
+     * is recorded in undo history like any other add. @default false
+     */
+    readonly enableDrawTask?: boolean;
+    /**
+     * Show a small chevron at the edge of a task's row when that task's bar is
+     * scrolled out of the visible timeline window; clicking it scrolls the bar
+     * into view. Also available programmatically via `gantt.scrollToTask()`.
+     * @default true
+     */
+    readonly enableScrollButtons?: boolean;
     /**
      * Configures the undo/redo history stack. Every mutating call (drag, resize,
      * inline / dialog edit, add, delete, move, dependency change) is recorded
@@ -1813,15 +2532,15 @@ export declare interface GanttUserOptions {
     readonly history?: Partial<HistoryOptions>;
     /** Show a tooltip on task-bar hover. @default true */
     readonly enableTooltip?: boolean;
-    /** Color for all text in the chart. @default '#000000' */
+    /** Color for all text in the chart. @default '#1F2933' (light) / '#E0E0E0' (dark) */
     readonly fontColor?: string;
-    /** CSS font-family for the chart. Falls back to the page default when empty. */
+    /** CSS font-family for the chart. @default 'system-ui, -apple-system, "Segoe UI", Roboto, Helvetica, Arial, sans-serif' */
     readonly fontFamily?: string;
     /** CSS font-size for the chart, e.g. `'14px'`. @default '14px' */
     readonly fontSize?: string;
     /** CSS font-weight for the chart. @default '400' */
     readonly fontWeight?: string;
-    /** Background color of the timeline and task-list header row. @default '#f3f3f3' */
+    /** Background color of the timeline and task-list header row. @default '#F8F9FB' (light) / '#2A2A2A' (dark) */
     readonly headerBackground?: string;
     /** Height of the chart. Accepts a pixel number or a CSS string. @default 500 */
     readonly height?: number | string;
@@ -1829,7 +2548,7 @@ export declare interface GanttUserOptions {
     readonly inputDateFormat?: string;
     /** Alternating row background colors. The pattern cycles automatically. @default ['#FFFFFF'] */
     readonly rowBackgroundColors?: readonly string[];
-    /** Height of each task row in pixels. @default 28 */
+    /** Height of each task row in pixels. @default 40 */
     readonly rowHeight?: number;
     /** Task data array. Required. Each item must satisfy `TaskInput`, or use `parsing` to map custom field names. */
     readonly series: TaskInput[] | Record<string, unknown>[];
@@ -1837,7 +2556,7 @@ export declare interface GanttUserOptions {
     readonly tasksContainerWidth?: number;
     /** Background color of the hover tooltip. @default '#FFFFFF' */
     readonly tooltipBGColor?: string;
-    /** Border color of the hover tooltip. @default '#BCBCBC' */
+    /** Border color of the hover tooltip. @default '#E5E7EB' (light) / '#444444' (dark) */
     readonly tooltipBorderColor?: string;
     /** HTML `id` for the tooltip container element. @default 'apexgantt-tooltip-container' */
     readonly tooltipId?: string;
@@ -1898,6 +2617,15 @@ export declare interface GanttUserOptions {
      * @default []
      */
     readonly toolbarItems?: ToolbarItem[];
+    /**
+     * Show a built-in quick-filter search box in the toolbar. Typing filters the
+     * task list to rows whose configured fields contain the query (ancestors of
+     * matches stay visible); clearing it removes the filter. Drives the same
+     * view-only filter as `gantt.filter()`. @default false
+     */
+    readonly enableQuickFilter?: boolean;
+    /** Fine-tunes the built-in quick-filter search box (placeholder, fields, case-sensitivity). */
+    readonly quickFilter?: QuickFilterOptions;
     /** `aria-label` for the task-list table, used by screen readers. @default 'Task list' */
     readonly taskListAriaLabel?: string;
     /**
@@ -1951,6 +2679,42 @@ export declare interface GanttUserOptions {
 
 export declare function getTheme(mode: ThemeMode): GanttTheme;
 
+/**
+ * Detail for the `groupChange` event, fired when the active grouping changes via
+ * `gantt.groupBy()` / `gantt.clearGrouping()`.
+ */
+export declare interface GroupChangeEventDetail {
+    /** Whether grouping is active after the change. */
+    active: boolean;
+    /** The field being grouped by, or `null` when grouping was cleared. */
+    field: string | null;
+    /** Number of groups produced by the active grouping (0 when cleared). */
+    groupCount: number;
+    timestamp: number;
+}
+
+/**
+ * Describes how to group the task grid by a field. When active, the parent/child
+ * tree is suspended and every task appears flat under a collapsible group header.
+ *
+ * Pass a bare `ColumnKey`/string to `gantt.groupBy()` (or the `groupBy` option)
+ * to group by that column's value, or this object form to customize how the
+ * group value is extracted, labelled, and ordered.
+ */
+export declare interface GroupCriterion {
+    /** Column key whose value tasks are grouped by (a `ColumnKey` or custom column id). */
+    readonly field: ColumnKey | string;
+    /**
+     * Extract the raw group value from a task. Overrides the column's `accessor`.
+     * Tasks with an equal value (by `String(value)`) land in the same group.
+     */
+    readonly accessor?: (task: Task) => unknown;
+    /** Format a raw group value into the header label. Defaults to `String(value)`. */
+    readonly label?: (value: unknown) => string;
+    /** Order of the group headers by key. @default 'asc' */
+    readonly direction?: SortDirection;
+}
+
 /**
  * Detail payload for the `historyChange` event.
  *
@@ -2029,6 +2793,8 @@ declare interface InteractiveOptions {
     readonly enableTaskCRUDToolbar: boolean;
     readonly enableContextMenu: boolean;
     readonly enableAddTaskRow: boolean;
+    readonly enableDrawTask: boolean;
+    readonly enableScrollButtons: boolean;
     readonly history: HistoryOptions;
     readonly snapUnit: SnapUnit;
     readonly snapValue: number;
@@ -2131,6 +2897,36 @@ export declare type ParsingValue = string | {
     transform?: (value: unknown) => unknown;
 };
 
+/**
+ * Built-in column renderer that draws an SVG progress ring for the task's
+ * completion percentage, with an optional centered numeric label.
+ *
+ * Reads from `task.progress` by default; override with `accessor` for
+ * computed values.
+ *
+ * @example
+ * ```ts
+ * import { ApexGantt, ColumnKey, renderers } from '@apexcharts/apexgantt';
+ *
+ * new ApexGantt('#chart', {
+ *   series,
+ *   columnConfig: [
+ *     { key: ColumnKey.Name, title: 'Task' },
+ *     {
+ *       key: 'progressRing',
+ *       title: '%',
+ *       render: renderers.progressRing({
+ *         size: 28,
+ *         strokeWidth: 3,
+ *         progressColor: (_task, value) => value > 80 ? '#22C55E' : value >= 40 ? '#3B82F6' : '#EF4444',
+ *       }),
+ *     },
+ *   ],
+ * });
+ * ```
+ */
+declare function progressRing(options?: ProgressRingRendererOptions): ColumnRenderer;
+
 /**
  * Configuration for the {@link progressRing} column renderer.
  */
@@ -2154,14 +2950,35 @@ export declare interface ProgressRingRendererOptions {
     readonly labelColor?: string;
 }
 
-export declare namespace renderers {
-        {
+/**
+ * Configures the built-in quick-filter search box (enabled via
+ * `enableQuickFilter`).
+ */
+export declare interface QuickFilterOptions {
+    /**
+     * Placeholder text for the search input. Falls back to the localized
+     * `quickFilterPlaceholder` message when omitted.
+     */
+    readonly placeholder?: string;
+    /**
+     * Task string fields matched against the query. @default ['name']
+     */
+    readonly fields?: ReadonlyArray<keyof Task | string>;
+    /**
+     * Match case-sensitively. @default false
+     */
+    readonly caseSensitive?: boolean;
+}
+
+declare namespace renderers {
+    export {
         avatars,
         AvatarsRendererOptions,
         progressRing,
         ProgressRingRendererOptions
     }
 }
+export { renderers }
 
 /**
  * Detail payload for the `selectionChange` event.
@@ -2182,6 +2999,33 @@ declare interface SelectionOptions {
 
 export declare type SnapUnit = 'day' | 'hour' | 'minute';
 
+/**
+ * Detail for the `sortChange` event, fired when the active sort changes via
+ * `gantt.sort()` / `gantt.clearSort()` or a column-header click.
+ */
+export declare interface SortChangeEventDetail {
+    /** Active sort criteria after the change. Empty array = natural (input) order. */
+    criteria: ReadonlyArray<{
+        key: string;
+        direction: 'asc' | 'desc';
+    }>;
+    timestamp: number;
+}
+
+/**
+ * A single sort key: which column to sort by and in which direction.
+ * Multiple criteria sort by the first key, breaking ties with the next.
+ */
+export declare interface SortCriterion {
+    /** Column key to sort by (a `ColumnKey` or a custom column id). */
+    readonly key: ColumnKey | string;
+    /** Sort direction. @default 'asc' */
+    readonly direction?: SortDirection;
+}
+
+/** Sort direction for a {@link SortCriterion}. */
+export declare type SortDirection = 'asc' | 'desc';
+
 /**
  * Resolved task object used internally and returned from selection/event APIs.
  *
@@ -2201,6 +3045,16 @@ export declare interface Task extends TaskInput {
      * tree changes; render via the `ColumnKey.Wbs` column or read directly.
      */
     readonly wbs?: string;
+    /**
+     * Comma-separated references to this task's predecessors (the tasks it depends
+     * on), by WBS code with a non-`FS` type and non-zero lag suffix (e.g.
+     * `'1.2, 3SS+2d'`). Derived by `DataManager` from the dependency list and
+     * refreshed whenever the tree, sort, or dependencies change. Render via the
+     * `ColumnKey.Predecessors` column.
+     */
+    readonly predecessors?: string;
+    /** Comma-separated references to this task's successors (tasks that depend on it); see {@link predecessors}. */
+    readonly successors?: string;
     /** Resolved progress value (0–100). Always present; defaults to `0`. */
     readonly progress: number;
     /** Resolved task type. Always present; defaults to `TaskType.Task`. */
@@ -2219,6 +3073,19 @@ export declare interface Task extends TaskInput {
      * when `showSummaryBar` is `true`; equals the latest `endTime` among all descendants.
      */
     readonly summaryEnd?: string;
+    /**
+     * View-only flag marking a synthetic group-header row produced while grouping
+     * is active (`gantt.groupBy(...)`). Group headers are never stored in the data
+     * model — they exist only in the flat render list — so real-task queries,
+     * selection, and dependencies never see them.
+     */
+    readonly isGroup?: boolean;
+    /** Stable key of the group this header represents (group rows only). */
+    readonly groupKey?: string;
+    /** Display label for the group header (group rows only). */
+    readonly groupLabel?: string;
+    /** Number of member tasks in the group (group rows only). */
+    readonly groupCount?: number;
 }
 
 /**
@@ -2235,6 +3102,12 @@ export declare interface TaskAddedEventDetail {
     timestamp: number;
 }
 
+/**
+ * Comparator over two tasks returning negative / zero / positive (ascending).
+ * Used by `ColumnListItem.comparator` and internally by the sort engine.
+ */
+export declare type TaskComparator = (a: Task, b: Task) => number;
+
 /**
  * Detail payload for the `taskDeleted` event.
  *
@@ -2301,6 +3174,13 @@ export declare interface TaskDraggedEventDetail {
     timestamp: number;
 }
 
+/**
+ * Predicate deciding whether a task matches an active filter. A task is kept
+ * when it matches OR has a descendant that matches (ancestors of matches stay
+ * visible so the tree context is preserved).
+ */
+export declare type TaskFilterPredicate = (task: Task) => boolean;
+
 /**
  * Raw task data shape passed to `new ApexGantt()` via `GanttUserOptions.series`
  * or to `DataParser.parse()`.
@@ -2391,6 +3271,14 @@ export declare interface TaskInput {
      * column is configured via `columnConfig`.
      */
     readonly assignees?: readonly Assignee[];
+    /**
+     * Worked spans of a split task. When two or more are provided, the task
+     * renders as separate bar pieces with gaps between them, and its
+     * `startTime`/`endTime` are derived from the segments (first start → last end).
+     * Omit (or provide fewer than two) for a normal contiguous task.
+     * Split a task at runtime via `gantt.splitTask()`.
+     */
+    readonly segments?: readonly TaskSegment[];
 }
 
 /**
@@ -2438,6 +3326,22 @@ export declare interface TaskResizedEventDetail {
     timestamp: number;
 }
 
+/**
+ * One worked span of a split task. A task with two or more `segments` renders as
+ * separate bar pieces with gaps between them (e.g. work Mon–Wed, pause, resume
+ * Fri). Dates are strings parsed with `GanttUserOptions.inputDateFormat`.
+ *
+ * The task's own `startTime`/`endTime` remain the overall envelope (first
+ * segment start → last segment end) and are derived automatically from the
+ * segments, so summary rollups, dependencies, and the timeline all keep working.
+ */
+export declare interface TaskSegment {
+    /** Start date of this worked span. */
+    readonly start: string;
+    /** End date of this worked span. */
+    readonly end: string;
+}
+
 /**
  * Discriminates how a task is rendered in the timeline.
  *
@@ -2574,6 +3478,20 @@ export declare type ToolbarItem = ToolbarButton | ToolbarSelect | ToolbarSeparat
 
 declare interface ToolbarOptions {
     readonly toolbarItems: ToolbarItem[];
+    /**
+     * Show a built-in quick-filter search box in the toolbar. As the user types,
+     * the task list is filtered to rows whose configured fields contain the
+     * query (ancestors of matches stay visible). Drives the same view-only filter
+     * as `gantt.filter()`. @default false
+     */
+    readonly enableQuickFilter: boolean;
+    /** Fine-tunes the built-in quick-filter search box. See {@link QuickFilterOptions}. */
+    readonly quickFilter?: QuickFilterOptions;
+    /**
+     * Show the built-in advanced filter builder (a "Filter" toolbar button that
+     * opens a rule-composer popover). @default false
+     */
+    readonly enableFilterBuilder: boolean;
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apexgantt",
-  "version": "3.14.0",
+  "version": "3.14.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/apexcharts/apexgantt"