@cqa-lib/cqa-ui 1.1.525 → 1.1.526

package/lib/assets/images/image-assets.constants.d.ts

@@ -17,5 +17,6 @@ export declare const EMPTY_STATE_IMAGES: {
     readonly ANALYTICS_CHART: "assets/images/ReportsIcon.png";
     readonly DEFAULT: "assets/images/SearchIcon.png";
     readonly COMPARE_RUNS: "assets/images/CompareRunsIcon.png";
+    readonly EMPTY_FOLDER_STATE: "assets/images/EmptyFolderState.png";
 };
 export declare type EmptyStateImageKey = keyof typeof EMPTY_STATE_IMAGES;

package/lib/segment-control/segment-control.component.d.ts

@@ -18,6 +18,7 @@ export declare class SegmentControlComponent implements OnChanges, AfterViewInit
     containerBgColor: string;
     /** When true, the control stretches to fill its parent and buttons share equal width. */
     fullWidth: boolean;
+    size: 'md' | 'lg';
     get hostDisplay(): string;
     get hostWidth(): string;
     valueChange: EventEmitter<string>;
@@ -47,6 +48,6 @@ export declare class SegmentControlComponent implements OnChanges, AfterViewInit
     private updateIndicator;
     get isIndicatorVisible(): boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<SegmentControlComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<SegmentControlComponent, "cqa-segment-control", never, { "segments": "segments"; "value": "value"; "disabled": "disabled"; "containerBgColor": "containerBgColor"; "fullWidth": "fullWidth"; }, { "valueChange": "valueChange"; }, never, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SegmentControlComponent, "cqa-segment-control", never, { "segments": "segments"; "value": "value"; "disabled": "disabled"; "containerBgColor": "containerBgColor"; "fullWidth": "fullWidth"; "size": "size"; }, { "valueChange": "valueChange"; }, never, never>;
 }
 export {};

package/lib/table/dynamic-table/dynamic-table.component.d.ts

@@ -1,5 +1,6 @@
 import { QueryList, TemplateRef, EventEmitter, ViewContainerRef, Type, OnDestroy, ChangeDetectorRef, OnChanges, SimpleChanges } from "@angular/core";
 import { DomSanitizer, SafeHtml } from "@angular/platform-browser";
+import { DndDropEvent } from "ngx-drag-drop";
 import { DynamicCellTemplateDirective, DynamicHeaderTemplateDirective } from "./dynamic-cell.directive";
 import { ComponentRenderConfig } from "./component-render-config.interface";
 import * as i0 from "@angular/core";
@@ -60,6 +61,30 @@ export declare class DynamicTableComponent implements OnDestroy, OnChanges {
         path: string;
         source: string;
     }) => void;
+    /**
+     * When true, renders a drag-handle column as the leftmost cell and enables
+     * row drag-and-drop reordering via ngx-drag-drop. Off by default so existing
+     * consumers are unaffected.
+     */
+    enableRowReorder: boolean;
+    /** Tooltip for the drag handle icon. */
+    reorderHandleTooltip: string;
+    /**
+     * Emitted after a successful row drop. `orderedData` is a freshly allocated
+     * array reflecting the new order — parents should assign it back to `[data]`
+     * rather than relying on in-place mutation.
+     */
+    rowReorder: EventEmitter<{
+        previousIndex: number;
+        currentIndex: number;
+        orderedData: any[];
+    }>;
+    /** Index of the row the cursor is currently hovering during a reorder drag. */
+    dropHoverIndex: number | null;
+    /** Whether the cursor is in the top or bottom half of the hovered row. */
+    dropPosition: 'above' | 'below' | null;
+    /** The row currently being dragged — used to suppress the indicator on the source row. */
+    private draggedRow;
     cellTemplates: QueryList<DynamicCellTemplateDirective>;
     headerTemplates: QueryList<DynamicHeaderTemplateDirective>;
     emptyTableTpl?: TemplateRef<any>;
