@masmarino/gabarit 1.1.0 → 1.2.0

package/types/masmarino-gabarit.d.ts

@@ -1,10 +1,11 @@
 import * as _angular_platform_browser from '@angular/platform-browser';
 import * as _angular_core from '@angular/core';
-import { OnDestroy, TemplateRef, ElementRef, InjectionToken, Signal } from '@angular/core';
+import { WritableSignal, Signal, OnDestroy, TemplateRef, ElementRef, PipeTransform, InjectionToken, Provider } from '@angular/core';
 import { ControlValueAccessor, FormControl } from '@angular/forms';
 import { Observable } from 'rxjs';
+import * as _masmarino_gabarit from '@masmarino/gabarit';
 
-declare const GABARIT_VERSION = "1.1.0";
+declare const GABARIT_VERSION = "1.2.0";
 
 declare class Icon {
     private readonly sanitizer;
@@ -51,9 +52,24 @@ declare class AppShell {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<AppShell, "gbt-app-shell", never, { "navLabel": { "alias": "navLabel"; "required": true; "isSignal": true; }; "skipLabel": { "alias": "skipLabel"; "required": true; "isSignal": true; }; "openMenuLabel": { "alias": "openMenuLabel"; "required": true; "isSignal": true; }; "closeMenuLabel": { "alias": "closeMenuLabel"; "required": true; "isSignal": true; }; "collapseLabel": { "alias": "collapseLabel"; "required": false; "isSignal": true; }; "expandLabel": { "alias": "expandLabel"; "required": false; "isSignal": true; }; "versionLabel": { "alias": "versionLabel"; "required": false; "isSignal": true; }; "collapsed": { "alias": "collapsed"; "required": false; "isSignal": true; }; "collapsible": { "alias": "collapsible"; "required": false; "isSignal": true; }; }, { "collapsedChange": "collapsedChange"; }, never, ["[shell-brand]", "[shell-nav]", "[shell-header]", "*"], true, never>;
 }
 
+declare class AppShellNavGroup {
+    label: _angular_core.InputSignal<string>;
+    icon: _angular_core.InputSignal<string | null>;
+    expanded: _angular_core.ModelSignal<boolean>;
+    protected readonly panelId: string;
+    protected toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AppShellNavGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AppShellNavGroup, "gbt-app-shell-nav-group", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; }, { "expanded": "expandedChange"; }, never, ["*"], true, never>;
+}
+
+type ButtonVariant = 'primary' | 'secondary' | 'danger' | 'ghost' | 'ghost-danger' | 'link';
+type ButtonSize = 'small' | 'medium' | 'large';
+type ButtonHaspopup = 'menu' | 'listbox' | 'tree' | 'grid' | 'dialog' | 'true' | 'false';
 declare class Button {
-    variant: _angular_core.InputSignal<"primary" | "secondary" | "danger">;
-    size: _angular_core.InputSignal<"small" | "medium" | "large">;
+    private readonly elementRef;
+    protected readonly isAnchor: boolean;
+    variant: _angular_core.InputSignal<ButtonVariant>;
+    size: _angular_core.InputSignal<ButtonSize>;
     type: _angular_core.InputSignal<"button" | "submit">;
     text: _angular_core.InputSignal<string>;
     iconName: _angular_core.InputSignal<string | null>;
@@ -61,104 +77,130 @@ declare class Button {
     loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
     loadingLabel: _angular_core.InputSignal<string>;
     disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    pressed: _angular_core.InputSignalWithTransform<boolean | null, string | boolean | null | undefined>;
+    ariaExpanded: _angular_core.InputSignalWithTransform<boolean | null, string | boolean | null | undefined>;
+    ariaControls: _angular_core.InputSignal<string | null>;
+    ariaHaspopup: _angular_core.InputSignal<boolean | ButtonHaspopup | null>;
+    block: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    iconOnly: _angular_core.InputSignalWithTransform<boolean, unknown>;
     clicked: _angular_core.OutputEmitterRef<void>;
+    protected readonly anchorHostClass: _angular_core.Signal<string>;
+    constructor();
     protected handleClick(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<Button, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Button, "gbt-button", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; "iconName": { "alias": "iconName"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "loadingLabel": { "alias": "loadingLabel"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "clicked": "clicked"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Button, "gbt-button, a[gbtButton]", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; "iconName": { "alias": "iconName"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "loadingLabel": { "alias": "loadingLabel"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "pressed": { "alias": "pressed"; "required": false; "isSignal": true; }; "ariaExpanded": { "alias": "ariaExpanded"; "required": false; "isSignal": true; }; "ariaControls": { "alias": "ariaControls"; "required": false; "isSignal": true; }; "ariaHaspopup": { "alias": "ariaHaspopup"; "required": false; "isSignal": true; }; "block": { "alias": "block"; "required": false; "isSignal": true; }; "iconOnly": { "alias": "iconOnly"; "required": false; "isSignal": true; }; }, { "clicked": "clicked"; }, never, ["*"], true, never>;
+}
+
+type CopyStatus = 'idle' | 'copied' | 'failed';
+type CopyValue = string | (() => string);
+declare function copyToClipboard(text: string): Promise<boolean>;
+declare function selectContents(element: HTMLElement | null | undefined): void;
+interface CopyOutcome {
+    copied: boolean;
+    text: string;
+}
+declare class ClipboardFeedback {
+    readonly status: _angular_core.WritableSignal<CopyStatus>;
+    private timer;
+    private destroyed;
+    constructor();
+    copy(value: CopyValue, feedbackMs: number, selectTarget?: HTMLElement | null): Promise<CopyOutcome | null>;
+    reset(): void;
+    private show;
+    private clearTimer;
 }
 
 type BadgeVariant = 'neutral' | 'success' | 'warning' | 'error' | 'info';
+type BadgeAppearance = 'filled' | 'outline';
+type BadgeSize = 'md' | 'sm';
 declare class Badge {
     variant: _angular_core.InputSignal<BadgeVariant>;
     icon: _angular_core.InputSignal<string | undefined>;
+    appearance: _angular_core.InputSignal<BadgeAppearance>;
+    size: _angular_core.InputSignal<BadgeSize>;
+    truncate: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    tabularNums: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    mono: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    maxWidth: _angular_core.InputSignal<string | null>;
+    fullText: _angular_core.InputSignal<string | null>;
+    copyable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    copyValue: _angular_core.InputSignal<string | null>;
+    copyLabel: _angular_core.InputSignal<string>;
+    copiedText: _angular_core.InputSignal<string>;
+    failedText: _angular_core.InputSignal<string>;
+    feedbackMs: _angular_core.InputSignal<number>;
+    value: _angular_core.InputSignal<number | null>;
+    max: _angular_core.InputSignal<number | null>;
+    hideZero: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    label: _angular_core.InputSignal<string | null>;
+    copied: _angular_core.OutputEmitterRef<string>;
+    copyFailed: _angular_core.OutputEmitterRef<void>;
+    protected readonly clipboard: ClipboardFeedback;
+    private readonly content;
+    protected readonly hasValue: _angular_core.Signal<boolean>;
+    private readonly count;
+    protected readonly displayText: _angular_core.Signal<string>;
+    protected readonly visible: _angular_core.Signal<boolean>;
+    protected readonly glyph: _angular_core.Signal<"copy" | "check" | "alert-circle">;
+    protected readonly statusText: _angular_core.Signal<string>;
+    protected copy(): Promise<void>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<Badge, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Badge, "gbt-badge", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Badge, "gbt-badge", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "truncate": { "alias": "truncate"; "required": false; "isSignal": true; }; "tabularNums": { "alias": "tabularNums"; "required": false; "isSignal": true; }; "mono": { "alias": "mono"; "required": false; "isSignal": true; }; "maxWidth": { "alias": "maxWidth"; "required": false; "isSignal": true; }; "fullText": { "alias": "fullText"; "required": false; "isSignal": true; }; "copyable": { "alias": "copyable"; "required": false; "isSignal": true; }; "copyValue": { "alias": "copyValue"; "required": false; "isSignal": true; }; "copyLabel": { "alias": "copyLabel"; "required": false; "isSignal": true; }; "copiedText": { "alias": "copiedText"; "required": false; "isSignal": true; }; "failedText": { "alias": "failedText"; "required": false; "isSignal": true; }; "feedbackMs": { "alias": "feedbackMs"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "hideZero": { "alias": "hideZero"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, { "copied": "copied"; "copyFailed": "copyFailed"; }, never, ["*"], true, never>;
 }
 
-type AvatarSize = 'sm' | 'md' | 'lg';
-declare class Avatar {
-    name: _angular_core.InputSignal<string>;
-    src: _angular_core.InputSignal<string | null>;
-    size: _angular_core.InputSignal<AvatarSize>;
-    protected readonly imageFailed: _angular_core.WritableSignal<boolean>;
-    protected readonly showImage: _angular_core.Signal<boolean>;
-    protected readonly initials: _angular_core.Signal<string>;
-    protected onImageError(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Avatar, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Avatar, "gbt-avatar", never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; "src": { "alias": "src"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+interface Scale<T> {
+    map(value: T): number;
+    invert(pixel: number): T;
+    readonly domain: [T, T];
+    readonly range: [number, number];
 }
-
-type SkeletonVariant = 'text' | 'circle' | 'rect';
-declare class Skeleton {
-    variant: _angular_core.InputSignal<SkeletonVariant>;
-    width: _angular_core.InputSignal<string>;
-    height: _angular_core.InputSignal<string | null>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Skeleton, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Skeleton, "gbt-skeleton", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+declare function linearScale(domain: [number, number], range: [number, number]): Scale<number>;
+declare function timeScale(domain: [Date, Date], range: [number, number]): Scale<Date>;
+interface BandScale {
+    map(value: string): number;
+    invert(pixel: number): string | null;
+    readonly bandwidth: number;
+    readonly domain: string[];
+    readonly range: [number, number];
 }
+declare function bandScale(domain: string[], range: [number, number], padding?: number): BandScale;
 
-interface AvatarGroupItem {
-    name: string;
-    src?: string;
-}
-declare class AvatarGroup<T extends AvatarGroupItem = AvatarGroupItem> {
-    private readonly elementRef;
-    items: _angular_core.InputSignal<T[]>;
-    max: _angular_core.InputSignal<number>;
-    ariaLabel: _angular_core.InputSignal<string>;
-    moreLabel: _angular_core.InputSignal<(count: number) => string>;
-    activeItem: _angular_core.InputSignal<T | null>;
-    itemClick: _angular_core.OutputEmitterRef<T>;
-    protected readonly panelOpen: _angular_core.WritableSignal<boolean>;
-    protected readonly panelStyle: _angular_core.WritableSignal<{
-        top: string;
-        left: string;
-    } | null>;
-    protected readonly visibleItems: _angular_core.Signal<T[]>;
-    protected readonly overflowItems: _angular_core.Signal<T[]>;
-    protected readonly overflowCount: _angular_core.Signal<number>;
-    protected isActive(item: T): boolean;
-    protected selectItem(item: T): void;
-    protected toggleOverflowPanel(): void;
-    protected updatePanelPosition(): void;
-    protected handleClickOutside(event: MouseEvent): void;
-    protected onKeydown(event: KeyboardEvent): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvatarGroup<any>, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvatarGroup<any>, "gbt-avatar-group", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "moreLabel": { "alias": "moreLabel"; "required": false; "isSignal": true; }; "activeItem": { "alias": "activeItem"; "required": false; "isSignal": true; }; }, { "itemClick": "itemClick"; }, never, never, true, never>;
+declare function niceTicks(min: number, max: number, count: number): number[];
+type TimeUnit = 'second' | 'minute' | 'hour' | 'day' | 'month' | 'year';
+interface TimeTicks {
+    readonly values: Date[];
+    readonly unit: TimeUnit;
+    format(date: Date, locale: string): string;
 }
+declare function timeTicks(start: Date, end: Date, pixelWidth: number): TimeTicks;
 
-type AlertVariant = 'info' | 'success' | 'warning' | 'error';
-declare class Alert {
-    variant: _angular_core.InputSignal<AlertVariant>;
-    dismissible: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    closeLabel: _angular_core.InputSignal<string>;
-    dismissed: _angular_core.OutputEmitterRef<void>;
-    protected readonly role: _angular_core.Signal<"alert" | "status">;
-    protected readonly icon: _angular_core.Signal<string>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Alert, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Alert, "gbt-alert", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "dismissible": { "alias": "dismissible"; "required": false; "isSignal": true; }; "closeLabel": { "alias": "closeLabel"; "required": false; "isSignal": true; }; }, { "dismissed": "dismissed"; }, never, ["*"], true, never>;
+declare function formatNumber(value: number, locale: string, decimals?: number): string;
+declare function formatCompact(value: number, locale: string): string;
+interface FormatDurationOptions {
+    days?: boolean;
 }
+declare function formatDuration(ms: number, locale: string, options?: FormatDurationOptions): string;
+declare function formatPercent(ratio: number, locale: string, decimals?: number): string;
 
-declare class Tag {
-    color: _angular_core.InputSignal<string>;
-    removable: _angular_core.InputSignal<boolean>;
-    removeLabel: _angular_core.InputSignal<string>;
-    disabled: _angular_core.InputSignal<boolean>;
-    removed: _angular_core.OutputEmitterRef<void>;
-    protected readonly textColor: _angular_core.Signal<string>;
-    protected onRemoveClick(event: MouseEvent): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Tag, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Tag, "gbt-tag", never, { "color": { "alias": "color"; "required": true; "isSignal": true; }; "removable": { "alias": "removable"; "required": false; "isSignal": true; }; "removeLabel": { "alias": "removeLabel"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "removed": "removed"; }, never, ["*"], true, never>;
+interface FormatBytesOptions {
+    base?: 1000 | 1024;
+    decimals?: number;
+    binaryUnits?: 'iec' | 'legacy';
 }
+declare function formatBytes(bytes: number, locale: string, options?: FormatBytesOptions): string;
 
-type EmptyStateIllustration = 'folder' | 'star' | 'checklist' | 'merge' | 'pipeline' | 'tag' | 'book' | 'server';
-declare class EmptyState {
-    illustration: _angular_core.InputSignal<EmptyStateIllustration>;
-    heading: _angular_core.InputSignal<string>;
-    message: _angular_core.InputSignal<string>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EmptyState, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EmptyState, "gbt-empty-state", never, { "illustration": { "alias": "illustration"; "required": true; "isSignal": true; }; "heading": { "alias": "heading"; "required": true; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+type DateInput = Date | string | number;
+interface FormatRelativeTimeOptions {
+    style?: 'long' | 'short' | 'narrow';
+    numeric?: 'auto' | 'always';
+    maxUnit?: 'hour' | 'day' | 'week' | 'month';
+    absoluteAfterDays?: number;
+    timeZone?: string;
 }
+declare function formatRelativeTime(date: DateInput | null | undefined, locale: string, now?: DateInput, options?: FormatRelativeTimeOptions): string;
+declare function formatDateTime(date: DateInput | null | undefined, locale: string, options?: Intl.DateTimeFormatOptions): string;
+
+declare function computeInitials(name: string): string;
 
 interface SelectOption<T = string> {
     value: T;
@@ -170,7 +212,10 @@ declare class Select<T = string> implements ControlValueAccessor {
     private readonly elementRef;
     id: _angular_core.InputSignal<string>;
     label: _angular_core.InputSignal<string>;
-    size: _angular_core.InputSignal<"sm" | "md">;
+    size: _angular_core.InputSignal<"md" | "sm">;
+    hint: _angular_core.InputSignal<string>;
+    hideLabel: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    fullWidth: _angular_core.InputSignalWithTransform<boolean, unknown>;
     options: _angular_core.InputSignal<SelectOption<T>[]>;
     multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
     chips: _angular_core.InputSignalWithTransform<boolean, unknown>;
@@ -180,6 +225,7 @@ declare class Select<T = string> implements ControlValueAccessor {
     errorMessage: _angular_core.InputSignal<string | null>;
     selectedCountLabel: _angular_core.InputSignal<(count: number) => string>;
     chipRemoveLabel: _angular_core.InputSignal<(label: string) => string>;
+    noOptionsMessage: _angular_core.InputSignal<string>;
     protected readonly open: _angular_core.WritableSignal<boolean>;
     protected readonly activeIndex: _angular_core.WritableSignal<number>;
     protected readonly selected: _angular_core.WritableSignal<T[]>;
@@ -191,6 +237,8 @@ declare class Select<T = string> implements ControlValueAccessor {
     private readonly formDisabled;
     protected readonly labelId: _angular_core.Signal<string>;
     protected readonly chipsId: _angular_core.Signal<string>;
+    protected readonly hintId: _angular_core.Signal<string>;
+    protected readonly showHint: _angular_core.Signal<boolean>;
     protected readonly isDisabled: _angular_core.Signal<boolean>;
     private onChange;
     private onTouched;
@@ -201,30 +249,19 @@ declare class Select<T = string> implements ControlValueAccessor {
     protected readonly selectedOptions: _angular_core.Signal<SelectOption<T>[]>;
     protected readonly triggerLabel: _angular_core.Signal<string>;
     protected readonly chipsVisible: _angular_core.Signal<boolean>;
-    /**
-     * In chips mode the trigger keeps showing the placeholder, so the selection
-     * is conveyed to assistive technology by describing the trigger with the
-     * chip row itself. The error message keeps its own id in the list.
-     */
     protected readonly describedBy: _angular_core.Signal<string | null>;
     protected readonly triggerIcon: _angular_core.Signal<string | undefined>;
     protected readonly activeOptionId: _angular_core.Signal<string | null>;
+    protected readonly hasNoOptions: _angular_core.Signal<boolean>;
     protected isSelected(value: T): boolean;
     protected toggleOpen(): void;
     protected updatePanelPosition(): void;
-    /**
-     * Removes the chip at `index`. Refuses to mutate anything while the control
-     * is disabled (the remove buttons are not rendered then, but a programmatic
-     * caller must not be able to bypass the disabled state either), and moves
-     * focus off the button it is about to destroy — otherwise focus falls back
-     * to `<body>`.
-     */
     protected removeChip(value: T, index: number): void;
     protected selectOption(value: T): void;
     protected handleClickOutside(event: MouseEvent): void;
     protected onKeydown(event: KeyboardEvent): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<Select<any>, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Select<any>, "gbt-select", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": true; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "chips": { "alias": "chips"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; "selectedCountLabel": { "alias": "selectedCountLabel"; "required": false; "isSignal": true; }; "chipRemoveLabel": { "alias": "chipRemoveLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Select<any>, "gbt-select", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "hideLabel": { "alias": "hideLabel"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": true; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "chips": { "alias": "chips"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; "selectedCountLabel": { "alias": "selectedCountLabel"; "required": false; "isSignal": true; }; "chipRemoveLabel": { "alias": "chipRemoveLabel"; "required": false; "isSignal": true; }; "noOptionsMessage": { "alias": "noOptionsMessage"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 interface ListToolbarSortOption<T extends string = string> {
@@ -252,31 +289,226 @@ declare class ListToolbar<T extends string = string> {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<ListToolbar<any>, "gbt-list-toolbar", never, { "searchValue": { "alias": "searchValue"; "required": false; "isSignal": true; }; "searchLabel": { "alias": "searchLabel"; "required": true; "isSignal": true; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; "isSignal": true; }; "sortOptions": { "alias": "sortOptions"; "required": true; "isSignal": true; }; "sortValue": { "alias": "sortValue"; "required": true; "isSignal": true; }; "sortDirection": { "alias": "sortDirection"; "required": false; "isSignal": true; }; "sortLabel": { "alias": "sortLabel"; "required": false; "isSignal": true; }; "directionLabel": { "alias": "directionLabel"; "required": false; "isSignal": true; }; }, { "searchValueChange": "searchValueChange"; "sortValueChange": "sortValueChange"; "sortDirectionChange": "sortDirectionChange"; }, never, never, true, never>;
 }
 
+type ListToolbarDirection = 'asc' | 'desc';
+type ListToolbarSortValue = string | number | boolean | Date | null | undefined;
+interface ListToolbarStateConfig<K extends string> {
+    sortOptions?: ListToolbarSortOption<K>[];
+    defaultSort?: K;
+    defaultDirection?: ListToolbarDirection;
+    initialSearch?: string;
+}
+interface ListToolbarAccessors<T, K extends string> {
+    text?: (item: T) => string | readonly (string | null | undefined)[] | null | undefined;
+    matches?: (item: T, query: string) => boolean;
+    sortBy?: Partial<Record<K, (item: T) => ListToolbarSortValue>>;
+    compare?: (a: T, b: T, key: K) => number;
+    locale?: string;
+}
+interface ListToolbarState<K extends string = string> {
+    readonly search: WritableSignal<string>;
+    readonly sortValue: WritableSignal<K>;
+    readonly direction: WritableSignal<ListToolbarDirection>;
+    readonly sortOptions: ListToolbarSortOption<K>[];
+    readonly dirty: Signal<boolean>;
+    reset(): void;
+    apply<T>(items: readonly T[], accessors: ListToolbarAccessors<T, K>): T[];
+    filtered<T>(source: () => readonly T[], accessors: ListToolbarAccessors<T, K>): Signal<T[]>;
+}
+declare function createListToolbarState<K extends string = string>(config?: ListToolbarStateConfig<K>): ListToolbarState<K>;
+
+interface Point {
+    x: number;
+    y: number;
+}
+declare function linePath(points: Point[]): string;
+declare function areaPath(points: Point[], baseline: number): string;
+interface Arc {
+    startAngle: number;
+    endAngle: number;
+    innerRadius: number;
+    outerRadius: number;
+}
+declare function arcPath(arc: Arc): string;
+
+declare function nearestIndex(sorted: number[], target: number): number;
+
+type AvatarSize = 'sm' | 'md' | 'lg';
+declare class Avatar {
+    name: _angular_core.InputSignal<string>;
+    src: _angular_core.InputSignal<string | null>;
+    size: _angular_core.InputSignal<AvatarSize>;
+    protected readonly imageFailed: _angular_core.WritableSignal<boolean>;
+    protected readonly showImage: _angular_core.Signal<boolean>;
+    protected readonly initials: _angular_core.Signal<string>;
+    protected onImageError(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Avatar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Avatar, "gbt-avatar", never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; "src": { "alias": "src"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type SkeletonVariant = 'text' | 'circle' | 'rect';
+declare class Skeleton {
+    variant: _angular_core.InputSignal<SkeletonVariant>;
+    width: _angular_core.InputSignal<string>;
+    height: _angular_core.InputSignal<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Skeleton, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Skeleton, "gbt-skeleton", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface AvatarGroupItem {
+    name: string;
+    src?: string;
+}
+declare class AvatarGroup<T extends AvatarGroupItem = AvatarGroupItem> {
+    private readonly elementRef;
+    items: _angular_core.InputSignal<T[]>;
+    max: _angular_core.InputSignal<number>;
+    ariaLabel: _angular_core.InputSignal<string>;
+    moreLabel: _angular_core.InputSignal<(count: number) => string>;
+    activeItem: _angular_core.InputSignal<T | null>;
+    itemClick: _angular_core.OutputEmitterRef<T>;
+    protected readonly panelOpen: _angular_core.WritableSignal<boolean>;
+    protected readonly panelStyle: _angular_core.WritableSignal<{
+        top: string;
+        left: string;
+    } | null>;
+    protected readonly visibleItems: _angular_core.Signal<T[]>;
+    protected readonly overflowItems: _angular_core.Signal<T[]>;
+    protected readonly overflowCount: _angular_core.Signal<number>;
+    protected isActive(item: T): boolean;
+    protected selectItem(item: T): void;
+    protected toggleOverflowPanel(): void;
+    protected updatePanelPosition(): void;
+    protected handleClickOutside(event: MouseEvent): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvatarGroup<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvatarGroup<any>, "gbt-avatar-group", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "moreLabel": { "alias": "moreLabel"; "required": false; "isSignal": true; }; "activeItem": { "alias": "activeItem"; "required": false; "isSignal": true; }; }, { "itemClick": "itemClick"; }, never, never, true, never>;
+}
+
+type AlertVariant = 'info' | 'success' | 'warning' | 'error' | 'neutral';
+type AlertLive = 'auto' | 'assertive' | 'polite' | 'off';
+type AlertSize = 'md' | 'sm';
+type AlertAppearance = 'default' | 'subtle';
+type AlertIconAlign = 'auto' | 'center' | 'start';
+declare class Alert {
+    variant: _angular_core.InputSignal<AlertVariant>;
+    dismissible: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    closeLabel: _angular_core.InputSignal<string>;
+    live: _angular_core.InputSignal<AlertLive>;
+    heading: _angular_core.InputSignal<string>;
+    size: _angular_core.InputSignal<AlertSize>;
+    appearance: _angular_core.InputSignal<AlertAppearance>;
+    iconAlign: _angular_core.InputSignal<AlertIconAlign>;
+    dismissed: _angular_core.OutputEmitterRef<void>;
+    protected readonly role: _angular_core.Signal<"alert" | "status" | null>;
+    protected readonly icon: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Alert, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Alert, "gbt-alert", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "dismissible": { "alias": "dismissible"; "required": false; "isSignal": true; }; "closeLabel": { "alias": "closeLabel"; "required": false; "isSignal": true; }; "live": { "alias": "live"; "required": false; "isSignal": true; }; "heading": { "alias": "heading"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "iconAlign": { "alias": "iconAlign"; "required": false; "isSignal": true; }; }, { "dismissed": "dismissed"; }, never, ["*", "[alert-actions]"], true, never>;
+}
+
+declare class Tag {
+    color: _angular_core.InputSignal<string>;
+    removable: _angular_core.InputSignal<boolean>;
+    removeLabel: _angular_core.InputSignal<string>;
+    disabled: _angular_core.InputSignal<boolean>;
+    removed: _angular_core.OutputEmitterRef<void>;
+    protected readonly textColor: _angular_core.Signal<string>;
+    protected onRemoveClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Tag, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Tag, "gbt-tag", never, { "color": { "alias": "color"; "required": true; "isSignal": true; }; "removable": { "alias": "removable"; "required": false; "isSignal": true; }; "removeLabel": { "alias": "removeLabel"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "removed": "removed"; }, never, ["*"], true, never>;
+}
+
+type EmptyStateIllustration = 'folder' | 'star' | 'checklist' | 'merge' | 'pipeline' | 'tag' | 'book' | 'server';
+type EmptyStateSize = 'default' | 'compact';
+type EmptyStateTone = 'default' | 'error';
+type EmptyStateHeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
+declare class EmptyState {
+    illustration: _angular_core.InputSignal<EmptyStateIllustration | null | undefined>;
+    heading: _angular_core.InputSignal<string>;
+    message: _angular_core.InputSignal<string>;
+    icon: _angular_core.InputSignal<string | null>;
+    size: _angular_core.InputSignal<EmptyStateSize>;
+    tone: _angular_core.InputSignal<EmptyStateTone>;
+    headingLevel: _angular_core.InputSignal<EmptyStateHeadingLevel | null>;
+    headingId: _angular_core.InputSignal<string | null>;
+    headingFocusable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly headingEl;
+    focusHeading(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EmptyState, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EmptyState, "gbt-empty-state", never, { "illustration": { "alias": "illustration"; "required": false; "isSignal": true; }; "heading": { "alias": "heading"; "required": true; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "headingLevel": { "alias": "headingLevel"; "required": false; "isSignal": true; }; "headingId": { "alias": "headingId"; "required": false; "isSignal": true; }; "headingFocusable": { "alias": "headingFocusable"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+type CardVariant = 'elevated' | 'outlined';
+type CardTone = 'default' | 'success' | 'warning' | 'error';
+declare class CardHeader {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardHeader, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CardHeader, "[card-header]", never, {}, {}, never, never, true, never>;
+}
 declare class Card {
     hoverable: _angular_core.InputSignalWithTransform<boolean, unknown>;
     heading: _angular_core.InputSignal<string>;
     icon: _angular_core.InputSignal<string>;
-    headingLevel: _angular_core.InputSignal<2 | 1 | 5 | 6 | 4 | 3>;
+    headingLevel: _angular_core.InputSignal<2 | 1 | 5 | 3 | 6 | 4>;
+    variant: _angular_core.InputSignal<CardVariant>;
+    description: _angular_core.InputSignal<string>;
+    count: _angular_core.InputSignal<number | null>;
+    flush: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    tone: _angular_core.InputSignal<CardTone>;
+    selected: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    selectedLabel: _angular_core.InputSignal<string>;
+    href: _angular_core.InputSignal<string | null>;
+    linkLabel: _angular_core.InputSignal<string | null>;
+    private readonly customHeader;
+    private readonly projectedLink;
+    protected readonly hasCustomHeader: _angular_core.Signal<boolean>;
+    protected readonly hasHeader: _angular_core.Signal<boolean>;
+    protected readonly linked: _angular_core.Signal<boolean>;
+    protected readonly headerIcon: _angular_core.Signal<string>;
     protected readonly cardClass: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<Card, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Card, "gbt-card", never, { "hoverable": { "alias": "hoverable"; "required": false; "isSignal": true; }; "heading": { "alias": "heading"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "headingLevel": { "alias": "headingLevel"; "required": false; "isSignal": true; }; }, {}, never, ["[card-header-actions]", "*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Card, "gbt-card", never, { "hoverable": { "alias": "hoverable"; "required": false; "isSignal": true; }; "heading": { "alias": "heading"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "headingLevel": { "alias": "headingLevel"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "count": { "alias": "count"; "required": false; "isSignal": true; }; "flush": { "alias": "flush"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "selectedLabel": { "alias": "selectedLabel"; "required": false; "isSignal": true; }; "href": { "alias": "href"; "required": false; "isSignal": true; }; "linkLabel": { "alias": "linkLabel"; "required": false; "isSignal": true; }; }, {}, ["customHeader", "projectedLink"], ["[card-header-actions]", "*", "[card-header]"], true, never>;
 }
 
+declare class CardLink {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardLink, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CardLink, "a[gbtCardLink]", never, {}, {}, never, ["*"], true, never>;
+}
+
+type InputType = 'text' | 'password' | 'email' | 'number' | 'search' | 'url';
+type InputSize = 'md' | 'sm';
+type InputInputmode = 'none' | 'text' | 'tel' | 'url' | 'email' | 'numeric' | 'decimal' | 'search';
+type InputAutocapitalize = 'off' | 'none' | 'on' | 'sentences' | 'words' | 'characters';
+type InputEnterkeyhint = 'enter' | 'done' | 'go' | 'next' | 'previous' | 'search' | 'send';
 declare class GbtInput implements ControlValueAccessor {
     id: _angular_core.InputSignal<string>;
     label: _angular_core.InputSignal<string>;
-    type: _angular_core.InputSignal<"text" | "password" | "email">;
+    type: _angular_core.InputSignal<InputType>;
     required: _angular_core.InputSignalWithTransform<boolean, unknown>;
     disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     placeholder: _angular_core.InputSignal<string>;
     errorMessage: _angular_core.InputSignal<string | null>;
     autocomplete: _angular_core.InputSignal<string>;
+    hint: _angular_core.InputSignal<string>;
+    hideLabel: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    size: _angular_core.InputSignal<InputSize>;
+    mono: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    leadingIcon: _angular_core.InputSignal<string | null>;
+    inputmode: _angular_core.InputSignal<InputInputmode | null>;
+    spellcheck: _angular_core.InputSignal<boolean | null>;
+    autocapitalize: _angular_core.InputSignal<InputAutocapitalize | null>;
+    enterkeyhint: _angular_core.InputSignal<InputEnterkeyhint | null>;
+    maxlength: _angular_core.InputSignal<number | null>;
+    min: _angular_core.InputSignal<string | number | null>;
+    max: _angular_core.InputSignal<string | number | null>;
     showPasswordLabel: _angular_core.InputSignal<string>;
     hidePasswordLabel: _angular_core.InputSignal<string>;
     committed: _angular_core.OutputEmitterRef<string>;
     protected readonly value: _angular_core.WritableSignal<string>;
     protected readonly passwordVisible: _angular_core.WritableSignal<boolean>;
-    protected readonly effectiveType: _angular_core.Signal<"text" | "password" | "email">;
+    protected readonly effectiveType: _angular_core.Signal<InputType>;
+    protected readonly hintId: _angular_core.Signal<string>;
+    protected readonly errorId: _angular_core.Signal<string>;
+    protected readonly showHint: _angular_core.Signal<boolean>;
+    protected readonly describedBy: _angular_core.Signal<string | null>;
     private readonly formDisabled;
     protected readonly isDisabled: _angular_core.Signal<boolean>;
     private onChange;
@@ -289,14 +521,16 @@ declare class GbtInput implements ControlValueAccessor {
     protected onBlur(): void;
     protected togglePasswordVisibility(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<GbtInput, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GbtInput, "gbt-input", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; "showPasswordLabel": { "alias": "showPasswordLabel"; "required": false; "isSignal": true; }; "hidePasswordLabel": { "alias": "hidePasswordLabel"; "required": false; "isSignal": true; }; }, { "committed": "committed"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GbtInput, "gbt-input", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "hideLabel": { "alias": "hideLabel"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "mono": { "alias": "mono"; "required": false; "isSignal": true; }; "leadingIcon": { "alias": "leadingIcon"; "required": false; "isSignal": true; }; "inputmode": { "alias": "inputmode"; "required": false; "isSignal": true; }; "spellcheck": { "alias": "spellcheck"; "required": false; "isSignal": true; }; "autocapitalize": { "alias": "autocapitalize"; "required": false; "isSignal": true; }; "enterkeyhint": { "alias": "enterkeyhint"; "required": false; "isSignal": true; }; "maxlength": { "alias": "maxlength"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "showPasswordLabel": { "alias": "showPasswordLabel"; "required": false; "isSignal": true; }; "hidePasswordLabel": { "alias": "hidePasswordLabel"; "required": false; "isSignal": true; }; }, { "committed": "committed"; }, never, never, true, never>;
 }
 
 declare class Checkbox implements ControlValueAccessor {
     id: _angular_core.InputSignal<string>;
     label: _angular_core.InputSignal<string>;
     disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    protected readonly checked: _angular_core.WritableSignal<boolean>;
+    hint: _angular_core.InputSignal<string>;
+    checked: _angular_core.ModelSignal<boolean>;
+    protected readonly hintId: _angular_core.Signal<string>;
     private readonly formDisabled;
     protected readonly isDisabled: _angular_core.Signal<boolean>;
     private onChange;
@@ -307,14 +541,17 @@ declare class Checkbox implements ControlValueAccessor {
     setDisabledState(isDisabled: boolean): void;
     protected onToggle(event: Event): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<Checkbox, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Checkbox, "gbt-checkbox", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Checkbox, "gbt-checkbox", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; }, never, never, true, never>;
 }
 
 declare class Modal implements OnDestroy {
     isOpen: _angular_core.InputSignal<boolean>;
     heading: _angular_core.InputSignal<string>;
-    headingLevel: _angular_core.InputSignal<2 | 1 | 5 | 6 | 4 | 3>;
+    headingLevel: _angular_core.InputSignal<2 | 1 | 5 | 3 | 6 | 4>;
     closeLabel: _angular_core.InputSignal<string>;
+    busy: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    busyLabel: _angular_core.InputSignal<string>;
+    returnFocus: _angular_core.InputSignalWithTransform<boolean, unknown>;
     closed: _angular_core.OutputEmitterRef<void>;
     private readonly dialog;
     private previouslyFocused;
@@ -322,9 +559,10 @@ declare class Modal implements OnDestroy {
     ngOnDestroy(): void;
     protected onEscape(): void;
     protected onBackdropClick(event: MouseEvent): void;
+    protected onCloseClick(): void;
     protected onDialogKeydown(event: KeyboardEvent): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<Modal, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Modal, "gbt-modal", never, { "isOpen": { "alias": "isOpen"; "required": true; "isSignal": true; }; "heading": { "alias": "heading"; "required": false; "isSignal": true; }; "headingLevel": { "alias": "headingLevel"; "required": false; "isSignal": true; }; "closeLabel": { "alias": "closeLabel"; "required": false; "isSignal": true; }; }, { "closed": "closed"; }, never, ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Modal, "gbt-modal", never, { "isOpen": { "alias": "isOpen"; "required": true; "isSignal": true; }; "heading": { "alias": "heading"; "required": false; "isSignal": true; }; "headingLevel": { "alias": "headingLevel"; "required": false; "isSignal": true; }; "closeLabel": { "alias": "closeLabel"; "required": false; "isSignal": true; }; "busy": { "alias": "busy"; "required": false; "isSignal": true; }; "busyLabel": { "alias": "busyLabel"; "required": false; "isSignal": true; }; "returnFocus": { "alias": "returnFocus"; "required": false; "isSignal": true; }; }, { "closed": "closed"; }, never, ["*", "[modal-footer]"], true, never>;
 }
 
 type DrawerEdge = 'right' | 'left' | 'top' | 'bottom';
@@ -332,7 +570,7 @@ declare class Drawer implements OnDestroy {
     isOpen: _angular_core.InputSignal<boolean>;
     edge: _angular_core.InputSignal<DrawerEdge>;
     heading: _angular_core.InputSignal<string>;
-    headingLevel: _angular_core.InputSignal<2 | 1 | 5 | 6 | 4 | 3>;
+    headingLevel: _angular_core.InputSignal<2 | 1 | 5 | 3 | 6 | 4>;
     closeLabel: _angular_core.InputSignal<string>;
     closed: _angular_core.OutputEmitterRef<void>;
     protected readonly rendered: _angular_core.WritableSignal<boolean>;
@@ -365,7 +603,9 @@ declare class Table<T extends object> {
     clickableRows: _angular_core.InputSignalWithTransform<boolean, unknown>;
     rowClick: _angular_core.OutputEmitterRef<T>;
     protected trackRow: (index: number, row: T) => unknown;
+    protected onRowClick(event: MouseEvent, row: T): void;
     protected onRowKeydown(event: KeyboardEvent, row: T): void;
+    private isInteractiveTarget;
     protected cellValue(row: T, column: TableColumn<T>): unknown;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<Table<any>, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<Table<any>, "gbt-table", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; "columns": { "alias": "columns"; "required": true; "isSignal": true; }; "trackBy": { "alias": "trackBy"; "required": false; "isSignal": true; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; "isSignal": true; }; "caption": { "alias": "caption"; "required": true; "isSignal": true; }; "clickableRows": { "alias": "clickableRows"; "required": false; "isSignal": true; }; }, { "rowClick": "rowClick"; }, never, never, true, never>;
@@ -376,8 +616,10 @@ interface SearchResultCategory<T = unknown> {
     icon?: string;
     items: T[];
 }
+type SearchBarCollapsible = boolean | 'narrow';
 declare class SearchBar<T = unknown> {
     private readonly elementRef;
+    private readonly injector;
     id: _angular_core.InputSignal<string>;
     results: _angular_core.InputSignal<T[] | null>;
     groupedResults: _angular_core.InputSignal<SearchResultCategory<T>[] | null>;
@@ -393,6 +635,10 @@ declare class SearchBar<T = unknown> {
     navigateHint: _angular_core.InputSignal<string>;
     selectHint: _angular_core.InputSignal<string>;
     closeHint: _angular_core.InputSignal<string>;
+    collapsible: _angular_core.InputSignalWithTransform<SearchBarCollapsible, string | boolean | null | undefined>;
+    expanded: _angular_core.ModelSignal<boolean>;
+    openLabel: _angular_core.InputSignal<string>;
+    closeLabel: _angular_core.InputSignal<string>;
     queryChange: _angular_core.OutputEmitterRef<string>;
     itemSelected: _angular_core.OutputEmitterRef<T>;
     clear: _angular_core.OutputEmitterRef<void>;
@@ -401,6 +647,10 @@ declare class SearchBar<T = unknown> {
     protected readonly searchQuery: _angular_core.WritableSignal<string>;
     protected readonly activeIndex: _angular_core.WritableSignal<number>;
     protected readonly searchInput: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
+    private readonly toggleButton;
+    protected readonly collapsibleMode: _angular_core.Signal<"narrow" | "always" | null>;
+    protected readonly folded: _angular_core.Signal<boolean>;
+    protected readonly triggerId: _angular_core.Signal<string>;
     private readonly hasGroupedResultsInput;
     protected readonly allVisibleItems: _angular_core.Signal<T[]>;
     protected readonly showOverlay: _angular_core.Signal<boolean>;
@@ -430,12 +680,15 @@ declare class SearchBar<T = unknown> {
     focusSearch(): void;
     protected blurSearch(): void;
     protected onFocus(): void;
-    protected onBlur(): void;
+    protected expand(): void;
+    private fold;
+    protected close(event: Event): void;
+    protected onBlur(event?: FocusEvent): void;
     protected onInput(event: Event): void;
     protected onClear(): void;
     protected onSelect(item: T): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<SearchBar<any>, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SearchBar<any>, "gbt-search-bar", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "results": { "alias": "results"; "required": false; "isSignal": true; }; "groupedResults": { "alias": "groupedResults"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "displayFn": { "alias": "displayFn"; "required": false; "isSignal": true; }; "itemTemplate": { "alias": "itemTemplate"; "required": false; "isSignal": true; }; "keepQueryOnSelect": { "alias": "keepQueryOnSelect"; "required": false; "isSignal": true; }; "noResultsMessage": { "alias": "noResultsMessage"; "required": false; "isSignal": true; }; "noResultsHint": { "alias": "noResultsHint"; "required": false; "isSignal": true; }; "clearLabel": { "alias": "clearLabel"; "required": false; "isSignal": true; }; "resultsAnnouncement": { "alias": "resultsAnnouncement"; "required": false; "isSignal": true; }; "navigateHint": { "alias": "navigateHint"; "required": false; "isSignal": true; }; "selectHint": { "alias": "selectHint"; "required": false; "isSignal": true; }; "closeHint": { "alias": "closeHint"; "required": false; "isSignal": true; }; }, { "queryChange": "queryChange"; "itemSelected": "itemSelected"; "clear": "clear"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SearchBar<any>, "gbt-search-bar", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "results": { "alias": "results"; "required": false; "isSignal": true; }; "groupedResults": { "alias": "groupedResults"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "displayFn": { "alias": "displayFn"; "required": false; "isSignal": true; }; "itemTemplate": { "alias": "itemTemplate"; "required": false; "isSignal": true; }; "keepQueryOnSelect": { "alias": "keepQueryOnSelect"; "required": false; "isSignal": true; }; "noResultsMessage": { "alias": "noResultsMessage"; "required": false; "isSignal": true; }; "noResultsHint": { "alias": "noResultsHint"; "required": false; "isSignal": true; }; "clearLabel": { "alias": "clearLabel"; "required": false; "isSignal": true; }; "resultsAnnouncement": { "alias": "resultsAnnouncement"; "required": false; "isSignal": true; }; "navigateHint": { "alias": "navigateHint"; "required": false; "isSignal": true; }; "selectHint": { "alias": "selectHint"; "required": false; "isSignal": true; }; "closeHint": { "alias": "closeHint"; "required": false; "isSignal": true; }; "collapsible": { "alias": "collapsible"; "required": false; "isSignal": true; }; "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; "openLabel": { "alias": "openLabel"; "required": false; "isSignal": true; }; "closeLabel": { "alias": "closeLabel"; "required": false; "isSignal": true; }; }, { "expanded": "expandedChange"; "queryChange": "queryChange"; "itemSelected": "itemSelected"; "clear": "clear"; }, never, never, true, never>;
 }
 
 declare class Tab {
@@ -460,52 +713,32 @@ declare class Tabs {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<Tabs, "gbt-tabs", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "activeIndex": { "alias": "activeIndex"; "required": false; "isSignal": true; }; }, { "activeIndex": "activeIndexChange"; }, ["tabs"], ["*"], true, never>;
 }
 
-interface Scale<T> {
-    map(value: T): number;
-    invert(pixel: number): T;
-    readonly domain: [T, T];
-    readonly range: [number, number];
+interface GbtPipeLocale {
+    locale?: string;
 }
-declare function linearScale(domain: [number, number], range: [number, number]): Scale<number>;
-declare function timeScale(domain: [Date, Date], range: [number, number]): Scale<Date>;
-interface BandScale {
-    map(value: string): number;
-    invert(pixel: number): string | null;
-    readonly bandwidth: number;
-    readonly domain: string[];
-    readonly range: [number, number];
-}
-declare function bandScale(domain: string[], range: [number, number], padding?: number): BandScale;
-
-declare function niceTicks(min: number, max: number, count: number): number[];
-type TimeUnit = 'second' | 'minute' | 'hour' | 'day' | 'month' | 'year';
-interface TimeTicks {
-    readonly values: Date[];
-    readonly unit: TimeUnit;
-    format(date: Date, locale: string): string;
-}
-declare function timeTicks(start: Date, end: Date, pixelWidth: number): TimeTicks;
-
-declare function formatNumber(value: number, locale: string, decimals?: number): string;
-declare function formatCompact(value: number, locale: string): string;
-declare function formatDuration(ms: number, locale: string): string;
-declare function formatPercent(ratio: number, locale: string, decimals?: number): string;
-
-interface Point {
-    x: number;
-    y: number;
-}
-declare function linePath(points: Point[]): string;
-declare function areaPath(points: Point[], baseline: number): string;
-interface Arc {
-    startAngle: number;
-    endAngle: number;
-    innerRadius: number;
-    outerRadius: number;
+type GbtRelativeTimePipeOptions = FormatRelativeTimeOptions & GbtPipeLocale & {
+    now?: DateInput;
+};
+type GbtBytesPipeOptions = FormatBytesOptions & GbtPipeLocale;
+type GbtDateTimePipeOptions = Intl.DateTimeFormatOptions & GbtPipeLocale;
+declare class GbtRelativeTimePipe implements PipeTransform {
+    private readonly localeId;
+    transform(value: DateInput | null | undefined, options?: GbtRelativeTimePipeOptions): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GbtRelativeTimePipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<GbtRelativeTimePipe, "gbtRelativeTime", true>;
+}
+declare class GbtBytesPipe implements PipeTransform {
+    private readonly localeId;
+    transform(value: number | null | undefined, options?: GbtBytesPipeOptions): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GbtBytesPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<GbtBytesPipe, "gbtBytes", true>;
+}
+declare class GbtDateTimePipe implements PipeTransform {
+    private readonly localeId;
+    transform(value: DateInput | null | undefined, options?: GbtDateTimePipeOptions): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GbtDateTimePipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<GbtDateTimePipe, "gbtDateTime", true>;
 }
-declare function arcPath(arc: Arc): string;
-
-declare function nearestIndex(sorted: number[], target: number): number;
 
 interface ChartMargin {
     top: number;
@@ -549,7 +782,7 @@ declare class ChartFrame {
     private readonly context;
     label: _angular_core.InputSignal<string>;
     heading: _angular_core.InputSignal<string>;
-    headingLevel: _angular_core.InputSignal<2 | 1 | 5 | 6 | 4 | 3>;
+    headingLevel: _angular_core.InputSignal<2 | 1 | 5 | 3 | 6 | 4>;
     headline: _angular_core.InputSignal<string>;
     trend: _angular_core.InputSignal<string>;
     x: _angular_core.InputSignal<AxisSpec>;
@@ -691,7 +924,7 @@ declare class LineChart<X extends number | Date> {
         height: number;
     } | null>;
     heading: _angular_core.InputSignal<string>;
-    headingLevel: _angular_core.InputSignal<2 | 1 | 5 | 6 | 4 | 3>;
+    headingLevel: _angular_core.InputSignal<2 | 1 | 5 | 3 | 6 | 4>;
     headline: _angular_core.InputSignal<string>;
     trend: _angular_core.InputSignal<string>;
     protected readonly activeIndex: _angular_core.WritableSignal<number | null>;
@@ -747,7 +980,7 @@ declare class BarChart {
         height: number;
     } | null>;
     heading: _angular_core.InputSignal<string>;
-    headingLevel: _angular_core.InputSignal<2 | 1 | 5 | 6 | 4 | 3>;
+    headingLevel: _angular_core.InputSignal<2 | 1 | 5 | 3 | 6 | 4>;
     headline: _angular_core.InputSignal<string>;
     trend: _angular_core.InputSignal<string>;
     protected readonly hasData: _angular_core.Signal<boolean>;
@@ -794,7 +1027,7 @@ declare class TimelineChart {
         height: number;
     } | null>;
     heading: _angular_core.InputSignal<string>;
-    headingLevel: _angular_core.InputSignal<2 | 1 | 5 | 6 | 4 | 3>;
+    headingLevel: _angular_core.InputSignal<2 | 1 | 5 | 3 | 6 | 4>;
     headline: _angular_core.InputSignal<string>;
     trend: _angular_core.InputSignal<string>;
     protected readonly hasData: _angular_core.Signal<boolean>;
@@ -983,22 +1216,29 @@ interface PopupPosition {
     left: string | null;
     right: string | null;
 }
+declare class MenuTrigger {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenuTrigger, "[gbtMenuTrigger]", never, {}, {}, never, never, true, never>;
+}
 declare class Menu {
     private readonly elementRef;
     private readonly injector;
     label: _angular_core.InputSignal<string>;
     align: _angular_core.InputSignal<"start" | "end">;
     triggerIcon: _angular_core.InputSignal<string | null>;
+    triggerAriaLabel: _angular_core.InputSignal<string | null>;
+    chevron: _angular_core.InputSignalWithTransform<boolean, unknown>;
     opened: _angular_core.OutputEmitterRef<void>;
     protected readonly open: _angular_core.WritableSignal<boolean>;
     protected readonly position: _angular_core.WritableSignal<PopupPosition | null>;
+    protected readonly customTrigger: _angular_core.Signal<MenuTrigger | undefined>;
     private readonly trigger;
     private readonly list;
     protected toggle(): void;
     protected close(returnFocus: boolean): void;
     protected onTriggerKeydown(event: KeyboardEvent): void;
     protected onListKeydown(event: KeyboardEvent): void;
-    protected onListClick(): void;
+    protected onListClick(event: MouseEvent): void;
     protected onDocumentClick(event: MouseEvent): void;
     protected onFocusOut(event: FocusEvent): void;
     protected updatePosition(): void;
@@ -1006,7 +1246,17 @@ declare class Menu {
     private focus;
     private focusAfterRender;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<Menu, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Menu, "gbt-menu", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "triggerIcon": { "alias": "triggerIcon"; "required": false; "isSignal": true; }; }, { "opened": "opened"; }, never, ["*"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Menu, "gbt-menu", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "triggerIcon": { "alias": "triggerIcon"; "required": false; "isSignal": true; }; "triggerAriaLabel": { "alias": "triggerAriaLabel"; "required": false; "isSignal": true; }; "chevron": { "alias": "chevron"; "required": false; "isSignal": true; }; }, { "opened": "opened"; }, ["customTrigger"], ["[gbtMenuTrigger]", "*"], true, never>;
+}
+
+type MenuItemVariant = 'default' | 'danger';
+declare class MenuItem {
+    icon: _angular_core.InputSignal<string | null>;
+    variant: _angular_core.InputSignal<MenuItemVariant>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuItem, "button[gbtMenuItem], a[gbtMenuItem]", never, { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
 type PopoverAlign = 'start' | 'end';
@@ -1035,6 +1285,8 @@ declare class Popover {
 }
 
 type DescriptionListLayout = 'stacked' | 'inline';
+type DescriptionListValueAlign = 'start' | 'end';
+type DescriptionListResponsive = 'viewport' | 'container';
 interface DescriptionListEntry {
     term: string;
     value: string | TemplateRef<unknown>;
@@ -1042,9 +1294,11 @@ interface DescriptionListEntry {
 declare class DescriptionList {
     items: _angular_core.InputSignal<DescriptionListEntry[]>;
     layout: _angular_core.InputSignal<DescriptionListLayout>;
+    valueAlign: _angular_core.InputSignal<DescriptionListValueAlign>;
+    responsive: _angular_core.InputSignal<DescriptionListResponsive>;
     protected isTemplate(value: DescriptionListEntry['value']): value is TemplateRef<unknown>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<DescriptionList, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DescriptionList, "gbt-description-list", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "layout": { "alias": "layout"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DescriptionList, "gbt-description-list", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "layout": { "alias": "layout"; "required": false; "isSignal": true; }; "valueAlign": { "alias": "valueAlign"; "required": false; "isSignal": true; }; "responsive": { "alias": "responsive"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 interface SegmentedControlOption<T = string> {
@@ -1052,19 +1306,26 @@ interface SegmentedControlOption<T = string> {
     label: string;
     disabled?: boolean;
 }
+type SegmentedControlSize = 'md' | 'sm';
 declare class SegmentedControl<T = string> {
     private readonly group;
     options: _angular_core.InputSignal<SegmentedControlOption<T>[]>;
     value: _angular_core.ModelSignal<T>;
     ariaLabel: _angular_core.InputSignal<string>;
     disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    label: _angular_core.InputSignal<string>;
+    fullWidth: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    wrap: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    size: _angular_core.InputSignal<SegmentedControlSize>;
+    tinted: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly labelId: string;
     protected isSelected(value: T): boolean;
     protected select(option: SegmentedControlOption<T>): void;
     protected onKeydown(event: KeyboardEvent, index: number): void;
     private nextEnabledIndex;
     private focusButton;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<SegmentedControl<any>, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SegmentedControl<any>, "gbt-segmented-control", never, { "options": { "alias": "options"; "required": true; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SegmentedControl<any>, "gbt-segmented-control", never, { "options": { "alias": "options"; "required": true; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "tinted": { "alias": "tinted"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
 }
 
 type WeekStartsOn = 0 | 1;
@@ -1074,13 +1335,14 @@ interface CalendarDay {
     isToday: boolean;
 }
 
-type DatePickerVisibleMonths = 1 | 2;
-interface DatePickerMonthView {
+interface CalendarPanelView {
     year: number;
     month: number;
     label: string;
     weeks: CalendarDay[][];
 }
+
+type DatePickerVisibleMonths = 1 | 2;
 declare class DatePicker implements ControlValueAccessor {
     private readonly elementRef;
     private readonly injector;
@@ -1101,6 +1363,7 @@ declare class DatePicker implements ControlValueAccessor {
     yearSelectLabel: _angular_core.InputSignal<string>;
     minYear: _angular_core.InputSignal<number>;
     maxYear: _angular_core.InputSignal<number>;
+    private readonly panel;
     protected readonly open: _angular_core.WritableSignal<boolean>;
     protected readonly selected: _angular_core.WritableSignal<Date | null>;
     protected readonly focusedDate: _angular_core.WritableSignal<Date>;
@@ -1114,7 +1377,7 @@ declare class DatePicker implements ControlValueAccessor {
     private onTouched;
     protected readonly isDisabled: _angular_core.Signal<boolean>;
     protected readonly showClear: _angular_core.Signal<boolean>;
-    protected readonly monthViews: _angular_core.Signal<DatePickerMonthView[]>;
+    protected readonly monthViews: _angular_core.Signal<CalendarPanelView[]>;
     protected readonly panelLabel: _angular_core.Signal<string>;
     protected readonly weekdayLabels: _angular_core.Signal<string[]>;
     protected readonly monthOptions: _angular_core.Signal<{
@@ -1137,16 +1400,10 @@ declare class DatePicker implements ControlValueAccessor {
     protected shiftMonth(delta: number): void;
     protected onMonthSelect(value: string): void;
     protected onYearSelect(value: string): void;
-    private setAnchorMonth;
     protected onGridKeydown(event: KeyboardEvent): void;
-    private nextFocusedDate;
-    /** Shifts the anchor by the minimum amount needed so `date`'s month becomes visible. */
-    private ensureVisible;
     protected onEscape(event: KeyboardEvent): void;
     protected handleClickOutside(event: MouseEvent): void;
     protected updatePanelPosition(): void;
-    private trigger;
-    private focusCellAfterRender;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<DatePicker, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<DatePicker, "gbt-date-picker", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "weekStartsOn": { "alias": "weekStartsOn"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; "previousMonthLabel": { "alias": "previousMonthLabel"; "required": false; "isSignal": true; }; "nextMonthLabel": { "alias": "nextMonthLabel"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "clearLabel": { "alias": "clearLabel"; "required": false; "isSignal": true; }; "visibleMonths": { "alias": "visibleMonths"; "required": false; "isSignal": true; }; "monthSelectLabel": { "alias": "monthSelectLabel"; "required": false; "isSignal": true; }; "yearSelectLabel": { "alias": "yearSelectLabel"; "required": false; "isSignal": true; }; "minYear": { "alias": "minYear"; "required": false; "isSignal": true; }; "maxYear": { "alias": "maxYear"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
@@ -1156,12 +1413,6 @@ interface DateRangeValue {
     start: Date;
     end: Date | null;
 }
-interface DateRangePickerMonthView {
-    year: number;
-    month: number;
-    label: string;
-    weeks: CalendarDay[][];
-}
 declare class DateRangePicker implements ControlValueAccessor {
     private readonly elementRef;
     private readonly injector;
@@ -1183,6 +1434,7 @@ declare class DateRangePicker implements ControlValueAccessor {
     minYear: _angular_core.InputSignal<number>;
     maxYear: _angular_core.InputSignal<number>;
     rangeStatus: _angular_core.InputSignal<(start: string | null, end: string | null) => string>;
+    private readonly panel;
     protected readonly open: _angular_core.WritableSignal<boolean>;
     protected readonly value: _angular_core.WritableSignal<DateRangeValue | null>;
     protected readonly draftStart: _angular_core.WritableSignal<Date | null>;
@@ -1199,7 +1451,7 @@ declare class DateRangePicker implements ControlValueAccessor {
     private onTouched;
     protected readonly isDisabled: _angular_core.Signal<boolean>;
     protected readonly showClear: _angular_core.Signal<boolean>;
-    protected readonly monthViews: _angular_core.Signal<DateRangePickerMonthView[]>;
+    protected readonly monthViews: _angular_core.Signal<CalendarPanelView[]>;
     protected readonly panelLabel: _angular_core.Signal<string>;
     protected readonly weekdayLabels: _angular_core.Signal<string[]>;
     protected readonly monthOptions: _angular_core.Signal<{
@@ -1209,7 +1461,6 @@ declare class DateRangePicker implements ControlValueAccessor {
     protected readonly yearOptions: _angular_core.Signal<number[]>;
     private readonly dateFormatter;
     protected readonly triggerLabel: _angular_core.Signal<string>;
-    /** The visual [lower, upper] bounds to paint — the confirmed range once `draftEnd` is set, else a live preview against `hoveredDate`. */
     private readonly previewBounds;
     protected readonly isPreviewing: _angular_core.Signal<boolean>;
     protected readonly statusMessage: _angular_core.Signal<string>;
@@ -1231,16 +1482,10 @@ declare class DateRangePicker implements ControlValueAccessor {
     protected shiftMonth(delta: number): void;
     protected onMonthSelect(value: string): void;
     protected onYearSelect(value: string): void;
-    private setAnchorMonth;
     protected onGridKeydown(event: KeyboardEvent): void;
-    private nextFocusedDate;
-    /** Shifts the anchor by the minimum amount needed so `date`'s month becomes visible. */
-    private ensureVisible;
     protected onEscape(event: KeyboardEvent): void;
     protected handleClickOutside(event: MouseEvent): void;
     protected updatePanelPosition(): void;
-    private trigger;
-    private focusCellAfterRender;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<DateRangePicker, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<DateRangePicker, "gbt-date-range-picker", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "weekStartsOn": { "alias": "weekStartsOn"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; "previousMonthLabel": { "alias": "previousMonthLabel"; "required": false; "isSignal": true; }; "nextMonthLabel": { "alias": "nextMonthLabel"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "clearLabel": { "alias": "clearLabel"; "required": false; "isSignal": true; }; "visibleMonths": { "alias": "visibleMonths"; "required": false; "isSignal": true; }; "monthSelectLabel": { "alias": "monthSelectLabel"; "required": false; "isSignal": true; }; "yearSelectLabel": { "alias": "yearSelectLabel"; "required": false; "isSignal": true; }; "minYear": { "alias": "minYear"; "required": false; "isSignal": true; }; "maxYear": { "alias": "maxYear"; "required": false; "isSignal": true; }; "rangeStatus": { "alias": "rangeStatus"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
@@ -1313,24 +1558,32 @@ declare class Breadcrumb {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<Breadcrumb, "gbt-breadcrumb", never, { "ariaLabel": { "alias": "ariaLabel"; "required": true; "isSignal": true; }; }, {}, never, ["[breadcrumb-ancestor]", "*"], true, never>;
 }
 
+type ConfirmDangerModalTone = 'danger' | 'warning' | 'neutral';
 declare class ConfirmDangerModal {
     isOpen: _angular_core.InputSignal<boolean>;
     heading: _angular_core.InputSignal<string>;
     message: _angular_core.InputSignal<string>;
-    confirmText: _angular_core.InputSignal<string>;
+    confirmText: _angular_core.InputSignal<string | null | undefined>;
     confirmInputLabel: _angular_core.InputSignal<string>;
     confirmLabel: _angular_core.InputSignal<string>;
     cancelLabel: _angular_core.InputSignal<string>;
     closeLabel: _angular_core.InputSignal<string>;
+    busy: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    busyLabel: _angular_core.InputSignal<string>;
+    confirmIcon: _angular_core.InputSignal<string | null>;
+    tone: _angular_core.InputSignal<ConfirmDangerModalTone>;
     confirmed: _angular_core.OutputEmitterRef<void>;
     closed: _angular_core.OutputEmitterRef<void>;
     protected readonly typed: _angular_core.WritableSignal<string>;
+    protected readonly requiresTyping: _angular_core.Signal<boolean>;
     protected readonly canConfirm: _angular_core.Signal<boolean>;
+    protected readonly confirmVariant: _angular_core.Signal<ButtonVariant>;
+    protected readonly toneIcon: _angular_core.Signal<"info" | "alert-triangle">;
     constructor();
     protected confirm(): void;
     protected cancel(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ConfirmDangerModal, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ConfirmDangerModal, "gbt-confirm-danger-modal", never, { "isOpen": { "alias": "isOpen"; "required": true; "isSignal": true; }; "heading": { "alias": "heading"; "required": true; "isSignal": true; }; "message": { "alias": "message"; "required": true; "isSignal": true; }; "confirmText": { "alias": "confirmText"; "required": true; "isSignal": true; }; "confirmInputLabel": { "alias": "confirmInputLabel"; "required": false; "isSignal": true; }; "confirmLabel": { "alias": "confirmLabel"; "required": false; "isSignal": true; }; "cancelLabel": { "alias": "cancelLabel"; "required": false; "isSignal": true; }; "closeLabel": { "alias": "closeLabel"; "required": false; "isSignal": true; }; }, { "confirmed": "confirmed"; "closed": "closed"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ConfirmDangerModal, "gbt-confirm-danger-modal", never, { "isOpen": { "alias": "isOpen"; "required": true; "isSignal": true; }; "heading": { "alias": "heading"; "required": true; "isSignal": true; }; "message": { "alias": "message"; "required": true; "isSignal": true; }; "confirmText": { "alias": "confirmText"; "required": false; "isSignal": true; }; "confirmInputLabel": { "alias": "confirmInputLabel"; "required": false; "isSignal": true; }; "confirmLabel": { "alias": "confirmLabel"; "required": false; "isSignal": true; }; "cancelLabel": { "alias": "cancelLabel"; "required": false; "isSignal": true; }; "closeLabel": { "alias": "closeLabel"; "required": false; "isSignal": true; }; "busy": { "alias": "busy"; "required": false; "isSignal": true; }; "busyLabel": { "alias": "busyLabel"; "required": false; "isSignal": true; }; "confirmIcon": { "alias": "confirmIcon"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; }, { "confirmed": "confirmed"; "closed": "closed"; }, never, never, true, never>;
 }
 
 type ToastVariant = 'success' | 'error' | 'warning' | 'info';
@@ -1342,17 +1595,38 @@ interface ToastItem {
     duration?: number;
 }
 declare class Toaster implements OnDestroy {
-    toasts: _angular_core.InputSignal<ToastItem[]>;
+    toasts: _angular_core.InputSignal<ToastItem[] | undefined>;
     position: _angular_core.InputSignal<ToasterPosition>;
     closeLabel: _angular_core.InputSignal<string>;
     dismissed: _angular_core.OutputEmitterRef<string>;
+    private readonly service;
     private readonly timers;
+    protected readonly items: _angular_core.Signal<ToastItem[]>;
     constructor();
     ngOnDestroy(): void;
+    protected close(id: string): void;
     protected roleFor(variant: ToastVariant): 'alert' | 'status';
     protected iconFor(variant: ToastVariant): string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<Toaster, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Toaster, "gbt-toaster", never, { "toasts": { "alias": "toasts"; "required": true; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "closeLabel": { "alias": "closeLabel"; "required": false; "isSignal": true; }; }, { "dismissed": "dismissed"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Toaster, "gbt-toaster", never, { "toasts": { "alias": "toasts"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "closeLabel": { "alias": "closeLabel"; "required": false; "isSignal": true; }; }, { "dismissed": "dismissed"; }, never, never, true, never>;
+}
+
+type GbtToastKind = ToastVariant;
+interface GbtToastOptions {
+    duration?: number;
+}
+declare class GbtToastService {
+    private readonly items;
+    private readonly timers;
+    readonly toasts: _angular_core.Signal<ToastItem[]>;
+    readonly defaultDuration: _angular_core.WritableSignal<number>;
+    constructor();
+    show(message: string, kind?: GbtToastKind, options?: GbtToastOptions): string;
+    dismiss(id: string): void;
+    clear(): void;
+    private clearTimers;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GbtToastService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<any>;
 }
 
 type TooltipPosition = 'top' | 'bottom' | 'left' | 'right';
@@ -1408,10 +1682,65 @@ declare class RadioGroup<T = string> implements ControlValueAccessor {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<RadioGroup<any>, "gbt-radio-group", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": true; "isSignal": true; }; "options": { "alias": "options"; "required": true; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
+interface CheckboxGroupOption<T = string> {
+    value: T;
+    label: string;
+    hint?: string;
+    disabled?: boolean;
+}
+interface CheckboxGroupSection<T = string> {
+    label: string;
+    options: CheckboxGroupOption<T>[];
+}
+interface RenderedItem<T> {
+    id: string;
+    option: CheckboxGroupOption<T>;
+}
+interface RenderedSection<T> {
+    key: string;
+    label: string | null;
+    labelId: string;
+    items: RenderedItem<T>[];
+}
+declare class CheckboxGroup<T = string> implements ControlValueAccessor {
+    id: _angular_core.InputSignal<string>;
+    legend: _angular_core.InputSignal<string>;
+    hideLegend: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    options: _angular_core.InputSignal<CheckboxGroupOption<T>[]>;
+    groups: _angular_core.InputSignal<CheckboxGroupSection<T>[]>;
+    columns: _angular_core.InputSignal<number | "auto">;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    required: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    hint: _angular_core.InputSignal<string>;
+    errorMessage: _angular_core.InputSignal<string | null>;
+    value: _angular_core.ModelSignal<T[]>;
+    private readonly formDisabled;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly hintId: _angular_core.Signal<string>;
+    protected readonly errorId: _angular_core.Signal<string>;
+    protected readonly showHint: _angular_core.Signal<boolean>;
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    protected readonly sections: _angular_core.Signal<RenderedSection<T>[]>;
+    protected readonly sectioned: _angular_core.Signal<boolean>;
+    protected readonly gridColumns: _angular_core.Signal<string | null>;
+    private onChange;
+    private onTouched;
+    writeValue(value: T[] | null): void;
+    registerOnChange(fn: (value: T[]) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    protected isChecked(value: T): boolean;
+    protected setChecked(value: T, checked: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CheckboxGroup<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CheckboxGroup<any>, "gbt-checkbox-group", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "legend": { "alias": "legend"; "required": true; "isSignal": true; }; "hideLegend": { "alias": "hideLegend"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "groups": { "alias": "groups"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
 declare class Switch implements ControlValueAccessor {
     id: _angular_core.InputSignal<string>;
     label: _angular_core.InputSignal<string>;
     disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    hint: _angular_core.InputSignal<string>;
+    protected readonly hintId: _angular_core.Signal<string>;
     protected readonly checked: _angular_core.WritableSignal<boolean>;
     private readonly formDisabled;
     protected readonly isDisabled: _angular_core.Signal<boolean>;
@@ -1423,9 +1752,10 @@ declare class Switch implements ControlValueAccessor {
     setDisabledState(isDisabled: boolean): void;
     protected onToggle(event: Event): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<Switch, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Switch, "gbt-switch", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Switch, "gbt-switch", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
+type TextareaResize = 'vertical' | 'none' | 'both' | 'horizontal';
 declare class Textarea implements ControlValueAccessor {
     id: _angular_core.InputSignal<string>;
     label: _angular_core.InputSignal<string>;
@@ -1434,10 +1764,25 @@ declare class Textarea implements ControlValueAccessor {
     placeholder: _angular_core.InputSignal<string>;
     errorMessage: _angular_core.InputSignal<string | null>;
     rows: _angular_core.InputSignal<number>;
+    hint: _angular_core.InputSignal<string>;
+    hideLabel: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    mono: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    autosize: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    maxRows: _angular_core.InputSignal<number | null>;
+    resize: _angular_core.InputSignal<TextareaResize>;
     committed: _angular_core.OutputEmitterRef<string>;
     protected readonly value: _angular_core.WritableSignal<string>;
+    private readonly field;
+    protected readonly hintId: _angular_core.Signal<string>;
+    protected readonly errorId: _angular_core.Signal<string>;
+    protected readonly showHint: _angular_core.Signal<boolean>;
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    protected readonly effectiveResize: _angular_core.Signal<TextareaResize>;
+    protected readonly maxRowsProperty: _angular_core.Signal<number | null>;
     private readonly formDisabled;
     protected readonly isDisabled: _angular_core.Signal<boolean>;
+    constructor();
+    private fitToContent;
     private onChange;
     private onTouched;
     writeValue(value: string): void;
@@ -1447,7 +1792,7 @@ declare class Textarea implements ControlValueAccessor {
     protected onInput(event: Event): void;
     protected onBlur(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<Textarea, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Textarea, "gbt-textarea", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; }, { "committed": "committed"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Textarea, "gbt-textarea", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "hideLabel": { "alias": "hideLabel"; "required": false; "isSignal": true; }; "mono": { "alias": "mono"; "required": false; "isSignal": true; }; "autosize": { "alias": "autosize"; "required": false; "isSignal": true; }; "maxRows": { "alias": "maxRows"; "required": false; "isSignal": true; }; "resize": { "alias": "resize"; "required": false; "isSignal": true; }; }, { "committed": "committed"; }, never, never, true, never>;
 }
 
 type AutocompleteSearchFn<T> = (query: string) => Observable<T[]> | Promise<T[]>;
@@ -1571,13 +1916,20 @@ declare class Stepper {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<Stepper, "gbt-stepper", never, { "steps": { "alias": "steps"; "required": true; "isSignal": true; }; "activeIndex": { "alias": "activeIndex"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "completedLabel": { "alias": "completedLabel"; "required": false; "isSignal": true; }; "errorLabel": { "alias": "errorLabel"; "required": false; "isSignal": true; }; "interactive": { "alias": "interactive"; "required": false; "isSignal": true; }; "selectedIndex": { "alias": "selectedIndex"; "required": false; "isSignal": true; }; "selectedLabel": { "alias": "selectedLabel"; "required": false; "isSignal": true; }; }, { "activeIndex": "activeIndexChange"; "selectedIndex": "selectedIndexChange"; }, never, never, true, never>;
 }
 
-type JobGraphStatus = 'pending' | 'running' | 'success' | 'failed' | 'canceled';
+type JobStatusValue = 'pending' | 'running' | 'success' | 'failed' | 'canceled';
+declare class JobStatus {
+    status: _angular_core.InputSignal<JobStatusValue>;
+    label: _angular_core.InputSignal<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<JobStatus, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<JobStatus, "gbt-job-status", never, { "status": { "alias": "status"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type JobGraphStatus = JobStatusValue;
 interface JobGraphJob {
     id: string;
     name: string;
     status: JobGraphStatus;
     durationLabel?: string;
-    /** Names (not ids) of the jobs this job depends on; names are unique within a graph. */
     needs: string[];
 }
 interface JobGraphStage {
@@ -1593,7 +1945,7 @@ interface GraphLink {
 declare class JobGraph {
     stages: _angular_core.InputSignal<JobGraphStage[]>;
     selectedJobId: _angular_core.InputSignal<string | null>;
-    statusLabels: _angular_core.InputSignal<Record<JobGraphStatus, string>>;
+    statusLabels: _angular_core.InputSignal<Record<_masmarino_gabarit.JobStatusValue, string>>;
     needsLabel: _angular_core.InputSignal<string>;
     ariaLabel: _angular_core.InputSignal<string>;
     jobSelected: _angular_core.OutputEmitterRef<string>;
@@ -1619,6 +1971,7 @@ declare class FileUpload implements ControlValueAccessor {
     dropLabel: _angular_core.InputSignal<string>;
     removeLabel: _angular_core.InputSignal<(name: string) => string>;
     oversizeMessage: _angular_core.InputSignal<(name: string, maxSizeMb: number) => string>;
+    extraFileMessage: _angular_core.InputSignal<(name: string) => string>;
     protected readonly files: _angular_core.WritableSignal<File[]>;
     protected readonly rejections: _angular_core.WritableSignal<string[]>;
     protected readonly dragOver: _angular_core.WritableSignal<boolean>;
@@ -1640,7 +1993,7 @@ declare class FileUpload implements ControlValueAccessor {
     protected removeFile(file: File): void;
     private addFiles;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<FileUpload, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FileUpload, "gbt-file-upload", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "accept": { "alias": "accept"; "required": false; "isSignal": true; }; "maxSizeMb": { "alias": "maxSizeMb"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; "dropLabel": { "alias": "dropLabel"; "required": false; "isSignal": true; }; "removeLabel": { "alias": "removeLabel"; "required": false; "isSignal": true; }; "oversizeMessage": { "alias": "oversizeMessage"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FileUpload, "gbt-file-upload", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "accept": { "alias": "accept"; "required": false; "isSignal": true; }; "maxSizeMb": { "alias": "maxSizeMb"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; "dropLabel": { "alias": "dropLabel"; "required": false; "isSignal": true; }; "removeLabel": { "alias": "removeLabel"; "required": false; "isSignal": true; }; "oversizeMessage": { "alias": "oversizeMessage"; "required": false; "isSignal": true; }; "extraFileMessage": { "alias": "extraFileMessage"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 type NotificationDotVariant = 'error' | 'warning' | 'success' | 'info';
@@ -1722,5 +2075,1130 @@ declare class Tree {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<Tree, "gbt-tree", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "selectedId": { "alias": "selectedId"; "required": false; "isSignal": true; }; "expandedIds": { "alias": "expandedIds"; "required": false; "isSignal": true; }; "expandLabel": { "alias": "expandLabel"; "required": false; "isSignal": true; }; "collapseLabel": { "alias": "collapseLabel"; "required": false; "isSignal": true; }; }, { "selectedId": "selectedIdChange"; "expandedIds": "expandedIdsChange"; }, never, never, true, never>;
 }
 
-export { Accordion, AccordionItem, Alert, AppShell, Autocomplete, Avatar, AvatarGroup, Badge, BarChart, BarSeries, Breadcrumb, Button, CHART_CONTEXT, Card, ChartAxis, ChartEmpty, ChartFrame, ChartLegend, ChartTable, ChartTooltip, Checkbox, ConfirmDangerModal, DatePicker, DateRangePicker, DescriptionList, DimensionCard, Divider, Drawer, EmptyState, FileUpload, FunnelChart, GABARIT_VERSION, GaugeBar, GbtInput, Icon, IconRegistry, JobGraph, LineChart, LineSeries, ListToolbar, Menu, Modal, NotificationDot, Pagination, PieChart, Popover, RadioGroup, SearchBar, SegmentedControl, Select, Skeleton, Slider, Sparkline, Spinner, Stepper, Switch, Tab, Table, Tabs, Tag, TagInput, Textarea, TimelineChart, TimelineSeries, Toaster, Tooltip, Tree, arcPath, areaPath, bandScale, formatCompact, formatDuration, formatNumber, formatPercent, linePath, linearScale, nearestIndex, niceTicks, niceXDomain, niceYDomain, timeScale, timeTicks };
-export type { AccordionMode, AlertVariant, Arc, AutocompleteSearchFn, AvatarGroupItem, AvatarSize, AxisSpec, BadgeVariant, BandScale, CalendarDay, ChartBox, ChartInterval, ChartMargin, ChartPoint, ChartReader, ChartSeries, DateRangeValue, DescriptionListEntry, DescriptionListLayout, DimensionRow, DividerOrientation, DrawerEdge, EmptyStateIllustration, FlatTreeNode, FunnelStep, JobGraphJob, JobGraphStage, JobGraphStatus, LegendEntry, LinearAxisSpec, ListToolbarSortOption, NotificationDotVariant, PieSlice, Point, PointValue, PopoverAlign, RadioOption, Scale, SearchResultCategory, SegmentedControlOption, SelectOption, SkeletonVariant, SpinnerSize, StepperOrientation, StepperStatus, StepperStep, TableColumn, TimeTicks, TimeUnit, ToastItem, ToastVariant, ToasterPosition, TooltipPoint, TooltipPosition, TooltipRow, TreeNode, WeekStartsOn };
+type UserChipSize = 'sm' | 'md';
+declare class UserChip {
+    name: _angular_core.InputSignal<string>;
+    size: _angular_core.InputSignal<UserChipSize>;
+    src: _angular_core.InputSignal<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UserChip, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UserChip, "gbt-user-chip", never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "src": { "alias": "src"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type PanelHeadingLevel = 2 | 3 | 4;
+declare class Panel {
+    heading: _angular_core.InputSignal<string>;
+    headingLevel: _angular_core.InputSignal<PanelHeadingLevel>;
+    protected readonly headingId: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Panel, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Panel, "gbt-panel", never, { "heading": { "alias": "heading"; "required": true; "isSignal": true; }; "headingLevel": { "alias": "headingLevel"; "required": false; "isSignal": true; }; }, {}, never, ["[panel-actions]", "*"], true, never>;
+}
+
+type PageHeaderLevel = 1 | 2 | 3;
+declare class PageHeader {
+    heading: _angular_core.InputSignal<string>;
+    headingLevel: _angular_core.InputSignal<PageHeaderLevel>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PageHeader, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PageHeader, "gbt-page-header", never, { "heading": { "alias": "heading"; "required": true; "isSignal": true; }; "headingLevel": { "alias": "headingLevel"; "required": false; "isSignal": true; }; }, {}, never, ["[header-title]", "[header-badges]", "[header-meta]", "[header-actions]"], true, never>;
+}
+
+type PageLayoutWidth = 'narrow' | 'default' | 'wide' | 'full';
+type PageLayoutAsideWidth = 'sm' | 'md' | 'lg';
+type PageLayoutAsidePosition = 'start' | 'end';
+declare class PageLayout {
+    width: _angular_core.InputSignal<PageLayoutWidth>;
+    asideWidth: _angular_core.InputSignal<PageLayoutAsideWidth>;
+    asidePosition: _angular_core.InputSignal<PageLayoutAsidePosition>;
+    navLabel: _angular_core.InputSignal<string>;
+    asideLabel: _angular_core.InputSignal<string | null>;
+    stickyNav: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PageLayout, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PageLayout, "gbt-page-layout", never, { "width": { "alias": "width"; "required": false; "isSignal": true; }; "asideWidth": { "alias": "asideWidth"; "required": false; "isSignal": true; }; "asidePosition": { "alias": "asidePosition"; "required": false; "isSignal": true; }; "navLabel": { "alias": "navLabel"; "required": false; "isSignal": true; }; "asideLabel": { "alias": "asideLabel"; "required": false; "isSignal": true; }; "stickyNav": { "alias": "stickyNav"; "required": false; "isSignal": true; }; }, {}, never, ["[page-nav]", "*", "[page-aside]"], true, never>;
+}
+
+type ListRowTone = 'neutral' | 'success' | 'warning' | 'error' | 'info';
+declare class ListRow {
+    tone: _angular_core.InputSignal<ListRowTone>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListRow, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ListRow, "gbt-list-row", never, { "tone": { "alias": "tone"; "required": false; "isSignal": true; }; }, {}, never, ["[row-leading]", "*", "[row-meta]", "[row-trailing]"], true, never>;
+}
+
+type ListCardState = 'loading' | 'failed' | 'empty' | 'ready';
+declare class ListCard {
+    state: _angular_core.InputSignal<ListCardState>;
+    ariaLabel: _angular_core.InputSignal<string | null>;
+    loadingLabel: _angular_core.InputSignal<string>;
+    skeletonRows: _angular_core.InputSignal<number>;
+    skeletonHeader: _angular_core.InputSignal<boolean>;
+    failedHeading: _angular_core.InputSignal<string>;
+    failedMessage: _angular_core.InputSignal<string>;
+    retryLabel: _angular_core.InputSignal<string | null>;
+    retry: _angular_core.OutputEmitterRef<void>;
+    emptyHeading: _angular_core.InputSignal<string>;
+    emptyMessage: _angular_core.InputSignal<string>;
+    emptyIllustration: _angular_core.InputSignal<EmptyStateIllustration | null>;
+    emptyIcon: _angular_core.InputSignal<string | null>;
+    /**
+     * What sits above the box: the projected `[list-card-header]` (ready), its placeholder (loading,
+     * unless `skeletonHeader` is off), or nothing (failed, empty).
+     */
+    protected readonly header: _angular_core.Signal<"slot" | "skeleton" | null>;
+    protected readonly placeholders: _angular_core.Signal<string[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListCard, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ListCard, "gbt-list-card", never, { "state": { "alias": "state"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "loadingLabel": { "alias": "loadingLabel"; "required": false; "isSignal": true; }; "skeletonRows": { "alias": "skeletonRows"; "required": false; "isSignal": true; }; "skeletonHeader": { "alias": "skeletonHeader"; "required": false; "isSignal": true; }; "failedHeading": { "alias": "failedHeading"; "required": false; "isSignal": true; }; "failedMessage": { "alias": "failedMessage"; "required": false; "isSignal": true; }; "retryLabel": { "alias": "retryLabel"; "required": false; "isSignal": true; }; "emptyHeading": { "alias": "emptyHeading"; "required": false; "isSignal": true; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; "isSignal": true; }; "emptyIllustration": { "alias": "emptyIllustration"; "required": false; "isSignal": true; }; "emptyIcon": { "alias": "emptyIcon"; "required": false; "isSignal": true; }; }, { "retry": "retry"; }, never, ["[list-card-header]", "[list-card-failed]", "[list-card-empty]", "*"], true, never>;
+}
+
+type CopyButtonFeedback = 'bubble' | 'inline' | 'hidden';
+
+declare class CopyButton {
+    value: _angular_core.InputSignal<CopyValue>;
+    text: _angular_core.InputSignal<string>;
+    ariaLabel: _angular_core.InputSignal<string | null>;
+    copiedText: _angular_core.InputSignal<string>;
+    failedText: _angular_core.InputSignal<string>;
+    feedbackMs: _angular_core.InputSignal<number>;
+    variant: _angular_core.InputSignal<ButtonVariant>;
+    size: _angular_core.InputSignal<ButtonSize>;
+    icon: _angular_core.InputSignal<string>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    feedback: _angular_core.InputSignal<CopyButtonFeedback>;
+    selectTarget: _angular_core.InputSignal<HTMLElement | null>;
+    copied: _angular_core.OutputEmitterRef<string>;
+    copyFailed: _angular_core.OutputEmitterRef<void>;
+    protected readonly clipboard: ClipboardFeedback;
+    constructor();
+    reset(): void;
+    protected readonly glyph: _angular_core.Signal<string>;
+    protected readonly statusText: _angular_core.Signal<string>;
+    protected readonly name: _angular_core.Signal<string | null>;
+    protected copy(): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopyButton, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopyButton, "gbt-copy-button", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "copiedText": { "alias": "copiedText"; "required": false; "isSignal": true; }; "failedText": { "alias": "failedText"; "required": false; "isSignal": true; }; "feedbackMs": { "alias": "feedbackMs"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "feedback": { "alias": "feedback"; "required": false; "isSignal": true; }; "selectTarget": { "alias": "selectTarget"; "required": false; "isSignal": true; }; }, { "copied": "copied"; "copyFailed": "copyFailed"; }, never, never, true, never>;
+}
+
+declare const COPY_FIELD_WRAP_AT: RegExp;
+declare class CopyField {
+    value: _angular_core.InputSignal<string>;
+    label: _angular_core.InputSignal<string | null>;
+    copyLabel: _angular_core.InputSignal<string>;
+    copiedText: _angular_core.InputSignal<string>;
+    failedText: _angular_core.InputSignal<string>;
+    feedbackMs: _angular_core.InputSignal<number>;
+    feedback: _angular_core.InputSignal<CopyButtonFeedback>;
+    wrapAt: _angular_core.InputSignal<RegExp | null>;
+    copied: _angular_core.OutputEmitterRef<string>;
+    copyFailed: _angular_core.OutputEmitterRef<void>;
+    protected readonly labelId: string;
+    protected readonly segments: _angular_core.Signal<string[]>;
+    private cut;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopyField, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopyField, "gbt-copy-field", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "copyLabel": { "alias": "copyLabel"; "required": false; "isSignal": true; }; "copiedText": { "alias": "copiedText"; "required": false; "isSignal": true; }; "failedText": { "alias": "failedText"; "required": false; "isSignal": true; }; "feedbackMs": { "alias": "feedbackMs"; "required": false; "isSignal": true; }; "feedback": { "alias": "feedback"; "required": false; "isSignal": true; }; "wrapAt": { "alias": "wrapAt"; "required": false; "isSignal": true; }; }, { "copied": "copied"; "copyFailed": "copyFailed"; }, never, never, true, never>;
+}
+
+declare class SecretReveal {
+    value: _angular_core.InputSignal<string>;
+    revealed: _angular_core.ModelSignal<boolean>;
+    label: _angular_core.InputSignal<string | null>;
+    showLabel: _angular_core.InputSignal<string>;
+    hideLabel: _angular_core.InputSignal<string>;
+    hiddenLabel: _angular_core.InputSignal<string>;
+    copyLabel: _angular_core.InputSignal<string>;
+    copiedText: _angular_core.InputSignal<string>;
+    failedText: _angular_core.InputSignal<string>;
+    feedbackMs: _angular_core.InputSignal<number>;
+    feedback: _angular_core.InputSignal<CopyButtonFeedback>;
+    maskLength: _angular_core.InputSignal<number>;
+    copied: _angular_core.OutputEmitterRef<string>;
+    copyFailed: _angular_core.OutputEmitterRef<void>;
+    protected readonly id: string;
+    protected readonly valueId: string;
+    protected readonly labelId: string;
+    private readonly code;
+    private readonly copyButton;
+    private readonly injector;
+    constructor();
+    protected mask(): string;
+    protected toggle(): void;
+    protected onCopyFailed(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SecretReveal, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SecretReveal, "gbt-secret-reveal", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "revealed": { "alias": "revealed"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "showLabel": { "alias": "showLabel"; "required": false; "isSignal": true; }; "hideLabel": { "alias": "hideLabel"; "required": false; "isSignal": true; }; "hiddenLabel": { "alias": "hiddenLabel"; "required": false; "isSignal": true; }; "copyLabel": { "alias": "copyLabel"; "required": false; "isSignal": true; }; "copiedText": { "alias": "copiedText"; "required": false; "isSignal": true; }; "failedText": { "alias": "failedText"; "required": false; "isSignal": true; }; "feedbackMs": { "alias": "feedbackMs"; "required": false; "isSignal": true; }; "feedback": { "alias": "feedback"; "required": false; "isSignal": true; }; "maskLength": { "alias": "maskLength"; "required": false; "isSignal": true; }; }, { "revealed": "revealedChange"; "copied": "copied"; "copyFailed": "copyFailed"; }, never, never, true, never>;
+}
+
+type SaveStatusState = 'idle' | 'saving' | 'saved' | 'error';
+declare class SaveStatus {
+    state: _angular_core.InputSignal<SaveStatusState>;
+    savingLabel: _angular_core.InputSignal<string>;
+    savedLabel: _angular_core.InputSignal<string>;
+    errorLabel: _angular_core.InputSignal<string>;
+    message: _angular_core.InputSignal<string | null>;
+    protected readonly text: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SaveStatus, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SaveStatus, "gbt-save-status", never, { "state": { "alias": "state"; "required": false; "isSignal": true; }; "savingLabel": { "alias": "savingLabel"; "required": false; "isSignal": true; }; "savedLabel": { "alias": "savedLabel"; "required": false; "isSignal": true; }; "errorLabel": { "alias": "errorLabel"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type IconMarkerTone = 'neutral' | 'primary' | 'success' | 'warning' | 'error' | 'info';
+type IconMarkerSize = 'sm' | 'md' | 'lg' | 'xl';
+type IconMarkerShape = 'disc' | 'tile';
+type IconMarkerAppearance = 'soft' | 'outline';
+declare class IconMarker {
+    icon: _angular_core.InputSignal<string>;
+    tone: _angular_core.InputSignal<IconMarkerTone>;
+    size: _angular_core.InputSignal<IconMarkerSize>;
+    shape: _angular_core.InputSignal<IconMarkerShape>;
+    appearance: _angular_core.InputSignal<IconMarkerAppearance>;
+    label: _angular_core.InputSignal<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconMarker, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IconMarker, "gbt-icon-marker", never, { "icon": { "alias": "icon"; "required": true; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type StatGridColumns = 2 | 3 | 4 | 5 | 6;
+declare class StatGrid {
+    ariaLabel: _angular_core.InputSignal<string>;
+    columns: _angular_core.InputSignal<StatGridColumns>;
+    loading: _angular_core.InputSignal<boolean>;
+    loadingCount: _angular_core.InputSignal<number>;
+    loadingLabel: _angular_core.InputSignal<string>;
+    protected readonly placeholders: _angular_core.Signal<number[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StatGrid, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StatGrid, "gbt-stat-grid", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "loadingCount": { "alias": "loadingCount"; "required": false; "isSignal": true; }; "loadingLabel": { "alias": "loadingLabel"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+type StatTileTrend = 'up' | 'down' | 'flat';
+type StatTileTrendTone = 'neutral' | 'success' | 'error';
+declare class StatTile {
+    label: _angular_core.InputSignal<string>;
+    value: _angular_core.InputSignal<string | number>;
+    icon: _angular_core.InputSignal<string | null>;
+    iconTone: _angular_core.InputSignal<IconMarkerTone>;
+    hint: _angular_core.InputSignal<string | null>;
+    trend: _angular_core.InputSignal<StatTileTrend | null>;
+    trendLabel: _angular_core.InputSignal<string | null>;
+    trendTone: _angular_core.InputSignal<StatTileTrendTone>;
+    href: _angular_core.InputSignal<string | null>;
+    muted: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly link;
+    protected readonly grid: StatGrid | null;
+    protected linked(): boolean;
+    protected hasLink(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StatTile, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StatTile, "gbt-stat-tile", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconTone": { "alias": "iconTone"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "trend": { "alias": "trend"; "required": false; "isSignal": true; }; "trendLabel": { "alias": "trendLabel"; "required": false; "isSignal": true; }; "trendTone": { "alias": "trendTone"; "required": false; "isSignal": true; }; "href": { "alias": "href"; "required": false; "isSignal": true; }; "muted": { "alias": "muted"; "required": false; "isSignal": true; }; }, {}, ["link"], ["a[gbtStatTileLink]"], true, never>;
+}
+
+declare class StatTileLink {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StatTileLink, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StatTileLink, "a[gbtStatTileLink]", never, {}, {}, never, ["*"], true, never>;
+}
+
+type SkeletonListLeading = 'circle' | 'square' | 'none';
+declare class SkeletonList {
+    rows: _angular_core.InputSignal<number>;
+    leading: _angular_core.InputSignal<SkeletonListLeading>;
+    leadingSize: _angular_core.InputSignal<string>;
+    lines: _angular_core.InputSignal<2 | 1 | 3>;
+    loadingLabel: _angular_core.InputSignal<string>;
+    divided: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    padded: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly items: _angular_core.Signal<{
+        row: number;
+        widths: string[];
+    }[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkeletonList, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkeletonList, "gbt-skeleton-list", never, { "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "leading": { "alias": "leading"; "required": false; "isSignal": true; }; "leadingSize": { "alias": "leadingSize"; "required": false; "isSignal": true; }; "lines": { "alias": "lines"; "required": false; "isSignal": true; }; "loadingLabel": { "alias": "loadingLabel"; "required": false; "isSignal": true; }; "divided": { "alias": "divided"; "required": false; "isSignal": true; }; "padded": { "alias": "padded"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type DisclosureAppearance = 'bordered' | 'plain';
+type DisclosureHeadingLevel = 2 | 3 | 4 | 5 | 6;
+declare class Disclosure {
+    label: _angular_core.InputSignal<string>;
+    open: _angular_core.ModelSignal<boolean>;
+    icon: _angular_core.InputSignal<string | null>;
+    appearance: _angular_core.InputSignal<DisclosureAppearance>;
+    headingLevel: _angular_core.InputSignal<DisclosureHeadingLevel | null>;
+    protected readonly buttonId: string;
+    protected readonly panelId: string;
+    protected toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Disclosure, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Disclosure, "gbt-disclosure", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "headingLevel": { "alias": "headingLevel"; "required": false; "isSignal": true; }; }, { "open": "openChange"; }, never, ["*"], true, never>;
+}
+
+type NavTabsOrientation = 'horizontal' | 'vertical';
+
+declare class NavTabs {
+    ariaLabel: _angular_core.InputSignal<string>;
+    orientation: _angular_core.InputSignal<NavTabsOrientation>;
+    landmark: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly list;
+    private readonly tabs;
+    protected readonly hiddenBefore: _angular_core.WritableSignal<boolean>;
+    protected readonly hiddenAfter: _angular_core.WritableSignal<boolean>;
+    protected updateOverflow(): void;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavTabs, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NavTabs, "gbt-nav-tabs", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "landmark": { "alias": "landmark"; "required": false; "isSignal": true; }; }, {}, ["tabs"], ["*"], true, never>;
+}
+
+declare class NavTab {
+    active: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    icon: _angular_core.InputSignal<string | null>;
+    badge: _angular_core.InputSignal<string | number | null>;
+    private readonly nav;
+    private readonly label;
+    protected readonly orientation: _angular_core.Signal<_masmarino_gabarit.NavTabsOrientation>;
+    protected readonly hasBadge: _angular_core.Signal<boolean>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavTab, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NavTab, "a[gbtNavTab]", never, { "active": { "alias": "active"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "badge": { "alias": "badge"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+interface LoginResponse {
+    token: string | null;
+    mfaToken?: string;
+    mfaSetupRequired?: boolean;
+    mfaHasTotp?: boolean;
+    mfaHasPasskey?: boolean;
+}
+interface AuthConfig {
+    registrationEnabled: boolean;
+    passkeysAvailable: boolean;
+}
+interface PasskeyChallenge {
+    challengeId: string;
+    publicKey: unknown;
+}
+type MfaProof = {
+    code: string;
+} | {
+    backupCode: string;
+};
+interface TotpEnrollment {
+    secret: string;
+    otpauthUrl: string;
+}
+interface MfaSetupResult {
+    token: string;
+    backupCodes: string[];
+}
+interface AuthPort {
+    authConfig(): Observable<AuthConfig>;
+    login(username: string, password: string): Observable<LoginResponse>;
+    register(username: string, email: string, password: string): Observable<LoginResponse>;
+    activate(token: string, password: string): Observable<void>;
+    verifyMfa(mfaToken: string, proof: MfaProof): Observable<void>;
+    startPasskeyChallenge(mfaToken: string): Observable<PasskeyChallenge>;
+    finishPasskeyChallenge(mfaToken: string, challengeId: string, credential: unknown): Observable<void>;
+    enrollTotp(mfaToken: string): Observable<TotpEnrollment>;
+    confirmTotp(mfaToken: string, code: string): Observable<MfaSetupResult>;
+    startPasskeySetup(mfaToken: string): Observable<PasskeyChallenge>;
+    finishPasskeySetup(mfaToken: string, challengeId: string, credential: unknown, name: string): Observable<MfaSetupResult>;
+    setToken(token: string): void;
+}
+declare const AUTH_PORT: InjectionToken<AuthPort>;
+
+interface Passkey {
+    id: string;
+    name: string;
+    createdAt: string;
+    lastUsedAt: string | null;
+}
+interface MfaStatus {
+    totpEnabled: boolean;
+    backupCodesRemaining: number;
+    passkeys: Passkey[];
+}
+interface BackupCodesResult {
+    backupCodes: string[];
+}
+interface MfaPort {
+    status(): Observable<MfaStatus>;
+    enroll(currentPassword: string): Observable<TotpEnrollment>;
+    confirm(code: string): Observable<BackupCodesResult>;
+    regenerate(currentPassword: string): Observable<BackupCodesResult>;
+    disable(currentPassword: string): Observable<void>;
+    startPasskeyRegistration(currentPassword: string): Observable<PasskeyChallenge>;
+    finishPasskeyRegistration(challengeId: string, credential: unknown, name: string): Observable<Passkey>;
+    deletePasskey(id: string, currentPassword: string): Observable<void>;
+}
+declare const MFA_PORT: InjectionToken<MfaPort>;
+
+type PasskeyFailure = 'cancelled' | 'already-registered' | 'unsupported' | 'failed';
+declare function bufferToBase64Url(buffer: ArrayBuffer): string;
+declare function base64UrlToBuffer(base64Url: string): ArrayBuffer;
+declare function passkeysSupported(): boolean;
+declare function classifyPasskeyError(e: unknown): PasskeyFailure;
+declare function createPasskeyCredential(publicKey: unknown): Promise<unknown>;
+declare function getPasskeyAssertion(publicKey: unknown): Promise<unknown>;
+
+type EnrolledFactor = 'totp' | 'passkey';
+interface TotpQrLabels {
+    fallback: string;
+    imageAlt: string;
+    secretLabel: string;
+    fallbackSecretLabel: string;
+    copyLabel: string;
+    copied: string;
+    copyFailed: string;
+}
+declare const DEFAULT_TOTP_QR_LABELS: Readonly<TotpQrLabels>;
+interface BackupCodesLabels {
+    listLabel: string;
+    copy: string;
+    copied: string;
+    copyFailed: string;
+    download: string;
+    acknowledge: string;
+    fileName: string;
+    fileTitle: string;
+    fileNotice: string;
+}
+declare const DEFAULT_BACKUP_CODES_LABELS: Readonly<BackupCodesLabels>;
+interface CommonFailureLabels {
+    tooManyAttempts: string;
+}
+interface MfaEnrollmentLabels extends CommonFailureLabels {
+    step: (current: number, total: number) => string;
+    choiceHeading: string;
+    scanHeading: string;
+    passkeyHeading: string;
+    codesHeading: string;
+    mandatory: string;
+    choiceLead: string;
+    passkeyOption: string;
+    recommended: string;
+    passkeyOptionText: string;
+    usePasskey: string;
+    appOption: string;
+    appOptionText: string;
+    useApp: string;
+    preparing: string;
+    back: string;
+    todoInstall: string;
+    todoScan: string;
+    todoKeep: string;
+    begin: string;
+    scanLead: string;
+    codeLabel: string;
+    activate: string;
+    verifying: string;
+    passkeyLead: string;
+    passkeyNameLabel: string;
+    defaultPasskeyName: string;
+    createPasskey: string;
+    creating: string;
+    promptOpen: string;
+    codesLead: (factor: EnrolledFactor) => string;
+    continue: string;
+    enterCode: string;
+    wrongCode: string;
+    startFailed: string;
+    activationFailed: string;
+    passkeyFailed: string;
+    alreadyRegistered: string;
+    cancelled: string;
+    browserUnsupported: string;
+    passkeysUnavailable: string;
+    loginExpired: string;
+    alreadySetUp: string;
+    nameTooLong: (max: number) => string;
+    nameControlCharacters: string;
+}
+declare const DEFAULT_MFA_ENROLLMENT_LABELS: Readonly<MfaEnrollmentLabels>;
+interface LoginLabels extends CommonFailureLabels {
+    heading: string;
+    intro: string;
+    challengeHeading: string;
+    enrollmentHeading: string;
+    username: string;
+    password: string;
+    showPassword: string;
+    hidePassword: string;
+    submit: string;
+    submitting: string;
+    registerPrompt: string;
+    wrongCredentials: string;
+    loginFailed: string;
+    introBackupCode: string;
+    introPasskeyOrCode: string;
+    introPasskey: string;
+    introCode: string;
+    blockedByServer: string;
+    blockedByBrowser: string;
+    backToPasskeyOrApp: string;
+    backToPasskey: string;
+    backToApp: string;
+    useBackupCode: string;
+    back: string;
+    backupCodeLabel: string;
+    codeLabel: string;
+    verify: string;
+    verifying: string;
+    usePasskey: string;
+    passkeyValidating: string;
+    or: string;
+    passkeyPrompt: string;
+    enterBackupCode: string;
+    enterCode: string;
+    wrongCode: string;
+    verifyFailed: string;
+    cancelled: string;
+    browserUnsupported: string;
+    passkeyRefused: string;
+    passkeysUnavailable: string;
+    loginExpired: string;
+}
+declare const DEFAULT_LOGIN_LABELS: Readonly<LoginLabels>;
+interface RegisterLabels extends CommonFailureLabels {
+    heading: string;
+    intro: string;
+    enrollmentHeading: string;
+    loading: string;
+    closedHeading: string;
+    closedMessage: string;
+    signIn: string;
+    createdHeading: string;
+    createdMessage: string;
+    enrollmentExpired: string;
+    createdName: string;
+    username: string;
+    usernameHint: string;
+    email: string;
+    password: string;
+    passwordHint: (minLength: number) => string;
+    showPassword: string;
+    hidePassword: string;
+    submit: string;
+    submitting: string;
+    signInPrompt: string;
+    usernameEmpty: string;
+    usernameInvalid: string;
+    emailEmpty: string;
+    emailInvalid: string;
+    passwordEmpty: string;
+    passwordTooShort: (minLength: number) => string;
+    invalid: string;
+    reserved: string;
+    taken: string;
+    failed: string;
+}
+declare const DEFAULT_REGISTER_LABELS: Readonly<RegisterLabels>;
+interface ActivateLabels extends CommonFailureLabels {
+    heading: string;
+    intro: string;
+    password: string;
+    passwordHint: (minLength: number) => string;
+    confirmation: string;
+    showPassword: string;
+    hidePassword: string;
+    submit: string;
+    submitting: string;
+    signInPrompt: string;
+    successHeading: string;
+    successMessage: string;
+    invalidHeading: string;
+    invalidMessage: string;
+    signIn: string;
+    passwordEmpty: string;
+    passwordTooShort: (minLength: number) => string;
+    confirmationEmpty: string;
+    mismatch: string;
+    weakPassword: (minLength: number) => string;
+    failed: string;
+}
+declare const DEFAULT_ACTIVATE_LABELS: Readonly<ActivateLabels>;
+interface MfaSettingsLabels extends CommonFailureLabels {
+    heading: string;
+    enrollingHeading: string;
+    codesHeading: string;
+    help: string;
+    codesHelp: string;
+    loading: string;
+    loadFailed: string;
+    retry: string;
+    enrollLead: string;
+    enrollSubmit: string;
+    enrollBusy: string;
+    enrollFailed: string;
+    regenerateLead: string;
+    regenerateSubmit: string;
+    regenerateBusy: string;
+    regenerateFailed: string;
+    disableSubmit: string;
+    disableCheckBusy: string;
+    disableFailed: string;
+    removeTitle: string;
+    removeHelp: string;
+    removeAction: string;
+    removeDialogHeading: string;
+    removeDialogMessage: string;
+    removePromptLead: string;
+    removeBusy: string;
+    resetTitle: string;
+    resetHelp: string;
+    resetAction: string;
+    resetDialogHeading: string;
+    resetDialogMessage: string;
+    resetPromptLead: string;
+    resetBusy: string;
+    codesLeft: (count: number) => string;
+    lowCodes: string;
+    scanLead: string;
+    codeLabel: string;
+    activate: string;
+    verifying: string;
+    cancel: string;
+    close: string;
+    codesLeadEnrolled: string;
+    codesLeadRegenerated: string;
+    dontLeave: string;
+    done: string;
+    appConfigured: string;
+    enabled: string;
+    appHelpWithPasskey: string;
+    appHelp: string;
+    noApp: string;
+    optional: string;
+    noAppHelp: string;
+    addApp: string;
+    backupCodesTitle: string;
+    backupCodesHelp: string;
+    regenerateCodes: string;
+    noFactorWarning: string;
+    setUpNow: string;
+    currentPassword: string;
+    showPassword: string;
+    hidePassword: string;
+    enterPassword: string;
+    wrongPassword: string;
+    enterCode: string;
+    wrongCode: string;
+    activationFailed: string;
+    signedOut: string;
+}
+declare const DEFAULT_MFA_SETTINGS_LABELS: Readonly<MfaSettingsLabels>;
+interface PasskeySettingsLabels extends CommonFailureLabels {
+    heading: string;
+    description: string;
+    loading: string;
+    loadFailed: string;
+    retry: string;
+    browserBlocked: string;
+    serverBlocked: string;
+    emptyHeading: string;
+    emptyMessage: string;
+    listLabel: string;
+    added: (absolute: boolean) => string;
+    lastUsed: (absolute: boolean) => string;
+    neverUsed: string;
+    delete: string;
+    deleteKey: (name: string) => string;
+    passkeyAdded: (name: string) => string;
+    passkeyGone: (name: string) => string;
+    addPasskey: string;
+    finishAppFirst: string;
+    deleteDialogHeading: string;
+    deleteDialogMessage: (name: string, lastFactor: boolean) => string;
+    deleteConfirm: string;
+    cancel: string;
+    close: string;
+    deleting: string;
+    addLead: string;
+    promptOpen: string;
+    nameLabel: string;
+    defaultPasskeyName: string;
+    currentPassword: string;
+    showPassword: string;
+    hidePassword: string;
+    create: string;
+    creating: string;
+    deleteLead: (name: string) => string;
+    lastFactorWarning: string;
+    continue: string;
+    checking: string;
+    nameTooLong: (max: number) => string;
+    nameControlCharacters: string;
+    enterPassword: string;
+    wrongPassword: string;
+    tooManyPasskeys: string;
+    alreadyRegistered: string;
+    passkeysUnavailable: string;
+    addFailed: string;
+    cancelled: string;
+    browserUnsupported: string;
+    deleteFailed: string;
+    signedOut: string;
+}
+declare const DEFAULT_PASSKEY_SETTINGS_LABELS: Readonly<PasskeySettingsLabels>;
+interface AuthLabels {
+    totpQr?: Partial<TotpQrLabels>;
+    backupCodes?: Partial<BackupCodesLabels>;
+    mfaEnrollment?: Partial<MfaEnrollmentLabels>;
+    login?: Partial<LoginLabels>;
+    register?: Partial<RegisterLabels>;
+    activate?: Partial<ActivateLabels>;
+    mfaSettings?: Partial<MfaSettingsLabels>;
+    passkeySettings?: Partial<PasskeySettingsLabels>;
+}
+declare const AUTH_LABELS: InjectionToken<AuthLabels>;
+declare function provideAuthLabels(labels: AuthLabels): Provider;
+
+interface AuthPortError {
+    status: number;
+    error?: unknown;
+}
+declare const AUTH_PORT_ERROR_BODIES: {
+    readonly invalidToken: "invalid or expired token";
+    readonly invalidCode: "invalid code";
+    readonly alreadySetUp: "MFA is already set up";
+    readonly wrongPassword: "current password is incorrect";
+    readonly tooManyPasskeys: "too many passkeys";
+    readonly registrationDisabled: "registration is disabled";
+    readonly usernameReserved: "username is reserved";
+    readonly emailTaken: "email already in use";
+    readonly invalidEmail: "email is not a valid address";
+    readonly weakPasswordPrefix: "password must be at least";
+    readonly usernamePrefix: "username ";
+};
+declare function isAuthPortError(err: unknown): err is AuthPortError;
+declare function portErrorMessage(err: AuthPortError): string | null;
+
+type MfaFailure = 'wrong-code' | 'expired' | 'rate-limited' | 'unavailable' | 'already-set-up' | 'other';
+declare function classifyMfaFailure(err: unknown): MfaFailure;
+type PasswordGatedFailure = 'wrong-password' | 'rate-limited' | 'other';
+declare function classifyPasswordFailure(err: unknown): PasswordGatedFailure;
+declare function isTooManyPasskeys(err: unknown): boolean;
+
+type RegisterFailure = 'disabled' | 'invalid' | 'username-invalid' | 'email-invalid' | 'password-weak' | 'username-reserved' | 'username-taken' | 'email-taken' | 'rate-limited' | 'other';
+type ActivateFailure = 'invalid-link' | 'weak-password' | 'rate-limited' | 'other';
+declare function classifyRegisterFailure(err: unknown): RegisterFailure;
+declare function classifyActivateFailure(err: unknown): ActivateFailure;
+
+declare const MIN_PASSWORD_LENGTH = 8;
+declare const USERNAME_PATTERN: RegExp;
+type UsernameProblem = 'empty' | 'invalid';
+type EmailProblem = 'empty' | 'invalid';
+type PasswordProblem = 'empty' | 'too-short';
+declare function usernameProblem(raw: string, pattern?: RegExp): UsernameProblem | null;
+declare function emailProblem(raw: string): EmailProblem | null;
+declare function passwordProblem(password: string, minLength?: number): PasswordProblem | null;
+declare function accountName(raw: string): string;
+
+declare const ACTIVATION_TOKEN_SHAPE: RegExp;
+declare function activationToken(fragment: string | null, query: string | null, shape?: RegExp): string | null;
+
+declare const PASSKEY_NAME_MAX = 40;
+type PasskeyNameProblem = 'too-long' | 'control-characters';
+declare function passkeyNameProblem(name: string, maxLength?: number): PasskeyNameProblem | null;
+
+type MfaFormOwner = 'passkeys' | 'app';
+declare class MfaSettingsState {
+    private readonly passkeys;
+    private readonly totp;
+    private readonly owner;
+    private readonly appFlow;
+    readonly passkeyCount: _angular_core.Signal<number | null>;
+    readonly totpEnabled: _angular_core.Signal<boolean | null>;
+    readonly formOwner: _angular_core.Signal<MfaFormOwner | null>;
+    readonly appFlowActive: _angular_core.Signal<boolean>;
+    claimForm(owner: MfaFormOwner): void;
+    setAppFlowActive(active: boolean): void;
+    statusLoaded(status: MfaStatus): void;
+    totpConfirmed(): void;
+    passkeyAdded(): void;
+    passkeyGone(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MfaSettingsState, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<any>;
+}
+
+declare class AuthPanel {
+    heading: _angular_core.InputSignal<string>;
+    intro: _angular_core.InputSignal<string>;
+    wide: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AuthPanel, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AuthPanel, "gbt-auth-panel", never, { "heading": { "alias": "heading"; "required": false; "isSignal": true; }; "intro": { "alias": "intro"; "required": false; "isSignal": true; }; "wide": { "alias": "wide"; "required": false; "isSignal": true; }; }, {}, never, ["[auth-logo]", "*"], true, never>;
+}
+
+declare class AuthFooterLink {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AuthFooterLink, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AuthFooterLink, "[gbtAuthFooterLink]", never, {}, {}, never, never, true, never>;
+}
+declare class AuthFooter {
+    text: _angular_core.InputSignal<string>;
+    href: _angular_core.InputSignal<string | null>;
+    linkText: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AuthFooter, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AuthFooter, "gbt-auth-footer", never, { "text": { "alias": "text"; "required": true; "isSignal": true; }; "href": { "alias": "href"; "required": false; "isSignal": true; }; "linkText": { "alias": "linkText"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+interface TotpQrRenderOptions {
+    width: number;
+    margin: number;
+    errorCorrectionLevel: 'L' | 'M' | 'Q' | 'H';
+}
+type TotpQrRenderer = (text: string, options: TotpQrRenderOptions) => Promise<string>;
+declare const TOTP_QR_RENDERER: InjectionToken<TotpQrRenderer>;
+declare class TotpQr {
+    otpauthUrl: _angular_core.InputSignal<string>;
+    secret: _angular_core.InputSignal<string>;
+    labels: _angular_core.InputSignal<Partial<TotpQrLabels>>;
+    protected readonly text: _angular_core.Signal<Readonly<TotpQrLabels>>;
+    protected dataUrl: _angular_core.WritableSignal<string | null>;
+    protected failed: _angular_core.WritableSignal<boolean>;
+    private readonly render;
+    private generation;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TotpQr, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TotpQr, "gbt-totp-qr", never, { "otpauthUrl": { "alias": "otpauthUrl"; "required": true; "isSignal": true; }; "secret": { "alias": "secret"; "required": true; "isSignal": true; }; "labels": { "alias": "labels"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class BackupCodes {
+    codes: _angular_core.InputSignal<string[]>;
+    acknowledged: _angular_core.ModelSignal<boolean>;
+    labels: _angular_core.InputSignal<Partial<BackupCodesLabels>>;
+    protected readonly text: _angular_core.Signal<Readonly<BackupCodesLabels>>;
+    protected readonly id: string;
+    private readonly document;
+    protected readonly display: _angular_core.Signal<string[][]>;
+    constructor();
+    protected readonly codesText: _angular_core.Signal<string>;
+    protected download(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BackupCodes, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BackupCodes, "gbt-backup-codes", never, { "codes": { "alias": "codes"; "required": true; "isSignal": true; }; "acknowledged": { "alias": "acknowledged"; "required": false; "isSignal": true; }; "labels": { "alias": "labels"; "required": false; "isSignal": true; }; }, { "acknowledged": "acknowledgedChange"; }, never, never, true, never>;
+}
+
+type Step = 'choice' | 'scan' | 'passkey' | 'codes';
+type Factor = 'totp' | 'passkey';
+declare class MfaEnrollment {
+    private readonly auth;
+    private readonly host;
+    private readonly injector;
+    mfaToken: _angular_core.InputSignal<string>;
+    passkeysAvailable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    labels: _angular_core.InputSignal<Partial<MfaEnrollmentLabels>>;
+    completed: _angular_core.OutputEmitterRef<string>;
+    cancelled: _angular_core.OutputEmitterRef<void>;
+    expired: _angular_core.OutputEmitterRef<void>;
+    protected readonly text: _angular_core.Signal<Readonly<MfaEnrollmentLabels>>;
+    protected readonly stepCount = 3;
+    protected readonly id: string;
+    protected step: _angular_core.WritableSignal<Step>;
+    protected factor: _angular_core.WritableSignal<Factor>;
+    protected passkeyOffered: _angular_core.Signal<boolean>;
+    protected passkeyName: _angular_core.WritableSignal<string>;
+    protected errorVariant: _angular_core.WritableSignal<"info" | "error">;
+    protected promptOpen: _angular_core.WritableSignal<boolean>;
+    protected stepNumber: _angular_core.Signal<number>;
+    protected secret: _angular_core.WritableSignal<string>;
+    protected otpauthUrl: _angular_core.WritableSignal<string>;
+    protected code: _angular_core.WritableSignal<string>;
+    protected backupCodes: _angular_core.WritableSignal<string[]>;
+    protected acknowledged: _angular_core.WritableSignal<boolean>;
+    protected error: _angular_core.WritableSignal<string>;
+    protected submitting: _angular_core.WritableSignal<boolean>;
+    private sessionToken;
+    private readonly browserHasPasskeys;
+    private ceremony;
+    constructor();
+    begin(): void;
+    confirm(): void;
+    choosePasskey(): void;
+    createPasskey(): void;
+    protected back(): void;
+    finish(): void;
+    private goTo;
+    private passkeyFailed;
+    private clearError;
+    private fail;
+    private messageFor;
+    private focus;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MfaEnrollment, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MfaEnrollment, "gbt-mfa-enrollment", never, { "mfaToken": { "alias": "mfaToken"; "required": true; "isSignal": true; }; "passkeysAvailable": { "alias": "passkeysAvailable"; "required": false; "isSignal": true; }; "labels": { "alias": "labels"; "required": false; "isSignal": true; }; }, { "completed": "completed"; "cancelled": "cancelled"; "expired": "expired"; }, never, never, true, never>;
+}
+
+declare class AuthLogin {
+    private readonly auth;
+    private readonly host;
+    private readonly injector;
+    labels: _angular_core.InputSignal<Partial<LoginLabels>>;
+    loggedIn: _angular_core.OutputEmitterRef<void>;
+    protected readonly text: _angular_core.Signal<Readonly<LoginLabels>>;
+    protected readonly registerLink: _angular_core.Signal<AuthFooterLink | undefined>;
+    protected readonly id: string;
+    username: _angular_core.WritableSignal<string>;
+    protected password: _angular_core.WritableSignal<string>;
+    error: _angular_core.WritableSignal<string>;
+    submitting: _angular_core.WritableSignal<boolean>;
+    protected mfaToken: _angular_core.WritableSignal<string | null>;
+    mfaSetupRequired: _angular_core.WritableSignal<boolean>;
+    mfaHasTotp: _angular_core.WritableSignal<boolean>;
+    mfaHasPasskey: _angular_core.WritableSignal<boolean>;
+    useBackupCode: _angular_core.WritableSignal<boolean>;
+    protected code: _angular_core.WritableSignal<string>;
+    protected backupCode: _angular_core.WritableSignal<string>;
+    protected registrationEnabled: _angular_core.WritableSignal<boolean>;
+    protected passkeysAvailable: _angular_core.WritableSignal<boolean | null>;
+    private browserHasPasskeys;
+    protected passkeyInFlight: _angular_core.WritableSignal<boolean>;
+    private ceremony;
+    protected errorVariant: _angular_core.WritableSignal<"info" | "error">;
+    protected enrolling: _angular_core.Signal<boolean>;
+    protected challenging: _angular_core.Signal<boolean>;
+    protected canUsePasskey: _angular_core.Signal<boolean>;
+    protected hasTotp: _angular_core.Signal<boolean>;
+    protected passkeyBlocked: _angular_core.Signal<boolean>;
+    protected showBackupCode: _angular_core.Signal<boolean>;
+    protected blockedReason: _angular_core.Signal<string>;
+    protected backFromBackupLabel: _angular_core.Signal<string>;
+    protected heading: _angular_core.Signal<string>;
+    protected intro: _angular_core.Signal<string>;
+    constructor();
+    submit(): void;
+    private loginFailureMessage;
+    verify(): void;
+    usePasskey(): void;
+    private passkeyFailed;
+    toggleBackupCode(): void;
+    private firstChallengeTarget;
+    backToCredentials(): void;
+    sessionExpired(): void;
+    enrolled(token: string): void;
+    private resetMfa;
+    private fail;
+    private focusField;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AuthLogin, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AuthLogin, "gbt-auth-login", never, { "labels": { "alias": "labels"; "required": false; "isSignal": true; }; }, { "loggedIn": "loggedIn"; }, ["registerLink"], ["[auth-logo]", "[gbtAuthFooterLink]"], true, never>;
+}
+
+type Registration = 'loading' | 'open' | 'closed' | 'created';
+declare class AuthRegister {
+    private readonly auth;
+    private readonly host;
+    private readonly injector;
+    labels: _angular_core.InputSignal<Partial<RegisterLabels>>;
+    minPasswordLength: _angular_core.InputSignal<number>;
+    usernamePattern: _angular_core.InputSignal<RegExp>;
+    registered: _angular_core.OutputEmitterRef<void>;
+    signIn: _angular_core.OutputEmitterRef<void>;
+    protected readonly text: _angular_core.Signal<Readonly<RegisterLabels>>;
+    protected readonly signInLink: _angular_core.Signal<AuthFooterLink | undefined>;
+    protected readonly id: string;
+    protected readonly passwordHint: _angular_core.Signal<string>;
+    protected readonly skeletonFields: {
+        name: string;
+        hint: boolean;
+    }[];
+    registration: _angular_core.WritableSignal<Registration>;
+    username: _angular_core.WritableSignal<string>;
+    email: _angular_core.WritableSignal<string>;
+    protected password: _angular_core.WritableSignal<string>;
+    error: _angular_core.WritableSignal<string>;
+    submitting: _angular_core.WritableSignal<boolean>;
+    private attempted;
+    protected mfaToken: _angular_core.WritableSignal<string | null>;
+    protected passkeysAvailable: _angular_core.WritableSignal<boolean>;
+    protected heading: _angular_core.Signal<string>;
+    protected intro: _angular_core.Signal<string>;
+    protected createdName: _angular_core.Signal<string>;
+    private enrollmentExpired;
+    protected createdMessage: _angular_core.Signal<string>;
+    protected usernameFieldError: _angular_core.Signal<string | null>;
+    protected emailFieldError: _angular_core.Signal<string | null>;
+    protected passwordFieldError: _angular_core.Signal<string | null>;
+    constructor();
+    submit(): void;
+    enrolled(token: string): void;
+    enrollmentInterrupted(expired: boolean): void;
+    private opened;
+    private failed;
+    private fail;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AuthRegister, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AuthRegister, "gbt-auth-register", never, { "labels": { "alias": "labels"; "required": false; "isSignal": true; }; "minPasswordLength": { "alias": "minPasswordLength"; "required": false; "isSignal": true; }; "usernamePattern": { "alias": "usernamePattern"; "required": false; "isSignal": true; }; }, { "registered": "registered"; "signIn": "signIn"; }, ["signInLink"], ["[auth-logo]", "[gbtAuthFooterLink]"], true, never>;
+}
+
+type View$2 = 'form' | 'success' | 'invalid';
+declare class AuthActivate {
+    private readonly auth;
+    private readonly host;
+    private readonly injector;
+    token: _angular_core.InputSignal<string | null>;
+    labels: _angular_core.InputSignal<Partial<ActivateLabels>>;
+    minPasswordLength: _angular_core.InputSignal<number>;
+    activated: _angular_core.OutputEmitterRef<void>;
+    signIn: _angular_core.OutputEmitterRef<void>;
+    protected readonly text: _angular_core.Signal<Readonly<ActivateLabels>>;
+    protected readonly id: string;
+    protected readonly signInLink: _angular_core.Signal<AuthFooterLink | undefined>;
+    protected readonly passwordHint: _angular_core.Signal<string>;
+    private readonly spent;
+    view: _angular_core.WritableSignal<View$2>;
+    protected password: _angular_core.WritableSignal<string>;
+    protected confirmation: _angular_core.WritableSignal<string>;
+    error: _angular_core.WritableSignal<string>;
+    submitting: _angular_core.WritableSignal<boolean>;
+    private attempted;
+    protected passwordFieldError: _angular_core.Signal<string | null>;
+    protected confirmationFieldError: _angular_core.Signal<string | null>;
+    constructor();
+    submit(): void;
+    private confirmationProblem;
+    private clearPasswords;
+    private show;
+    private fail;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AuthActivate, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AuthActivate, "gbt-auth-activate", never, { "token": { "alias": "token"; "required": false; "isSignal": true; }; "labels": { "alias": "labels"; "required": false; "isSignal": true; }; "minPasswordLength": { "alias": "minPasswordLength"; "required": false; "isSignal": true; }; }, { "activated": "activated"; "signIn": "signIn"; }, ["signInLink"], ["[auth-logo]", "[gbtAuthFooterLink]"], true, never>;
+}
+
+type View$1 = 'loading' | 'failed' | 'ready' | 'enrolling' | 'codes' | 'revoked';
+type Prompt = 'enroll' | 'regenerate' | 'disable';
+type CodesOrigin = 'enrolled' | 'regenerated';
+interface PromptCopy {
+    lead: string;
+    submit: string;
+    busy: string;
+    variant: 'primary' | 'secondary';
+    failed: string;
+}
+interface RemovalCopy {
+    title: string;
+    help: string;
+    action: string;
+    dialogHeading: string;
+    dialogMessage: string;
+    promptLead: string;
+    busy: string;
+}
+declare class MfaSettings {
+    private readonly mfa;
+    private readonly state;
+    private readonly host;
+    private readonly injector;
+    labels: _angular_core.InputSignal<Partial<MfaSettingsLabels>>;
+    lowCodesThreshold: _angular_core.InputSignal<number>;
+    sessionRevoked: _angular_core.OutputEmitterRef<void>;
+    protected readonly text: _angular_core.Signal<Readonly<MfaSettingsLabels>>;
+    protected readonly id: string;
+    protected view: _angular_core.WritableSignal<View$1>;
+    protected status: _angular_core.WritableSignal<MfaStatus>;
+    protected prompt: _angular_core.WritableSignal<Prompt | null>;
+    protected password: _angular_core.WritableSignal<string>;
+    protected passwordError: _angular_core.WritableSignal<string | null>;
+    protected notice: _angular_core.WritableSignal<string>;
+    protected secret: _angular_core.WritableSignal<string>;
+    protected otpauthUrl: _angular_core.WritableSignal<string>;
+    protected code: _angular_core.WritableSignal<string>;
+    protected codeError: _angular_core.WritableSignal<string | null>;
+    protected backupCodes: _angular_core.WritableSignal<string[]>;
+    protected codesOrigin: _angular_core.WritableSignal<CodesOrigin>;
+    protected acknowledged: _angular_core.WritableSignal<boolean>;
+    protected busy: _angular_core.WritableSignal<boolean>;
+    protected confirmingDisable: _angular_core.WritableSignal<boolean>;
+    protected hasPasskey: _angular_core.Signal<boolean>;
+    protected hasFactor: _angular_core.Signal<boolean>;
+    protected removal: _angular_core.Signal<RemovalCopy>;
+    protected lowCodes: _angular_core.Signal<boolean>;
+    protected codesLeft: _angular_core.Signal<string>;
+    protected promptCopy: _angular_core.Signal<PromptCopy>;
+    protected heading: _angular_core.Signal<string>;
+    protected help: _angular_core.Signal<string>;
+    constructor();
+    protected load(): void;
+    private copyOf;
+    protected openPrompt(prompt: Prompt): void;
+    protected cancelPrompt(): void;
+    protected setPassword(value: string): void;
+    protected submitPrompt(): void;
+    private enroll;
+    private regenerate;
+    protected disable(): void;
+    protected closeDisableDialog(): void;
+    private promptFailed;
+    private resetPrompt;
+    protected activate(): void;
+    protected setCode(value: string): void;
+    protected cancelEnrollment(): void;
+    private showCodes;
+    protected finishCodes(): void;
+    private focus;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MfaSettings, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MfaSettings, "gbt-mfa-settings", never, { "labels": { "alias": "labels"; "required": false; "isSignal": true; }; "lowCodesThreshold": { "alias": "lowCodesThreshold"; "required": false; "isSignal": true; }; }, { "sessionRevoked": "sessionRevoked"; }, never, never, true, never>;
+}
+
+type View = 'loading' | 'failed' | 'ready' | 'revoked';
+declare class PasskeySettings {
+    private readonly mfa;
+    private readonly auth;
+    private readonly state;
+    private readonly host;
+    private readonly injector;
+    labels: _angular_core.InputSignal<Partial<PasskeySettingsLabels>>;
+    locale: _angular_core.InputSignal<string | null>;
+    sessionRevoked: _angular_core.OutputEmitterRef<void>;
+    protected readonly text: _angular_core.Signal<Readonly<PasskeySettingsLabels>>;
+    protected readonly id: string;
+    protected readonly relativeOptions: _angular_core.Signal<{
+        style: "short";
+        maxUnit: "day";
+        absoluteAfterDays: number;
+        locale: string | undefined;
+    }>;
+    protected readonly dateOptions: _angular_core.Signal<{
+        day: "2-digit";
+        month: "2-digit";
+        year: "numeric";
+        hour: "2-digit";
+        minute: "2-digit";
+        locale: string | undefined;
+    }>;
+    protected readonly absolute: (iso: string) => boolean;
+    protected view: _angular_core.WritableSignal<View>;
+    protected passkeys: _angular_core.WritableSignal<Passkey[]>;
+    protected totpEnabled: _angular_core.WritableSignal<boolean>;
+    private serverAvailable;
+    private readonly browserSupported;
+    protected blockedReason: _angular_core.Signal<string | null>;
+    protected result: _angular_core.WritableSignal<string | null>;
+    protected adding: _angular_core.WritableSignal<boolean>;
+    protected name: _angular_core.WritableSignal<string>;
+    protected nameError: _angular_core.WritableSignal<string | null>;
+    protected password: _angular_core.WritableSignal<string>;
+    protected passwordError: _angular_core.WritableSignal<string | null>;
+    protected notice: _angular_core.WritableSignal<string>;
+    protected noticeVariant: _angular_core.WritableSignal<"info" | "error">;
+    protected busy: _angular_core.WritableSignal<boolean>;
+    protected promptOpen: _angular_core.WritableSignal<boolean>;
+    private ceremony;
+    protected deleting: _angular_core.WritableSignal<Passkey | null>;
+    protected deletePassword: _angular_core.WritableSignal<string>;
+    protected deletePasswordError: _angular_core.WritableSignal<string | null>;
+    protected deleteNotice: _angular_core.WritableSignal<string>;
+    protected confirmingDelete: _angular_core.WritableSignal<boolean>;
+    protected deleteBusy: _angular_core.WritableSignal<boolean>;
+    protected count: _angular_core.Signal<number | null>;
+    protected appBusy: _angular_core.Signal<boolean>;
+    protected lastFactor: _angular_core.Signal<boolean>;
+    protected deleteMessage: _angular_core.Signal<string>;
+    constructor();
+    protected load(): void;
+    protected openAdd(): void;
+    protected cancelAdd(): void;
+    protected setName(value: string): void;
+    protected setPassword(value: string): void;
+    protected submitAdd(): void;
+    private addFailed;
+    private fail;
+    private clearNotice;
+    private resetAdd;
+    protected openDelete(passkey: Passkey): void;
+    protected cancelDelete(): void;
+    protected setDeletePassword(value: string): void;
+    protected submitDelete(): void;
+    protected closeDeleteDialog(): void;
+    protected delete(): void;
+    private deleteFailed;
+    private closeDelete;
+    private resetDelete;
+    private cancelAddQuietly;
+    private focus;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PasskeySettings, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PasskeySettings, "gbt-passkey-settings", never, { "labels": { "alias": "labels"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; }, { "sessionRevoked": "sessionRevoked"; }, never, never, true, never>;
+}
+
+export { ACTIVATION_TOKEN_SHAPE, AUTH_LABELS, AUTH_PORT, AUTH_PORT_ERROR_BODIES, Accordion, AccordionItem, Alert, AppShell, AppShellNavGroup, AuthActivate, AuthFooter, AuthFooterLink, AuthLogin, AuthPanel, AuthRegister, Autocomplete, Avatar, AvatarGroup, BackupCodes, Badge, BarChart, BarSeries, Breadcrumb, Button, CHART_CONTEXT, COPY_FIELD_WRAP_AT, Card, CardHeader, CardLink, ChartAxis, ChartEmpty, ChartFrame, ChartLegend, ChartTable, ChartTooltip, Checkbox, CheckboxGroup, ClipboardFeedback, ConfirmDangerModal, CopyButton, CopyField, DEFAULT_ACTIVATE_LABELS, DEFAULT_BACKUP_CODES_LABELS, DEFAULT_LOGIN_LABELS, DEFAULT_MFA_ENROLLMENT_LABELS, DEFAULT_MFA_SETTINGS_LABELS, DEFAULT_PASSKEY_SETTINGS_LABELS, DEFAULT_REGISTER_LABELS, DEFAULT_TOTP_QR_LABELS, DatePicker, DateRangePicker, DescriptionList, DimensionCard, Disclosure, Divider, Drawer, EmptyState, FileUpload, FunnelChart, GABARIT_VERSION, GaugeBar, GbtBytesPipe, GbtDateTimePipe, GbtInput, GbtRelativeTimePipe, GbtToastService, Icon, IconMarker, IconRegistry, JobGraph, JobStatus, LineChart, LineSeries, ListCard, ListRow, ListToolbar, MFA_PORT, MIN_PASSWORD_LENGTH, Menu, MenuItem, MenuTrigger, MfaEnrollment, MfaSettings, MfaSettingsState, Modal, NavTab, NavTabs, NotificationDot, PASSKEY_NAME_MAX, PageHeader, PageLayout, Pagination, Panel, PasskeySettings, PieChart, Popover, RadioGroup, SaveStatus, SearchBar, SecretReveal, SegmentedControl, Select, Skeleton, SkeletonList, Slider, Sparkline, Spinner, StatGrid, StatTile, StatTileLink, Stepper, Switch, TOTP_QR_RENDERER, Tab, Table, Tabs, Tag, TagInput, Textarea, TimelineChart, TimelineSeries, Toaster, Tooltip, TotpQr, Tree, USERNAME_PATTERN, UserChip, accountName, activationToken, arcPath, areaPath, bandScale, base64UrlToBuffer, bufferToBase64Url, classifyActivateFailure, classifyMfaFailure, classifyPasskeyError, classifyPasswordFailure, classifyRegisterFailure, computeInitials, copyToClipboard, createListToolbarState, createPasskeyCredential, emailProblem, formatBytes, formatCompact, formatDateTime, formatDuration, formatNumber, formatPercent, formatRelativeTime, getPasskeyAssertion, isAuthPortError, isTooManyPasskeys, linePath, linearScale, nearestIndex, niceTicks, niceXDomain, niceYDomain, passkeyNameProblem, passkeysSupported, passwordProblem, portErrorMessage, provideAuthLabels, selectContents, timeScale, timeTicks, usernameProblem };
+export type { AccordionMode, ActivateFailure, ActivateLabels, AlertAppearance, AlertIconAlign, AlertLive, AlertSize, AlertVariant, Arc, AuthConfig, AuthLabels, AuthPort, AuthPortError, AutocompleteSearchFn, AvatarGroupItem, AvatarSize, AxisSpec, BackupCodesLabels, BackupCodesResult, BadgeAppearance, BadgeSize, BadgeVariant, BandScale, ButtonHaspopup, ButtonSize, ButtonVariant, CalendarDay, CardTone, CardVariant, ChartBox, ChartInterval, ChartMargin, ChartPoint, ChartReader, ChartSeries, CheckboxGroupOption, CheckboxGroupSection, ConfirmDangerModalTone, CopyButtonFeedback, CopyOutcome, CopyStatus, CopyValue, DateInput, DateRangeValue, DescriptionListEntry, DescriptionListLayout, DescriptionListResponsive, DescriptionListValueAlign, DimensionRow, DisclosureAppearance, DisclosureHeadingLevel, DividerOrientation, DrawerEdge, EmailProblem, EmptyStateHeadingLevel, EmptyStateIllustration, EmptyStateSize, EmptyStateTone, EnrolledFactor, FlatTreeNode, FormatBytesOptions, FormatDurationOptions, FormatRelativeTimeOptions, FunnelStep, GbtBytesPipeOptions, GbtDateTimePipeOptions, GbtPipeLocale, GbtRelativeTimePipeOptions, GbtToastKind, GbtToastOptions, IconMarkerAppearance, IconMarkerShape, IconMarkerSize, IconMarkerTone, JobGraphJob, JobGraphStage, JobGraphStatus, JobStatusValue, LegendEntry, LinearAxisSpec, ListCardState, ListRowTone, ListToolbarAccessors, ListToolbarDirection, ListToolbarSortOption, ListToolbarSortValue, ListToolbarState, ListToolbarStateConfig, LoginLabels, LoginResponse, MenuItemVariant, MfaEnrollmentLabels, MfaFailure, MfaFormOwner, MfaPort, MfaProof, MfaSettingsLabels, MfaSetupResult, MfaStatus, NavTabsOrientation, NotificationDotVariant, PageHeaderLevel, PageLayoutAsidePosition, PageLayoutAsideWidth, PageLayoutWidth, PanelHeadingLevel, Passkey, PasskeyChallenge, PasskeyFailure, PasskeyNameProblem, PasskeySettingsLabels, PasswordGatedFailure, PasswordProblem, PieSlice, Point, PointValue, PopoverAlign, RadioOption, RegisterFailure, RegisterLabels, SaveStatusState, Scale, SearchBarCollapsible, SearchResultCategory, SegmentedControlOption, SegmentedControlSize, SelectOption, SkeletonListLeading, SkeletonVariant, SpinnerSize, StatGridColumns, StatTileTrend, StatTileTrendTone, StepperOrientation, StepperStatus, StepperStep, TableColumn, TimeTicks, TimeUnit, ToastItem, ToastVariant, ToasterPosition, TooltipPoint, TooltipPosition, TooltipRow, TotpEnrollment, TotpQrLabels, TotpQrRenderOptions, TotpQrRenderer, TreeNode, UserChipSize, UsernameProblem, WeekStartsOn };