@truenas/ui-components 0.7.3 → 0.7.5

package/types/truenas-ui-components.d.ts

@@ -2,12 +2,12 @@ import * as _truenas_ui_components from '@truenas/ui-components';
 import * as _angular_core from '@angular/core';
 import { Signal, InjectionToken, Renderer2, OnDestroy, ElementRef, AfterViewInit, TemplateRef, AfterContentInit, Provider, DoCheck, ChangeDetectorRef, OnInit, TrackByFunction, OnChanges, SimpleChanges, PipeTransform, ViewContainerRef, AfterViewChecked, ComponentRef } from '@angular/core';
 import { ControlValueAccessor, NgControl, AbstractControl, ValidationErrors } from '@angular/forms';
+import * as rxjs from 'rxjs';
+import { Observable, BehaviorSubject } from 'rxjs';
 import { ComponentHarness, BaseHarnessFilters, HarnessPredicate, TestKey, HarnessLoader, ModifierKeys as ModifierKeys$1 } from '@angular/cdk/testing';
 import { SafeHtml, SafeResourceUrl, DomSanitizer } from '@angular/platform-browser';
 import { ComponentFixture } from '@angular/core/testing';
 import { SelectionModel, DataSource, CollectionViewer } from '@angular/cdk/collections';
-import * as rxjs from 'rxjs';
-import { Observable, BehaviorSubject } from 'rxjs';
 import * as i1 from '@angular/cdk/tree';
 import { CdkTree, CdkTreeNode, CdkNestedTreeNode, CdkTreeNodeOutletContext, CdkTreeNodeDef } from '@angular/cdk/tree';
 export { FlatTreeControl } from '@angular/cdk/tree';
