@weeehaoooz/talos-ui 0.1.0 → 0.1.2

package/types/weeehaoooz-talos-ui-feedback.d.ts

@@ -0,0 +1,1495 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef, Type, InjectionToken, OnInit, OnDestroy } from '@angular/core';
+import { DialogRef } from '@angular/cdk/dialog';
+import { Observable } from 'rxjs';
+import { ComponentType } from '@angular/cdk/portal';
+import * as _weeehaoooz_talos_ui_feedback from '@weeehaoooz/talos-ui/feedback';
+
+type TalosAlertVariant = 'default' | 'info' | 'success' | 'warning' | 'error' | 'primary' | 'critical';
+type TalosAlertSeverity = 'success' | 'info' | 'warning' | 'error';
+type TalosAlertAppearance = 'subtle' | 'outline' | 'filled' | 'accent' | 'left-border';
+type TalosAlertSize = 'sm' | 'md' | 'lg';
+interface TalosAlertConfig {
+    /** Optional unique identifier */
+    id?: string;
+    /** Title header text or custom TemplateRef */
+    title?: string | TemplateRef<unknown>;
+    /** Main message content or custom TemplateRef */
+    message?: string | TemplateRef<unknown>;
+    /** Visual variant theme */
+    variant?: TalosAlertVariant;
+    /** Severity state: 'success' (default), 'info', 'warning', 'error' */
+    severity?: TalosAlertSeverity;
+    /** Visual surface appearance style */
+    appearance?: TalosAlertAppearance;
+    /** Alert sizing */
+    size?: TalosAlertSize;
+    /** Whether to show an icon. Default: true */
+    showIcon?: boolean;
+    /** Custom Lucide icon component, TemplateRef, or null/false to hide */
+    icon?: Type<unknown> | TemplateRef<unknown> | boolean | null;
+    /** Whether to display a severity badge. Default: false */
+    showSeverityBadge?: boolean;
+    /** Whether the alert can be closed by the user. Default: false for inline, true for service */
+    dismissible?: boolean;
+    /** Action button text label (e.g., 'Retry', 'View Logs') */
+    actionLabel?: string;
+    /** Callback triggered when action button is clicked */
+    onAction?: () => void;
+    /** Callback triggered when alert is dismissed */
+    onDismiss?: () => void;
+    /** Custom CSS class to attach to the alert container */
+    customClass?: string;
+    /** Explicit border outline. Default: false */
+    bordered?: boolean;
+    /** Auto-dismiss duration in milliseconds */
+    duration?: number;
+    /** Arbitrary metadata attached to the instance */
+    data?: unknown;
+}
+interface TalosAlertRef {
+    id: string;
+    dismiss: () => void;
+}
+interface TalosAlertInstance extends TalosAlertConfig {
+    id: string;
+    createdAt: number;
+}
+
+declare class TalosAlertService {
+    /** Reactive list of currently active programmatic alerts */
+    readonly alerts: _angular_core.WritableSignal<TalosAlertInstance[]>;
+    /** Reactive list of currently active top-level banner alerts */
+    readonly bannerAlerts: _angular_core.WritableSignal<TalosAlertInstance[]>;
+    private idCounter;
+    /** Default global configurations */
+    private defaultConfig;
+    /**
+     * Override default global configurations.
+     */
+    setDefaultConfig(config: Partial<TalosAlertConfig>): void;
+    /**
+     * Main entry point to create a programmatic alert instance.
+     */
+    show(messageOrConfig: string | TemplateRef<unknown> | TalosAlertConfig, configOverrides?: Partial<TalosAlertConfig>): TalosAlertRef;
+    /**
+     * Display a high-visibility global banner alert.
+     */
+    banner(messageOrConfig: string | TemplateRef<unknown> | TalosAlertConfig, configOverrides?: Partial<TalosAlertConfig>): TalosAlertRef;
+    /** Convenience method for Success alerts (Default severity) */
+    success(message: string | TemplateRef<unknown>, config?: Partial<TalosAlertConfig>): TalosAlertRef;
+    /** Convenience method for Info alerts */
+    info(message: string | TemplateRef<unknown>, config?: Partial<TalosAlertConfig>): TalosAlertRef;
+    /** Convenience method for Warning alerts */
+    warning(message: string | TemplateRef<unknown>, config?: Partial<TalosAlertConfig>): TalosAlertRef;
+    /** Convenience method for Error alerts */
+    error(message: string | TemplateRef<unknown>, config?: Partial<TalosAlertConfig>): TalosAlertRef;
+    /**
+     * Dismiss a specific programmatic alert by ID, or the oldest if no ID is provided.
+     */
+    dismiss(id?: string): void;
+    /**
+     * Dismiss a banner alert by ID.
+     */
+    dismissBanner(id?: string): void;
+    /**
+     * Dismiss all currently active alerts and banners.
+     */
+    dismissAll(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosAlertService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TalosAlertService>;
+}
+
+/**
+ * Structural / Slot directive for alert title projection.
+ *
+ * Usage:
+ * ```html
+ * <talos-alert>
+ *   <div talosAlertTitle>System Maintenance</div>
+ *   <div talosAlertDescription>All services will undergo updates tonight.</div>
+ * </talos-alert>
+ * ```
+ */
+declare class TalosAlertTitleDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosAlertTitleDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TalosAlertTitleDirective, "[talosAlertTitle], talos-alert-title", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Slot directive for alert description / message body.
+ */
+declare class TalosAlertDescriptionDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosAlertDescriptionDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TalosAlertDescriptionDirective, "[talosAlertDescription], talos-alert-description", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Slot directive for custom alert actions / button group.
+ */
+declare class TalosAlertActionsDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosAlertActionsDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TalosAlertActionsDirective, "[talosAlertActions], talos-alert-actions", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Slot directive for custom alert icon.
+ */
+declare class TalosAlertIconDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosAlertIconDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TalosAlertIconDirective, "[talosAlertIcon], talos-alert-icon", never, {}, {}, never, never, true, never>;
+}
+
+declare class TalosAlertComponent {
+    /** Alert severity state: 'success' (default), 'info', 'warning', 'error' */
+    readonly severity: _angular_core.InputSignal<TalosAlertSeverity | undefined>;
+    /** Visual variant theme fallback */
+    readonly variant: _angular_core.InputSignal<TalosAlertVariant | undefined>;
+    /** Visual surface appearance style */
+    readonly appearance: _angular_core.InputSignal<TalosAlertAppearance>;
+    /** Sizing of padding and typography */
+    readonly size: _angular_core.InputSignal<TalosAlertSize>;
+    /** Header title text or custom TemplateRef */
+    readonly title: _angular_core.InputSignal<string | TemplateRef<unknown> | undefined>;
+    /** Main message content or custom TemplateRef */
+    readonly message: _angular_core.InputSignal<string | TemplateRef<unknown> | undefined>;
+    /** Whether to display the icon */
+    readonly showIcon: _angular_core.InputSignal<boolean>;
+    /** Custom Lucide icon component, TemplateRef, or boolean */
+    readonly icon: _angular_core.InputSignal<boolean | TemplateRef<unknown> | Type<unknown> | null | undefined>;
+    /** Whether to display a dedicated severity pill badge */
+    readonly showSeverityBadge: _angular_core.InputSignal<boolean>;
+    /** Whether the alert can be dismissed */
+    readonly dismissible: _angular_core.InputSignal<boolean>;
+    /** Action button text label */
+    readonly actionLabel: _angular_core.InputSignal<string | undefined>;
+    /** Optional explicit border outline */
+    readonly bordered: _angular_core.InputSignal<boolean>;
+    /** Additional CSS class */
+    readonly customClass: _angular_core.InputSignal<string>;
+    /** Emitted when dismiss close button is clicked */
+    readonly dismiss: _angular_core.OutputEmitterRef<void>;
+    /** Emitted when action button is clicked */
+    readonly action: _angular_core.OutputEmitterRef<void>;
+    /** Emitted when dismiss animation has finished and alert is removed */
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    protected readonly isDismissing: _angular_core.WritableSignal<boolean>;
+    protected readonly isDismissed: _angular_core.WritableSignal<boolean>;
+    /** Resolved visual variant considering severity */
+    readonly resolvedVariant: _angular_core.Signal<TalosAlertVariant>;
+    /** Severity display label for badge */
+    readonly severityLabel: _angular_core.Signal<string>;
+    readonly isTitleTemplate: _angular_core.Signal<boolean>;
+    readonly titleTemplate: _angular_core.Signal<TemplateRef<unknown>>;
+    readonly isMessageTemplate: _angular_core.Signal<boolean>;
+    readonly messageTemplate: _angular_core.Signal<TemplateRef<unknown>>;
+    readonly isIconTemplate: _angular_core.Signal<boolean>;
+    readonly iconTemplate: _angular_core.Signal<TemplateRef<unknown>>;
+    readonly customIconComponent: _angular_core.Signal<Type<unknown> | null>;
+    readonly ariaRole: _angular_core.Signal<"alert" | "status">;
+    readonly ariaLive: _angular_core.Signal<"assertive" | "polite">;
+    protected onActionClick(): void;
+    protected onCloseClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosAlertComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TalosAlertComponent, "talos-alert", never, { "severity": { "alias": "severity"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "message": { "alias": "message"; "required": false; "isSignal": true; }; "showIcon": { "alias": "showIcon"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "showSeverityBadge": { "alias": "showSeverityBadge"; "required": false; "isSignal": true; }; "dismissible": { "alias": "dismissible"; "required": false; "isSignal": true; }; "actionLabel": { "alias": "actionLabel"; "required": false; "isSignal": true; }; "bordered": { "alias": "bordered"; "required": false; "isSignal": true; }; "customClass": { "alias": "customClass"; "required": false; "isSignal": true; }; }, { "dismiss": "dismiss"; "action": "action"; "closed": "closed"; }, never, ["[talosAlertIcon], talos-alert-icon", "[talosAlertTitle], talos-alert-title", "[talosAlertDescription], talos-alert-description", "*", "[talosAlertActions], talos-alert-actions"], true, never>;
+}
+
+declare class TalosAlertContainerComponent {
+    private readonly alertService;
+    /** Mode of alerts to render from the service ('inline', 'banner', or 'all') */
+    readonly type: _angular_core.InputSignal<"inline" | "banner" | "all">;
+    readonly targetAlerts: _angular_core.Signal<TalosAlertInstance[]>;
+    onDismiss(id: string): void;
+    onAction(item: TalosAlertInstance): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosAlertContainerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TalosAlertContainerComponent, "talos-alert-container", never, { "type": { "alias": "type"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Convenience NgModule wrapping standalone alert components and directives.
+ */
+declare class TalosAlertModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosAlertModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<TalosAlertModule, never, [typeof TalosAlertComponent, typeof TalosAlertContainerComponent, typeof TalosAlertTitleDirective, typeof TalosAlertDescriptionDirective, typeof TalosAlertActionsDirective, typeof TalosAlertIconDirective], [typeof TalosAlertComponent, typeof TalosAlertContainerComponent, typeof TalosAlertTitleDirective, typeof TalosAlertDescriptionDirective, typeof TalosAlertActionsDirective, typeof TalosAlertIconDirective]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<TalosAlertModule>;
+}
+
+/** Size options for the dialog modal */
+type TalosDialogSize = 'auto' | 'sm' | 'md' | 'lg' | 'xl' | 'fullscreen';
+/** Backdrop blur intensity options */
+type TalosDialogBlur = boolean | 'none' | 'sm' | 'md' | 'lg';
+/** Visual variant for dialog styling and icons */
+type TalosDialogVariant = 'default' | 'primary' | 'danger' | 'warning' | 'info' | 'success';
+/** Footer button alignment */
+type TalosDialogFooterAlign = 'start' | 'center' | 'end' | 'space-between';
+/** Content padding variants */
+type TalosDialogPadding = 'none' | 'sm' | 'md' | 'lg';
+/**
+ * Configuration options for opening a Talos Dialog.
+ */
+interface TalosDialogConfig<TData = unknown> {
+    /** Sizing preset: 'auto' (content-hugging), 'sm' (420px), 'md' (560px), 'lg' (768px), 'xl' (1024px), or 'fullscreen' */
+    size?: TalosDialogSize;
+    /** Blur background effect: true/'md' (standard frosted glass), 'sm' (light blur), 'lg' (heavy blur), or false/'none' */
+    backdropBlur?: TalosDialogBlur;
+    /** Explicit width override (e.g. '500px', '75vw') */
+    width?: string;
+    /** Explicit min-width override */
+    minWidth?: string;
+    /** Explicit max-width override */
+    maxWidth?: string;
+    /** Explicit height override (e.g. '600px', '80vh') */
+    height?: string;
+    /** Explicit min-height override */
+    minHeight?: string;
+    /** Explicit max-height override */
+    maxHeight?: string;
+    /** Custom CSS classes to append to the dialog panel */
+    panelClass?: string | string[];
+    /** Custom CSS classes to append to the dialog backdrop */
+    backdropClass?: string | string[];
+    /** Whether the dialog has a backdrop overlay. Defaults to true. */
+    hasBackdrop?: boolean;
+    /** Whether the user can dismiss the dialog by clicking the backdrop or pressing ESC. Defaults to false. */
+    disableClose?: boolean;
+    /** Whether pressing ESC closes the dialog. Defaults to true unless disableClose is true. */
+    closeOnEsc?: boolean;
+    /** Whether clicking the backdrop closes the dialog. Defaults to true unless disableClose is true. */
+    closeOnBackdropClick?: boolean;
+    /** Arbitrary data passed to the dialog component via TALOS_DIALOG_DATA */
+    data?: TData;
+    /** Accessible label for the dialog */
+    ariaLabel?: string;
+    /** ID of the element that labels the dialog */
+    ariaLabelledBy?: string;
+    /** ID of the element that describes the dialog */
+    ariaDescribedBy?: string;
+    /** ARIA role for the dialog element ('dialog' or 'alertdialog') */
+    role?: 'dialog' | 'alertdialog';
+    /** Whether focus should automatically be trapped and moved to the first focusable element */
+    autoFocus?: boolean | 'first-tabbable' | 'first-heading' | 'dialog';
+    /** Whether focus should be restored to the triggering element upon closure */
+    restoreFocus?: boolean;
+    /** Custom ID for the dialog */
+    id?: string;
+}
+/**
+ * Options for the confirm dialog convenience method.
+ */
+interface TalosConfirmDialogOptions {
+    title: string;
+    message: string | TemplateRef<unknown>;
+    confirmText?: string;
+    cancelText?: string;
+    variant?: TalosDialogVariant;
+    size?: TalosDialogSize;
+    backdropBlur?: TalosDialogBlur;
+    disableClose?: boolean;
+    showCancel?: boolean;
+    icon?: any;
+}
+/**
+ * Options for the alert dialog convenience method.
+ */
+interface TalosAlertDialogOptions {
+    title: string;
+    message: string | TemplateRef<unknown>;
+    okText?: string;
+    variant?: TalosDialogVariant;
+    size?: TalosDialogSize;
+    backdropBlur?: TalosDialogBlur;
+    icon?: any;
+}
+/** Injection token for data passed to a dialog component */
+declare const TALOS_DIALOG_DATA: InjectionToken<unknown>;
+/** Injection token for dialog configuration */
+declare const TALOS_DIALOG_CONFIG: InjectionToken<TalosDialogConfig<unknown>>;
+/** Injection token for dialog reference */
+declare const TALOS_DIALOG_REF: InjectionToken<unknown>;
+
+/**
+ * Reference to an actively open dialog instance.
+ */
+declare class TalosDialogRef<R = unknown, D = unknown> {
+    readonly cdkDialogRef: DialogRef<R, unknown>;
+    readonly config: TalosDialogConfig<D>;
+    readonly data?: D | undefined;
+    constructor(cdkDialogRef: DialogRef<R, unknown>, config: TalosDialogConfig<D>, data?: D | undefined);
+    /** Unique identifier for the dialog */
+    get id(): string;
+    /** Observable that emits when the dialog is closed with the result value */
+    get closed(): Observable<R | undefined>;
+    /** Observable that emits when the backdrop overlay is clicked */
+    get backdropClick(): Observable<MouseEvent>;
+    /** Observable that emits keyboard events received by the dialog overlay */
+    get keydownEvents(): Observable<KeyboardEvent>;
+    /**
+     * Close the dialog, optionally returning a result value to the opener.
+     */
+    close(result?: R): void;
+    /**
+     * Dynamically update the size of the dialog panel.
+     */
+    updateSize(width?: string, height?: string): this;
+    /**
+     * Add CSS class(es) to the dialog overlay panel.
+     */
+    addPanelClass(classes: string | string[]): this;
+    /**
+     * Remove CSS class(es) from the dialog overlay panel.
+     */
+    removePanelClass(classes: string | string[]): this;
+}
+
+declare class TalosDialogService {
+    private readonly cdkDialog;
+    private readonly injector;
+    /** Signal of currently open dialog references */
+    readonly openDialogs: _angular_core.WritableSignal<TalosDialogRef<unknown, unknown>[]>;
+    /**
+     * Open a component or template inside a modal dialog.
+     */
+    open<R = unknown, D = unknown>(componentOrTemplate: ComponentType<unknown> | TemplateRef<unknown>, config?: TalosDialogConfig<D>): TalosDialogRef<R, D>;
+    /**
+     * Convenience helper to display a confirmation dialog.
+     */
+    confirm(options: TalosConfirmDialogOptions): TalosDialogRef<boolean>;
+    /**
+     * Convenience helper to display an alert dialog.
+     */
+    alert(options: TalosAlertDialogOptions): TalosDialogRef<void>;
+    /**
+     * Close all currently open dialogs.
+     */
+    closeAll(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosDialogService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TalosDialogService>;
+}
+
+/**
+ * Directive for the dialog title element.
+ * Automatically handles accessible ARIA labeling.
+ */
+declare class TalosDialogTitleDirective implements OnInit {
+    /** Optional custom ID for accessibility linking */
+    readonly id: _angular_core.InputSignal<string>;
+    private readonly dialogRef;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosDialogTitleDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TalosDialogTitleDirective, "[talosDialogTitle]", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Directive for the dialog description/subtitle element.
+ * Automatically handles accessible ARIA descriptions.
+ */
+declare class TalosDialogDescriptionDirective {
+    /** Optional custom ID for accessibility linking */
+    readonly id: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosDialogDescriptionDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TalosDialogDescriptionDirective, "[talosDialogDescription]", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Directive placed on buttons inside a dialog to trigger dismissal.
+ * Passes the optional [talosDialogClose] value as the dialog result.
+ */
+declare class TalosDialogCloseDirective {
+    /** Value returned when closing the dialog */
+    readonly dialogResult: _angular_core.InputSignal<unknown>;
+    private readonly dialogRef;
+    protected onClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosDialogCloseDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TalosDialogCloseDirective, "[talosDialogClose]", never, { "dialogResult": { "alias": "talosDialogClose"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class TalosDialogHeaderComponent {
+    /** Main dialog title */
+    readonly title: _angular_core.InputSignal<string | undefined>;
+    /** Subtitle or helper description */
+    readonly subtitle: _angular_core.InputSignal<string | undefined>;
+    /** Visual accent variant */
+    readonly variant: _angular_core.InputSignal<TalosDialogVariant>;
+    /** Whether to show a bottom divider line */
+    readonly divider: _angular_core.InputSignal<boolean>;
+    /** Whether to show the top-right X close button */
+    readonly showCloseButton: _angular_core.InputSignal<boolean>;
+    /** Accessible label for the close button */
+    readonly closeButtonAriaLabel: _angular_core.InputSignal<string>;
+    /** Emitted when the close button is clicked */
+    readonly closeClick: _angular_core.OutputEmitterRef<MouseEvent>;
+    private readonly dialogRef;
+    protected handleClose(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosDialogHeaderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TalosDialogHeaderComponent, "talos-dialog-header, [talosDialogHeader]", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "subtitle": { "alias": "subtitle"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "divider": { "alias": "divider"; "required": false; "isSignal": true; }; "showCloseButton": { "alias": "showCloseButton"; "required": false; "isSignal": true; }; "closeButtonAriaLabel": { "alias": "closeButtonAriaLabel"; "required": false; "isSignal": true; }; }, { "closeClick": "closeClick"; }, never, ["[talos-dialog-icon], [dialog-icon], lucide-icon, svg", "[talosDialogTitle], h2, h3", "[talosDialogDescription], p", "[talos-dialog-header-actions]"], true, never>;
+}
+
+declare class TalosDialogContentComponent {
+    /** Internal padding size */
+    readonly padding: _angular_core.InputSignal<TalosDialogPadding>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosDialogContentComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TalosDialogContentComponent, "talos-dialog-content, [talosDialogContent]", never, { "padding": { "alias": "padding"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class TalosDialogFooterComponent {
+    /** Button alignment in footer */
+    readonly align: _angular_core.InputSignal<TalosDialogFooterAlign>;
+    /** Whether to show a top divider border */
+    readonly divider: _angular_core.InputSignal<boolean>;
+    /** Whether the footer sticks to the bottom when content scrolls */
+    readonly sticky: _angular_core.InputSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosDialogFooterComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TalosDialogFooterComponent, "talos-dialog-footer, [talosDialogFooter]", never, { "align": { "alias": "align"; "required": false; "isSignal": true; }; "divider": { "alias": "divider"; "required": false; "isSignal": true; }; "sticky": { "alias": "sticky"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class TalosConfirmDialogComponent {
+    readonly data: TalosConfirmDialogOptions;
+    private readonly dialogRef;
+    protected readonly title: string;
+    protected readonly message: string | _angular_core.TemplateRef<unknown>;
+    protected readonly isTemplateMessage: boolean;
+    protected readonly confirmText: string;
+    protected readonly cancelText: string;
+    protected readonly variant: _weeehaoooz_talos_ui_feedback.TalosDialogVariant;
+    protected readonly showCancel: boolean;
+    protected get confirmButtonVariant(): 'primary' | 'danger' | 'secondary';
+    protected onConfirm(): void;
+    protected onCancel(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosConfirmDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TalosConfirmDialogComponent, "talos-confirm-dialog", never, {}, {}, never, never, true, never>;
+}
+
+declare class TalosDialogModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosDialogModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<TalosDialogModule, never, [typeof TalosDialogHeaderComponent, typeof TalosDialogContentComponent, typeof TalosDialogFooterComponent, typeof TalosConfirmDialogComponent, typeof TalosDialogTitleDirective, typeof TalosDialogDescriptionDirective, typeof TalosDialogCloseDirective], [typeof TalosDialogHeaderComponent, typeof TalosDialogContentComponent, typeof TalosDialogFooterComponent, typeof TalosConfirmDialogComponent, typeof TalosDialogTitleDirective, typeof TalosDialogDescriptionDirective, typeof TalosDialogCloseDirective]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<TalosDialogModule>;
+}
+
+/**
+ * Operational mode of the progress bar.
+ * - 'determinate': Standard progress bar showing a discrete percentage from min to max.
+ * - 'indeterminate': Animated sliding activity bar for unknown durations or async background tasks.
+ * - 'buffer': Shows dual progress values (e.g. streaming buffered progress vs playback/uploaded).
+ * - 'query': Reversed indeterminate animation indicating a pending query or handshake.
+ */
+type TalosProgressBarMode = 'determinate' | 'indeterminate' | 'buffer' | 'query';
+/**
+ * Visual semantic variant palette for the progress bar.
+ */
+type TalosProgressBarVariant = 'primary' | 'secondary' | 'success' | 'warning' | 'danger' | 'error' | 'info' | 'neutral' | 'gradient';
+/**
+ * Standard sizing presets for the progress bar track height.
+ * - 'xs': 2px (subtle top-of-page hairline or compact table indicator)
+ * - 'sm': 4px (dense inline layout)
+ * - 'md': 8px (default standard track)
+ * - 'lg': 12px (prominent task progress)
+ * - 'xl': 16px (large display capable of containing inside labels)
+ */
+type TalosProgressBarSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+/**
+ * Corner shape styling of the progress bar track and fill.
+ * - 'rounded': Full pill radius (default)
+ * - 'square': Sharp rectangular corners (0 radius)
+ * - 'subtle': Subtle corner radius (md token)
+ */
+type TalosProgressBarShape = 'rounded' | 'square' | 'subtle';
+/**
+ * Placement of the numeric or formatted progress value.
+ * - 'end': Right side of an inline layout
+ * - 'start': Left side of an inline layout
+ * - 'top-end': Top right above the bar
+ * - 'bottom-end': Bottom right below the bar
+ * - 'inside': Centered inside the progress fill (recommended for size 'xl' or 'lg')
+ */
+type TalosProgressBarValuePosition = 'start' | 'end' | 'inside' | 'top-end' | 'bottom-end';
+/**
+ * Placement of the progress text label.
+ * - 'top': Displayed above the track
+ * - 'inline': Displayed in the same row as the track
+ * - 'bottom': Displayed below the track
+ */
+type TalosProgressBarLabelPosition = 'top' | 'inline' | 'bottom';
+/**
+ * Custom formatter callback function to transform numeric value and percentage into a readable string.
+ */
+type TalosProgressBarFormatter = (value: number, percentage: number) => string;
+/**
+ * Clamps a numeric value between a minimum and maximum threshold.
+ *
+ * @param value The value to clamp
+ * @param min The lower bound (inclusive)
+ * @param max The upper bound (inclusive)
+ * @returns Clamped numerical value
+ */
+declare function clampProgress(value: number, min: number, max: number): number;
+/**
+ * Calculates percentage completion (0 to 100) based on value, min, and max.
+ *
+ * @param value Current progress value
+ * @param min Minimum possible value
+ * @param max Maximum possible value
+ * @returns Scaled percentage between 0 and 100
+ */
+declare function calculatePercentage(value: number, min: number, max: number): number;
+/**
+ * Normalizes CSS dimension input (number converted to px string, or raw string).
+ *
+ * @param value Dimension input as string or number
+ * @returns CSS dimension string or undefined
+ */
+declare function resolveProgressDimension(value: string | number | null | undefined): string | undefined;
+
+/**
+ * Directive for projecting custom header label content into a `<talos-progress-bar>`.
+ *
+ * @example
+ * ```html
+ * <talos-progress-bar [value]="uploadProgress()">
+ *   <div talosProgressLabel class="flex items-center gap-2">
+ *     <span>Uploading assets</span>
+ *     <span class="talos-badge talos-badge--sm talos-badge--info">Active</span>
+ *   </div>
+ * </talos-progress-bar>
+ * ```
+ */
+declare class TalosProgressLabelDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosProgressLabelDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TalosProgressLabelDirective, "[talosProgressLabel], talos-progress-label", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Directive for projecting custom formatted value or badge indicator into a `<talos-progress-bar>`.
+ *
+ * @example
+ * ```html
+ * <talos-progress-bar [value]="75">
+ *   <span talosProgressValue class="font-mono text-xs">750 / 1,000 MB</span>
+ * </talos-progress-bar>
+ * ```
+ */
+declare class TalosProgressValueDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosProgressValueDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TalosProgressValueDirective, "[talosProgressValue], talos-progress-value", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Directive for projecting auxiliary description, ETA, or subtext beneath a `<talos-progress-bar>`.
+ *
+ * @example
+ * ```html
+ * <talos-progress-bar [value]="42">
+ *   <span talosProgressHint>Estimated time remaining: 2 minutes 45 seconds</span>
+ * </talos-progress-bar>
+ * ```
+ */
+declare class TalosProgressHintDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosProgressHintDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TalosProgressHintDirective, "[talosProgressHint], talos-progress-hint", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Modern, accessible linear progress bar component for asynchronous task completion,
+ * asset uploads, streaming buffer states, and metric progress visualization.
+ *
+ * Fully reactive via Angular signals, with support for indeterminate/buffer modes,
+ * striped animated fills, semantic color variants, custom sizes, inside/inline labels,
+ * and comprehensive WCAG AA accessibility attributes.
+ *
+ * @example
+ * ```html
+ * <!-- Determinate task progress -->
+ * <talos-progress-bar [value]="65" label="Uploading telemetry" showValue />
+ *
+ * <!-- Indeterminate background worker -->
+ * <talos-progress-bar mode="indeterminate" variant="info" size="sm" />
+ *
+ * <!-- Streaming buffer mode -->
+ * <talos-progress-bar mode="buffer" [value]="35" [bufferValue]="75" variant="primary" />
+ *
+ * <!-- Animated striped bar with inside label -->
+ * <talos-progress-bar [value]="82" size="xl" striped animated variant="success" [showValue]="true" valuePosition="inside" />
+ * ```
+ */
+declare class TalosProgressBarComponent {
+    /**
+     * Current progress value, evaluated between `min` and `max`.
+     * @default 0
+     */
+    readonly value: _angular_core.InputSignal<number>;
+    /**
+     * Secondary buffer progress value for streaming or staged downloads.
+     * Only active when `mode` is 'buffer'.
+     */
+    readonly bufferValue: _angular_core.InputSignal<number | undefined>;
+    /**
+     * Minimum possible numerical value.
+     * @default 0
+     */
+    readonly min: _angular_core.InputSignal<number>;
+    /**
+     * Maximum possible numerical value.
+     * @default 100
+     */
+    readonly max: _angular_core.InputSignal<number>;
+    /**
+     * Operational mode of the progress bar.
+     * @default 'determinate'
+     */
+    readonly mode: _angular_core.InputSignal<TalosProgressBarMode>;
+    /**
+     * Semantic color theme variant.
+     * @default 'primary'
+     */
+    readonly variant: _angular_core.InputSignal<TalosProgressBarVariant>;
+    /**
+     * Track height size preset.
+     * @default 'md'
+     */
+    readonly size: _angular_core.InputSignal<TalosProgressBarSize>;
+    /**
+     * Corner rounding shape of the progress track.
+     * @default 'rounded'
+     */
+    readonly shape: _angular_core.InputSignal<TalosProgressBarShape>;
+    /**
+     * Whether to display diagonal textured stripes across the fill.
+     * @default false
+     */
+    readonly striped: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Whether to continuously animate the striped texture pattern.
+     * @default false
+     */
+    readonly animated: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Whether to display the calculated or formatted progress value label.
+     * @default false
+     */
+    readonly showValue: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Positioning of the value indicator relative to the progress bar.
+     * @default 'end'
+     */
+    readonly valuePosition: _angular_core.InputSignal<TalosProgressBarValuePosition>;
+    /**
+     * Optional custom formatting function for the displayed value.
+     * Receives current numerical value and calculated percentage.
+     */
+    readonly valueFormatter: _angular_core.InputSignal<TalosProgressBarFormatter | undefined>;
+    /**
+     * Optional primary text label describing the progress context.
+     */
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Placement of the text label relative to the track.
+     * @default 'top'
+     */
+    readonly labelPosition: _angular_core.InputSignal<TalosProgressBarLabelPosition>;
+    /**
+     * Custom CSS color override for the fill bar (e.g. hex, rgb, or css variable).
+     */
+    readonly color: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Custom CSS background color override for the track.
+     */
+    readonly trackColor: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Custom CSS background color override for the buffer bar.
+     */
+    readonly bufferColor: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Custom explicit track height override (e.g., '14px', '1.25rem', or number in pixels).
+     */
+    readonly height: _angular_core.InputSignal<string | number | undefined>;
+    /**
+     * Accessible description announced by screen readers.
+     * Falls back to `label` or 'Progress'.
+     */
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    /**
+     * ID of an external DOM element that labels this progress bar.
+     */
+    readonly ariaLabelledby: _angular_core.InputSignal<string | undefined>;
+    /** Numerical value safely clamped within [min, max] */
+    readonly clampedValue: _angular_core.Signal<number>;
+    /** Scaled percentage (0 - 100) of primary progress */
+    readonly percentage: _angular_core.Signal<number>;
+    /** Scaled percentage (0 - 100) of buffer progress */
+    readonly bufferPercentage: _angular_core.Signal<number>;
+    /** Whether the progress bar operates in buffer mode */
+    readonly isBuffer: _angular_core.Signal<boolean>;
+    /** Whether the progress bar operates in an indeterminate state */
+    readonly isIndeterminate: _angular_core.Signal<boolean>;
+    /** Formatted display string for the progress value */
+    readonly formattedValue: _angular_core.Signal<string>;
+    /** Resolved accessible label */
+    readonly resolvedAriaLabel: _angular_core.Signal<string>;
+    /** Resolved track height override */
+    readonly computedHeight: _angular_core.Signal<string | null>;
+    /** Whether the value is aligned inline (start or end) alongside the bar */
+    readonly isInlineValueLayout: _angular_core.Signal<boolean>;
+    /** Optional projected custom label directive */
+    readonly customLabel: _angular_core.Signal<TalosProgressLabelDirective | undefined>;
+    /** Optional projected custom value directive */
+    readonly customValue: _angular_core.Signal<TalosProgressValueDirective | undefined>;
+    /** Optional projected custom hint directive */
+    readonly customHint: _angular_core.Signal<TalosProgressHintDirective | undefined>;
+    /** Whether top header container should render */
+    readonly shouldRenderHeader: _angular_core.Signal<boolean>;
+    /** Whether bottom footer container should render */
+    readonly shouldRenderFooter: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosProgressBarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TalosProgressBarComponent, "talos-progress-bar, [talosProgressBar]", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "bufferValue": { "alias": "bufferValue"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "striped": { "alias": "striped"; "required": false; "isSignal": true; }; "animated": { "alias": "animated"; "required": false; "isSignal": true; }; "showValue": { "alias": "showValue"; "required": false; "isSignal": true; }; "valuePosition": { "alias": "valuePosition"; "required": false; "isSignal": true; }; "valueFormatter": { "alias": "valueFormatter"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "labelPosition": { "alias": "labelPosition"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "trackColor": { "alias": "trackColor"; "required": false; "isSignal": true; }; "bufferColor": { "alias": "bufferColor"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "ariaLabelledby"; "required": false; "isSignal": true; }; }, {}, ["customLabel", "customValue", "customHint"], ["[talosProgressLabel], talos-progress-label", "[talosProgressValue], talos-progress-value", "[talosProgressHint], talos-progress-hint", "[talosProgressHint], talos-progress-hint"], true, never>;
+}
+
+declare class TalosProgressBarModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosProgressBarModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<TalosProgressBarModule, never, [typeof TalosProgressBarComponent, typeof TalosProgressLabelDirective, typeof TalosProgressValueDirective, typeof TalosProgressHintDirective], [typeof TalosProgressBarComponent, typeof TalosProgressLabelDirective, typeof TalosProgressValueDirective, typeof TalosProgressHintDirective]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<TalosProgressBarModule>;
+}
+
+/**
+ * Visual shape variant for the skeleton placeholder.
+ * - 'text': Standard typography line with slight corner rounding.
+ * - 'circular' / 'avatar': Perfectly circular element (e.g., avatars, icon indicators).
+ * - 'rectangular': Sharp or subtly rounded rectangular container (e.g., images, banners, card media).
+ * - 'rounded' / 'button': Rounded container with standard border radius (e.g., buttons, tags, chips).
+ * - 'card': Composite layout container placeholder.
+ */
+type TalosSkeletonVariant = 'text' | 'circular' | 'avatar' | 'rectangular' | 'rounded' | 'button' | 'card';
+/**
+ * Animation style for the skeleton loading effect.
+ * - 'shimmer': Continuous sliding gradient wave shine.
+ * - 'pulse': Smooth opacity breathing effect.
+ * - 'none': Static placeholder without movement.
+ */
+type TalosSkeletonAnimation = 'shimmer' | 'pulse' | 'none';
+/**
+ * Standard sizing presets for typography and circular skeleton loaders.
+ */
+type TalosSkeletonSize = 'xs' | 'sm' | 'md' | 'lg';
+/**
+ * Configuration options for the skeleton loader directive.
+ */
+interface TalosSkeletonOptions {
+    /** Visual shape of the skeleton mask */
+    variant?: TalosSkeletonVariant;
+    /** Animation style */
+    animation?: TalosSkeletonAnimation;
+    /** Width override */
+    width?: string | number;
+    /** Height override */
+    height?: string | number;
+    /** Custom border radius override */
+    borderRadius?: string | number;
+    /** Custom accessible label */
+    ariaLabel?: string;
+}
+/**
+ * Normalizes CSS dimension input (number converted to px string, or raw string).
+ * @param value Dimension input as string or number
+ * @returns CSS dimension string or undefined
+ */
+declare function resolveCssDimension(value: string | number | null | undefined): string | undefined;
+
+/**
+ * Directive that attaches skeleton loading state directly to any HTML tag or component.
+ *
+ * Conceals element content and text while preserving exact layout geometry and dimensions
+ * (0 Cumulative Layout Shift), while applying an animated shimmer or pulse placeholder mask.
+ *
+ * @example
+ * ```html
+ * <h3 [talosSkeleton]="isLoading()">{{ profile().name }}</h3>
+ * <button [talosSkeleton]="isSaving()" talosButton>Submit</button>
+ * <div [talosSkeleton]="loading()" talosSkeletonShape="circular" style="width: 48px; height: 48px;"></div>
+ * ```
+ */
+declare class TalosSkeletonDirective {
+    /**
+     * Whether the skeleton loading state is active.
+     * Accepts a boolean, string ('true'/'false'/empty attribute), or signal value.
+     */
+    readonly talosSkeleton: _angular_core.InputSignal<string | boolean | null | undefined>;
+    /**
+     * Animation style when skeleton state is active.
+     * @default 'shimmer'
+     */
+    readonly animation: _angular_core.InputSignal<TalosSkeletonAnimation>;
+    /**
+     * Visual shape variant of the attached skeleton mask.
+     * @default 'rounded'
+     */
+    readonly shape: _angular_core.InputSignal<TalosSkeletonVariant>;
+    /**
+     * Visual shape alias for consistency with variant.
+     */
+    readonly variant: _angular_core.InputSignal<TalosSkeletonVariant | undefined>;
+    /**
+     * Explicit width override while loading.
+     */
+    readonly width: _angular_core.InputSignal<string | number | undefined>;
+    /**
+     * Explicit height override while loading.
+     */
+    readonly height: _angular_core.InputSignal<string | number | undefined>;
+    /**
+     * Explicit border-radius override while loading.
+     */
+    readonly borderRadius: _angular_core.InputSignal<string | number | undefined>;
+    /**
+     * Accessible description announced to assistive technology when busy.
+     * @default 'Loading content...'
+     */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /** Resolved active state boolean */
+    readonly isActive: _angular_core.Signal<boolean>;
+    /** Resolved active shape variant */
+    readonly activeShape: _angular_core.Signal<TalosSkeletonVariant>;
+    readonly isCircular: _angular_core.Signal<boolean>;
+    readonly isRounded: _angular_core.Signal<boolean>;
+    readonly isRectangular: _angular_core.Signal<boolean>;
+    readonly computedWidth: _angular_core.Signal<string | null>;
+    readonly computedHeight: _angular_core.Signal<string | null>;
+    readonly computedRadius: _angular_core.Signal<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosSkeletonDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TalosSkeletonDirective, "[talosSkeleton]", never, { "talosSkeleton": { "alias": "talosSkeleton"; "required": false; "isSignal": true; }; "animation": { "alias": "talosSkeletonAnimation"; "required": false; "isSignal": true; }; "shape": { "alias": "talosSkeletonShape"; "required": false; "isSignal": true; }; "variant": { "alias": "talosSkeletonVariant"; "required": false; "isSignal": true; }; "width": { "alias": "talosSkeletonWidth"; "required": false; "isSignal": true; }; "height": { "alias": "talosSkeletonHeight"; "required": false; "isSignal": true; }; "borderRadius": { "alias": "talosSkeletonRadius"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "talosSkeletonAriaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Modern, accessible skeleton loader placeholder component for asynchronous data loading states.
+ *
+ * Supports various geometric shapes, fluid shimmer/pulse animations, multi-line typography
+ * simulation with customizable last line tapering, and automatic content projection toggle.
+ *
+ * @example
+ * ```html
+ * <!-- Single line or custom shape -->
+ * <talos-skeleton variant="text" width="180px" />
+ * <talos-skeleton variant="circular" width="48px" height="48px" />
+ *
+ * <!-- Multi-line paragraph -->
+ * <talos-skeleton variant="text" [count]="3" lastLineWidth="65%" />
+ *
+ * <!-- Conditional content wrapper -->
+ * <talos-skeleton [loading]="isLoading()">
+ *   <div class="user-content">Loaded User Profile</div>
+ * </talos-skeleton>
+ * ```
+ */
+declare class TalosSkeletonComponent {
+    /**
+     * Visual shape variant of the skeleton.
+     * @default 'text'
+     */
+    readonly variant: _angular_core.InputSignal<TalosSkeletonVariant>;
+    /**
+     * Animation style applied while loading.
+     * @default 'shimmer'
+     */
+    readonly animation: _angular_core.InputSignal<TalosSkeletonAnimation>;
+    /**
+     * Sizing scale preset for text and circular variants.
+     * @default 'md'
+     */
+    readonly size: _angular_core.InputSignal<TalosSkeletonSize>;
+    /**
+     * Explicit width override (e.g., '100%', '240px', or number in pixels).
+     */
+    readonly width: _angular_core.InputSignal<string | number | undefined>;
+    /**
+     * Explicit height override (e.g., '2rem', '48px', or number in pixels).
+     */
+    readonly height: _angular_core.InputSignal<string | number | undefined>;
+    /**
+     * Custom border radius override (e.g., '6px', '50%').
+     */
+    readonly borderRadius: _angular_core.InputSignal<string | number | undefined>;
+    /**
+     * Number of lines to render for multi-line text placeholders.
+     * @default 1
+     */
+    readonly count: _angular_core.InputSignal<number>;
+    /**
+     * Width of the last line when `count` > 1 (e.g. '60%' for realistic paragraph tapering).
+     * @default '60%'
+     */
+    readonly lastLineWidth: _angular_core.InputSignal<string | number>;
+    /**
+     * Spacing gap between lines when `count` > 1.
+     * @default '0.5rem'
+     */
+    readonly gap: _angular_core.InputSignal<string | number>;
+    /**
+     * Whether the skeleton is actively in a loading state.
+     * When false, the skeleton hides and projects inner `<ng-content>`.
+     * @default true
+     */
+    readonly loading: _angular_core.InputSignal<boolean>;
+    /**
+     * Accessible description for screen readers during loading.
+     * @default 'Loading content...'
+     */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /** Whether the component represents a circular shape (circle or avatar) */
+    readonly isCircular: _angular_core.Signal<boolean>;
+    /** Whether the component represents a rounded shape (rounded or button) */
+    readonly isRounded: _angular_core.Signal<boolean>;
+    /** Whether this is a multi-line text skeleton */
+    readonly isMultiLine: _angular_core.Signal<boolean>;
+    /** Normalized line array for multi-line rendering */
+    readonly lineIndices: _angular_core.Signal<number[]>;
+    /** Resolved CSS width string */
+    readonly computedWidth: _angular_core.Signal<string | null>;
+    /** Resolved CSS height string */
+    readonly computedHeight: _angular_core.Signal<string | null>;
+    /** Resolved CSS border radius string */
+    readonly computedRadius: _angular_core.Signal<string | null>;
+    /** Resolved CSS gap string */
+    readonly computedGap: _angular_core.Signal<string>;
+    /**
+     * Computes the width for an individual line in multi-line text mode.
+     * @param index Line index (0-based)
+     */
+    getLineWidth(index: number): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosSkeletonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TalosSkeletonComponent, "talos-skeleton", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "animation": { "alias": "animation"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "borderRadius": { "alias": "borderRadius"; "required": false; "isSignal": true; }; "count": { "alias": "count"; "required": false; "isSignal": true; }; "lastLineWidth": { "alias": "lastLineWidth"; "required": false; "isSignal": true; }; "gap": { "alias": "gap"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class TalosSkeletonModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosSkeletonModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<TalosSkeletonModule, never, [typeof TalosSkeletonComponent, typeof TalosSkeletonDirective], [typeof TalosSkeletonComponent, typeof TalosSkeletonDirective]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<TalosSkeletonModule>;
+}
+
+type TalosSnackbarVariant = 'default' | 'info' | 'success' | 'warning' | 'error';
+type TalosSnackbarPosition = 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';
+interface TalosSnackbarConfig {
+    /** Title text shown above message */
+    title?: string;
+    /** Main message text or custom Angular TemplateRef */
+    message: string | TemplateRef<unknown>;
+    /** Visual variant theme */
+    variant?: TalosSnackbarVariant;
+    /** Screen position placement */
+    position?: TalosSnackbarPosition;
+    /** Auto-dismiss duration in milliseconds. 0 or Infinity for persistent. Default: 4000ms */
+    duration?: number;
+    /** Whether to show a close button ('X'). Default: true */
+    dismissible?: boolean;
+    /** Text label for an action button (e.g., 'Undo', 'Retry') */
+    actionLabel?: string;
+    /** Callback fired when action button is clicked */
+    onAction?: () => void;
+    /** Callback fired when snackbar is dismissed */
+    onDismiss?: () => void;
+    /** Custom CSS class name to append to the snackbar element */
+    customClass?: string;
+    /** Whether to display a timer progress bar at the bottom. Default: true */
+    showProgressBar?: boolean;
+    /** Whether mouse hover pauses auto-dismiss countdown. Default: true */
+    pauseOnHover?: boolean;
+    /** Custom Lucide icon component or null/false to hide icon */
+    icon?: Type<unknown> | null | boolean;
+    /** Optional custom data context when using TemplateRef */
+    data?: unknown;
+}
+interface TalosSnackbarRef {
+    /** Unique ID of the snackbar instance */
+    readonly id: string;
+    /** Programmatically dismiss this snackbar */
+    dismiss: () => void;
+}
+interface TalosSnackbarInstance extends Required<Omit<TalosSnackbarConfig, 'title' | 'actionLabel' | 'onAction' | 'onDismiss' | 'customClass' | 'icon' | 'data'>> {
+    id: string;
+    title?: string;
+    actionLabel?: string;
+    onAction?: () => void;
+    onDismiss?: () => void;
+    customClass?: string;
+    icon?: Type<unknown> | null | boolean;
+    data?: unknown;
+    createdAt: number;
+    isPaused: boolean;
+}
+
+declare class TalosSnackbarService {
+    private readonly overlay;
+    private overlayRef;
+    /** Reactive list of currently active snackbar instances */
+    readonly snackbars: _angular_core.WritableSignal<TalosSnackbarInstance[]>;
+    private idCounter;
+    /** Global default configuration values */
+    private defaultConfig;
+    /**
+     * Override default global configurations for all subsequent snackbars.
+     */
+    setDefaultConfig(config: Partial<TalosSnackbarConfig>): void;
+    /**
+     * Main entry point to open a configured snackbar.
+     */
+    show(messageOrConfig: string | TemplateRef<unknown> | TalosSnackbarConfig, configOverrides?: Partial<TalosSnackbarConfig>): TalosSnackbarRef;
+    /** Convenience method for Success variant snackbars */
+    success(message: string | TemplateRef<unknown>, config?: Partial<TalosSnackbarConfig>): TalosSnackbarRef;
+    /** Convenience method for Error variant snackbars */
+    error(message: string | TemplateRef<unknown>, config?: Partial<TalosSnackbarConfig>): TalosSnackbarRef;
+    /** Convenience method for Warning variant snackbars */
+    warning(message: string | TemplateRef<unknown>, config?: Partial<TalosSnackbarConfig>): TalosSnackbarRef;
+    /** Convenience method for Info variant snackbars */
+    info(message: string | TemplateRef<unknown>, config?: Partial<TalosSnackbarConfig>): TalosSnackbarRef;
+    /**
+     * Dismiss a specific snackbar by ID, or the oldest active snackbar if no ID is specified.
+     */
+    dismiss(id?: string): void;
+    /**
+     * Dismiss all currently active snackbars.
+     */
+    dismissAll(): void;
+    private ensureOverlayCreated;
+    private destroyOverlay;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosSnackbarService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TalosSnackbarService>;
+}
+
+declare class TalosSnackbarComponent implements OnInit, OnDestroy {
+    /** Snackbar instance data */
+    readonly instance: _angular_core.InputSignal<TalosSnackbarInstance>;
+    /** Event emitted when snackbar requests dismissal */
+    readonly dismiss: _angular_core.OutputEmitterRef<string>;
+    /** Event emitted when snackbar action button is clicked */
+    readonly action: _angular_core.OutputEmitterRef<string>;
+    protected readonly isDismissing: _angular_core.WritableSignal<boolean>;
+    protected readonly progressPercent: _angular_core.WritableSignal<number>;
+    protected readonly Infinity: number;
+    private timerId;
+    private remainingMs;
+    private lastTickMs;
+    readonly isTopPosition: _angular_core.Signal<boolean>;
+    readonly isTemplateMessage: _angular_core.Signal<boolean>;
+    readonly templateMessage: _angular_core.Signal<TemplateRef<unknown>>;
+    readonly customIconComponent: _angular_core.Signal<Type<unknown> | null>;
+    readonly ariaRole: _angular_core.Signal<"alert" | "status">;
+    readonly ariaLive: _angular_core.Signal<"assertive" | "polite">;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private startTimer;
+    private stopTimer;
+    protected onMouseEnter(): void;
+    protected onMouseLeave(): void;
+    protected onActionClick(): void;
+    protected onCloseClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosSnackbarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TalosSnackbarComponent, "talos-snackbar", never, { "instance": { "alias": "instance"; "required": true; "isSignal": true; }; }, { "dismiss": "dismiss"; "action": "action"; }, never, never, true, never>;
+}
+
+declare class TalosSnackbarContainerComponent {
+    private readonly snackbarService;
+    readonly positions: TalosSnackbarPosition[];
+    readonly groupedSnackbars: _angular_core.Signal<Record<TalosSnackbarPosition, TalosSnackbarInstance[]>>;
+    onDismiss(id: string): void;
+    onAction(id: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosSnackbarContainerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TalosSnackbarContainerComponent, "talos-snackbar-container", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Convenience NgModule wrapping standalone snackbar components.
+ *
+ * Allows developers who prefer `TalosSnackbarModule` to import all snackbar elements in one go.
+ */
+declare class TalosSnackbarModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosSnackbarModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<TalosSnackbarModule, never, [typeof TalosSnackbarComponent, typeof TalosSnackbarContainerComponent], [typeof TalosSnackbarComponent, typeof TalosSnackbarContainerComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<TalosSnackbarModule>;
+}
+
+/**
+ * Sizing presets for the loading spinner diameter.
+ * - 'xs': 16px (dense inline buttons, form affix, tags)
+ * - 'sm': 20px (standard compact buttons, table cells)
+ * - 'md': 28px (default cards, content sections)
+ * - 'lg': 40px (prominent view loader, dialogs)
+ * - 'xl': 56px (full-page or hero loading states)
+ */
+type TalosSpinnerSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+/**
+ * Visual semantic variant palette for the loading spinner.
+ */
+type TalosSpinnerVariant = 'primary' | 'secondary' | 'success' | 'warning' | 'danger' | 'error' | 'info' | 'neutral' | 'subtle' | 'outline' | 'inherit';
+/**
+ * Animation and visual rendering type for the loading spinner.
+ * - 'circular': Modern SVG ring with animated rotating dash offset (default).
+ * - 'dots': Three rhythmic pulsing / bouncing dots for compact inline loading.
+ * - 'ring': Smooth dual-arc or segmented rotating ring.
+ * - 'orbit': Modern dual-node orbital rotation for rich dashboards.
+ */
+type TalosSpinnerType = 'circular' | 'dots' | 'ring' | 'orbit';
+/**
+ * Rotation and animation speed presets.
+ * - 'slow': 1.5s per cycle
+ * - 'normal': 0.85s per cycle (default)
+ * - 'fast': 0.5s per cycle
+ */
+type TalosSpinnerSpeed = 'slow' | 'normal' | 'fast';
+/**
+ * Placement of the optional label text relative to the spinner.
+ * - 'bottom': Centered below the spinner (default for block/card layouts)
+ * - 'top': Centered above the spinner
+ * - 'end' / 'inline': Positioned to the right in an inline horizontal layout
+ * - 'start': Positioned to the left in an inline horizontal layout
+ */
+type TalosSpinnerLabelPosition = 'top' | 'bottom' | 'start' | 'end' | 'inline';
+/**
+ * Configuration options for the global spinner service and programmatic triggers.
+ */
+interface TalosSpinnerConfig {
+    /** Text message or description to display */
+    message?: string;
+    /** Visual semantic variant */
+    variant?: TalosSpinnerVariant;
+    /** Size preset or custom dimension */
+    size?: TalosSpinnerSize | string | number;
+    /** Spinner rendering type */
+    type?: TalosSpinnerType;
+    /** Whether to apply a frosted glassmorphic backdrop blur */
+    blur?: boolean;
+    /** Whether to render over full screen viewport */
+    fullscreen?: boolean;
+    /** Custom accessible label */
+    ariaLabel?: string;
+}
+/**
+ * Maps standard sizing presets to pixel dimensions.
+ */
+declare const SPINNER_SIZE_MAP: Record<TalosSpinnerSize, number>;
+/**
+ * Maps standard sizing presets to default stroke / track widths.
+ */
+declare const SPINNER_STROKE_MAP: Record<TalosSpinnerSize, number>;
+/**
+ * Normalizes CSS dimension input (number converted to px string, or raw string).
+ *
+ * @param value Dimension input as string or number
+ * @returns CSS dimension string or undefined
+ */
+declare function resolveSpinnerDimension(value: string | number | null | undefined): string | undefined;
+/**
+ * Extracts a numeric pixel dimension or falls back to size preset lookup.
+ *
+ * @param size Preset or custom dimension
+ * @returns Numeric pixel size
+ */
+declare function resolveNumericSize(size: TalosSpinnerSize | string | number | undefined): number;
+
+/**
+ * Structural / content directive for marking custom spinner label templates.
+ *
+ * @example
+ * ```html
+ * <talos-spinner>
+ *   <span *talosSpinnerLabel class="custom-label">
+ *     Syncing <strong>24/100</strong> files...
+ *   </span>
+ * </talos-spinner>
+ * ```
+ */
+declare class TalosSpinnerLabelDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosSpinnerLabelDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TalosSpinnerLabelDirective, "[talosSpinnerLabel]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Directive that attaches an accessible loading spinner overlay directly onto any container element
+ * (e.g., card, panel, table, or form section).
+ *
+ * When active, it dims the host container, applies an optional blur effect, disables interactions,
+ * and renders a centered spinner indicator with optional message.
+ *
+ * @example
+ * ```html
+ * <div [talosSpinnerOverlay]="isUpdating()" talosSpinnerMessage="Saving changes..." talosSpinnerVariant="primary">
+ *   <p>Card Content...</p>
+ * </div>
+ * ```
+ */
+declare class TalosSpinnerOverlayDirective implements OnDestroy {
+    private readonly elementRef;
+    private readonly renderer;
+    private readonly appRef;
+    private readonly envInjector;
+    private overlayElement;
+    private spinnerRef;
+    /**
+     * Whether the loading overlay is currently active.
+     */
+    readonly talosSpinnerOverlay: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Alias input `talosLoading` for concise developer ergonomics.
+     */
+    readonly talosLoading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Optional loading message or status string to display below the spinner.
+     */
+    readonly message: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Semantic color variant for the attached spinner overlay.
+     * @default 'primary'
+     */
+    readonly variant: _angular_core.InputSignal<TalosSpinnerVariant>;
+    /**
+     * Size preset for the attached spinner indicator.
+     * @default 'md'
+     */
+    readonly size: _angular_core.InputSignal<TalosSpinnerSize>;
+    /**
+     * Animation rendering type for the attached spinner indicator.
+     * @default 'circular'
+     */
+    readonly type: _angular_core.InputSignal<TalosSpinnerType>;
+    /**
+     * Whether to apply a frosted glassmorphic backdrop blur effect.
+     * @default true
+     */
+    readonly blur: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Accessible description announced by assistive technologies.
+     */
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    constructor();
+    /**
+     * Computes whether the overlay is active from either primary input or alias.
+     */
+    isActive(): boolean;
+    private renderOverlay;
+    private updateSpinnerInputs;
+    private removeOverlay;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosSpinnerOverlayDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TalosSpinnerOverlayDirective, "[talosSpinnerOverlay], [talosLoading]", never, { "talosSpinnerOverlay": { "alias": "talosSpinnerOverlay"; "required": false; "isSignal": true; }; "talosLoading": { "alias": "talosLoading"; "required": false; "isSignal": true; }; "message": { "alias": "talosSpinnerMessage"; "required": false; "isSignal": true; }; "variant": { "alias": "talosSpinnerVariant"; "required": false; "isSignal": true; }; "size": { "alias": "talosSpinnerSize"; "required": false; "isSignal": true; }; "type": { "alias": "talosSpinnerType"; "required": false; "isSignal": true; }; "blur": { "alias": "talosSpinnerBlur"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "talosSpinnerAriaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Global singleton service for displaying full-page or application-level loading spinners.
+ *
+ * Implements reference-counting so concurrent asynchronous operations (such as parallel HTTP requests
+ * or multi-stage workflow transitions) can safely call `show()` and `hide()` without prematurely
+ * dismissing the indicator while other background tasks are still in progress.
+ *
+ * @example
+ * ```typescript
+ * const spinner = inject(TalosSpinnerService);
+ *
+ * // Basic usage
+ * spinner.show('Syncing database...');
+ * await syncData();
+ * spinner.hide();
+ *
+ * // Advanced configuration
+ * spinner.show({
+ *   message: 'Processing batch export...',
+ *   variant: 'primary',
+ *   size: 'lg',
+ *   blur: true
+ * });
+ * ```
+ */
+declare class TalosSpinnerService {
+    /** Active concurrent request counter */
+    private readonly requestCount;
+    /** Current active spinner configuration */
+    private readonly currentConfig;
+    /** Whether the global spinner is currently active */
+    readonly active: _angular_core.Signal<boolean>;
+    /** The message currently displayed on the global spinner */
+    readonly message: _angular_core.Signal<string | undefined>;
+    /** The color variant currently used on the global spinner */
+    readonly variant: _angular_core.Signal<TalosSpinnerVariant>;
+    /** The size preset currently used on the global spinner */
+    readonly size: _angular_core.Signal<string | number>;
+    /** The animation type currently used on the global spinner */
+    readonly type: _angular_core.Signal<TalosSpinnerType>;
+    /** Whether backdrop blur is enabled for the global spinner */
+    readonly blur: _angular_core.Signal<boolean>;
+    /** Accessible label announced to screen readers */
+    readonly ariaLabel: _angular_core.Signal<string>;
+    /**
+     * Activates the global loading spinner or increments the active operation counter.
+     *
+     * @param configOrMessage Optional configuration object or text message string
+     */
+    show(configOrMessage?: TalosSpinnerConfig | string): void;
+    /**
+     * Decrements the active operation counter. Dismisses the global spinner once all operations have completed.
+     */
+    hide(): void;
+    /**
+     * Immediately clears all active requests and forces the global spinner to hide.
+     */
+    forceHide(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosSpinnerService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TalosSpinnerService>;
+}
+
+/**
+ * Modern, accessible loading spinner component for inline button indicators,
+ * contextual card loading overlays, and global asynchronous feedback.
+ *
+ * Fully reactive via Angular signals with support for circular, dots, ring,
+ * and orbital animations, standard sizing presets, semantic variants, and WCAG AA compliance.
+ *
+ * @example
+ * ```html
+ * <!-- Standard inline spinner -->
+ * <talos-spinner size="sm" variant="primary" />
+ *
+ * <!-- Centered card overlay with custom label -->
+ * <talos-spinner [overlay]="true" [loading]="isSyncing()" label="Synchronizing records...">
+ *   <div class="card-content">...</div>
+ * </talos-spinner>
+ *
+ * <!-- Bouncing dots variant for button states -->
+ * <talos-spinner type="dots" size="xs" variant="inherit" />
+ * ```
+ */
+declare class TalosSpinnerComponent {
+    /**
+     * Visual semantic variant palette for the spinner stroke and accents.
+     * @default 'primary'
+     */
+    readonly variant: _angular_core.InputSignal<TalosSpinnerVariant>;
+    /**
+     * Sizing preset ('xs' | 'sm' | 'md' | 'lg' | 'xl') or custom numerical / CSS dimension.
+     * @default 'md'
+     */
+    readonly size: _angular_core.InputSignal<string | number>;
+    /**
+     * Animation visual rendering type.
+     * @default 'circular'
+     */
+    readonly type: _angular_core.InputSignal<TalosSpinnerType>;
+    /**
+     * Cycle animation speed preset.
+     * @default 'normal'
+     */
+    readonly speed: _angular_core.InputSignal<TalosSpinnerSpeed>;
+    /**
+     * Custom stroke width in pixels for SVG circular / ring animations.
+     */
+    readonly strokeWidth: _angular_core.InputSignal<number | undefined>;
+    /**
+     * Custom CSS color override for the animated spinner fill.
+     */
+    readonly color: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Custom CSS background color override for the subtle circular track ring.
+     */
+    readonly trackColor: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Whether to render the secondary background track ring.
+     * @default true
+     */
+    readonly showTrack: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Optional visible text label displayed next to or below the spinner.
+     */
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Position of the label text relative to the spinner indicator.
+     * @default 'bottom'
+     */
+    readonly labelPosition: _angular_core.InputSignal<TalosSpinnerLabelPosition>;
+    /**
+     * Whether this spinner functions as a container wrapper overlay over projected content.
+     * @default false
+     */
+    readonly overlay: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Active state when used as an overlay wrapper.
+     * @default true
+     */
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Whether to apply a frosted glassmorphic backdrop blur to the container overlay.
+     * @default false
+     */
+    readonly blur: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Whether this overlay covers the full viewport screen.
+     * @default false
+     */
+    readonly fullscreen: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Accessible description announced to screen readers.
+     * Defaults to `label` or 'Loading, please wait...'.
+     */
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    /** Projected custom label directive */
+    readonly customLabel: _angular_core.Signal<TalosSpinnerLabelDirective | undefined>;
+    /** Evaluated numeric pixel diameter */
+    readonly numericSize: _angular_core.Signal<number>;
+    /** Computed CSS dimension string (e.g., '28px') */
+    readonly computedDimension: _angular_core.Signal<string | null>;
+    /** Evaluated stroke width based on size or custom input */
+    readonly computedStrokeWidth: _angular_core.Signal<number>;
+    /** Radius of SVG circle taking stroke into account */
+    readonly computedRadius: _angular_core.Signal<number>;
+    /** Circumference of SVG circle for stroke dash animations */
+    readonly computedCircumference: _angular_core.Signal<number>;
+    /** Dash array for SVG circular arc */
+    readonly computedDashArray: _angular_core.Signal<string>;
+    /** Dash offset for initial arc position */
+    readonly computedDashOffset: _angular_core.Signal<number>;
+    /** Resolved accessible label */
+    readonly resolvedAriaLabel: _angular_core.Signal<string>;
+    /** Whether the label is arranged in horizontal inline layout with the spinner */
+    readonly isInlineLayout: _angular_core.Signal<boolean>;
+    /** Whether the overlay is actively showing */
+    readonly isOverlayActive: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosSpinnerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TalosSpinnerComponent, "talos-spinner, talos-loading-spinner, [talosSpinner], [talosLoadingSpinner]", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "speed": { "alias": "speed"; "required": false; "isSignal": true; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "trackColor": { "alias": "trackColor"; "required": false; "isSignal": true; }; "showTrack": { "alias": "showTrack"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "labelPosition": { "alias": "labelPosition"; "required": false; "isSignal": true; }; "overlay": { "alias": "overlay"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "blur": { "alias": "blur"; "required": false; "isSignal": true; }; "fullscreen": { "alias": "fullscreen"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, ["customLabel"], ["*", "[talosSpinnerLabel]"], true, never>;
+}
+/**
+ * Global overlay component connected to `TalosSpinnerService`.
+ *
+ * Can be placed in the root template (`app.component.html`) to provide a reactive,
+ * unified full-screen loading state for all global asynchronous background processes.
+ *
+ * @example
+ * ```html
+ * <!-- In app.component.html -->
+ * <talos-global-spinner />
+ * ```
+ */
+declare class TalosGlobalSpinnerComponent {
+    readonly spinnerService: TalosSpinnerService;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosGlobalSpinnerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TalosGlobalSpinnerComponent, "talos-global-spinner", never, {}, {}, never, never, true, never>;
+}
+
+declare class TalosSpinnerModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosSpinnerModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<TalosSpinnerModule, never, [typeof TalosSpinnerComponent, typeof TalosGlobalSpinnerComponent, typeof TalosSpinnerLabelDirective, typeof TalosSpinnerOverlayDirective], [typeof TalosSpinnerComponent, typeof TalosGlobalSpinnerComponent, typeof TalosSpinnerLabelDirective, typeof TalosSpinnerOverlayDirective]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<TalosSpinnerModule>;
+}
+
+type TooltipPosition = 'top' | 'left' | 'right' | 'bottom' | 'auto';
+declare class TalosTooltipComponent {
+    readonly text: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosTooltipComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TalosTooltipComponent, "talos-tooltip-content", never, { "text": { "alias": "text"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class TalosTooltipDirective implements OnInit {
+    private readonly elementRef;
+    private readonly overlay;
+    private readonly destroyRef;
+    private readonly injector;
+    private readonly focusMonitor;
+    readonly tooltip: _angular_core.InputSignal<string>;
+    readonly tooltipContent: _angular_core.InputSignal<string>;
+    readonly position: _angular_core.InputSignal<TooltipPosition>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    private overlayRef;
+    ngOnInit(): void;
+    get tooltipText(): string;
+    show(): void;
+    hide(): void;
+    private createPositionStrategy;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TalosTooltipDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TalosTooltipDirective, "[talosTooltip], [tooltip]", never, { "tooltip": { "alias": "talosTooltip"; "required": false; "isSignal": true; }; "tooltipContent": { "alias": "tooltip"; "required": false; "isSignal": true; }; "position": { "alias": "tooltipPosition"; "required": false; "isSignal": true; }; "disabled": { "alias": "tooltipDisabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { SPINNER_SIZE_MAP, SPINNER_STROKE_MAP, TALOS_DIALOG_CONFIG, TALOS_DIALOG_DATA, TALOS_DIALOG_REF, TalosAlertActionsDirective, TalosAlertComponent, TalosAlertContainerComponent, TalosAlertDescriptionDirective, TalosAlertIconDirective, TalosAlertModule, TalosAlertService, TalosAlertTitleDirective, TalosConfirmDialogComponent, TalosDialogCloseDirective, TalosDialogContentComponent, TalosDialogDescriptionDirective, TalosDialogFooterComponent, TalosDialogHeaderComponent, TalosDialogModule, TalosDialogRef, TalosDialogService, TalosDialogTitleDirective, TalosGlobalSpinnerComponent, TalosProgressBarComponent, TalosProgressBarModule, TalosProgressHintDirective, TalosProgressLabelDirective, TalosProgressValueDirective, TalosSkeletonComponent, TalosSkeletonDirective, TalosSkeletonModule, TalosSnackbarComponent, TalosSnackbarContainerComponent, TalosSnackbarModule, TalosSnackbarService, TalosSpinnerComponent, TalosSpinnerLabelDirective, TalosSpinnerModule, TalosSpinnerOverlayDirective, TalosSpinnerService, TalosTooltipComponent, TalosTooltipDirective, calculatePercentage, clampProgress, resolveCssDimension, resolveNumericSize, resolveProgressDimension, resolveSpinnerDimension };
+export type { TalosAlertAppearance, TalosAlertConfig, TalosAlertDialogOptions, TalosAlertInstance, TalosAlertRef, TalosAlertSeverity, TalosAlertSize, TalosAlertVariant, TalosConfirmDialogOptions, TalosDialogBlur, TalosDialogConfig, TalosDialogFooterAlign, TalosDialogPadding, TalosDialogSize, TalosDialogVariant, TalosProgressBarFormatter, TalosProgressBarLabelPosition, TalosProgressBarMode, TalosProgressBarShape, TalosProgressBarSize, TalosProgressBarValuePosition, TalosProgressBarVariant, TalosSkeletonAnimation, TalosSkeletonOptions, TalosSkeletonSize, TalosSkeletonVariant, TalosSnackbarConfig, TalosSnackbarInstance, TalosSnackbarPosition, TalosSnackbarRef, TalosSnackbarVariant, TalosSpinnerConfig, TalosSpinnerLabelPosition, TalosSpinnerSize, TalosSpinnerSpeed, TalosSpinnerType, TalosSpinnerVariant, TooltipPosition };
+//# sourceMappingURL=weeehaoooz-talos-ui-feedback.d.ts.map