@cdevhub/ngx-tw 0.2.0

package/types/cdevhub-ngx-tw-dialog.d.ts

@@ -0,0 +1,303 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, Signal, EventEmitter, ComponentRef, OnDestroy, TemplateRef, EnvironmentProviders, OnInit } from '@angular/core';
+import { ComponentType } from '@angular/cdk/portal';
+import { Observable } from 'rxjs';
+import { DialogConfig, AutoFocusTarget, RestoreFocusValue, DialogRole, CdkDialogContainer, DialogRef } from '@angular/cdk/dialog';
+import { OverlayContainerAnimationEvent, OverlayContainerState, TwColor } from '@cdevhub/ngx-tw/core';
+import * as i1 from '@angular/cdk/scrolling';
+
+/** Preset sizes mapped to width constraints for the dialog panel. */
+type TwDialogSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'fullscreen';
+/** ARIA role of the dialog element. Use `'alertdialog'` for destructive confirmation prompts. */
+type TwDialogRole = DialogRole;
+/** Where to move focus when the dialog opens. */
+type TwDialogAutoFocus = AutoFocusTarget | string | boolean;
+/** How to restore focus on close. `true` restores to the previously focused element; a selector or element targets a specific node. */
+type TwDialogRestoreFocus = RestoreFocusValue;
+/** Scroll behavior for content underneath the dialog. */
+type TwDialogScrollStrategy = 'block' | 'close' | 'reposition' | 'noop';
+/**
+ * Configuration for opening a dialog with {@link TwDialog.open}.
+ *
+ * Mirrors the shape of `@angular/cdk/dialog`'s `DialogConfig` with additional
+ * tailwind-focused options (`size`, `enterAnimationDuration`, etc.).
+ */
+declare class TwDialogConfig<D = unknown, R = unknown> extends DialogConfig<D, R> {
+    /** Preset size for the dialog panel. Ignored when `width`/`maxWidth` are provided. Defaults to `'md'`. */
+    size?: TwDialogSize;
+    /** Duration of the open animation in ms. Defaults to `150`. Use `0` to disable. */
+    enterAnimationDuration?: number;
+    /**
+     * Duration of the close animation in ms. Defaults to `120`. Use `0` to disable.
+     * Asymmetric with `enterAnimationDuration` by design: the close transition is
+     * slightly faster so the dialog feels dismissive rather than reluctant.
+     */
+    exitAnimationDuration?: number;
+    /** Scroll strategy preset applied when `scrollStrategy` isn't set. Defaults to `'block'`. */
+    scrollBehavior?: TwDialogScrollStrategy;
+    /** Maximum width. Number values are treated as pixels. Defaults to `'calc(100vw - 32px)'`. */
+    maxWidth?: number | string;
+    /**
+     * Whether the dialog is modal — sets `aria-modal` on the container.
+     * Defaults to `true`: a `role="dialog"` opened over the page is modal by
+     * default and the rest of the document is inert while it is open. Set to
+     * `false` only for non-modal surfaces (rare; consider `popover` instead).
+     */
+    ariaModal?: boolean;
+    /** Whether Escape and backdrop clicks are blocked. Defaults to `false`. */
+    disableClose?: boolean;
+    /** Where to move focus when the dialog opens. Defaults to `'first-tabbable'`. */
+    autoFocus?: TwDialogAutoFocus;
+    /** Whether to restore focus to the previously focused element after close. Defaults to `true`. */
+    restoreFocus?: TwDialogRestoreFocus;
+    /** Whether the dialog renders a backdrop. Defaults to `true`. */
+    hasBackdrop?: boolean;
+    /** Whether navigation (e.g. router) closes the dialog. Defaults to `true`. */
+    closeOnNavigation?: boolean;
+}
+/** Injection token carrying the `data` value passed via {@link TwDialogConfig.data}. */
+declare const TW_DIALOG_DATA: InjectionToken<unknown>;
+/** Injection token for application-wide default dialog options. Set via `provideTwDialog()`. */
+declare const TW_DIALOG_DEFAULT_OPTIONS: InjectionToken<Partial<TwDialogConfig<unknown, unknown>>>;
+
+/** Lifecycle states a dialog passes through. */
+type DialogState = OverlayContainerState;
+/** Event emitted when the dialog's animation state transitions. */
+type DialogAnimationEvent = OverlayContainerAnimationEvent;
+/**
+ * Dialog container rendered inside the CDK overlay. Wraps the user-provided
+ * content in a Tailwind-styled surface and coordinates enter/exit transitions
+ * with {@link TwDialogRef}.
+ *
+ * The animation state machine, `aria-describedby` queue, and panel-class
+ * merge are shared with `SheetContainer` via {@link OverlayContainerCoordinator}
+ * (component-scoped — see `providers: [OverlayContainerCoordinator]`).
+ *
+ * @docs-private
+ */
+declare class DialogContainer extends CdkDialogContainer<TwDialogConfig> {
+    private readonly coordinator;
+    /** Lifecycle state of the dialog's enter/exit animation. */
+    readonly state: Signal<DialogState>;
+    /** Emits whenever the animation state transitions. */
+    readonly animationStateChanged: EventEmitter<DialogAnimationEvent>;
+    /** Resolved enter-animation duration in ms. */
+    readonly enterAnimationDuration: number;
+    /** Resolved exit-animation duration in ms. */
+    readonly exitAnimationDuration: number;
+    private readonly sizeVariant;
+    protected readonly hostClasses: Signal<string>;
+    protected readonly ariaDescribedByAttr: Signal<string | null>;
+    protected readonly transitionDuration: Signal<number>;
+    constructor();
+    protected _contentAttached(): void;
+    /** Triggered by the dialog ref to play the exit transition before disposing the overlay. */
+    _startExitAnimation(): void;
+    /** Registers a description id for the container's `aria-describedby`. */
+    _addAriaDescribedBy(id: string): void;
+    /** Removes a previously registered description id. */
+    _removeAriaDescribedBy(id: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogContainer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogContainer, "tw-dialog-container", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Reference to a dialog opened via {@link TwDialog.open}. Drives the dialog
+ * lifecycle (close, state, observables) and forwards useful overlay streams.
+ */
+declare class TwDialogRef<R = unknown, C = unknown> {
+    private readonly cdkRef;
+    readonly config: TwDialogConfig<unknown, R>;
+    readonly containerInstance: DialogContainer;
+    /** Unique ID of the dialog. */
+    readonly id: string;
+    /** Instance of the component rendered inside the dialog, or `null` for template dialogs. */
+    componentInstance: C | null;
+    /** `ComponentRef` of the content component, or `null` for template dialogs. */
+    readonly componentRef: ComponentRef<C> | null;
+    /** Current lifecycle state. Reactively readable. */
+    readonly state: Signal<DialogState>;
+    /** When `true`, close-via-escape and close-via-backdrop are disabled. */
+    disableClose: boolean | undefined;
+    private readonly stateSignal;
+    private readonly afterOpenedSubject;
+    private readonly beforeClosedSubject;
+    private readonly afterClosedSubject;
+    private pendingResult;
+    private closeFocusOrigin;
+    constructor(cdkRef: DialogRef<R, C>, config: TwDialogConfig<unknown, R>, containerInstance: DialogContainer);
+    /**
+     * Closes the dialog. The exit animation runs before the overlay is disposed.
+     * @param result Value forwarded to `afterClosed()` subscribers.
+     */
+    close(result?: R): void;
+    /** Observable that emits once after the enter animation finishes. */
+    afterOpened(): Observable<void>;
+    /** Observable that emits once when the close animation starts. */
+    beforeClosed(): Observable<R | undefined>;
+    /** Observable that emits once after the dialog has fully closed and the overlay is disposed. */
+    afterClosed(): Observable<R | undefined>;
+    /** Backdrop click stream (emits even when `disableClose` is set). */
+    backdropClick(): Observable<MouseEvent>;
+    /** Keydown event stream for the overlay. */
+    keydownEvents(): Observable<KeyboardEvent>;
+    /** Updates the dialog's width/height. Pass empty string to reset a dimension. */
+    updateSize(width?: string | number, height?: string | number): this;
+    /** Adds CSS classes to the overlay panel. */
+    addPanelClass(classes: string | string[]): this;
+    /** Removes CSS classes from the overlay panel. */
+    removePanelClass(classes: string | string[]): this;
+    private closeWithOrigin;
+    private finishClose;
+}
+
+/**
+ * Opens Tailwind-styled modal dialogs. Composes `@angular/cdk/dialog` for focus
+ * trapping, portals, overlay plumbing, and adds a Tailwind container, richer
+ * ref API, and animation lifecycle.
+ *
+ * Not `providedIn: 'root'` — register it via {@link provideTwDialog}.
+ */
+declare class TwDialog implements OnDestroy {
+    private readonly cdkDialog;
+    private readonly injector;
+    private readonly defaultOptions;
+    private readonly parentDialog;
+    private readonly openDialogsAtThisLevel;
+    private readonly afterOpenedSubject;
+    private readonly afterAllClosedSubject;
+    /** Reactively-readable list of currently-open dialogs across the full dialog tree. */
+    readonly openDialogs: Signal<readonly TwDialogRef<unknown, unknown>[]>;
+    /** Emits every time a dialog is opened. */
+    readonly afterOpened: Observable<TwDialogRef<unknown, unknown>>;
+    /**
+     * Emits when every open dialog has closed. Emits immediately on subscribe if
+     * there are none open.
+     */
+    readonly afterAllClosed: Observable<void>;
+    /**
+     * Opens a dialog using the given component or template.
+     * @param content Component class or `TemplateRef`.
+     * @param config Options merged over the application defaults.
+     * @returns Reference controlling the opened dialog.
+     */
+    open<R = unknown, D = unknown, C = unknown>(content: ComponentType<C> | TemplateRef<C>, config?: TwDialogConfig<D, R>): TwDialogRef<R, C>;
+    /** Closes every open dialog managed by this service (and child services). */
+    closeAll(): void;
+    /** Looks up an open dialog by its id. */
+    getDialogById<R = unknown, C = unknown>(id: string): TwDialogRef<R, C> | undefined;
+    ngOnDestroy(): void;
+    private registerOpen;
+    private unregister;
+    private getAfterAllClosedSource;
+    private resolveConfig;
+    private resolveScrollStrategy;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TwDialog, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TwDialog>;
+}
+/**
+ * Registers the {@link TwDialog} service for dependency injection.
+ *
+ * @param defaultOptions Optional defaults merged into every `open()` call.
+ * @example
+ * ```ts
+ * provideTwDialog({ size: 'lg', hasBackdrop: true })
+ * ```
+ */
+declare function provideTwDialog(defaultOptions?: Partial<TwDialogConfig>): EnvironmentProviders;
+
+/**
+ * Header wrapper for a dialog. Provides consistent padding and spacing for
+ * title + subtitle + leading icon, and separates the header from scrollable
+ * content below.
+ */
+declare class DialogHeaderDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogHeaderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DialogHeaderDirective, "[twDialogHeader], tw-dialog-header", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Decorative leading icon for a dialog header. Use with a semantic `color` to
+ * match destructive / informational / success dialogs.
+ */
+declare class DialogIconDirective {
+    /** Semantic color for the icon container. Defaults to a neutral surface. */
+    readonly color: i0.InputSignal<TwColor | undefined>;
+    protected readonly classes: i0.Signal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogIconDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DialogIconDirective, "[twDialogIcon]", never, { "color": { "alias": "color"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Dialog title. Registers its ID with the container's `aria-labelledby` queue
+ * so screen readers announce it automatically.
+ */
+declare class DialogTitleDirective implements OnInit, OnDestroy {
+    private readonly generatedId;
+    private readonly dialogRef;
+    private readonly container;
+    /** Custom id for the title element. Defaults to a generated unique id. */
+    readonly id: i0.InputSignal<string>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogTitleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DialogTitleDirective, "[twDialogTitle], tw-dialog-title", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/** Secondary line beneath the dialog title — intended for a short description. */
+declare class DialogSubtitleDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogSubtitleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DialogSubtitleDirective, "[twDialogSubtitle], tw-dialog-subtitle", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Dialog description. Registers its ID with the container's `aria-describedby`
+ * queue so screen readers announce the descriptive paragraph after the title.
+ * Mirrors {@link DialogTitleDirective} but for `aria-describedby`.
+ */
+declare class DialogDescriptionDirective implements OnInit, OnDestroy {
+    private readonly generatedId;
+    private readonly dialogRef;
+    private readonly container;
+    /** Custom id for the description element. Defaults to a generated unique id. */
+    readonly id: i0.InputSignal<string>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogDescriptionDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DialogDescriptionDirective, "[twDialogDescription], tw-dialog-description", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Scrollable content region of the dialog. Apply between the header and the
+ * actions bar. Inherits CDK's `CdkScrollable` to play nicely with scroll
+ * strategies and nested scrollables.
+ */
+declare class DialogContentDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DialogContentDirective, "[twDialogContent], tw-dialog-content", never, {}, {}, never, never, true, [{ directive: typeof i1.CdkScrollable; inputs: {}; outputs: {}; }]>;
+}
+/** Horizontal alignment for dialog action buttons. */
+type DialogActionsAlign = 'start' | 'center' | 'end';
+/**
+ * Bottom action bar of a dialog. Use inside the dialog content or template to
+ * host Cancel/Confirm buttons. Stays pinned below scrollable content.
+ */
+declare class DialogActionsDirective {
+    /** Horizontal alignment of the action buttons. Defaults to `'end'`. */
+    readonly align: i0.InputSignal<DialogActionsAlign>;
+    protected readonly classes: i0.Signal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogActionsDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DialogActionsDirective, "[twDialogActions], tw-dialog-actions", never, { "align": { "alias": "align"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Closes the enclosing dialog when the host button is clicked. Provide a
+ * `[twDialogClose]` value to pass a result to `afterClosed()` subscribers.
+ */
+declare class DialogCloseDirective {
+    /** Value passed to `afterClosed()` when the button is clicked. */
+    readonly twDialogClose: i0.InputSignal<unknown>;
+    /** Native button `type`. Defaults to `'button'` to avoid accidental form submission. */
+    readonly type: i0.InputSignal<"button" | "submit" | "reset">;
+    private readonly dialogRef;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogCloseDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DialogCloseDirective, "[twDialogClose]", never, { "twDialogClose": { "alias": "twDialogClose"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { DialogActionsDirective, DialogCloseDirective, DialogContainer, DialogContentDirective, DialogDescriptionDirective, DialogHeaderDirective, DialogIconDirective, DialogSubtitleDirective, DialogTitleDirective, TW_DIALOG_DATA, TW_DIALOG_DEFAULT_OPTIONS, TwDialog, TwDialogConfig, TwDialogRef, provideTwDialog };
+export type { DialogActionsAlign, DialogAnimationEvent, DialogState, TwDialogAutoFocus, TwDialogRestoreFocus, TwDialogRole, TwDialogScrollStrategy, TwDialogSize };

package/types/cdevhub-ngx-tw-empty-state.d.ts

@@ -0,0 +1,104 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef } from '@angular/core';
+import { TwSize } from '@cdevhub/ngx-tw/core';
+
+/** Layout style of the empty state. */
+type EmptyStateVariant = 'centered' | 'inline';
+/** Heading level for the title element. Matches native `<h1>`–`<h6>`. */
+type EmptyStateTitleLevel = 1 | 2 | 3 | 4 | 5 | 6;
+/**
+ * Icon-slot marker. Project an icon element with `twEmptyStateIcon` to
+ * replace the fallback `<tw-icon name="inbox">`.
+ *
+ * @example
+ * ```html
+ * <tw-empty-state>
+ *   <tw-icon twEmptyStateIcon name="search" />
+ * </tw-empty-state>
+ * ```
+ */
+declare class EmptyStateIconDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EmptyStateIconDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<EmptyStateIconDirective, "[twEmptyStateIcon]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Structural title slot. Captures a `TemplateRef` so the heading can be
+ * rendered into the dynamic `<h1>`–`<h6>` wrapper at runtime.
+ *
+ * @example
+ * ```html
+ * <tw-empty-state>
+ *   <span *twEmptyStateTitle>No results <tw-badge>0</tw-badge></span>
+ * </tw-empty-state>
+ * ```
+ */
+declare class EmptyStateTitleDirective {
+    readonly templateRef: TemplateRef<unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EmptyStateTitleDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<EmptyStateTitleDirective, "[twEmptyStateTitle]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Structural description slot. Captures a `TemplateRef` so the content can
+ * be rendered into the `<p>` wrapper.
+ *
+ * @example
+ * ```html
+ * <tw-empty-state>
+ *   <span *twEmptyStateDescription>Try a <a href="…">different search</a>.</span>
+ * </tw-empty-state>
+ * ```
+ */
+declare class EmptyStateDescriptionDirective {
+    readonly templateRef: TemplateRef<unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EmptyStateDescriptionDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<EmptyStateDescriptionDirective, "[twEmptyStateDescription]", never, {}, {}, never, never, true, never>;
+}
+/** Actions-slot directive. Carries the actions row classes (`flex gap-2` etc.) on its host. */
+declare class EmptyStateActionsDirective {
+    private readonly emptyStateRef;
+    readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EmptyStateActionsDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<EmptyStateActionsDirective, "[twEmptyStateActions]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Zero-data layout primitive. Renders an icon, title, description, and
+ * actions for surfaces that have nothing to display.
+ *
+ * The component is intentionally neutral — accent comes from projected
+ * action buttons. It does not announce itself: consumers that want a live
+ * announcement (e.g. "no search results found") wrap the component with
+ * `<div role="status" aria-live="polite">…</div>` themselves.
+ */
+declare class EmptyStateComponent {
+    /** Controls overall spacing and icon scale. Defaults to `'md'`. */
+    readonly size: _angular_core.InputSignal<TwSize>;
+    /** Layout style. `'centered'` stacks icon/title/description/actions vertically with center alignment for full-region usage; `'inline'` arranges them horizontally for compact rows. Defaults to `'centered'`. */
+    readonly variant: _angular_core.InputSignal<EmptyStateVariant>;
+    /** Primary heading text. Projected `*twEmptyStateTitle` content takes precedence. Defaults to `undefined`. */
+    readonly title: _angular_core.InputSignal<string | undefined>;
+    /** Secondary descriptive text. Projected `*twEmptyStateDescription` content takes precedence. Defaults to `undefined`. */
+    readonly description: _angular_core.InputSignal<string | undefined>;
+    /** Heading level used for the title element. Set to match the surrounding document outline. Defaults to `3`. */
+    readonly titleLevel: _angular_core.InputSignal<EmptyStateTitleLevel>;
+    /** @internal */
+    readonly titleSlot: _angular_core.Signal<EmptyStateTitleDirective | undefined>;
+    /** @internal */
+    readonly descriptionSlot: _angular_core.Signal<EmptyStateDescriptionDirective | undefined>;
+    readonly hasTitleSlot: _angular_core.Signal<boolean>;
+    readonly hasDescriptionSlot: _angular_core.Signal<boolean>;
+    readonly hasTitle: _angular_core.Signal<boolean>;
+    readonly hasDescription: _angular_core.Signal<boolean>;
+    /** Size passed to the fallback `<tw-icon>` per CLAUDE.md glyph sub-scale. */
+    readonly iconSize: _angular_core.Signal<TwSize>;
+    private readonly variantResult;
+    readonly rootClasses: _angular_core.Signal<string>;
+    readonly iconWrapperClasses: _angular_core.Signal<string>;
+    readonly titleClasses: _angular_core.Signal<string>;
+    readonly descriptionClasses: _angular_core.Signal<string>;
+    readonly actionsClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EmptyStateComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EmptyStateComponent, "tw-empty-state", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "titleLevel": { "alias": "titleLevel"; "required": false; "isSignal": true; }; }, {}, ["titleSlot", "descriptionSlot"], ["[twEmptyStateIcon]", "[twEmptyStateActions]"], true, never>;
+}
+
+export { EmptyStateActionsDirective, EmptyStateComponent, EmptyStateDescriptionDirective, EmptyStateIconDirective, EmptyStateTitleDirective };
+export type { EmptyStateTitleLevel, EmptyStateVariant };

package/types/cdevhub-ngx-tw-flip-card.d.ts

@@ -0,0 +1,95 @@
+import * as _angular_core from '@angular/core';
+
+/** Visual style of the flip card chrome. Mirrors `tw-card`. */
+type FlipCardVariant = 'outlined' | 'elevated' | 'ghost';
+/** Axis of rotation for the flip animation. */
+type FlipCardDirection = 'horizontal' | 'vertical';
+/** Which user interaction flips the card. */
+type FlipCardTrigger = 'hover' | 'click' | 'manual' | 'both';
+/**
+ * Two-faced card with a CSS 3D-perspective flip animation.
+ *
+ * @remarks
+ * **Hard theme dependency.** The flip animation is driven by helper classes
+ * (`tw-flip-perspective`, `tw-flip-inner`, `tw-flip-face`, `tw-flip-back-face`,
+ * `tw-flip-axis-x`, `tw-flip-axis-y`, `tw-flip-rotated`, `tw-flip-back-x`,
+ * `tw-flip-back-y`) declared in `projects/ngx-tw/theme/_base.css` and re-exported
+ * via `ngx-tw/theme/default.css`. Consumers MUST import the theme stylesheet —
+ * without it the card renders as two stacked faces with no perspective and no
+ * rotation, and there is no run-time fallback. `prefers-reduced-motion: reduce`
+ * is handled in the theme CSS, not here.
+ */
+declare class FlipCardComponent {
+    /**
+     * Visual style of the card chrome. Mirrors `tw-card`'s variant vocabulary.
+     * Defaults to `'outlined'` (vs `tw-card`'s `'elevated'` default) so the flip
+     * animation reads more clearly without a baseline shadow underneath.
+     */
+    readonly variant: _angular_core.InputSignal<FlipCardVariant>;
+    /** Axis of rotation. `'horizontal'` rotates around the Y axis (left/right flip); `'vertical'` rotates around the X axis (top/bottom flip). Defaults to `'horizontal'`. */
+    readonly direction: _angular_core.InputSignal<FlipCardDirection>;
+    /** Which user action flips the card. `'both'` enables click and hover. `'manual'` disables all triggers and defers control to the `flipped` model. Defaults to `'both'`. */
+    readonly trigger: _angular_core.InputSignal<FlipCardTrigger>;
+    /** When true, all triggers and keyboard handling are disabled; the current face stays visible. Defaults to `false`. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the back face is currently visible. Two-way bindable via `[(flipped)]`. Defaults to `false`. The `flippedChange` event fires on every toggle. */
+    readonly flipped: _angular_core.ModelSignal<boolean>;
+    /**
+     * Accessible name for the host element. Required when `trigger` is
+     * `'manual'` (the host renders as `role="region"`, which AXE requires to
+     * have an accessible name); a default of `'Flip card'` is used in that
+     * mode if no value is provided. In interactive modes the host's accessible
+     * name is normally derived from the visible face's content — set this
+     * input to override.
+     */
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    private readonly liveAnnouncer;
+    private readonly destroyRef;
+    private readonly backWrapper;
+    private readonly _hasBack;
+    /** @internal */
+    readonly hasBack: _angular_core.Signal<boolean>;
+    /** @internal */
+    readonly interactive: _angular_core.Signal<boolean>;
+    /** @internal */
+    readonly hostRole: _angular_core.Signal<"region" | "button">;
+    /** @internal */
+    readonly hostTabindex: _angular_core.Signal<0 | null>;
+    /** @internal */
+    readonly ariaPressed: _angular_core.Signal<string | null>;
+    /** @internal */
+    readonly ariaLive: _angular_core.Signal<"polite" | null>;
+    /** @internal */
+    readonly ariaDisabled: _angular_core.Signal<"true" | null>;
+    /** @internal */
+    readonly hostAriaLabel: _angular_core.Signal<string | null>;
+    /** @internal */
+    readonly frontAriaHidden: _angular_core.Signal<"true" | null>;
+    /** @internal */
+    readonly backAriaHidden: _angular_core.Signal<"true" | null>;
+    /** @internal */
+    readonly frontInert: _angular_core.Signal<"" | null>;
+    /** @internal */
+    readonly backInert: _angular_core.Signal<"" | null>;
+    private readonly variantResult;
+    readonly rootClasses: _angular_core.Signal<string>;
+    readonly innerClasses: _angular_core.Signal<string>;
+    readonly frontClasses: _angular_core.Signal<string>;
+    readonly backClasses: _angular_core.Signal<string>;
+    constructor();
+    /** @internal */
+    onClick(): void;
+    /** @internal */
+    onKeydown(event: KeyboardEvent): void;
+    /** @internal */
+    onMouseEnter(): void;
+    /** @internal */
+    onMouseLeave(): void;
+    private toggle;
+    private setFlipped;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FlipCardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FlipCardComponent, "tw-flip-card", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "trigger": { "alias": "trigger"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "flipped": { "alias": "flipped"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "flipped": "flippedChange"; }, never, ["[slot='front']", "[slot='back']"], true, never>;
+}
+
+export { FlipCardComponent };
+export type { FlipCardDirection, FlipCardTrigger, FlipCardVariant };