import{type TemplateResult,type PropertyValues}from'lit';import{LyraElement}from'../../../internal/lyra-element.js';export type GitStatus='added'|'modified'|'deleted'|'renamed'|'untracked'|'conflicted'|'ignored';export interface FileTreeNode{readonly path:string;readonly name?:string;readonly kind?:'file'|'directory';readonly mimeType?:string;readonly gitStatus?:GitStatus;readonly additions?:number;readonly deletions?:number;readonly children?:readonly FileTreeNode[];readonly hasChildren?:boolean;}export declare const GIT_STATUSES:ReadonlySet<GitStatus>;export interface LyraFileTreeEventMap{'lr-file-select':CustomEvent<Readonly<{filePath:string;node:FileTreeNode;}>>;'lr-file-open':CustomEvent<Readonly<{filePath:string;node:FileTreeNode;}>>;'lr-load-children':CustomEvent<Readonly<{filePath:string;}>>;}
/**
* `<lr-file-tree>` — a file-explorer preset over `<lr-tree>` + `<lr-file-icon>`: path-keyed
* nodes with git-status/diff-count badges, lazy directory loading, and select/open events.
*
* **The composed `<lr-tree>`'s `reorderable`/`lr-reorder` capability is deliberately not
* forwarded.** The tree it renders is not a model this component owns: `treeItems` is derived
* from `nodes` on every render and keyed by filesystem path, so sibling order is whatever the
* host's own listing produced (name, type, git status), not an authored sequence a user can
* rearrange. `<lr-tree>`'s reorder is also strictly sibling-scoped — it never crosses a subtree
* boundary, precisely so a reorder can never become a reparent — which is the one file operation
* ("move this file into that directory") that would change a path and therefore mean something
* here. Forwarding it would have to invent a second, path-shaped event alongside
* `lr-file-select`/`lr-file-open`/`lr-load-children`, permanently, for a gesture whose result the
* host would have to discard. A consumer that genuinely needs orderable rows composes `<lr-tree>`
* directly, where the capability already lives.
*
* @customElement lr-file-tree
* @event lr-file-select - `detail: { filePath, node }` — a row was activated.
* @event lr-file-open - `detail: { filePath, node }` — Enter/click on an already-selected file row
*   (keyboard-open parity: a second activation of the same file opens it).
* @event lr-load-children - `detail: { filePath }` — a lazy (hasChildren, unloaded) directory expanded.
* @csspart base - The root wrapper.
* @status stable
* @since 4.0.0
*/
export declare class LyraFileTree extends LyraElement<LyraFileTreeEventMap>{static styles:import("lit").CSSResultGroup[];private _nodes;
/** Clone-owned, cycle-safe readonly node snapshot. Empty/blank paths are omitted and duplicate
* paths use the first valid node; projection inspects at most 10,000 source positions across 64
* descendant levels. An unreadable optional field rejects only its node, without reserving the
* path against a later valid occurrence. Reassign after changes. */
get nodes():readonly FileTreeNode[];set nodes(value:readonly FileTreeNode[]);selectedPath:string|null;
/** Accessible-name override for the internal `<lr-tree>`; falls back to the localized default
*  when unset. An explicitly empty string renders as an empty label rather than falling back. */
label?:string;private nodesByPath;private parentPathByPath;protected willUpdate(changed:PropertyValues):void;private toTreeItem;private get treeItems();private onNodeSelect;private onNodeToggle;
/** Fulfills a lazy directory's children in place. Expansion state survives because `<lr-tree>`
*  reconciles top-level items by id and each `<lr-tree-item>` keeps its own `expanded` state. */
setChildren(path:string,children:readonly FileTreeNode[]):void;private ancestorChain;
/** Expands every ancestor of `path` and focuses its row. Resolves `false` when `path` isn't
*  present in `nodes` (including a still-unloaded lazy descendant). */
revealPath(path:string):Promise<boolean>;expandAll():Promise<void> |void;collapseAll():void;render():TemplateResult;}declare global{interface HTMLElementTagNameMap{'lr-file-tree':LyraFileTree;}}