@thl-ui/angular 0.0.0-stage → 0.1.0

package/types/thl-ui-angular.d.ts

@@ -0,0 +1,1665 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, PipeTransform, Signal, EnvironmentProviders, DestroyRef, ElementRef, TemplateRef, model } from '@angular/core';
+import * as _thl_ui_core from '@thl-ui/core';
+import { ThlConfig, ThlComponentDefaults, ThlInstance, TParams, Modifiers, ToastManager, Toast, ThlUserConfig, Store, ThlSemanticColor, Placement, BreadcrumbItem, StepItem, TabsItem, TimelineItem, SelectOption, UploadFile, Rule, ColumnDef, MenuItem, LayoutMode, ColorMode, skins } from '@thl-ui/core';
+export { MenuItem, ThlConfig, ThlUserConfig, createThl, rules } from '@thl-ui/core';
+import * as _thl_ui_locales from '@thl-ui/locales';
+import { SafeHtml } from '@angular/platform-browser';
+import { IconRegistry } from '@thl-ui/icons';
+import * as _thl_ui_charts from '@thl-ui/charts';
+import { Series } from '@thl-ui/charts';
+import { ControlValueAccessor, AbstractControl, ValidatorFn } from '@angular/forms';
+
+declare const THL_CONFIG: InjectionToken<Partial<Omit<ThlConfig, "components" | "messages">> & {
+    components?: Partial<ThlComponentDefaults>;
+    messages?: Record<string, _thl_ui_locales.Messages>;
+    loadLocale?: (locale: string) => Promise<_thl_ui_locales.Messages | {
+        default: _thl_ui_locales.Messages;
+    }>;
+} & {
+    icons?: IconRegistry;
+    instance?: ThlInstance;
+}>;
+/** Bridge a core Store to an Angular signal. */
+declare function storeSignal<T>(store: Store<T>, destroyRef?: DestroyRef): Signal<T>;
+/** Global config service (signals). */
+declare class ThlConfigService {
+    private readonly opts;
+    readonly instance: ThlInstance;
+    private readonly _config;
+    readonly config: Signal<ThlConfig>;
+    readonly prefix: Signal<string>;
+    readonly toast: ToastManager;
+    readonly toasts: Signal<Toast[]>;
+    constructor();
+    set(patch: Partial<ThlConfig>): void;
+    /** BEM class builder bound to current prefix. */
+    bem(block: string): _thl_ui_core.Bem;
+    defaults<K extends keyof ThlComponentDefaults>(name: K, props?: Record<string, unknown>): NonNullable<ThlComponentDefaults[K]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlConfigService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ThlConfigService>;
+}
+/** i18n service — `t()` is signal-tracked so templates/computed re-evaluate on locale change. */
+declare class ThlI18nService {
+    private readonly cfg;
+    private readonly rev;
+    readonly locale: _angular_core.WritableSignal<string>;
+    constructor();
+    t(key: string, params?: TParams): string;
+    te(key: string): boolean;
+    n(v: number, o?: Intl.NumberFormatOptions): string;
+    d(v: Date | number | string, o?: Intl.DateTimeFormatOptions): string;
+    intlLocale(): string;
+    setLocale(l: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlI18nService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ThlI18nService>;
+}
+/** `{{ 'common.ok' | thlT }}` / `{{ 'pagination.total' | thlT: { count: 5 } }}` */
+declare class ThlTranslatePipe implements PipeTransform {
+    private readonly i18n;
+    transform(key: string, params?: TParams): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlTranslatePipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ThlTranslatePipe, "thlT", true>;
+}
+/** `[class]="'btn' | thlBem: { primary: true }"` */
+declare class ThlBemPipe implements PipeTransform {
+    private readonly cfg;
+    transform(block: string, modsOrEl?: Modifiers | string, mods?: Modifiers): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlBemPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ThlBemPipe, "thlBem", true>;
+}
+/** Toast service. Render <thl-toaster/> once (included in <thl-app-layout/>). */
+declare class ThlToastService {
+    private readonly cfg;
+    show: (...a: Parameters<ToastManager["show"]>) => string;
+    success: (...a: Parameters<ToastManager["success"]>) => string;
+    info: (...a: Parameters<ToastManager["info"]>) => string;
+    warning: (...a: Parameters<ToastManager["warning"]>) => string;
+    error: (...a: Parameters<ToastManager["error"]>) => string;
+    dismiss: (id: string) => void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlToastService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ThlToastService>;
+}
+/** Standalone providers: `bootstrapApplication(App, { providers: [provideThlUI({ locale: 'vi', theme: 'green-dark' })] })` */
+declare function provideThlUI(config?: ThlUserConfig & {
+    icons?: IconRegistry;
+    instance?: ThlInstance;
+}): EnvironmentProviders;
+/** <thl-icon name="bell" /> */
+declare class ThlIconComponent {
+    private readonly san;
+    readonly name: _angular_core.InputSignal<string>;
+    readonly size: _angular_core.InputSignal<string | number>;
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    readonly strokeWidth: _angular_core.InputSignal<number>;
+    readonly svg: Signal<SafeHtml>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlIconComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlIconComponent, "thl-icon", never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** <button thl-button variant="primary">  or  <a thl-button href=...> — attribute component keeps native semantics. */
+declare class ThlButtonComponent {
+    private readonly cfg;
+    private readonly el;
+    readonly isButton: boolean;
+    readonly variant: _angular_core.InputSignal<string | undefined>;
+    readonly size: _angular_core.InputSignal<"sm" | "md" | "lg" | "xs" | "xl" | undefined>;
+    readonly outline: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
+    readonly rounded: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
+    readonly circle: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly block: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly noRipple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly icon: _angular_core.InputSignal<string | undefined>;
+    readonly iconRight: _angular_core.InputSignal<string | undefined>;
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    readonly b: (el: string) => string;
+    readonly cls: _angular_core.Signal<string>;
+    ripple(e: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlButtonComponent, "button[thl-button], a[thl-button]", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "outline": { "alias": "outline"; "required": false; "isSignal": true; }; "rounded": { "alias": "rounded"; "required": false; "isSignal": true; }; "circle": { "alias": "circle"; "required": false; "isSignal": true; }; "block": { "alias": "block"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "noRipple": { "alias": "noRipple"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconRight": { "alias": "iconRight"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class ThlButtonGroupComponent {
+    private readonly cfg;
+    readonly vertical: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly justified: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly cls: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlButtonGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlButtonGroupComponent, "thl-button-group", never, { "vertical": { "alias": "vertical"; "required": false; "isSignal": true; }; "justified": { "alias": "justified"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class ThlBadgeComponent {
+    private readonly cfg;
+    readonly color: _angular_core.InputSignal<"default" | "red" | "purple" | "dark" | "success" | "info" | "warning" | "primary" | "danger" | "inverse">;
+    readonly size: _angular_core.InputSignal<"sm" | "md" | "xs">;
+    readonly dot: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly pill: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly cls: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlBadgeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlBadgeComponent, "thl-badge", never, { "color": { "alias": "color"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "dot": { "alias": "dot"; "required": false; "isSignal": true; }; "pill": { "alias": "pill"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class ThlLabelComponent {
+    private readonly cfg;
+    readonly color: _angular_core.InputSignal<string>;
+    readonly rounded: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly outline: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly closable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    readonly b: (e: string) => string;
+    readonly cls: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlLabelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlLabelComponent, "thl-label", never, { "color": { "alias": "color"; "required": false; "isSignal": true; }; "rounded": { "alias": "rounded"; "required": false; "isSignal": true; }; "outline": { "alias": "outline"; "required": false; "isSignal": true; }; "closable": { "alias": "closable"; "required": false; "isSignal": true; }; }, { "closed": "closed"; }, never, ["*"], true, never>;
+}
+declare class ThlAvatarComponent {
+    private readonly cfg;
+    readonly src: _angular_core.InputSignal<string | undefined>;
+    readonly name: _angular_core.InputSignal<string | undefined>;
+    readonly size: _angular_core.InputSignal<number | "sm" | "md" | "lg" | "xs" | "xl">;
+    readonly status: _angular_core.InputSignal<"online" | "offline" | "away" | "busy" | undefined>;
+    readonly shape: _angular_core.InputSignal<"rounded" | "circle" | "square">;
+    readonly initials: _angular_core.Signal<string>;
+    readonly px: _angular_core.Signal<string | null>;
+    readonly cls: _angular_core.Signal<string>;
+    readonly statusCls: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlAvatarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlAvatarComponent, "thl-avatar", never, { "src": { "alias": "src"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class ThlSpinnerComponent {
+    private readonly cfg;
+    private readonly i18n;
+    readonly aria: _angular_core.Signal<string>;
+    readonly size: _angular_core.InputSignal<"sm" | "md" | "lg">;
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    readonly cls: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlSpinnerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlSpinnerComponent, "thl-spinner", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/** Marker for <div thlCardActions> projected into the card header. */
+declare class ThlCardActionsDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlCardActionsDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ThlCardActionsDirective, "[thlCardActions]", never, {}, {}, never, never, true, never>;
+}
+declare class ThlCardComponent {
+    private readonly cfg;
+    readonly title: _angular_core.InputSignal<string | undefined>;
+    readonly subtitle: _angular_core.InputSignal<string | undefined>;
+    readonly shadow: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
+    readonly bordered: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
+    readonly flush: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly actions: _angular_core.Signal<ThlCardActionsDirective | undefined>;
+    readonly b: (e: string) => string;
+    readonly cls: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlCardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlCardComponent, "thl-card", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "subtitle": { "alias": "subtitle"; "required": false; "isSignal": true; }; "shadow": { "alias": "shadow"; "required": false; "isSignal": true; }; "bordered": { "alias": "bordered"; "required": false; "isSignal": true; }; "flush": { "alias": "flush"; "required": false; "isSignal": true; }; }, {}, ["actions"], ["[thlCardMedia]", "[thlCardActions]", "*", "[thlCardFooter]"], true, never>;
+}
+declare class ThlPanelComponent {
+    private readonly cfg;
+    readonly prefix: _angular_core.Signal<string>;
+    readonly title: _angular_core.InputSignal<string | undefined>;
+    readonly color: _angular_core.InputSignal<string>;
+    readonly collapsible: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly collapsed: _angular_core.InputSignal<boolean | undefined>;
+    readonly dismissible: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly expandable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly loadingText: _angular_core.InputSignal<string | undefined>;
+    readonly collapsedChange: _angular_core.OutputEmitterRef<boolean>;
+    readonly dismissed: _angular_core.OutputEmitterRef<void>;
+    readonly inner: _angular_core.WritableSignal<boolean>;
+    readonly gone: _angular_core.WritableSignal<boolean>;
+    readonly full: _angular_core.WritableSignal<boolean>;
+    readonly isCollapsed: _angular_core.Signal<boolean>;
+    readonly b: (e: string) => string;
+    readonly cls: _angular_core.Signal<string>;
+    toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlPanelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlPanelComponent, "thl-panel", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "collapsible": { "alias": "collapsible"; "required": false; "isSignal": true; }; "collapsed": { "alias": "collapsed"; "required": false; "isSignal": true; }; "dismissible": { "alias": "dismissible"; "required": false; "isSignal": true; }; "expandable": { "alias": "expandable"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "loadingText": { "alias": "loadingText"; "required": false; "isSignal": true; }; }, { "collapsedChange": "collapsedChange"; "dismissed": "dismissed"; }, never, ["[thlPanelActions]", "*", "[thlPanelFooter]"], true, never>;
+}
+declare class ThlWellComponent {
+    private readonly cfg;
+    readonly size: _angular_core.InputSignal<"sm" | "lg" | undefined>;
+    readonly cls: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlWellComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlWellComponent, "thl-well", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class ThlRibbonComponent {
+    private readonly cfg;
+    readonly prefix: _angular_core.Signal<string>;
+    readonly text: _angular_core.InputSignal<string>;
+    readonly color: _angular_core.InputSignal<string>;
+    readonly variant: _angular_core.InputSignal<"default" | "badge" | "bookmark" | "corner" | "vertical-left" | "vertical-right">;
+    readonly position: _angular_core.InputSignal<"left" | "right">;
+    readonly placement: _angular_core.InputSignal<"top" | "bottom">;
+    private readonly vert;
+    readonly wrap: _angular_core.Signal<string>;
+    readonly rib: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlRibbonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlRibbonComponent, "thl-ribbon", never, { "text": { "alias": "text"; "required": true; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class ThlAlertComponent {
+    private readonly cfg;
+    readonly type: _angular_core.InputSignal<"default" | "red" | "purple" | "dark" | "success" | "info" | "warning" | "primary" | "danger" | "inverse">;
+    readonly title: _angular_core.InputSignal<string | undefined>;
+    readonly icon: _angular_core.InputSignal<string | boolean | undefined>;
+    readonly dismissible: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly soft: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly image: _angular_core.InputSignal<string | undefined>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    readonly open: _angular_core.WritableSignal<boolean>;
+    readonly b: (e: string) => string;
+    readonly role: _angular_core.Signal<"status" | "alert">;
+    readonly iconName: _angular_core.Signal<string | undefined>;
+    readonly cls: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlAlertComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlAlertComponent, "thl-alert", never, { "type": { "alias": "type"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "dismissible": { "alias": "dismissible"; "required": false; "isSignal": true; }; "soft": { "alias": "soft"; "required": false; "isSignal": true; }; "image": { "alias": "image"; "required": false; "isSignal": true; }; }, { "closed": "closed"; }, never, ["*"], true, never>;
+}
+
+declare class ThlModalComponent {
+    private readonly cfg;
+    private readonly host;
+    private readonly injector;
+    readonly open: _angular_core.ModelSignal<boolean>;
+    readonly title: _angular_core.InputSignal<string | undefined>;
+    readonly size: _angular_core.InputSignal<"sm" | "md" | "lg" | "xl" | "full" | undefined>;
+    readonly closeOnBackdrop: _angular_core.InputSignal<boolean | undefined>;
+    readonly closeOnEsc: _angular_core.InputSignal<boolean | undefined>;
+    readonly centered: _angular_core.InputSignal<boolean | undefined>;
+    readonly scrollable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly hideClose: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly modalClass: _angular_core.InputSignal<string | undefined>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    readonly dlg: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
+    readonly titleId: string;
+    readonly d: _angular_core.Signal<{
+        size?: "sm" | "md" | "lg";
+        closeOnBackdrop?: boolean;
+        closeOnEsc?: boolean;
+        centered?: boolean;
+    }>;
+    readonly b: (e: string) => string;
+    readonly backdropCls: _angular_core.Signal<string>;
+    readonly dialogCls: _angular_core.Signal<string>;
+    private release;
+    private onKey;
+    constructor();
+    private teardown;
+    onBackdrop(e: MouseEvent): void;
+    close(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlModalComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlModalComponent, "thl-modal", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "closeOnBackdrop": { "alias": "closeOnBackdrop"; "required": false; "isSignal": true; }; "closeOnEsc": { "alias": "closeOnEsc"; "required": false; "isSignal": true; }; "centered": { "alias": "centered"; "required": false; "isSignal": true; }; "scrollable": { "alias": "scrollable"; "required": false; "isSignal": true; }; "hideClose": { "alias": "hideClose"; "required": false; "isSignal": true; }; "modalClass": { "alias": "modalClass"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "closed": "closed"; }, never, ["[thlModalTitle]", "*", "[thlModalFooter]"], true, never>;
+}
+interface ConfirmOptions {
+    title?: string;
+    text?: string;
+    icon?: 'warning' | 'danger' | 'success' | 'info' | 'question';
+    confirmText?: string;
+    cancelText?: string;
+    confirmVariant?: ThlSemanticColor;
+    showCancel?: boolean;
+}
+declare class ThlModalService {
+    readonly state: _angular_core.WritableSignal<(ConfirmOptions & {
+        resolve: (v: boolean) => void;
+    }) | null>;
+    hosts: number;
+    confirm(opts?: ConfirmOptions): Promise<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlModalService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ThlModalService>;
+}
+declare class ThlConfirmHostComponent {
+    readonly svc: ThlModalService;
+    private readonly cfg;
+    readonly prefix: _angular_core.Signal<string>;
+    readonly ic: _angular_core.Signal<"success" | "info" | "warning" | "danger" | "question">;
+    readonly iconName: _angular_core.Signal<string>;
+    readonly iconCls: _angular_core.Signal<string>;
+    readonly confirmVariant: _angular_core.Signal<"default" | "red" | "purple" | "dark" | "success" | "info" | "warning" | "primary" | "danger" | "inverse">;
+    constructor();
+    done(v: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlConfirmHostComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlConfirmHostComponent, "thl-confirm-host", never, {}, {}, never, never, true, never>;
+}
+declare class ThlDrawerComponent {
+    private readonly cfg;
+    readonly prefix: _angular_core.Signal<string>;
+    readonly open: _angular_core.ModelSignal<boolean>;
+    readonly title: _angular_core.InputSignal<string | undefined>;
+    readonly side: _angular_core.InputSignal<"start" | "end">;
+    readonly wide: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly panel: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
+    readonly b: (e: string) => string;
+    readonly cls: _angular_core.Signal<string>;
+    private onKey;
+    constructor();
+    close(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlDrawerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlDrawerComponent, "thl-drawer", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; "wide": { "alias": "wide"; "required": false; "isSignal": true; }; }, { "open": "openChange"; }, never, ["*"], true, never>;
+}
+declare abstract class FloatingBase {
+    protected readonly cfg: ThlConfigService;
+    protected readonly host: ElementRef<any>;
+    readonly placement: _angular_core.InputSignal<Placement>;
+    readonly visible: _angular_core.WritableSignal<boolean>;
+    readonly pos: _angular_core.WritableSignal<{
+        top: string;
+        left: string;
+    }>;
+    readonly id: string;
+    readonly float: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
+    protected update: () => void;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FloatingBase, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FloatingBase, never, never, { "placement": { "alias": "placement"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class ThlTooltipComponent extends FloatingBase {
+    readonly content: _angular_core.InputSignal<string>;
+    readonly color: _angular_core.InputSignal<"default" | "red" | "purple" | "dark" | "success" | "info" | "warning" | "primary" | "danger" | "inverse" | undefined>;
+    readonly delay: _angular_core.InputSignal<number | undefined>;
+    private timer?;
+    readonly cls: _angular_core.Signal<string>;
+    show(): void;
+    hide(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlTooltipComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlTooltipComponent, "thl-tooltip", never, { "content": { "alias": "content"; "required": true; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "delay": { "alias": "delay"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class ThlPopoverComponent extends FloatingBase {
+    readonly placement: _angular_core.InputSignal<Placement>;
+    readonly title: _angular_core.InputSignal<string | undefined>;
+    readonly content: _angular_core.InputSignal<string | undefined>;
+    readonly contentTpl: _angular_core.InputSignal<TemplateRef<unknown> | undefined>;
+    readonly color: _angular_core.InputSignal<"default" | "red" | "purple" | "dark" | "success" | "info" | "warning" | "primary" | "danger" | "inverse" | undefined>;
+    readonly trigger: _angular_core.InputSignal<"click" | "hover">;
+    readonly b: (e: string) => string;
+    readonly cls: _angular_core.Signal<string>;
+    private off;
+    constructor();
+    toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlPopoverComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlPopoverComponent, "thl-popover", never, { "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "content": { "alias": "content"; "required": false; "isSignal": true; }; "contentTpl": { "alias": "contentTpl"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "trigger": { "alias": "trigger"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+interface DropdownItem {
+    key: string;
+    label?: string;
+    icon?: string;
+    href?: string;
+    disabled?: boolean;
+    danger?: boolean;
+    divider?: boolean;
+    header?: boolean;
+}
+declare class ThlDropdownComponent {
+    private readonly cfg;
+    private readonly host;
+    readonly prefix: _angular_core.Signal<string>;
+    readonly items: _angular_core.InputSignal<DropdownItem[]>;
+    readonly align: _angular_core.InputSignal<"start" | "end">;
+    readonly placement: _angular_core.InputSignal<"top" | "bottom">;
+    readonly menuClass: _angular_core.InputSignal<string | undefined>;
+    readonly animation: _angular_core.InputSignal<string | undefined>;
+    readonly selected: _angular_core.OutputEmitterRef<string>;
+    readonly open: _angular_core.WritableSignal<boolean>;
+    readonly hi: _angular_core.WritableSignal<number>;
+    readonly enabled: _angular_core.Signal<DropdownItem[]>;
+    readonly m: (e: string, mods?: Record<string, unknown>) => string;
+    readonly menuCls: _angular_core.Signal<string>;
+    itemCls(it: DropdownItem): string;
+    private off;
+    readonly menuId: string;
+    readonly trig: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
+    /** ARIA belongs on the actual trigger element (first projected child), not on the wrapper. */
+    private triggerEl;
+    constructor();
+    close(): void;
+    choose(it: DropdownItem): void;
+    onKey(e: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlDropdownComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlDropdownComponent, "thl-dropdown", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "menuClass": { "alias": "menuClass"; "required": false; "isSignal": true; }; "animation": { "alias": "animation"; "required": false; "isSignal": true; }; }, { "selected": "selected"; }, never, ["[thlDropdownTrigger]", "*"], true, never>;
+}
+declare class ThlToasterComponent {
+    readonly cfg: ThlConfigService;
+    readonly icons: Record<string, string>;
+    readonly groups: _angular_core.Signal<[string, _thl_ui_core.Toast[]][]>;
+    groupCls(pos: string): string;
+    toastCls(type: string): string;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlToasterComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlToasterComponent, "thl-toaster", never, {}, {}, never, never, true, never>;
+}
+declare class ThlProgressComponent {
+    private readonly cfg;
+    private readonly i18n;
+    readonly value: _angular_core.InputSignal<number>;
+    readonly max: _angular_core.InputSignal<number>;
+    readonly color: _angular_core.InputSignal<string>;
+    readonly size: _angular_core.InputSignal<"sm" | "md" | "lg" | "xs" | undefined>;
+    readonly striped: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
+    readonly animated: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
+    readonly vertical: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly label: _angular_core.InputSignal<string | boolean | undefined>;
+    readonly bar: string;
+    readonly d: _angular_core.Signal<{
+        size?: "sm" | "md" | "lg";
+        striped?: boolean;
+        animated?: boolean;
+    }>;
+    readonly pct: _angular_core.Signal<number>;
+    readonly text: _angular_core.Signal<string>;
+    readonly aria: _angular_core.Signal<string>;
+    readonly cls: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlProgressComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlProgressComponent, "thl-progress", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "striped": { "alias": "striped"; "required": false; "isSignal": true; }; "animated": { "alias": "animated"; "required": false; "isSignal": true; }; "vertical": { "alias": "vertical"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class ThlProgressCircleComponent {
+    readonly cfg: ThlConfigService;
+    readonly value: _angular_core.InputSignal<number>;
+    readonly max: _angular_core.InputSignal<number>;
+    readonly size: _angular_core.InputSignal<number>;
+    readonly stroke: _angular_core.InputSignal<number>;
+    readonly color: _angular_core.InputSignal<string>;
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    readonly i18n: ThlI18nService;
+    readonly r: _angular_core.Signal<number>;
+    readonly c: _angular_core.Signal<number>;
+    readonly pct: _angular_core.Signal<number>;
+    readonly b: (e?: string) => string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlProgressCircleComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlProgressCircleComponent, "thl-progress-circle", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "stroke": { "alias": "stroke"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/** <ng-template thlTab="key">…</ng-template> provides a tab panel. */
+declare class ThlTabPanelDirective {
+    readonly key: _angular_core.InputSignal<string>;
+    readonly tpl: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlTabPanelDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ThlTabPanelDirective, "ng-template[thlTab]", never, { "key": { "alias": "thlTab"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class ThlTabsComponent {
+    private readonly cfg;
+    readonly items: _angular_core.InputSignal<TabsItem[]>;
+    readonly active: _angular_core.ModelSignal<string | undefined>;
+    readonly variant: _angular_core.InputSignal<"default" | "vertical" | "underline" | "filled" | "pills" | "pills-rounded" | "line" | undefined>;
+    readonly justified: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly keepMounted: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly panels: _angular_core.Signal<readonly ThlTabPanelDirective[]>;
+    readonly list: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
+    private readonly baseId;
+    readonly api: {
+        state: _thl_ui_core.Store<string>;
+        active: () => string;
+        select: (key: string) => void;
+        setItems: (next: _thl_ui_core.TabsOptions["items"]) => void;
+        onKeyDown(e: {
+            key: string;
+            preventDefault(): void;
+        }, orientation?: "horizontal" | "vertical"): boolean;
+        ids: (base: string, key: string) => {
+            tab: string;
+            panel: string;
+        };
+    };
+    readonly current: _angular_core.Signal<string>;
+    readonly v: _angular_core.Signal<string>;
+    readonly vertical: _angular_core.Signal<boolean>;
+    readonly cls: _angular_core.Signal<string>;
+    readonly b: (e: string) => string;
+    constructor();
+    ids(k: string): {
+        tab: string;
+        panel: string;
+    };
+    tabCls(k: string): string;
+    onKey(e: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlTabsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlTabsComponent, "thl-tabs", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "active": { "alias": "active"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "justified": { "alias": "justified"; "required": false; "isSignal": true; }; "keepMounted": { "alias": "keepMounted"; "required": false; "isSignal": true; }; }, { "active": "activeChange"; }, ["panels"], never, true, never>;
+}
+declare class ThlBreadcrumbComponent {
+    private readonly cfg;
+    readonly items: _angular_core.InputSignal<BreadcrumbItem[]>;
+    readonly b: (e?: string) => string;
+    itemCls(last: boolean): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlBreadcrumbComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlBreadcrumbComponent, "thl-breadcrumb", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class ThlPaginationComponent {
+    readonly cfg: ThlConfigService;
+    readonly page: _angular_core.ModelSignal<number>;
+    readonly pageSize: _angular_core.ModelSignal<number>;
+    readonly total: _angular_core.InputSignal<number>;
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    readonly maxPages: _angular_core.InputSignal<number | undefined>;
+    readonly size: _angular_core.InputSignal<"sm" | "md" | "lg" | undefined>;
+    readonly showTotal: _angular_core.InputSignal<boolean | undefined>;
+    readonly showFirstLast: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly split: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly rounded: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly pageSizes: _angular_core.InputSignal<number[] | undefined>;
+    readonly d: _angular_core.Signal<{
+        maxPages?: number;
+        showTotal?: boolean;
+    }>;
+    readonly showTotalD: _angular_core.Signal<boolean>;
+    readonly m: _angular_core.Signal<{
+        page: number;
+        pageCount: number;
+        items: _thl_ui_core.PageItem[];
+        from: number;
+        to: number;
+        hasPrev: boolean;
+        hasNext: boolean;
+    }>;
+    readonly b: (e?: string, mods?: Record<string, unknown>) => string;
+    readonly listCls: _angular_core.Signal<string>;
+    pageCls(active: boolean): string;
+    go(p: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlPaginationComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlPaginationComponent, "thl-pagination", never, { "page": { "alias": "page"; "required": true; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "total": { "alias": "total"; "required": true; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "maxPages": { "alias": "maxPages"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "showTotal": { "alias": "showTotal"; "required": false; "isSignal": true; }; "showFirstLast": { "alias": "showFirstLast"; "required": false; "isSignal": true; }; "split": { "alias": "split"; "required": false; "isSignal": true; }; "rounded": { "alias": "rounded"; "required": false; "isSignal": true; }; "pageSizes": { "alias": "pageSizes"; "required": false; "isSignal": true; }; }, { "page": "pageChange"; "pageSize": "pageSizeChange"; }, never, never, true, never>;
+}
+declare class ThlStepsComponent {
+    readonly cfg: ThlConfigService;
+    readonly items: _angular_core.InputSignal<StepItem[]>;
+    readonly current: _angular_core.ModelSignal<number>;
+    readonly variant: _angular_core.InputSignal<"default" | "line" | "no-bg" | "thin">;
+    readonly clickable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly vertical: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly b: (e: string) => string;
+    readonly cls: _angular_core.Signal<string>;
+    status(i: number): "done" | "active" | "pending";
+    itemCls(i: number): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlStepsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlStepsComponent, "thl-steps", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "current": { "alias": "current"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "clickable": { "alias": "clickable"; "required": false; "isSignal": true; }; "vertical": { "alias": "vertical"; "required": false; "isSignal": true; }; }, { "current": "currentChange"; }, never, never, true, never>;
+}
+declare class ThlTimelineComponent {
+    private readonly cfg;
+    readonly items: _angular_core.InputSignal<TimelineItem[]>;
+    readonly variant: _angular_core.InputSignal<"left" | "alternate">;
+    /** heading level of item titles (match the surrounding outline) */
+    readonly headingLevel: _angular_core.InputSignal<2 | 3 | 4 | 5 | 6>;
+    readonly b: (e: string, m?: Record<string, unknown>) => string;
+    readonly cls: _angular_core.Signal<string>;
+    badgeCls(c?: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlTimelineComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlTimelineComponent, "thl-timeline", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "headingLevel": { "alias": "headingLevel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class ThlActivityFeedComponent {
+    readonly cfg: ThlConfigService;
+    readonly items: _angular_core.InputSignal<{
+        avatar?: string;
+        icon?: string;
+        title: string;
+        time?: string;
+        content?: string;
+        color?: string;
+    }[]>;
+    readonly b: (e?: string) => string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlActivityFeedComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlActivityFeedComponent, "thl-activity-feed", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class ThlHorizontalTimelineComponent {
+    private readonly cfg;
+    readonly items: _angular_core.InputSignal<{
+        date: string;
+        title: string;
+        content?: string;
+    }[]>;
+    readonly headingLevel: _angular_core.InputSignal<2 | 3 | 4 | 5 | 6>;
+    readonly i: _angular_core.WritableSignal<number>;
+    readonly btn: string;
+    readonly b: (e?: string) => string;
+    dotCls(k: number): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlHorizontalTimelineComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlHorizontalTimelineComponent, "thl-horizontal-timeline", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "headingLevel": { "alias": "headingLevel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class ThlCarouselComponent {
+    private readonly cfg;
+    readonly slides: _angular_core.InputSignal<{
+        image?: string;
+        caption?: string;
+        alt?: string;
+    }[]>;
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    readonly i18n: ThlI18nService;
+    readonly interval: _angular_core.InputSignal<number>;
+    readonly fade: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly arrows: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly dots: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly height: _angular_core.InputSignal<string | undefined>;
+    readonly api: {
+        state: _thl_ui_core.Store<number>;
+        index: () => number;
+        next: () => void;
+        prev: () => void;
+        goTo: (i: number) => void;
+        setCount: (n: number) => void;
+        play(): void;
+        pause(): void;
+        destroy(): void;
+    };
+    readonly idx: _angular_core.Signal<number>;
+    readonly b: (e?: string, m?: Record<string, unknown>) => string;
+    readonly cls: _angular_core.Signal<string>;
+    slideCls(i: number): string;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlCarouselComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlCarouselComponent, "thl-carousel", never, { "slides": { "alias": "slides"; "required": true; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "interval": { "alias": "interval"; "required": false; "isSignal": true; }; "fade": { "alias": "fade"; "required": false; "isSignal": true; }; "arrows": { "alias": "arrows"; "required": false; "isSignal": true; }; "dots": { "alias": "dots"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** Base for components implementing ControlValueAccessor with a `value` model signal. */
+declare abstract class CvaBase<T> implements ControlValueAccessor {
+    abstract readonly value: ReturnType<typeof model<T>>;
+    readonly disabledByForm: _angular_core.WritableSignal<boolean>;
+    protected onChange: (v: T) => void;
+    protected onTouched: () => void;
+    writeValue(v: T): void;
+    registerOnChange(fn: (v: T) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(d: boolean): void;
+    protected emit(v: T): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CvaBase<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CvaBase<any>, never, never, {}, {}, never, never, true, never>;
+}
+/** Adapt thl-ui core rules (returning i18n keys) to Angular ValidatorFn: `new FormControl('', thlValidators(rules.required(), rules.email()))` */
+declare function thlValidators(...list: Rule[]): ValidatorFn;
+declare class ThlFieldComponent {
+    private readonly cfg;
+    private readonly i18n;
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    readonly help: _angular_core.InputSignal<string | undefined>;
+    readonly error: _angular_core.InputSignal<string | undefined>;
+    readonly for: _angular_core.InputSignal<string | undefined>;
+    readonly required: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly status: _angular_core.InputSignal<"success" | "warning" | "error" | undefined>;
+    /** Reactive-forms control: shows localized error from thlValidators / built-in validators once touched. */
+    readonly control: _angular_core.InputSignal<AbstractControl<any, any, any> | null | undefined>;
+    private readonly tick;
+    readonly id: string;
+    private readonly lab;
+    private readonly box;
+    constructor();
+    readonly errorText: _angular_core.Signal<string | undefined>;
+    readonly b: (e: string) => string;
+    readonly cls: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlFieldComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlFieldComponent, "thl-field", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "help": { "alias": "help"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "for": { "alias": "for"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; "control": { "alias": "control"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class ThlInputDirective {
+    private readonly cfg;
+    private readonly el;
+    readonly size: _angular_core.InputSignal<"sm" | "md" | "lg" | undefined>;
+    readonly variant: _angular_core.InputSignal<"default" | "line" | "material" | undefined>;
+    readonly rounded: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly cls: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlInputDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ThlInputDirective, "input[thlInput], textarea[thlInput], select[thlInput]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "rounded": { "alias": "rounded"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class ThlInputGroupComponent {
+    readonly cfg: ThlConfigService;
+    readonly prepend: _angular_core.InputSignal<string | undefined>;
+    readonly append: _angular_core.InputSignal<string | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlInputGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlInputGroupComponent, "thl-input-group", never, { "prepend": { "alias": "prepend"; "required": false; "isSignal": true; }; "append": { "alias": "append"; "required": false; "isSignal": true; }; }, {}, never, ["[thlPrepend]", "*", "[thlAppend]"], true, never>;
+}
+declare class ThlCheckboxComponent extends CvaBase<boolean> {
+    private readonly cfg;
+    readonly value: _angular_core.ModelSignal<boolean>;
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    readonly color: _angular_core.InputSignal<string | undefined>;
+    readonly skin: _angular_core.InputSignal<"default" | "flat" | "circle" | "square">;
+    readonly indeterminate: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    readonly changed: _angular_core.OutputEmitterRef<boolean>;
+    readonly box: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
+    readonly lid: string;
+    constructor();
+    /** host is not a <label>: clicking the text toggles like a native label would */
+    onHostClick(e: MouseEvent): void;
+    readonly b: (e: string) => string;
+    readonly cls: _angular_core.Signal<string>;
+    toggle(c: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlCheckboxComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlCheckboxComponent, "thl-checkbox", never, { "value": { "alias": "checked"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "skin": { "alias": "skin"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "value": "checkedChange"; "changed": "changed"; }, never, ["*"], true, never>;
+}
+declare class ThlRadioGroupComponent extends CvaBase<unknown> {
+    private readonly cfg;
+    readonly value: _angular_core.ModelSignal<unknown>;
+    readonly options: _angular_core.InputSignal<{
+        label: string;
+        value: unknown;
+        disabled?: boolean;
+    }[]>;
+    readonly color: _angular_core.InputSignal<string | undefined>;
+    readonly vertical: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly name: string;
+    readonly b: (e: string) => string;
+    readonly cls: _angular_core.Signal<string>;
+    itemCls(dis?: boolean): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlRadioGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlRadioGroupComponent, "thl-radio-group", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": true; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "vertical": { "alias": "vertical"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+declare class ThlCheckboxGroupComponent extends CvaBase<unknown[] | null> {
+    private readonly cfg;
+    /** null when a FormControl is reset without a default */
+    readonly value: _angular_core.ModelSignal<unknown[] | null>;
+    readonly options: _angular_core.InputSignal<{
+        label: string;
+        value: unknown;
+        disabled?: boolean;
+    }[]>;
+    readonly color: _angular_core.InputSignal<string | undefined>;
+    readonly vertical: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly b: (e: string) => string;
+    readonly cls: _angular_core.Signal<string>;
+    itemCls(dis?: boolean): string;
+    toggle(v: unknown, c: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlCheckboxGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlCheckboxGroupComponent, "thl-checkbox-group", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": true; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "vertical": { "alias": "vertical"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+declare class ThlSwitchComponent extends CvaBase<boolean> {
+    private readonly cfg;
+    readonly value: _angular_core.ModelSignal<boolean>;
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    readonly color: _angular_core.InputSignal<string | undefined>;
+    readonly size: _angular_core.InputSignal<"sm" | "md" | "lg">;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly lid: string;
+    readonly box: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
+    onHostClick(e: MouseEvent): void;
+    readonly b: (e: string) => string;
+    readonly cls: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlSwitchComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlSwitchComponent, "thl-switch", never, { "value": { "alias": "checked"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "value": "checkedChange"; }, never, never, true, never>;
+}
+declare class ThlNumberInputComponent extends CvaBase<number | null> {
+    readonly cfg: ThlConfigService;
+    readonly value: _angular_core.ModelSignal<number | null>;
+    readonly min: _angular_core.InputSignal<number | undefined>;
+    readonly max: _angular_core.InputSignal<number | undefined>;
+    readonly stepSize: _angular_core.InputSignal<number>;
+    readonly prefix: _angular_core.InputSignal<string | undefined>;
+    readonly suffix: _angular_core.InputSignal<string | undefined>;
+    readonly inputId: _angular_core.InputSignal<string | undefined>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly dis: _angular_core.Signal<boolean>;
+    readonly b: (e: string) => string;
+    step(d: 1 | -1): void;
+    onInput(s: string): void;
+    onBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlNumberInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlNumberInputComponent, "thl-number-input", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "stepSize": { "alias": "step"; "required": false; "isSignal": true; }; "prefix": { "alias": "prefix"; "required": false; "isSignal": true; }; "suffix": { "alias": "suffix"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+declare class ThlSliderComponent extends CvaBase<number | [number, number]> {
+    private readonly cfg;
+    readonly value: _angular_core.ModelSignal<number | [number, number]>;
+    readonly min: _angular_core.InputSignal<number>;
+    readonly max: _angular_core.InputSignal<number>;
+    readonly step: _angular_core.InputSignal<number>;
+    readonly color: _angular_core.InputSignal<string | undefined>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly showTip: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly showScale: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly format: _angular_core.InputSignal<(n: number) => string>;
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    private readonly i18n;
+    thumbLabel(i: number): string;
+    readonly rail: _angular_core.Signal<ElementRef<HTMLElement>>;
+    readonly dis: _angular_core.Signal<boolean>;
+    readonly vals: _angular_core.Signal<number[]>;
+    readonly lo: _angular_core.Signal<number>;
+    readonly hi: _angular_core.Signal<number>;
+    readonly mid: _angular_core.Signal<number>;
+    readonly b: (e: string) => string;
+    readonly cls: _angular_core.Signal<string>;
+    pct(v: number): number;
+    fmt(v: number): string;
+    private fromX;
+    private update;
+    railDown(e: PointerEvent): void;
+    drag(i: number, e: PointerEvent): void;
+    key(i: number, v: number, e: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlSliderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlSliderComponent, "thl-slider", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "showTip": { "alias": "showTip"; "required": false; "isSignal": true; }; "showScale": { "alias": "showScale"; "required": false; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+declare class ThlSelectComponent extends CvaBase<unknown> {
+    readonly cfg: ThlConfigService;
+    private readonly i18n;
+    private readonly host;
+    readonly value: _angular_core.ModelSignal<unknown>;
+    readonly options: _angular_core.InputSignal<SelectOption<any>[]>;
+    readonly multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly searchable: _angular_core.InputSignal<boolean | undefined>;
+    readonly clearable: _angular_core.InputSignal<boolean | undefined>;
+    readonly creatable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly placeholder: _angular_core.InputSignal<string | undefined>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly inputId: _angular_core.InputSignal<string | undefined>;
+    readonly search: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
+    readonly listId: string;
+    readonly api: {
+        state: _thl_ui_core.Store<{
+            open: boolean;
+            query: string;
+            highlighted: number;
+            value: any;
+        }>;
+        filtered: () => SelectOption<any>[];
+        isSelected: (v: any) => boolean;
+        configure(patch: {
+            multiple?: boolean;
+            creatable?: boolean;
+            max?: number;
+            onChange?: ((v: any) => void) | undefined;
+        }): void;
+        setOptions(next: SelectOption<any>[]): void;
+        selectedOptions: () => SelectOption<any>[];
+        open: () => void;
+        close: () => void;
+        toggle: () => void;
+        setQuery: (query: string) => void;
+        setValue(v: any): void;
+        select(v: any): void;
+        remove(v: any): void;
+        clear(): void;
+        create(): void;
+        onKeyDown(e: {
+            key: string;
+            preventDefault(): void;
+        }): boolean;
+    };
+    readonly st: _angular_core.Signal<{
+        open: boolean;
+        query: string;
+        highlighted: number;
+        value: any;
+    }>;
+    readonly dis: _angular_core.Signal<boolean>;
+    readonly d: _angular_core.Signal<{
+        searchable?: boolean;
+        clearable?: boolean;
+    }>;
+    readonly canType: _angular_core.Signal<boolean>;
+    readonly clearableD: _angular_core.Signal<boolean>;
+    readonly ph: _angular_core.Signal<string>;
+    readonly selected: _angular_core.Signal<SelectOption<any>[]>;
+    readonly filtered: _angular_core.Signal<SelectOption<any>[]>;
+    readonly b: (e: string) => string;
+    readonly cls: _angular_core.Signal<string>;
+    readonly ctrlCls: _angular_core.Signal<string>;
+    optCls(o: SelectOption<any>, i: number): string;
+    private off;
+    constructor();
+    openIt(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlSelectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlSelectComponent, "thl-select", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": true; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "searchable": { "alias": "searchable"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "creatable": { "alias": "creatable"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+declare abstract class PopBase {
+    protected readonly host: ElementRef<any>;
+    readonly open: _angular_core.WritableSignal<boolean>;
+    private off;
+    private onKey;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PopBase, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PopBase, never, never, {}, {}, never, never, true, never>;
+}
+declare class ThlCalendarGridComponent {
+    private readonly cfg;
+    private readonly i18n;
+    readonly month: _angular_core.InputSignal<Date>;
+    readonly selected: _angular_core.InputSignal<Date | null | undefined>;
+    readonly rangeStart: _angular_core.InputSignal<Date | null | undefined>;
+    readonly rangeEnd: _angular_core.InputSignal<Date | null | undefined>;
+    readonly hover: _angular_core.InputSignal<Date | null | undefined>;
+    readonly min: _angular_core.InputSignal<Date | null | undefined>;
+    readonly max: _angular_core.InputSignal<Date | null | undefined>;
+    readonly monthChange: _angular_core.OutputEmitterRef<Date>;
+    readonly pick: _angular_core.OutputEmitterRef<Date>;
+    readonly hoverDay: _angular_core.OutputEmitterRef<Date>;
+    readonly ws: _angular_core.Signal<0 | 1>;
+    readonly names: _angular_core.Signal<string[]>;
+    readonly weeks: _angular_core.Signal<_thl_ui_core.DayCell[][]>;
+    readonly title: _angular_core.Signal<string>;
+    readonly b: (e?: string) => string;
+    shift(n: number): Date;
+    full(d: Date): string;
+    isDis(d: Date): boolean;
+    isSel(d: Date): boolean;
+    dayCls(c: {
+        date: Date;
+        inMonth: boolean;
+        today: boolean;
+    }): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlCalendarGridComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlCalendarGridComponent, "thl-calendar-grid", never, { "month": { "alias": "month"; "required": true; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "rangeStart": { "alias": "rangeStart"; "required": false; "isSignal": true; }; "rangeEnd": { "alias": "rangeEnd"; "required": false; "isSignal": true; }; "hover": { "alias": "hover"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; }, { "monthChange": "monthChange"; "pick": "pick"; "hoverDay": "hoverDay"; }, never, never, true, never>;
+}
+declare class ThlDatePickerComponent extends PopBase implements ControlValueAccessor {
+    readonly cfg: ThlConfigService;
+    private readonly i18n;
+    readonly value: _angular_core.ModelSignal<string | null>;
+    readonly placeholder: _angular_core.InputSignal<string | undefined>;
+    readonly min: _angular_core.InputSignal<string | undefined>;
+    readonly max: _angular_core.InputSignal<string | undefined>;
+    readonly inputId: _angular_core.InputSignal<string | undefined>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly clearable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabledByForm: _angular_core.WritableSignal<boolean>;
+    readonly dis: _angular_core.Signal<boolean>;
+    readonly date: _angular_core.Signal<Date | null>;
+    readonly minD: _angular_core.Signal<Date | null>;
+    readonly maxD: _angular_core.Signal<Date | null>;
+    readonly month: _angular_core.WritableSignal<Date>;
+    readonly display: _angular_core.Signal<string>;
+    onChange: (v: string | null) => void;
+    onTouched: () => void;
+    constructor();
+    today(): Date;
+    emit(v: string | null): void;
+    choose(d: Date): void;
+    writeValue(v: string | null): void;
+    registerOnChange(fn: (v: string | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(d: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlDatePickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlDatePickerComponent, "thl-date-picker", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+declare class ThlDateRangePickerComponent extends PopBase implements ControlValueAccessor {
+    readonly cfg: ThlConfigService;
+    private readonly i18n;
+    readonly value: _angular_core.ModelSignal<[string | null, string | null]>;
+    readonly presets: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly ranges: [string, [Date, Date]][];
+    readonly start: _angular_core.Signal<Date | null>;
+    readonly end: _angular_core.Signal<Date | null>;
+    readonly month: _angular_core.WritableSignal<Date>;
+    readonly next: _angular_core.Signal<Date>;
+    readonly pending: _angular_core.WritableSignal<Date | null>;
+    readonly hover: _angular_core.WritableSignal<Date | null>;
+    readonly display: _angular_core.Signal<string>;
+    onChange: (v: [string | null, string | null]) => void;
+    prev(d: Date): Date;
+    isPreset(r: [Date, Date]): boolean;
+    set(a: Date, b: Date): void;
+    pick(d: Date): void;
+    writeValue(v: [string | null, string | null]): void;
+    registerOnChange(fn: (v: [string | null, string | null]) => void): void;
+    registerOnTouched(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlDateRangePickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlDateRangePickerComponent, "thl-date-range-picker", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "presets": { "alias": "presets"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+declare class ThlTimePickerComponent extends PopBase implements ControlValueAccessor {
+    readonly cfg: ThlConfigService;
+    private readonly i18n;
+    readonly value: _angular_core.ModelSignal<string | null>;
+    readonly step: _angular_core.InputSignal<number>;
+    readonly hours: number[];
+    readonly minutes: _angular_core.Signal<number[]>;
+    readonly hh: _angular_core.Signal<number | null>;
+    readonly mm: _angular_core.Signal<number | null>;
+    readonly display: _angular_core.Signal<string>;
+    onChange: (v: string | null) => void;
+    pad(n: number): string;
+    set(h: number, m: number): void;
+    now(): void;
+    writeValue(v: string | null): void;
+    registerOnChange(fn: (v: string | null) => void): void;
+    registerOnTouched(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlTimePickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlTimePickerComponent, "thl-time-picker", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+declare class ThlColorPickerComponent extends PopBase implements ControlValueAccessor {
+    readonly cfg: ThlConfigService;
+    readonly value: _angular_core.ModelSignal<string>;
+    readonly palette: _angular_core.InputSignal<string[]>;
+    onChange: (v: string) => void;
+    emit(v: string): void;
+    writeValue(v: string): void;
+    registerOnChange(fn: (v: string) => void): void;
+    registerOnTouched(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlColorPickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlColorPickerComponent, "thl-color-picker", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "palette": { "alias": "palette"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+declare class ThlUploadComponent {
+    readonly cfg: ThlConfigService;
+    private readonly i18n;
+    readonly accept: _angular_core.InputSignal<string | undefined>;
+    readonly maxSize: _angular_core.InputSignal<number | undefined>;
+    readonly multiple: _angular_core.InputSignal<boolean | undefined>;
+    readonly maxFiles: _angular_core.InputSignal<number | undefined>;
+    readonly request: _angular_core.InputSignal<((file: File, onProgress: (p: number) => void) => Promise<unknown>) | undefined>;
+    readonly variant: _angular_core.InputSignal<"list" | "single">;
+    readonly hint: _angular_core.InputSignal<string | undefined>;
+    readonly filesChange: _angular_core.OutputEmitterRef<UploadFile[]>;
+    readonly multi: _angular_core.Signal<boolean>;
+    readonly api: {
+        state: _thl_ui_core.Store<{
+            files: UploadFile[];
+            dragging: boolean;
+            errors: Array<{
+                key: string;
+                params: Record<string, string>;
+            }>;
+        }>;
+        configure(patch: Partial<_thl_ui_core.UploadOptions>): void;
+        add(list: FileList | File[]): UploadFile[];
+        remove(id: string): void;
+        clear(): void;
+        upload: (id: string) => Promise<void>;
+        uploadAll: () => Promise<void[]>;
+        dragHandlers: {
+            onDragEnter: (e: DragEvent) => void;
+            onDragOver: (e: DragEvent) => void;
+            onDragLeave: (e: DragEvent) => void;
+            onDrop: (e: DragEvent) => void;
+        };
+    };
+    readonly st: _angular_core.Signal<{
+        files: UploadFile[];
+        dragging: boolean;
+        errors: Array<{
+            key: string;
+            params: Record<string, string>;
+        }>;
+    }>;
+    readonly single: _angular_core.Signal<UploadFile | undefined>;
+    readonly b: (e?: string) => string;
+    readonly zoneCls: _angular_core.Signal<string>;
+    constructor();
+    fileCls(f: UploadFile): string;
+    size(n: number): string;
+    status(f: UploadFile): string;
+    onFiles(el: HTMLInputElement): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlUploadComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlUploadComponent, "thl-upload", never, { "accept": { "alias": "accept"; "required": false; "isSignal": true; }; "maxSize": { "alias": "maxSize"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "maxFiles": { "alias": "maxFiles"; "required": false; "isSignal": true; }; "request": { "alias": "request"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; }, { "filesChange": "filesChange"; }, never, never, true, never>;
+}
+declare class ThlEditorComponent extends CvaBase<string> {
+    private readonly cfg;
+    readonly value: _angular_core.ModelSignal<string>;
+    readonly placeholder: _angular_core.InputSignal<string | undefined>;
+    readonly minHeight: _angular_core.InputSignal<number | undefined>;
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    readonly area: _angular_core.Signal<ElementRef<HTMLElement>>;
+    readonly tools: Array<[string, string, string?]>;
+    readonly b: (e?: string) => string;
+    constructor();
+    cmd(c: string, arg?: string): void;
+    onInput(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlEditorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlEditorComponent, "thl-editor", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "minHeight": { "alias": "minHeight"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+declare class ThlTableDirective {
+    private readonly cfg;
+    readonly striped: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly hover: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly bordered: _angular_core.InputSignal<string | boolean | undefined>;
+    readonly compact: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly color: _angular_core.InputSignal<string | undefined>;
+    readonly full: _angular_core.InputSignal<string | undefined>;
+    readonly cls: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlTableDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ThlTableDirective, "table[thlTable]", never, { "striped": { "alias": "striped"; "required": false; "isSignal": true; }; "hover": { "alias": "hover"; "required": false; "isSignal": true; }; "bordered": { "alias": "bordered"; "required": false; "isSignal": true; }; "compact": { "alias": "compact"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "full": { "alias": "full"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/** <ng-template thlCell="name" let-row let-value="value">…</ng-template> */
+declare class ThlCellDirective {
+    readonly key: _angular_core.InputSignal<string>;
+    readonly tpl: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlCellDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ThlCellDirective, "ng-template[thlCell]", never, { "key": { "alias": "thlCell"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class ThlDataTableComponent {
+    private readonly cfg;
+    readonly p: _angular_core.Signal<string>;
+    readonly data: _angular_core.InputSignal<any[]>;
+    readonly columns: _angular_core.InputSignal<ColumnDef<any>[]>;
+    readonly rowKey: _angular_core.InputSignal<string | ((r: any) => string | number) | undefined>;
+    readonly pageSize: _angular_core.InputSignal<number | undefined>;
+    readonly paginate: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly searchable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly selectable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly striped: _angular_core.InputSignal<boolean | undefined>;
+    readonly hover: _angular_core.InputSignal<boolean | undefined>;
+    readonly bordered: _angular_core.InputSignal<boolean | undefined>;
+    readonly compact: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly stack: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly color: _angular_core.InputSignal<"default" | "red" | "purple" | "dark" | "success" | "info" | "warning" | "primary" | "danger" | "inverse" | undefined>;
+    readonly emptyText: _angular_core.InputSignal<string | undefined>;
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly selectionChange: _angular_core.OutputEmitterRef<any[]>;
+    readonly cellEdit: _angular_core.OutputEmitterRef<{
+        rowKey: string | number;
+        key: string;
+        value: unknown;
+        data: any[];
+    }>;
+    readonly cells: _angular_core.Signal<readonly ThlCellDirective[]>;
+    readonly api: {
+        state: _thl_ui_core.Store<_thl_ui_core.TableState>;
+        columns: () => ColumnDef<any>[];
+        setData(next: any[]): void;
+        setColumns(next: ColumnDef<any>[]): void;
+        view(): {
+            rows: {
+                row: any;
+                key: string | number;
+            }[];
+            total: number;
+            page: number;
+            pageSize: number;
+            pageCount: number;
+        };
+        value: (c: ColumnDef<any>, row: any) => any;
+        toggleSort(key: string): void;
+        sortDir: (key: string) => _thl_ui_core.SortDir | null;
+        setSearch: (search: string) => void;
+        setFilter: (key: string, value: unknown) => void;
+        setPage: (page: number) => void;
+        setPageSize: (pageSize: number) => void;
+        isSelected: (k: string | number) => boolean;
+        toggleRow(k: string | number): void;
+        toggleAll(): void;
+        allSelected(): boolean | "indeterminate";
+        selectedRows: () => any[];
+        updateCell(rowKey: string | number, colKey: string, value: unknown): any[];
+    };
+    readonly st: _angular_core.Signal<_thl_ui_core.TableState>;
+    readonly view: _angular_core.Signal<{
+        rows: {
+            row: any;
+            key: string | number;
+        }[];
+        total: number;
+        page: number;
+        pageSize: number;
+        pageCount: number;
+    }>;
+    readonly total: _angular_core.Signal<number>;
+    readonly from: _angular_core.Signal<number>;
+    readonly to: _angular_core.Signal<number>;
+    readonly all: _angular_core.Signal<boolean | "indeterminate">;
+    readonly d: _angular_core.Signal<{
+        striped?: boolean;
+        hover?: boolean;
+        bordered?: boolean;
+        pageSize?: number;
+        pageSizes?: number[];
+    }>;
+    private readonly i18n;
+    readonly showParts: _angular_core.Signal<string[]>;
+    readonly sizes: _angular_core.Signal<number[]>;
+    readonly b: (e?: string) => string;
+    readonly tableCls: _angular_core.Signal<string>;
+    readonly editing: _angular_core.WritableSignal<{
+        row: string | number;
+        key: string;
+        value: string;
+    } | null>;
+    private sizeInit;
+    constructor();
+    tpl(key: string): TemplateRef<any> | undefined;
+    hide(c: ColumnDef): string;
+    ariaSort(k: string): "ascending" | "descending" | null;
+    sortCls(k: string): string;
+    isEditing(r: string | number, k: string): boolean;
+    startEdit(r: string | number, k: string, row: any): void;
+    editValue(v: string): void;
+    commit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlDataTableComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlDataTableComponent, "thl-data-table", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; "columns": { "alias": "columns"; "required": true; "isSignal": true; }; "rowKey": { "alias": "rowKey"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "paginate": { "alias": "paginate"; "required": false; "isSignal": true; }; "searchable": { "alias": "searchable"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "striped": { "alias": "striped"; "required": false; "isSignal": true; }; "hover": { "alias": "hover"; "required": false; "isSignal": true; }; "bordered": { "alias": "bordered"; "required": false; "isSignal": true; }; "compact": { "alias": "compact"; "required": false; "isSignal": true; }; "stack": { "alias": "stack"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "emptyText": { "alias": "emptyText"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, { "selectionChange": "selectionChange"; "cellEdit": "cellEdit"; }, ["cells"], ["[thlToolbar]"], true, never>;
+}
+declare class ThlListComponent {
+    private readonly cfg;
+    readonly p: _angular_core.Signal<string>;
+    readonly items: _angular_core.InputSignal<{
+        avatar?: string;
+        icon?: string;
+        iconColor?: string;
+        title: string;
+        description?: string;
+        meta?: string;
+    }[]>;
+    readonly hover: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly itemClick: _angular_core.OutputEmitterRef<any>;
+    readonly b: (e: string) => string;
+    readonly cls: _angular_core.Signal<string>;
+    iconCls(c?: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlListComponent, "thl-list", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "hover": { "alias": "hover"; "required": false; "isSignal": true; }; }, { "itemClick": "itemClick"; }, never, never, true, never>;
+}
+declare class ThlGalleryComponent {
+    private readonly cfg;
+    readonly images: _angular_core.InputSignal<{
+        src: string;
+        thumb?: string;
+        alt?: string;
+        caption?: string;
+    }[]>;
+    readonly idx: _angular_core.WritableSignal<number | null>;
+    readonly g: (e?: string) => string;
+    readonly l: (e?: string) => string;
+    move(d: number): void;
+    onKey(e: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlGalleryComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlGalleryComponent, "thl-gallery", never, { "images": { "alias": "images"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class ThlInfoBoxComponent {
+    private readonly cfg;
+    readonly icon: _angular_core.InputSignal<string | undefined>;
+    readonly value: _angular_core.InputSignal<string | number | undefined>;
+    readonly title: _angular_core.InputSignal<string | undefined>;
+    readonly color: _angular_core.InputSignal<string>;
+    readonly filled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly soft: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly b: (e: string) => string;
+    readonly cls: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlInfoBoxComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlInfoBoxComponent, "thl-info-box", never, { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "filled": { "alias": "filled"; "required": false; "isSignal": true; }; "soft": { "alias": "soft"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class ThlStatBoxComponent {
+    private readonly cfg;
+    readonly title: _angular_core.InputSignal<string | undefined>;
+    readonly value: _angular_core.InputSignal<string | number | undefined>;
+    readonly icon: _angular_core.InputSignal<string | undefined>;
+    readonly color: _angular_core.InputSignal<string>;
+    readonly trend: _angular_core.InputSignal<"up" | "down">;
+    readonly delta: _angular_core.InputSignal<string | undefined>;
+    readonly progress: _angular_core.InputSignal<number | undefined>;
+    readonly b: (e: string) => string;
+    readonly cls: _angular_core.Signal<string>;
+    readonly deltaCls: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlStatBoxComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlStatBoxComponent, "thl-stat-box", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "trend": { "alias": "trend"; "required": false; "isSignal": true; }; "delta": { "alias": "delta"; "required": false; "isSignal": true; }; "progress": { "alias": "progress"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class ThlColorBoxComponent {
+    private readonly cfg;
+    readonly color: _angular_core.InputSignal<string>;
+    readonly icon: _angular_core.InputSignal<string | undefined>;
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    readonly value: _angular_core.InputSignal<string | number | undefined>;
+    readonly b: (e: string) => string;
+    readonly cls: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlColorBoxComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlColorBoxComponent, "thl-color-box", never, { "color": { "alias": "color"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class ThlStatsRowComponent {
+    private readonly cfg;
+    readonly items: _angular_core.InputSignal<{
+        label: string;
+        value: string | number;
+    }[]>;
+    readonly b: (e?: string) => string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlStatsRowComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlStatsRowComponent, "thl-stats-row", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+interface PricingPlanData {
+    name: string;
+    price: string | number;
+    currency?: string;
+    period?: string;
+    features: Array<{
+        icon?: string;
+        text: string;
+    }>;
+    featured?: boolean;
+    tag?: string;
+    cta?: string;
+    ctaVariant?: string;
+}
+declare class ThlPricingTableComponent {
+    readonly cfg: ThlConfigService;
+    readonly plans: _angular_core.InputSignal<PricingPlanData[]>;
+    readonly selected: _angular_core.OutputEmitterRef<PricingPlanData>;
+    readonly b: (e: string) => string;
+    planCls(f?: boolean): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlPricingTableComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlPricingTableComponent, "thl-pricing-table", never, { "plans": { "alias": "plans"; "required": true; "isSignal": true; }; }, { "selected": "selected"; }, never, never, true, never>;
+}
+declare class ThlUserCardComponent {
+    private readonly cfg;
+    readonly image: _angular_core.InputSignal<string>;
+    readonly name: _angular_core.InputSignal<string | undefined>;
+    readonly subtitle: _angular_core.InputSignal<string | undefined>;
+    readonly b: (e?: string) => string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlUserCardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlUserCardComponent, "thl-user-card", never, { "image": { "alias": "image"; "required": true; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "subtitle": { "alias": "subtitle"; "required": false; "isSignal": true; }; }, {}, never, ["[thlActions]"], true, never>;
+}
+declare class ThlProfileCardComponent {
+    private readonly cfg;
+    readonly cover: _angular_core.InputSignal<string | undefined>;
+    readonly avatar: _angular_core.InputSignal<string | undefined>;
+    readonly name: _angular_core.InputSignal<string | undefined>;
+    readonly email: _angular_core.InputSignal<string | undefined>;
+    readonly stats: _angular_core.InputSignal<{
+        label: string;
+        value: string | number;
+    }[] | undefined>;
+    readonly b: (e?: string) => string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlProfileCardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlProfileCardComponent, "thl-profile-card", never, { "cover": { "alias": "cover"; "required": false; "isSignal": true; }; "avatar": { "alias": "avatar"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "email": { "alias": "email"; "required": false; "isSignal": true; }; "stats": { "alias": "stats"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class ThlChatComponent {
+    readonly cfg: ThlConfigService;
+    readonly messages: _angular_core.InputSignal<{
+        id: string | number;
+        from: string;
+        avatar?: string;
+        text: string;
+        time?: string;
+        me?: boolean;
+    }[]>;
+    readonly composer: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly send: _angular_core.OutputEmitterRef<string>;
+    readonly b: (e?: string) => string;
+    msgCls(me?: boolean): string;
+    submit(el: HTMLInputElement): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlChatComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlChatComponent, "thl-chat", never, { "messages": { "alias": "messages"; "required": true; "isSignal": true; }; "composer": { "alias": "composer"; "required": false; "isSignal": true; }; }, { "send": "send"; }, never, never, true, never>;
+}
+declare class ThlTodoListComponent {
+    readonly cfg: ThlConfigService;
+    readonly items: _angular_core.InputSignal<{
+        id: string | number;
+        text: string;
+        done?: boolean;
+        badge?: {
+            text: string;
+            color?: string;
+        };
+    }[]>;
+    readonly addable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly toggle: _angular_core.OutputEmitterRef<string | number>;
+    readonly remove: _angular_core.OutputEmitterRef<string | number>;
+    readonly add: _angular_core.OutputEmitterRef<string>;
+    readonly b: (e?: string) => string;
+    itemCls(done?: boolean): string;
+    submit(el: HTMLInputElement): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlTodoListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlTodoListComponent, "thl-todo-list", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "addable": { "alias": "addable"; "required": false; "isSignal": true; }; }, { "toggle": "toggle"; "remove": "remove"; "add": "add"; }, never, never, true, never>;
+}
+declare class ThlWeatherComponent {
+    readonly cfg: ThlConfigService;
+    readonly city: _angular_core.InputSignal<string | undefined>;
+    readonly temp: _angular_core.InputSignal<number | undefined>;
+    readonly condition: _angular_core.InputSignal<string | undefined>;
+    readonly icon: _angular_core.InputSignal<string>;
+    readonly days: _angular_core.InputSignal<{
+        day: string;
+        temp: number;
+        icon?: string;
+    }[] | undefined>;
+    readonly b: (e?: string) => string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlWeatherComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlWeatherComponent, "thl-weather", never, { "city": { "alias": "city"; "required": false; "isSignal": true; }; "temp": { "alias": "temp"; "required": false; "isSignal": true; }; "condition": { "alias": "condition"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "days": { "alias": "days"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare abstract class ResponsiveChart {
+    protected readonly cfg: ThlConfigService;
+    protected readonly i18n: ThlI18nService;
+    readonly width: _angular_core.WritableSignal<number>;
+    constructor();
+    fmt(v: number): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ResponsiveChart, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ResponsiveChart, never, never, {}, {}, never, never, true, never>;
+}
+declare class ThlLineChartComponent extends ResponsiveChart {
+    readonly cfg: ThlConfigService;
+    readonly series: _angular_core.InputSignal<Series[]>;
+    readonly labels: _angular_core.InputSignal<string[]>;
+    readonly height: _angular_core.InputSignal<number>;
+    readonly area: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly smooth: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly legend: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly hover: _angular_core.WritableSignal<number | null>;
+    readonly c: _angular_core.Signal<_thl_ui_charts.XYChart>;
+    readonly band: _angular_core.Signal<number>;
+    readonly aria: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlLineChartComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlLineChartComponent, "thl-line-chart", never, { "series": { "alias": "series"; "required": true; "isSignal": true; }; "labels": { "alias": "labels"; "required": true; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "area": { "alias": "area"; "required": false; "isSignal": true; }; "smooth": { "alias": "smooth"; "required": false; "isSignal": true; }; "legend": { "alias": "legend"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class ThlBarChartComponent extends ResponsiveChart {
+    readonly cfg: ThlConfigService;
+    readonly series: _angular_core.InputSignal<Series[]>;
+    readonly labels: _angular_core.InputSignal<string[]>;
+    readonly height: _angular_core.InputSignal<number>;
+    readonly stacked: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly legend: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly c: _angular_core.Signal<_thl_ui_charts.BarChart>;
+    readonly aria: _angular_core.Signal<string>;
+    color(i: number, s: Series): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlBarChartComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlBarChartComponent, "thl-bar-chart", never, { "series": { "alias": "series"; "required": true; "isSignal": true; }; "labels": { "alias": "labels"; "required": true; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "stacked": { "alias": "stacked"; "required": false; "isSignal": true; }; "legend": { "alias": "legend"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class ThlPieChartComponent {
+    readonly cfg: ThlConfigService;
+    readonly data: _angular_core.InputSignal<{
+        label: string;
+        value: number;
+        color?: string;
+    }[]>;
+    readonly size: _angular_core.InputSignal<number>;
+    readonly donut: _angular_core.InputSignal<number>;
+    readonly legend: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly hover: _angular_core.WritableSignal<number | null>;
+    readonly slices: _angular_core.Signal<_thl_ui_charts.PieSlice[]>;
+    readonly aria: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlPieChartComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlPieChartComponent, "thl-pie-chart", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "donut": { "alias": "donut"; "required": false; "isSignal": true; }; "legend": { "alias": "legend"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class ThlSparklineComponent {
+    private readonly cfg;
+    readonly data: _angular_core.InputSignal<number[]>;
+    readonly width: _angular_core.InputSignal<number>;
+    readonly height: _angular_core.InputSignal<number>;
+    readonly type: _angular_core.InputSignal<"area" | "line" | "bar">;
+    readonly color: _angular_core.InputSignal<string>;
+    readonly s: _angular_core.Signal<{
+        bars: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+            value: number;
+        }[];
+        line: string;
+        area: string;
+        last?: undefined;
+    } | {
+        bars: never[];
+        line: string;
+        area: string;
+        last: [number, number];
+    }>;
+    readonly c: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlSparklineComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlSparklineComponent, "thl-sparkline", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+interface CalendarEvent {
+    id: string | number;
+    title: string;
+    date: string;
+    color?: string;
+}
+declare class ThlCalendarComponent {
+    readonly cfg: ThlConfigService;
+    private readonly i18n;
+    readonly events: _angular_core.InputSignal<CalendarEvent[]>;
+    readonly eventMove: _angular_core.OutputEmitterRef<{
+        id: string | number;
+        date: string;
+    }>;
+    readonly dateClick: _angular_core.OutputEmitterRef<string>;
+    readonly eventClick: _angular_core.OutputEmitterRef<CalendarEvent>;
+    readonly month: _angular_core.WritableSignal<Date>;
+    readonly drop: _angular_core.WritableSignal<string | null>;
+    readonly ws: _angular_core.Signal<0 | 1>;
+    readonly names: _angular_core.Signal<string[]>;
+    readonly cells: _angular_core.Signal<_thl_ui_core.DayCell[]>;
+    readonly title: _angular_core.Signal<string>;
+    fullDate(d: Date): string;
+    readonly byDate: _angular_core.Signal<Partial<Record<string, CalendarEvent[]>>>;
+    readonly b: (e?: string) => string;
+    iso(d: Date): string;
+    shift(n: number): void;
+    today(): void;
+    cellCls(c: {
+        date: Date;
+        inMonth: boolean;
+        today: boolean;
+    }): string;
+    evCls(color?: string): string;
+    onDrop(e: DragEvent, date: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlCalendarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlCalendarComponent, "thl-calendar", never, { "events": { "alias": "events"; "required": true; "isSignal": true; }; }, { "eventMove": "eventMove"; "dateClick": "dateClick"; "eventClick": "eventClick"; }, never, never, true, never>;
+}
+
+/** Custom link rendering (e.g. routerLink): <ng-template thlMenuLink let-item let-cls="cls">…</ng-template> */
+declare class ThlMenuLinkDirective {
+    readonly tpl: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlMenuLinkDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ThlMenuLinkDirective, "ng-template[thlMenuLink]", never, {}, {}, never, never, true, never>;
+}
+declare class ThlSideMenuComponent {
+    private readonly cfg;
+    protected readonly i18n: ThlI18nService;
+    readonly items: _angular_core.InputSignal<MenuItem[]>;
+    readonly currentPath: _angular_core.InputSignal<string | undefined>;
+    readonly accordion: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** One-row menu: top-level items that do not fit move into a "More" dropdown. */
+    readonly horizontal: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly host;
+    readonly visible: _angular_core.WritableSignal<number>;
+    readonly overflow: _angular_core.Signal<boolean>;
+    readonly rest: _angular_core.Signal<MenuItem[]>;
+    isHidden(depth: number, idx: number): boolean;
+    moreCls(): string;
+    readonly linkTpl: _angular_core.Signal<ThlMenuLinkDirective | undefined>;
+    readonly trail: _angular_core.Signal<string[]>;
+    readonly open: _angular_core.WritableSignal<string[]>;
+    constructor();
+    readonly b: (e?: string) => string;
+    label(l: string): string;
+    isOpen(k: string): boolean;
+    isCurrent(k: string): boolean;
+    linkCls(k: string): string;
+    collapseCls(k: string): string;
+    toggle(k: string, sib: MenuItem[]): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlSideMenuComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlSideMenuComponent, "thl-side-menu", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "currentPath": { "alias": "currentPath"; "required": false; "isSignal": true; }; "accordion": { "alias": "accordion"; "required": false; "isSignal": true; }; "horizontal": { "alias": "horizontal"; "required": false; "isSignal": true; }; }, {}, ["linkTpl"], never, true, never>;
+}
+declare class ThlSettingsPanelComponent {
+    readonly cfg: ThlConfigService;
+    readonly open: _angular_core.ModelSignal<boolean>;
+    readonly c: _angular_core.Signal<_thl_ui_core.ThlConfig>;
+    readonly layouts: LayoutMode[];
+    readonly modes: Array<[ColorMode, string]>;
+    readonly bases: Array<keyof typeof skins>;
+    readonly s: (e?: string) => string;
+    skinCls(k: string): string;
+    grad(k: keyof typeof skins): string;
+    setDark(k: string): void;
+    name(l: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlSettingsPanelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlSettingsPanelComponent, "thl-settings-panel", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; }, { "open": "openChange"; }, never, never, true, never>;
+}
+interface ThlTopbarNotification {
+    id: string | number;
+    title: string;
+    text?: string;
+    time?: string;
+    avatar?: string;
+    icon?: string;
+    status?: string;
+}
+declare class ThlTopbarMessagesComponent {
+    readonly cfg: ThlConfigService;
+    readonly items: _angular_core.InputSignal<ThlTopbarNotification[]>;
+    readonly icon: _angular_core.InputSignal<string>;
+    readonly title: _angular_core.InputSignal<string | undefined>;
+    readonly footer: _angular_core.InputSignal<string | undefined>;
+    readonly footerHref: _angular_core.InputSignal<string>;
+    readonly tb: (e?: string) => string;
+    readonly mc: (e?: string) => string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlTopbarMessagesComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlTopbarMessagesComponent, "thl-topbar-messages", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "footer": { "alias": "footer"; "required": false; "isSignal": true; }; "footerHref": { "alias": "footerHref"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+interface ThlLayoutUser {
+    name: string;
+    avatar?: string;
+    role?: string;
+    menu?: DropdownItem[];
+}
+declare class ThlAppLayoutComponent {
+    readonly cfg: ThlConfigService;
+    readonly i18n: ThlI18nService;
+    readonly p: _angular_core.Signal<string>;
+    readonly c: _angular_core.Signal<_thl_ui_core.ThlConfig>;
+    readonly menu: _angular_core.InputSignal<MenuItem[]>;
+    readonly currentPath: _angular_core.InputSignal<string | undefined>;
+    readonly brand: _angular_core.InputSignal<string>;
+    readonly brandHref: _angular_core.InputSignal<string>;
+    readonly user: _angular_core.InputSignal<ThlLayoutUser | undefined>;
+    readonly searchable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly settings: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly footer: _angular_core.InputSignal<string | false | undefined>;
+    readonly search: _angular_core.OutputEmitterRef<string>;
+    readonly userSelect: _angular_core.OutputEmitterRef<string>;
+    readonly year: number;
+    readonly panel: _angular_core.WritableSignal<boolean>;
+    readonly sidebar: {
+        state: _thl_ui_core.Store<_thl_ui_core.SidebarState>;
+        toggle(): void;
+        setMini: (mini: boolean) => void;
+        closeMobile: () => void;
+        destroy(): void;
+    };
+    readonly sb: _angular_core.Signal<_thl_ui_core.SidebarState>;
+    readonly horizontal: _angular_core.Signal<boolean>;
+    readonly appCls: _angular_core.Signal<string>;
+    readonly tb: (e?: string) => string;
+    readonly modeIcon: _angular_core.Signal<"sun" | "moon" | "monitor">;
+    readonly localeItems: _angular_core.Signal<{
+        key: string;
+        label: string;
+    }[]>;
+    readonly userItems: _angular_core.Signal<DropdownItem[]>;
+    constructor();
+    cycleMode(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlAppLayoutComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlAppLayoutComponent, "thl-app-layout", never, { "menu": { "alias": "menu"; "required": true; "isSignal": true; }; "currentPath": { "alias": "currentPath"; "required": false; "isSignal": true; }; "brand": { "alias": "brand"; "required": false; "isSignal": true; }; "brandHref": { "alias": "brandHref"; "required": false; "isSignal": true; }; "user": { "alias": "user"; "required": false; "isSignal": true; }; "searchable": { "alias": "searchable"; "required": false; "isSignal": true; }; "settings": { "alias": "settings"; "required": false; "isSignal": true; }; "footer": { "alias": "footer"; "required": false; "isSignal": true; }; }, { "search": "search"; "userSelect": "userSelect"; }, never, ["[thlBrandIcon]", "[thlTopbarLeft]", "[thlTopbarRight]", "[thlMenuLink]", "[thlSidebarFooter]", "*"], true, never>;
+}
+declare class ThlPageComponent {
+    readonly p: _angular_core.Signal<string>;
+    readonly title: _angular_core.InputSignal<string | undefined>;
+    readonly breadcrumb: _angular_core.InputSignal<{
+        label: string;
+        href?: string;
+    }[] | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlPageComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlPageComponent, "thl-page", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "breadcrumb": { "alias": "breadcrumb"; "required": false; "isSignal": true; }; }, {}, never, ["[thlPageActions]", "*"], true, never>;
+}
+declare class ThlAuthLayoutComponent {
+    readonly cfg: ThlConfigService;
+    readonly title: _angular_core.InputSignal<string | undefined>;
+    readonly avatar: _angular_core.InputSignal<string | undefined>;
+    readonly b: (e?: string) => string;
+    name(l: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlAuthLayoutComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlAuthLayoutComponent, "thl-auth-layout", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "avatar": { "alias": "avatar"; "required": false; "isSignal": true; }; }, {}, never, ["*", "[thlAuthFooter]"], true, never>;
+}
+declare class ThlErrorLayoutComponent {
+    private readonly cfg;
+    readonly code: _angular_core.InputSignal<number>;
+    readonly title: _angular_core.InputSignal<string | undefined>;
+    readonly text: _angular_core.InputSignal<string | undefined>;
+    readonly homeHref: _angular_core.InputSignal<string>;
+    readonly known: _angular_core.Signal<boolean>;
+    readonly year: number;
+    readonly b: (e?: string) => string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThlErrorLayoutComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThlErrorLayoutComponent, "thl-error-layout", never, { "code": { "alias": "code"; "required": true; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; "homeHref": { "alias": "homeHref"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** Every standalone component/directive/pipe — `imports: [THL_UI]` for convenience. */
+declare const THL_UI: readonly [typeof ThlTranslatePipe, typeof ThlBemPipe, typeof ThlIconComponent, ...any[]];
+
+export { THL_CONFIG, THL_UI, ThlActivityFeedComponent, ThlAlertComponent, ThlAppLayoutComponent, ThlAuthLayoutComponent, ThlAvatarComponent, ThlBadgeComponent, ThlBarChartComponent, ThlBemPipe, ThlBreadcrumbComponent, ThlButtonComponent, ThlButtonGroupComponent, ThlCalendarComponent, ThlCalendarGridComponent, ThlCardActionsDirective, ThlCardComponent, ThlCarouselComponent, ThlCellDirective, ThlChatComponent, ThlCheckboxComponent, ThlCheckboxGroupComponent, ThlColorBoxComponent, ThlColorPickerComponent, ThlConfigService, ThlConfirmHostComponent, ThlDataTableComponent, ThlDatePickerComponent, ThlDateRangePickerComponent, ThlDrawerComponent, ThlDropdownComponent, ThlEditorComponent, ThlErrorLayoutComponent, ThlFieldComponent, ThlGalleryComponent, ThlHorizontalTimelineComponent, ThlI18nService, ThlIconComponent, ThlInfoBoxComponent, ThlInputDirective, ThlInputGroupComponent, ThlLabelComponent, ThlLineChartComponent, ThlListComponent, ThlMenuLinkDirective, ThlModalComponent, ThlModalService, ThlNumberInputComponent, ThlPageComponent, ThlPaginationComponent, ThlPanelComponent, ThlPieChartComponent, ThlPopoverComponent, ThlPricingTableComponent, ThlProfileCardComponent, ThlProgressCircleComponent, ThlProgressComponent, ThlRadioGroupComponent, ThlRibbonComponent, ThlSelectComponent, ThlSettingsPanelComponent, ThlSideMenuComponent, ThlSliderComponent, ThlSparklineComponent, ThlSpinnerComponent, ThlStatBoxComponent, ThlStatsRowComponent, ThlStepsComponent, ThlSwitchComponent, ThlTabPanelDirective, ThlTableDirective, ThlTabsComponent, ThlTimePickerComponent, ThlTimelineComponent, ThlToastService, ThlToasterComponent, ThlTodoListComponent, ThlTooltipComponent, ThlTopbarMessagesComponent, ThlTranslatePipe, ThlUploadComponent, ThlUserCardComponent, ThlWeatherComponent, ThlWellComponent, provideThlUI, storeSignal, thlValidators };
+export type { CalendarEvent, ConfirmOptions, DropdownItem, PricingPlanData, ThlLayoutUser, ThlTopbarNotification };
+//# sourceMappingURL=thl-ui-angular.d.ts.map