ngwr 6.0.0 → 7.0.0

package/types/ngwr-context-menu.d.ts

@@ -0,0 +1,207 @@
+import * as i0 from '@angular/core';
+import { TemplateRef } from '@angular/core';
+
+/**
+ * Container for the rows shown when a {@link WrContextMenu} opens.
+ * The component itself doesn't render; the directive portals the inner
+ * template into an overlay positioned at the pointer.
+ *
+ * @example
+ * ```html
+ * <div [wrContextMenu]="menu">Right-click me</div>
+ * <wr-context-menu #menu>
+ *   <wr-context-menu-item icon="copy" (click)="copy()">Copy</wr-context-menu-item>
+ *   <wr-context-menu-item icon="trash" (click)="remove()">Delete</wr-context-menu-item>
+ * </wr-context-menu>
+ * ```
+ */
+declare class WrContextMenuPanel {
+    /** The internal template the directive portals into the overlay. @internal */
+    readonly contentTpl: i0.Signal<TemplateRef<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WrContextMenuPanel, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WrContextMenuPanel, "wr-context-menu", ["wrContextMenu"], {}, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Attach to any element to show a `<wr-context-menu>` at the pointer
+ * position when the user right-clicks (or sends a `contextmenu` event by
+ * any means — long-press on touch, Shift+F10, etc.). The native browser
+ * menu is suppressed for the host element.
+ *
+ * @example
+ * ```html
+ * <div [wrContextMenu]="menu">Right-click me</div>
+ * <wr-context-menu #menu>
+ *   <wr-context-menu-item (click)="copy()">Copy</wr-context-menu-item>
+ *   <wr-context-menu-item (click)="remove()">Delete</wr-context-menu-item>
+ * </wr-context-menu>
+ * ```
+ *
+ * @see https://ngwr.dev/components/context-menu
+ */
+declare class WrContextMenu {
+    /** Menu to open. Pass a `<wr-context-menu>` template reference. */
+    readonly menu: i0.InputSignal<WrContextMenuPanel>;
+    private readonly host;
+    private readonly overlay;
+    private readonly vcr;
+    private readonly scrollStrategies;
+    private readonly destroyRef;
+    private overlayRef;
+    private closingTimer;
+    private leaveTimer;
+    /**
+     * Single open root menu at a time. Submenu items use this to signal
+     * chain-level hover state: when the cursor enters ANY pane in the
+     * chain (root or submenu) `keepChainAlive()` cancels the close timer;
+     * when the cursor leaves ALL panes `scheduleChainClose()` starts it.
+     * The whole chain (root → submenus) tears down through the root's
+     * close (submenus react to their owner-item destroyRef + the static
+     * registry in `WrContextMenuItem`).
+     */
+    private static activeRoot;
+    /** Called from a submenu pane's mouseenter — keep the whole chain alive. */
+    static keepChainAlive(): void;
+    /** Called from a submenu pane's mouseleave when the cursor left ALL menus. */
+    static scheduleChainClose(): void;
+    /**
+     * Open/close animation duration in ms. Matches the longest SCSS
+     * transition on `.wr-context-menu-overlay` (the spring-scale curve).
+     * The directive holds the overlay alive for this long during close
+     * so the exit animation can play before the pane is removed from
+     * the DOM.
+     */
+    private static readonly TRANSITION_MS;
+    /**
+     * Grace window after the cursor leaves the root pane. Long enough
+     * for the user to dip momentarily into the gap between the root and
+     * a submenu (or back from a submenu), short enough to feel snappy
+     * on a deliberate hover-out.
+     */
+    private static readonly LEAVE_DELAY;
+    constructor();
+    /** @internal Right-click handler — opens at the pointer (or re-positions if already open). */
+    protected onContextMenu(event: MouseEvent): void;
+    /** Close the menu. */
+    close(): void;
+    private openOverlay;
+    private closeOverlay;
+    private cancelLeaveTimer;
+    private scheduleLeave;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WrContextMenu, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<WrContextMenu, "[wrContextMenu]", never, { "menu": { "alias": "wrContextMenu"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Single row inside a `<wr-context-menu>`. Mirrors `<wr-dropdown-item>` —
+ * rendered as a menu item with an optional leading icon and an optional
+ * nested `[submenu]` that opens to the right on hover.
+ *
+ * @example
+ * ```html
+ * <wr-context-menu #menu>
+ *   <wr-context-menu-item icon="copy" (click)="copy()">Copy</wr-context-menu-item>
+ *   <wr-context-menu-item icon="more" [submenu]="extras">More…</wr-context-menu-item>
+ * </wr-context-menu>
+ *
+ * <wr-context-menu #extras>
+ *   <wr-context-menu-item (click)="duplicate()">Duplicate</wr-context-menu-item>
+ *   <wr-context-menu-item (click)="archive()">Archive</wr-context-menu-item>
+ * </wr-context-menu>
+ * ```
+ */
+declare class WrContextMenuItem {
+    /** Optional leading icon name. @default null */
+    readonly icon: i0.InputSignal<string | null>;
+    /** Disable interaction (suppresses pointer + keyboard). @default false */
+    readonly disabled: i0.InputSignalWithTransform<boolean, any>;
+    /**
+     * Optional nested `<wr-context-menu>`. When set, hovering the item
+     * (or pressing →) opens it to the right with a chevron indicator.
+     */
+    readonly submenu: i0.InputSignal<WrContextMenuPanel | null>;
+    protected readonly classes: i0.Signal<string>;
+    private readonly host;
+    private readonly overlay;
+    private readonly vcr;
+    private readonly scrollStrategies;
+    private readonly destroyRef;
+    private submenuRef;
+    private openTimer;
+    private closeTimer;
+    protected submenuOpen: boolean;
+    /**
+     * Global registry of open submenus keyed by the host element of the
+     * item that owns them. Used to cascade-close descendants when a
+     * parent submenu is disposed — Angular's onDestroy on detached
+     * portals doesn't always tear down the deepest grand-children's
+     * overlays in the right order, leaving orphaned floating panes.
+     */
+    private static readonly openSubmenus;
+    /**
+     * Dispose every open submenu pane on the page. Called by the root
+     * `WrContextMenu` when its own overlay closes — destroyRef cascade
+     * isn't reliable across separate overlay panes (each pane lives in
+     * the CDK overlay container, not inside the parent pane's view).
+     */
+    static disposeAll(immediate: boolean): void;
+    constructor();
+    /** @internal Keyboard activation — Enter / Space. */
+    protected activate(event: Event): void;
+    /** @internal Right-arrow opens the submenu. */
+    protected onArrowRight(event: Event): void;
+    /** @internal Left-arrow closes the submenu (if open). */
+    protected onArrowLeft(event: Event): void;
+    /** @internal Hover schedules a submenu open after a small delay. */
+    protected onMouseEnter(): void;
+    /** @internal Hover-out schedules a close with a grace window. */
+    protected onMouseLeave(event: MouseEvent): void;
+    private scheduleOpen;
+    private scheduleClose;
+    private cancelOpen;
+    private cancelClose;
+    private openSubmenu;
+    /** Bound handlers (= preserves identity for removeEventListener). */
+    private readonly onSubmenuEnter;
+    private readonly onSubmenuLeave;
+    private relatedTargetIsInsideAnyMenu;
+    /**
+     * `true` when the cursor moved from this item directly into the pane
+     * of its own (just-opening) submenu — drilling down. Sibling items
+     * and ancestor menus do NOT count.
+     */
+    private relatedTargetIsInsideOwnSubmenu;
+    /**
+     * `true` when the cursor moved from our submenu pane into another
+     * submenu pane whose owner-item lives INSIDE ours — the user is
+     * drilling further down the chain (e.g., from the Share submenu into
+     * the Export-as submenu). Moving back up the chain returns false so
+     * we close.
+     */
+    private relatedTargetIsInsideDescendantSubmenu;
+    private disposeSubmenu;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WrContextMenuItem, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WrContextMenuItem, "wr-context-menu-item", never, { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "submenu": { "alias": "submenu"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Thin horizontal separator inside a `<wr-context-menu>`. Use it to
+ * group related items (e.g., a destructive action below a divider, or
+ * a "More" section below the primary items).
+ *
+ * @example
+ * ```html
+ * <wr-context-menu #menu>
+ *   <wr-context-menu-item (click)="copy()">Copy</wr-context-menu-item>
+ *   <wr-context-menu-item (click)="paste()">Paste</wr-context-menu-item>
+ *   <wr-context-menu-divider />
+ *   <wr-context-menu-item (click)="remove()">Delete</wr-context-menu-item>
+ * </wr-context-menu>
+ * ```
+ */
+declare class WrContextMenuDivider {
+    static ɵfac: i0.ɵɵFactoryDeclaration<WrContextMenuDivider, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WrContextMenuDivider, "wr-context-menu-divider", never, {}, {}, never, never, true, never>;
+}
+
+export { WrContextMenu, WrContextMenuDivider, WrContextMenuItem, WrContextMenuPanel };

package/types/ngwr-cookie.d.ts

@@ -0,0 +1,60 @@
+import * as i0 from '@angular/core';
+
+/** Options for `WrCookie.set` / `WrCookie.remove`. */
+interface WrCookieOptions {
+    /**
+     * Expiry. `Date` is written as an `expires=` attribute; `number` is
+     * treated as seconds-from-now and converted to `Max-Age`.
+     */
+    readonly expires?: Date | number;
+    /** Cookie path. @default '/' */
+    readonly path?: string;
+    /** Cookie domain. */
+    readonly domain?: string;
+    /** `Secure` flag. */
+    readonly secure?: boolean;
+    /** `SameSite` policy. @default 'Lax' */
+    readonly sameSite?: 'Lax' | 'Strict' | 'None';
+}
+
+/**
+ * Thin, SSR-safe `document.cookie` wrapper modelled after {@link WrStorage}.
+ *
+ * - Read/write/delete cookies through a typed API.
+ * - `set()` serialises `expires` as either an HTTP-date or `Max-Age`.
+ * - Every method short-circuits when there's no DOM (SSR / unit tests
+ *   without a document) — reads return the fallback, writes are no-ops.
+ *
+ * @example
+ * ```ts
+ * const cookies = inject(WrCookie);
+ *
+ * cookies.set('theme', 'dark', { expires: 60 * 60 * 24 * 30 });  // 30 days
+ * cookies.get('theme');                                          // 'dark'
+ * cookies.has('theme');                                          // true
+ * cookies.remove('theme');
+ * cookies.keys();                                                // readonly string[]
+ * ```
+ *
+ * @see https://ngwr.dev/services/cookie
+ */
+declare class WrCookie {
+    private readonly doc;
+    /** Is `key` present (regardless of value)? */
+    has(key: string): boolean;
+    /** Read `key`. Returns `fallback` (default `null`) when the key is missing. */
+    get(key: string, fallback?: string | null): string | null;
+    /** Write `key=value` with optional attributes. */
+    set(key: string, value: string, options?: WrCookieOptions): void;
+    /** Remove `key`. Path / domain must match what was used in `set()`. */
+    remove(key: string, options?: Pick<WrCookieOptions, 'path' | 'domain'>): void;
+    /** Every cookie key visible to this document. */
+    keys(): readonly string[];
+    /** Remove every cookie visible to this document. Uses `path: '/'`. */
+    clear(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WrCookie, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WrCookie>;
+}
+
+export { WrCookie };
+export type { WrCookieOptions };

package/types/ngwr-counter.d.ts

@@ -0,0 +1,182 @@
+import * as _angular_core from '@angular/core';
+
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+/**
+ * Animation mode for {@link WrCounter}.
+ *
+ * - `odometer` — digits roll vertically like a mechanical counter.
+ * - `tween` — single eased interpolation from the previous value to the new
+ *   one (matches `<wr-count-up>` behavior, formatted inline).
+ */
+/** Animation curve. */
+type WrCountUpEasing = 'ease-out' | 'spring';
+/** When the counter should start animating. */
+type WrCountUpTrigger = 'mount' | 'visible';
+/** Counting direction. `'down'` swaps `from` ↔ `to`. */
+type WrCountUpDirection = 'up' | 'down';
+type WrCounterMode = 'odometer' | 'tween';
+
+/** Visual cell in odometer mode — either a 0-9 column or a static glyph. */
+type Cell = {
+    readonly kind: 'digit';
+    readonly fraction: number;
+} | {
+    readonly kind: 'static';
+    readonly char: string;
+};
+/**
+ * Animated number display with two modes:
+ *
+ * - **`odometer`** (default) — each digit is a vertical strip of 0-9 that
+ *   rolls into place, continuously interpolated for smooth motion when the
+ *   value changes.
+ * - **`tween`** — a single eased count-up between the previous and new value,
+ *   rendered through `Intl.NumberFormat`.
+ *
+ * Reacts to `[value]` changes — animate from any number to any number.
+ *
+ * @example
+ * ```html
+ * <wr-counter [value]="123456" mode="odometer" />
+ * <wr-counter [value]="9.99" mode="tween" [decimals]="2" prefix="$" />
+ * ```
+ *
+ * @see https://ngwr.dev/components/counter
+ */
+declare class WrCounter {
+    /** Target value. */
+    readonly value: _angular_core.InputSignal<number>;
+    /** Animation mode. @default 'odometer' */
+    readonly mode: _angular_core.InputSignal<WrCounterMode>;
+    /** Duration (ms). @default 900 */
+    readonly duration: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Fixed number of decimals. @default 0 */
+    readonly decimals: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Optional prefix (e.g. `'$'`). */
+    readonly prefix: _angular_core.InputSignal<string>;
+    /** Optional suffix (e.g. `'%'`). */
+    readonly suffix: _angular_core.InputSignal<string>;
+    /** Group thousands. @default true */
+    readonly grouping: _angular_core.InputSignal<boolean>;
+    /** Pad integer part to at least this many digits. @default 0 (no padding) */
+    readonly minIntegerDigits: _angular_core.InputSignalWithTransform<number, unknown>;
+    private readonly current;
+    private readonly locale;
+    private readonly isBrowser;
+    private rafId;
+    /** Tween-mode formatted output. */
+    protected readonly tweenText: _angular_core.Signal<string>;
+    /** Odometer cells — one per character in the formatted target string. */
+    protected readonly cells: _angular_core.Signal<readonly Cell[]>;
+    constructor();
+    private cancel;
+    private format;
+    /**
+     * Compute the smoothly-interpolated digit (0..10) at column `i` of the
+     * formatted live string. Returns the integer digit + a fraction so the
+     * strip CSS translate looks like a real rolling odometer.
+     */
+    private digitFractionAt;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrCounter, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrCounter, "wr-counter", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "duration": { "alias": "duration"; "required": false; "isSignal": true; }; "decimals": { "alias": "decimals"; "required": false; "isSignal": true; }; "prefix": { "alias": "prefix"; "required": false; "isSignal": true; }; "suffix": { "alias": "suffix"; "required": false; "isSignal": true; }; "grouping": { "alias": "grouping"; "required": false; "isSignal": true; }; "minIntegerDigits": { "alias": "minIntegerDigits"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Animated number tick. Animates from `from` to the current `to`, formatting
+ * via `Intl.NumberFormat`. Re-runs whenever `to` changes.
+ *
+ * @example Basic
+ * ```html
+ * <wr-count-up [to]="12345" />
+ * <wr-count-up [to]="9.99" [decimals]="2" prefix="$" />
+ * ```
+ *
+ * @example Reactbits-style — spring curve + viewport trigger
+ * ```html
+ * <wr-count-up [to]="100" easing="spring" trigger="visible" [delay]="200" />
+ * ```
+ *
+ * @example Count down
+ * ```html
+ * <wr-count-up [from]="60" [to]="0" direction="down" />
+ * ```
+ *
+ * @see https://ngwr.dev/components/counter
+ */
+declare class WrCountUp {
+    /** Starting value. @default 0 */
+    readonly from: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Target value. */
+    readonly to: _angular_core.InputSignal<number>;
+    /**
+     * Animation duration. Units depend on `easing`:
+     *
+     * - `ease-out` — milliseconds (default 1200, min 100)
+     * - `spring` — seconds (tunes spring stiffness; default 2)
+     */
+    readonly duration: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Optional delay (ms) before the animation starts. @default 0 */
+    readonly delay: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Animation curve. @default 'ease-out' */
+    readonly easing: _angular_core.InputSignal<WrCountUpEasing>;
+    /**
+     * When to start the animation.
+     *
+     * - `'mount'` (default) — start as soon as the component is rendered.
+     * - `'visible'` — wait for the host to enter the viewport
+     *   (IntersectionObserver). Useful for long pages or hero numbers
+     *   below the fold.
+     */
+    readonly trigger: _angular_core.InputSignal<WrCountUpTrigger>;
+    /** Counting direction. `'down'` swaps `from` ↔ `to`. @default 'up' */
+    readonly direction: _angular_core.InputSignal<WrCountUpDirection>;
+    /** Fixed number of decimals. @default 0 */
+    readonly decimals: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Optional prefix (e.g. `'$'`). */
+    readonly prefix: _angular_core.InputSignal<string>;
+    /** Optional suffix (e.g. `'%'`). */
+    readonly suffix: _angular_core.InputSignal<string>;
+    /** Disable grouping separators (`1,234` → `1234`). @default true (grouping on) */
+    readonly grouping: _angular_core.InputSignal<boolean>;
+    /** Emits when the animation begins. */
+    readonly started: _angular_core.OutputEmitterRef<void>;
+    /** Emits when the animation settles. */
+    readonly completed: _angular_core.OutputEmitterRef<void>;
+    private readonly value;
+    private readonly host;
+    private readonly locale;
+    private readonly isBrowser;
+    private readonly destroyRef;
+    private rafId;
+    private delayTimer;
+    private observer;
+    private hasFiredForVisible;
+    protected readonly formatted: _angular_core.Signal<string>;
+    constructor();
+    private setupViewportTrigger;
+    private scheduleRun;
+    private run;
+    private tweenEaseOut;
+    /**
+     * Critically-damped spring tween. Same formula as `motion/react`'s
+     * `useSpring` with mass = 1:
+     *
+     *   damping   = 20 + 40 / duration
+     *   stiffness = 100 / duration
+     *
+     * We integrate `(spring force − damping force)` each frame until both
+     * displacement and velocity fall below epsilon.
+     */
+    private tweenSpring;
+    private cancel;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrCountUp, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrCountUp, "wr-count-up", never, { "from": { "alias": "from"; "required": false; "isSignal": true; }; "to": { "alias": "to"; "required": true; "isSignal": true; }; "duration": { "alias": "duration"; "required": false; "isSignal": true; }; "delay": { "alias": "delay"; "required": false; "isSignal": true; }; "easing": { "alias": "easing"; "required": false; "isSignal": true; }; "trigger": { "alias": "trigger"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "decimals": { "alias": "decimals"; "required": false; "isSignal": true; }; "prefix": { "alias": "prefix"; "required": false; "isSignal": true; }; "suffix": { "alias": "suffix"; "required": false; "isSignal": true; }; "grouping": { "alias": "grouping"; "required": false; "isSignal": true; }; }, { "started": "started"; "completed": "completed"; }, never, never, true, never>;
+}
+
+export { WrCountUp, WrCounter };
+export type { WrCountUpDirection, WrCountUpEasing, WrCountUpTrigger, WrCounterMode };

package/types/ngwr-date-adapter-fns.d.ts

@@ -0,0 +1,73 @@
+import { WrDateAdapter, WrDateFormat } from 'ngwr/date-adapter';
+import * as i0 from '@angular/core';
+import { EnvironmentProviders } from '@angular/core';
+
+/**
+ * {@link WrDateAdapter} backed by `date-fns`. Same `Date` value type as the
+ * native adapter, but defers all math, formatting, and parsing to date-fns
+ * — pick this when you want more robust locale-aware patterns (`P`, `PP`,
+ * `PPP`, `p`) without writing them by hand.
+ *
+ * @example
+ * ```ts
+ * bootstrapApplication(AppComponent, {
+ *   providers: [provideWrDateFnsAdapter()],
+ * });
+ * ```
+ *
+ * Peer dep: `date-fns@^3` (or `^4`).
+ */
+declare class WrDateFnsAdapter extends WrDateAdapter<Date> {
+    private readonly locale;
+    today(): Date;
+    clone(date: Date): Date;
+    createDate(year: number, month: number, day: number): Date;
+    isValid(date: Date): boolean;
+    getYear(date: Date): number;
+    getMonth(date: Date): number;
+    getDate(date: Date): number;
+    getDayOfWeek(date: Date): number;
+    getDaysInMonth(date: Date): number;
+    getHours(date: Date): number;
+    getMinutes(date: Date): number;
+    getSeconds(date: Date): number;
+    addYears(date: Date, amount: number): Date;
+    addMonths(date: Date, amount: number): Date;
+    addDays(date: Date, amount: number): Date;
+    setTime(date: Date, hours: number, minutes: number, seconds: number): Date;
+    isSameDay(a: Date, b: Date): boolean;
+    isSameMonth(a: Date, b: Date): boolean;
+    compareDate(a: Date, b: Date): number;
+    format(date: Date, formatKeyOrString: WrDateFormat | (string & {})): string;
+    parse(value: string, formatKeyOrString: WrDateFormat | (string & {})): Date | null;
+    getFirstDayOfWeek(): number;
+    getDayOfWeekNames(style: 'narrow' | 'short' | 'long'): readonly string[];
+    getMonthNames(style: 'narrow' | 'short' | 'long'): readonly string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<WrDateFnsAdapter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WrDateFnsAdapter>;
+}
+
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+
+/**
+ * Register the {@link WrDateFnsAdapter} so date-pickers / calendars in this
+ * app use `date-fns` for all math and formatting. Pass `locale` to override
+ * the BCP 47 tag.
+ *
+ * @example
+ * ```ts
+ * bootstrapApplication(AppComponent, {
+ *   providers: [provideWrDateFnsAdapter()],
+ * });
+ * ```
+ */
+declare function provideWrDateFnsAdapter(options?: {
+    readonly locale?: string;
+}): EnvironmentProviders;
+
+export { WrDateFnsAdapter, provideWrDateFnsAdapter };

package/types/ngwr-date-adapter-luxon.d.ts

@@ -0,0 +1,73 @@
+import { DateTime } from 'luxon';
+import { WrDateAdapter, WrDateFormat } from 'ngwr/date-adapter';
+import * as i0 from '@angular/core';
+import { EnvironmentProviders } from '@angular/core';
+
+/**
+ * {@link WrDateAdapter} backed by Luxon `DateTime`. Use this when you need
+ * proper timezone-aware math or IANA zone handling (the native + date-fns
+ * adapters both work on plain `Date` and inherit JS quirks).
+ *
+ * @example
+ * ```ts
+ * bootstrapApplication(AppComponent, {
+ *   providers: [provideWrLuxonAdapter()],
+ * });
+ * ```
+ *
+ * Peer dep: `luxon@^3`.
+ */
+declare class WrLuxonAdapter extends WrDateAdapter<DateTime> {
+    private readonly locale;
+    today(): DateTime;
+    clone(date: DateTime): DateTime;
+    createDate(year: number, month: number, day: number): DateTime;
+    isValid(date: DateTime): boolean;
+    getYear(date: DateTime): number;
+    getMonth(date: DateTime): number;
+    getDate(date: DateTime): number;
+    getDayOfWeek(date: DateTime): number;
+    getDaysInMonth(date: DateTime): number;
+    getHours(date: DateTime): number;
+    getMinutes(date: DateTime): number;
+    getSeconds(date: DateTime): number;
+    addYears(date: DateTime, amount: number): DateTime;
+    addMonths(date: DateTime, amount: number): DateTime;
+    addDays(date: DateTime, amount: number): DateTime;
+    setTime(date: DateTime, hours: number, minutes: number, seconds: number): DateTime;
+    isSameDay(a: DateTime, b: DateTime): boolean;
+    isSameMonth(a: DateTime, b: DateTime): boolean;
+    compareDate(a: DateTime, b: DateTime): number;
+    format(date: DateTime, formatKeyOrString: WrDateFormat | (string & {})): string;
+    parse(value: string, formatKeyOrString: WrDateFormat | (string & {})): DateTime | null;
+    getFirstDayOfWeek(): number;
+    getDayOfWeekNames(style: 'narrow' | 'short' | 'long'): readonly string[];
+    getMonthNames(style: 'narrow' | 'short' | 'long'): readonly string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<WrLuxonAdapter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WrLuxonAdapter>;
+}
+
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+
+/**
+ * Register the {@link WrLuxonAdapter} so date-pickers / calendars in this
+ * app use Luxon `DateTime` for all math and formatting. Pass `locale` to
+ * override the BCP 47 tag.
+ *
+ * @example
+ * ```ts
+ * bootstrapApplication(AppComponent, {
+ *   providers: [provideWrLuxonAdapter()],
+ * });
+ * ```
+ */
+declare function provideWrLuxonAdapter(options?: {
+    readonly locale?: string;
+}): EnvironmentProviders;
+
+export { WrLuxonAdapter, provideWrLuxonAdapter };