@@ -122,6 +147,23 @@ export declare class DynamicTableComponent implements OnDestroy, OnChanges {
     getSanitizedHtml(value: string): SafeHtml;
     getCellValue(row: any, path?: string): any;
     trackByIndex(index: number): number;
+    onRowDragStart(row: any): void;
+    onRowDragEnd(): void;
+    /**
+     * Fires continuously while a drag is over a row. Computes whether the cursor
+     * is in the top or bottom half of the row and updates the indicator state.
+     * Suppresses the indicator on the dragged row itself.
+     */
+    onRowDragOver(event: Event, rowIndex: number): void;
+    /** Clears the indicator when the cursor leaves the tbody entirely. */
+    onTbodyDragLeave(event: Event): void;
+    private clearDropIndicator;
+    /**
+     * Handles a row drop from ngx-drag-drop. Prefers the tracked dragover position
+     * (which the user can see live via the insertion line) over `event.index` when
+     * computing the final insert slot. Emits a fresh array — does not mutate `data`.
+     */
+    onRowDndDrop(event: DndDropEvent): void;
     copyCellJsonPath(path: string, event: Event, source?: string): void;
     private updateGridTemplate;
     isRowSelectable(row: any): boolean;
@@ -141,5 +183,5 @@ export declare class DynamicTableComponent implements OnDestroy, OnChanges {
     toggleSort(col: DynamicTableColumn): void;
     private compareValues;
     static ɵfac: i0.ɵɵFactoryDeclaration<DynamicTableComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicTableComponent, "app-dynamic-table", never, { "data": "data"; "columns": "columns"; "emptyState": "emptyState"; "gridTemplateColumns": "gridTemplateColumns"; "screenWidth": "screenWidth"; "enableSelectAll": "enableSelectAll"; "rowSelectable": "rowSelectable"; "enableLocalSort": "enableLocalSort"; "isTableLoading": "isTableLoading"; "isTableDataLoading": "isTableDataLoading"; "cellJsonPathGetter": "cellJsonPathGetter"; "onJsonPathCopiedHandler": "onJsonPathCopiedHandler"; }, { "sortChange": "sortChange"; }, ["emptyTableTpl", "cellTemplates", "headerTemplates"], never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicTableComponent, "app-dynamic-table", never, { "data": "data"; "columns": "columns"; "emptyState": "emptyState"; "gridTemplateColumns": "gridTemplateColumns"; "screenWidth": "screenWidth"; "enableSelectAll": "enableSelectAll"; "rowSelectable": "rowSelectable"; "enableLocalSort": "enableLocalSort"; "isTableLoading": "isTableLoading"; "isTableDataLoading": "isTableDataLoading"; "cellJsonPathGetter": "cellJsonPathGetter"; "onJsonPathCopiedHandler": "onJsonPathCopiedHandler"; "enableRowReorder": "enableRowReorder"; "reorderHandleTooltip": "reorderHandleTooltip"; }, { "sortChange": "sortChange"; "rowReorder": "rowReorder"; }, ["emptyTableTpl", "cellTemplates", "headerTemplates"], never>;
 }

package/lib/templates/modular-table-template/dialogs/delete-folder-dialog.component.d.ts

@@ -0,0 +1,34 @@
+import { ChangeDetectorRef, EventEmitter, OnChanges, OnInit, SimpleChanges } from '@angular/core';
+import { FolderDeleteStrategy, ModularLabels } from '../modular-table-template.models';
+import * as i0 from "@angular/core";
+/**
+ * Body of the "Delete folder" dialog — a radio-card picker for what happens to
+ * the folder's contained test cases.
+ *
+ * Designed to be usable two ways:
+ *
+ *  1. **From within this library** via `DialogService.open(...)`. The outer
+ *     `cqa-dialog` supplies the title/Cancel/Delete-folder buttons; the Delete
+ *     button reads `strategy` via `getComponentInstance()`.
+ *
+ *  2. **From the host/UI layer directly** — hosts render this inside their own
+ *     modal and observe `(strategyChange)`.
+ */
+export declare class DeleteFolderDialogComponent implements OnInit, OnChanges {
+    private cdr;
+    folderName: string;
+    testCount: number;
+    hasParent: boolean;
+    labels: ModularLabels;
+    strategy: FolderDeleteStrategy;
+    strategyChange: EventEmitter<FolderDeleteStrategy>;
+    constructor(cdr: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    /** If the folder has no parent, the "move to parent" option isn't available — fall back. */
+    private normaliseStrategy;
+    get bodyText(): string;
+    setStrategy(value: FolderDeleteStrategy): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DeleteFolderDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DeleteFolderDialogComponent, "cqa-delete-folder-dialog", never, { "folderName": "folderName"; "testCount": "testCount"; "hasParent": "hasParent"; "labels": "labels"; "strategy": "strategy"; }, { "strategyChange": "strategyChange"; }, never, never>;
+}

package/lib/templates/modular-table-template/dialogs/move-to-folder-dialog.component.d.ts

@@ -0,0 +1,57 @@
+import { ChangeDetectorRef, EventEmitter, OnChanges, OnInit, SimpleChanges } from '@angular/core';
+import { FolderNode, ModularLabels } from '../modular-table-template.models';
+import * as i0 from "@angular/core";
+interface FlatFolderRow {
+    id: number | null;
+    name: string;
+    depth: number;
+    disabled: boolean;
+    hasChildren: boolean;
+    expanded: boolean;
+}
+/**
+ * Folder-picker body used inside the Move-to-Folder dialog.
+ *
+ * This component is designed to be usable two ways:
+ *
+ *  1. **From inside the library** via `DialogService.open({ content: { type: 'component', component: MoveToFolderDialogComponent, inputs: {...} } })`.
+ *     The outer `cqa-dialog` provides the title, description, Cancel and "Move here"
+ *     buttons; the Move button reads `pickedFolderId` via `dialogRef.getComponentInstance()`.
+ *
+ *  2. **From the host/UI layer directly** once API ownership moves up. The host
+ *     renders `<cqa-move-to-folder-dialog>` inside its own modal shell and
+ *     listens to `(folderPicked)` (fires on every pick) to drive its own "Move here"
+ *     button. All visual state lives on `pickedFolderId` so hosts can also two-way
+ *     bind if they prefer.
+ */
+export declare class MoveToFolderDialogComponent implements OnInit, OnChanges {
+    private cdr;
+    /** Folder tree to pick from. */
+    folders: FolderNode[];
+    /** Label overrides. */
+    labels: ModularLabels;
+    /** The folder the tests currently live in — rendered as disabled (can't move into itself). */
+    currentFolderId: number | null;
+    /** Controls which folder is visually selected. Two-way-bind friendly via `pickedFolderIdChange`. */
+    pickedFolderId: number | null;
+    /** Folder ids to expand by default. If not provided, ancestors of `currentFolderId` are expanded. */
+    initialExpandedIds?: number[];
+    /** Fires whenever the user picks a destination. */
+    folderPicked: EventEmitter<number>;
+    /** Companion output for banana-in-the-box `[(pickedFolderId)]` binding. */
+    pickedFolderIdChange: EventEmitter<number>;
+    private expandedIds;
+    constructor(cdr: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private seedExpandedIds;
+    private collectAncestors;
+    get flatRows(): FlatFolderRow[];
+    isPicked(id: number | null): boolean;
+    pick(id: number | null): void;
+    toggleExpanded(id: number, event: Event): void;
+    trackById: (_: number, row: FlatFolderRow) => number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MoveToFolderDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MoveToFolderDialogComponent, "cqa-move-to-folder-dialog", never, { "folders": "folders"; "labels": "labels"; "currentFolderId": "currentFolderId"; "pickedFolderId": "pickedFolderId"; "initialExpandedIds": "initialExpandedIds"; }, { "folderPicked": "folderPicked"; "pickedFolderIdChange": "pickedFolderIdChange"; }, never, never>;
+}
+export {};

package/lib/templates/modular-table-template/dialogs/new-folder-dialog.component.d.ts

@@ -0,0 +1,79 @@
+import { ChangeDetectorRef, EventEmitter, OnInit } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { DynamicSelectFieldConfig } from '../../../dynamic-select/dynamic-select-field.component';
+import { FolderNode, ModularLabels } from '../modular-table-template.models';
+import * as i0 from "@angular/core";
+export declare const DEFAULT_FOLDER_COLOR = "#99999E";
+/**
+ * Body of the "New Folder" dialog.
+ *
+ * Uses reusable library components (`cqa-custom-input` for the name field,
+ * `cqa-dynamic-select` for the parent dropdown) so hosts can drop this dialog
+ * into their own modal shell without worrying about styling drift.
+ *
+ * Two integration paths:
+ *
+ *  1. **From within this library** via `DialogService.open(...)`. The outer
+ *     `cqa-dialog` supplies title/description/Cancel/Create-folder buttons; the
+ *     Create button reads `name` + `parentId` via `getComponentInstance()`.
+ *
+ *  2. **Host-driven** — host renders `<cqa-new-folder-dialog>` inside its own
+ *     modal and listens to `(submitted)` / `(cancelled)` / `(nameChange)` /
+ *     `(parentIdChange)`.
+ */
+export declare class NewFolderDialogComponent implements OnInit {
+    private cdr;
+    private _folders;
+    set folders(value: FolderNode[]);
+    get folders(): FolderNode[];
+    private _labels;
+    set labels(value: ModularLabels);
+    get labels(): ModularLabels;
+    name: string;
+    private _parentId;
+    set parentId(value: number | null);
+    get parentId(): number | null;
+    color: string;
+    readonly presetColors: string[];
+    readonly rainbowBorder: string;
+    nameChange: EventEmitter<string>;
+    parentIdChange: EventEmitter<number>;
+    colorChange: EventEmitter<string>;
+    submitted: EventEmitter<{
+        name: string;
+        parentId: number | null;
+        color: string;
+    }>;
+    cancelled: EventEmitter<void>;
+    /** Reactive form used by cqa-dynamic-select. Untyped to match the project's Angular 13.4 forms API. */
+    parentForm: FormGroup;
+    /**
+     * Config passed to `cqa-dynamic-select`. Stored as a field (not a getter) so
+     * the object reference is stable across change-detection passes — a getter
+     * returns a fresh object every CD tick and causes
+     * `ExpressionChangedAfterItHasBeenCheckedError` + repeated `ngOnChanges` on
+     * the child select. Other consumers in this lib (e.g. `loop-step`) follow
+     * the same pattern.
+     */
+    parentSelectConfig: DynamicSelectFieldConfig;
+    private parentOptions;
+    constructor(cdr: ChangeDetectorRef);
+    ngOnInit(): void;
+    private rebuildSelectConfig;
+    private rebuildOptions;
+    private syncParentControl;
+    onNameChange(value: string): void;
+    onParentSelectionChange(event: {
+        key: string;
+        value: any;
+    }): void;
+    isColor(c: string): boolean;
+    get isCustomColor(): boolean;
+    onColorChange(value: string): void;
+    onColorInputEvent(event: Event): void;
+    /** Returns true when the current state is a valid submission (non-empty, trimmed name). */
+    get isValid(): boolean;
+    submit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NewFolderDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NewFolderDialogComponent, "cqa-new-folder-dialog", never, { "folders": "folders"; "labels": "labels"; "name": "name"; "parentId": "parentId"; "color": "color"; }, { "nameChange": "nameChange"; "parentIdChange": "parentIdChange"; "colorChange": "colorChange"; "submitted": "submitted"; "cancelled": "cancelled"; }, never, never>;
+}

package/lib/templates/modular-table-template/directives/folder-drag.directive.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+export declare class FolderDragDirective {
+    /** Folder id being dragged. */
+    folderId: number | null;
+    dragEnabled: boolean;
+    get draggable(): string;
+    onDragStart(event: DragEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FolderDragDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FolderDragDirective, "[cqaFolderDrag]", never, { "folderId": "cqaFolderDrag"; "dragEnabled": "dragEnabled"; }, {}, never>;
+}

package/lib/templates/modular-table-template/directives/folder-drop.directive.d.ts

@@ -0,0 +1,22 @@
+import { EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class FolderDropDirective {
+    /** Folder id this drop target represents. `null` means "unorganised / root". */
+    targetFolderId: number | null;
+    dropEnabled: boolean;
+    testsDropped: EventEmitter<{
+        testIds: Array<string | number>;
+        targetFolderId: number | null;
+    }>;
+    /** Fires when a folder row is dropped here. `folderId` is the dragged folder's id. */
+    folderDropped: EventEmitter<{
+        folderId: number;
+        targetFolderId: number | null;
+    }>;
+    isOver: boolean;
+    onDragOver(event: DragEvent): void;
+    onDragLeave(): void;
+    onDrop(event: DragEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FolderDropDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FolderDropDirective, "[cqaFolderDrop]", never, { "targetFolderId": "cqaFolderDrop"; "dropEnabled": "dropEnabled"; }, { "testsDropped": "testsDropped"; "folderDropped": "folderDropped"; }, never>;
+}

package/lib/templates/modular-table-template/directives/row-drag.directive.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+export declare class RowDragDirective {
+    /** Function that returns the test id payload for this row (array of ids). */
+    buildPayload: () => Array<string | number>;
+    dragEnabled: boolean;
+    get draggable(): string;
+    onDragStart(event: DragEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RowDragDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RowDragDirective, "[cqaRowDrag]", never, { "buildPayload": "cqaRowDrag"; "dragEnabled": "dragEnabled"; }, {}, never>;
+}

package/lib/templates/modular-table-template/folder-sidebar/folder-sidebar.component.d.ts

@@ -0,0 +1,149 @@
+import { ChangeDetectorRef, EventEmitter, OnDestroy } from '@angular/core';
+import { FolderNode, FolderRenamedPayload, ModularLabels } from '../modular-table-template.models';
+import * as i0 from "@angular/core";
+interface RenderNode {
+    node: FolderNode;
+    depth: number;
+    visible: boolean;
+    hasChildren: boolean;
+}
+export declare class FolderSidebarComponent implements OnDestroy {
+    private cdr;
+    folders: FolderNode[];
+    selectedFolderId: number | null;
+    expandedFolderIds: number[];
+    unorganisedCount: number;
+    allowCreate: boolean;
+    allowRename: boolean;
+    allowDelete: boolean;
+    allowMove: boolean;
+    allowDuplicate: boolean;
+    allowDrop: boolean;
+    showCounts: boolean;
+    collapsed: boolean;
+    labels: ModularLabels;
+    folderSelected: EventEmitter<number>;
+    folderExpansionToggled: EventEmitter<{
+        id: number;
+        expanded: boolean;
+    }>;
+    /** Emitted after the host completes folder creation (e.g., inline rename flow). Reserved for future use. */
+    folderCreated: EventEmitter<{
+        parentId: number | null;
+        name: string;
+    }>;
+    /** Emitted when the user clicks the "+" header button. Host should open a creation modal. */
+    folderCreateRequested: EventEmitter<{
+        parentId: number | null;
+    }>;
+    /** Carries the full renamed folder node + parent id so hosts can issue complete update requests. */
+    folderRenamed: EventEmitter<FolderRenamedPayload>;
+    folderDeleted: EventEmitter<{
+        id: number;
+    }>;
+    /** User picked "Move folder" from the context menu. Host opens the folder picker. */
+    folderMoveRequested: EventEmitter<{
+        id: number;
+    }>;
+    /** User picked "Duplicate folder" from the context menu. Host clones the subtree (tests referenced, not copied). */
+    folderDuplicateRequested: EventEmitter<{
+        id: number;
+    }>;
+    testsDropped: EventEmitter<{
+        testIds: Array<string | number>;
+        targetFolderId: number | null;
+    }>;
+    /** Fires when a folder row is dropped onto another folder (or the Unorganised row). */
+    folderDropped: EventEmitter<{
+        id: number;
+        newParentId: number | null;
+    }>;
+    collapsedChange: EventEmitter<boolean>;
+    searchValue: string;
+    renamingId: number | null;
+    renameDraft: string;
+    /** Id of the folder whose context menu is open, or null when closed. */
+    contextMenuFolderId: number | null;
+    /** Viewport-anchored position (client coordinates) for the floating menu. */
+    contextMenuPosition: {
+        x: number;
+        y: number;
+    };
+    /** Pending auto-expand timers while a folder drag is hovered over collapsed rows. */
+    private dragExpandTimers;
+    private readonly DRAG_EXPAND_DELAY_MS;
+    /** Id of the folder currently being dragged; used to skip cycle targets and source-hover expansion. */
+    private activeFolderDragId;
+    constructor(cdr: ChangeDetectorRef);
+    get expandedSet(): Set<number>;
+    /** Flattened, depth-aware list of rows to render in order. Ancestors of matches are kept. */
+    get rows(): RenderNode[];
+    isExpanded(id: number): boolean;
+    isSelected(id: number | null): boolean;
+    onToggle(n: FolderNode, event: Event): void;
+    onSelect(n: FolderNode | null): void;
+    onSelectUnorganised(): void;
+    beginRename(n: FolderNode, event: Event): void;
+    commitRename(n: FolderNode): void;
+    cancelRename(): void;
+    onRenameKey(event: KeyboardEvent, n: FolderNode): void;
+    deleteFolder(n: FolderNode, event: Event): void;
+    /**
+     * Opens the folder context menu anchored at the given client coordinates.
+     * Called from both (contextmenu) on the row and (click) on the ellipsis button.
+     * Menu visibility is clamped in the template via CSS transforms so it never leaves the viewport.
+     */
+    openContextMenu(n: FolderNode, event: MouseEvent): void;
+    closeContextMenu(): void;
+    /** True when at least one menu entry is enabled — otherwise the trigger is suppressed entirely. */
+    get hasAnyContextAction(): boolean;
+    onContextCreateSubfolder(n: FolderNode): void;
+    onContextRename(n: FolderNode): void;
+    onContextMove(n: FolderNode): void;
+    onContextDuplicate(n: FolderNode): void;
+    onContextDelete(n: FolderNode): void;
+    onDocumentClick(): void;
+    onEscape(): void;
+    /** Template helper: resolve a folder node by id from the input tree. */
+    folderById(id: number | null): FolderNode | null;
+    /** Returns the parent id of `id`, or null when `id` is a root folder / not found. */
+    private parentIdOf;
+    requestCreate(parentId?: number | null): void;
+    togglePanel(): void;
+    rowDropped(targetId: number | null, event: {
+        testIds: Array<string | number>;
+        targetFolderId: number | null;
+    }): void;
+    /**
+     * Drop target received a folder drag. Validate against self/descendant cycles and
+     * emit `folderDropped` if the move is legal. Called from the directive's
+     * `(folderDropped)` output on every row and on the Unorganised row.
+     */
+    onFolderRowDropped(targetId: number | null, event: {
+        folderId: number;
+        targetFolderId: number | null;
+    }): void;
+    /** Remember the dragged folder so we can block self-hover expansion and cycle drops. */
+    onFolderDragStart(n: FolderNode): void;
+    onFolderDragEnd(): void;
+    /** Schedule an auto-expand for a collapsed folder that has children during drag-hover. */
+    onFolderRowDragOver(row: RenderNode): void;
+    onFolderRowDragLeave(row: RenderNode): void;
+    onDocumentDragEnd(): void;
+    /** True when `candidateId` is `sourceId` itself or any descendant of it. */
+    private isDescendantOf;
+    private clearAllExpandTimers;
+    ngOnDestroy(): void;
+    trackByRow: (_: number, row: RenderNode) => number;
+    onRowKeydown(event: KeyboardEvent, row: RenderNode, index: number): void;
+    private focusRowElement;
+    /**
+     * Focuses the inline rename input for the given folder. Uses `setTimeout` (not
+     * microtask) because the input is gated by `*ngIf="renamingId === ..."` and
+     * must survive the next OnPush change-detection cycle before it's in the DOM.
+     */
+    private focusRenameInput;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FolderSidebarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FolderSidebarComponent, "cqa-folder-sidebar", never, { "folders": "folders"; "selectedFolderId": "selectedFolderId"; "expandedFolderIds": "expandedFolderIds"; "unorganisedCount": "unorganisedCount"; "allowCreate": "allowCreate"; "allowRename": "allowRename"; "allowDelete": "allowDelete"; "allowMove": "allowMove"; "allowDuplicate": "allowDuplicate"; "allowDrop": "allowDrop"; "showCounts": "showCounts"; "collapsed": "collapsed"; "labels": "labels"; }, { "folderSelected": "folderSelected"; "folderExpansionToggled": "folderExpansionToggled"; "folderCreated": "folderCreated"; "folderCreateRequested": "folderCreateRequested"; "folderRenamed": "folderRenamed"; "folderDeleted": "folderDeleted"; "folderMoveRequested": "folderMoveRequested"; "folderDuplicateRequested": "folderDuplicateRequested"; "testsDropped": "testsDropped"; "folderDropped": "folderDropped"; "collapsedChange": "collapsedChange"; }, never, never>;
+}
+export {};