@tx-angular-design-system/ui-kit 0.1.0

package/types/tx-angular-design-system-ui-kit.d.ts

@@ -0,0 +1,3697 @@
+import * as _angular_core from '@angular/core';
+import { WritableSignal, InjectionToken, Signal, TemplateRef } from '@angular/core';
+import * as _tx_angular_design_system_ui_kit from '@tx-angular-design-system/ui-kit';
+import { ControlValueAccessor } from '@angular/forms';
+import { Combobox } from '@angular/aria/combobox';
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+import { DialogRef } from '@angular/cdk/dialog';
+import { ComponentType } from '@angular/cdk/portal';
+
+/**
+ * A process-unique DOM id.
+ *
+ * Used for label/control/description wiring. Ids only ever need to be unique
+ * within a document, and every id the kit generates carries the `tx-` prefix so
+ * it cannot collide with an application's own.
+ */
+declare function txUniqueId(prefix: string): string;
+
+/**
+ * One selectable option.
+ *
+ * Options are *data*, not configuration, so components take them through their
+ * own `options` input rather than as a field on a config object. That keeps the
+ * config interface to simple property-level variation, and lets an application
+ * pass an options array straight from a data source without wrapping it.
+ *
+ * Anything structural — a custom option template — is a `TemplateRef` input on
+ * the component, never a field here.
+ */
+interface TxOption<T = string> {
+    /** The value carried into the component's `value` model. */
+    value: T;
+    /** Visible text. Also what typeahead matches against. */
+    label: string;
+    /** Optional second line, shown smaller and muted. */
+    description?: string;
+    /** Registered icon name shown before the label. */
+    icon?: string;
+    /** Short text rendered as a badge after the label, e.g. a count or status. */
+    badge?: string;
+    disabled?: boolean;
+}
+/**
+ * A group of options with a heading. Accepted anywhere a flat option list is,
+ * for components that support grouping.
+ */
+interface TxOptionGroup<T = string> {
+    label: string;
+    options: TxOption<T>[];
+}
+/** Narrows a mixed list entry to a group. */
+declare function isTxOptionGroup<T>(entry: TxOption<T> | TxOptionGroup<T>): entry is TxOptionGroup<T>;
+/** Flattens a mixed option/group list into plain options, in display order. */
+declare function flattenTxOptions<T>(entries: readonly (TxOption<T> | TxOptionGroup<T>)[]): TxOption<T>[];
+
+/**
+ * Merges a caller's partial config over a component's defaults.
+ *
+ * Use this rather than `{ ...DEFAULTS, ...config }`. Object spread copies keys
+ * whose value is `undefined`, so a consumer binding an optional value:
+ *
+ * ```html
+ * <tx-button [config]="{ label: 'Save', variant: chosenVariant }" />
+ * ```
+ *
+ * would wipe the default whenever `chosenVariant` happens to be `undefined` —
+ * a bug that only shows up for some data. This treats an explicitly-undefined
+ * key as absent, which is what the call site reads as.
+ *
+ * `null`, `false`, `0` and `''` are all kept: those are deliberate values, and
+ * falling back from them is the `||` bug this exists to avoid.
+ */
+declare function txMergeConfig<T extends object>(defaults: Partial<NoInfer<T>>, config: Partial<NoInfer<T>>): T;
+
+/**
+ * Shared styling for the text-like control shell.
+ *
+ * Input, textarea, select, dropdown-tree, chips input and the datepicker
+ * trigger all present the same bordered surface with the same focus ring and
+ * the same error treatment. Building that string in one place is what stops
+ * them drifting apart, and keeps every value a token.
+ */
+/** Size of a control. Matches the form field's size vocabulary. */
+type TxControlSize = 'sm' | 'md' | 'lg';
+interface TxControlShellOptions {
+    size: TxControlSize;
+    /** Renders the error border and keeps the focus ring in the danger colour. */
+    invalid: boolean;
+    /** Whether the control grows with its content (textarea, chips input). */
+    height?: 'fixed' | 'auto';
+}
+/**
+ * The bordered control surface: border, background, radius, focus ring,
+ * placeholder colour and disabled treatment.
+ *
+ * Disabled and invalid are styled from real DOM state — the `disabled`
+ * attribute and `aria-invalid` — rather than from classes toggled in
+ * TypeScript, so the visual state can never disagree with the accessible one.
+ */
+declare function txControlShellClass(options: TxControlShellOptions): string;
+/** Icon size that pairs with each control size. */
+declare const CONTROL_ICON_SIZE: Record<TxControlSize, 'sm' | 'md'>;
+/**
+ * The chevron. Rotates from `aria-expanded` on the trigger, which carries `group`.
+ *
+ * `flex` on the wrapper is load-bearing, not decoration. `tx-icon` is an
+ * inline-flex box, so inside a wrapper that establishes an inline formatting
+ * context it sits on the text baseline and the line box adds the strut's
+ * descender space *below* it — around 3px at the control's 14px/1.55 text,
+ * which pushes the glyph that far above the trigger's centre line and then
+ * visibly shifts it again when `rotate-180` flips it about the wrapper's own
+ * centre. Making the wrapper a flex container removes the line box entirely,
+ * so its height is the icon's height and `items-center` on the trigger centres
+ * the glyph exactly, open or closed.
+ */
+declare const TX_TRIGGER_CHEVRON_CLASS: string;
+/** The clear button, sitting immediately before the chevron. */
+declare const TX_TRIGGER_CLEAR_CLASS: string;
+
+/**
+ * Bridges a `model()` signal to `@angular/forms`.
+ *
+ * Kit controls expose their value as a `model()` so template-driven signal
+ * binding works, and implement `ControlValueAccessor` so reactive forms do too.
+ * This holds the small amount of state that both need to agree on, in one
+ * place that can be unit-tested without rendering a component.
+ *
+ * @example
+ * ```ts
+ * export class TxInputComponent implements ControlValueAccessor {
+ *   readonly value = model('');
+ *   private readonly forms = new TxControlValueBridge<string>((v) => this.value.set(v));
+ *
+ *   writeValue(value: string): void { this.forms.writeValue(value); }
+ *   registerOnChange(fn: (value: string) => void): void { this.forms.registerOnChange(fn); }
+ *   registerOnTouched(fn: () => void): void { this.forms.registerOnTouched(fn); }
+ *   setDisabledState(isDisabled: boolean): void { this.forms.setDisabledState(isDisabled); }
+ * }
+ * ```
+ */
+declare class TxControlValueBridge<T> {
+    private readonly applyValue;
+    private onChange;
+    private onTouched;
+    /**
+     * Disabled state pushed down by a `FormControl`.
+     *
+     * Kept separate from the config's own `disabled` so the two can be OR'd
+     * rather than fighting: a control disabled by its form stays disabled even if
+     * the config says otherwise, and vice versa.
+     */
+    readonly formDisabled: WritableSignal<boolean>;
+    constructor(applyValue: (value: T) => void);
+    /** Called by forms to push a value in. Does not echo back through onChange. */
+    writeValue(value: T): void;
+    registerOnChange(fn: (value: T) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    /** Called by the control when the user changes the value. */
+    emit(value: T): void;
+    /** Called by the control on blur. */
+    touch(): void;
+}
+
+/** Vertical rhythm/size of a form field and the control inside it. */
+type TxFormFieldSize = 'sm' | 'md' | 'lg';
+/** How the label sits relative to the control. */
+type TxFormFieldLayout = 'stacked' | 'inline';
+/**
+ * Simple property configuration for {@link TxFormFieldComponent}.
+ *
+ * Everything here is optional: a form field with no label is a legitimate way
+ * to get consistent hint/error placement around a control.
+ */
+interface TxFormFieldConfig {
+    /** Visible label text. */
+    label?: string;
+    /**
+     * Keeps the label available to screen readers while hiding it visually —
+     * for a control whose purpose is already obvious from context, such as a
+     * search box with a magnifier icon.
+     */
+    labelVisibility?: 'visible' | 'screen-reader-only';
+    /** Helper text under the control. Hidden while an error is showing. */
+    hint?: string;
+    /**
+     * Error message. A non-empty value puts the field into its error state and
+     * marks the control `aria-invalid` — there is no separate `invalid` flag to
+     * keep in step with it.
+     */
+    error?: string;
+    /** Renders a required marker and sets `aria-required` on the control. */
+    required?: boolean;
+    /** Greys out the label/hint. The control still needs its own `disabled`. */
+    disabled?: boolean;
+    /** Defaults to `stacked`. */
+    layout?: TxFormFieldLayout;
+    /** Defaults to `md`. Controls inside inherit this unless they override it. */
+    size?: TxFormFieldSize;
+}
+declare const TX_FORM_FIELD_DEFAULTS: {
+    readonly labelVisibility: "visible";
+    readonly layout: "stacked";
+    readonly size: "md";
+};
+/**
+ * What a form field exposes to the control projected inside it.
+ *
+ * Controls inject this optionally: used bare, a control falls back to its own
+ * generated id and no described-by, so nothing depends on being wrapped.
+ */
+interface TxFormFieldApi {
+    /** Id the label's `for` points at. The control must adopt it. */
+    readonly controlId: Signal<string>;
+    /** Space-joined ids of the hint and/or error, for `aria-describedby`. */
+    readonly describedBy: Signal<string | null>;
+    /** True while `error` is a non-empty string. */
+    readonly invalid: Signal<boolean>;
+    readonly required: Signal<boolean>;
+    readonly disabled: Signal<boolean>;
+    readonly size: Signal<TxFormFieldSize>;
+}
+declare const TX_FORM_FIELD: InjectionToken<TxFormFieldApi>;
+
+/**
+ * What a control inherits from a surrounding {@link TxFormFieldComponent}.
+ * Every value falls back to a standalone default, so no kit control depends on
+ * being wrapped.
+ */
+interface TxFormFieldBinding {
+    /** The control's `id`; the field's label points its `for` at this. */
+    readonly id: Signal<string>;
+    /** For `aria-describedby` — the hint's or error's id, whichever is showing. */
+    readonly describedBy: Signal<string | null>;
+    /** True when the field is showing an error. Drives `aria-invalid`. */
+    readonly invalid: Signal<boolean>;
+    /** Required marker set on the field. Drives `aria-required`. */
+    readonly required: Signal<boolean>;
+    /** The field's size, or `null` when there is no field to inherit from. */
+    readonly size: Signal<TxFormFieldSize | null>;
+}
+/**
+ * Connects a control to its surrounding form field.
+ *
+ * Must be called from an injection context (a field initialiser or the
+ * constructor).
+ */
+declare function txBindFormField(idPrefix: string): TxFormFieldBinding;
+
+/**
+ * Shared overlay vocabulary for every popup surface in the kit — select,
+ * multiselect, dropdown tree, chips input, autocomplete, menu, datepicker and
+ * tooltip all position through the same directive.
+ */
+/**
+ * Preferred placement of the popup relative to its trigger. Each one carries
+ * its own fallback ladder, so a popup near a viewport edge flips rather than
+ * being clipped.
+ */
+type TxOverlayPlacement = 'bottom-start' | 'bottom-end' | 'bottom-center' | 'top-start' | 'top-end' | 'top-center' | 'right-start' | 'left-start';
+/**
+ * How the popup's width relates to its trigger.
+ *
+ * - `trigger`     — exactly the trigger's width. Selects and dropdown trees.
+ * - `min-trigger` — at least the trigger's width, wider if content needs it.
+ * - `content`     — sized purely by content. Menus, tooltips, datepickers.
+ */
+type TxOverlayWidth = 'trigger' | 'min-trigger' | 'content';
+/** Why the popup closed. Lets a trigger decide whether to restore focus. */
+type TxOverlayCloseReason = 'escape' | 'outside-click' | 'detach';
+/**
+ * Simple property configuration for a connected overlay.
+ *
+ * Structural content is NOT configured here — the popup body is a
+ * `TemplateRef` passed to the directive, never a field on this object.
+ */
+interface TxOverlayConfig {
+    /** Preferred placement; falls back through a ladder if it does not fit. */
+    placement: TxOverlayPlacement;
+    /** How the popup's width relates to the trigger's. */
+    width: TxOverlayWidth;
+    /** Gap between trigger and popup, expressed as a spacing token step. */
+    gap: 'none' | 'sm' | 'md';
+    /** Close when a pointer event lands outside the popup and its trigger. */
+    closeOnOutsideClick: boolean;
+    /** Close when Escape is pressed while the popup has focus or activedescendant. */
+    closeOnEscape: boolean;
+    /** Reposition the popup as ancestors scroll, instead of leaving it behind. */
+    repositionOnScroll: boolean;
+}
+declare const TX_OVERLAY_DEFAULTS: TxOverlayConfig;
+
+/**
+ * Positions a popup template against a trigger element using the CDK overlay.
+ *
+ * ## Why the portal is attached eagerly
+ *
+ * `@angular/aria`'s `ComboboxPopup` registers itself with its `Combobox` in
+ * `ngOnInit`, and that registration is what gives the trigger its
+ * `aria-controls`, its `aria-expanded` wiring and — most importantly — its
+ * forwarding of arrow keys into the popup widget. If the popup template were
+ * only instantiated on first open, the very first ArrowDown on a closed
+ * trigger would have nothing to forward to.
+ *
+ * So the `TemplatePortal` is attached as soon as the directive initialises,
+ * and stays attached for the directive's lifetime. Aria's own `DeferredContent`
+ * still creates and destroys the popup *body* in step with `expanded`, so the
+ * pane is genuinely empty (and zero-sized) while closed. `open` therefore
+ * drives positioning and the scroll strategy, not attachment.
+ *
+ * The alternative — letting Aria render the popup inline and moving the live
+ * node into an overlay with `DomPortal` — was rejected because detaching has
+ * to be sequenced against Aria destroying that same view, and we do not
+ * control that ordering.
+ *
+ * @example
+ * ```html
+ * <div ngCombobox #cb="ngCombobox" [(expanded)]="expanded"
+ *      [txConnectedOverlay]="popup" [txOverlayOpen]="expanded()">
+ *   {{ label() }}
+ * </div>
+ *
+ * <ng-template #popup>
+ *   <ng-template ngComboboxPopup [combobox]="cb">
+ *     <div ngComboboxWidget ngListbox>…</div>
+ *   </ng-template>
+ * </ng-template>
+ * ```
+ */
+declare class TxConnectedOverlayDirective {
+    private readonly host;
+    private readonly viewContainerRef;
+    private readonly injector;
+    /** The popup body. Structural, so it is a template — never a config field. */
+    readonly template: _angular_core.InputSignal<TemplateRef<unknown>>;
+    /** Whether the popup is currently shown. */
+    readonly open: _angular_core.InputSignal<boolean>;
+    /** Trigger to position against. Defaults to the element the directive is on. */
+    readonly origin: _angular_core.InputSignal<HTMLElement | undefined>;
+    /** Simple property configuration; merged over {@link TX_OVERLAY_DEFAULTS}. */
+    readonly config: _angular_core.InputSignal<Partial<TxOverlayConfig>>;
+    /** Emitted when the popup asks to close. The trigger owns the open state. */
+    readonly closed: _angular_core.OutputEmitterRef<TxOverlayCloseReason>;
+    protected readonly resolved: _angular_core.Signal<TxOverlayConfig>;
+    private overlayRef;
+    private get originElement();
+    constructor();
+    /** Recomputes position and size. Call after the popup's content changes. */
+    reposition(): void;
+    private ensureOverlay;
+    private applyOpenState;
+    private applyWidth;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TxConnectedOverlayDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TxConnectedOverlayDirective, "[txConnectedOverlay]", ["txConnectedOverlay"], { "template": { "alias": "txConnectedOverlay"; "required": true; "isSignal": true; }; "open": { "alias": "txOverlayOpen"; "required": false; "isSignal": true; }; "origin": { "alias": "txOverlayOrigin"; "required": false; "isSignal": true; }; "config": { "alias": "txOverlayConfig"; "required": false; "isSignal": true; }; }, { "closed": "closed"; }, never, never, true, never>;
+}
+
+/**
+ * A registered icon.
+ *
+ * Only the *inner* markup is stored — the `<svg>` wrapper, its viewBox and its
+ * paint attributes are rendered by `TxIconComponent`, so a registered icon can
+ * never override the element's sizing or accessibility attributes.
+ */
+interface TxIconDefinition {
+    /**
+     * Inner SVG markup: `<path>`, `<circle>`, `<rect>`, `<g>` and friends.
+     * Must NOT include an `<svg>` wrapper.
+     */
+    body: string;
+    /** Defaults to the kit's 24x24 grid. */
+    viewBox?: string;
+    /**
+     * `stroke` (default) matches the kit's line-drawn icon language;
+     * `fill` suits solid glyphs and brand marks.
+     */
+    paint?: 'stroke' | 'fill';
+}
+/** Icon size, aligned to the control heights so icons sit on the text baseline. */
+type TxIconSize = 'sm' | 'md' | 'lg' | 'inherit';
+/**
+ * Simple property configuration for {@link TxIconComponent}.
+ *
+ * `name` is genuinely required — an icon with no name has nothing to draw.
+ */
+interface TxIconConfig {
+    /** Registered icon name. Unknown names render nothing and warn in dev mode. */
+    name: string;
+    /** Defaults to `md`. `inherit` scales with the surrounding font size. */
+    size?: TxIconSize;
+    /**
+     * Accessible label. Omit for decorative icons (the default), which are
+     * marked `aria-hidden` so screen readers skip them.
+     */
+    label?: string;
+}
+declare const TX_ICON_DEFAULTS: {
+    readonly size: "md";
+};
+
+/**
+ * The icon set every consumer gets for free.
+ *
+ * Drawn on a 24x24 grid in one line-drawn language (round caps and joins,
+ * `currentColor` stroke) so a mixed row of icons reads as one family. Names are
+ * descriptive of the glyph, never of a use case — `clipboard-check`, not
+ * `reports` — so no application's vocabulary leaks into the library.
+ *
+ * Register your own with `TxIconRegistry.register()`; a custom icon of the same
+ * name replaces the default.
+ */
+declare const TX_DEFAULT_ICONS: Readonly<Record<string, TxIconDefinition>>;
+
+/**
+ * Holds the kit's icons and any the application registers.
+ *
+ * Icon bodies are parsed once into real SVG nodes and cached. Nothing goes
+ * through `innerHTML` or `bypassSecurityTrust*`: the parsed tree is walked and
+ * every element outside {@link ALLOWED_ELEMENTS}, every `on*` handler and every
+ * scripting URL is stripped before the fragment is ever attached. Registering
+ * an icon is therefore safe even for markup you did not author, though the
+ * intended use is still SVG you control.
+ */
+declare class TxIconRegistry {
+    private readonly definitions;
+    private readonly parsed;
+    /** Bumped on every mutation so rendered icons re-resolve their name. */
+    readonly revision: _angular_core.WritableSignal<number>;
+    /** Registers (or replaces) a single icon. */
+    register(name: string, definition: TxIconDefinition | string): void;
+    /**
+     * Registers (or replaces) many icons at once.
+     *
+     * @example
+     * ```ts
+     * inject(TxIconRegistry).registerAll({
+     *   'company-logo': { body: '<path d="…"/>', paint: 'fill' },
+     * });
+     * ```
+     */
+    registerAll(icons: Record<string, TxIconDefinition | string>): void;
+    /** Whether an icon is registered under this name. */
+    has(name: string): boolean;
+    /** Every registered name, sorted. Useful for building an icon browser. */
+    names(): string[];
+    /** The raw definition, for reading `viewBox` and `paint`. */
+    definition(name: string): TxIconDefinition | undefined;
+    /**
+     * A fresh clone of the icon's sanitised nodes, ready to append.
+     * Returns `null` for an unknown name.
+     */
+    resolve(name: string): DocumentFragment | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TxIconRegistry, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TxIconRegistry>;
+}
+
+/**
+ * Renders a registered icon.
+ *
+ * Decorative by default (`aria-hidden`); give the config a `label` to expose it
+ * as an image to assistive technology. Colour comes from `currentColor`, so an
+ * icon inherits whatever text colour its context sets — no icon ever needs a
+ * colour of its own.
+ *
+ * @example
+ * ```html
+ * <tx-icon [config]="{ name: 'chevron-down' }" />
+ * <tx-icon [config]="{ name: 'trash', size: 'sm', label: 'Delete row' }" />
+ * ```
+ *
+ * Config is a signal input, so update it by replacing the object:
+ * `this.iconConfig = { ...this.iconConfig, name: 'check' }`.
+ */
+declare class TxIconComponent {
+    private readonly registry;
+    private readonly svg;
+    readonly config: _angular_core.InputSignal<TxIconConfig>;
+    protected readonly label: _angular_core.Signal<string | null>;
+    protected readonly viewBox: _angular_core.Signal<string>;
+    protected readonly svgClass: _angular_core.Signal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TxIconComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TxIconComponent, "tx-icon", never, { "config": { "alias": "config"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Label / hint / error / required-marker chrome around a form control.
+ *
+ * Wraps any control — the kit's or your own — and wires up the accessible
+ * relationships: the label's `for`, `aria-describedby` for the hint and error,
+ * and `aria-invalid` / `aria-required` on the control. Kit controls pick these
+ * up by injecting {@link TX_FORM_FIELD}; a plain `<input>` can use the exported
+ * `controlId` from the template reference instead.
+ *
+ * @example
+ * ```html
+ * <tx-form-field [config]="{ label: 'Part number', required: true, hint: 'As printed on the label' }">
+ *   <tx-input [config]="{ placeholder: 'e.g. 44-2201' }" [(value)]="partNumber" />
+ * </tx-form-field>
+ * ```
+ *
+ * Config is a signal input, so update it by replacing the object rather than
+ * mutating it: `this.fieldConfig = { ...this.fieldConfig, error: 'Required' }`.
+ */
+declare class TxFormFieldComponent implements TxFormFieldApi {
+    readonly config: _angular_core.InputSignal<Partial<TxFormFieldConfig>>;
+    private readonly resolved;
+    protected readonly hintId: string;
+    protected readonly errorId: string;
+    /** Stable for the component's lifetime; the label's `for` and the control's `id`. */
+    readonly controlId: _angular_core.Signal<string>;
+    private readonly generatedId;
+    protected readonly label: _angular_core.Signal<string | null>;
+    protected readonly hint: _angular_core.Signal<string | null>;
+    protected readonly error: _angular_core.Signal<string | null>;
+    readonly invalid: _angular_core.Signal<boolean>;
+    readonly required: _angular_core.Signal<boolean>;
+    readonly disabled: _angular_core.Signal<boolean>;
+    readonly size: _angular_core.Signal<_tx_angular_design_system_ui_kit.TxFormFieldSize>;
+    readonly describedBy: _angular_core.Signal<string | null>;
+    protected readonly wrapperClass: _angular_core.Signal<"flex flex-col gap-tx-1 sm:flex-row sm:items-baseline sm:gap-tx-3" | "flex flex-col gap-tx-1-5">;
+    protected readonly labelClass: _angular_core.Signal<string>;
+    protected readonly hintClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TxFormFieldComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TxFormFieldComponent, "tx-form-field", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Visual weight of a button.
+ *
+ * `primary` is the emphasis action (outlined in the brand colour, filling on
+ * hover); `accent` is the solid dark button used for a page's single dominant
+ * action; `secondary` is the neutral outlined default; `ghost` is the quiet
+ * action that only gains a border on hover; `danger` is destructive.
+ */
+type TxButtonVariant = 'primary' | 'accent' | 'secondary' | 'ghost' | 'danger';
+type TxButtonSize = 'sm' | 'md' | 'lg';
+/** Where an icon sits relative to the label. */
+type TxButtonIconPosition = 'leading' | 'trailing';
+/**
+ * Whether the label is rendered or used only as the accessible name.
+ * `icon-only` requires `icon` to be set.
+ */
+type TxButtonDisplay = 'label' | 'icon-only';
+/**
+ * Simple property configuration for {@link TxButtonComponent}.
+ *
+ * `label` is genuinely required, including for `icon-only` buttons where it
+ * becomes the accessible name — an unlabelled icon button is unusable with a
+ * screen reader, so there is no way to omit it.
+ */
+interface TxButtonConfig {
+    label: string;
+    /** Defaults to `secondary`. */
+    variant?: TxButtonVariant;
+    /** Defaults to `md`. */
+    size?: TxButtonSize;
+    /** Registered icon name. */
+    icon?: string;
+    /** Defaults to `leading`. Ignored when `display` is `icon-only`. */
+    iconPosition?: TxButtonIconPosition;
+    /** Defaults to `label`. */
+    display?: TxButtonDisplay;
+    /** Native button type. Defaults to `button` so it never submits by accident. */
+    type?: 'button' | 'submit' | 'reset';
+    /** Defaults to `auto`. `full` stretches to the container. */
+    width?: 'auto' | 'full';
+    disabled?: boolean;
+    /** Swaps the icon for a spinner, marks `aria-busy` and blocks activation. */
+    loading?: boolean;
+}
+declare const TX_BUTTON_DEFAULTS: {
+    readonly variant: "secondary";
+    readonly size: "md";
+    readonly iconPosition: "leading";
+    readonly display: "label";
+    readonly type: "button";
+    readonly width: "auto";
+};
+
+/**
+ * A button.
+ *
+ * Renders a native `<button>`, so keyboard activation, form participation and
+ * the disabled semantics are the platform's rather than ours.
+ *
+ * @example
+ * ```html
+ * <tx-button [config]="saveConfig" (clicked)="save()" />
+ * ```
+ * ```ts
+ * saveConfig: TxButtonConfig = { label: 'Save', variant: 'primary', icon: 'check' };
+ * ```
+ *
+ * Config is a signal input, so updates happen by passing a new object
+ * reference, never by mutating in place:
+ * ```ts
+ * this.saveConfig = { ...this.saveConfig, loading: true };
+ * ```
+ */
+declare class TxButtonComponent {
+    readonly config: _angular_core.InputSignal<TxButtonConfig>;
+    /** Native click. Behaviour never lives in the config object. */
+    readonly clicked: _angular_core.OutputEmitterRef<MouseEvent>;
+    private readonly resolved;
+    protected readonly label: _angular_core.Signal<string>;
+    protected readonly icon: _angular_core.Signal<string | null>;
+    protected readonly iconPosition: _angular_core.Signal<_tx_angular_design_system_ui_kit.TxButtonIconPosition | undefined>;
+    protected readonly type: _angular_core.Signal<"button" | "submit" | "reset" | undefined>;
+    protected readonly loading: _angular_core.Signal<boolean>;
+    protected readonly iconOnly: _angular_core.Signal<boolean>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly iconSize: _angular_core.Signal<"sm" | "md" | "lg">;
+    protected readonly hostClass: _angular_core.Signal<"block w-full" | "inline-block">;
+    protected readonly buttonClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TxButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TxButtonComponent, "tx-button", never, { "config": { "alias": "config"; "required": true; "isSignal": true; }; }, { "clicked": "clicked"; }, never, never, true, never>;
+}
+
+/** Text-like input types. Checkbox/radio/date have their own components. */
+type TxInputType = 'text' | 'email' | 'password' | 'search' | 'tel' | 'url' | 'number';
+/**
+ * Simple property configuration for {@link TxInputComponent}.
+ *
+ * Everything is optional: `<tx-input />` with no config is a valid text box.
+ */
+interface TxInputConfig {
+    /** Defaults to `text`. */
+    type?: TxInputType;
+    placeholder?: string;
+    /** Defaults to the surrounding form field's size, else `md`. */
+    size?: TxControlSize;
+    disabled?: boolean;
+    readonly?: boolean;
+    /**
+     * Marks the input required. A surrounding form field's `required` also
+     * applies, so this only needs setting on a bare input.
+     */
+    required?: boolean;
+    /**
+     * Forces the error appearance on a bare input. Inside a form field the
+     * field's `error` message already drives this, and the two are OR'd.
+     */
+    invalid?: boolean;
+    /** Registered icon name shown inside the leading edge. */
+    iconStart?: string;
+    /** Registered icon name shown inside the trailing edge. */
+    iconEnd?: string;
+    /** Shows a clear button once the input has a value. */
+    clearable?: boolean;
+    /** Native `name`, for uncontrolled form submission. */
+    name?: string;
+    /** Native `autocomplete` token. */
+    autocomplete?: string;
+    maxLength?: number;
+    /** Native `min`/`max`/`step`, meaningful for `type: 'number'`. */
+    min?: number;
+    max?: number;
+    step?: number;
+    /** Accessible name for a bare input with no surrounding form field. */
+    ariaLabel?: string;
+}
+declare const TX_INPUT_DEFAULTS: {
+    readonly type: "text";
+};
+
+/**
+ * A single-line text input.
+ *
+ * Renders a native `<input>`. Works three ways: with `[(value)]`, with
+ * `[formControl]` / `formControlName`, or uncontrolled with a `name`.
+ *
+ * @example
+ * ```html
+ * <tx-form-field [config]="{ label: 'Part number', required: true }">
+ *   <tx-input [config]="{ placeholder: 'e.g. 44-2201', iconStart: 'search', clearable: true }"
+ *             [(value)]="partNumber" />
+ * </tx-form-field>
+ * ```
+ *
+ * Config is a signal input — replace the object to change it:
+ * `this.inputConfig = { ...this.inputConfig, disabled: true }`.
+ */
+declare class TxInputComponent implements ControlValueAccessor {
+    readonly config: _angular_core.InputSignal<Partial<TxInputConfig>>;
+    /** Two-way bindable value. Also driven by `formControl` via CVA. */
+    readonly value: _angular_core.ModelSignal<string>;
+    /** Fires on the native `change` event, i.e. on commit rather than per key. */
+    readonly changed: _angular_core.OutputEmitterRef<string>;
+    /** Fires when the clear button empties the input. */
+    readonly cleared: _angular_core.OutputEmitterRef<void>;
+    private readonly field;
+    private readonly formField;
+    private readonly forms;
+    protected readonly fieldId: _angular_core.Signal<string>;
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    private readonly resolved;
+    protected readonly type: _angular_core.Signal<_tx_angular_design_system_ui_kit.TxInputType | undefined>;
+    protected readonly placeholder: _angular_core.Signal<string | null>;
+    protected readonly iconStart: _angular_core.Signal<string | null>;
+    protected readonly iconEnd: _angular_core.Signal<string | null>;
+    protected readonly isReadonly: _angular_core.Signal<boolean>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isInvalid: _angular_core.Signal<boolean>;
+    protected readonly isRequired: _angular_core.Signal<boolean>;
+    protected readonly size: _angular_core.Signal<"sm" | "md" | "lg">;
+    protected readonly iconSize: _angular_core.Signal<"sm" | "md">;
+    protected readonly showClear: _angular_core.Signal<boolean>;
+    protected readonly inputClass: _angular_core.Signal<string>;
+    /** Moves focus into the input. */
+    focus(): void;
+    protected onInput(event: Event): void;
+    protected onBlur(): void;
+    protected clear(): void;
+    writeValue(value: string): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TxInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TxInputComponent, "tx-input", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "changed": "changed"; "cleared": "cleared"; }, never, never, true, never>;
+}
+
+/** How the textarea handles growth. */
+type TxTextareaResize = 'vertical' | 'none' | 'auto';
+/** Simple property configuration for {@link TxTextareaComponent}. */
+interface TxTextareaConfig {
+    placeholder?: string;
+    /** Defaults to the surrounding form field's size, else `md`. */
+    size?: TxControlSize;
+    /** Visible rows before scrolling. Defaults to 3. */
+    rows?: number;
+    /**
+     * `vertical` (default) lets the user drag to resize; `none` locks the height;
+     * `auto` grows the textarea to fit its content and hides the drag handle.
+     */
+    resize?: TxTextareaResize;
+    disabled?: boolean;
+    readonly?: boolean;
+    required?: boolean;
+    invalid?: boolean;
+    maxLength?: number;
+    /** Shows a live "n / max" counter. Requires `maxLength`. */
+    showCount?: boolean;
+    name?: string;
+    ariaLabel?: string;
+}
+declare const TX_TEXTAREA_DEFAULTS: {
+    readonly rows: 3;
+    readonly resize: "vertical";
+};
+/**
+ * A multi-line text input.
+ *
+ * @example
+ * ```html
+ * <tx-form-field [config]="{ label: 'Failure description', required: true }">
+ *   <tx-textarea [config]="{ rows: 5, maxLength: 500, showCount: true }"
+ *                [(value)]="description" />
+ * </tx-form-field>
+ * ```
+ *
+ * Config is a signal input — replace the object rather than mutating it.
+ */
+declare class TxTextareaComponent implements ControlValueAccessor {
+    readonly config: _angular_core.InputSignal<Partial<TxTextareaConfig>>;
+    readonly value: _angular_core.ModelSignal<string>;
+    readonly changed: _angular_core.OutputEmitterRef<string>;
+    private readonly field;
+    private readonly formField;
+    private readonly forms;
+    protected readonly fieldId: _angular_core.Signal<string>;
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    private readonly resolved;
+    protected readonly rows: _angular_core.Signal<number | undefined>;
+    protected readonly placeholder: _angular_core.Signal<string | null>;
+    protected readonly isReadonly: _angular_core.Signal<boolean>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isInvalid: _angular_core.Signal<boolean>;
+    protected readonly isRequired: _angular_core.Signal<boolean>;
+    protected readonly size: _angular_core.Signal<"sm" | "md" | "lg">;
+    protected readonly showCount: _angular_core.Signal<boolean>;
+    protected readonly overLimit: _angular_core.Signal<boolean>;
+    protected readonly textareaClass: _angular_core.Signal<string>;
+    constructor();
+    /** Moves focus into the textarea. */
+    focus(): void;
+    protected onInput(event: Event): void;
+    protected onBlur(): void;
+    writeValue(value: string): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TxTextareaComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TxTextareaComponent, "tx-textarea", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "changed": "changed"; }, never, never, true, never>;
+}
+
+/** Simple property configuration for {@link TxCheckboxComponent}. */
+interface TxCheckboxConfig {
+    /**
+     * Inline label beside the box. Omit when a surrounding form field already
+     * labels the control.
+     */
+    label?: string;
+    /** Second line under the label, for the "what does this actually do" text. */
+    description?: string;
+    /** Defaults to the surrounding form field's size, else `md`. */
+    size?: TxControlSize;
+    /** Defaults to `after`. */
+    labelPosition?: 'after' | 'before';
+    /**
+     * Renders the mixed state. Indeterminate is a presentation of a tri-state
+     * parent, so it is separate from `value` rather than a third value.
+     */
+    indeterminate?: boolean;
+    disabled?: boolean;
+    required?: boolean;
+    invalid?: boolean;
+    name?: string;
+    ariaLabel?: string;
+}
+/**
+ * A checkbox.
+ *
+ * A native `input[type=checkbox]` tinted with `accent-color` from the theme, so
+ * the platform provides the checked, indeterminate, focus and disabled visuals
+ * rather than a re-implementation of them.
+ *
+ * @example
+ * ```html
+ * <tx-checkbox [config]="{ label: 'Include retired parts' }" [(checked)]="includeRetired" />
+ * ```
+ *
+ * Config is a signal input — replace the object rather than mutating it.
+ */
+declare class TxCheckboxComponent implements ControlValueAccessor {
+    readonly config: _angular_core.InputSignal<Partial<TxCheckboxConfig>>;
+    readonly checked: _angular_core.ModelSignal<boolean>;
+    readonly changed: _angular_core.OutputEmitterRef<boolean>;
+    private readonly box;
+    private readonly formField;
+    private readonly forms;
+    protected readonly fieldId: _angular_core.Signal<string>;
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    private readonly resolved;
+    protected readonly label: _angular_core.Signal<string | null>;
+    protected readonly description: _angular_core.Signal<string | null>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isInvalid: _angular_core.Signal<boolean>;
+    protected readonly isRequired: _angular_core.Signal<boolean>;
+    protected readonly size: _angular_core.Signal<"sm" | "md" | "lg">;
+    protected readonly labelClass: _angular_core.Signal<string>;
+    protected readonly boxClass: _angular_core.Signal<string>;
+    protected readonly textClass: _angular_core.Signal<string>;
+    constructor();
+    /** Moves focus onto the checkbox. */
+    focus(): void;
+    protected onChange(event: Event): void;
+    protected onBlur(): void;
+    writeValue(value: boolean): void;
+    registerOnChange(fn: (value: boolean) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TxCheckboxComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TxCheckboxComponent, "tx-checkbox", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "changed": "changed"; }, never, never, true, never>;
+}
+
+/**
+ * How each option is presented.
+ *
+ * `plain` is a bare radio and label; `card` is a bordered tile that tints when
+ * selected, which reads far better when options carry descriptions.
+ */
+type TxRadioAppearance = 'plain' | 'card';
+/** Simple property configuration for {@link TxRadioGroupComponent}. */
+interface TxRadioGroupConfig {
+    /** Defaults to `vertical`. */
+    orientation?: 'vertical' | 'horizontal';
+    /** Defaults to `plain`. */
+    appearance?: TxRadioAppearance;
+    /** Defaults to the surrounding form field's size, else `md`. */
+    size?: TxControlSize;
+    /** Disables every option at once. Individual options can also be disabled. */
+    disabled?: boolean;
+    required?: boolean;
+    invalid?: boolean;
+    /** Shared `name` for the radios. Generated when omitted. */
+    name?: string;
+    /** Accessible name when there is no surrounding form field. */
+    ariaLabel?: string;
+}
+declare const TX_RADIO_GROUP_DEFAULTS: {
+    readonly orientation: "vertical";
+    readonly appearance: "plain";
+};
+/**
+ * A group of mutually exclusive options, built from native radio inputs so
+ * arrow-key navigation and the roving tab stop come from the platform.
+ *
+ * Options are passed as data through `options`, not as a config field.
+ *
+ * @example
+ * ```html
+ * <tx-form-field [config]="{ label: 'Origin', required: true }">
+ *   <tx-radio-group
+ *     [options]="[{ value: 'field', label: 'Field' }, { value: 'qc', label: 'QC' }]"
+ *     [config]="{ orientation: 'horizontal' }"
+ *     [(value)]="origin" />
+ * </tx-form-field>
+ * ```
+ *
+ * Config is a signal input — replace the object rather than mutating it.
+ */
+declare class TxRadioGroupComponent<T = string> implements ControlValueAccessor {
+    readonly config: _angular_core.InputSignal<Partial<TxRadioGroupConfig>>;
+    /** The selectable options. Data, so it is its own input. */
+    readonly options: _angular_core.InputSignal<readonly TxOption<T>[]>;
+    /** Currently selected value, or `null` when nothing is selected. */
+    readonly value: _angular_core.ModelSignal<T | null>;
+    readonly changed: _angular_core.OutputEmitterRef<T>;
+    private readonly formField;
+    private readonly forms;
+    private readonly fallbackName;
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    protected readonly String: StringConstructor;
+    private readonly resolved;
+    protected readonly orientation: _angular_core.Signal<"vertical" | "horizontal" | undefined>;
+    protected readonly groupName: _angular_core.Signal<string>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isInvalid: _angular_core.Signal<boolean>;
+    protected readonly isRequired: _angular_core.Signal<boolean>;
+    protected readonly size: _angular_core.Signal<"sm" | "md" | "lg">;
+    protected readonly groupClass: _angular_core.Signal<string>;
+    protected readonly boxClass: _angular_core.Signal<string>;
+    protected isOptionDisabled(option: TxOption<T>): boolean;
+    protected optionClass(option: TxOption<T>): string;
+    protected labelClass(option: TxOption<T>): string;
+    protected select(option: TxOption<T>): void;
+    protected onBlur(): void;
+    writeValue(value: T | null): void;
+    registerOnChange(fn: (value: T | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TxRadioGroupComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TxRadioGroupComponent<any>, "tx-radio-group", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": true; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "changed": "changed"; }, never, never, true, never>;
+}
+
+/** Simple property configuration for {@link TxSwitchComponent}. */
+interface TxSwitchConfig {
+    /** Inline label beside the switch. */
+    label?: string;
+    /** Second line under the label. */
+    description?: string;
+    /** Defaults to the surrounding form field's size, else `md`. */
+    size?: TxControlSize;
+    /** Defaults to `after`. */
+    labelPosition?: 'after' | 'before';
+    disabled?: boolean;
+    required?: boolean;
+    name?: string;
+    ariaLabel?: string;
+}
+/**
+ * An on/off switch.
+ *
+ * A native `input[type=checkbox]` carrying `role="switch"`, as the brief
+ * requires — the platform provides keyboard activation, the checked state and
+ * the form value, and only the track/thumb appearance is ours. The visual state
+ * is driven entirely by the `checked:` variant reading the element's real
+ * state, never by classes toggled from TypeScript.
+ *
+ * @example
+ * ```html
+ * <tx-switch [config]="{ label: 'Notify on new failures' }" [(checked)]="notify" />
+ * ```
+ *
+ * Config is a signal input — replace the object rather than mutating it.
+ */
+declare class TxSwitchComponent implements ControlValueAccessor {
+    readonly config: _angular_core.InputSignal<Partial<TxSwitchConfig>>;
+    readonly checked: _angular_core.ModelSignal<boolean>;
+    readonly changed: _angular_core.OutputEmitterRef<boolean>;
+    private readonly control;
+    private readonly formField;
+    private readonly forms;
+    protected readonly fieldId: _angular_core.Signal<string>;
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    private readonly resolved;
+    protected readonly label: _angular_core.Signal<string | null>;
+    protected readonly description: _angular_core.Signal<string | null>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isRequired: _angular_core.Signal<boolean>;
+    protected readonly size: _angular_core.Signal<"sm" | "md" | "lg">;
+    protected readonly labelClass: _angular_core.Signal<string>;
+    protected readonly wrapperClass: _angular_core.Signal<string>;
+    protected readonly trackClass: _angular_core.Signal<string>;
+    protected readonly thumbClass: _angular_core.Signal<string>;
+    protected readonly textClass: _angular_core.Signal<string>;
+    /** Moves focus onto the switch. */
+    focus(): void;
+    protected onChange(event: Event): void;
+    protected onBlur(): void;
+    writeValue(value: boolean): void;
+    registerOnChange(fn: (value: boolean) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TxSwitchComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TxSwitchComponent, "tx-switch", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "changed": "changed"; }, never, never, true, never>;
+}
+
+/**
+ * Shared appearance for every popup surface — select, multiselect, dropdown
+ * tree, chips input, autocomplete, menu and the datepicker.
+ *
+ * Interaction state is styled from the attributes `@angular/aria` already
+ * emits, never from booleans mirrored into TypeScript:
+ *
+ *   `aria-selected` / `aria-disabled` / `aria-expanded` — Tailwind's built-in
+ *   aria variants match `="true"` exactly, so a `false` attribute (which
+ *   Angular still renders) does not match.
+ *
+ *   `data-active` — the roving "active descendant" marker. This one must be
+ *   written as `data-[active=true]:`, because Aria binds a boolean and Angular
+ *   renders `data-active="false"` rather than removing the attribute, which
+ *   would make a bare `data-active:` match at all times.
+ */
+/** Popup height, chosen per component through its config. */
+type TxPopupHeight = 'sm' | 'md' | 'lg';
+declare const TX_POPUP_MAX_HEIGHT: Record<TxPopupHeight, string>;
+/**
+ * The popup card itself. `min-h-0` matters: the CDK pane sets a max-height when
+ * the popup would otherwise leave the viewport, and without it the panel would
+ * refuse to shrink and the list would overflow the screen instead of scrolling.
+ */
+declare const TX_POPUP_PANEL_CLASS: string;
+/** The scrollable list inside the popup. */
+declare const TX_POPUP_LIST_CLASS: string;
+/** One option row. */
+declare const TX_POPUP_OPTION_CLASS: string;
+/** Group heading inside a popup list. */
+declare const TX_POPUP_GROUP_CLASS: string;
+/** "No results" / "No options" row. */
+declare const TX_POPUP_EMPTY_CLASS = "px-tx-3 py-tx-5 text-center text-tx-base text-tx-text-muted";
+
+/**
+ * Simple property configuration for {@link TxSelectComponent} and
+ * {@link TxMultiselectComponent}.
+ *
+ * Options are data and come through the component's own `options` input; a
+ * custom option renderer is structural and comes through `optionTemplate`.
+ * Neither belongs here.
+ */
+interface TxSelectConfig {
+    /** Shown in the trigger when nothing is selected. */
+    placeholder?: string;
+    /** Defaults to the surrounding form field's size, else `md`. */
+    size?: TxControlSize;
+    /** Defaults to `md`. */
+    popupHeight?: TxPopupHeight;
+    /** Shows a clear button in the trigger once something is selected. */
+    clearable?: boolean;
+    disabled?: boolean;
+    required?: boolean;
+    invalid?: boolean;
+    /** Message shown in the popup when `options` is empty. */
+    emptyText?: string;
+    /** Accessible name when there is no surrounding form field. */
+    ariaLabel?: string;
+    name?: string;
+}
+declare const TX_SELECT_DEFAULTS: {
+    readonly placeholder: "Select…";
+    readonly popupHeight: "md";
+    readonly emptyText: "No options";
+};
+/**
+ * How a multiselect summarises its selection in the closed trigger.
+ *
+ * A union rather than a pair of booleans, so the states stay mutually
+ * exclusive as more are added.
+ */
+type TxMultiselectSummary = 'chips' | 'comma' | 'count';
+/** Simple property configuration for {@link TxMultiselectComponent}. */
+interface TxMultiselectConfig extends TxSelectConfig {
+    /** Defaults to `chips`. */
+    summary?: TxMultiselectSummary;
+    /**
+     * Above this many selections a `chips` trigger collapses to a count, so a
+     * long selection cannot push the trigger to an unusable height. Defaults to 3.
+     */
+    maxVisibleChips?: number;
+}
+declare const TX_MULTISELECT_DEFAULTS: {
+    readonly placeholder: "Select…";
+    readonly summary: "chips";
+    readonly maxVisibleChips: 3;
+    readonly popupHeight: "md";
+    readonly emptyText: "No options";
+};
+
+/**
+ * A single-select dropdown.
+ *
+ * Behaviour is `@angular/aria`'s: `ngCombobox` on the trigger provides
+ * `role="combobox"`, `aria-expanded`, `aria-controls`, `aria-activedescendant`
+ * and key forwarding into the popup; `ngListbox`/`ngOption` provide roving
+ * activation, typeahead and selection. Positioning is
+ * {@link TxConnectedOverlayDirective}, which hosts the Aria popup template in a
+ * CDK overlay so it escapes `overflow` clipping and flips near a viewport edge.
+ *
+ * Every visual state is styled from the attributes Aria emits —
+ * `aria-selected`, `aria-disabled`, `aria-expanded`, `data-active` — so nothing
+ * is mirrored into a boolean and toggled from TypeScript.
+ *
+ * The trigger is deliberately assembled so a search box can be added inside it
+ * later without changing this public API: typed-text filtering is out of scope
+ * for v1.
+ *
+ * @example
+ * ```html
+ * <tx-form-field [config]="{ label: 'Disposition', required: true }">
+ *   <tx-select [options]="dispositions" [config]="{ clearable: true }" [(value)]="disposition" />
+ * </tx-form-field>
+ * ```
+ *
+ * Config is a signal input — replace the object rather than mutating it:
+ * `this.selectConfig = { ...this.selectConfig, disabled: true }`.
+ */
+declare class TxSelectComponent<T = string> implements ControlValueAccessor {
+    readonly config: _angular_core.InputSignal<Partial<TxSelectConfig>>;
+    /** The selectable options. Data, so it is its own input. */
+    readonly options: _angular_core.InputSignal<readonly TxOption<T>[]>;
+    /**
+     * Custom option renderer. Structural, so it is a `TemplateRef` input rather
+     * than a config field. Context: `$implicit` is the option, `selected` is a
+     * boolean.
+     */
+    readonly optionTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
+    /** Selected value, or `null`. */
+    readonly value: _angular_core.ModelSignal<T | null>;
+    readonly changed: _angular_core.OutputEmitterRef<T | null>;
+    readonly openedChange: _angular_core.OutputEmitterRef<boolean>;
+    protected readonly expanded: _angular_core.WritableSignal<boolean>;
+    private readonly trigger;
+    private readonly formField;
+    private readonly forms;
+    protected readonly fieldId: _angular_core.Signal<string>;
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    protected readonly optionClass: string;
+    protected readonly emptyClass = "px-tx-3 py-tx-5 text-center text-tx-base text-tx-text-muted";
+    protected readonly listClass: string;
+    protected readonly overlayConfig: Partial<TxOverlayConfig>;
+    private readonly resolved;
+    protected readonly emptyText: _angular_core.Signal<string | undefined>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isInvalid: _angular_core.Signal<boolean>;
+    protected readonly isRequired: _angular_core.Signal<boolean>;
+    protected readonly size: _angular_core.Signal<"sm" | "md" | "lg">;
+    protected readonly iconSize: _angular_core.Signal<"sm" | "md">;
+    private readonly selectedOption;
+    protected readonly triggerLabel: _angular_core.Signal<string>;
+    protected readonly showClear: _angular_core.Signal<boolean>;
+    /** Aria's listbox always models its value as an array, even single-select. */
+    protected readonly listboxValue: _angular_core.Signal<T[]>;
+    protected readonly triggerClass: _angular_core.Signal<string>;
+    protected readonly chevronClass: string;
+    protected readonly clearClass: string;
+    protected readonly valueClass: _angular_core.Signal<string>;
+    protected readonly panelClass: _angular_core.Signal<string>;
+    protected onListboxValue(next: T[]): void;
+    protected onOverlayClosed(reason: TxOverlayCloseReason): void;
+    private close;
+    protected clear(event: MouseEvent): void;
+    /** Moves focus onto the trigger. */
+    focus(): void;
+    writeValue(value: T | null): void;
+    registerOnChange(fn: (value: T | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TxSelectComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TxSelectComponent<any>, "tx-select", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": true; "isSignal": true; }; "optionTemplate": { "alias": "optionTemplate"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "changed": "changed"; "openedChange": "openedChange"; }, never, never, true, never>;
+}
+
+/**
+ * A multi-select dropdown.
+ *
+ * Same Aria machinery as {@link TxSelectComponent}, with `multi` on the listbox
+ * and a popup that stays open across selections. The closed trigger summarises
+ * the selection as chips, a comma-joined list or a count, chosen through the
+ * config's `summary` union rather than a set of booleans.
+ *
+ * @example
+ * ```html
+ * <tx-form-field [config]="{ label: 'Symptoms' }">
+ *   <tx-multiselect [options]="symptoms" [config]="{ summary: 'chips' }" [(value)]="selected" />
+ * </tx-form-field>
+ * ```
+ *
+ * Config is a signal input — replace the object rather than mutating it.
+ */
+declare class TxMultiselectComponent<T = string> implements ControlValueAccessor {
+    readonly config: _angular_core.InputSignal<Partial<TxMultiselectConfig>>;
+    /** The selectable options. Data, so it is its own input. */
+    readonly options: _angular_core.InputSignal<readonly TxOption<T>[]>;
+    /** Custom option renderer. Structural, so a template rather than config. */
+    readonly optionTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
+    /** Selected values. */
+    readonly value: _angular_core.ModelSignal<T[]>;
+    readonly changed: _angular_core.OutputEmitterRef<T[]>;
+    readonly openedChange: _angular_core.OutputEmitterRef<boolean>;
+    protected readonly expanded: _angular_core.WritableSignal<boolean>;
+    private readonly trigger;
+    private readonly formField;
+    private readonly forms;
+    protected readonly fieldId: _angular_core.Signal<string>;
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    protected readonly optionClass: string;
+    protected readonly emptyClass = "px-tx-3 py-tx-5 text-center text-tx-base text-tx-text-muted";
+    protected readonly listClass: string;
+    protected readonly overlayConfig: Partial<TxOverlayConfig>;
+    private readonly resolved;
+    protected readonly placeholder: _angular_core.Signal<string | undefined>;
+    protected readonly summary: _angular_core.Signal<_tx_angular_design_system_ui_kit.TxMultiselectSummary | undefined>;
+    protected readonly emptyText: _angular_core.Signal<string | undefined>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isInvalid: _angular_core.Signal<boolean>;
+    protected readonly isRequired: _angular_core.Signal<boolean>;
+    protected readonly size: _angular_core.Signal<"sm" | "md" | "lg">;
+    protected readonly iconSize: _angular_core.Signal<"sm" | "md">;
+    private readonly selectedLabels;
+    protected readonly chips: _angular_core.Signal<{
+        visible: string[];
+        overflow: number;
+    }>;
+    protected readonly summaryText: _angular_core.Signal<string>;
+    protected readonly showClear: _angular_core.Signal<boolean>;
+    protected readonly triggerClass: _angular_core.Signal<string>;
+    protected readonly chevronClass: string;
+    protected readonly clearClass: string;
+    protected readonly panelClass: _angular_core.Signal<string>;
+    protected onListboxValue(next: T[]): void;
+    protected onOverlayClosed(reason: TxOverlayCloseReason): void;
+    protected clear(event: MouseEvent): void;
+    /** Moves focus onto the trigger. */
+    focus(): void;
+    writeValue(value: T[]): void;
+    registerOnChange(fn: (value: T[]) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TxMultiselectComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TxMultiselectComponent<any>, "tx-multiselect", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": true; "isSignal": true; }; "optionTemplate": { "alias": "optionTemplate"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "changed": "changed"; "openedChange": "openedChange"; }, never, never, true, never>;
+}
+
+/**
+ * Builds the text a closed multi-select trigger shows.
+ *
+ * Shared by the multiselect and the dropdown tree so the two never drift into
+ * summarising the same selection differently.
+ */
+declare function txSelectionSummary(labels: readonly string[], mode: 'comma' | 'count', noun?: string): string;
+/**
+ * Splits labels into the chips to render and the number hidden behind a
+ * "+n" pill, so a long selection cannot grow the trigger without bound.
+ */
+declare function txVisibleChips(labels: readonly string[], maxVisible: number): {
+    visible: string[];
+    overflow: number;
+};
+
+/**
+ * One node in a {@link TxTreeComponent}.
+ *
+ * Nodes are data. Anything structural about how a node is drawn — a leading
+ * control, a badge, trailing actions — is a `TemplateRef` slot on the component,
+ * never a field here.
+ */
+interface TxTreeNode<T = string> {
+    /** Unique across the whole tree. Carried in the selection value. */
+    id: T;
+    label: string;
+    children?: readonly TxTreeNode<T>[];
+    /** Registered icon name shown before the label. */
+    icon?: string;
+    /** Short text rendered in the default badge slot. */
+    badge?: string;
+    disabled?: boolean;
+    /** Defaults to true. Set false for a node that is a container only. */
+    selectable?: boolean;
+    /** Application payload. Passed back in slot contexts and in outputs. */
+    data?: unknown;
+}
+/**
+ * How many nodes may be selected.
+ *
+ * A union rather than a `multi` boolean, so `none` is a first-class state
+ * instead of an absence that has to be inferred.
+ */
+type TxTreeSelection = 'none' | 'single' | 'multiple';
+/**
+ * Whether the built-in checkbox indicator fills the leading slot, and for which
+ * nodes. Ignored when a `leadingTemplate` is supplied.
+ */
+type TxTreeCheckboxes = 'none' | 'all' | 'leaf';
+/** Whether branches can be collapsed. */
+type TxTreeExpansion = 'collapsible' | 'static';
+/** Whether connector lines are drawn between parents and children. */
+type TxTreeGuides = 'lines' | 'none';
+/** Simple property configuration for {@link TxTreeComponent}. */
+interface TxTreeConfig {
+    /** Defaults to `single`. */
+    selection?: TxTreeSelection;
+    /** Defaults to `none`. Pairs naturally with `selection: 'multiple'`. */
+    checkboxes?: TxTreeCheckboxes;
+    /** Defaults to `collapsible`. */
+    expansion?: TxTreeExpansion;
+    /** Defaults to `lines`, matching the reference tree of parts. */
+    guides?: TxTreeGuides;
+    /** Defaults to `md`. */
+    size?: 'sm' | 'md';
+    disabled?: boolean;
+    /** Message shown when `nodes` is empty. */
+    emptyText?: string;
+    /** Accessible name for the tree. */
+    ariaLabel?: string;
+}
+declare const TX_TREE_DEFAULTS: {
+    readonly selection: "single";
+    readonly checkboxes: "none";
+    readonly expansion: "collapsible";
+    readonly guides: "lines";
+    readonly size: "md";
+    readonly emptyText: "No items";
+};
+/**
+ * Context handed to every tree slot template.
+ *
+ * `$implicit` is the node, so `let-node` works without naming the key.
+ */
+interface TxTreeSlotContext<T = string> {
+    $implicit: TxTreeNode<T>;
+    node: TxTreeNode<T>;
+    /** 1-based depth, matching `aria-level`. */
+    level: number;
+    selected: boolean;
+    expanded: boolean;
+    hasChildren: boolean;
+}
+/** Flattens a node tree into visible rows, honouring collapsed branches. */
+declare function flattenTxTree<T>(nodes: readonly TxTreeNode<T>[], isExpanded: (node: TxTreeNode<T>) => boolean, level?: number): {
+    node: TxTreeNode<T>;
+    level: number;
+}[];
+/** Every node id in the tree, depth-first. */
+declare function txTreeNodeIds<T>(nodes: readonly TxTreeNode<T>[]): T[];
+/** Ids of every node that has children, depth-first. */
+declare function txTreeBranchIds<T>(nodes: readonly TxTreeNode<T>[]): T[];
+/** Finds a node by id, searching depth-first. */
+declare function findTxTreeNode<T>(nodes: readonly TxTreeNode<T>[], id: T): TxTreeNode<T> | null;
+
+/** Simple property configuration for {@link TxDropdownTreeComponent}. */
+interface TxDropdownTreeConfig {
+    /** Shown in the trigger when nothing is selected. */
+    placeholder?: string;
+    /**
+     * Defaults to `single`: the popup closes on selection. `multiple` keeps the
+     * popup open and turns on the tree's leading checkbox indicator.
+     */
+    selection?: 'single' | 'multiple';
+    /** How a multiple selection is summarised in the closed trigger. Defaults to `chips`. */
+    summary?: TxMultiselectSummary;
+    /** Chips shown before collapsing to a "+n" pill. Defaults to 3. */
+    maxVisibleChips?: number;
+    /** Defaults to the surrounding form field's size, else `md`. */
+    size?: TxControlSize;
+    /** Defaults to `md`. */
+    popupHeight?: TxPopupHeight;
+    /** Forwarded to the tree. Defaults to `all` when selection is `multiple`. */
+    checkboxes?: TxTreeCheckboxes;
+    /** Forwarded to the tree. Defaults to `collapsible`. */
+    expansion?: TxTreeExpansion;
+    /** Forwarded to the tree. Defaults to `lines`. */
+    guides?: TxTreeGuides;
+    clearable?: boolean;
+    disabled?: boolean;
+    required?: boolean;
+    invalid?: boolean;
+    emptyText?: string;
+    ariaLabel?: string;
+    name?: string;
+}
+declare const TX_DROPDOWN_TREE_DEFAULTS: {
+    readonly placeholder: "Select…";
+    readonly selection: "single";
+    readonly summary: "chips";
+    readonly maxVisibleChips: 3;
+    readonly popupHeight: "md";
+    readonly expansion: "collapsible";
+    readonly guides: "lines";
+    readonly emptyText: "No items";
+};
+/**
+ * A select-style trigger whose popup contains a tree.
+ *
+ * Assembled from the pieces that already exist rather than reimplemented: the
+ * combobox trigger and {@link TxConnectedOverlayDirective} from the select, and
+ * {@link TxTreeComponent} for everything inside the popup. No node-rendering
+ * logic is duplicated — the tree's `comboboxHost` input is the extension point
+ * that lets it act as the combobox's popup widget, so `aria-controls` points at
+ * the real `role="tree"` element and its collapsible behaviour, badge slot and
+ * leading-checkbox slot all work exactly as they do standalone.
+ *
+ * Single-select closes the popup on selection and shows the node's label.
+ * Multi-select keeps the popup open, turns on the tree's checkbox indicator and
+ * summarises the selection in the trigger.
+ *
+ * Typed-text filtering inside the trigger is out of scope for v1. The trigger is
+ * laid out so a search box can be added inside the popup later without changing
+ * this public API.
+ *
+ * @example
+ * ```html
+ * <tx-form-field [config]="{ label: 'Failed part' }">
+ *   <tx-dropdown-tree
+ *     [nodes]="assemblyTree"
+ *     [config]="{ selection: 'multiple', summary: 'chips', clearable: true }"
+ *     [(selectedIds)]="failedParts" />
+ * </tx-form-field>
+ * ```
+ *
+ * Config is a signal input — replace the object rather than mutating it.
+ */
+declare class TxDropdownTreeComponent<T = string> implements ControlValueAccessor {
+    readonly config: _angular_core.InputSignal<Partial<TxDropdownTreeConfig>>;
+    /** The node hierarchy. Data, so it is its own input. */
+    readonly nodes: _angular_core.InputSignal<readonly TxTreeNode<T>[]>;
+    /** Selected node ids. Always an array, including in single-select. */
+    readonly selectedIds: _angular_core.ModelSignal<T[]>;
+    /** Expanded branch ids, forwarded to the tree. */
+    readonly expandedIds: _angular_core.ModelSignal<T[]>;
+    readonly leadingTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
+    readonly badgeTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
+    readonly actionsTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
+    readonly changed: _angular_core.OutputEmitterRef<T[]>;
+    readonly openedChange: _angular_core.OutputEmitterRef<boolean>;
+    protected readonly expanded: _angular_core.WritableSignal<boolean>;
+    private readonly trigger;
+    private readonly formField;
+    private readonly forms;
+    protected readonly fieldId: _angular_core.Signal<string>;
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    protected readonly overlayConfig: Partial<TxOverlayConfig>;
+    private readonly resolved;
+    protected readonly placeholder: _angular_core.Signal<string | undefined>;
+    protected readonly summary: _angular_core.Signal<TxMultiselectSummary | undefined>;
+    protected readonly isMultiple: _angular_core.Signal<boolean>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isInvalid: _angular_core.Signal<boolean>;
+    protected readonly isRequired: _angular_core.Signal<boolean>;
+    protected readonly size: _angular_core.Signal<"sm" | "md" | "lg">;
+    protected readonly iconSize: _angular_core.Signal<"sm" | "md">;
+    /** Everything the tree needs, derived from this component's own config. */
+    protected readonly treeConfig: _angular_core.Signal<{
+        selection: "single" | "multiple";
+        checkboxes: TxTreeCheckboxes;
+        expansion: TxTreeExpansion | undefined;
+        guides: TxTreeGuides | undefined;
+        emptyText: string | undefined;
+        size: "sm" | "md";
+        disabled: boolean;
+    }>;
+    private readonly selectedLabels;
+    protected readonly chips: _angular_core.Signal<{
+        visible: string[];
+        overflow: number;
+    }>;
+    protected readonly triggerText: _angular_core.Signal<string>;
+    protected readonly showClear: _angular_core.Signal<boolean>;
+    protected readonly triggerClass: _angular_core.Signal<string>;
+    protected readonly chevronClass: string;
+    protected readonly clearClass: string;
+    protected readonly panelClass: _angular_core.Signal<string>;
+    protected onTreeSelection(next: T[]): void;
+    protected onOverlayClosed(reason: TxOverlayCloseReason): void;
+    private close;
+    protected clear(event: MouseEvent): void;
+    /** Moves focus onto the trigger. */
+    focus(): void;
+    writeValue(value: T[]): void;
+    registerOnChange(fn: (value: T[]) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TxDropdownTreeComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TxDropdownTreeComponent<any>, "tx-dropdown-tree", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; "nodes": { "alias": "nodes"; "required": true; "isSignal": true; }; "selectedIds": { "alias": "selectedIds"; "required": false; "isSignal": true; }; "expandedIds": { "alias": "expandedIds"; "required": false; "isSignal": true; }; "leadingTemplate": { "alias": "leadingTemplate"; "required": false; "isSignal": true; }; "badgeTemplate": { "alias": "badgeTemplate"; "required": false; "isSignal": true; }; "actionsTemplate": { "alias": "actionsTemplate"; "required": false; "isSignal": true; }; }, { "selectedIds": "selectedIdsChange"; "expandedIds": "expandedIdsChange"; "changed": "changed"; "openedChange": "openedChange"; }, never, never, true, never>;
+}
+
+/**
+ * Where new chip values may come from.
+ *
+ * A union rather than `allowFreeText` + `allowSuggestions` booleans, so the
+ * three states stay mutually exclusive as they are added to.
+ */
+type TxChipsSource = 'free-text' | 'suggestions' | 'both';
+/** Simple property configuration for {@link TxChipsInputComponent}. */
+interface TxChipsInputConfig {
+    placeholder?: string;
+    /** Defaults to the surrounding form field's size, else `md`. */
+    size?: TxControlSize;
+    /** Defaults to `both`. */
+    source?: TxChipsSource;
+    /** Defaults to `md`. */
+    popupHeight?: TxPopupHeight;
+    /** Refuses a value already present. Defaults to true. */
+    unique?: boolean;
+    /** Maximum number of chips. Further input is refused once reached. */
+    max?: number;
+    /** Keys that commit the typed text. Defaults to Enter and comma. */
+    commitKeys?: readonly string[];
+    disabled?: boolean;
+    required?: boolean;
+    invalid?: boolean;
+    /** Message shown in the popup when nothing matches. */
+    emptyText?: string;
+    ariaLabel?: string;
+}
+declare const TX_CHIPS_INPUT_DEFAULTS: {
+    readonly placeholder: "Add…";
+    readonly source: "both";
+    readonly popupHeight: "md";
+    readonly unique: true;
+    readonly commitKeys: readonly ["Enter", ","];
+    readonly emptyText: "No matches";
+};
+/**
+ * A text field that turns entries into removable chips, with an optional
+ * suggestion popup.
+ *
+ * The popup is `@angular/aria`'s combobox and listbox — the same primitives and
+ * the same overlay as the select — driven by an editable `<input>` rather than a
+ * static trigger, which is exactly the autocomplete shape Aria's combobox is
+ * built for. Suggestions filter as you type.
+ *
+ * Backspace on an empty field removes the last chip, matching every chips input
+ * people already know.
+ *
+ * @example
+ * ```html
+ * <tx-form-field [config]="{ label: 'Symptoms' }">
+ *   <tx-chips-input
+ *     [suggestions]="symptomOptions"
+ *     [config]="{ placeholder: 'Add a symptom…', max: 8 }"
+ *     [(value)]="symptoms" />
+ * </tx-form-field>
+ * ```
+ *
+ * Config is a signal input — replace the object rather than mutating it.
+ */
+declare class TxChipsInputComponent implements ControlValueAccessor {
+    readonly config: _angular_core.InputSignal<Partial<TxChipsInputConfig>>;
+    /** Optional suggestions. Data, so it is its own input. */
+    readonly suggestions: _angular_core.InputSignal<readonly TxOption<string>[]>;
+    /** The committed chip values. */
+    readonly value: _angular_core.ModelSignal<string[]>;
+    readonly changed: _angular_core.OutputEmitterRef<string[]>;
+    /** Emitted when a value is refused — duplicate, or over `max`. */
+    readonly rejected: _angular_core.OutputEmitterRef<{
+        value: string;
+        reason: "duplicate" | "max";
+    }>;
+    protected readonly expanded: _angular_core.WritableSignal<boolean>;
+    protected readonly query: _angular_core.WritableSignal<string>;
+    private readonly shell;
+    private readonly field;
+    private readonly formField;
+    private readonly forms;
+    protected readonly fieldId: _angular_core.Signal<string>;
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    protected readonly optionClass: string;
+    protected readonly emptyClass = "px-tx-3 py-tx-5 text-center text-tx-base text-tx-text-muted";
+    protected readonly listClass: string;
+    protected readonly overlayConfig: Partial<TxOverlayConfig>;
+    private readonly resolved;
+    protected readonly placeholder: _angular_core.Signal<string | undefined>;
+    protected readonly emptyText: _angular_core.Signal<string | undefined>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isInvalid: _angular_core.Signal<boolean>;
+    protected readonly isRequired: _angular_core.Signal<boolean>;
+    protected readonly size: _angular_core.Signal<"sm" | "md" | "lg">;
+    protected readonly atMax: _angular_core.Signal<boolean>;
+    /** Suggestions matching the query and not already chosen. */
+    protected readonly filtered: _angular_core.Signal<TxOption<string>[]>;
+    protected readonly shellClass: _angular_core.Signal<string>;
+    protected readonly panelClass: _angular_core.Signal<string>;
+    /** The suggestion's label if the chip came from one, else the raw value. */
+    protected labelFor(value: string): string;
+    /** Moves focus into the text field. */
+    focus(): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    protected onSuggestionPicked(picked: string[]): void;
+    /** Adds a value as a chip, applying the uniqueness and max rules. */
+    add(raw: string): void;
+    protected remove(chip: string, event: MouseEvent): void;
+    protected onOverlayClosed(reason: TxOverlayCloseReason): void;
+    protected onBlur(): void;
+    private commitValue;
+    writeValue(value: string[]): void;
+    registerOnChange(fn: (value: string[]) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TxChipsInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TxChipsInputComponent, "tx-chips-input", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; "suggestions": { "alias": "suggestions"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "changed": "changed"; "rejected": "rejected"; }, never, never, true, never>;
+}
+
+/**
+ * Pure date helpers for {@link TxDatepickerComponent}.
+ *
+ * Everything here is local-time and constructed with `new Date(y, m, d)` rather
+ * than by parsing strings, so a date never shifts a day across a timezone
+ * boundary. Kept separate from the component because parsing and grid building
+ * are exactly the sort of logic that is easy to get subtly wrong, and are the
+ * part worth unit-testing.
+ */
+/** Supported input/display formats. */
+type TxDateFormat = 'iso' | 'dmy' | 'mdy';
+/** 0 = Sunday … 6 = Saturday. */
+type TxWeekday = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+/** Midnight local time on the same calendar day. */
+declare function txStartOfDay(date: Date): Date;
+/** Whether two dates fall on the same calendar day. */
+declare function txIsSameDay(a: Date | null, b: Date | null): boolean;
+/** Whether two dates fall in the same calendar month. */
+declare function txIsSameMonth(a: Date, b: Date): boolean;
+/** The first day of `date`'s month. */
+declare function txStartOfMonth(date: Date): Date;
+/**
+ * Adds whole months, clamping the day so that adding a month to 31 January
+ * gives 28/29 February rather than rolling into March.
+ */
+declare function txAddMonths(date: Date, months: number): Date;
+/** Adds whole days. */
+declare function txAddDays(date: Date, days: number): Date;
+/** Number of days in a given month. `month` is 0-based. */
+declare function txDaysInMonth(year: number, month: number): number;
+/** Restricts a date to the inclusive `[min, max]` range. */
+declare function txClampDate(date: Date, min?: Date | null, max?: Date | null): Date;
+/** Whether a date falls inside the inclusive `[min, max]` range. */
+declare function txIsWithin(date: Date, min?: Date | null, max?: Date | null): boolean;
+/**
+ * Formats a date for display and for the text input.
+ *
+ * Always zero-padded and always four-digit years, so the output round-trips
+ * back through {@link txParseDate} unchanged.
+ */
+declare function txFormatDate(date: Date | null, format: TxDateFormat): string;
+/** The placeholder that matches a format, e.g. `dd/mm/yyyy`. */
+declare function txFormatPlaceholder(format: TxDateFormat): string;
+/**
+ * Parses user-typed text.
+ *
+ * Accepts `-`, `/` and `.` as separators regardless of format, and one- or
+ * two-digit day/month parts, because people type `1/2/2026` far more often than
+ * `01/02/2026`. Returns `null` for anything that is not a real calendar date —
+ * notably 31 February, which a naive `new Date` would silently roll into March.
+ */
+declare function txParseDate(text: string, format: TxDateFormat): Date | null;
+/** One cell of the month grid. */
+interface TxCalendarDay {
+    date: Date;
+    /** False for the leading/trailing days borrowed from adjacent months. */
+    inMonth: boolean;
+}
+/**
+ * Builds a six-week grid covering `month`, padded with adjacent months' days.
+ *
+ * Always six rows, so the popup does not change height as the user pages
+ * through months.
+ */
+declare function txBuildMonthGrid(year: number, month: number, firstDayOfWeek?: TxWeekday): TxCalendarDay[][];
+/** Weekday initials starting from `firstDayOfWeek`, in the given locale. */
+declare function txWeekdayLabels(firstDayOfWeek?: TxWeekday, locale?: string): string[];
+/** Month and year heading, e.g. `February 2026`. */
+declare function txMonthLabel(date: Date, locale?: string): string;
+/** Full date for an accessible label, e.g. `Monday, 2 February 2026`. */
+declare function txFullDateLabel(date: Date, locale?: string): string;
+
+/**
+ * How a date may be entered.
+ *
+ * A union rather than a `readonly` boolean, so a third mode can be added
+ * without the two existing ones becoming ambiguous.
+ */
+type TxDatepickerEntry = 'typed' | 'picker-only';
+/** Simple property configuration for {@link TxDatepickerComponent}. */
+interface TxDatepickerConfig {
+    /** Defaults to the placeholder implied by `format`, e.g. `dd/mm/yyyy`. */
+    placeholder?: string;
+    /** Defaults to the surrounding form field's size, else `md`. */
+    size?: TxControlSize;
+    /** Display and parse format. Defaults to `iso`. */
+    format?: TxDateFormat;
+    /** Earliest selectable date, inclusive. */
+    min?: Date | null;
+    /** Latest selectable date, inclusive. */
+    max?: Date | null;
+    /** 0 = Sunday … 6 = Saturday. Defaults to Monday. */
+    firstDayOfWeek?: TxWeekday;
+    /** BCP 47 tag for month and weekday names. Defaults to the browser's. */
+    locale?: string;
+    /** Defaults to `typed`. */
+    entry?: TxDatepickerEntry;
+    /** Shows a "Today" shortcut in the calendar footer. Defaults to true. */
+    showToday?: boolean;
+    clearable?: boolean;
+    disabled?: boolean;
+    required?: boolean;
+    invalid?: boolean;
+    ariaLabel?: string;
+    name?: string;
+}
+declare const TX_DATEPICKER_DEFAULTS: {
+    readonly format: "iso";
+    readonly firstDayOfWeek: 1;
+    readonly entry: "typed";
+    readonly showToday: true;
+};
+/**
+ * A date field with a calendar popup.
+ *
+ * `@angular/aria` has no datepicker, so the popup is a CDK overlay positioned by
+ * {@link TxConnectedOverlayDirective} — the same one the select uses, which is
+ * what keeps a datepicker inside a scrolling panel from being clipped. The
+ * calendar is a `role="grid"` with a roving tab stop, matching the ARIA date
+ * picker dialog pattern.
+ *
+ * Parsing and formatting live in `date-utils`, away from the component, because
+ * they are the part that is easy to get subtly wrong — and they are unit-tested
+ * there rather than through the DOM.
+ *
+ * @example
+ * ```html
+ * <tx-form-field [config]="{ label: 'Failure date', required: true }">
+ *   <tx-datepicker [config]="{ format: 'dmy', max: today, clearable: true }" [(value)]="failedOn" />
+ * </tx-form-field>
+ * ```
+ *
+ * Config is a signal input — replace the object rather than mutating it.
+ */
+declare class TxDatepickerComponent implements ControlValueAccessor {
+    readonly config: _angular_core.InputSignal<Partial<TxDatepickerConfig>>;
+    /** The selected date, or `null`. */
+    readonly value: _angular_core.ModelSignal<Date | null>;
+    readonly changed: _angular_core.OutputEmitterRef<Date | null>;
+    readonly openedChange: _angular_core.OutputEmitterRef<boolean>;
+    protected readonly expanded: _angular_core.WritableSignal<boolean>;
+    protected readonly text: _angular_core.WritableSignal<string>;
+    /** The day the roving tab stop is on. Drives arrow-key navigation. */
+    protected readonly focusedDate: _angular_core.WritableSignal<Date>;
+    /** First of the visible month. */
+    protected readonly viewMonth: _angular_core.WritableSignal<Date>;
+    protected readonly todayDate: Date;
+    protected readonly gridLabelId: string;
+    protected readonly panelClass: string;
+    protected readonly txIsSameDay: typeof txIsSameDay;
+    protected readonly navClass: string;
+    protected readonly footerClass: string;
+    protected readonly overlayConfig: Partial<TxOverlayConfig>;
+    private readonly field;
+    private readonly trigger;
+    private readonly formField;
+    private readonly forms;
+    protected readonly fieldId: _angular_core.Signal<string>;
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    private readonly resolved;
+    protected readonly format: _angular_core.Signal<TxDateFormat>;
+    protected readonly showToday: _angular_core.Signal<boolean>;
+    protected readonly isPickerOnly: _angular_core.Signal<boolean>;
+    protected readonly placeholder: _angular_core.Signal<string>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly isInvalid: _angular_core.Signal<boolean>;
+    protected readonly isRequired: _angular_core.Signal<boolean>;
+    protected readonly size: _angular_core.Signal<"sm" | "md" | "lg">;
+    protected readonly iconSize: _angular_core.Signal<"sm" | "md">;
+    protected readonly showClear: _angular_core.Signal<boolean>;
+    protected readonly shellClass: _angular_core.Signal<string>;
+    protected readonly weekdays: _angular_core.Signal<string[]>;
+    protected readonly monthLabel: _angular_core.Signal<string>;
+    protected readonly weeks: _angular_core.Signal<_tx_angular_design_system_ui_kit.TxCalendarDay[][]>;
+    protected readonly canGoPrevious: _angular_core.Signal<boolean>;
+    protected readonly canGoNext: _angular_core.Signal<boolean>;
+    constructor();
+    protected selectable(date: Date): boolean;
+    protected isToday(date: Date): boolean;
+    protected isFocused(date: Date): boolean;
+    protected fullLabel(date: Date): string;
+    protected dayClass(date: Date, inMonth: boolean): string;
+    /** Opens the calendar. */
+    open(): void;
+    /** Closes the calendar. */
+    close(restoreFocus?: boolean): void;
+    protected toggle(): void;
+    protected onOverlayClosed(reason: TxOverlayCloseReason): void;
+    protected onInput(event: Event): void;
+    protected onBlur(): void;
+    protected onFieldKeydown(event: KeyboardEvent): void;
+    protected onCalendarKeydown(event: KeyboardEvent): void;
+    protected shiftMonth(delta: number): void;
+    protected pick(date: Date): void;
+    protected clear(): void;
+    /** Moves focus onto the text field. */
+    focus(): void;
+    private commit;
+    /**
+     * Moves DOM focus onto the day carrying the roving tab stop, once the grid
+     * has rendered the new month.
+     */
+    private focusActiveDay;
+    writeValue(value: Date | string | null): void;
+    registerOnChange(fn: (value: Date | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TxDatepickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TxDatepickerComponent, "tx-datepicker", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "changed": "changed"; "openedChange": "openedChange"; }, never, never, true, never>;
+}
+
+/**
+ * A hierarchical tree of nodes.
+ *
+ * Behaviour is `@angular/aria`'s `ngTree` / `ngTreeItem` / `ngTreeItemGroup`:
+ * roving focus, typeahead, arrow-key expansion, deferred rendering of collapsed
+ * branches, and the full `treeitem` ARIA contract. Every visual state is read
+ * off the attributes Aria emits — `aria-selected`, `aria-expanded`,
+ * `aria-disabled`, `data-active` — so nothing is mirrored into a boolean and
+ * toggled from TypeScript.
+ *
+ * ## Slots
+ *
+ * Structural customisation goes through `TemplateRef` inputs, not config:
+ * `leadingTemplate` (before the label), `badgeTemplate` (after the label) and
+ * `actionsTemplate` (trailing). Each receives a {@link TxTreeSlotContext}. The
+ * `checkboxes` config fills the leading slot with a built-in indicator when no
+ * `leadingTemplate` is given, so the common case needs no template at all.
+ *
+ * ## Reuse by the dropdown tree
+ *
+ * `comboboxHost` is the extension point that lets {@link TxDropdownTreeComponent}
+ * compose this component into a combobox popup rather than re-implementing node
+ * rendering. Setting it applies `ngComboboxWidget` to the `role="tree"` element
+ * so the combobox's `aria-controls` points at the tree itself. Only the two
+ * `<ul>` declarations differ between the modes; every node is rendered by the
+ * one recursive template below.
+ *
+ * @example
+ * ```html
+ * <tx-tree
+ *   [nodes]="parts"
+ *   [config]="{ selection: 'multiple', checkboxes: 'all' }"
+ *   [(selectedIds)]="selected"
+ *   [actionsTemplate]="rowActions" />
+ *
+ * <ng-template #rowActions let-node>
+ *   <tx-button [config]="{ label: 'Rename ' + node.label, icon: 'edit',
+ *                          display: 'icon-only', variant: 'ghost', size: 'sm' }" />
+ * </ng-template>
+ * ```
+ *
+ * Config is a signal input — replace the object rather than mutating it.
+ */
+declare class TxTreeComponent<T = string> {
+    readonly config: _angular_core.InputSignal<Partial<TxTreeConfig>>;
+    /** The node hierarchy. Data, so it is its own input. */
+    readonly nodes: _angular_core.InputSignal<readonly TxTreeNode<T>[]>;
+    /** Selected node ids. Always an array, including in single-select. */
+    readonly selectedIds: _angular_core.ModelSignal<T[]>;
+    /** Expanded branch ids. Two-way, so a page can expand or collapse all. */
+    readonly expandedIds: _angular_core.ModelSignal<T[]>;
+    /** Before the label. Replaces the built-in checkbox indicator. */
+    readonly leadingTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
+    /** After the label. Replaces the node's `badge` text. */
+    readonly badgeTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
+    /** Trailing row actions. Revealed on hover, focus-within or selection. */
+    readonly actionsTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
+    /**
+     * Extension point for {@link TxDropdownTreeComponent}: the combobox this tree
+     * is the popup widget for. Leave unset for a standalone tree.
+     */
+    readonly comboboxHost: _angular_core.InputSignal<Combobox | null>;
+    readonly selectionChange: _angular_core.OutputEmitterRef<T[]>;
+    readonly expansionChange: _angular_core.OutputEmitterRef<T[]>;
+    private readonly resolved;
+    private readonly expandedSet;
+    protected readonly emptyText: _angular_core.Signal<string | undefined>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly selectionEnabled: _angular_core.Signal<boolean>;
+    protected readonly isMulti: _angular_core.Signal<boolean>;
+    protected readonly collapsible: _angular_core.Signal<boolean>;
+    protected readonly treeClass: _angular_core.Signal<string>;
+    protected readonly rowClass: _angular_core.Signal<string>;
+    /** Expands every branch. */
+    expandAll(): void;
+    /** Collapses every branch. */
+    collapseAll(): void;
+    protected isExpanded(id: T): boolean;
+    protected setExpanded(id: T, expanded: boolean): void;
+    protected toggle(id: T, event: MouseEvent): void;
+    protected showCheckbox(node: TxTreeNode<T>): boolean;
+    protected slotContext(node: TxTreeNode<T>, level: number): {
+        $implicit: TxTreeNode<T>;
+        node: TxTreeNode<T>;
+        level: number;
+        selected: boolean;
+        expanded: boolean;
+        hasChildren: boolean;
+    };
+    protected onValue(next: T[]): void;
+    private setExpansion;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TxTreeComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TxTreeComponent<any>, "tx-tree", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; "nodes": { "alias": "nodes"; "required": true; "isSignal": true; }; "selectedIds": { "alias": "selectedIds"; "required": false; "isSignal": true; }; "expandedIds": { "alias": "expandedIds"; "required": false; "isSignal": true; }; "leadingTemplate": { "alias": "leadingTemplate"; "required": false; "isSignal": true; }; "badgeTemplate": { "alias": "badgeTemplate"; "required": false; "isSignal": true; }; "actionsTemplate": { "alias": "actionsTemplate"; "required": false; "isSignal": true; }; "comboboxHost": { "alias": "comboboxHost"; "required": false; "isSignal": true; }; }, { "selectedIds": "selectedIdsChange"; "expandedIds": "expandedIdsChange"; "selectionChange": "selectionChange"; "expansionChange": "expansionChange"; }, never, never, true, never>;
+}
+
+/** Sort direction. `null` means unsorted. */
+type TxSortDirection = 'asc' | 'desc';
+/** Which column is sorted, and which way. */
+interface TxTableSort {
+    column: string;
+    direction: TxSortDirection;
+}
+/** Horizontal alignment of a column's cells. */
+type TxColumnAlign = 'start' | 'center' | 'end';
+/**
+ * How a column's text is rendered.
+ *
+ * `mono` is the reference design's treatment for part numbers, serials and
+ * identifiers; `numeric` right-aligns and uses tabular figures so columns of
+ * numbers line up.
+ */
+type TxColumnVariant = 'text' | 'mono' | 'numeric';
+/**
+ * The breakpoint at or above which a column appears.
+ *
+ * This is the documented column-priority approach to narrow screens: rather
+ * than letting a wide table overflow, low-priority columns drop out and the
+ * rest stay readable. Pair it with the table's `responsive` config.
+ */
+type TxColumnPriority = 'always' | 'sm' | 'md' | 'lg' | 'xl';
+/**
+ * One column.
+ *
+ * Columns are *data*, so they come through the table's own `columns` input
+ * rather than as a field on the config object. `value` and `compare` are
+ * projections of a row, not behaviour — event handlers stay as `output()`s on
+ * the component. Anything structural (a custom cell) is a projected
+ * `ng-template[txTableCell]`, never a field here.
+ */
+interface TxTableColumn<T = Record<string, unknown>> {
+    /**
+     * Unique key. Doubles as the property name read from each row unless `value`
+     * is supplied, and as the name a `txTableCell` template matches on.
+     */
+    key: string;
+    /** Column heading. */
+    header: string;
+    /** Derives the display value. Defaults to `row[key]`. */
+    value?: (row: T) => string | number | boolean | null | undefined;
+    /** Whether this column can be sorted. Defaults to false. */
+    sortable?: boolean;
+    /**
+     * Custom comparator, for when the display value does not sort correctly —
+     * a formatted date, or a status that has a rank rather than an alphabet.
+     */
+    compare?: (a: T, b: T) => number;
+    /** Defaults to `start`, or `end` when the variant is `numeric`. */
+    align?: TxColumnAlign;
+    /** Defaults to `text`. */
+    variant?: TxColumnVariant;
+    /** Defaults to `always`. */
+    priority?: TxColumnPriority;
+    /** Stops the cell wrapping. Useful for timestamps and identifiers. */
+    noWrap?: boolean;
+    /** Accessible description of the column, announced with the header. */
+    headerLabel?: string;
+}
+/** Row selection mode. */
+type TxTableSelection = 'none' | 'single' | 'multiple';
+/** Simple property configuration for {@link TxTableComponent}. */
+interface TxTableConfig {
+    /** Defaults to `none`. */
+    selection?: TxTableSelection;
+    /** Defaults to `comfortable`. */
+    density?: 'comfortable' | 'compact';
+    /**
+     * `client` sorts the rows given to the table; `server` only reports the
+     * requested sort through the `sortChange` output and leaves `rows` alone.
+     * Defaults to `client`.
+     */
+    sort?: 'none' | 'client' | 'server';
+    /** Same split as `sort`. Defaults to `none`. */
+    pagination?: 'none' | 'client' | 'server';
+    /** Page sizes offered in the footer. */
+    pageSizeOptions?: readonly number[];
+    /**
+     * How the table copes with a narrow viewport.
+     *
+     * `scroll` puts the table in a horizontal scroller; `sticky-first` also pins
+     * the first column so the row stays identifiable while scrolling; `priority`
+     * drops low-priority columns instead of scrolling at all.
+     * Defaults to `sticky-first`.
+     */
+    responsive?: 'scroll' | 'sticky-first' | 'priority';
+    /** Highlights the row under the pointer. Defaults to true. */
+    hoverable?: boolean;
+    /** Replaces the body with a loading state. */
+    loading?: boolean;
+    /** Rows rendered as skeletons while loading. Defaults to 5. */
+    loadingRows?: number;
+    /** Shown when there are no rows and the table is not loading. */
+    emptyText?: string;
+    /** Registered icon name shown above `emptyText`. */
+    emptyIcon?: string;
+    /** Adds a trailing action column fed by the `txTableActions` template. */
+    actionColumn?: 'none' | 'end';
+    /** Heading for the action column. Defaults to a visually hidden "Actions". */
+    actionColumnHeader?: string;
+    /** Noun used by the footer's range summary, e.g. "84 reports". */
+    itemLabel?: string;
+    /** Accessible name for the table. */
+    ariaLabel?: string;
+    /** Visible caption above the table. */
+    caption?: string;
+}
+declare const TX_TABLE_DEFAULTS: {
+    readonly selection: "none";
+    readonly density: "comfortable";
+    readonly sort: "client";
+    readonly pagination: "none";
+    readonly responsive: "sticky-first";
+    readonly hoverable: true;
+    readonly loadingRows: 5;
+    readonly emptyText: "Nothing to show";
+    readonly emptyIcon: "inbox";
+    readonly actionColumn: "none";
+    readonly actionColumnHeader: "Actions";
+    readonly itemLabel: "rows";
+};
+
+/**
+ * Pure sorting helpers.
+ *
+ * Comparators are the classic source of quiet bugs — nulls sorting to the top,
+ * numbers compared as strings so `10` lands before `9`, a sort that is not
+ * stable so equal rows shuffle on every re-sort. Kept out of the component and
+ * unit-tested directly.
+ */
+/** Reads a column's display value from a row. */
+declare function txColumnValue<T>(column: TxTableColumn<T>, row: T): string | number | boolean | null | undefined;
+/**
+ * Compares two cell values.
+ *
+ * Nulls and empty strings always sort last regardless of direction, because a
+ * missing value is not "smaller" — burying blanks at the bottom is what people
+ * actually expect. Numbers compare numerically, strings with `localeCompare`
+ * so accents and case behave, and numeric strings are compared as numbers so
+ * `10` does not sort before `9`.
+ */
+declare function txCompareValues(a: unknown, b: unknown): number;
+/**
+ * Returns a sorted copy of `rows`.
+ *
+ * Never mutates the input — the caller owns that array — and the sort is stable
+ * (`Array.prototype.sort` has been required to be stable since ES2019), so rows
+ * that compare equal keep the order they were given in. "Empty last" is applied
+ * before the direction flip, so blanks stay at the bottom either way.
+ */
+declare function txSortRows<T>(rows: readonly T[], column: TxTableColumn<T> | undefined, direction: TxSortDirection): T[];
+/**
+ * The sort state after clicking a column header.
+ *
+ * Cycles ascending → descending → unsorted, so a user can always get back to
+ * the original order without reloading.
+ */
+declare function txNextSort(current: {
+    column: string;
+    direction: TxSortDirection;
+} | null, column: string): {
+    column: string;
+    direction: TxSortDirection;
+} | null;
+/** The `aria-sort` value for a header cell. */
+declare function txAriaSort(current: {
+    column: string;
+    direction: TxSortDirection;
+} | null, column: string, sortable: boolean): 'ascending' | 'descending' | 'none' | null;
+
+/**
+ * Marks an `ng-template` as the renderer for one column's cells.
+ *
+ * Structural customisation by projection rather than by config: a table can
+ * have any number of custom cells, and each one is a template with the row in
+ * scope, so a cell can contain badges, links, nested controls — anything.
+ *
+ * @example
+ * ```html
+ * <tx-table [columns]="columns" [rows]="reports">
+ *   <ng-template txTableCell="status" let-row>
+ *     <tx-badge [config]="{ label: row.status, variant: toneFor(row.status) }" />
+ *   </ng-template>
+ * </tx-table>
+ * ```
+ *
+ * Context: `$implicit` and `row` are the row; `column` is the column; `value`
+ * is what the table would otherwise have rendered.
+ */
+declare class TxTableCellDirective {
+    /** The `key` of the column this template renders. */
+    readonly column: _angular_core.InputSignal<string>;
+    readonly template: TemplateRef<unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TxTableCellDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TxTableCellDirective, "ng-template[txTableCell]", never, { "column": { "alias": "txTableCell"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Marks an `ng-template` as the content of the table's action column.
+ *
+ * Turned on with the table's `actionColumn: 'end'` config. Actions are quiet
+ * until the row is hovered, focused within or selected, and always visible on
+ * touch-sized screens where there is no hover at all.
+ *
+ * @example
+ * ```html
+ * <ng-template txTableActions let-row>
+ *   <tx-button [config]="{ label: 'Edit ' + row.id, icon: 'edit',
+ *                          display: 'icon-only', variant: 'ghost', size: 'sm' }"
+ *              (clicked)="edit(row)" />
+ * </ng-template>
+ * ```
+ */
+declare class TxTableActionsDirective {
+    readonly template: TemplateRef<unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TxTableActionsDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TxTableActionsDirective, "ng-template[txTableActions]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * A data table.
+ *
+ * Built on `@angular/cdk/table` in its native-`<table>` form, so the markup is a
+ * real table with real `th`/`td` semantics rather than a grid of divs.
+ *
+ * ## What is config and what is a slot
+ *
+ * Sorting, pagination, density, selection mode, loading and the empty state are
+ * simple property variation and live in {@link TxTableConfig}. Columns are data
+ * and come through `columns`. Anything structural is projected: a custom cell is
+ * an `ng-template[txTableCell="key"]`, and the action column's content is an
+ * `ng-template[txTableActions]`.
+ *
+ * ## Narrow screens
+ *
+ * `responsive` picks the strategy rather than leaving it to chance:
+ * `sticky-first` (default) scrolls horizontally with the first column pinned so
+ * the row stays identifiable; `scroll` scrolls plainly; `priority` drops columns
+ * by their `priority` instead of scrolling at all.
+ *
+ * @example
+ * ```html
+ * <tx-table
+ *   [columns]="columns"
+ *   [rows]="reports()"
+ *   [config]="{ sort: 'client', pagination: 'client', actionColumn: 'end' }"
+ *   [(sort)]="sort"
+ *   [(selectedRows)]="selected">
+ *   <ng-template txTableCell="status" let-row>
+ *     <tx-badge [config]="{ label: row.status }" />
+ *   </ng-template>
+ *   <ng-template txTableActions let-row>
+ *     <tx-button [config]="{ label: 'Edit', icon: 'edit', display: 'icon-only' }" />
+ *   </ng-template>
+ * </tx-table>
+ * ```
+ *
+ * Config is a signal input — replace the object rather than mutating it.
+ */
+declare class TxTableComponent<T = Record<string, unknown>> {
+    readonly config: _angular_core.InputSignal<Partial<TxTableConfig>>;
+    /** Column descriptors. Data, so they are their own input. */
+    readonly columns: _angular_core.InputSignal<readonly TxTableColumn<T>[]>;
+    /** The rows to show. */
+    readonly rows: _angular_core.InputSignal<readonly T[]>;
+    /**
+     * Identity for selection and tracking. Defaults to the row object itself,
+     * which is right when rows are stable references; supply one when rows are
+     * re-created on every fetch.
+     */
+    readonly trackBy: _angular_core.InputSignal<(row: T) => unknown>;
+    /**
+     * Total row count for server-side pagination. Ignored when paginating on the
+     * client, where the row count is simply `rows().length`.
+     */
+    readonly total: _angular_core.InputSignal<number | null>;
+    readonly sort: _angular_core.ModelSignal<TxTableSort | null>;
+    readonly pageIndex: _angular_core.ModelSignal<number>;
+    readonly pageSize: _angular_core.ModelSignal<number>;
+    readonly selectedRows: _angular_core.ModelSignal<T[]>;
+    readonly pageChange: _angular_core.OutputEmitterRef<{
+        pageIndex: number;
+        pageSize: number;
+    }>;
+    readonly selectionChange: _angular_core.OutputEmitterRef<T[]>;
+    /** A row was clicked or activated with Enter/Space. */
+    readonly rowActivate: _angular_core.OutputEmitterRef<T>;
+    private readonly cellTemplates;
+    protected readonly actionsTemplate: _angular_core.Signal<TxTableActionsDirective | undefined>;
+    protected readonly selectColumn = "__tx_select";
+    protected readonly actionColumn = "__tx_actions";
+    private readonly resolved;
+    protected readonly caption: _angular_core.Signal<string | null>;
+    protected readonly emptyText: _angular_core.Signal<string | undefined>;
+    protected readonly emptyIcon: _angular_core.Signal<string | null>;
+    protected readonly itemLabel: _angular_core.Signal<string | undefined>;
+    protected readonly isLoading: _angular_core.Signal<boolean>;
+    protected readonly selectionMode: _angular_core.Signal<_tx_angular_design_system_ui_kit.TxTableSelection>;
+    protected readonly sortEnabled: _angular_core.Signal<boolean>;
+    protected readonly paginationEnabled: _angular_core.Signal<boolean>;
+    protected readonly hasActionColumn: _angular_core.Signal<boolean>;
+    protected readonly actionHeader: _angular_core.Signal<string | undefined>;
+    protected readonly stickyFirst: _angular_core.Signal<boolean>;
+    protected readonly loadingRows: _angular_core.Signal<unknown[]>;
+    /** Rows after client-side sorting. Server modes leave the input untouched. */
+    private readonly sortedRows;
+    /** Total for the pagination footer. */
+    protected readonly totalRows: _angular_core.Signal<number>;
+    /** Rows actually rendered. Empty while loading, so the no-data row shows. */
+    protected readonly visibleRows: _angular_core.Signal<readonly T[]>;
+    protected readonly displayedColumns: _angular_core.Signal<string[]>;
+    constructor();
+    protected alignOf(column: TxTableColumn<T>): 'start' | 'center' | 'end';
+    protected isStickyColumn(column: TxTableColumn<T>): boolean;
+    protected display(column: TxTableColumn<T>, row: T): string;
+    protected cellTemplateFor(key: string): _angular_core.TemplateRef<unknown> | null;
+    protected ariaSort(column: TxTableColumn<T>): "none" | "ascending" | "descending" | null;
+    protected sortIcon(column: TxTableColumn<T>): string;
+    protected sortLabel(column: TxTableColumn<T>): string;
+    protected readonly headerRowClass = "border-b-2 border-tx-accent";
+    protected readonly sortButtonClass: string;
+    protected scrollerClass(): string;
+    protected tableClass(): string;
+    protected headerCellClass(align: 'start' | 'center' | 'end', sticky: boolean, priority?: TxColumnPriority): string;
+    protected bodyCellClass(align: 'start' | 'center' | 'end', variant: 'text' | 'mono' | 'numeric', sticky: boolean, priority?: TxColumnPriority, noWrap?: boolean): string;
+    protected rowClass(): string;
+    protected toggleSort(column: TxTableColumn<T>): void;
+    protected isSelected(row: T): boolean;
+    protected allSelected(): boolean;
+    protected someSelected(): boolean;
+    protected toggleRow(row: T): void;
+    protected toggleAll(): void;
+    protected onRowActivate(row: T): void;
+    protected onRowKeydown(row: T, event: KeyboardEvent): void;
+    private commitSelection;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TxTableComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TxTableComponent<any>, "tx-table", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": true; "isSignal": true; }; "rows": { "alias": "rows"; "required": true; "isSignal": true; }; "trackBy": { "alias": "trackBy"; "required": false; "isSignal": true; }; "total": { "alias": "total"; "required": false; "isSignal": true; }; "sort": { "alias": "sort"; "required": false; "isSignal": true; }; "pageIndex": { "alias": "pageIndex"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "selectedRows": { "alias": "selectedRows"; "required": false; "isSignal": true; }; }, { "sort": "sortChange"; "pageIndex": "pageIndexChange"; "pageSize": "pageSizeChange"; "selectedRows": "selectedRowsChange"; "pageChange": "pageChange"; "selectionChange": "selectionChange"; "rowActivate": "rowActivate"; }, ["cellTemplates", "actionsTemplate"], never, true, never>;
+}
+
+/**
+ * One reorderable item.
+ *
+ * Items are data. Anything structural — per-item actions, a custom body — is a
+ * `TemplateRef` slot on the component, never a field here.
+ */
+interface TxReorderItem<T = unknown> {
+    /** Unique within the list. */
+    id: string;
+    label: string;
+    /** Optional second line. */
+    description?: string;
+    /** Registered icon name shown before the label. */
+    icon?: string;
+    /** Excluded from dragging and from the move buttons. */
+    disabled?: boolean;
+    /** Application payload, passed back in slot contexts and outputs. */
+    data?: T;
+}
+/**
+ * What the user grabs to drag.
+ *
+ * A union rather than a `dragAnywhere` boolean, so a third mode stays possible.
+ */
+type TxReorderHandle = 'handle' | 'row';
+/** Simple property configuration for {@link TxReorderListComponent}. */
+interface TxReorderListConfig {
+    /** Defaults to `handle`. */
+    handle?: TxReorderHandle;
+    /** Defaults to `md`. */
+    size?: 'sm' | 'md';
+    /** Shows the 1-based position before each item. */
+    showIndex?: boolean;
+    disabled?: boolean;
+    emptyText?: string;
+    ariaLabel?: string;
+}
+declare const TX_REORDER_LIST_DEFAULTS: {
+    readonly handle: "handle";
+    readonly size: "md";
+    readonly emptyText: "Nothing to reorder";
+    readonly ariaLabel: "Reorderable list";
+};
+/**
+ * A list whose items can be reordered.
+ *
+ * Dragging is `@angular/cdk/drag-drop`. Dragging alone is not accessible, so
+ * every row also carries move-up and move-down buttons: they are the keyboard
+ * path, they are reachable by Tab, and they appear on focus as well as on hover.
+ * Each move is announced through the CDK's `LiveAnnouncer`, so a screen-reader
+ * user hears where the item landed rather than being left to guess.
+ *
+ * @example
+ * ```html
+ * <tx-reorder-list [(items)]="steps" [config]="{ showIndex: true }"
+ *                  [actionsTemplate]="rowActions" />
+ *
+ * <ng-template #rowActions let-item>
+ *   <tx-button [config]="{ label: 'Remove ' + item.label, icon: 'trash',
+ *                          display: 'icon-only', variant: 'danger', size: 'sm' }" />
+ * </ng-template>
+ * ```
+ *
+ * Config is a signal input — replace the object rather than mutating it.
+ */
+declare class TxReorderListComponent<T = unknown> {
+    private readonly announcer;
+    readonly config: _angular_core.InputSignal<Partial<TxReorderListConfig>>;
+    /** The ordered items. Two-way, so the new order flows straight back out. */
+    readonly items: _angular_core.ModelSignal<TxReorderItem<T>[]>;
+    /** Replaces the default label/description body. */
+    readonly itemTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
+    /** Per-item action buttons, rendered after the move buttons. */
+    readonly actionsTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
+    /** Emitted with the new order whenever an item moves. */
+    readonly reordered: _angular_core.OutputEmitterRef<{
+        item: TxReorderItem<T>;
+        from: number;
+        to: number;
+        items: TxReorderItem<T>[];
+    }>;
+    private readonly resolved;
+    protected readonly emptyText: _angular_core.Signal<string | undefined>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly showIndex: _angular_core.Signal<boolean>;
+    protected readonly grabWholeRow: _angular_core.Signal<boolean>;
+    protected readonly moveButtonClass: string;
+    protected rowClass(): string;
+    protected handleClass(): string;
+    protected moveGroupClass(): string;
+    protected slotContext(item: TxReorderItem<T>, index: number): {
+        $implicit: TxReorderItem<T>;
+        item: TxReorderItem<T>;
+        index: number;
+        first: boolean;
+        last: boolean;
+    };
+    protected onDrop(event: CdkDragDrop<unknown>): void;
+    /** Moves an item, clamped to the list's bounds. Also the keyboard path. */
+    move(from: number, to: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TxReorderListComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TxReorderListComponent<any>, "tx-reorder-list", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; "items": { "alias": "items"; "required": true; "isSignal": true; }; "itemTemplate": { "alias": "itemTemplate"; "required": false; "isSignal": true; }; "actionsTemplate": { "alias": "actionsTemplate"; "required": false; "isSignal": true; }; }, { "items": "itemsChange"; "reordered": "reordered"; }, never, never, true, never>;
+}
+
+/** Diameter of the spinner, aligned to the icon sizes. */
+type TxSpinnerSize = 'sm' | 'md' | 'lg';
+/**
+ * Colour of the spinner. `current` inherits the surrounding text colour, which
+ * is what lets the same component sit inside a button of any variant.
+ */
+type TxSpinnerTone = 'current' | 'primary' | 'muted' | 'inverse';
+/** Simple property configuration for {@link TxSpinnerComponent}. */
+interface TxSpinnerConfig {
+    /** Defaults to `md`. */
+    size?: TxSpinnerSize;
+    /** Defaults to `current`. */
+    tone?: TxSpinnerTone;
+    /**
+     * Accessible label announced to screen readers. Defaults to `Loading`.
+     * Set `labelVisibility: 'visible'` to also show it beside the spinner.
+     */
+    label?: string;
+    /** Defaults to `screen-reader-only`. */
+    labelVisibility?: 'visible' | 'screen-reader-only';
+}
+declare const TX_SPINNER_DEFAULTS: {
+    readonly size: "md";
+    readonly tone: "current";
+    readonly label: "Loading";
+    readonly labelVisibility: "screen-reader-only";
+};
+/**
+ * An indeterminate loading indicator.
+ *
+ * @example
+ * ```html
+ * <tx-spinner [config]="{ size: 'lg', tone: 'primary', label: 'Loading reports' }" />
+ * ```
+ *
+ * Config is a signal input — update it by replacing the object:
+ * `this.spinnerConfig = { ...this.spinnerConfig, size: 'sm' }`.
+ */
+declare class TxSpinnerComponent {
+    readonly config: _angular_core.InputSignal<Partial<TxSpinnerConfig>>;
+    private readonly resolved;
+    protected readonly label: _angular_core.Signal<string | undefined>;
+    protected readonly svgClass: _angular_core.Signal<string>;
+    protected readonly labelClass: _angular_core.Signal<"sr-only" | "text-tx-base text-tx-text-muted">;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TxSpinnerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TxSpinnerComponent, "tx-spinner", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** Shape of the placeholder. */
+type TxSkeletonShape = 'text' | 'heading' | 'block' | 'circle' | 'pill';
+/** Simple property configuration for {@link TxSkeletonComponent}. */
+interface TxSkeletonConfig {
+    /** Defaults to `text`. */
+    shape?: TxSkeletonShape;
+    /**
+     * Number of lines. Only meaningful for `text`; the last line is rendered
+     * short so a block of them reads as a paragraph rather than a grid.
+     * Defaults to 1.
+     */
+    lines?: number;
+    /** CSS width, e.g. `60%`. Defaults to full width (or a square for `circle`). */
+    width?: string;
+    /** CSS height. Defaults to a sensible height for the shape. */
+    height?: string;
+    /** Set false for a static placeholder. Defaults to true. */
+    animated?: boolean;
+    /**
+     * Announced to screen readers while content loads. Defaults to `Loading`;
+     * set to an empty string when a nearby live region already says so.
+     */
+    label?: string;
+}
+declare const TX_SKELETON_DEFAULTS: {
+    readonly shape: "text";
+    readonly lines: 1;
+    readonly animated: true;
+    readonly label: "Loading";
+};
+/**
+ * A placeholder shown in the shape of the content that is loading.
+ *
+ * Used on its own, and by {@link TxTableComponent} for its loading rows.
+ *
+ * @example
+ * ```html
+ * <tx-skeleton [config]="{ shape: 'text', lines: 3 }" />
+ * <tx-skeleton [config]="{ shape: 'circle' }" />
+ * ```
+ *
+ * Config is a signal input — replace the object rather than mutating it.
+ */
+declare class TxSkeletonComponent {
+    readonly config: _angular_core.InputSignal<Partial<TxSkeletonConfig>>;
+    private readonly resolved;
+    protected readonly label: _angular_core.Signal<string | undefined>;
+    protected readonly height: _angular_core.Signal<string | null>;
+    protected readonly lines: _angular_core.Signal<unknown[]>;
+    protected lineClass(index: number): string;
+    protected widthFor(index: number): string | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TxSkeletonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TxSkeletonComponent, "tx-skeleton", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** Severity of the message. Drives colour, default icon and the ARIA role. */
+type TxAlertVariant = 'info' | 'success' | 'warning' | 'danger';
+/**
+ * How prominent the alert is.
+ *
+ * `subtle` is a tinted panel; `solid` fills with the variant colour for
+ * something that must not be missed; `bare` drops the surface and keeps only
+ * the icon and text, for use inside an already-bordered container.
+ */
+type TxAlertAppearance = 'subtle' | 'solid' | 'bare';
+/** Simple property configuration for {@link TxAlertComponent}. */
+interface TxAlertConfig {
+    /** Genuinely required: an alert with no severity has no meaning. */
+    variant: TxAlertVariant;
+    /** Bold first line. Omit for a single-line alert. */
+    title?: string;
+    /** Body text. Omit and project content instead for anything richer. */
+    message?: string;
+    /** Defaults to `subtle`. */
+    appearance?: TxAlertAppearance;
+    /** Registered icon name. Defaults to the variant's icon; `null` hides it. */
+    icon?: string | null;
+    /** Shows a close button and enables the `dismissed` output. */
+    dismissible?: boolean;
+    /**
+     * `polite` (default) waits for a pause; `assertive` interrupts; `none`
+     * renders no live region, for an alert present on first paint that would
+     * otherwise be announced twice.
+     */
+    announce?: 'polite' | 'assertive' | 'none';
+}
+declare const TX_ALERT_DEFAULTS: {
+    readonly appearance: "subtle";
+    readonly announce: "polite";
+};
+/**
+ * An inline message about the state of the page or a region of it.
+ *
+ * Use `message` for plain text, or project content for anything richer — a
+ * link, a list, a button. Both can be used together.
+ *
+ * `danger` and `warning` render as `role="alert"` so they interrupt; the others
+ * are `role="status"`. Set `announce: 'none'` for an alert that is present on
+ * first paint, which a live region would otherwise announce twice.
+ *
+ * @example
+ * ```html
+ * <tx-alert [config]="{ variant: 'warning', title: 'Unsaved changes',
+ *                       message: 'Leaving now discards them.', dismissible: true }"
+ *           (dismissed)="hide()" />
+ * ```
+ *
+ * Config is a signal input — replace the object rather than mutating it.
+ */
+declare class TxAlertComponent {
+    readonly config: _angular_core.InputSignal<TxAlertConfig>;
+    /** Emitted when the close button is used. The parent owns visibility. */
+    readonly dismissed: _angular_core.OutputEmitterRef<void>;
+    private readonly resolved;
+    protected readonly title: _angular_core.Signal<string | null>;
+    protected readonly message: _angular_core.Signal<string | null>;
+    protected readonly iconName: _angular_core.Signal<string | null>;
+    protected readonly role: _angular_core.Signal<"status" | "alert" | null>;
+    protected readonly ariaLive: _angular_core.Signal<"polite" | "assertive" | null | undefined>;
+    private readonly isSolid;
+    protected readonly rootClass: _angular_core.Signal<string>;
+    protected readonly iconClass: _angular_core.Signal<string>;
+    protected readonly messageClass: _angular_core.Signal<string>;
+    protected readonly closeClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TxAlertComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TxAlertComponent, "tx-alert", never, { "config": { "alias": "config"; "required": true; "isSignal": true; }; }, { "dismissed": "dismissed"; }, never, ["*"], true, never>;
+}
+
+/** Simple property configuration for {@link TxTooltipDirective}. */
+interface TxTooltipConfig {
+    /** The text. Genuinely required — a tooltip with no text does nothing. */
+    text: string;
+    /** Defaults to `top-center`. Falls back through a ladder if it does not fit. */
+    placement?: TxOverlayPlacement;
+    /** Milliseconds before showing on hover. Defaults to 300. */
+    showDelay?: number;
+    /** Milliseconds before hiding. Defaults to 100. */
+    hideDelay?: number;
+    disabled?: boolean;
+}
+declare const TX_TOOLTIP_DEFAULTS: {
+    readonly placement: "top-center";
+    readonly showDelay: 300;
+    readonly hideDelay: 100;
+};
+/** The floating bubble. Rendered into the overlay by the directive. */
+declare class TxTooltipPanelComponent {
+    readonly text: _angular_core.WritableSignal<string>;
+    id: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TxTooltipPanelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TxTooltipPanelComponent, "tx-tooltip-panel", never, {}, {}, never, never, true, never>;
+}
+/**
+ * A text tooltip on hover and on keyboard focus.
+ *
+ * Aria has no tooltip, so this is a CDK overlay. It attaches on demand rather
+ * than eagerly — unlike the dropdown overlays, nothing needs to register with
+ * it before first use.
+ *
+ * Shows on `focus-visible` as well as hover, so a tooltip is never information
+ * available only to a mouse, and hides on Escape. The host gets
+ * `aria-describedby` while the tooltip is up, which is how the text reaches a
+ * screen reader — note that a tooltip *describes* a control, so the control
+ * still needs its own accessible name.
+ *
+ * @example
+ * ```html
+ * <tx-button [config]="{ label: 'Export', icon: 'download', display: 'icon-only' }"
+ *            [txTooltip]="{ text: 'Export as CSV' }" />
+ * ```
+ *
+ * Config is a signal input — replace the object rather than mutating it.
+ */
+declare class TxTooltipDirective {
+    private readonly host;
+    private readonly injector;
+    readonly config: _angular_core.InputSignal<TxTooltipConfig>;
+    protected readonly panelId: string;
+    protected readonly visible: _angular_core.WritableSignal<boolean>;
+    private overlayRef;
+    private panel;
+    private timer;
+    private readonly resolved;
+    constructor();
+    /** Shows the tooltip after the configured delay. */
+    show(): void;
+    /** Hides the tooltip after the configured delay. */
+    hide(): void;
+    /**
+     * Only a keyboard focus should show a tooltip. A click focuses the element
+     * too, and a bubble appearing under the pointer you just clicked with is
+     * noise rather than help.
+     */
+    protected onFocus(event: FocusEvent): void;
+    private attach;
+    private detach;
+    private clearTimer;
+    private dispose;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TxTooltipDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TxTooltipDirective, "[txTooltip]", ["txTooltip"], { "config": { "alias": "txTooltip"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** Severity of a toast. Drives colour, default icon and announcement urgency. */
+type TxToastVariant = 'info' | 'success' | 'warning' | 'danger';
+/** Where the stack sits. Set once through {@link TxToastService.configure}. */
+type TxToastPosition = 'top-start' | 'top-center' | 'top-end' | 'bottom-start' | 'bottom-center' | 'bottom-end';
+/**
+ * Simple property configuration for a toast.
+ *
+ * Deliberately no `onAction` callback: behaviour never lives in a config
+ * object. `show()` returns a {@link TxToastRef} whose `action` promise resolves
+ * when the action button is used.
+ */
+interface TxToastConfig {
+    /** Genuinely required: a toast with no message says nothing. */
+    message: string;
+    /** Defaults to `info`. */
+    variant?: TxToastVariant;
+    /** Bold first line above the message. */
+    title?: string;
+    /** Registered icon name. Defaults to the variant's icon; `null` hides it. */
+    icon?: string | null;
+    /**
+     * Milliseconds before auto-dismissal. `0` keeps it until dismissed, which is
+     * what `danger` defaults to — an error that vanishes is an error missed.
+     */
+    duration?: number;
+    /** Shows a close button. Defaults to true. */
+    dismissible?: boolean;
+    /** Label for an action button, e.g. "Undo". */
+    actionLabel?: string;
+}
+/** Why a toast closed. */
+type TxToastCloseReason = 'timeout' | 'dismissed' | 'action' | 'cleared';
+/** Handle to a live toast. */
+interface TxToastRef {
+    readonly id: string;
+    /** Resolves when the toast closes, with the reason. */
+    readonly closed: Promise<TxToastCloseReason>;
+    /** Resolves only if the action button is used. Never rejects. */
+    readonly action: Promise<void>;
+    /** Closes the toast early. */
+    dismiss(): void;
+}
+interface ToastEntry {
+    id: string;
+    config: Required<Pick<TxToastConfig, 'message'>> & TxToastConfig;
+    variant: TxToastVariant;
+    timer: ReturnType<typeof setTimeout> | null;
+    close: (reason: TxToastCloseReason) => void;
+    fireAction: () => void;
+}
+/** Service-level settings, applied to every toast. */
+interface TxToastServiceConfig {
+    /** Defaults to `bottom-center`, matching the reference design. */
+    position?: TxToastPosition;
+    /** Most toasts on screen at once. Oldest are dropped first. Defaults to 4. */
+    max?: number;
+    /** Default duration in ms for non-danger toasts. Defaults to 5000. */
+    duration?: number;
+}
+/**
+ * The stack. One instance, attached to a global CDK overlay on first use.
+ */
+declare class TxToastStackComponent {
+    readonly entries: _angular_core.WritableSignal<ToastEntry[]>;
+    readonly position: _angular_core.WritableSignal<TxToastPosition>;
+    protected readonly stackClass: _angular_core.Signal<string>;
+    protected iconFor(entry: ToastEntry): string | null;
+    protected toastClass(variant: TxToastVariant): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TxToastStackComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TxToastStackComponent, "tx-toast-stack", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Shows transient notifications.
+ *
+ * Aria has no toaster, so this is a CDK global overlay plus the CDK's
+ * `LiveAnnouncer`. The announcement matters: a toast that only appears visually
+ * is invisible to a screen-reader user, and `danger` toasts are announced
+ * assertively while the rest are polite.
+ *
+ * Behaviour never lives in the config object — `show()` returns a
+ * {@link TxToastRef} whose `action` and `closed` promises are how a caller
+ * responds.
+ *
+ * @example
+ * ```ts
+ * const toast = inject(TxToastService);
+ *
+ * toast.success('Report saved');
+ *
+ * const ref = toast.show({ message: 'Report deleted', actionLabel: 'Undo' });
+ * ref.action.then(() => this.restore());
+ * ```
+ */
+declare class TxToastService {
+    private readonly injector;
+    private readonly announcer;
+    private overlayRef;
+    private stack;
+    private settings;
+    /** Sets stack position, capacity and default duration for the whole app. */
+    configure(config: TxToastServiceConfig): void;
+    /** Shows a toast. */
+    show(config: TxToastConfig): TxToastRef;
+    /** Shorthand for an informational toast. */
+    info(message: string, config?: Omit<TxToastConfig, 'message' | 'variant'>): TxToastRef;
+    /** Shorthand for a success toast. */
+    success(message: string, config?: Omit<TxToastConfig, 'message' | 'variant'>): TxToastRef;
+    /** Shorthand for a warning toast. */
+    warning(message: string, config?: Omit<TxToastConfig, 'message' | 'variant'>): TxToastRef;
+    /** Shorthand for an error toast. Stays until dismissed by default. */
+    danger(message: string, config?: Omit<TxToastConfig, 'message' | 'variant'>): TxToastRef;
+    /** Removes every toast on screen. */
+    clear(): void;
+    private remove;
+    private ensureStack;
+    private applyPosition;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TxToastService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TxToastService>;
+}
+
+/** Width of the dialog. */
+type TxDialogSize = 'sm' | 'md' | 'lg' | 'full';
+/** Tone of the header icon, for a dialog that carries consequence. */
+type TxDialogTone = 'default' | 'info' | 'warning' | 'danger';
+/** Simple property configuration for {@link TxDialogComponent}. */
+interface TxDialogConfig {
+    /** Genuinely required: it names the dialog for assistive technology. */
+    title: string;
+    /** Secondary line under the title. */
+    description?: string;
+    /** Defaults to `md`. */
+    size?: TxDialogSize;
+    /** Defaults to `default`. */
+    tone?: TxDialogTone;
+    /** Registered icon name shown beside the title. */
+    icon?: string;
+    /** Shows the header close button. Defaults to true. */
+    dismissible?: boolean;
+}
+declare const TX_DIALOG_DEFAULTS: {
+    readonly size: "md";
+    readonly tone: "default";
+    readonly dismissible: true;
+};
+/**
+ * The chrome of a dialog: header, scrolling body and footer.
+ *
+ * Put this inside the component you open with {@link TxDialogService}; it does
+ * not open anything itself. The body is projected, and the footer is a named
+ * slot, so a dialog can hold anything without this component knowing about it.
+ *
+ * @example
+ * ```html
+ * <tx-dialog [config]="{ title: 'Edit report', description: 'R-1042' }"
+ *            (dismissed)="ref.close()">
+ *   <tx-form-field [config]="{ label: 'Summary' }">…</tx-form-field>
+ *
+ *   <ng-container txDialogFooter>
+ *     <tx-button [config]="{ label: 'Cancel', variant: 'secondary' }" (clicked)="ref.close()" />
+ *     <tx-button [config]="{ label: 'Save', variant: 'primary' }" (clicked)="save()" />
+ *   </ng-container>
+ * </tx-dialog>
+ * ```
+ *
+ * Config is a signal input — replace the object rather than mutating it.
+ */
+declare class TxDialogComponent {
+    readonly config: _angular_core.InputSignal<TxDialogConfig>;
+    /** The header close button was used. The opener owns closing. */
+    readonly dismissed: _angular_core.OutputEmitterRef<void>;
+    private readonly resolved;
+    protected readonly isDismissible: _angular_core.Signal<boolean>;
+    protected readonly rootClass: _angular_core.Signal<string>;
+    protected readonly iconClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TxDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TxDialogComponent, "tx-dialog", never, { "config": { "alias": "config"; "required": true; "isSignal": true; }; }, { "dismissed": "dismissed"; }, never, ["*", "[txDialogFooter]"], true, never>;
+}
+
+/** Options for opening any dialog. */
+interface TxDialogOpenConfig<D = unknown> {
+    /** Data injected into the dialog component via `DIALOG_DATA`. */
+    data?: D;
+    /** Defaults to `md`. Only used for the backdrop/panel sizing hints. */
+    size?: TxDialogSize;
+    /** Clicking the backdrop or pressing Escape closes. Defaults to true. */
+    dismissible?: boolean;
+    /** Extra classes for the overlay pane. */
+    panelClass?: string | string[];
+    /** Accessible name, when the dialog does not render a TxDialogComponent. */
+    ariaLabel?: string;
+}
+/** Simple property configuration for a confirmation dialog. */
+interface TxConfirmDialogConfig {
+    /** Genuinely required: it names the dialog. */
+    title: string;
+    /** The question or consequence. */
+    message: string;
+    /** Defaults to `Confirm`. */
+    confirmLabel?: string;
+    /** Defaults to `Cancel`. */
+    cancelLabel?: string;
+    /**
+     * Visual weight of the confirm button. Defaults to `primary`, or `danger`
+     * when `tone` is `danger` — so a destructive confirmation looks destructive
+     * without the caller having to say it twice.
+     */
+    confirmVariant?: TxButtonVariant;
+    /** Defaults to `warning`. */
+    tone?: TxDialogTone;
+    /** Registered icon name. Defaults to the tone's icon. */
+    icon?: string;
+    /** Defaults to `sm`. */
+    size?: TxDialogSize;
+}
+/** The built-in confirmation dialog body. */
+declare class TxConfirmDialogComponent {
+    private readonly ref;
+    readonly config: _angular_core.WritableSignal<TxConfirmDialogConfig>;
+    protected readonly dialogConfig: _angular_core.Signal<TxDialogConfig>;
+    protected readonly confirmVariant: _angular_core.Signal<TxButtonVariant>;
+    protected close(result: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TxConfirmDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TxConfirmDialogComponent, "tx-confirm-dialog", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Opens dialogs.
+ *
+ * Wraps `@angular/cdk/dialog`, which provides the overlay, the focus trap,
+ * focus restoration on close, and the `Escape` handling. This adds the kit's
+ * sizing, the scrim token, and a ready-made confirmation.
+ *
+ * @example
+ * ```ts
+ * const dialogs = inject(TxDialogService);
+ *
+ * // A custom dialog component
+ * const ref = dialogs.open(EditReportDialog, { data: { id: 'R-1042' }, size: 'lg' });
+ * ref.closed.subscribe((result) => …);
+ *
+ * // The built-in confirmation
+ * if (await dialogs.confirm({
+ *   title: 'Delete report?',
+ *   message: 'This cannot be undone.',
+ *   tone: 'danger',
+ *   confirmLabel: 'Delete',
+ * })) {
+ *   this.remove();
+ * }
+ * ```
+ */
+declare class TxDialogService {
+    private readonly dialog;
+    /** Opens a component as a dialog. */
+    open<T, D = unknown, R = unknown>(component: ComponentType<T>, config?: TxDialogOpenConfig<D>): DialogRef<R, T>;
+    /**
+     * Opens a confirmation and resolves to the user's answer.
+     *
+     * Resolves `false` when dismissed by Escape or the backdrop, so a caller can
+     * treat "closed without answering" and "declined" the same way.
+     */
+    confirm(config: TxConfirmDialogConfig): Promise<boolean>;
+    /** Closes every open dialog. */
+    closeAll(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TxDialogService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TxDialogService>;
+}
+
+/**
+ * Pure pagination arithmetic.
+ *
+ * Off-by-one errors here are invisible until someone lands on an empty last
+ * page, so this is kept out of the component and unit-tested directly.
+ *
+ * Page indexes are zero-based throughout; only the rendered label is 1-based.
+ */
+/** Number of pages needed to hold `total` rows. Always at least 1. */
+declare function txPageCount(total: number, pageSize: number): number;
+/**
+ * Restricts a page index to one that exists.
+ *
+ * Called after the row count changes — deleting the last row of the last page
+ * would otherwise leave the user stranded on a page past the end.
+ */
+declare function txClampPageIndex(index: number, total: number, pageSize: number): number;
+/** The slice of rows on a given page. */
+declare function txPaginate<T>(rows: readonly T[], pageIndex: number, pageSize: number): T[];
+/** Inclusive 1-based row range on a page, for a "n–m of t" label. */
+interface TxPageRange {
+    /** 1-based index of the first row, or 0 when there are none. */
+    from: number;
+    /** 1-based index of the last row, or 0 when there are none. */
+    to: number;
+    total: number;
+}
+declare function txPageRange(pageIndex: number, pageSize: number, total: number): TxPageRange;
+/**
+ * The page buttons to render: page indexes plus `'gap'` markers.
+ *
+ * Always shows the first and last page, and a window of `siblings` either side
+ * of the current one, so the control's width stays stable no matter how many
+ * pages there are.
+ */
+declare function txPageItems(pageIndex: number, pageCount: number, siblings?: number): (number | 'gap')[];
+
+/**
+ * How much of the control is shown.
+ *
+ * A union rather than a set of `showX` booleans, so the variants stay mutually
+ * exclusive as more are added.
+ */
+type TxPaginationAppearance = 'full' | 'compact' | 'simple';
+/** Simple property configuration for {@link TxPaginationComponent}. */
+interface TxPaginationConfig {
+    /**
+     * `full` shows numbered pages, a range summary and a page-size selector;
+     * `compact` drops the numbers; `simple` is just previous/next.
+     * Defaults to `full`.
+     */
+    appearance?: TxPaginationAppearance;
+    /** Page sizes offered in the selector. Omit to hide the selector. */
+    pageSizeOptions?: readonly number[];
+    /** Pages shown either side of the current one. Defaults to 1. */
+    siblings?: number;
+    /** Noun used in the range summary, e.g. "12–20 of 84 reports". */
+    itemLabel?: string;
+    disabled?: boolean;
+    ariaLabel?: string;
+}
+declare const TX_PAGINATION_DEFAULTS: {
+    readonly appearance: "full";
+    readonly siblings: 1;
+    readonly itemLabel: "items";
+    readonly ariaLabel: "Pagination";
+};
+/**
+ * A standalone pagination control.
+ *
+ * Used on its own, and by {@link TxTableComponent} for its footer — the table
+ * does not reimplement any of this.
+ *
+ * All arithmetic lives in `pagination-utils` and is unit-tested there: page
+ * clamping in particular matters, because deleting the last row of the last
+ * page would otherwise strand the user on a page that no longer exists.
+ *
+ * @example
+ * ```html
+ * <tx-pagination
+ *   [total]="reports().length"
+ *   [(pageIndex)]="pageIndex"
+ *   [(pageSize)]="pageSize"
+ *   [config]="{ pageSizeOptions: [10, 25, 50], itemLabel: 'reports' }" />
+ * ```
+ *
+ * Config is a signal input — replace the object rather than mutating it.
+ */
+declare class TxPaginationComponent {
+    readonly config: _angular_core.InputSignal<Partial<TxPaginationConfig>>;
+    /** Total number of rows across all pages. */
+    readonly total: _angular_core.InputSignal<number>;
+    /** Zero-based current page. */
+    readonly pageIndex: _angular_core.ModelSignal<number>;
+    readonly pageSize: _angular_core.ModelSignal<number>;
+    /** Emitted whenever the page or the page size changes. */
+    readonly pageChange: _angular_core.OutputEmitterRef<{
+        pageIndex: number;
+        pageSize: number;
+    }>;
+    private readonly resolved;
+    protected readonly appearance: _angular_core.Signal<TxPaginationAppearance | undefined>;
+    protected readonly itemLabel: _angular_core.Signal<string | undefined>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly pageSizeOptions: _angular_core.Signal<readonly number[]>;
+    protected readonly pageCount: _angular_core.Signal<number>;
+    protected readonly range: _angular_core.Signal<_tx_angular_design_system_ui_kit.TxPageRange>;
+    protected readonly items: _angular_core.Signal<(number | "gap")[]>;
+    protected readonly navClass: string;
+    protected readonly pageClass: string;
+    protected readonly selectClass: string;
+    /** Moves to a page, clamped to one that exists. */
+    goTo(index: number): void;
+    protected onPageSize(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TxPaginationComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TxPaginationComponent, "tx-pagination", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; "total": { "alias": "total"; "required": true; "isSignal": true; }; "pageIndex": { "alias": "pageIndex"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; }, { "pageIndex": "pageIndexChange"; "pageSize": "pageSizeChange"; "pageChange": "pageChange"; }, never, never, true, never>;
+}
+
+/** Semantic colour of a badge. */
+type TxBadgeVariant = 'neutral' | 'primary' | 'accent' | 'info' | 'success' | 'warning' | 'danger';
+/** How the badge is filled. */
+type TxBadgeAppearance = 'subtle' | 'solid' | 'outline';
+/** Simple property configuration for {@link TxBadgeComponent}. */
+interface TxBadgeConfig {
+    /** Genuinely required: a badge with no text is decoration, not information. */
+    label: string;
+    /** Defaults to `neutral`. */
+    variant?: TxBadgeVariant;
+    /** Defaults to `subtle`. */
+    appearance?: TxBadgeAppearance;
+    /** Defaults to `md`. */
+    size?: 'sm' | 'md';
+    /** Registered icon name shown before the label. */
+    icon?: string;
+    /** Small filled circle before the label, for a status pip. */
+    dot?: boolean;
+    /** Strikes the label through, for a retired or superseded item. */
+    struck?: boolean;
+    /** Shows a remove button and enables the `removed` output. */
+    removable?: boolean;
+}
+declare const TX_BADGE_DEFAULTS: {
+    readonly variant: "neutral";
+    readonly appearance: "subtle";
+    readonly size: "md";
+};
+/**
+ * A small status pill or tag.
+ *
+ * Rendered in the mono face at the smallest type step, matching the reference
+ * design's treatment for statuses, counts and part classifications.
+ *
+ * @example
+ * ```html
+ * <tx-badge [config]="{ label: 'critical', variant: 'danger' }" />
+ * <tx-badge [config]="{ label: 'Gearbox', removable: true }" (removed)="drop()" />
+ * ```
+ *
+ * Config is a signal input — replace the object rather than mutating it.
+ */
+declare class TxBadgeComponent {
+    readonly config: _angular_core.InputSignal<TxBadgeConfig>;
+    /** Emitted by the remove button. The parent owns the list. */
+    readonly removed: _angular_core.OutputEmitterRef<void>;
+    private readonly resolved;
+    private readonly variant;
+    protected readonly rootClass: _angular_core.Signal<string>;
+    protected readonly labelClass: _angular_core.Signal<string>;
+    protected readonly dotClass: _angular_core.Signal<string>;
+    protected readonly removeClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TxBadgeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TxBadgeComponent, "tx-badge", never, { "config": { "alias": "config"; "required": true; "isSignal": true; }; }, { "removed": "removed"; }, never, never, true, never>;
+}
+
+/**
+ * Visual treatment of the rule.
+ *
+ * `groove` is the reference design's one ornament — a diagonal tread band. It
+ * is the brand's signature, so it ships as a divider variant rather than being
+ * re-cut by hand wherever it is wanted.
+ */
+type TxDividerVariant = 'line' | 'subtle' | 'groove';
+/** Simple property configuration for {@link TxDividerComponent}. */
+interface TxDividerConfig {
+    /** Defaults to `horizontal`. */
+    orientation?: 'horizontal' | 'vertical';
+    /** Defaults to `line`. */
+    variant?: TxDividerVariant;
+    /** Text set into the rule. Horizontal only; ignored by `groove`. */
+    label?: string;
+    /** Where the label sits. Defaults to `center`. */
+    labelPosition?: 'start' | 'center' | 'end';
+    /** Vertical margin around the rule. Defaults to `md`. */
+    spacing?: 'none' | 'sm' | 'md' | 'lg';
+}
+declare const TX_DIVIDER_DEFAULTS: {
+    readonly orientation: "horizontal";
+    readonly variant: "line";
+    readonly labelPosition: "center";
+    readonly spacing: "md";
+};
+/**
+ * A rule between sections.
+ *
+ * `separator` role only when it carries no label; a labelled divider is a
+ * heading in disguise and is announced as its text instead.
+ *
+ * @example
+ * ```html
+ * <tx-divider />
+ * <tx-divider [config]="{ label: 'Failed parts' }" />
+ * <tx-divider [config]="{ variant: 'groove', spacing: 'none' }" />
+ * <tx-divider [config]="{ orientation: 'vertical', spacing: 'sm' }" />
+ * ```
+ *
+ * Config is a signal input — replace the object rather than mutating it.
+ */
+declare class TxDividerComponent {
+    readonly config: _angular_core.InputSignal<Partial<TxDividerConfig>>;
+    private readonly resolved;
+    protected readonly label: _angular_core.Signal<string | null>;
+    protected readonly orientation: _angular_core.Signal<"vertical" | "horizontal" | undefined>;
+    protected readonly variant: _angular_core.Signal<TxDividerVariant | undefined>;
+    protected readonly labelPosition: _angular_core.Signal<"start" | "end" | "center" | undefined>;
+    /**
+     * The tread band: diagonal brand-coloured strokes over a tinted ground.
+     * Built from gradients rather than an image so it re-themes with the tokens.
+     */
+    protected readonly grooveClass = "tx-groove";
+    protected readonly hostClass: _angular_core.Signal<string>;
+    protected readonly ruleClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TxDividerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TxDividerComponent, "tx-divider", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** Surface treatment of the card. */
+type TxCardAppearance = 'panel' | 'plain' | 'sunken';
+/** Simple property configuration for {@link TxCardComponent}. */
+interface TxCardConfig {
+    /** Heading. Rendered in the reference design's uppercase panel-header style. */
+    title?: string;
+    /** Secondary line under the title. */
+    description?: string;
+    /** Registered icon name shown before the title. */
+    icon?: string;
+    /** Defaults to `panel`. */
+    appearance?: TxCardAppearance;
+    /** Body padding. Defaults to `md`. `none` suits a table or list body. */
+    padding?: 'none' | 'sm' | 'md' | 'lg';
+    /** Adds a chevron that collapses the body. */
+    collapsible?: boolean;
+    /** Short muted text beside the title, e.g. the current selection. */
+    summary?: string;
+    /**
+     * Leading accent bar in a semantic colour, matching the reference design's
+     * failed-part card.
+     */
+    accent?: 'none' | 'primary' | 'danger' | 'warning' | 'info';
+}
+declare const TX_CARD_DEFAULTS: {
+    readonly appearance: "panel";
+    readonly padding: "md";
+    readonly accent: "none";
+};
+/**
+ * A bordered panel with an optional header, and slots for header actions and a
+ * footer.
+ *
+ * The header's action slot is a projected `[txCardActions]`, not a config
+ * field, so a panel header can carry arbitrary buttons — which is exactly the
+ * case config could never cover.
+ *
+ * @example
+ * ```html
+ * <tx-card [config]="{ title: 'Failed parts', collapsible: true }">
+ *   <ng-container txCardActions>
+ *     <tx-button [config]="{ label: 'Add', icon: 'plus', size: 'sm' }" />
+ *   </ng-container>
+ *
+ *   <p>Body</p>
+ *
+ *   <ng-container txCardFooter>
+ *     <tx-button [config]="{ label: 'Save', variant: 'primary' }" />
+ *   </ng-container>
+ * </tx-card>
+ * ```
+ *
+ * Config is a signal input — replace the object rather than mutating it.
+ */
+declare class TxCardComponent {
+    readonly config: _angular_core.InputSignal<Partial<TxCardConfig>>;
+    /** Whether the body is shown. Two-way, so a page can collapse every card. */
+    readonly expanded: _angular_core.ModelSignal<boolean>;
+    readonly toggled: _angular_core.OutputEmitterRef<boolean>;
+    private readonly resolved;
+    protected readonly hasHeader: _angular_core.Signal<boolean>;
+    protected readonly rootClass: _angular_core.Signal<string>;
+    protected readonly headerClass: _angular_core.Signal<string>;
+    protected readonly bodyClass: _angular_core.Signal<string>;
+    protected toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TxCardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TxCardComponent, "tx-card", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; }, { "expanded": "expandedChange"; "toggled": "toggled"; }, never, ["[txCardActions]", "*", "[txCardFooter]"], true, never>;
+}
+
+/** Simple property configuration for {@link TxEmptyStateComponent}. */
+interface TxEmptyStateConfig {
+    /** Genuinely required: an empty state with no message explains nothing. */
+    title: string;
+    /** What to do about it. */
+    description?: string;
+    /** Registered icon name. Defaults to `inbox`; `null` hides it. */
+    icon?: string | null;
+    /** Defaults to `md`. `sm` suits an empty panel body or popup. */
+    size?: 'sm' | 'md' | 'lg';
+    /** Defaults to `dashed`. */
+    appearance?: 'dashed' | 'plain';
+}
+declare const TX_EMPTY_STATE_DEFAULTS: {
+    readonly icon: "inbox";
+    readonly size: "md";
+    readonly appearance: "dashed";
+};
+/**
+ * The "there is nothing here" panel.
+ *
+ * Actions are projected rather than configured, so an empty state can offer
+ * whatever the situation calls for — a button, a link, a short form.
+ *
+ * @example
+ * ```html
+ * <tx-empty-state [config]="{ title: 'No reports yet',
+ *                             description: 'Create one to get started.' }">
+ *   <tx-button [config]="{ label: 'New report', variant: 'primary', icon: 'plus' }" />
+ * </tx-empty-state>
+ * ```
+ *
+ * Config is a signal input — replace the object rather than mutating it.
+ */
+declare class TxEmptyStateComponent {
+    readonly config: _angular_core.InputSignal<TxEmptyStateConfig>;
+    private readonly resolved;
+    protected readonly iconName: _angular_core.Signal<string | null>;
+    protected readonly rootClass: _angular_core.Signal<string>;
+    protected readonly titleClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TxEmptyStateComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TxEmptyStateComponent, "tx-empty-state", never, { "config": { "alias": "config"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * One step in the trail.
+ *
+ * Items are data. A crumb navigates by `routerLink` or `href`, or by nothing at
+ * all — in which case the component emits `selected` and the application
+ * decides. No callback ever lives on the item.
+ */
+interface TxBreadcrumbItem {
+    label: string;
+    /** Angular router target. Takes precedence over `href`. */
+    routerLink?: string | readonly unknown[];
+    /** Plain link target, for anything outside the router. */
+    href?: string;
+    /** Registered icon name shown before the label. */
+    icon?: string;
+}
+/** Simple property configuration for {@link TxBreadcrumbComponent}. */
+interface TxBreadcrumbConfig {
+    /** Registered icon name used between crumbs. Defaults to `chevron-right`. */
+    separator?: string;
+    /**
+     * Above this many crumbs the middle ones collapse behind an ellipsis, so a
+     * deep trail cannot wrap onto three lines. `0` disables collapsing.
+     * Defaults to 4.
+     */
+    maxVisible?: number;
+    /** Defaults to `md`. */
+    size?: 'sm' | 'md';
+    /** Accessible name. Defaults to `Breadcrumb`. */
+    ariaLabel?: string;
+}
+declare const TX_BREADCRUMB_DEFAULTS: {
+    readonly separator: "chevron-right";
+    readonly maxVisible: 4;
+    readonly size: "md";
+    readonly ariaLabel: "Breadcrumb";
+};
+/**
+ * A crumb, or the ellipsis standing in for the ones that were collapsed.
+ *
+ * A nullable `item` rather than a discriminated union: Angular's template type
+ * checker narrows cleanly through `@if (crumb.item; as item)`, whereas a `kind`
+ * discriminant does not survive an `@else if` chain.
+ */
+interface Crumb {
+    /** `null` for the ellipsis placeholder. */
+    item: TxBreadcrumbItem | null;
+}
+/**
+ * A trail of ancestor links.
+ *
+ * The last crumb is the current page: it is never a link, and carries
+ * `aria-current="page"`.
+ *
+ * @example
+ * ```html
+ * <tx-breadcrumb
+ *   [items]="[{ label: 'Reports', routerLink: '/reports' }, { label: 'R-1042' }]" />
+ * ```
+ *
+ * Config is a signal input — replace the object rather than mutating it.
+ */
+declare class TxBreadcrumbComponent {
+    readonly config: _angular_core.InputSignal<Partial<TxBreadcrumbConfig>>;
+    /** The trail, root first. Data, so it is its own input. */
+    readonly items: _angular_core.InputSignal<readonly TxBreadcrumbItem[]>;
+    /** Emitted when a crumb with no link target is activated. */
+    readonly selected: _angular_core.OutputEmitterRef<TxBreadcrumbItem>;
+    private readonly resolved;
+    protected readonly separator: _angular_core.Signal<string>;
+    protected readonly hiddenCount: _angular_core.Signal<number>;
+    /** First crumb, an ellipsis, then the tail — so the trail never wraps. */
+    protected readonly crumbs: _angular_core.Signal<Crumb[]>;
+    protected readonly listClass: _angular_core.Signal<string>;
+    protected readonly linkClass: _angular_core.Signal<string>;
+    protected readonly currentClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TxBreadcrumbComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TxBreadcrumbComponent, "tx-breadcrumb", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; "items": { "alias": "items"; "required": true; "isSignal": true; }; }, { "selected": "selected"; }, never, never, true, never>;
+}
+
+/**
+ * One tab.
+ *
+ * Tabs are data; each panel's *content* is a projected
+ * `ng-template[txTabPanel="value"]`, because content is structural and could
+ * never be a config field.
+ */
+interface TxTab {
+    /** Unique value. Also what a `txTabPanel` template matches on. */
+    value: string;
+    label: string;
+    /** Registered icon name shown before the label. */
+    icon?: string;
+    /** Short count or status after the label. */
+    badge?: string;
+    disabled?: boolean;
+}
+/** Visual treatment of the tab strip. */
+type TxTabsAppearance = 'underline' | 'pills' | 'enclosed';
+/** Simple property configuration for {@link TxTabsComponent}. */
+interface TxTabsConfig {
+    /** Defaults to `underline`. */
+    appearance?: TxTabsAppearance;
+    /** Defaults to `horizontal`. */
+    orientation?: 'horizontal' | 'vertical';
+    /** Defaults to `md`. */
+    size?: 'sm' | 'md';
+    /**
+     * `follow` selects a tab as soon as it is focused, which is the usual
+     * behaviour for cheap panels; `explicit` waits for Enter or Space, which is
+     * right when switching tabs costs a fetch. Defaults to `follow`.
+     */
+    activation?: 'follow' | 'explicit';
+    /** Stretches tabs to fill the strip. Defaults to false. */
+    stretch?: boolean;
+    disabled?: boolean;
+    ariaLabel?: string;
+}
+declare const TX_TABS_DEFAULTS: {
+    readonly appearance: "underline";
+    readonly orientation: "horizontal";
+    readonly size: "md";
+    readonly activation: "follow";
+};
+/**
+ * Marks an `ng-template` as one tab's panel content.
+ *
+ * @example
+ * ```html
+ * <ng-template txTabPanel="details">…</ng-template>
+ * ```
+ */
+declare class TxTabPanelDirective {
+    /** The `value` of the tab this template belongs to. */
+    readonly tab: _angular_core.InputSignal<string>;
+    readonly template: TemplateRef<unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TxTabPanelDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TxTabPanelDirective, "ng-template[txTabPanel]", never, { "tab": { "alias": "txTabPanel"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Tabs.
+ *
+ * Behaviour is `@angular/aria`'s `ngTabs` / `ngTabList` / `ngTab` /
+ * `ngTabPanel`: the roving tab stop, arrow-key navigation, Home/End, and the
+ * `aria-controls` / `aria-labelledby` pairing between each tab and its panel.
+ * Every visual state is read off `aria-selected` and `aria-disabled` rather
+ * than mirrored into TypeScript.
+ *
+ * Panel content is deferred by Aria, so a panel is only created once its tab is
+ * first selected.
+ *
+ * @example
+ * ```html
+ * <tx-tabs [tabs]="tabs" [(selected)]="current">
+ *   <ng-template txTabPanel="details">…</ng-template>
+ *   <ng-template txTabPanel="history">…</ng-template>
+ * </tx-tabs>
+ * ```
+ *
+ * Config is a signal input — replace the object rather than mutating it.
+ */
+declare class TxTabsComponent {
+    readonly config: _angular_core.InputSignal<Partial<TxTabsConfig>>;
+    /** The tabs. Data, so they are their own input. */
+    readonly tabs: _angular_core.InputSignal<readonly TxTab[]>;
+    /** The selected tab's `value`. */
+    readonly selected: _angular_core.ModelSignal<string | undefined>;
+    readonly selectedChanged: _angular_core.OutputEmitterRef<string | undefined>;
+    private readonly panels;
+    private readonly resolved;
+    protected readonly orientation: _angular_core.Signal<"vertical" | "horizontal">;
+    protected readonly activation: _angular_core.Signal<"follow" | "explicit">;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected panelFor(value: string): TemplateRef<unknown> | null;
+    protected readonly rootClass: _angular_core.Signal<string>;
+    protected readonly listClass: _angular_core.Signal<string>;
+    protected readonly triggerClass: _angular_core.Signal<string>;
+    protected readonly panelsClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TxTabsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TxTabsComponent, "tx-tabs", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; "tabs": { "alias": "tabs"; "required": true; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; }, { "selected": "selectedChange"; "selectedChanged": "selectedChanged"; }, ["panels"], never, true, never>;
+}
+
+/**
+ * One accordion section.
+ *
+ * Sections are data. Both the body and any header buttons are projected
+ * templates, because a header that "must accept arbitrary buttons" is exactly
+ * what a config field can never express.
+ */
+interface TxAccordionItem {
+    /** Unique value. Also what the content and header-action templates match on. */
+    value: string;
+    label: string;
+    /** Secondary line under the label. */
+    description?: string;
+    /** Registered icon name shown before the label. */
+    icon?: string;
+    /** Short count or status shown after the label. */
+    badge?: string;
+    disabled?: boolean;
+}
+/** Visual treatment. */
+type TxAccordionAppearance = 'separated' | 'contained' | 'flush';
+/** Simple property configuration for {@link TxAccordionComponent}. */
+interface TxAccordionConfig {
+    /** Defaults to `separated`. */
+    appearance?: TxAccordionAppearance;
+    /** Defaults to `md`. */
+    size?: 'sm' | 'md';
+    /** More than one section open at a time. Defaults to true. */
+    multiple?: boolean;
+    /** Which side the chevron sits on. Defaults to `start`. */
+    chevronPosition?: 'start' | 'end';
+    disabled?: boolean;
+}
+declare const TX_ACCORDION_DEFAULTS: {
+    readonly appearance: "separated";
+    readonly size: "md";
+    readonly multiple: true;
+    readonly chevronPosition: "start";
+};
+/** Marks an `ng-template` as one section's body. */
+declare class TxAccordionContentDirective {
+    /** The `value` of the section this template belongs to. */
+    readonly item: _angular_core.InputSignal<string>;
+    readonly template: TemplateRef<unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TxAccordionContentDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TxAccordionContentDirective, "ng-template[txAccordionContent]", never, { "item": { "alias": "txAccordionContent"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Marks an `ng-template` as buttons for one section's header.
+ *
+ * Rendered outside the trigger button, because a button inside a button is
+ * invalid and unreachable — which is why this is a slot rather than a config
+ * field.
+ */
+declare class TxAccordionHeaderActionsDirective {
+    /** The `value` of the section these actions belong to. */
+    readonly item: _angular_core.InputSignal<string>;
+    readonly template: TemplateRef<unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TxAccordionHeaderActionsDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TxAccordionHeaderActionsDirective, "ng-template[txAccordionHeaderActions]", never, { "item": { "alias": "txAccordionHeaderActions"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * A stack of collapsible sections.
+ *
+ * Behaviour is `@angular/aria`'s `ngAccordionGroup` / `ngAccordionPanel` /
+ * `ngAccordionTrigger` / `ngAccordionContent`: arrow-key navigation between
+ * headers, Home/End, the `aria-expanded` / `aria-controls` pairing, and
+ * deferred rendering so a collapsed body is never created.
+ *
+ * Header actions are projected and rendered *beside* the trigger, never inside
+ * it: nesting a button in a button is invalid HTML and the inner one cannot be
+ * reached by keyboard.
+ *
+ * @example
+ * ```html
+ * <tx-accordion [items]="sections" [(expanded)]="open">
+ *   <ng-template txAccordionContent="symptoms">…</ng-template>
+ *   <ng-template txAccordionHeaderActions="symptoms">
+ *     <tx-button [config]="{ label: 'Add symptom', icon: 'plus', size: 'sm' }" />
+ *   </ng-template>
+ * </tx-accordion>
+ * ```
+ *
+ * Config is a signal input — replace the object rather than mutating it.
+ */
+declare class TxAccordionComponent {
+    readonly config: _angular_core.InputSignal<Partial<TxAccordionConfig>>;
+    /** The sections. Data, so they are their own input. */
+    readonly items: _angular_core.InputSignal<readonly TxAccordionItem[]>;
+    /** Values of the open sections. */
+    readonly expanded: _angular_core.ModelSignal<string[]>;
+    readonly expandedChanged: _angular_core.OutputEmitterRef<string[]>;
+    private readonly contents;
+    private readonly headerActions;
+    private readonly resolved;
+    private readonly expandedSet;
+    protected readonly isMultiple: _angular_core.Signal<boolean>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly chevronStart: _angular_core.Signal<boolean>;
+    protected readonly chevronClass: string;
+    protected contentFor(value: string): TemplateRef<unknown> | null;
+    protected headerActionsFor(value: string): TemplateRef<unknown> | null;
+    protected isExpanded(value: string): boolean;
+    protected setExpanded(value: string, expanded: boolean): void;
+    protected readonly rootClass: _angular_core.Signal<string>;
+    protected readonly sectionClass: _angular_core.Signal<string>;
+    protected readonly headerClass: _angular_core.Signal<string>;
+    protected readonly triggerClass: _angular_core.Signal<string>;
+    protected readonly bodyClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TxAccordionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TxAccordionComponent, "tx-accordion", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; "items": { "alias": "items"; "required": true; "isSignal": true; }; "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; }, { "expanded": "expandedChange"; "expandedChanged": "expandedChanged"; }, ["contents", "headerActions"], never, true, never>;
+}
+
+/** Simple property configuration for {@link TxHeaderComponent}. */
+interface TxHeaderConfig {
+    /**
+     * Wordmark text. Rendered in the display face, uppercase and letter-spaced,
+     * matching the reference design's lockup.
+     */
+    wordmark?: string;
+    /**
+     * A slice of the wordmark to accent in the brand colour, e.g. the `X` in
+     * `TRAXTION`. Matched case-sensitively, first occurrence only.
+     */
+    wordmarkAccent?: string;
+    /** Application name, shown after a divider. */
+    appName?: string;
+    /** Registered icon name shown before the wordmark. */
+    icon?: string;
+    /** Shows the menu button below `lg`, for toggling a sidebar. Defaults to true. */
+    menuButton?: boolean;
+    /** Reflected on the menu button as `aria-expanded`. */
+    menuOpen?: boolean;
+    /** Id of the element the menu button controls. */
+    menuControls?: string;
+    /** Sticks the header to the top of the viewport. Defaults to true. */
+    sticky?: boolean;
+    /** Adds the brand's tread band under the header. Defaults to false. */
+    groove?: boolean;
+}
+declare const TX_HEADER_DEFAULTS: {
+    readonly menuButton: true;
+    readonly sticky: true;
+};
+/**
+ * The application header bar.
+ *
+ * The wordmark and app name are simple properties; everything else — search,
+ * user chip, actions — is projected, because a header's contents are exactly
+ * the sort of thing a config object could never anticipate.
+ *
+ * Slots: `[txHeaderStart]` after the wordmark, default content in the middle,
+ * `[txHeaderEnd]` pinned to the trailing edge.
+ *
+ * @example
+ * ```html
+ * <tx-header
+ *   [config]="{ wordmark: 'TRAXTION', wordmarkAccent: 'X', appName: 'UI Kit',
+ *               menuOpen: navOpen(), menuControls: 'app-nav' }"
+ *   (menuToggled)="navOpen.set(!navOpen())">
+ *   <div txHeaderEnd>
+ *     <tx-button [config]="{ label: 'Sign out', variant: 'ghost', size: 'sm' }" />
+ *   </div>
+ * </tx-header>
+ * ```
+ *
+ * Config is a signal input — replace the object rather than mutating it.
+ */
+declare class TxHeaderComponent {
+    readonly config: _angular_core.InputSignal<Partial<TxHeaderConfig>>;
+    /** Emitted with the requested state. The app owns whether the nav is open. */
+    readonly menuToggled: _angular_core.OutputEmitterRef<boolean>;
+    private readonly resolved;
+    protected readonly showMenuButton: _angular_core.Signal<boolean>;
+    /** Splits the wordmark so one slice can carry the brand colour. */
+    protected readonly wordmarkParts: _angular_core.Signal<{
+        before: string;
+        accent: string;
+        after: string;
+    } | null>;
+    protected readonly grooveClass = "tx-groove";
+    protected readonly hostClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TxHeaderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TxHeaderComponent, "tx-header", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; }, { "menuToggled": "menuToggled"; }, never, ["[txHeaderStart]", "*", "[txHeaderEnd]"], true, never>;
+}
+
+/**
+ * One navigation entry.
+ *
+ * Items are data, and nest through `children`. A link navigates by
+ * `routerLink` or `href`; an item with neither emits `selected` and the
+ * application decides. No callback ever lives on the item.
+ */
+interface TxNavItem {
+    /** Unique within the sidebar. Used for expansion state. */
+    id: string;
+    label: string;
+    /** Registered icon name. */
+    icon?: string;
+    /** Short count or status after the label. */
+    badge?: string;
+    /** Angular router target. Takes precedence over `href`. */
+    routerLink?: string | readonly unknown[];
+    /** Plain link target. */
+    href?: string;
+    /** Nested entries. A parent with children is a disclosure, not a link. */
+    children?: readonly TxNavItem[];
+    disabled?: boolean;
+}
+/** A titled block of entries. */
+interface TxNavGroup {
+    /** Optional heading. Omit for an untitled block. */
+    label?: string;
+    items: readonly TxNavItem[];
+}
+/** Simple property configuration for {@link TxSidebarComponent}. */
+interface TxSidebarConfig {
+    /**
+     * Below this breakpoint the sidebar becomes an overlay drawer; at and above
+     * it, a static column. Defaults to `lg`.
+     */
+    breakpoint?: 'sm' | 'md' | 'lg' | 'xl';
+    /** Collapses the static sidebar to an icon rail. Defaults to false. */
+    railed?: boolean;
+    /** Defaults to `md`. */
+    size?: 'sm' | 'md';
+    /** Accessible name. Defaults to `Main`. */
+    ariaLabel?: string;
+}
+declare const TX_SIDEBAR_DEFAULTS: {
+    readonly breakpoint: "lg";
+    readonly size: "md";
+    readonly ariaLabel: "Main";
+};
+/**
+ * The application's navigation sidebar.
+ *
+ * A static column from its breakpoint up, and an overlay drawer below it, with
+ * a scrim that closes on click. Nested entries are disclosures that carry
+ * `aria-expanded`; the active route is marked with `aria-current="page"` by
+ * `RouterLinkActive`, and every selected/active style is read off that
+ * attribute rather than from a mirrored boolean.
+ *
+ * Header and footer are projected slots, so a product can put a logo, a search
+ * box or a user chip in without this component knowing about any of them.
+ *
+ * @example
+ * ```html
+ * <tx-sidebar
+ *   id="app-nav"
+ *   [groups]="navGroups"
+ *   [(open)]="navOpen"
+ *   [config]="{ breakpoint: 'lg' }">
+ *   <div txSidebarFooter>
+ *     <tx-button [config]="{ label: 'Sign out', variant: 'ghost', width: 'full' }" />
+ *   </div>
+ * </tx-sidebar>
+ * ```
+ *
+ * Config is a signal input — replace the object rather than mutating it.
+ */
+declare class TxSidebarComponent {
+    readonly config: _angular_core.InputSignal<Partial<TxSidebarConfig>>;
+    /** The navigation tree, in groups. Data, so it is its own input. */
+    readonly groups: _angular_core.InputSignal<readonly TxNavGroup[]>;
+    /** Whether the drawer is open. Only meaningful below the breakpoint. */
+    readonly open: _angular_core.ModelSignal<boolean>;
+    /** Ids of the expanded parent entries. */
+    readonly expandedIds: _angular_core.ModelSignal<string[]>;
+    /** Emitted for an entry that has no link target. */
+    readonly selected: _angular_core.OutputEmitterRef<TxNavItem>;
+    private readonly resolved;
+    private readonly breakpoint;
+    private readonly expandedSet;
+    protected readonly isRailed: _angular_core.Signal<boolean>;
+    protected readonly navClass: _angular_core.Signal<string>;
+    protected readonly scrimClass: _angular_core.Signal<string>;
+    protected itemClass(depth: number): string;
+    protected isExpanded(id: string): boolean;
+    protected toggle(id: string): void;
+    protected setOpen(open: boolean): void;
+    /** Navigating from the drawer should close it; on desktop it is a no-op. */
+    protected onNavigate(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TxSidebarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TxSidebarComponent, "tx-sidebar", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; "groups": { "alias": "groups"; "required": true; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "expandedIds": { "alias": "expandedIds"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "expandedIds": "expandedIdsChange"; "selected": "selected"; }, never, ["[txSidebarHeader]", "[txSidebarFooter]"], true, never>;
+}
+
+export { CONTROL_ICON_SIZE, TX_ACCORDION_DEFAULTS, TX_ALERT_DEFAULTS, TX_BADGE_DEFAULTS, TX_BREADCRUMB_DEFAULTS, TX_BUTTON_DEFAULTS, TX_CARD_DEFAULTS, TX_CHIPS_INPUT_DEFAULTS, TX_DATEPICKER_DEFAULTS, TX_DEFAULT_ICONS, TX_DIALOG_DEFAULTS, TX_DIVIDER_DEFAULTS, TX_DROPDOWN_TREE_DEFAULTS, TX_EMPTY_STATE_DEFAULTS, TX_FORM_FIELD, TX_FORM_FIELD_DEFAULTS, TX_HEADER_DEFAULTS, TX_ICON_DEFAULTS, TX_INPUT_DEFAULTS, TX_MULTISELECT_DEFAULTS, TX_OVERLAY_DEFAULTS, TX_PAGINATION_DEFAULTS, TX_POPUP_EMPTY_CLASS, TX_POPUP_GROUP_CLASS, TX_POPUP_LIST_CLASS, TX_POPUP_MAX_HEIGHT, TX_POPUP_OPTION_CLASS, TX_POPUP_PANEL_CLASS, TX_RADIO_GROUP_DEFAULTS, TX_REORDER_LIST_DEFAULTS, TX_SELECT_DEFAULTS, TX_SIDEBAR_DEFAULTS, TX_SKELETON_DEFAULTS, TX_SPINNER_DEFAULTS, TX_TABLE_DEFAULTS, TX_TABS_DEFAULTS, TX_TEXTAREA_DEFAULTS, TX_TOOLTIP_DEFAULTS, TX_TREE_DEFAULTS, TX_TRIGGER_CHEVRON_CLASS, TX_TRIGGER_CLEAR_CLASS, TxAccordionComponent, TxAccordionContentDirective, TxAccordionHeaderActionsDirective, TxAlertComponent, TxBadgeComponent, TxBreadcrumbComponent, TxButtonComponent, TxCardComponent, TxCheckboxComponent, TxChipsInputComponent, TxConfirmDialogComponent, TxConnectedOverlayDirective, TxControlValueBridge, TxDatepickerComponent, TxDialogComponent, TxDialogService, TxDividerComponent, TxDropdownTreeComponent, TxEmptyStateComponent, TxFormFieldComponent, TxHeaderComponent, TxIconComponent, TxIconRegistry, TxInputComponent, TxMultiselectComponent, TxPaginationComponent, TxRadioGroupComponent, TxReorderListComponent, TxSelectComponent, TxSidebarComponent, TxSkeletonComponent, TxSpinnerComponent, TxSwitchComponent, TxTabPanelDirective, TxTableActionsDirective, TxTableCellDirective, TxTableComponent, TxTabsComponent, TxTextareaComponent, TxToastService, TxToastStackComponent, TxTooltipDirective, TxTooltipPanelComponent, TxTreeComponent, findTxTreeNode, flattenTxOptions, flattenTxTree, isTxOptionGroup, txAddDays, txAddMonths, txAriaSort, txBindFormField, txBuildMonthGrid, txClampDate, txClampPageIndex, txColumnValue, txCompareValues, txControlShellClass, txDaysInMonth, txFormatDate, txFormatPlaceholder, txFullDateLabel, txIsSameDay, txIsSameMonth, txIsWithin, txMergeConfig, txMonthLabel, txNextSort, txPageCount, txPageItems, txPageRange, txPaginate, txParseDate, txSelectionSummary, txSortRows, txStartOfDay, txStartOfMonth, txTreeBranchIds, txTreeNodeIds, txUniqueId, txVisibleChips, txWeekdayLabels };
+export type { TxAccordionAppearance, TxAccordionConfig, TxAccordionItem, TxAlertAppearance, TxAlertConfig, TxAlertVariant, TxBadgeAppearance, TxBadgeConfig, TxBadgeVariant, TxBreadcrumbConfig, TxBreadcrumbItem, TxButtonConfig, TxButtonDisplay, TxButtonIconPosition, TxButtonSize, TxButtonVariant, TxCalendarDay, TxCardAppearance, TxCardConfig, TxCheckboxConfig, TxChipsInputConfig, TxChipsSource, TxColumnAlign, TxColumnPriority, TxColumnVariant, TxConfirmDialogConfig, TxControlShellOptions, TxControlSize, TxDateFormat, TxDatepickerConfig, TxDatepickerEntry, TxDialogConfig, TxDialogOpenConfig, TxDialogSize, TxDialogTone, TxDividerConfig, TxDividerVariant, TxDropdownTreeConfig, TxEmptyStateConfig, TxFormFieldApi, TxFormFieldBinding, TxFormFieldConfig, TxFormFieldLayout, TxFormFieldSize, TxHeaderConfig, TxIconConfig, TxIconDefinition, TxIconSize, TxInputConfig, TxInputType, TxMultiselectConfig, TxMultiselectSummary, TxNavGroup, TxNavItem, TxOption, TxOptionGroup, TxOverlayCloseReason, TxOverlayConfig, TxOverlayPlacement, TxOverlayWidth, TxPageRange, TxPaginationAppearance, TxPaginationConfig, TxPopupHeight, TxRadioAppearance, TxRadioGroupConfig, TxReorderHandle, TxReorderItem, TxReorderListConfig, TxSelectConfig, TxSidebarConfig, TxSkeletonConfig, TxSkeletonShape, TxSortDirection, TxSpinnerConfig, TxSpinnerSize, TxSpinnerTone, TxSwitchConfig, TxTab, TxTableColumn, TxTableConfig, TxTableSelection, TxTableSort, TxTabsAppearance, TxTabsConfig, TxTextareaConfig, TxTextareaResize, TxToastCloseReason, TxToastConfig, TxToastPosition, TxToastRef, TxToastServiceConfig, TxToastVariant, TxTooltipConfig, TxTreeCheckboxes, TxTreeConfig, TxTreeExpansion, TxTreeGuides, TxTreeNode, TxTreeSelection, TxTreeSlotContext, TxWeekday };