@@ -575,6 +575,129 @@ declare class TnSelectComponent<T = unknown> implements ControlValueAccessor, On
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnSelectComponent<any>, "tn-select", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "optionGroups": { "alias": "optionGroups"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "noOptionsLabel": { "alias": "noOptionsLabel"; "required": false; "isSignal": true; }; "allowEmpty": { "alias": "allowEmpty"; "required": false; "isSignal": true; }; "emptyLabel": { "alias": "emptyLabel"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "showSelectAll": { "alias": "showSelectAll"; "required": false; "isSignal": true; }; "selectAllLabel": { "alias": "selectAllLabel"; "required": false; "isSignal": true; }; "testId": { "alias": "testId"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "optionTestIdKey": { "alias": "optionTestIdKey"; "required": false; "isSignal": true; }; "compareWith": { "alias": "compareWith"; "required": false; "isSignal": true; }; }, { "selectionChange": "selectionChange"; "multiSelectionChange": "multiSelectionChange"; }, never, never, true, never>;
 }
 
+/**
+ * Fetches one page of options for a server-driven dropdown.
+ *
+ * Stateless on purpose: the page number is passed in rather than held by the
+ * caller, so a source is a plain function of `(query, page)` and never has to
+ * track — or roll back — a cursor of its own. {@link createTnOptionsDataSource}
+ * owns the cursor, and rolls it back for you when a page fails.
+ *
+ * `page` is zero-based; page 0 is the first page of a fresh search.
+ *
+ * Only the FIRST emission is read, and an observable that completes without
+ * emitting is treated as an empty page — both normalized by
+ * {@link createTnOptionsDataSource} rather than required of the caller, since
+ * the signature promises neither. `(q) => q ? this.api.search(q) : EMPTY` is a
+ * shape consumers reach for, and left unnormalized it wedged the `loading`
+ * latch for the life of the field: both hosts prime with `''`, so the very
+ * first open would hang a spinner over an empty panel and kill paging with it.
+ */
+type TnOptionsFetchFn<O> = (query: string, page: number) => Observable<O[]>;
+/** Inputs {@link createTnOptionsDataSource} reads. All are signals so they stay live. */
+interface TnOptionsDataSourceConfig<O> {
+    /** The fetch function, or `undefined` when the host has no async source bound. */
+    source: Signal<TnOptionsFetchFn<O> | undefined>;
+    /** Debounce applied to typing before a request goes out, in ms. */
+    debounceMs: Signal<number>;
+    /**
+     * Rows per page. Only used to detect exhaustion: a page shorter than this is
+     * the last one, after which further {@link TnOptionsDataSource.loadMore}
+     * calls are dropped instead of issuing queries that can only return `[]`.
+     */
+    pageSize: Signal<number>;
+    /** Identity of an option, used to drop duplicates when appending a page. */
+    identity: (option: O) => unknown;
+    /** Called once per failed request, so the host can surface it its own way. */
+    onError: (error: unknown) => void;
+    /**
+     * Called after every request settles, successfully or not. Hosts use this to
+     * release their own "a page is in flight" latches: a synchronous source
+     * flips {@link TnOptionsDataSource.loading} true and back within one block,
+     * so watching that signal misses the round trip entirely.
+     */
+    onSettled?: () => void;
+}
+/** The live state of a {@link createTnOptionsDataSource}. */
+interface TnOptionsDataSource<O> {
+    /** Options fetched so far for the current query, in server order. */
+    readonly options: Signal<O[]>;
+    /** Whether a request is in flight. */
+    readonly loading: Signal<boolean>;
+    /** Whether the last page came back short, i.e. there is nothing more to page in. */
+    readonly exhausted: Signal<boolean>;
+    /** Run a fresh (debounced) search, resetting paging to page 0. */
+    search(query: string): void;
+    /**
+     * Fetch page 0 for the current term immediately if nothing has been fetched
+     * yet. For click-to-open pickers, where `search` never fires until the user
+     * types. A no-op once a query has run *successfully*, so reopening the panel
+     * does not refetch — but a request that failed is retried, as it is on the
+     * `search` path.
+     */
+    prime(): void;
+    /** Append the next page. No-op while loading, when exhausted, or with no source. */
+    loadMore(): void;
+    /**
+     * Declare everything fetched so far out of date, without fetching anything.
+     *
+     * The other half of the stable-source contract. A host whose `[dataSource]`
+     * is a fixed function reading live configuration — the shape that keeps a
+     * source from being swapped out from under a search in flight — has nothing
+     * here observing that configuration, so a change to it would otherwise take
+     * effect only on the next keystroke. This is how the host says it changed.
+     *
+     * Clears {@link TnOptionsDataSource.prime}'s latch and rolls paging back to
+     * page 0, so the next `prime` refetches instead of being answered from the
+     * previous configuration's rows — and is not suppressed for repeating the
+     * term already on screen. Deliberately does NOT issue a request itself: only
+     * the host knows whether its panel is open, and a field nobody has touched
+     * should not query the server because a sibling input moved. A host with rows
+     * on screen calls `prime` straight after this.
+     */
+    refresh(): void;
+}
+/**
+ * The part of a host component (`tn-autocomplete`, `tn-chip-input`) that an
+ * outer component wrapping it drives directly.
+ *
+ * The engine is private to the host, so a composite field — one that builds the
+ * `[dataSource]` itself and binds it once — needs this to invalidate what the
+ * host has fetched when its own inputs move.
+ */
+interface TnAsyncOptionsHost {
+    /** See {@link TnOptionsDataSource.refresh}. */
+    refreshOptions(): void;
+}
+/**
+ * The stateful half of a server-driven dropdown: debounce, cancellation,
+ * paging, exhaustion, and error recovery, so a host component only has to
+ * render {@link TnOptionsDataSource.options} and forward its own events.
+ *
+ * Must be called in an injection context — it ties its subscription to the
+ * caller's {@link DestroyRef}.
+ *
+ * Notable behaviours, each of which was a bug in a hand-rolled copy of this:
+ *
+ * - **Errors never kill the stream.** `catchError` sits inside the `switchMap`,
+ *   so a failed request reports and yields an empty page while the outer
+ *   subscription survives; without that, one transient failure freezes the
+ *   field for the life of the panel.
+ * - **A failed term is retryable.** `distinctUntilChanged` treats a repeat of a
+ *   failed query as a change, so reopening a picker after an error refetches
+ *   instead of being suppressed as a duplicate.
+ * - **A failed page does not advance the cursor**, so the next scroll re-requests
+ *   the page that errored rather than stepping over those rows. The cursor
+ *   tracks the *next* page to ask for rather than the last one loaded, so page 0
+ *   rolls back like every other page instead of being silently skipped.
+ * - **A late page cannot contaminate a newer search.** Every response carries
+ *   the generation it was requested in and is dropped if a search — or a
+ *   {@link TnOptionsDataSource.refresh} — has since started. Cancellation is
+ *   not enough on its own: `refresh` invalidates without issuing a request, so
+ *   there is nothing for `switchMap` to unsubscribe the old one in favour of.
+ */
+declare function createTnOptionsDataSource<O>(config: TnOptionsDataSourceConfig<O>): TnOptionsDataSource<O>;
+
 /**
  * Option shape for `tn-autocomplete` — the `label` is displayed, the `value`
  * is committed to the form control, and a truthy `disabled` keeps the row
@@ -607,7 +730,7 @@ declare const TN_AUTOCOMPLETE_DEFAULT_LABELS: TnAutocompleteLabels;
  * Explicit input bindings on `<tn-autocomplete>` still win over these defaults.
  */
 declare const TN_AUTOCOMPLETE_LABELS: InjectionToken<TnAutocompleteLabels | Signal<TnAutocompleteLabels>>;
-declare class TnAutocompleteComponent<T = unknown> implements ControlValueAccessor, OnDestroy {
+declare class TnAutocompleteComponent<T = unknown> implements ControlValueAccessor, TnAsyncOptionsHost, OnDestroy {
     private readonly elementRef;
     private readonly overlay;
     private readonly viewContainerRef;
@@ -618,6 +741,12 @@ declare class TnAutocompleteComponent<T = unknown> implements ControlValueAccess
      * to the form control. A written value is resolved back to its option's
      * label for display — falling back to `String(value)` until the matching
      * option is available, and upgraded once an async option load lands.
+     *
+     * With a `[dataSource]` bound these are not listed in the dropdown, which is
+     * the source's, but they still NAME a value: pass the options a host already
+     * holds labels for — the ids on the record being edited — and the field
+     * reads them as names from the moment it renders, rather than as raw numbers
+     * until someone opens it.
      */
     options: _angular_core.InputSignal<TnAutocompleteOption<T>[]>;
     /**
@@ -646,9 +775,71 @@ declare class TnAutocompleteComponent<T = unknown> implements ControlValueAccess
      * exclusive with `requireSelection`, which reverts unmatched text.
      */
     allowCustomValue: _angular_core.InputSignal<boolean>;
+    /**
+     * Server-driven options: a function of `(query, page)` returning one page of
+     * matches. Binding it hands the component the whole async lifecycle —
+     * debounced search, request cancellation, the paging cursor, exhaustion,
+     * error recovery and the loading state — so a consumer no longer writes a
+     * `searchChange` → subject → `switchMap` → `options` pipeline of its own.
+     *
+     * While set, the source is the only origin of DROPDOWN rows and the
+     * client-side filter is skipped, since the server already filtered — pass an
+     * explicit `[filterFn]` to filter the fetched page on top. `[options]` stays
+     * a source of LABELS, for values the host can already name before the first
+     * page is fetched; see {@link options}.
+     *
+     * The first page is fetched when the panel first opens, not on init, so a
+     * form full of pickers issues no queries until one is actually used. Binding
+     * a source that is `undefined` at that moment is fine — the field fetches as
+     * soon as one arrives, open panel included.
+     *
+     * Swapping one source function for ANOTHER is not a signal to refetch, since
+     * a source is expected to be a stable function reading live configuration.
+     * Call {@link refreshOptions} when that configuration moves.
+     *
+     * @example
+     * ```html
+     * <tn-autocomplete [dataSource]="userOptions" [pageSize]="50" />
+     * ```
+     * ```ts
+     * userOptions: TnOptionsFetchFn<string> =
+     *   (query, page) => this.api.searchUsers(query, page * 50);
+     * ```
+     */
+    dataSource: _angular_core.InputSignal<TnOptionsFetchFn<TnAutocompleteOption<T>> | undefined>;
+    /** Debounce applied to typing before `dataSource` is queried, in ms. */
+    dataSourceDebounce: _angular_core.InputSignal<number>;
+    /**
+     * Rows `dataSource` returns per page. Used to detect exhaustion — a short
+     * page is the last one — so scrolling past the end stops querying rather
+     * than issuing requests at a growing offset that can only return nothing.
+     */
+    pageSize: _angular_core.InputSignal<number>;
+    /**
+     * A row pinned above the results that performs an action instead of
+     * selecting a value — "Add New…" and friends. It survives filtering and the
+     * `maxResults` cap, and choosing it emits {@link actionSelected} and closes
+     * the panel **without** touching the form control, so no placeholder
+     * sentinel is ever committed to the value.
+     *
+     * **Must be a stable reference.** The row is recognized by identity, so the
+     * obvious call site — `[actionOption]="{ label: 'Add ' + term, value: null }"`
+     * — builds a new object on every change-detection pass, re-firing the input,
+     * invalidating the filtered rows and marking the component dirty again. Hold
+     * it in a field, or derive it with `computed()`.
+     */
+    actionOption: _angular_core.InputSignal<TnAutocompleteOption<T> | undefined>;
+    /**
+     * Keep the committed value listed even when the page on screen does not
+     * contain it — a value sorted past the first page, or one just created that
+     * the query does not match yet. Without it such a field renders blank for a
+     * perfectly valid value. Only applies with `dataSource` bound.
+     */
+    keepSelectedOption: _angular_core.InputSignal<boolean>;
     /**
      * Show a loading row in the dropdown panel while options are being fetched.
-     * Pair with `searchChange`/`loadMore` for server-driven options.
+     * Pair with `searchChange`/`loadMore` for server-driven options. Redundant
+     * with `dataSource`, which drives this state itself; the two are OR-ed.
      */
     loading: _angular_core.InputSignal<boolean>;
     /** Text shown next to the spinner while `loading` is set. */
@@ -717,12 +908,30 @@ declare class TnAutocompleteComponent<T = unknown> implements ControlValueAccess
      * lookup is expensive.
      */
     searchChange: _angular_core.OutputEmitterRef<string>;
+    /**
+     * Emits when {@link actionOption} is chosen. No value is committed and the
+     * panel closes; the consumer runs whatever the row promises (typically
+     * opening a create form) and can then write the new value to the control.
+     */
+    actionSelected: _angular_core.OutputEmitterRef<void>;
+    /**
+     * Emits once per failed `dataSource` request. The component recovers on its
+     * own — the stream stays alive and the failed term stays retryable — so this
+     * is purely for the app to report the failure the way it reports others.
+     */
+    dataSourceError: _angular_core.OutputEmitterRef<unknown>;
     /**
      * Emits when the open dropdown is scrolled near its bottom — append the
      * next page to `options` (and use `loading` while it fetches). Suppressed
-     * until the `options` COUNT changes so a slow consumer is not spammed —
-     * which also means replacing the array with a same-length page (e.g. a
-     * fixed-size window) does not re-arm the emitter; pagination must append.
+     * until the row COUNT changes so a slow consumer is not spammed — which also
+     * means replacing the array with a same-length page (e.g. a fixed-size
+     * window) does not re-arm the emitter; pagination must append.
+     *
+     * With a `[dataSource]` bound the count read is the resolved one (the
+     * fetched pages), and the latch is also released when a request settles, so
+     * a page that FAILED does not leave scrolling dead. The output still fires
+     * either way: it is for a host paging `options` itself, so do not wire both
+     * — the source already pages, and the two together fetch each page twice.
      */
     loadMore: _angular_core.OutputEmitterRef<void>;
     /**
@@ -745,14 +954,105 @@ declare class TnAutocompleteComponent<T = unknown> implements ControlValueAccess
     protected highlightedIndex: _angular_core.WritableSignal<number>;
     /** The currently committed value (an option's `value`, or a custom-typed one) */
     private selectedValue;
+    /**
+     * Label of the option the value was chosen from, remembered so
+     * `keepSelectedOption` can re-list it with its real text after a search
+     * replaced the page it came from. Null for a programmatic write, whose
+     * label is not known until an option carrying it arrives.
+     */
+    private selectedLabel;
     /** CVA disabled state from the form */
     private formDisabled;
     /** Combined disabled state */
     isDisabled: Signal<boolean>;
-    /** Filtered and capped options */
+    /** Async engine backing `dataSource`; idle while no source is bound. */
+    private readonly asyncOptions;
+    /**
+     * The synthetic row that keeps a committed value listed while the pages
+     * fetched so far do not contain it, or `undefined`.
+     *
+     * Held separately from {@link resolvedOptions} so {@link filteredOptions} can
+     * recognize it and pin it past the `maxResults` cap, the way the action row
+     * is pinned. Appended and then sliced with everything else, a full page
+     * filled the cap and cut off the one row this exists to guarantee.
+     */
+    private readonly keptSelectedOption;
+    /**
+     * Rows the host named itself, honoured even while a `dataSource` is bound.
+     *
+     * With a source the dropdown is the server's to fill — but its first page is
+     * not fetched until the field is focused, so a value the host already holds
+     * the label for renders as its raw `String(value)` until someone opens the
+     * panel. An edit form bound to an id shows the number. `options` is how that
+     * label is supplied, so it stays part of the LOOKUP even where it is not
+     * part of the dropdown. `tn-chip-input` treats its own `options` the same
+     * way, and the asymmetry was a bug rather than a design.
+     *
+     * Reached through {@link resolvableOptions} for display and
+     * {@link matchableOptions} for matching, so `commitCustomValue` and the
+     * `requireSelection` branch of `onBlur` recognise a pinned label too.
+     * Painting from a list wider than the one it reads back is the bug this
+     * shape exists to avoid.
+     */
+    private readonly pinnedOptions;
+    /**
+     * The rows to work from: the async engine's when `dataSource` is bound,
+     * the `options` input otherwise. Everything that resolves a value to a
+     * label, matches typed text, or counts rows reads this rather than
+     * `options` — the action row is deliberately absent, since it carries no
+     * selectable value.
+     */
+    private readonly resolvedOptions;
+    /**
+     * The rows a value may be resolved to a label FROM — the fetched pages plus
+     * the host-pinned {@link pinnedOptions}, and never the synthetic kept row.
+     * {@link matchableOptions} is the other direction.
+     *
+     * That row exists to keep a committed value listed, and its label is the
+     * display text itself: `String(value)` for a value nothing has named yet.
+     * Resolving against it therefore always "succeeds", which would report the
+     * raw fallback as a resolved label and leave it on screen for good.
+     */
+    private readonly resolvableOptions;
+    /**
+     * The rows typed text may be matched BACK to a value by: every label this
+     * field puts in front of the user, so that anything it PAINTS it also READS.
+     *
+     * {@link resolvableOptions} for the labels a value can be resolved from,
+     * plus the synthetic kept row — which the two lists on either side each drop
+     * for a reason that does not apply here:
+     *
+     * - {@link resolvedOptions} omits the host-pinned rows, since the dropdown
+     *   under a source is the server's to fill. But a pinned row is exactly how a
+     *   host names a value the pages do not carry, so matching without it painted
+     *   `g-7` as `admins` and then committed the raw string `'admins'` over the
+     *   id it names. That is the asymmetry `tn-chip-input` closed by pointing
+     *   `commitText` at its `labelOptions`.
+     * - {@link resolvableOptions} omits the kept row, because resolving a VALUE
+     *   against it always "succeeds" and would report its `String(value)`
+     *   fallback as a real label. Matching a LABEL against it is the opposite
+     *   case: the row is listed, the user can click it, and its label may be one
+     *   remembered from the option the value was picked from. Dropping it would
+     *   turn "type the text you can see, then blur" into a free-text commit of
+     *   that text over the value it stands for.
+     *
+     * Order is the usual precedence — the server's rows, then the host's, then
+     * the synthetic one — and every reader takes the first match.
+     */
+    private readonly matchableOptions;
+    /** Loading state: the `loading` input OR-ed with the async engine's. */
+    protected readonly resolvedLoading: Signal<boolean>;
+    /** Filtered and capped options, with {@link actionOption} pinned on top. */
     protected filteredOptions: Signal<TnAutocompleteOption<T>[]>;
-    /** Whether there are any results to show */
+    /** Whether there are any rows to render (the action row counts). */
     protected hasResults: Signal<boolean>;
+    /**
+     * Whether the query matched anything selectable. Distinct from
+     * {@link hasResults} so a search that found nothing still says so, rather
+     * than being masked by a pinned action row — or by the kept-selected row,
+     * which is held on screen for the committed value regardless of the query.
+     */
+    protected hasMatches: Signal<boolean>;
     private onChange;
     private onTouched;
     /** Live overlay holding the dropdown panel, or undefined when closed. */
@@ -767,18 +1067,84 @@ declare class TnAutocompleteComponent<T = unknown> implements ControlValueAccess
     private lastOptionsCount;
     /** Scroll distance (px) from the panel bottom that triggers `loadMore`. */
     private static readonly loadMoreThresholdPx;
+    /**
+     * Cap on how many pages the underfill check may request without the user
+     * scrolling, per search. The check re-arms whenever the option count
+     * changes, which a `dataSource` answering synchronously does within the same
+     * change-detection pass — so an inexhaustible source would spin the tab
+     * rather than yield between rounds. Well beyond any real panel's capacity
+     * (20 × a 50-row page), so it only ever trips on a misbehaving source.
+     */
+    private static readonly maxAutoFillPages;
+    /** Underfill-driven pages requested since the last search or panel open. */
+    private autoFillCount;
     /** Guards the object-without-compareWith warning so it fires only once. */
     private warnedAboutObjectCompare;
+    /**
+     * Whether the text on screen is the raw `String(value)` fallback rather than
+     * an option's label — i.e. the value has never resolved and the user has not
+     * typed over it.
+     *
+     * The upgrade effect otherwise leaves an open panel alone, on the grounds
+     * that the text belongs to the user's search. With a `dataSource` that never
+     * holds: rows only ever arrive while the panel is open, so a written value
+     * would keep the fallback as its display text for good — and
+     * `allowCustomValue` would then commit that text back over the real value on
+     * blur. This says the text is nobody's draft, so upgrading it is safe.
+     */
+    private displayIsFallback;
     constructor();
     ngOnDestroy(): void;
     writeValue(value: T | null): void;
     registerOnChange(fn: (value: T | null) => void): void;
     registerOnTouched(fn: () => void): void;
     setDisabledState(isDisabled: boolean): void;
+    /**
+     * Discard the pages fetched from `dataSource` and re-query the current term.
+     *
+     * For a caller whose `[dataSource]` is a fixed function reading live
+     * configuration — the shape that keeps the source from being swapped out
+     * from under a search in flight — this is how a change to that configuration
+     * takes effect, rather than waiting for the next keystroke to notice.
+     */
+    refreshOptions(): void;
+    /**
+     * Commit an option programmatically, its label included.
+     *
+     * `writeValue` deliberately forgets the label — the forms layer hands over a
+     * value and nothing else — so a value the host picked itself would render as
+     * `String(value)` until a search happened to return the row carrying it.
+     * This is the path for a caller that already holds the option: the
+     * `actionOption` handoff, where `(actionSelected)` creates an entity and the
+     * host hands the new row straight back.
+     *
+     * It COMMITS, form control included. Updating only the display left the
+     * field showing the new label, marking that row selected, and the bound
+     * control still holding the previous value — which is what a submit then
+     * sent. (With `requireSelection` and `keepSelectedOption` together, blur
+     * happened to find the label on the synthetic kept row and reconcile it
+     * through `selectOption`; on the default path nothing ever did.)
+     *
+     * `optionSelected` deliberately does NOT fire: that output means the user
+     * picked a row, and this is the host telling the component what the host
+     * already decided — echoing it back to the caller that made the call would
+     * be noise. A host keeping a side model in sync updates it where it calls
+     * this, not from the output.
+     */
+    setSelectedOption(option: TnAutocompleteOption<T>): void;
     onInput(event: Event): void;
     onFocus(): void;
     onBlur(): void;
     onOptionClick(option: TnAutocompleteOption<T>): void;
+    /** Whether `option` is the pinned {@link actionOption} row rather than a value. */
+    private isActionOption;
+    /**
+     * The action row was chosen: close the panel and hand off, leaving the
+     * committed value and the text exactly as they were. Restoring the text
+     * matters because the user has usually typed a partial term to find the
+     * row — that draft must not survive as a value.
+     */
+    private runAction;
     onKeydown(event: KeyboardEvent): void;
     /**
      * `loadMore` normally fires from a scroll event, which never happens when
@@ -787,6 +1153,12 @@ declare class TnAutocompleteComponent<T = unknown> implements ControlValueAccess
      * opens), emit once more if the panel has no scrollbar.
      */
     private checkUnderfill;
+    /**
+     * Ask for another page: the internal engine when `dataSource` is bound, the
+     * consumer via `loadMore` otherwise. Both are notified — an app can page a
+     * `dataSource` and still observe the event.
+     */
+    private requestMore;
     onPanelScroll(event: Event): void;
     /**
      * Whether `option` carries the committed value — drives `aria-selected` so
@@ -827,13 +1199,50 @@ declare class TnAutocompleteComponent<T = unknown> implements ControlValueAccess
      * display match (case-insensitive, same as the requireSelection path)
      * commits the matching option instead, so picking an existing entry by
      * typing its full text behaves like clicking it.
+     *
+     * Matched against {@link matchableOptions} so the host-pinned rows count:
+     * with `[dataSource]` + `[options]` the field painted `g-7` as `admins` and
+     * then, on a page that did not carry that row, committed the raw string
+     * `'admins'` over the id it names — a label it would not read back. Same
+     * asymmetry `tn-chip-input` closed by pointing `commitText` at its
+     * `labelOptions`.
      */
     private commitCustomValue;
     /**
-     * Resolves a committed value back to its option's display label, falling
-     * back to the raw value's string until the matching option is available.
+     * Show `value`'s label and record whether that text is a real label or the
+     * raw `String(value)` fallback, so {@link displayIsFallback} — and with it
+     * the upgrade effect — can tell a resolved display from an unresolved one.
+     * Every path that re-derives the text from the committed value goes through
+     * here, so the two can never disagree.
+     *
+     * A label remembered from the option the value was picked from counts as
+     * resolved: it is the same text the option would give, and the row carrying
+     * it may well have been paged away since.
      */
-    private displayValue;
+    private setDisplayFromValue;
+    /**
+     * Abandon the draft term: repaint `value`'s label AND tell the async engine
+     * the term is gone.
+     *
+     * `asyncOptions.search()` is otherwise only reached from `onInput`, so every
+     * path that rewrites the text WITHOUT the user typing — the `requireSelection`
+     * revert on blur, the `allowCustomValue` Escape branch, and `runAction` —
+     * moved the display while the engine kept the query, the rows and the
+     * `primed` latch of the term walked away from. Reopening then showed that
+     * term's results (or "No results found") against a field displaying something
+     * else, and issued nothing to correct it: `open()` only calls `prime()`,
+     * which is a documented no-op once primed.
+     *
+     * `tn-chip-input.clearInput()` closes the same gap the same way. The request
+     * goes through the usual debounce, and the duplicate-term guard drops it
+     * entirely when the reverted text is the term already loaded — which is the
+     * common case of an Escape with no draft typed.
+     *
+     * `writeValue` deliberately does NOT come through here: a programmatic write
+     * is not a user abandoning a search, and querying there would break the rule
+     * that a field nobody has opened issues no request.
+     */
+    private revertDisplayToValue;
     /**
      * Compares option values, honoring `compareWith` when provided. Without one,
      * falls back to identity (`===`) — which never matches structurally-equal
@@ -858,7 +1267,7 @@ declare class TnAutocompleteComponent<T = unknown> implements ControlValueAccess
     private detachOverlay;
     private scrollToHighlighted;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TnAutocompleteComponent<any>, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnAutocompleteComponent<any>, "tn-autocomplete", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "compareWith": { "alias": "compareWith"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "requireSelection": { "alias": "requireSelection"; "required": false; "isSignal": true; }; "allowCustomValue": { "alias": "allowCustomValue"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "loadingText": { "alias": "loadingText"; "required": false; "isSignal": true; }; "filterFn": { "alias": "filterFn"; "required": false; "isSignal": true; }; "noResultsText": { "alias": "noResultsText"; "required": false; "isSignal": true; }; "maxResults": { "alias": "maxResults"; "required": false; "isSignal": true; }; "panelMaxHeight": { "alias": "panelMaxHeight"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "testId": { "alias": "testId"; "required": false; "isSignal": true; }; "optionTestIdKey": { "alias": "optionTestIdKey"; "required": false; "isSignal": true; }; }, { "optionSelected": "optionSelected"; "searchChange": "searchChange"; "loadMore": "loadMore"; "opened": "opened"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnAutocompleteComponent<any>, "tn-autocomplete", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "compareWith": { "alias": "compareWith"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "requireSelection": { "alias": "requireSelection"; "required": false; "isSignal": true; }; "allowCustomValue": { "alias": "allowCustomValue"; "required": false; "isSignal": true; }; "dataSource": { "alias": "dataSource"; "required": false; "isSignal": true; }; "dataSourceDebounce": { "alias": "dataSourceDebounce"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "actionOption": { "alias": "actionOption"; "required": false; "isSignal": true; }; "keepSelectedOption": { "alias": "keepSelectedOption"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "loadingText": { "alias": "loadingText"; "required": false; "isSignal": true; }; "filterFn": { "alias": "filterFn"; "required": false; "isSignal": true; }; "noResultsText": { "alias": "noResultsText"; "required": false; "isSignal": true; }; "maxResults": { "alias": "maxResults"; "required": false; "isSignal": true; }; "panelMaxHeight": { "alias": "panelMaxHeight"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "testId": { "alias": "testId"; "required": false; "isSignal": true; }; "optionTestIdKey": { "alias": "optionTestIdKey"; "required": false; "isSignal": true; }; }, { "optionSelected": "optionSelected"; "searchChange": "searchChange"; "actionSelected": "actionSelected"; "dataSourceError": "dataSourceError"; "loadMore": "loadMore"; "opened": "opened"; }, never, never, true, never>;
 }
 
 /**
@@ -3635,6 +4044,26 @@ interface ChipHarnessFilters extends BaseHarnessFilters {
  * feed all three.
  */
 type TnChipInputOption<T = unknown> = TnSelectOption<T>;
+/**
+ * Copy rendered inside `tn-chip-input` that is the same for every instance in
+ * an app. Provide {@link TN_CHIP_INPUT_LABELS} at the app root rather than
+ * repeating the identical string on each call site; the matching input on
+ * `<tn-chip-input>` still wins where one instance needs its own wording.
+ */
+interface TnChipInputLabels {
+    /** Text shown next to the spinner while a `dataSource` request is in flight. */
+    loading: string;
+}
+/** English defaults used when no {@link TN_CHIP_INPUT_LABELS} provider is registered. */
+declare const TN_CHIP_INPUT_DEFAULT_LABELS: TnChipInputLabels;
+/**
+ * DI token for app-wide default labels. Provide either a static object or a
+ * `Signal<TnChipInputLabels>` — the latter lets every chip input react to
+ * language changes when the consumer wires it up to an i18n service.
+ *
+ * Explicit input bindings on `<tn-chip-input>` still win over these defaults.
+ */
+declare const TN_CHIP_INPUT_LABELS: InjectionToken<TnChipInputLabels | Signal<TnChipInputLabels>>;
 /**
  * An editable, multi-value chip input — tokenized entry where typed text
  * becomes removable `tn-chip`s alongside an inline text field. Text is
@@ -3675,7 +4104,7 @@ type TnChipInputOption<T = unknown> = TnSelectOption<T>;
  * </tn-form-field>
  * ```
  */
-declare class TnChipInputComponent<T = string> implements ControlValueAccessor, OnDestroy {
+declare class TnChipInputComponent<T = string> implements ControlValueAccessor, TnAsyncOptionsHost, OnDestroy {
     private readonly overlay;
     private readonly viewContainerRef;
     /** Unique instance id for ARIA linkage between the input and its dropdown. */
@@ -3721,8 +4150,45 @@ declare class TnChipInputComponent<T = string> implements ControlValueAccessor,
      * Value-mode option list (`{ label, value }`). When non-empty, chips display
      * the resolved `label` while the form model holds `value`s. Takes precedence
      * over `suggestions`. For async sources, update in response to `(searchChange)`.
+     *
+     * A bound `dataSource` supersedes these as the *suggestions*, but they are
+     * still read when labelling a chip — see {@link labelOptions}.
      */
     options: _angular_core.InputSignal<TnChipInputOption<T>[]>;
+    /**
+     * Server-driven suggestions: a function of `(query, page)` returning the
+     * matches for `query`. Binding it hands the component the debounce,
+     * request cancellation, loading state and error recovery that a consumer
+     * otherwise writes by hand around `(searchChange)`, and it supersedes both
+     * `suggestions` and `options` as the source of the dropdown's rows —
+     * `options` is still consulted when labelling a chip, so a host can name a
+     * value the fetched pages have not produced.
+     *
+     * The chip dropdown is not paged, so `page` is always 0 — the parameter is
+     * there only so one source function can feed both this and `tn-autocomplete`.
+     *
+     * The first query runs when the field is first focused, not on init. Binding
+     * a source that is `undefined` at that moment is fine — the field fetches as
+     * soon as one arrives, open panel included.
+     *
+     * Swapping one source function for ANOTHER is not a signal to refetch: a
+     * source is expected to be a stable function reading live configuration,
+     * which is what keeps it from being replaced out from under a request in
+     * flight. Call `refreshOptions()` when that configuration moves.
+     *
+     * @example
+     * ```html
+     * <tn-chip-input [dataSource]="groupOptions" />
+     * ```
+     */
+    dataSource: _angular_core.InputSignal<TnOptionsFetchFn<TnChipInputOption<T>> | undefined>;
+    /** Debounce applied to typing before `dataSource` is queried, in ms. */
+    dataSourceDebounce: _angular_core.InputSignal<number>;
+    /**
+     * Text shown next to the spinner while a `dataSource` request is in flight.
+     * Falls back to {@link TN_CHIP_INPUT_LABELS}.
+     */
+    loadingText: _angular_core.InputSignal<string | undefined>;
     /**
      * Comparator for value equality — used for de-duplication, display resolution
      * and the selected-set. Defaults to identity (`===`), correct for primitives;
@@ -3749,7 +4215,7 @@ declare class TnChipInputComponent<T = string> implements ControlValueAccessor,
      */
     testId: _angular_core.InputSignal<TnTestIdValue>;
     /** Test-id base, falling back to the bound control name when `testId` is unset. */
-    protected resolvedTestId: _angular_core.Signal<TnTestIdValue>;
+    protected resolvedTestId: Signal<TnTestIdValue>;
     /**
      * Optional extractor for the per-option test-id discriminator, applied to both
      * a suggestion row and the chip it becomes. Defaults to the option's `label`,
@@ -3774,11 +4240,36 @@ declare class TnChipInputComponent<T = string> implements ControlValueAccessor,
      * the consumer if the lookup is expensive.
      */
     searchChange: _angular_core.OutputEmitterRef<string>;
+    /**
+     * Emits once per failed `dataSource` request. The component recovers on its
+     * own — the stream stays alive and the failed term stays retryable — so this
+     * is purely for the app to report the failure the way it reports others.
+     */
+    dataSourceError: _angular_core.OutputEmitterRef<unknown>;
+    private readonly defaultLabels;
+    protected readonly resolvedLoadingText: Signal<string>;
     private readonly container;
     private readonly inputEl;
     private readonly dropdownTemplate;
     /** Committed chip values — the form model. */
     protected values: _angular_core.WritableSignal<T[]>;
+    /**
+     * The label each committed value was picked FROM, for values whose row is no
+     * longer in {@link optionList} or {@link options}.
+     *
+     * With a `dataSource` the fetched page is the only list a chip's label can be
+     * resolved from, and it is replaced on the next search: pick `admins`, type
+     * `dev`, and the row carrying `g-7` is gone, so the chip the user just made
+     * reverts to `g-7` and stays that way. The pinned `[options]` escape hatch
+     * does not cover it — the host would have to append every freshly picked row
+     * to that input, which is the bookkeeping `dataSource` exists to remove.
+     *
+     * `tn-autocomplete` remembers the same thing in its `selectedLabel`; this is
+     * the multi-value form of it. Consulted LAST (see {@link labelOptions}), so a
+     * live row or a host pin always wins over a name that may since have changed,
+     * and pruned to the committed values so it cannot grow without bound.
+     */
+    private readonly rememberedLabels;
     /** Current text in the field. */
     protected inputValue: _angular_core.WritableSignal<string>;
     /** Whether the suggestion dropdown is open. */
@@ -3790,22 +4281,94 @@ declare class TnChipInputComponent<T = string> implements ControlValueAccessor,
     /** CVA disabled state pushed by the form. */
     private formDisabled;
     /** Combined disabled state from the input and the form. */
-    protected isDisabled: _angular_core.Signal<boolean>;
+    protected isDisabled: Signal<boolean>;
     /** Whether another chip may still be added under `maxChips`. */
-    protected canAddMore: _angular_core.Signal<boolean>;
+    protected canAddMore: Signal<boolean>;
+    /** Async engine backing `dataSource`; idle while no source is bound. */
+    private readonly asyncOptions;
+    /**
+     * Whether a `dataSource` request is in flight.
+     *
+     * Surfaced in the dropdown because with a `dataSource` bound the rows are NOT
+     * re-filtered on the label — the server already applied the query — so the
+     * panel keeps showing the *previous* term's matches, clickable and looking
+     * current, for the debounce plus the round trip. Without a cue that is
+     * indistinguishable from "these are your results".
+     *
+     * It covers the ROUND TRIP only. The debounce window before it is
+     * deliberately left uncued: a spinner appearing and vanishing on every
+     * keystroke of a term that is still being typed is noise, and the request it
+     * would announce may never be sent.
+     */
+    protected readonly loading: Signal<boolean>;
+    /**
+     * Unified option list. A bound `dataSource` wins; then value-mode `options`;
+     * otherwise string-mode `suggestions` lifted into `{ label: s, value: s }`.
+     */
+    protected optionList: Signal<TnChipInputOption<T>[]>;
     /**
-     * Unified option list. Value-mode `options` win; otherwise string-mode
-     * `suggestions` are lifted into `{ label: s, value: s }`.
+     * The rows a chip's label and test id may be resolved from: the suggestions,
+     * plus — with a `dataSource` bound — the `options` input.
+     *
+     * Those two lists are the same thing without a `dataSource`. With one, the
+     * fetched pages are the only source of labels, and the first of them does not
+     * exist until the field is focused: a form loaded with ids would render every
+     * chip as its raw id until someone clicked into it. `options` is how a host
+     * names values it already knows the labels for, so it stays part of the
+     * lookup even where it is not part of the dropdown.
+     *
+     * Deliberately not deduplicated: the order is the precedence — the server's
+     * fetched rows, then the host's pinned ones, then the labels this field
+     * remembered committing ({@link rememberedLabels}) — and every reader takes
+     * the first match, so the freshest name for a value wins.
+     *
+     * Read by {@link commitText} as well, so the labels the field paints and the
+     * labels it accepts back are one set. Deliberately NOT read by
+     * {@link filteredSuggestions}: with a source bound the rows are shown as the
+     * server ordered and filtered them, and splicing the pinned rows in would
+     * append the same entries to every term's results, matching or not.
      */
-    protected optionList: _angular_core.Signal<TnChipInputOption<T>[]>;
+    private readonly labelOptions;
     /** Options matching the typed text and not already selected. */
-    protected filteredSuggestions: _angular_core.Signal<TnChipInputOption<T>[]>;
+    protected filteredSuggestions: Signal<TnChipInputOption<T>[]>;
     private onChange;
     private onTouched;
     private overlayRef?;
     private overlaySubs;
+    /**
+     * Set when the panel was closed deliberately — by committing a chip, or by
+     * Escape — and read by everything that would otherwise re-open it.
+     *
+     * Committing changes the suggestion list, since the chosen row is now
+     * excluded, which re-runs the effect below. On the static path the empty
+     * input makes `activelySearching` false and the close stands; with a
+     * `dataSource` bound, `searchingEmpty` holds regardless, so the panel sprang
+     * back open against an empty field, still listing the rows of the term just
+     * committed.
+     *
+     * Escape is here for the same reason and one more: a response landing after
+     * it reaches `syncDropdownAfterFetch`, which OPENS. Typing `an`, pressing
+     * Escape inside the 250 ms debounce, and waiting put the panel straight back
+     * with focus still in the field — Escape defeated for the whole in-flight
+     * window. The ARIA combobox pattern is that Escape dismisses the popup and it
+     * stays dismissed, so that was a keyboard and AT regression, not a cosmetic
+     * one.
+     *
+     * Cleared by the next thing that is genuinely a search, so typing re-arms the
+     * panel immediately.
+     */
+    private closedByUser;
     constructor();
     ngOnDestroy(): void;
+    /**
+     * Discard the pages fetched from `dataSource` and re-query the current term.
+     *
+     * For a caller whose `[dataSource]` is a fixed function reading live
+     * configuration — the shape that keeps the source from being swapped out
+     * from under a search in flight — this is how a change to that configuration
+     * takes effect, rather than waiting for the next keystroke to notice.
+     */
+    refreshOptions(): void;
     writeValue(value: T[] | null | undefined): void;
     registerOnChange(fn: (value: T[]) => void): void;
     registerOnTouched(fn: () => void): void;
@@ -3850,6 +4413,8 @@ declare class TnChipInputComponent<T = string> implements ControlValueAccessor,
      * emitting one would invite collisions between inputs.
      */
     protected suggestionTestId(option: TnChipInputOption<T>): TnTestIdValue;
+    /** Test-id parts for the dropdown's status row. Mirrors `tn-autocomplete`. */
+    protected statusTestIdParts(status: 'loading'): (string | number | null | undefined)[];
     /**
      * Keeps a scoped id only when both halves of it survive normalization.
      *
@@ -3863,10 +4428,32 @@ declare class TnChipInputComponent<T = string> implements ControlValueAccessor,
      */
     private discriminatedTestId;
     private isCommitKey;
-    /** Commits typed text: resolve it to an option's value, else accept as custom. */
+    /**
+     * Commits typed text: resolve it to an option's value, else accept as custom.
+     *
+     * Matched against {@link labelOptions}, not the dropdown rows, so that every
+     * label the field is willing to PAINT it is also willing to READ back. With a
+     * `dataSource` bound, `options` names values the host already knows the
+     * labels for; a chip rendered as `admins` that this method did not recognise
+     * when `admins` was typed was silently dropped under
+     * `allowCustomValue="false"` and committed as the raw string under the
+     * default `true` — a second chip beside the one it duplicates.
+     */
     private commitText;
-    /** Commits a resolved value, honouring duplicate and cap rules. */
+    /**
+     * Commits a resolved value, honouring duplicate and cap rules.
+     *
+     * `label` is the text of the option the value came from, when there was one —
+     * remembered so the chip keeps that name after the page carrying its row is
+     * replaced. See {@link rememberedLabels}. Free text passes none: such a chip
+     * is its own label, and `String(value)` already renders it.
+     */
     private commitValue;
+    /**
+     * Drop remembered labels for values no longer committed, so the memory stays
+     * bounded by the chips on screen rather than by everything ever picked.
+     */
+    private pruneRememberedLabels;
     /**
      * The option a committed value came from, or `undefined` for a free-text chip.
      *
@@ -3888,10 +4475,34 @@ declare class TnChipInputComponent<T = string> implements ControlValueAccessor,
     private valuesIncludes;
     private valueMatches;
     private clearInput;
+    /**
+     * Re-decide the panel once a `dataSource` response lands.
+     *
+     * The constructor effect only ever OPENS — it must not fight Escape, blur or
+     * the post-commit close — and with a source bound `onInput` runs
+     * `syncDropdown()` against the PREVIOUS term's rows, which are still there,
+     * so it leaves the panel open too. Nothing was left to retract it: a search
+     * that matched nothing kept a bordered, empty `role="listbox"` attached,
+     * `aria-expanded="true"` over it, until the next keystroke or blur. The
+     * static path never reaches that state, because there the label filter has
+     * already emptied the list by the time `syncDropdown()` reads it.
+     *
+     * The guards are every deliberate close: {@link closedByUser} covers the
+     * post-commit close and Escape, `focused()` covers blur. This must not reopen
+     * a panel any of them just shut.
+     */
+    private syncDropdownAfterFetch;
     /**
      * Opens the dropdown when there is something to show, closes it otherwise.
      * Stays closed once the chip cap is reached — suggesting rows that
      * `commitValue()` would reject is misleading.
+     *
+     * A request in flight counts as something to show even with no rows behind
+     * it: the loading row is the only in-flight cue this field has, and the
+     * fetch most likely to be slow is the COLD one on first focus, where there
+     * is nothing to keep the panel open on its own. Without this the panel was
+     * detached for that whole round trip — no spinner, no `aria-busy` — and the
+     * empty listbox that carries the loading row cost no height.
      */
     private syncDropdown;
     /** Keeps the keyboard-highlighted suggestion visible within the scrolling panel. */
@@ -3901,7 +4512,7 @@ declare class TnChipInputComponent<T = string> implements ControlValueAccessor,
     private attachOverlay;
     private detachOverlay;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TnChipInputComponent<any>, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnChipInputComponent<any>, "tn-chip-input", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "separatorKeys": { "alias": "separatorKeys"; "required": false; "isSignal": true; }; "addOnBlur": { "alias": "addOnBlur"; "required": false; "isSignal": true; }; "allowCustomValue": { "alias": "allowCustomValue"; "required": false; "isSignal": true; }; "allowDuplicates": { "alias": "allowDuplicates"; "required": false; "isSignal": true; }; "maxChips": { "alias": "maxChips"; "required": false; "isSignal": true; }; "suggestions": { "alias": "suggestions"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "compareWith": { "alias": "compareWith"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "testId": { "alias": "testId"; "required": false; "isSignal": true; }; "optionTestIdKey": { "alias": "optionTestIdKey"; "required": false; "isSignal": true; }; }, { "chipAdded": "chipAdded"; "chipRemoved": "chipRemoved"; "searchChange": "searchChange"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnChipInputComponent<any>, "tn-chip-input", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "separatorKeys": { "alias": "separatorKeys"; "required": false; "isSignal": true; }; "addOnBlur": { "alias": "addOnBlur"; "required": false; "isSignal": true; }; "allowCustomValue": { "alias": "allowCustomValue"; "required": false; "isSignal": true; }; "allowDuplicates": { "alias": "allowDuplicates"; "required": false; "isSignal": true; }; "maxChips": { "alias": "maxChips"; "required": false; "isSignal": true; }; "suggestions": { "alias": "suggestions"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "dataSource": { "alias": "dataSource"; "required": false; "isSignal": true; }; "dataSourceDebounce": { "alias": "dataSourceDebounce"; "required": false; "isSignal": true; }; "loadingText": { "alias": "loadingText"; "required": false; "isSignal": true; }; "compareWith": { "alias": "compareWith"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "testId": { "alias": "testId"; "required": false; "isSignal": true; }; "optionTestIdKey": { "alias": "optionTestIdKey"; "required": false; "isSignal": true; }; }, { "chipAdded": "chipAdded"; "chipRemoved": "chipRemoved"; "searchChange": "searchChange"; "dataSourceError": "dataSourceError"; }, never, never, true, never>;
 }
 
 /**
@@ -3944,6 +4555,21 @@ declare class TnChipInputHarness extends ComponentHarness {
     removeChip(value: string): Promise<void>;
     /** Visible suggestion option texts, or `[]` when the dropdown is closed. */
     getSuggestions(): Promise<string[]>;
+    /**
+     * Whether the dropdown is showing its loading row, i.e. a `[dataSource]`
+     * request is in flight. Any rows on screen while this is true belong to the
+     * previous term — a `dataSource` is trusted to have applied the query, so
+     * they are not re-filtered as the user types. On the first focus there are
+     * no rows yet and the panel holds the loading row alone.
+     *
+     * @example
+     * ```typescript
+     * const chips = await loader.getHarness(TnChipInputHarness);
+     * await chips.focus();
+     * expect(await chips.isLoading()).toBe(true);
+     * ```
+     */
+    isLoading(): Promise<boolean>;
     isDisabled(): Promise<boolean>;
 }
 interface TnChipInputHarnessFilters extends BaseHarnessFilters {
@@ -9031,6 +9657,35 @@ declare class TnTableComponent<T = unknown> implements OnInit {
     dataSource: _angular_core.InputSignal<TnTableDataSource<T> | T[]>;
     displayedColumns: _angular_core.InputSignal<string[]>;
     trackBy: _angular_core.InputSignal<((index: number, item: T) => unknown) | undefined>;
+    /**
+     * Identity function for SELECTION. When set, the table tracks selected rows by the
+     * key this returns rather than by object reference, and the selection survives a
+     * `dataSource` change: paging, sorting, filtering, or a background reload that hands
+     * back freshly-built row objects. Rows selected on a page the table is no longer
+     * showing stay selected and keep coming back in `selectionChange`.
+     *
+     * Without it the table keeps its historical behaviour — any `dataSource` reference
+     * change clears the selection and emits an empty `selectionChange` — because
+     * reference-keyed selections cannot be recognised in a new array and would otherwise
+     * leave the header checkbox counting rows that are no longer on screen.
+     *
+     * This is deliberately separate from {@link trackBy}, which is a rendering concern
+     * (`@for` identity, index-based by default) and is free to stay so on a table whose
+     * selection has to be stable. Pass a key that identifies the ROW, not its position —
+     * and bind a stable member rather than writing the function in the template, since
+     * Angular's expression grammar has no arrow functions:
+     * `[selectionKey]="rowKey"` for a `rowKey = (row: User) => row.id` on the host.
+     *
+     * The select-all checkbox stays scoped to the visible page — it selects and clears
+     * the rows the table is currently showing, and `isAllSelected` reflects only those,
+     * so it never claims to have selected rows the user cannot see.
+     *
+     * Retention is unconditional, and it has to be: the table sees one page and cannot
+     * tell a row that moved off-screen from one that was destroyed. A consumer whose rows
+     * can disappear for good owns that check — reconcile `selectionChange` against the
+     * full list it holds, and call {@link clearSelection} once a batch action is done.
+     */
+    selectionKey: _angular_core.InputSignal<((row: T) => unknown) | undefined>;
     emptyMessage: _angular_core.InputSignal<string>;
     /**
      * Optional second line under `emptyMessage`, for empty states that carry both a headline and an
@@ -9250,8 +9905,29 @@ declare class TnTableComponent<T = unknown> implements OnInit {
     expandedRows: _angular_core.WritableSignal<Set<unknown>>;
     private static instanceCount;
     private readonly instanceId;
+    /**
+     * The rows of the CURRENT `data()` that are selected. With `selectionKey` set this is
+     * the visible slice of {@link selectedByKey} — it is what the row checkboxes and the
+     * select-all state read, so both stay scoped to the page on screen.
+     */
     selection: SelectionModel<T>;
+    /**
+     * The whole selection, keyed by `selectionKey`, including rows that are no longer in
+     * `data()`. Empty (and unused) when no `selectionKey` is set.
+     *
+     * It holds the row objects, not just the keys, so `selectionChange` can hand a
+     * consumer the rows it selected on an earlier page — a batch action has to act on
+     * rows, and the table is the only thing that ever saw them.
+     */
+    private readonly selectedByKey;
+    /** Number of selected rows present in the current `data()` — see {@link selection}. */
     private selectionCount;
+    /**
+     * The array last handed to `selectionChange`, so a reconcile that leaves the selection
+     * exactly as the consumer already sees it can stay quiet — re-running because
+     * `selectionKey`'s identity changed is not news.
+     */
+    private lastEmittedSelection;
     private initialized;
     private columnDefMap;
     constructor();
@@ -9462,6 +10138,29 @@ declare class TnTableComponent<T = unknown> implements OnInit {
     toggleSelectAll(): void;
     toggleRowSelection(row: T): void;
     isRowSelected(row: T): boolean;
+    /**
+     * Drops the whole selection, including rows retained from pages the table is not
+     * showing. Use it after a batch action consumes the selection.
+     *
+     * Emits an empty `selectionChange` if anything was selected. The caller knows it
+     * cleared, but `selectionChange` is the only way anything else can: a toolbar bound to
+     * a mirrored copy of the selection a layer up would otherwise stay stale until the next
+     * `dataSource` change happened to correct it. Clearing {@link selection} directly is not
+     * enough once `selectionKey` is set: the retained rows would survive and come back on
+     * the next reconcile.
+     */
+    clearSelection(): void;
+    /** Re-applies the retained selection to the rows currently on screen. */
+    private syncSelectionToData;
+    /** What `selectionChange` carries: the whole selection when keyed, the page's otherwise. */
+    private emittedSelection;
+    /** Emits the current selection and records it. For the paths that always change it. */
+    private emitSelection;
+    /**
+     * Emits only if the selection differs from the one last emitted, by row identity — for
+     * the paths that may be re-run without anything having moved.
+     */
+    private emitSelectionIfChanged;
     /**
      * The column rendered as the card title. The first `displayedColumns` entry
      * whose def sets `cardTitle`, else the first column not marked `cardHidden` —
@@ -9527,7 +10226,7 @@ declare class TnTableComponent<T = unknown> implements OnInit {
     getCardLabel(column: string): string;
     getCellValue(row: T, column: string): unknown;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TnTableComponent<any>, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnTableComponent<any>, "tn-table", never, { "dataSource": { "alias": "dataSource"; "required": false; "isSignal": true; }; "displayedColumns": { "alias": "displayedColumns"; "required": false; "isSignal": true; }; "trackBy": { "alias": "trackBy"; "required": false; "isSignal": true; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; "isSignal": true; }; "emptyDescription": { "alias": "emptyDescription"; "required": false; "isSignal": true; }; "emptyIcon": { "alias": "emptyIcon"; "required": false; "isSignal": true; }; "scrollRegionAriaLabel": { "alias": "scrollRegionAriaLabel"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "expandable": { "alias": "expandable"; "required": false; "isSignal": true; }; "bordered": { "alias": "bordered"; "required": false; "isSignal": true; }; "isRowExpandable": { "alias": "isRowExpandable"; "required": false; "isSignal": true; }; "activeRow": { "alias": "activeRow"; "required": false; "isSignal": true; }; "activeWhen": { "alias": "activeWhen"; "required": false; "isSignal": true; }; "activeBg": { "alias": "activeBg"; "required": false; "isSignal": true; }; "activeIndicator": { "alias": "activeIndicator"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "loadingMessage": { "alias": "loadingMessage"; "required": false; "isSignal": true; }; "clickable": { "alias": "clickable"; "required": false; "isSignal": true; }; "expandOnRowClick": { "alias": "expandOnRowClick"; "required": false; "isSignal": true; }; "singleExpand": { "alias": "singleExpand"; "required": false; "isSignal": true; }; "fixedLayout": { "alias": "fixedLayout"; "required": false; "isSignal": true; }; "minColumnWidth": { "alias": "minColumnWidth"; "required": false; "isSignal": true; }; "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; "mobileLayout": { "alias": "mobileLayout"; "required": false; "isSignal": true; }; "cardBreakpoint": { "alias": "cardBreakpoint"; "required": false; "isSignal": true; }; "cardPrimaryCount": { "alias": "cardPrimaryCount"; "required": false; "isSignal": true; }; "sortColumn": { "alias": "sortColumn"; "required": false; "isSignal": true; }; "sortDirection": { "alias": "sortDirection"; "required": false; "isSignal": true; }; }, { "sortChange": "sortChange"; "selectionChange": "selectionChange"; "rowClick": "rowClick"; "rowDoubleClick": "rowDoubleClick"; "sortColumn": "sortColumnChange"; "sortDirection": "sortDirectionChange"; }, ["columnDefs", "detailRowDef", "rowActionsDef"], never, true, [{ directive: typeof TnTestIdDirective; inputs: { "tnTestId": "testId"; }; outputs: {}; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TnTableComponent<any>, "tn-table", never, { "dataSource": { "alias": "dataSource"; "required": false; "isSignal": true; }; "displayedColumns": { "alias": "displayedColumns"; "required": false; "isSignal": true; }; "trackBy": { "alias": "trackBy"; "required": false; "isSignal": true; }; "selectionKey": { "alias": "selectionKey"; "required": false; "isSignal": true; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; "isSignal": true; }; "emptyDescription": { "alias": "emptyDescription"; "required": false; "isSignal": true; }; "emptyIcon": { "alias": "emptyIcon"; "required": false; "isSignal": true; }; "scrollRegionAriaLabel": { "alias": "scrollRegionAriaLabel"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "expandable": { "alias": "expandable"; "required": false; "isSignal": true; }; "bordered": { "alias": "bordered"; "required": false; "isSignal": true; }; "isRowExpandable": { "alias": "isRowExpandable"; "required": false; "isSignal": true; }; "activeRow": { "alias": "activeRow"; "required": false; "isSignal": true; }; "activeWhen": { "alias": "activeWhen"; "required": false; "isSignal": true; }; "activeBg": { "alias": "activeBg"; "required": false; "isSignal": true; }; "activeIndicator": { "alias": "activeIndicator"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "loadingMessage": { "alias": "loadingMessage"; "required": false; "isSignal": true; }; "clickable": { "alias": "clickable"; "required": false; "isSignal": true; }; "expandOnRowClick": { "alias": "expandOnRowClick"; "required": false; "isSignal": true; }; "singleExpand": { "alias": "singleExpand"; "required": false; "isSignal": true; }; "fixedLayout": { "alias": "fixedLayout"; "required": false; "isSignal": true; }; "minColumnWidth": { "alias": "minColumnWidth"; "required": false; "isSignal": true; }; "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; "mobileLayout": { "alias": "mobileLayout"; "required": false; "isSignal": true; }; "cardBreakpoint": { "alias": "cardBreakpoint"; "required": false; "isSignal": true; }; "cardPrimaryCount": { "alias": "cardPrimaryCount"; "required": false; "isSignal": true; }; "sortColumn": { "alias": "sortColumn"; "required": false; "isSignal": true; }; "sortDirection": { "alias": "sortDirection"; "required": false; "isSignal": true; }; }, { "sortChange": "sortChange"; "selectionChange": "selectionChange"; "rowClick": "rowClick"; "rowDoubleClick": "rowDoubleClick"; "sortColumn": "sortColumnChange"; "sortDirection": "sortDirectionChange"; }, ["columnDefs", "detailRowDef", "rowActionsDef"], never, true, [{ directive: typeof TnTestIdDirective; inputs: { "tnTestId": "testId"; }; outputs: {}; }]>;
 }
 
 /**
@@ -15631,5 +16330,5 @@ declare const TN_THEME_DEFINITIONS: readonly TnThemeDefinition[];
  */
 declare const THEME_MAP: Map<TnTheme, TnThemeDefinition>;
 
-export { CommonShortcuts, DEFAULT_THEME, DiskIconComponent, DiskType, FileSizePipe, InputType, LIGHT_THEME, LabelMarkupPipe, LabelTextPipe, LinuxModifierKeys, LinuxShortcuts, ModifierKeys, QuickShortcuts, ShortcutBuilder, THEME_MAP, THEME_STORAGE_KEY, TN_AUTOCOMPLETE_DEFAULT_LABELS, TN_AUTOCOMPLETE_LABELS, TN_BRANDED_SPINNER_DEFAULT_LABEL, TN_CALENDAR_INTL, TN_CALENDAR_INTL_DEFAULTS, TN_DEFAULT_FALLBACK_LABELS, TN_DIALOG_CHROME_LABELS, TN_DIALOG_DEFAULT_CHROME_LABELS, TN_DIALOG_SHELL_DEFAULT_LABEL, TN_DRAWER_CONTENT_LABEL, TN_DRAWER_DEFAULT_LABEL, TN_FALLBACK_LABELS, TN_FORM_FIELD_CONTEXT, TN_FORM_FIELD_DISMISSIBLE_ERRORS, TN_FORM_FIELD_ERRORS, TN_FORM_LIST_CONTEXT, TN_PARTICLE_PROGRESS_BAR_DEFAULT_LABEL, TN_PROGRESS_BAR_DEFAULT_LABEL, TN_RADIO_GROUP, TN_SELECT_DEFAULT_LABELS, TN_SELECT_LABELS, TN_SIDE_PANEL_CONTENT_LABEL, TN_SIDE_PANEL_DEFAULT_LABEL, TN_SIDE_PANEL_OVERFLOW_TOLERANCE_PX, TN_SPINNER_DEFAULT_LABEL, TN_STEPPER_STATUS_COMPLETED, TN_STEPPER_STATUS_ERROR, TN_TABLE_DEFAULT_LABELS, TN_TABLE_LABELS, TN_TABLE_PAGER_DEFAULT_LABELS, TN_TABLE_PAGER_LABELS, TN_TABLE_SCROLL_REGION_LABEL, TN_TAB_PANEL_CONTENT_LABEL, TN_TEST_ATTR, TN_THEME_DEFINITIONS, TN_TOAST_ANNOUNCE_DELAY_MS, TnAutocompleteComponent, TnAutocompleteHarness, TnBannerActionDirective, TnBannerActionHarness, TnBannerComponent, TnBannerHarness, TnBrandedSpinnerComponent, TnButtonComponent, TnButtonHarness, TnButtonToggleComponent, TnButtonToggleGroupComponent, TnButtonToggleGroupHarness, TnButtonToggleHarness, TnCalendarCellHarness, TnCalendarComponent, TnCalendarHarness, TnCalendarHeaderComponent, TnCardComponent, TnCardFooterActionsDirective, TnCardHeaderActionsDirective, TnCardHeaderDirective, TnCellDefDirective, TnCheckboxComponent, TnCheckboxGroupComponent, TnCheckboxGroupHarness, TnCheckboxHarness, TnCheckboxLabelDirective, TnChipComponent, TnChipHarness, TnChipInputComponent, TnChipInputHarness, TnConfirmDialogComponent, TnDateInputComponent, TnDateInputHarness, TnDateRangeInputComponent, TnDateRangeInputHarness, TnDetailRowDefDirective, TnDialog, TnDialogHarness, TnDialogShellComponent, TnDialogTesting, TnDividerComponent, TnDividerDirective, TnDrawerComponent, TnDrawerContainerComponent, TnDrawerContainerHarness, TnDrawerContentComponent, TnDrawerHarness, TnEmptyComponent, TnEmptyHarness, TnExpansionPanelComponent, TnExpansionPanelHarness, TnFileInputComponent, TnFileInputHarness, TnFilePickerComponent, TnFilePickerHarness, TnFilePickerPopupComponent, TnFormErrorsComponent, TnFormErrorsHarness, TnFormFieldComponent, TnFormFieldHarness, TnFormListComponent, TnFormListHarness, TnFormListItemComponent, TnFormListItemHarness, TnFormSectionComponent, TnFormSectionHarness, TnHeaderCellDefDirective, TnIconButtonComponent, TnIconButtonHarness, TnIconComponent, TnIconHarness, TnIconRegistryService, TnIconTesting, TnInputComponent, TnInputDirective, TnInputHarness, TnKeyboardShortcutComponent, TnKeyboardShortcutService, TnListAvatarDirective, TnListComponent, TnListIconDirective, TnListItemComponent, TnListItemLineDirective, TnListItemPrimaryDirective, TnListItemSecondaryDirective, TnListItemTitleDirective, TnListItemTrailingDirective, TnListOptionComponent, TnListSubheaderComponent, TnMenuActivateHoverDirective, TnMenuComponent, TnMenuHarness, TnMenuItemComponent, TnMenuTesting, TnMenuTriggerDirective, TnMonthViewComponent, TnMultiYearViewComponent, TnNestedTreeDataSource, TnNestedTreeNodeComponent, TnParticleProgressBarComponent, TnProgressBarComponent, TnRadioComponent, TnRadioGroupComponent, TnRadioGroupHarness, TnRadioHarness, TnRowActionsDefDirective, TnSelectComponent, TnSelectHarness, TnSelectionListComponent, TnSidePanelActionDirective, TnSidePanelComponent, TnSidePanelHarness, TnSidePanelHeaderActionDirective, TnSlideToggleComponent, TnSlideToggleHarness, TnSliderComponent, TnSliderThumbDirective, TnSliderWithLabelDirective, TnSpinnerComponent, TnSpriteLoaderService, TnStepComponent, TnStepperComponent, TnStepperHarness, TnStepperNextDirective, TnStepperPreviousDirective, TnTabComponent, TnTabHarness, TnTabPanelComponent, TnTabPanelHarness, TnTableColumnDirective, TnTableComponent, TnTableHarness, TnTablePagerComponent, TnTablePagerHarness, TnTableTesting, TnTabsComponent, TnTabsHarness, TnTestIdDirective, TnTheme, TnThemeService, TnTimeInputComponent, TnToastComponent, TnToastMock, TnToastPosition, TnToastRef, TnToastService, TnToastTesting, TnToastType, TnTooltipComponent, TnTooltipDirective, TnTooltipHarness, TnTooltipTesting, TnTreeComponent, TnTreeFlatDataSource, TnTreeFlattener, TnTreeHarness, TnTreeNodeComponent, TnTreeNodeHarness, TnTreeNodeOutletDirective, TnTreeVirtualScrollNodeOutletDirective, TnTreeVirtualScrollViewComponent, TnTreeVirtualScrollViewHarness, TruncatePathPipe, WindowsModifierKeys, WindowsShortcuts, allowsCurrentDirectorySelection, canonicalizeSize, composeTestId, controlTestId, createFlatTreeControl, createLucideLibrary, createNestedTreeControl, createShortcut, defaultSpriteBasePath, defaultSpriteConfigPath, defaultTreeItemSize, formatSize, formatSizeExact, formatSizeForEditing, getSelectableTypes, injectTnCalendarIntl, injectTnFallbackName, injectTnFormFieldAria, injectTnLabels, isPathWithinRoot, kebabTestSegment, labelMarkupToHtml, labelMarkupToText, libIconMarker, normalizeRootPath, optionTestId, parseLabelMarkup, parseSize, parseSizeParts, registerLucideIcons, resolveErrorMessage, scopeTestId, setupLucideIntegration, tnIconMarker, writeTestId };
-export type { AutocompleteHarnessFilters, BannerActionHarnessFilters, BannerHarnessFilters, ButtonHarnessFilters, ButtonToggleHarnessFilters, CalendarCell, CalendarCellFill, CalendarCellHarnessFilters, CalendarHarnessFilters, CheckboxGroupHarnessFilters, CheckboxHarnessFilters, ChipColor, ChipHarnessFilters, DateInputHarnessFilters, DateRange, DateRangeInputHarnessFilters, DialogHarnessFilters, EmptyHarnessFilters, ExpansionPanelHarnessFilters, FileInputHarnessFilters, FilePickerCallbacks, FilePickerCreateAction, FilePickerCreateActionEvent, FilePickerError, FilePickerHarnessFilters, FilePickerMode, FileSystemItem, FileSystemItemType, FlatTreeControlOptions, FormFieldHarnessFilters, FormSectionHarnessFilters, IconButtonHarnessFilters, IconHarnessFilters, IconLibrary, IconLibraryType, IconResult, IconSize, IconSource, IconTestingMockOverrides, InputHarnessFilters, KeyCombination, LabelMarkupSegment, LabelMarkupSegmentType, LabelType, LucideIconOptions, MenuHarnessFilters, MockIconRegistry, MockSpriteLoader, NestedTreeControlOptions, ParsedSize, PathSegment, PlatformType, ProgressBarMode, RadioGroupHarnessFilters, RadioHarnessFilters, ResolveErrorMessageOptions, ResolvedIcon, SelectHarnessFilters, ShortcutHandler, SidePanelHarnessFilters, SizeStandard, SlideToggleColor, SlideToggleHarnessFilters, SpinnerMode, SpriteConfig, StepperHarnessFilters, SubscriptSizing, TabChangeEvent, TabHarnessFilters, TabPanelHarnessFilters, TabsHarnessFilters, TnAutocompleteLabels, TnAutocompleteOption, TnBannerType, TnButtonToggleType, TnCalendarIntl, TnCalendarIntlInput, TnCalendarView, TnCardAction, TnCardControl, TnCardFooterLink, TnCardHeaderStatus, TnCheckboxOption, TnChipInputHarnessFilters, TnChipInputOption, TnConfirmDialogData, TnDialogChromeLabels, TnDialogDefaults, TnDialogOpenTarget, TnDrawerMode, TnDrawerPosition, TnEmptySize, TnFallbackLabels, TnFallbackName, TnFlatTreeNode, TnFormErrorsHarnessFilters, TnFormFieldAriaBindings, TnFormFieldContext, TnFormFieldErrorMessage, TnFormFieldErrorMessages, TnFormFieldErrorResolver, TnFormListContext, TnFormListHarnessFilters, TnFormListItemHarnessFilters, TnMenuItem, TnOptionTestIdSource, TnRadioGroupApi, TnRadioOption, TnSelectLabels, TnSelectOption, TnSelectOptionGroup, TnSelectionChange, TnSortEvent, TnTableDataProvider, TnTableDataSource, TnTableHarnessFilters, TnTableLabels, TnTableMobileLayout, TnTablePagerHarnessFilters, TnTablePagerLabels, TnTablePagination, TnTestAttrName, TnTestIdValue, TnThemeDefinition, TnToastCall, TnToastConfig, TnTreeExpansion, TnTreeHarnessFilters, TnTreeNodeHarnessFilters, TnTreeVirtualNodeData, TnTreeVirtualScrollViewHarnessFilters, TooltipHarnessFilters, TooltipPosition, YearCell };
+export { CommonShortcuts, DEFAULT_THEME, DiskIconComponent, DiskType, FileSizePipe, InputType, LIGHT_THEME, LabelMarkupPipe, LabelTextPipe, LinuxModifierKeys, LinuxShortcuts, ModifierKeys, QuickShortcuts, ShortcutBuilder, THEME_MAP, THEME_STORAGE_KEY, TN_AUTOCOMPLETE_DEFAULT_LABELS, TN_AUTOCOMPLETE_LABELS, TN_BRANDED_SPINNER_DEFAULT_LABEL, TN_CALENDAR_INTL, TN_CALENDAR_INTL_DEFAULTS, TN_CHIP_INPUT_DEFAULT_LABELS, TN_CHIP_INPUT_LABELS, TN_DEFAULT_FALLBACK_LABELS, TN_DIALOG_CHROME_LABELS, TN_DIALOG_DEFAULT_CHROME_LABELS, TN_DIALOG_SHELL_DEFAULT_LABEL, TN_DRAWER_CONTENT_LABEL, TN_DRAWER_DEFAULT_LABEL, TN_FALLBACK_LABELS, TN_FORM_FIELD_CONTEXT, TN_FORM_FIELD_DISMISSIBLE_ERRORS, TN_FORM_FIELD_ERRORS, TN_FORM_LIST_CONTEXT, TN_PARTICLE_PROGRESS_BAR_DEFAULT_LABEL, TN_PROGRESS_BAR_DEFAULT_LABEL, TN_RADIO_GROUP, TN_SELECT_DEFAULT_LABELS, TN_SELECT_LABELS, TN_SIDE_PANEL_CONTENT_LABEL, TN_SIDE_PANEL_DEFAULT_LABEL, TN_SIDE_PANEL_OVERFLOW_TOLERANCE_PX, TN_SPINNER_DEFAULT_LABEL, TN_STEPPER_STATUS_COMPLETED, TN_STEPPER_STATUS_ERROR, TN_TABLE_DEFAULT_LABELS, TN_TABLE_LABELS, TN_TABLE_PAGER_DEFAULT_LABELS, TN_TABLE_PAGER_LABELS, TN_TABLE_SCROLL_REGION_LABEL, TN_TAB_PANEL_CONTENT_LABEL, TN_TEST_ATTR, TN_THEME_DEFINITIONS, TN_TOAST_ANNOUNCE_DELAY_MS, TnAutocompleteComponent, TnAutocompleteHarness, TnBannerActionDirective, TnBannerActionHarness, TnBannerComponent, TnBannerHarness, TnBrandedSpinnerComponent, TnButtonComponent, TnButtonHarness, TnButtonToggleComponent, TnButtonToggleGroupComponent, TnButtonToggleGroupHarness, TnButtonToggleHarness, TnCalendarCellHarness, TnCalendarComponent, TnCalendarHarness, TnCalendarHeaderComponent, TnCardComponent, TnCardFooterActionsDirective, TnCardHeaderActionsDirective, TnCardHeaderDirective, TnCellDefDirective, TnCheckboxComponent, TnCheckboxGroupComponent, TnCheckboxGroupHarness, TnCheckboxHarness, TnCheckboxLabelDirective, TnChipComponent, TnChipHarness, TnChipInputComponent, TnChipInputHarness, TnConfirmDialogComponent, TnDateInputComponent, TnDateInputHarness, TnDateRangeInputComponent, TnDateRangeInputHarness, TnDetailRowDefDirective, TnDialog, TnDialogHarness, TnDialogShellComponent, TnDialogTesting, TnDividerComponent, TnDividerDirective, TnDrawerComponent, TnDrawerContainerComponent, TnDrawerContainerHarness, TnDrawerContentComponent, TnDrawerHarness, TnEmptyComponent, TnEmptyHarness, TnExpansionPanelComponent, TnExpansionPanelHarness, TnFileInputComponent, TnFileInputHarness, TnFilePickerComponent, TnFilePickerHarness, TnFilePickerPopupComponent, TnFormErrorsComponent, TnFormErrorsHarness, TnFormFieldComponent, TnFormFieldHarness, TnFormListComponent, TnFormListHarness, TnFormListItemComponent, TnFormListItemHarness, TnFormSectionComponent, TnFormSectionHarness, TnHeaderCellDefDirective, TnIconButtonComponent, TnIconButtonHarness, TnIconComponent, TnIconHarness, TnIconRegistryService, TnIconTesting, TnInputComponent, TnInputDirective, TnInputHarness, TnKeyboardShortcutComponent, TnKeyboardShortcutService, TnListAvatarDirective, TnListComponent, TnListIconDirective, TnListItemComponent, TnListItemLineDirective, TnListItemPrimaryDirective, TnListItemSecondaryDirective, TnListItemTitleDirective, TnListItemTrailingDirective, TnListOptionComponent, TnListSubheaderComponent, TnMenuActivateHoverDirective, TnMenuComponent, TnMenuHarness, TnMenuItemComponent, TnMenuTesting, TnMenuTriggerDirective, TnMonthViewComponent, TnMultiYearViewComponent, TnNestedTreeDataSource, TnNestedTreeNodeComponent, TnParticleProgressBarComponent, TnProgressBarComponent, TnRadioComponent, TnRadioGroupComponent, TnRadioGroupHarness, TnRadioHarness, TnRowActionsDefDirective, TnSelectComponent, TnSelectHarness, TnSelectionListComponent, TnSidePanelActionDirective, TnSidePanelComponent, TnSidePanelHarness, TnSidePanelHeaderActionDirective, TnSlideToggleComponent, TnSlideToggleHarness, TnSliderComponent, TnSliderThumbDirective, TnSliderWithLabelDirective, TnSpinnerComponent, TnSpriteLoaderService, TnStepComponent, TnStepperComponent, TnStepperHarness, TnStepperNextDirective, TnStepperPreviousDirective, TnTabComponent, TnTabHarness, TnTabPanelComponent, TnTabPanelHarness, TnTableColumnDirective, TnTableComponent, TnTableHarness, TnTablePagerComponent, TnTablePagerHarness, TnTableTesting, TnTabsComponent, TnTabsHarness, TnTestIdDirective, TnTheme, TnThemeService, TnTimeInputComponent, TnToastComponent, TnToastMock, TnToastPosition, TnToastRef, TnToastService, TnToastTesting, TnToastType, TnTooltipComponent, TnTooltipDirective, TnTooltipHarness, TnTooltipTesting, TnTreeComponent, TnTreeFlatDataSource, TnTreeFlattener, TnTreeHarness, TnTreeNodeComponent, TnTreeNodeHarness, TnTreeNodeOutletDirective, TnTreeVirtualScrollNodeOutletDirective, TnTreeVirtualScrollViewComponent, TnTreeVirtualScrollViewHarness, TruncatePathPipe, WindowsModifierKeys, WindowsShortcuts, allowsCurrentDirectorySelection, canonicalizeSize, composeTestId, controlTestId, createFlatTreeControl, createLucideLibrary, createNestedTreeControl, createShortcut, createTnOptionsDataSource, defaultSpriteBasePath, defaultSpriteConfigPath, defaultTreeItemSize, formatSize, formatSizeExact, formatSizeForEditing, getSelectableTypes, injectTnCalendarIntl, injectTnFallbackName, injectTnFormFieldAria, injectTnLabels, isPathWithinRoot, kebabTestSegment, labelMarkupToHtml, labelMarkupToText, libIconMarker, normalizeRootPath, optionTestId, parseLabelMarkup, parseSize, parseSizeParts, registerLucideIcons, resolveErrorMessage, scopeTestId, setupLucideIntegration, tnIconMarker, writeTestId };
+export type { AutocompleteHarnessFilters, BannerActionHarnessFilters, BannerHarnessFilters, ButtonHarnessFilters, ButtonToggleHarnessFilters, CalendarCell, CalendarCellFill, CalendarCellHarnessFilters, CalendarHarnessFilters, CheckboxGroupHarnessFilters, CheckboxHarnessFilters, ChipColor, ChipHarnessFilters, DateInputHarnessFilters, DateRange, DateRangeInputHarnessFilters, DialogHarnessFilters, EmptyHarnessFilters, ExpansionPanelHarnessFilters, FileInputHarnessFilters, FilePickerCallbacks, FilePickerCreateAction, FilePickerCreateActionEvent, FilePickerError, FilePickerHarnessFilters, FilePickerMode, FileSystemItem, FileSystemItemType, FlatTreeControlOptions, FormFieldHarnessFilters, FormSectionHarnessFilters, IconButtonHarnessFilters, IconHarnessFilters, IconLibrary, IconLibraryType, IconResult, IconSize, IconSource, IconTestingMockOverrides, InputHarnessFilters, KeyCombination, LabelMarkupSegment, LabelMarkupSegmentType, LabelType, LucideIconOptions, MenuHarnessFilters, MockIconRegistry, MockSpriteLoader, NestedTreeControlOptions, ParsedSize, PathSegment, PlatformType, ProgressBarMode, RadioGroupHarnessFilters, RadioHarnessFilters, ResolveErrorMessageOptions, ResolvedIcon, SelectHarnessFilters, ShortcutHandler, SidePanelHarnessFilters, SizeStandard, SlideToggleColor, SlideToggleHarnessFilters, SpinnerMode, SpriteConfig, StepperHarnessFilters, SubscriptSizing, TabChangeEvent, TabHarnessFilters, TabPanelHarnessFilters, TabsHarnessFilters, TnAsyncOptionsHost, TnAutocompleteLabels, TnAutocompleteOption, TnBannerType, TnButtonToggleType, TnCalendarIntl, TnCalendarIntlInput, TnCalendarView, TnCardAction, TnCardControl, TnCardFooterLink, TnCardHeaderStatus, TnCheckboxOption, TnChipInputHarnessFilters, TnChipInputLabels, TnChipInputOption, TnConfirmDialogData, TnDialogChromeLabels, TnDialogDefaults, TnDialogOpenTarget, TnDrawerMode, TnDrawerPosition, TnEmptySize, TnFallbackLabels, TnFallbackName, TnFlatTreeNode, TnFormErrorsHarnessFilters, TnFormFieldAriaBindings, TnFormFieldContext, TnFormFieldErrorMessage, TnFormFieldErrorMessages, TnFormFieldErrorResolver, TnFormListContext, TnFormListHarnessFilters, TnFormListItemHarnessFilters, TnMenuItem, TnOptionTestIdSource, TnOptionsDataSource, TnOptionsDataSourceConfig, TnOptionsFetchFn, TnRadioGroupApi, TnRadioOption, TnSelectLabels, TnSelectOption, TnSelectOptionGroup, TnSelectionChange, TnSortEvent, TnTableDataProvider, TnTableDataSource, TnTableHarnessFilters, TnTableLabels, TnTableMobileLayout, TnTablePagerHarnessFilters, TnTablePagerLabels, TnTablePagination, TnTestAttrName, TnTestIdValue, TnThemeDefinition, TnToastCall, TnToastConfig, TnTreeExpansion, TnTreeHarnessFilters, TnTreeNodeHarnessFilters, TnTreeVirtualNodeData, TnTreeVirtualScrollViewHarnessFilters, TooltipHarnessFilters, TooltipPosition, YearCell };