angular-movement 0.0.1

package/types/angular-movement.d.ts

@@ -0,0 +1,455 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, OnDestroy, OnInit, EnvironmentProviders } from '@angular/core';
+
+type MovePreset = 'fade-up' | 'fade-down' | 'fade-left' | 'fade-right' | 'slide-up' | 'slide-down' | 'slide-left' | 'slide-right' | 'zoom-in' | 'zoom-out' | 'flip-x' | 'flip-y' | 'bounce-in' | 'blur-in' | 'spin' | 'pulse' | 'none';
+type MoveValuePair = readonly number[];
+interface MoveSpring {
+    stiffness?: number;
+    damping?: number;
+    mass?: number;
+    velocity?: number;
+}
+interface MoveKeyframes {
+    opacity?: MoveValuePair;
+    x?: MoveValuePair;
+    y?: MoveValuePair;
+    scale?: MoveValuePair;
+    scaleX?: MoveValuePair;
+    scaleY?: MoveValuePair;
+    rotate?: MoveValuePair;
+    rotateX?: MoveValuePair;
+    rotateY?: MoveValuePair;
+    blur?: MoveValuePair;
+}
+type MoveVariant = MoveKeyframes & {
+    spring?: MoveSpring;
+    duration?: number;
+    easing?: string;
+    delay?: number;
+};
+interface MovePresetDefinition {
+    enter: MoveKeyframes;
+    leave: MoveKeyframes;
+}
+interface MoveKeyframeState {
+    opacity?: number;
+    x?: number;
+    y?: number;
+    scale?: number;
+    scaleX?: number;
+    scaleY?: number;
+    rotate?: number;
+    rotateX?: number;
+    rotateY?: number;
+    blur?: number;
+}
+interface MoveAnimationConfig {
+    initial?: MoveKeyframeState;
+    animate?: MoveKeyframeState;
+    exit?: MoveKeyframeState;
+    duration?: number;
+    easing?: string;
+    delay?: number;
+    spring?: MoveSpring;
+}
+
+interface MovePresenceChild {
+    playLeave(): Promise<void> | void;
+}
+interface MovePresenceProvider {
+    register(child: MovePresenceChild): void;
+    unregister(child: MovePresenceChild): void;
+}
+declare const MOVE_PRESENCE_PARENT: InjectionToken<MovePresenceProvider>;
+
+declare class MoveAnimateDirective implements OnDestroy, OnInit, MovePresenceChild {
+    #private;
+    readonly move: _angular_core.InputSignal<MovePreset | MoveKeyframes | undefined>;
+    readonly moveAnimate: _angular_core.InputSignal<MovePreset | MoveKeyframes | undefined>;
+    readonly moveAnimateLeave: _angular_core.InputSignal<MovePreset | MoveKeyframes | undefined>;
+    readonly moveDuration: _angular_core.InputSignal<number | undefined>;
+    readonly moveEasing: _angular_core.InputSignal<string | undefined>;
+    readonly moveDelay: _angular_core.InputSignal<number | undefined>;
+    readonly moveDisabled: _angular_core.InputSignal<boolean | undefined>;
+    readonly moveSpring: _angular_core.InputSignal<MoveSpring | undefined>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    playLeave(): Promise<void>;
+    private resolveEnterInput;
+    private resolveLeaveInput;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MoveAnimateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MoveAnimateDirective, "[move],[moveAnimate]", never, { "move": { "alias": "move"; "required": false; "isSignal": true; }; "moveAnimate": { "alias": "moveAnimate"; "required": false; "isSignal": true; }; "moveAnimateLeave": { "alias": "moveAnimateLeave"; "required": false; "isSignal": true; }; "moveDuration": { "alias": "moveDuration"; "required": false; "isSignal": true; }; "moveEasing": { "alias": "moveEasing"; "required": false; "isSignal": true; }; "moveDelay": { "alias": "moveDelay"; "required": false; "isSignal": true; }; "moveDisabled": { "alias": "moveDisabled"; "required": false; "isSignal": true; }; "moveSpring": { "alias": "moveSpring"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MoveAnimationDirective implements OnInit, OnDestroy, MovePresenceChild {
+    #private;
+    readonly moveAnimation: _angular_core.InputSignal<MoveAnimationConfig>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    playLeave(): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MoveAnimationDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MoveAnimationDirective, "[moveAnimation]", never, { "moveAnimation": { "alias": "moveAnimation"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MoveEnterDirective implements OnDestroy, OnInit {
+    #private;
+    readonly moveEnter: _angular_core.InputSignal<MovePreset | MoveKeyframes>;
+    readonly moveDuration: _angular_core.InputSignal<number | undefined>;
+    readonly moveEasing: _angular_core.InputSignal<string | undefined>;
+    readonly moveDelay: _angular_core.InputSignal<number | undefined>;
+    readonly moveDisabled: _angular_core.InputSignal<boolean | undefined>;
+    readonly moveSpring: _angular_core.InputSignal<MoveSpring | undefined>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MoveEnterDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MoveEnterDirective, "[moveEnter]", never, { "moveEnter": { "alias": "moveEnter"; "required": false; "isSignal": true; }; "moveDuration": { "alias": "moveDuration"; "required": false; "isSignal": true; }; "moveEasing": { "alias": "moveEasing"; "required": false; "isSignal": true; }; "moveDelay": { "alias": "moveDelay"; "required": false; "isSignal": true; }; "moveDisabled": { "alias": "moveDisabled"; "required": false; "isSignal": true; }; "moveSpring": { "alias": "moveSpring"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MoveLeaveDirective implements OnDestroy, OnInit, MovePresenceChild {
+    #private;
+    readonly moveLeave: _angular_core.InputSignal<MovePreset | MoveKeyframes>;
+    readonly moveDuration: _angular_core.InputSignal<number | undefined>;
+    readonly moveEasing: _angular_core.InputSignal<string | undefined>;
+    readonly moveDelay: _angular_core.InputSignal<number | undefined>;
+    readonly moveDisabled: _angular_core.InputSignal<boolean | undefined>;
+    readonly moveSpring: _angular_core.InputSignal<MoveSpring | undefined>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    playLeave(): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MoveLeaveDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MoveLeaveDirective, "[moveLeave]", never, { "moveLeave": { "alias": "moveLeave"; "required": false; "isSignal": true; }; "moveDuration": { "alias": "moveDuration"; "required": false; "isSignal": true; }; "moveEasing": { "alias": "moveEasing"; "required": false; "isSignal": true; }; "moveDelay": { "alias": "moveDelay"; "required": false; "isSignal": true; }; "moveDisabled": { "alias": "moveDisabled"; "required": false; "isSignal": true; }; "moveSpring": { "alias": "moveSpring"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MoveHoverDirective implements OnDestroy {
+    #private;
+    readonly moveWhileHover: _angular_core.InputSignal<MovePreset | MoveKeyframes>;
+    readonly moveDuration: _angular_core.InputSignal<number | undefined>;
+    readonly moveEasing: _angular_core.InputSignal<string | undefined>;
+    readonly moveDelay: _angular_core.InputSignal<number | undefined>;
+    readonly moveDisabled: _angular_core.InputSignal<boolean | undefined>;
+    readonly moveSpring: _angular_core.InputSignal<MoveSpring | undefined>;
+    onMouseEnter(): void;
+    onMouseLeave(): void;
+    onTouchStart(event: TouchEvent): void;
+    onTouchEnd(): void;
+    private play;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MoveHoverDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MoveHoverDirective, "[moveWhileHover]", never, { "moveWhileHover": { "alias": "moveWhileHover"; "required": true; "isSignal": true; }; "moveDuration": { "alias": "moveDuration"; "required": false; "isSignal": true; }; "moveEasing": { "alias": "moveEasing"; "required": false; "isSignal": true; }; "moveDelay": { "alias": "moveDelay"; "required": false; "isSignal": true; }; "moveDisabled": { "alias": "moveDisabled"; "required": false; "isSignal": true; }; "moveSpring": { "alias": "moveSpring"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MoveTapDirective implements OnDestroy {
+    #private;
+    readonly moveWhileTap: _angular_core.InputSignal<MovePreset | MoveKeyframes>;
+    readonly moveDuration: _angular_core.InputSignal<number | undefined>;
+    readonly moveEasing: _angular_core.InputSignal<string | undefined>;
+    readonly moveDelay: _angular_core.InputSignal<number | undefined>;
+    readonly moveDisabled: _angular_core.InputSignal<boolean | undefined>;
+    readonly moveSpring: _angular_core.InputSignal<MoveSpring | undefined>;
+    onPointerDown(): void;
+    onPointerUp(): void;
+    private play;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MoveTapDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MoveTapDirective, "[moveWhileTap]", never, { "moveWhileTap": { "alias": "moveWhileTap"; "required": true; "isSignal": true; }; "moveDuration": { "alias": "moveDuration"; "required": false; "isSignal": true; }; "moveEasing": { "alias": "moveEasing"; "required": false; "isSignal": true; }; "moveDelay": { "alias": "moveDelay"; "required": false; "isSignal": true; }; "moveDisabled": { "alias": "moveDisabled"; "required": false; "isSignal": true; }; "moveSpring": { "alias": "moveSpring"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface MoveVariantsProvider {
+    activeVariant: () => string | undefined;
+}
+declare const MOVE_VARIANTS_PARENT: InjectionToken<MoveVariantsProvider>;
+declare class MoveVariantsDirective implements MoveVariantsProvider, OnDestroy {
+    #private;
+    readonly moveVariants: _angular_core.InputSignal<Record<string, MoveVariant>>;
+    readonly moveAnimate: _angular_core.InputSignal<string | undefined>;
+    readonly moveDuration: _angular_core.InputSignal<number | undefined>;
+    readonly moveEasing: _angular_core.InputSignal<string | undefined>;
+    readonly moveDelay: _angular_core.InputSignal<number | undefined>;
+    readonly moveDisabled: _angular_core.InputSignal<boolean | undefined>;
+    readonly moveSpring: _angular_core.InputSignal<MoveSpring | undefined>;
+    readonly activeVariant: _angular_core.Signal<string | undefined>;
+    constructor();
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MoveVariantsDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MoveVariantsDirective, "[moveVariants]", never, { "moveVariants": { "alias": "moveVariants"; "required": true; "isSignal": true; }; "moveAnimate": { "alias": "moveAnimate"; "required": false; "isSignal": true; }; "moveDuration": { "alias": "moveDuration"; "required": false; "isSignal": true; }; "moveEasing": { "alias": "moveEasing"; "required": false; "isSignal": true; }; "moveDelay": { "alias": "moveDelay"; "required": false; "isSignal": true; }; "moveDisabled": { "alias": "moveDisabled"; "required": false; "isSignal": true; }; "moveSpring": { "alias": "moveSpring"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface MoveStaggerProvider {
+    register(el: HTMLElement): void;
+    unregister(el: HTMLElement): void;
+    getDelay(el: HTMLElement): number;
+}
+declare const MOVE_STAGGER_PARENT: InjectionToken<MoveStaggerProvider>;
+
+type MoveStaggerDirection = 'first' | 'last' | 'center';
+declare class MoveStaggerDirective implements MoveStaggerProvider {
+    #private;
+    readonly moveStagger: _angular_core.InputSignal<number | MoveSpring>;
+    readonly moveStaggerDirection: _angular_core.InputSignal<MoveStaggerDirection>;
+    register(el: HTMLElement): void;
+    unregister(el: HTMLElement): void;
+    getDelay(el: HTMLElement): number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MoveStaggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MoveStaggerDirective, "[moveStagger]", never, { "moveStagger": { "alias": "moveStagger"; "required": true; "isSignal": true; }; "moveStaggerDirection": { "alias": "moveStaggerDirection"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MoveLayoutDirective implements OnDestroy {
+    #private;
+    readonly moveLayout: _angular_core.InputSignal<boolean | "">;
+    readonly moveLayoutId: _angular_core.InputSignal<string | undefined>;
+    readonly moveDuration: _angular_core.InputSignal<number | undefined>;
+    readonly moveEasing: _angular_core.InputSignal<string | undefined>;
+    readonly moveDelay: _angular_core.InputSignal<number | undefined>;
+    readonly moveDisabled: _angular_core.InputSignal<boolean | undefined>;
+    readonly moveSpring: _angular_core.InputSignal<MoveSpring | undefined>;
+    constructor();
+    private playFlip;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MoveLayoutDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MoveLayoutDirective, "[moveLayout]", never, { "moveLayout": { "alias": "moveLayout"; "required": false; "isSignal": true; }; "moveLayoutId": { "alias": "moveLayoutId"; "required": false; "isSignal": true; }; "moveDuration": { "alias": "moveDuration"; "required": false; "isSignal": true; }; "moveEasing": { "alias": "moveEasing"; "required": false; "isSignal": true; }; "moveDelay": { "alias": "moveDelay"; "required": false; "isSignal": true; }; "moveDisabled": { "alias": "moveDisabled"; "required": false; "isSignal": true; }; "moveSpring": { "alias": "moveSpring"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MoveScrollDirective implements OnInit, OnDestroy {
+    #private;
+    readonly moveScroll: _angular_core.InputSignal<MoveKeyframes | undefined>;
+    readonly moveScrollOffset: _angular_core.InputSignal<[string, string]>;
+    /** Optional CSS selector for a custom scrollable container. Defaults to window scroll. */
+    readonly moveScrollContainer: _angular_core.InputSignal<string | null>;
+    readonly progress: _angular_core.WritableSignal<number>;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MoveScrollDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MoveScrollDirective, "[moveScroll]", ["moveScroll"], { "moveScroll": { "alias": "moveScroll"; "required": false; "isSignal": true; }; "moveScrollOffset": { "alias": "moveScrollOffset"; "required": false; "isSignal": true; }; "moveScrollContainer": { "alias": "moveScrollContainer"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MovePresenceDirective implements MovePresenceProvider {
+    #private;
+    readonly movePresence: _angular_core.InputSignal<unknown>;
+    constructor();
+    register(child: MovePresenceChild): void;
+    unregister(child: MovePresenceChild): void;
+    private removeView;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MovePresenceDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MovePresenceDirective, "[movePresence]", never, { "movePresence": { "alias": "movePresence"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type MoveDragConstraints = {
+    top?: number;
+    right?: number;
+    bottom?: number;
+    left?: number;
+} | HTMLElement;
+declare class MoveDragDirective implements OnDestroy {
+    #private;
+    readonly moveDrag: _angular_core.InputSignal<boolean | "">;
+    readonly moveDragConstraints: _angular_core.InputSignal<MoveDragConstraints | undefined>;
+    readonly moveDragElastic: _angular_core.InputSignal<number>;
+    readonly moveSpring: _angular_core.InputSignal<MoveSpring | undefined>;
+    onPointerDown(e: PointerEvent): void;
+    onPointerMove(e: PointerEvent): void;
+    onPointerUp(e: PointerEvent): void;
+    private resolveBounds;
+    private applyTransform;
+    private snapBackIfNeeded;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MoveDragDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MoveDragDirective, "[moveDrag]", never, { "moveDrag": { "alias": "moveDrag"; "required": false; "isSignal": true; }; "moveDragConstraints": { "alias": "moveDragConstraints"; "required": false; "isSignal": true; }; "moveDragElastic": { "alias": "moveDragElastic"; "required": false; "isSignal": true; }; "moveSpring": { "alias": "moveSpring"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MoveInViewDirective implements OnDestroy, OnInit {
+    #private;
+    readonly moveInView: _angular_core.InputSignal<MovePreset | MoveKeyframes>;
+    readonly moveInViewMargin: _angular_core.InputSignal<string>;
+    readonly moveInViewOnce: _angular_core.InputSignal<boolean>;
+    /** CSS selector for the IntersectionObserver root (for inner scrollable containers). */
+    readonly moveInViewRoot: _angular_core.InputSignal<string | null>;
+    readonly moveDuration: _angular_core.InputSignal<number | undefined>;
+    readonly moveEasing: _angular_core.InputSignal<string | undefined>;
+    readonly moveDelay: _angular_core.InputSignal<number | undefined>;
+    readonly moveDisabled: _angular_core.InputSignal<boolean | undefined>;
+    readonly moveSpring: _angular_core.InputSignal<MoveSpring | undefined>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MoveInViewDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MoveInViewDirective, "[moveInView]", never, { "moveInView": { "alias": "moveInView"; "required": false; "isSignal": true; }; "moveInViewMargin": { "alias": "moveInViewMargin"; "required": false; "isSignal": true; }; "moveInViewOnce": { "alias": "moveInViewOnce"; "required": false; "isSignal": true; }; "moveInViewRoot": { "alias": "moveInViewRoot"; "required": false; "isSignal": true; }; "moveDuration": { "alias": "moveDuration"; "required": false; "isSignal": true; }; "moveEasing": { "alias": "moveEasing"; "required": false; "isSignal": true; }; "moveDelay": { "alias": "moveDelay"; "required": false; "isSignal": true; }; "moveDisabled": { "alias": "moveDisabled"; "required": false; "isSignal": true; }; "moveSpring": { "alias": "moveSpring"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MoveTextDirective implements OnDestroy, OnInit {
+    #private;
+    readonly moveText: _angular_core.InputSignal<MovePreset | MoveKeyframes>;
+    readonly moveTextSplit: _angular_core.InputSignal<"chars" | "words">;
+    readonly moveTextStagger: _angular_core.InputSignal<number>;
+    readonly moveDuration: _angular_core.InputSignal<number | undefined>;
+    readonly moveEasing: _angular_core.InputSignal<string | undefined>;
+    readonly moveDelay: _angular_core.InputSignal<number | undefined>;
+    readonly moveDisabled: _angular_core.InputSignal<boolean | undefined>;
+    readonly moveSpring: _angular_core.InputSignal<MoveSpring | undefined>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MoveTextDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MoveTextDirective, "[moveText]", never, { "moveText": { "alias": "moveText"; "required": false; "isSignal": true; }; "moveTextSplit": { "alias": "moveTextSplit"; "required": false; "isSignal": true; }; "moveTextStagger": { "alias": "moveTextStagger"; "required": false; "isSignal": true; }; "moveDuration": { "alias": "moveDuration"; "required": false; "isSignal": true; }; "moveEasing": { "alias": "moveEasing"; "required": false; "isSignal": true; }; "moveDelay": { "alias": "moveDelay"; "required": false; "isSignal": true; }; "moveDisabled": { "alias": "moveDisabled"; "required": false; "isSignal": true; }; "moveSpring": { "alias": "moveSpring"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Directive that enables smooth scrolling on a specific scrollable container.
+ *
+ * Supports both mouse wheel (desktop) and touch scroll (mobile) with
+ * momentum-based inertia after finger lift, similar to Lenis.
+ *
+ * ⚠️  SmoothScrollService is a root singleton. Do NOT use this directive
+ * on multiple elements simultaneously — use it once on the page root or
+ * inject the service directly where needed.
+ *
+ * Usage:
+ *   <div moveSmoothScroll [moveSmoothScrollLerp]="0.08" style="overflow-y: auto; height: 100vh">
+ *     ...content...
+ *   </div>
+ *
+ * Or use the service directly (e.g. on documentElement):
+ *   constructor() {
+ *     inject(SmoothScrollService).init({ lerp: 0.1 });
+ *   }
+ */
+declare class MoveSmoothScrollDirective implements OnInit, OnDestroy {
+    #private;
+    /** Lerp factor passed to SmoothScrollService. Lower = smoother. Range: 0–1. */
+    readonly moveSmoothScrollLerp: _angular_core.InputSignal<number>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MoveSmoothScrollDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MoveSmoothScrollDirective, "[moveSmoothScroll]", never, { "moveSmoothScrollLerp": { "alias": "moveSmoothScrollLerp"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MoveFocusDirective implements OnDestroy {
+    #private;
+    readonly moveWhileFocus: _angular_core.InputSignal<MovePreset | MoveKeyframes>;
+    readonly moveDuration: _angular_core.InputSignal<number | undefined>;
+    readonly moveEasing: _angular_core.InputSignal<string | undefined>;
+    readonly moveDelay: _angular_core.InputSignal<number | undefined>;
+    readonly moveDisabled: _angular_core.InputSignal<boolean | undefined>;
+    readonly moveSpring: _angular_core.InputSignal<MoveSpring | undefined>;
+    onFocus(): void;
+    onBlur(): void;
+    private play;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MoveFocusDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MoveFocusDirective, "[moveWhileFocus]", never, { "moveWhileFocus": { "alias": "moveWhileFocus"; "required": true; "isSignal": true; }; "moveDuration": { "alias": "moveDuration"; "required": false; "isSignal": true; }; "moveEasing": { "alias": "moveEasing"; "required": false; "isSignal": true; }; "moveDelay": { "alias": "moveDelay"; "required": false; "isSignal": true; }; "moveDisabled": { "alias": "moveDisabled"; "required": false; "isSignal": true; }; "moveSpring": { "alias": "moveSpring"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MoveParallaxDirective implements OnInit, OnDestroy {
+    #private;
+    readonly moveParallax: _angular_core.InputSignal<number>;
+    readonly moveParallaxAxis: _angular_core.InputSignal<"x" | "y">;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MoveParallaxDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MoveParallaxDirective, "[moveParallax]", ["moveParallax"], { "moveParallax": { "alias": "moveParallax"; "required": false; "isSignal": true; }; "moveParallaxAxis": { "alias": "moveParallaxAxis"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * SmoothScrollService — Lenis-inspired smooth scroll for Angular.
+ *
+ * Desktop: intercepts wheel events → lerp interpolation → synthetic scrollTop.
+ * Mobile:  listens to native touch scroll → lerp interpolation → synthetic scrollTop.
+ *          Native scroll is prevented during touch to avoid the vibration conflict.
+ *
+ * The `scrollY` signal is updated on every RAF tick and can be consumed by
+ * `MoveScrollDirective` (or any other consumer) to react to smooth scroll position
+ * without relying on the native `scroll` event (which is NOT fired during smooth scroll).
+ *
+ * Usage (in app root or a layout service):
+ *
+ *   constructor() {
+ *     inject(SmoothScrollService).init();
+ *   }
+ */
+declare class SmoothScrollService implements OnDestroy {
+    #private;
+    /**
+     * Reactive scroll position (in pixels) updated on every RAF tick.
+     * Use this signal instead of listening to `window.scroll` when smooth scroll is active,
+     * since native scroll events are NOT fired during lerp-based scrolling.
+     */
+    readonly scrollY: _angular_core.WritableSignal<number>;
+    /** Whether the service is currently active (i.e. `init()` has been called). */
+    get isActive(): boolean;
+    init(options?: {
+        lerp?: number;
+        element?: HTMLElement;
+    }): void;
+    destroy(): void;
+    /** Scroll programmatically to a Y position */
+    scrollTo(y: number, instant?: boolean): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmoothScrollService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SmoothScrollService>;
+}
+
+interface AnimationControls {
+    play(): void;
+    pause(): void;
+    cancel(): void;
+    currentTime: number;
+    readonly finished: Promise<void>;
+}
+
+interface MovementConfig {
+    duration: number;
+    easing: string;
+    delay: number;
+    disabled: boolean;
+}
+declare const MOVEMENT_DEFAULTS: MovementConfig;
+declare const MOVEMENT_CONFIG: InjectionToken<MovementConfig>;
+
+interface PlayAnimationOptions {
+    config?: MovementConfig;
+    spring?: MoveSpring;
+    delay?: number;
+    disabled?: boolean;
+    onDone?: () => void;
+}
+declare class AnimationEngine {
+    #private;
+    play(host: HTMLElement, frames: MoveKeyframes, options?: PlayAnimationOptions): AnimationControls | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AnimationEngine, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AnimationEngine>;
+}
+
+declare class SpringPlayer implements AnimationControls {
+    #private;
+    private readonly host;
+    private readonly frames;
+    private readonly delay;
+    private readonly onDone?;
+    readonly finished: Promise<void>;
+    constructor(host: HTMLElement, frames: MoveKeyframes, userConfig: MoveSpring, delay: number, onDone?: (() => void) | undefined);
+    play(): void;
+    pause(): void;
+    cancel(): void;
+    get currentTime(): number;
+    set currentTime(time: number);
+}
+
+declare class WaapiPlayer implements AnimationControls {
+    #private;
+    readonly finished: Promise<void>;
+    constructor(host: HTMLElement, frames: MoveKeyframes, config: MovementConfig, onDone?: () => void);
+    play(): void;
+    pause(): void;
+    cancel(): void;
+    get currentTime(): number;
+    set currentTime(time: number);
+}
+
+declare const MOVE_PRESETS: Record<MovePreset, MovePresetDefinition>;
+
+type MovementConfigInput = Partial<MovementConfig>;
+declare function provideMovement(config?: MovementConfigInput): EnvironmentProviders;
+
+declare const MOVEMENT_DIRECTIVES: readonly [typeof MoveEnterDirective, typeof MoveLeaveDirective, typeof MoveAnimateDirective, typeof MoveHoverDirective, typeof MoveTapDirective, typeof MoveVariantsDirective, typeof MoveStaggerDirective, typeof MoveLayoutDirective, typeof MoveScrollDirective, typeof MovePresenceDirective, typeof MoveDragDirective, typeof MoveInViewDirective, typeof MoveTextDirective, typeof MoveSmoothScrollDirective, typeof MoveFocusDirective, typeof MoveParallaxDirective, typeof MoveAnimationDirective];
+
+export { AnimationEngine, MOVEMENT_CONFIG, MOVEMENT_DEFAULTS, MOVEMENT_DIRECTIVES, MOVE_PRESENCE_PARENT, MOVE_PRESETS, MOVE_STAGGER_PARENT, MOVE_VARIANTS_PARENT, MoveAnimateDirective, MoveAnimationDirective, MoveDragDirective, MoveEnterDirective, MoveFocusDirective, MoveHoverDirective, MoveInViewDirective, MoveLayoutDirective, MoveLeaveDirective, MoveParallaxDirective, MovePresenceDirective, MoveScrollDirective, MoveSmoothScrollDirective, MoveStaggerDirective, MoveTapDirective, MoveTextDirective, MoveVariantsDirective, SmoothScrollService, SpringPlayer, WaapiPlayer, provideMovement };
+export type { AnimationControls, MoveAnimationConfig, MoveDragConstraints, MoveKeyframeState, MoveKeyframes, MovePresenceChild, MovePresenceProvider, MovePreset, MovePresetDefinition, MoveSpring, MoveStaggerDirection, MoveStaggerProvider, MoveValuePair, MoveVariant, MoveVariantsProvider, MovementConfig, MovementConfigInput, PlayAnimationOptions };