@hua-labs/motion-core 2.2.3 → 2.4.0

package/dist/index.d.ts

@@ -1,614 +1,9 @@
+import { P as PageType, a as PageMotionRef, b as PageMotionsConfig, B as BaseMotionOptions, E as EntranceType, M as MotionElement, c as BaseMotionReturn, F as FadeInOptions, S as SlideOptions, d as ScaleOptions, e as BounceOptions, f as PulseOptions, g as SpringOptions, G as GradientOptions, H as HoverMotionOptions, h as ScrollRevealOptions, R as RepeatOptions, T as ToggleMotionOptions, I as InteractionReturn, i as InViewOptions, j as InViewReturn, k as MouseOptions, l as MouseReturn, m as ReducedMotionReturn, W as WindowSizeOptions, n as WindowSizeReturn, o as ScrollRevealMotionType } from './springPhysics-DLyZ4nbx.js';
+export { p as BuiltInProfileName, D as DeepPartial, q as EasingFunction, r as EasingType, s as GestureConfig, t as GestureOptions, u as MOTION_PRESETS, v as MotionCallback, w as MotionConfig, x as MotionDirection, y as MotionEasing, z as MotionEngine, A as MotionFrame, C as MotionInstance, J as MotionOptions, K as MotionPreset, L as MotionProfile, N as MotionProfileBase, O as MotionProfileEntrance, Q as MotionProfileInteraction, U as MotionProfileProvider, V as MotionProfileProviderProps, X as MotionProfileSpring, Y as MotionProfileStagger, Z as MotionProgressCallback, _ as MotionState, $ as MotionStateCallback, a0 as MotionTrigger, a1 as MotionType, a2 as OrchestrationConfig, a3 as PAGE_MOTIONS, a4 as PageMotionElement, a5 as PerformanceMetrics, a6 as PresetConfig, a7 as ReducedMotionStrategy, a8 as SpringConfig, a9 as SpringPhysicsConfig, aa as SpringResult, ab as TransitionEffects, ac as TransitionOptions, ad as TransitionType, ae as applyEasing, af as calculateSpring, ag as easeIn, ah as easeInOut, ai as easeInOutQuad, aj as easeInQuad, ak as easeOut, al as easeOutQuad, am as easingPresets, an as getAvailableEasings, ao as getEasing, ap as getMotionPreset, aq as getPagePreset, ar as getPresetEasing, as as hua, at as isEasingFunction, au as isValidEasing, av as linear, aw as mergeProfileOverrides, ax as mergeWithPreset, ay as motionEngine, az as neutral, aA as resolveProfile, aB as safeApplyEasing, aC as transitionEffects, aD as useMotionProfile } from './springPhysics-DLyZ4nbx.js';
 import * as react from 'react';
 import react__default, { CSSProperties, RefObject } from 'react';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 
-/**
- * HUA Motion Core - 의존성 제로 모션 엔진
- *
- * 순수 JavaScript로 구현된 고성능 모션 엔진
- * GPU 가속, 레이어 분리, 성능 최적화 포함
- */
-interface MotionFrame {
-    progress: number;
-    properties: {
-        opacity?: number;
-        transform?: string;
-        scale?: number;
-        translateX?: number;
-        translateY?: number;
-        rotate?: number;
-        rotateX?: number;
-        rotateY?: number;
-        rotateZ?: number;
-        skewX?: number;
-        skewY?: number;
-    };
-}
-interface MotionOptions {
-    duration: number;
-    easing: (t: number) => number;
-    delay?: number;
-    direction?: 'forward' | 'reverse' | 'alternate';
-    iterations?: number;
-    fill?: 'none' | 'forwards' | 'backwards' | 'both';
-    onStart?: () => void;
-    onUpdate?: (progress: number) => void;
-    onComplete?: () => void;
-    onCancel?: () => void;
-}
-interface Motion$1 {
-    id: string;
-    element: HTMLElement;
-    isRunning: boolean;
-    isPaused: boolean;
-    currentProgress: number;
-    startTime: number;
-    pauseTime: number;
-    options: MotionOptions;
-}
-declare class MotionEngine {
-    private motions;
-    private isRunning;
-    private animationFrameId;
-    /**
-     * 모션 시작
-     */
-    motion(element: HTMLElement, motionFrames: MotionFrame[], options: MotionOptions): Promise<string>;
-    /**
-     * 모션 중지
-     */
-    stop(motionId: string): void;
-    /**
-     * 모션 일시정지
-     */
-    pause(motionId: string): void;
-    /**
-     * 모션 재개
-     */
-    resume(motionId: string): void;
-    /**
-     * 모든 모션 중지
-     */
-    stopAll(): void;
-    /**
-     * 모션 상태 확인
-     */
-    getMotion(motionId: string): Motion$1 | undefined;
-    /**
-     * 실행 중인 모션 수
-     */
-    getActiveMotionCount(): number;
-    /**
-     * 애니메이션 루프 시작
-     */
-    private startAnimationLoop;
-    /**
-     * 애니메이션 루프 중지
-     */
-    private stopAnimationLoop;
-    /**
-     * 메인 애니메이션 루프
-     */
-    private animate;
-    /**
-     * 모션 프레임 적용
-     */
-    private applyMotionFrame;
-    /**
-     * GPU 가속 활성화
-     */
-    private enableGPUAcceleration;
-    /**
-     * 레이어 분리
-     */
-    private createLayer;
-    /**
-     * 고유 모션 ID 생성
-     */
-    private generateMotionId;
-    /**
-     * 정리
-     */
-    destroy(): void;
-}
-declare const motionEngine: MotionEngine;
-
-/**
- * HUA Motion Core - 전환 효과 시스템
- *
- * CSS Motion API를 활용한 고성능 전환 효과들
- * GPU 가속 및 레이어 분리 최적화 포함
- */
-
-type TransitionType = 'fade' | 'slide' | 'slide-up' | 'slide-down' | 'slide-left' | 'slide-right' | 'scale' | 'flip' | 'morph' | 'cube' | 'zoom';
-interface TransitionOptions extends Omit<MotionOptions, 'easing'> {
-    type: TransitionType;
-    easing?: (t: number) => number;
-    distance?: number;
-    scale?: number;
-    perspective?: number;
-    onTransitionStart?: () => void;
-    onTransitionComplete?: () => void;
-}
-declare class TransitionEffects {
-    private static instance;
-    private activeTransitions;
-    static getInstance(): TransitionEffects;
-    /**
-     * 페이드 인/아웃 전환
-     */
-    fade(element: HTMLElement, options: Omit<TransitionOptions, 'type'>): Promise<void>;
-    /**
-     * 슬라이드 전환
-     */
-    slide(element: HTMLElement, options: Omit<TransitionOptions, 'type'>): Promise<void>;
-    /**
-     * 스케일 전환
-     */
-    scale(element: HTMLElement, options: Omit<TransitionOptions, 'type'>): Promise<void>;
-    /**
-     * 플립 전환 (3D 회전)
-     */
-    flip(element: HTMLElement, options: Omit<TransitionOptions, 'type'>): Promise<void>;
-    /**
-     * 큐브 전환 (3D 큐브 회전)
-     */
-    cube(element: HTMLElement, options: Omit<TransitionOptions, 'type'>): Promise<void>;
-    /**
-     * 모프 전환 (복합 변형)
-     */
-    morph(element: HTMLElement, options: Omit<TransitionOptions, 'type'>): Promise<void>;
-    /**
-     * 전환 중지
-     */
-    stopTransition(transitionId: string): void;
-    /**
-     * 모든 전환 중지
-     */
-    stopAllTransitions(): void;
-    /**
-     * 활성 전환 수 확인
-     */
-    getActiveTransitionCount(): number;
-    /**
-     * GPU 가속 활성화
-     */
-    private enableGPUAcceleration;
-    /**
-     * 기본 이징 함수
-     */
-    private getDefaultEasing;
-    /**
-     * 고유 전환 ID 생성
-     */
-    private generateTransitionId;
-    /**
-     * 정리
-     */
-    destroy(): void;
-}
-declare const transitionEffects: TransitionEffects;
-
-/**
- * HUA Motion Core - 성능 최적화 시스템
- *
- * GPU 가속, 레이어 관리, 메모리 최적화를 위한 유틸리티들
- * 브라우저별 최적화 전략 포함
- */
-interface PerformanceOptimizerMetrics {
-    fps: number;
-    memoryUsage?: number;
-    gpuTime?: number;
-    cpuTime?: number;
-    layerCount: number;
-    activeMotions: number;
-}
-interface OptimizationConfig {
-    enableGPUAcceleration: boolean;
-    enableLayerSeparation: boolean;
-    enableMemoryOptimization: boolean;
-    targetFPS: number;
-    maxLayerCount: number;
-    memoryThreshold: number;
-}
-declare class PerformanceOptimizer {
-    private static instance;
-    private config;
-    private performanceObserver;
-    private metrics;
-    private layerRegistry;
-    private isMonitoring;
-    constructor();
-    static getInstance(): PerformanceOptimizer;
-    /**
-     * 성능 모니터링 초기화
-     */
-    private initializePerformanceMonitoring;
-    /**
-     * 성능 메트릭 업데이트
-     */
-    private updatePerformanceMetrics;
-    /**
-     * FPS 계산
-     */
-    private calculateFPS;
-    /**
-     * GPU 가속 활성화
-     */
-    enableGPUAcceleration(element: HTMLElement): void;
-    /**
-     * 레이어 분리 및 최적화
-     */
-    createOptimizedLayer(element: HTMLElement): void;
-    /**
-     * 레이어 등록
-     */
-    private registerLayer;
-    /**
-     * 레이어 제거
-     */
-    removeLayer(element: HTMLElement): void;
-    /**
-     * 레이어 수 제한 체크
-     */
-    private checkLayerLimit;
-    /**
-     * 오래된 레이어 정리
-     */
-    private cleanupOldLayers;
-    /**
-     * 메모리 사용량 체크
-     */
-    private checkMemoryUsage;
-    /**
-     * 메모리 정리
-     */
-    private cleanupMemory;
-    /**
-     * 성능 최적화 설정 업데이트
-     */
-    updateConfig(newConfig: Partial<OptimizationConfig>): void;
-    /**
-     * 모든 GPU 가속 비활성화
-     */
-    private disableAllGPUAcceleration;
-    /**
-     * 모든 레이어 비활성화
-     */
-    private disableAllLayers;
-    /**
-     * 성능 메트릭 가져오기
-     */
-    getMetrics(): PerformanceOptimizerMetrics;
-    /**
-     * 성능 모니터링 시작
-     */
-    startMonitoring(): void;
-    /**
-     * 성능 모니터링 중지
-     */
-    stopMonitoring(): void;
-    /**
-     * 메트릭 업데이트
-     */
-    private updateMetrics;
-    /**
-     * 성능 리포트 생성
-     */
-    generateReport(): string;
-    /**
-     * 바이트 단위 포맷팅
-     */
-    private formatBytes;
-    /**
-     * 성능 최적화 권장사항
-     */
-    getOptimizationRecommendations(): string[];
-    /**
-     * 정리
-     */
-    destroy(): void;
-    private lastFrameTime?;
-    private monitoringInterval?;
-}
-declare const performanceOptimizer: PerformanceOptimizer;
-
-type MotionElement = HTMLDivElement | HTMLSpanElement | HTMLButtonElement | HTMLHeadingElement | HTMLParagraphElement | HTMLImageElement;
-type MotionStyle = CSSProperties & {
-    '--motion-delay'?: string;
-    '--motion-duration'?: string;
-    '--motion-easing'?: string;
-    '--motion-progress'?: string;
-};
-interface BaseMotionOptions {
-    /** 모션 시작 지연 시간 (ms) */
-    delay?: number;
-    /** 모션 지속 시간 (ms) */
-    duration?: number;
-    /** Intersection Observer 임계값 (0-1) */
-    threshold?: number;
-    /** 한 번만 트리거할지 여부 */
-    triggerOnce?: boolean;
-    /** 이징 함수명 */
-    easing?: string;
-    /** 자동 시작 여부 */
-    autoStart?: boolean;
-    /** 모션 완료 시 콜백 */
-    onComplete?: () => void;
-    /** 모션 시작 시 콜백 */
-    onStart?: () => void;
-    /** 모션 중단 시 콜백 */
-    onStop?: () => void;
-    /** 모션 리셋 시 콜백 */
-    onReset?: () => void;
-}
-interface BaseMotionReturn<T extends MotionElement = HTMLDivElement> {
-    /** DOM 요소 참조 (React 19 호환) */
-    ref: React.RefObject<T | null>;
-    /** 요소가 화면에 보이는지 여부 */
-    isVisible: boolean;
-    /** 모션이 진행 중인지 여부 */
-    isAnimating: boolean;
-    /** 적용할 CSS 스타일 (React 19 호환) - useFadeIn 등에서는 항상 반환됨 */
-    style: MotionStyle;
-    /** 적용할 CSS 클래스명 */
-    className?: string;
-    /** 모션 진행률 (0-1) - useFadeIn 등에서는 항상 반환됨 */
-    progress: number;
-    /** 모션 시작 함수 - useFadeIn 등에서는 항상 반환됨 */
-    start: () => void;
-    /** 모션 리셋 함수 - useFadeIn 등에서는 항상 반환됨 */
-    reset: () => void;
-    /** 모션 중단 함수 - useFadeIn 등에서는 항상 반환됨 */
-    stop: () => void;
-    /** 모션 일시정지 함수 - 일부 훅에서만 제공 */
-    pause?: () => void;
-    /** 모션 재개 함수 - 일부 훅에서만 제공 */
-    resume?: () => void;
-}
-interface InteractionReturn<T extends MotionElement = HTMLDivElement> extends BaseMotionReturn<T> {
-    /** 가시성 토글 함수 */
-    toggle?: () => void;
-    /** 표시 함수 */
-    show?: () => void;
-    /** 숨김 함수 */
-    hide?: () => void;
-}
-interface FadeInOptions extends BaseMotionOptions {
-    /** 초기 투명도 */
-    initialOpacity?: number;
-    /** 목표 투명도 */
-    targetOpacity?: number;
-}
-interface SlideOptions extends BaseMotionOptions {
-    /** 슬라이드 방향 */
-    direction?: 'up' | 'down' | 'left' | 'right';
-    /** 슬라이드 거리 (px) */
-    distance?: number;
-}
-interface ScaleOptions extends BaseMotionOptions {
-    /** 초기 스케일 */
-    initialScale?: number;
-    /** 목표 스케일 */
-    targetScale?: number;
-}
-interface BounceOptions extends BaseMotionOptions {
-    /** 바운스 강도 */
-    intensity?: number;
-    /** 바운스 횟수 */
-    bounces?: number;
-}
-interface PulseOptions extends BaseMotionOptions {
-    /** 펄스 강도 */
-    intensity?: number;
-    /** 반복 횟수 (-1 = 무한) */
-    repeatCount?: number;
-    /** 반복 간격 (ms) */
-    repeatDelay?: number;
-}
-interface SpringOptions extends BaseMotionOptions {
-    /** 스프링 질량 */
-    mass?: number;
-    /** 스프링 강성 */
-    stiffness?: number;
-    /** 스프링 감쇠 */
-    damping?: number;
-    /** 정지 임계값 */
-    restDelta?: number;
-    /** 정지 속도 */
-    restSpeed?: number;
-}
-interface GestureOptions$1 extends BaseMotionOptions {
-    /** 호버 제스처 활성화 */
-    hover?: boolean;
-    /** 드래그 제스처 활성화 */
-    drag?: boolean;
-    /** 핀치 제스처 활성화 */
-    pinch?: boolean;
-    /** 스와이프 제스처 활성화 */
-    swipe?: boolean;
-    /** 틸트 제스처 활성화 */
-    tilt?: boolean;
-}
-type MotionDirection$1 = 'up' | 'down' | 'left' | 'right';
-type MotionEasing = 'linear' | 'ease-in' | 'ease-out' | 'ease-in-out' | 'bounce' | 'elastic';
-type MotionTrigger = 'scroll' | 'click' | 'hover' | 'focus' | 'auto';
-type MotionCallback = () => void;
-type MotionProgressCallback = (progress: number) => void;
-type MotionStateCallback<T extends MotionElement = HTMLDivElement> = (state: BaseMotionReturn<T>) => void;
-interface PerformanceMetrics {
-    /** 모션 시작 시간 */
-    startTime: number;
-    /** 모션 종료 시간 */
-    endTime?: number;
-    /** 총 지속 시간 */
-    duration: number;
-    /** FPS */
-    fps: number;
-    /** 메모리 사용량 */
-    memoryUsage?: number;
-}
-interface MotionConfig {
-    /** 성능 모니터링 활성화 */
-    enablePerformanceMonitoring?: boolean;
-    /** 디버그 모드 활성화 */
-    debug?: boolean;
-    /** 로그 레벨 */
-    logLevel?: 'none' | 'error' | 'warn' | 'info' | 'debug';
-}
-interface InViewOptions {
-    /** Intersection Observer 임계값 */
-    threshold?: number | number[];
-    /** 루트 마진 */
-    rootMargin?: string;
-    /** 한 번만 트리거할지 여부 */
-    triggerOnce?: boolean;
-    /** 초기 가시성 상태 */
-    initialInView?: boolean;
-}
-interface InViewReturn<T extends HTMLElement = HTMLDivElement> {
-    /** DOM 요소 참조 */
-    ref: RefObject<T | null>;
-    /** 요소가 화면에 보이는지 여부 */
-    inView: boolean;
-    /** IntersectionObserver 엔트리 */
-    entry: IntersectionObserverEntry | null;
-}
-interface MouseOptions {
-    /** 타겟 요소 참조 */
-    targetRef?: RefObject<HTMLElement | null>;
-    /** 스로틀 시간 (ms) */
-    throttle?: number;
-}
-interface MouseReturn {
-    /** 마우스 X 좌표 (viewport 기준) */
-    x: number;
-    /** 마우스 Y 좌표 (viewport 기준) */
-    y: number;
-    /** 요소 내 상대 X 좌표 (0-1) */
-    elementX: number;
-    /** 요소 내 상대 Y 좌표 (0-1) */
-    elementY: number;
-    /** 마우스가 타겟 위에 있는지 여부 */
-    isOver: boolean;
-}
-interface ReducedMotionReturn {
-    /** 사용자가 모션 감소를 선호하는지 여부 */
-    prefersReducedMotion: boolean;
-}
-interface WindowSizeOptions {
-    /** 디바운스 시간 (ms) */
-    debounce?: number;
-    /** 초기 너비 */
-    initialWidth?: number;
-    /** 초기 높이 */
-    initialHeight?: number;
-}
-interface WindowSizeReturn {
-    /** 윈도우 너비 */
-    width: number;
-    /** 윈도우 높이 */
-    height: number;
-    /** 마운트 여부 (SSR 대응) */
-    isMounted: boolean;
-}
-type ScrollRevealMotionType = 'fadeIn' | 'slideUp' | 'slideLeft' | 'slideRight' | 'scaleIn' | 'bounceIn';
-interface ScrollRevealOptions extends BaseMotionOptions {
-    /** 루트 마진 */
-    rootMargin?: string;
-    /** 모션 타입 */
-    motionType?: ScrollRevealMotionType;
-}
-interface GradientOptions extends BaseMotionOptions {
-    /** 그라디언트 색상 배열 */
-    colors?: string[];
-    /** 그라디언트 방향 */
-    direction?: 'horizontal' | 'vertical' | 'diagonal';
-    /** 그라디언트 크기 (%) */
-    size?: number;
-}
-interface ToggleMotionOptions extends BaseMotionOptions {
-}
-interface RepeatOptions extends BaseMotionOptions {
-    /** 반복 효과 타입 */
-    type?: 'pulse' | 'bounce' | 'wave' | 'fade';
-    /** 효과 강도 */
-    intensity?: number;
-}
-interface HoverMotionOptions extends BaseMotionOptions {
-    /** 호버 시 스케일 */
-    hoverScale?: number;
-    /** 호버 시 Y 오프셋 (px) */
-    hoverY?: number;
-    /** 호버 시 투명도 */
-    hoverOpacity?: number;
-}
-
-type PageType = 'home' | 'dashboard' | 'product' | 'blog';
-type MotionType$1 = 'hero' | 'title' | 'button' | 'card' | 'text' | 'image';
-type EntranceType = 'fadeIn' | 'slideUp' | 'slideLeft' | 'slideRight' | 'scaleIn' | 'bounceIn';
-interface PageMotionElement {
-    type: MotionType$1;
-    entrance?: EntranceType;
-    hover?: boolean;
-    click?: boolean;
-    delay?: number;
-    duration?: number;
-    threshold?: number;
-}
-interface PageMotionsConfig {
-    [elementId: string]: PageMotionElement;
-}
-interface MotionState$1 {
-    internalVisibility: boolean;
-    triggeredVisibility: boolean;
-    finalVisibility: boolean;
-    opacity: number;
-    translateY: number;
-    translateX: number;
-    scale: number;
-    rotation: number;
-    isHovered: boolean;
-    isClicked: boolean;
-    isAnimating: boolean;
-}
-interface PageMotionRef<T extends HTMLElement = HTMLElement> {
-    ref: React.RefObject<T | null>;
-    style: React.CSSProperties;
-    isVisible: boolean;
-    isHovered: boolean;
-    isClicked: boolean;
-}
-interface MotionPreset {
-    entrance: EntranceType;
-    delay: number;
-    duration: number;
-    hover: boolean;
-    click: boolean;
-}
-interface PresetConfig {
-    [key: string]: MotionPreset;
-}
-interface SpringConfig {
-    mass?: number;
-    stiffness?: number;
-    damping?: number;
-    restDelta?: number;
-    restSpeed?: number;
-}
-interface GestureConfig {
-    hover?: boolean;
-    drag?: boolean;
-    pinch?: boolean;
-    swipe?: boolean;
-    tilt?: boolean;
-}
-interface OrchestrationConfig {
-    sequence?: 'sequential' | 'parallel' | 'stagger';
-    staggerDelay?: number;
-    staggerDuration?: number;
-}
-
 /**
  * 1단계 API: 프리셋 기반 페이지 모션 (기존 방식)
  *
@@ -1061,6 +456,193 @@ declare function useGestureMotion(options: GestureMotionOptions): {
     isActive: boolean;
 };
 
+interface ButtonEffectOptions extends BaseMotionOptions {
+    type?: 'scale' | 'ripple' | 'glow' | 'shake' | 'bounce' | 'slide' | 'custom';
+    scaleAmount?: number;
+    rippleColor?: string;
+    rippleSize?: number;
+    rippleDuration?: number;
+    glowColor?: string;
+    glowSize?: number;
+    glowIntensity?: number;
+    shakeAmount?: number;
+    shakeFrequency?: number;
+    bounceHeight?: number;
+    bounceStiffness?: number;
+    slideDistance?: number;
+    slideDirection?: 'left' | 'right' | 'up' | 'down';
+    hoverScale?: number;
+    hoverRotate?: number;
+    hoverTranslateY?: number;
+    hoverTranslateX?: number;
+    activeScale?: number;
+    activeRotate?: number;
+    activeTranslateY?: number;
+    activeTranslateX?: number;
+    focusScale?: number;
+    focusGlow?: boolean;
+    disabled?: boolean;
+    disabledOpacity?: number;
+    autoStart?: boolean;
+}
+declare function useButtonEffect<T extends MotionElement = HTMLButtonElement>(options?: ButtonEffectOptions): BaseMotionReturn<T> & {
+    buttonType: string;
+    isPressed: boolean;
+    isHovered: boolean;
+    isFocused: boolean;
+    ripplePosition: {
+        x: number;
+        y: number;
+    };
+    currentGlowIntensity: number;
+    shakeOffset: number;
+    bounceOffset: number;
+    slideOffset: number;
+    pressButton: () => void;
+    releaseButton: () => void;
+    setButtonState: (state: 'idle' | 'hover' | 'active' | 'focus' | 'disabled') => void;
+};
+
+interface VisibilityToggleOptions extends BaseMotionOptions {
+    showScale?: number;
+    showOpacity?: number;
+    showRotate?: number;
+    showTranslateY?: number;
+    showTranslateX?: number;
+    hideScale?: number;
+    hideOpacity?: number;
+    hideRotate?: number;
+    hideTranslateY?: number;
+    hideTranslateX?: number;
+}
+declare function useVisibilityToggle<T extends MotionElement = HTMLDivElement>(options?: VisibilityToggleOptions): InteractionReturn<T>;
+
+interface ScrollToggleOptions extends BaseMotionOptions {
+    showScale?: number;
+    showOpacity?: number;
+    showRotate?: number;
+    showTranslateY?: number;
+    showTranslateX?: number;
+    hideScale?: number;
+    hideOpacity?: number;
+    hideRotate?: number;
+    hideTranslateY?: number;
+    hideTranslateX?: number;
+    scrollThreshold?: number;
+    scrollDirection?: 'up' | 'down' | 'both';
+}
+declare function useScrollToggle<T extends MotionElement = HTMLDivElement>(options?: ScrollToggleOptions): BaseMotionReturn<T>;
+
+interface CardListOptions extends BaseMotionOptions {
+    staggerDelay?: number;
+    cardScale?: number;
+    cardOpacity?: number;
+    cardRotate?: number;
+    cardTranslateY?: number;
+    cardTranslateX?: number;
+    initialScale?: number;
+    initialOpacity?: number;
+    initialRotate?: number;
+    initialTranslateY?: number;
+    initialTranslateX?: number;
+    gridColumns?: number;
+    gridGap?: number;
+}
+declare function useCardList<T extends MotionElement = HTMLDivElement>(options?: CardListOptions): BaseMotionReturn<T> & {
+    cardStyles: React.CSSProperties[];
+    staggerDelay: number;
+    gridColumns: number;
+    gridGap: number;
+};
+
+interface LoadingSpinnerOptions extends BaseMotionOptions {
+    type?: 'rotate' | 'pulse' | 'bounce' | 'wave' | 'dots' | 'bars' | 'custom';
+    rotationSpeed?: number;
+    pulseSpeed?: number;
+    bounceHeight?: number;
+    waveCount?: number;
+    dotCount?: number;
+    barCount?: number;
+    color?: string;
+    backgroundColor?: string;
+    size?: number;
+    thickness?: number;
+    autoStart?: boolean;
+    infinite?: boolean;
+}
+declare function useLoadingSpinner<T extends MotionElement = HTMLDivElement>(options?: LoadingSpinnerOptions): BaseMotionReturn<T> & {
+    isLoading: boolean;
+    spinnerType: string;
+    rotationAngle: number;
+    pulseScale: number;
+    bounceOffset: number;
+    waveProgress: number;
+    dotProgress: number;
+    barProgress: number;
+    startLoading: () => void;
+    stopLoading: () => void;
+    setLoadingState: (loading: boolean) => void;
+};
+
+interface NavigationOptions extends BaseMotionOptions {
+    type?: 'slide' | 'fade' | 'scale' | 'rotate' | 'custom';
+    slideDirection?: 'left' | 'right' | 'up' | 'down';
+    staggerDelay?: number;
+    itemScale?: number;
+    itemOpacity?: number;
+    itemRotate?: number;
+    itemTranslateY?: number;
+    itemTranslateX?: number;
+    initialScale?: number;
+    initialOpacity?: number;
+    initialRotate?: number;
+    initialTranslateY?: number;
+    initialTranslateX?: number;
+    activeScale?: number;
+    activeOpacity?: number;
+    activeRotate?: number;
+    activeTranslateY?: number;
+    activeTranslateX?: number;
+    hoverScale?: number;
+    hoverOpacity?: number;
+    hoverRotate?: number;
+    hoverTranslateY?: number;
+    hoverTranslateX?: number;
+    itemCount?: number;
+    autoStart?: boolean;
+}
+declare function useNavigation<T extends MotionElement = HTMLDivElement>(options?: NavigationOptions): BaseMotionReturn<T> & {
+    isOpen: boolean;
+    activeIndex: number;
+    itemStyles: React.CSSProperties[];
+    openMenu: () => void;
+    closeMenu: () => void;
+    toggleMenu: () => void;
+    setActiveItem: (index: number) => void;
+    goToNext: () => void;
+    goToPrevious: () => void;
+};
+
+interface SkeletonOptions extends BaseMotionOptions {
+    /** 스켈레톤 배경색 */
+    backgroundColor?: string;
+    /** 스켈레톤 하이라이트 색상 */
+    highlightColor?: string;
+    /** 모션 속도 (ms) */
+    motionSpeed?: number;
+    /** 스켈레톤 높이 */
+    height?: number;
+    /** 스켈레톤 너비 */
+    width?: number | string;
+    /** 보더 반지름 */
+    borderRadius?: number;
+    /** 웨이브 모션 활성화 여부 */
+    wave?: boolean;
+    /** 펄스 모션 활성화 여부 */
+    pulse?: boolean;
+}
+declare function useSkeleton<T extends MotionElement = HTMLDivElement>(options?: SkeletonOptions): BaseMotionReturn<T>;
+
 interface TypewriterOptions {
     /** 타이핑할 텍스트 */
     text: string;
@@ -1236,6 +818,9 @@ interface ElementProgressReturn<T extends HTMLElement = HTMLElement> {
  * useScrollProgress의 확장판. 페이지 전체가 아니라
  * 특정 요소가 뷰포트를 통과하는 진행률을 추적합니다.
  *
+ * 공유 스크롤 리스너(subscribeScroll)를 사용해 N개 인스턴스도
+ * 단 하나의 scroll/resize 이벤트 + rAF 배칭으로 처리됩니다.
+ *
  * @example
  * ```tsx
  * const { ref, progress, isInView } = useElementProgress<HTMLDivElement>()
@@ -1248,47 +833,552 @@ interface ElementProgressReturn<T extends HTMLElement = HTMLElement> {
  */
 declare function useElementProgress<T extends HTMLElement = HTMLElement>(options?: ElementProgressOptions): ElementProgressReturn<T>;
 
-declare const MOTION_PRESETS: PresetConfig;
-declare const PAGE_MOTIONS: Record<PageType, PageMotionsConfig>;
 /**
- * 프리셋과 커스텀 설정을 병합
+ * Shared IntersectionObserver Pool
+ *
+ * threshold|rootMargin 조합별로 하나의 IntersectionObserver를 공유합니다.
+ * N개 훅 = K개 observer (K = 고유 옵션 조합 수, 보통 1~3).
+ *
+ * sharedScroll.ts와 동일한 singleton pool 패턴.
+ *
+ * @example
+ * ```ts
+ * useEffect(() => {
+ *   if (!ref.current) return
+ *   return observeElement(
+ *     ref.current,
+ *     (entry) => { if (entry.isIntersecting) start() },
+ *     { threshold: 0.1 },
+ *     true // once
+ *   )
+ * }, [])
+ * ```
  */
-declare function mergeWithPreset(preset: MotionPreset, custom?: Partial<MotionPreset>): MotionPreset;
+type EntryCallback = (entry: IntersectionObserverEntry) => void;
 /**
- * 페이지 타입으로 프리셋 가져오기
+ * element를 공유 IntersectionObserver에 등록.
+ * 반환 함수를 호출하면 구독 해제.
+ *
+ * @param element - 관찰할 DOM element
+ * @param callback - intersection 변화 시 호출되는 콜백 (해당 element의 entry만 전달)
+ * @param options - threshold, rootMargin
+ * @param once - true이면 첫 intersection 후 자동 unsubscribe
+ * @returns unsubscribe 함수
  */
-declare function getPagePreset(pageType: PageType): PageMotionsConfig;
+declare function observeElement(element: Element, callback: EntryCallback, options?: {
+    threshold?: number | number[];
+    rootMargin?: string;
+}, once?: boolean): () => void;
+
+interface AutoFadeConfig {
+    initialOpacity?: number;
+    targetOpacity?: number;
+    duration?: number;
+    delay?: number;
+    repeat?: boolean;
+    repeatDelay?: number;
+    repeatCount?: number;
+    ease?: "linear" | "ease-in" | "ease-out" | "ease-in-out";
+    autoStart?: boolean;
+    onComplete?: () => void;
+    onRepeat?: (count: number) => void;
+    showOnMount?: boolean;
+}
+interface AutoFadeReturn {
+    opacity: number;
+    isAnimating: boolean;
+    isVisible: boolean;
+    mounted: boolean;
+    start: () => void;
+    stop: () => void;
+    reset: () => void;
+    fadeIn: () => void;
+    fadeOut: () => void;
+    toggle: () => void;
+}
+declare function useAutoFade(options?: AutoFadeConfig): AutoFadeReturn;
+
+interface AutoPlayConfig {
+    interval?: number;
+    delay?: number;
+    repeat?: number | "infinite";
+    autoStart?: boolean;
+    pauseOnHover?: boolean;
+    pauseOnBlur?: boolean;
+    showOnMount?: boolean;
+}
+declare function useAutoPlay(options?: AutoPlayConfig): {
+    isPlaying: boolean;
+    isPaused: boolean;
+    currentStep: number;
+    mounted: boolean;
+    start: () => void;
+    stop: () => void;
+    pause: () => void;
+    resume: () => void;
+    next: () => void;
+    previous: () => void;
+    goTo: (step: number) => void;
+};
+
+interface AutoScaleConfig {
+    initialScale?: number;
+    targetScale?: number;
+    duration?: number;
+    delay?: number;
+    repeat?: boolean;
+    repeatDelay?: number;
+    repeatCount?: number;
+    ease?: "linear" | "ease-in" | "ease-out" | "ease-in-out" | "bounce" | "elastic";
+    autoStart?: boolean;
+    onComplete?: () => void;
+    onRepeat?: (count: number) => void;
+    showOnMount?: boolean;
+    centerTransform?: boolean;
+}
+interface AutoScaleReturn {
+    scale: number;
+    isAnimating: boolean;
+    isVisible: boolean;
+    mounted: boolean;
+    start: () => void;
+    stop: () => void;
+    reset: () => void;
+    scaleIn: () => void;
+    scaleOut: () => void;
+    toggle: () => void;
+}
+declare function useAutoScale(options?: AutoScaleConfig): AutoScaleReturn;
+
+type SlideDirection = "left" | "right" | "up" | "down" | "left-up" | "left-down" | "right-up" | "right-down";
+interface AutoSlideConfig {
+    direction?: SlideDirection;
+    distance?: number;
+    initialPosition?: {
+        x: number;
+        y: number;
+    };
+    targetPosition?: {
+        x: number;
+        y: number;
+    };
+    duration?: number;
+    delay?: number;
+    repeat?: boolean;
+    repeatDelay?: number;
+    repeatCount?: number;
+    ease?: "linear" | "ease-in" | "ease-out" | "ease-in-out";
+    autoStart?: boolean;
+    onComplete?: () => void;
+    onRepeat?: (count: number) => void;
+    showOnMount?: boolean;
+}
+interface AutoSlideReturn {
+    position: {
+        x: number;
+        y: number;
+    };
+    isAnimating: boolean;
+    isVisible: boolean;
+    mounted: boolean;
+    start: () => void;
+    stop: () => void;
+    reset: () => void;
+    slideIn: () => void;
+    slideOut: () => void;
+    toggle: () => void;
+}
+declare function useAutoSlide(options?: AutoSlideConfig): AutoSlideReturn;
+
+interface MotionStep$1 {
+    id: string;
+    motion: () => void;
+    delay?: number;
+    duration?: number;
+    onComplete?: () => void;
+}
+interface MotionOrchestraOptions {
+    mode?: "sequential" | "parallel" | "stagger";
+    staggerDelay?: number;
+    autoStart?: boolean;
+    loop?: boolean;
+    onComplete?: () => void;
+}
+declare function useMotionOrchestra(options?: MotionOrchestraOptions): {
+    addMotion: (step: MotionStep$1) => void;
+    removeMotion: (id: string) => void;
+    play: () => void;
+    stop: () => void;
+    pause: () => void;
+    resume: () => void;
+    isPlaying: boolean;
+    currentStep: number;
+    completedSteps: Set<string>;
+    totalSteps: number;
+};
+
+interface MotionStep {
+    id: string;
+    duration: number;
+    delay?: number;
+    ease?: "linear" | "ease-in" | "ease-out" | "ease-in-out" | "bounce" | "elastic";
+    onStart?: () => void;
+    onUpdate?: (progress: number) => void;
+    onComplete?: () => void;
+    onError?: (error: Error) => void;
+}
+interface OrchestrationConfig {
+    autoStart?: boolean;
+    loop?: boolean;
+    loopCount?: number;
+    loopDelay?: number;
+    timeline?: MotionStep[];
+    duration?: number;
+    speed?: number;
+    reverse?: boolean;
+    onStart?: () => void;
+    onComplete?: () => void;
+    onLoop?: (count: number) => void;
+    onError?: (error: Error) => void;
+    onProgress?: (progress: number) => void;
+    onStepStart?: (stepId: string) => void;
+    onStepComplete?: (stepId: string) => void;
+}
+interface OrchestrationReturn {
+    isPlaying: boolean;
+    isPaused: boolean;
+    currentTime: number;
+    progress: number;
+    currentStep: string | null;
+    loopCount: number;
+    error: string | null;
+    play: () => void;
+    pause: () => void;
+    stop: () => void;
+    reset: () => void;
+    seek: (time: number) => void;
+    setSpeed: (speed: number) => void;
+    reverse: () => void;
+    addStep: (step: MotionStep) => void;
+    removeStep: (stepId: string) => void;
+    updateStep: (stepId: string, updates: Partial<MotionStep>) => void;
+    reorderSteps: (stepIds: string[]) => void;
+    getStepProgress: (stepId: string) => number;
+    getStepTime: (stepId: string) => number;
+    getTotalDuration: () => number;
+}
+declare function useOrchestration(options?: OrchestrationConfig): OrchestrationReturn;
+
+interface SequenceConfig {
+    autoStart?: boolean;
+    loop?: boolean;
+}
+interface SequenceItem {
+    hook: () => any;
+    delay?: number;
+}
+declare function useSequence(sequence: SequenceItem[], options?: SequenceConfig): {
+    start: () => void;
+    stop: () => void;
+    pause: () => void;
+    resume: () => void;
+    reset: () => void;
+    isPlaying: boolean;
+    currentIndex: number;
+    totalMotions: number;
+    ref: any;
+};
+
+interface LayoutMotionConfig {
+    from: {
+        width?: number | string;
+        height?: number | string;
+        flexDirection?: "row" | "column" | "row-reverse" | "column-reverse";
+        justifyContent?: "flex-start" | "flex-end" | "center" | "space-between" | "space-around" | "space-evenly";
+        alignItems?: "flex-start" | "flex-end" | "center" | "stretch" | "baseline";
+        gap?: number | string;
+        gridTemplateColumns?: string;
+        gridTemplateRows?: string;
+        gridGap?: number | string;
+    };
+    to: {
+        width?: number | string;
+        height?: number | string;
+        flexDirection?: "row" | "column" | "row-reverse" | "column-reverse";
+        justifyContent?: "flex-start" | "flex-end" | "center" | "space-between" | "space-around" | "space-evenly";
+        alignItems?: "flex-start" | "flex-end" | "center" | "stretch" | "baseline";
+        gap?: number | string;
+        gridTemplateColumns?: string;
+        gridTemplateRows?: string;
+        gridGap?: number | string;
+    };
+    duration?: number;
+    easing?: string;
+    autoStart?: boolean;
+    onComplete?: () => void;
+}
+interface LayoutState {
+    isAnimating: boolean;
+    progress: number;
+    currentStyle: React.CSSProperties;
+}
+declare function useLayoutMotion(config: LayoutMotionConfig): {
+    ref: react.RefObject<HTMLDivElement | null>;
+    state: LayoutState;
+    start: () => void;
+    stop: () => void;
+    reset: () => void;
+};
+declare function createLayoutTransition(from: LayoutMotionConfig["from"], to: LayoutMotionConfig["to"], options?: Partial<LayoutMotionConfig>): {
+    from: {
+        width?: number | string;
+        height?: number | string;
+        flexDirection?: "row" | "column" | "row-reverse" | "column-reverse";
+        justifyContent?: "flex-start" | "flex-end" | "center" | "space-between" | "space-around" | "space-evenly";
+        alignItems?: "flex-start" | "flex-end" | "center" | "stretch" | "baseline";
+        gap?: number | string;
+        gridTemplateColumns?: string;
+        gridTemplateRows?: string;
+        gridGap?: number | string;
+    };
+    to: {
+        width?: number | string;
+        height?: number | string;
+        flexDirection?: "row" | "column" | "row-reverse" | "column-reverse";
+        justifyContent?: "flex-start" | "flex-end" | "center" | "space-between" | "space-around" | "space-evenly";
+        alignItems?: "flex-start" | "flex-end" | "center" | "stretch" | "baseline";
+        gap?: number | string;
+        gridTemplateColumns?: string;
+        gridTemplateRows?: string;
+        gridGap?: number | string;
+    };
+    duration: number;
+    easing: string;
+    autoStart: boolean;
+    onComplete: (() => void) | undefined;
+};
+
+interface KeyboardToggleConfig {
+    initialState?: boolean;
+    keys?: string[];
+    keyCode?: number;
+    keyCombo?: string[];
+    toggleOnKeyDown?: boolean;
+    toggleOnKeyUp?: boolean;
+    toggleOnKeyPress?: boolean;
+    autoReset?: boolean;
+    resetDelay?: number;
+    preventDefault?: boolean;
+    stopPropagation?: boolean;
+    requireFocus?: boolean;
+    showOnMount?: boolean;
+}
+interface KeyboardToggleReturn {
+    isActive: boolean;
+    mounted: boolean;
+    toggle: () => void;
+    activate: () => void;
+    deactivate: () => void;
+    reset: () => void;
+    keyboardHandlers: {
+        onKeyDown?: (event: React.KeyboardEvent) => void;
+        onKeyUp?: (event: React.KeyboardEvent) => void;
+        onKeyPress?: (event: React.KeyboardEvent) => void;
+    };
+    ref: React.RefObject<HTMLElement | null>;
+}
+declare function useKeyboardToggle(options?: KeyboardToggleConfig): KeyboardToggleReturn;
+
+type ScrollDirection = "up" | "down" | "idle";
+interface ScrollDirectionConfig {
+    threshold?: number;
+    idleDelay?: number;
+    showOnMount?: boolean;
+}
+declare function useScrollDirection(options?: ScrollDirectionConfig): {
+    direction: ScrollDirection;
+    mounted: boolean;
+};
+
+interface StickyToggleConfig {
+    offset?: number;
+    behavior?: "smooth" | "auto";
+    showOnMount?: boolean;
+}
+declare function useStickyToggle(options?: StickyToggleConfig): {
+    isSticky: boolean;
+    mounted: boolean;
+};
+
+interface InteractiveConfig {
+    hoverScale?: number;
+    clickScale?: number;
+    duration?: number;
+}
+interface InteractiveState {
+    scale: number;
+    isHovered: boolean;
+    isClicked: boolean;
+}
+declare function useInteractive(config?: InteractiveConfig): {
+    ref: (element: HTMLDivElement | null) => void;
+    scale: number;
+    isHovered: boolean;
+    isClicked: boolean;
+    handleMouseEnter: () => void;
+    handleMouseLeave: () => void;
+    handleMouseDown: () => void;
+    handleMouseUp: () => void;
+};
+
+interface PerformanceMonitorConfig {
+    threshold?: number;
+    onPerformanceIssue?: (fps: number) => void;
+}
+interface PerformanceMonitorState {
+    fps: number;
+    isLowPerformance: boolean;
+    frameCount: number;
+}
+declare function usePerformanceMonitor(config?: PerformanceMonitorConfig): {
+    ref: (element: HTMLDivElement | null) => void;
+    fps: number;
+    isLowPerformance: boolean;
+    frameCount: number;
+};
+
+interface LanguageConfig {
+    motionType: "fadeIn" | "slideUp" | "slideLeft" | "slideRight" | "scaleIn" | "bounceIn";
+    duration?: number;
+    delay?: number;
+    threshold?: number;
+    pauseOnLanguageChange?: boolean;
+    restartOnLanguageChange?: boolean;
+    currentLanguage?: string;
+}
+declare function useLanguageAwareMotion(options: LanguageConfig): {
+    ref: react.RefObject<HTMLElement | null>;
+    isVisible: boolean;
+    isPaused: boolean;
+    style: {
+        opacity: number;
+        transform: string;
+        transition: string;
+    } | {
+        opacity: number;
+        transition: string;
+        transform?: undefined;
+    };
+    pauseMotion: () => void;
+    resumeMotion: () => void;
+    restartMotion: () => void;
+    currentLanguage: string;
+};
+
+interface GameLoopConfig {
+    fps?: number;
+    autoStart?: boolean;
+    maxFPS?: number;
+    minFPS?: number;
+    showOnMount?: boolean;
+}
+interface GameState {
+    isRunning: boolean;
+    fps: number;
+    deltaTime: number;
+    elapsedTime: number;
+    frameCount: number;
+    mounted: boolean;
+}
+interface GameLoopReturn {
+    isRunning: boolean;
+    fps: number;
+    deltaTime: number;
+    elapsedTime: number;
+    frameCount: number;
+    mounted: boolean;
+    start: () => void;
+    stop: () => void;
+    pause: () => void;
+    resume: () => void;
+    reset: () => void;
+    onUpdate: (callback: (deltaTime: number, elapsedTime: number) => void) => void;
+    onRender: (callback: (deltaTime: number, elapsedTime: number) => void) => void;
+}
+declare function useGameLoop(options?: GameLoopConfig): GameLoopReturn;
+
+interface AutoMotionConfig {
+    duration?: number;
+    delay?: number;
+    autoStart?: boolean;
+    easing?: string;
+    type?: "fade" | "slide" | "scale" | "rotate";
+}
+interface MotionConfig {
+    duration?: number;
+    delay?: number;
+    autoStart?: boolean;
+    easing?: string;
+    type?: "fade" | "slide" | "scale" | "rotate";
+}
+interface MotionFromToConfig {
+    from: Record<string, any>;
+    to: Record<string, any>;
+    duration?: number;
+    delay?: number;
+    autoStart?: boolean;
+    ease?: string;
+}
+declare function useMotion(configOrFrom?: MotionConfig | Record<string, any>, to?: Record<string, any>, options?: {
+    duration?: number;
+    delay?: number;
+    autoStart?: boolean;
+    ease?: string;
+}): {
+    ref: (element: HTMLDivElement | null) => void;
+    style: react__default.CSSProperties;
+    transform: string;
+    opacity: number;
+    backgroundColor: string | undefined;
+    isAnimating: boolean;
+    start: () => void;
+    stop: () => void;
+    reset: () => void;
+};
+
+interface ViewportToggleConfig {
+    threshold?: number;
+    rootMargin?: string;
+    trigger?: "enter" | "exit" | "both";
+    once?: boolean;
+    showOnMount?: boolean;
+}
+/**
+ * IntersectionObserver를 사용해 뷰포트 진입/이탈을 감지하는 훅.
+ * (구 hua-pro의 useVisibilityToggle — animation lifecycle 기반의
+ * motion-core useVisibilityToggle과 충돌을 피해 이름을 변경함)
+ */
+declare function useViewportToggle(options?: ViewportToggleConfig): {
+    ref: react.RefObject<HTMLElement | null>;
+    isVisible: boolean;
+    mounted: boolean;
+};
+
+interface ScrollPositionToggleConfig {
+    threshold?: number;
+    showOnMount?: boolean;
+    smooth?: boolean;
+}
 /**
- * 모션 타입으로 기본 프리셋 가져오기
+ * window.pageYOffset 기준 스크롤 위치 임계값에 따라 가시성을 토글하는 훅.
+ * (구 hua-pro의 useScrollToggle — animation lifecycle 기반의
+ * motion-core useScrollToggle과 충돌을 피해 이름을 변경함)
  */
-declare function getMotionPreset(type: string): MotionPreset;
-
-type EasingFunction = (t: number) => number;
-declare const linear: EasingFunction;
-declare const easeIn: EasingFunction;
-declare const easeOut: EasingFunction;
-declare const easeInOut: EasingFunction;
-declare const easeInQuad: EasingFunction;
-declare const easeOutQuad: EasingFunction;
-declare const easeInOutQuad: EasingFunction;
-type EasingType = 'linear' | 'easeIn' | 'easeOut' | 'easeInOut' | 'easeInQuad' | 'easeOutQuad' | 'easeInOutQuad' | 'easeInCubic' | 'easeOutCubic' | 'easeInOutCubic' | 'easeInQuart' | 'easeOutQuart' | 'easeInOutQuart' | 'easeInQuint' | 'easeOutQuint' | 'easeInOutQuint' | 'easeInSine' | 'easeOutSine' | 'easeInOutSine' | 'easeInExpo' | 'easeOutExpo' | 'easeInOutExpo' | 'easeInCirc' | 'easeOutCirc' | 'easeInOutCirc' | 'easeInBounce' | 'easeOutBounce' | 'easeInOutBounce' | 'easeInBack' | 'easeOutBack' | 'easeInOutBack' | 'easeInElastic' | 'easeOutElastic' | 'easeInOutElastic' | 'pulse' | 'pulseSmooth' | 'skeletonWave' | 'blink';
-declare function isValidEasing(easingName: string): boolean;
-declare function getEasing(easingName: unknown): EasingFunction;
-declare function applyEasing(t: number, easingName: string | EasingFunction): number;
-declare function safeApplyEasing(t: number, easingName: unknown): number;
-declare function getAvailableEasings(): string[];
-declare function isEasingFunction(value: any): value is EasingFunction;
-declare const easingPresets: {
-    readonly default: "easeOut";
-    readonly smooth: "easeInOutCubic";
-    readonly fast: "easeOutQuad";
-    readonly slow: "easeInOutSine";
-    readonly bouncy: "easeOutBounce";
-    readonly elastic: "easeOutElastic";
-    readonly fade: "easeInOut";
-    readonly scale: "easeOutBack";
+declare function useScrollPositionToggle(options?: ScrollPositionToggleConfig): {
+    isVisible: boolean;
+    scrollToTop: () => void;
+    mounted: boolean;
 };
-declare function getPresetEasing(preset: keyof typeof easingPresets): EasingFunction;
 
 type MotionAs = 'div' | 'span' | 'section' | 'article' | 'header' | 'footer' | 'main' | 'nav';
 interface MotionProps extends react__default.HTMLAttributes<HTMLElement> {
@@ -1323,6 +1413,108 @@ interface MotionProps extends react__default.HTMLAttributes<HTMLElement> {
  */
 declare function Motion({ as: Component, type, effects, scroll, delay, duration, children, className, style: userStyle, ...rest }: MotionProps): react_jsx_runtime.JSX.Element;
 
+interface CountUpOptions {
+    /** 목표 숫자 */
+    end: number;
+    /** 숫자 뒤에 붙는 접미사 (%, +, 명 등) */
+    suffix?: string;
+    /** 애니메이션 지속 시간 (ms) */
+    duration?: number;
+    /** 시작 지연 시간 (ms) */
+    delay?: number;
+    /** 애니메이션 활성화 여부 (true가 되면 시작, 한 번만 실행) */
+    active?: boolean;
+}
+interface CountUpReturn {
+    /** 현재 숫자 값 */
+    value: number;
+    /** 접미사 포함 표시 문자열 */
+    display: string;
+}
+/**
+ * useCountUp — 숫자 카운트업 애니메이션
+ *
+ * 통계, 대시보드, 메트릭 수치 강조에 적합.
+ * ease-out cubic 이징으로 자연스러운 감속 효과.
+ *
+ * @example
+ * ```tsx
+ * const { display } = useCountUp({ end: 1200, suffix: '+', active: isInView })
+ * return <span>{display}</span>
+ * ```
+ */
+declare function useCountUp(options: CountUpOptions): CountUpReturn;
+
+interface ClipRevealOptions {
+    /** 시작 지연 시간 (ms) */
+    delay?: number;
+    /** 애니메이션 지속 시간 (ms) */
+    duration?: number;
+    /** CSS 이징 함수 */
+    easing?: string;
+    /** 애니메이션 활성화 여부 (true가 되면 시작, 한 번만 실행) */
+    active?: boolean;
+}
+interface ClipRevealReturn {
+    /** overflow:hidden 컨테이너에 적용할 스타일 */
+    containerStyle: CSSProperties;
+    /** 슬라이딩 텍스트에 적용할 스타일 */
+    textStyle: CSSProperties;
+    /** 등장 완료 여부 */
+    isVisible: boolean;
+}
+/**
+ * useClipReveal — overflow clip으로 텍스트가 아래→위로 등장
+ *
+ * 커버 타이틀, 히어로 헤드라인, 큰 문구에 적합.
+ * 컨테이너에 overflow:hidden을 적용하고, 내부 텍스트가 translateY로 올라옴.
+ *
+ * @example
+ * ```tsx
+ * const { containerStyle, textStyle } = useClipReveal({ delay: 200, active: isInView })
+ * return (
+ *   <span style={containerStyle}>
+ *     <span style={textStyle}>Hello World</span>
+ *   </span>
+ * )
+ * ```
+ */
+declare function useClipReveal(options?: ClipRevealOptions): ClipRevealReturn;
+
+interface BlurInOptions {
+    /** 시작 지연 시간 (ms) */
+    delay?: number;
+    /** 애니메이션 지속 시간 (ms) */
+    duration?: number;
+    /** 초기 블러 강도 (px) */
+    blurAmount?: number;
+    /** 초기 스케일 (0~1) */
+    scale?: number;
+    /** CSS 이징 함수 */
+    easing?: string;
+    /** 애니메이션 활성화 여부 (true가 되면 시작, 한 번만 실행) */
+    active?: boolean;
+}
+interface BlurInReturn {
+    /** 요소에 적용할 스타일 */
+    style: CSSProperties;
+    /** 등장 완료 여부 */
+    isVisible: boolean;
+}
+/**
+ * useBlurIn — 블러에서 선명하게 + 스케일 등장
+ *
+ * 인용구, 임팩트 문구, 핵심 메시지에 적합.
+ * blur + scale + opacity 세 가지가 동시에 전환됨.
+ *
+ * @example
+ * ```tsx
+ * const { style } = useBlurIn({ blurAmount: 12, scale: 0.95, active: isInView })
+ * return <blockquote style={style}>Deep insight here</blockquote>
+ * ```
+ */
+declare function useBlurIn(options?: BlurInOptions): BlurInReturn;
+
 interface UseStaggerOptions {
     /** 자식 아이템 개수 */
     count: number;
@@ -1363,4 +1555,4 @@ interface UseStaggerReturn {
  */
 declare function useStagger(options: UseStaggerOptions): UseStaggerReturn;
 
-export { type BaseMotionOptions, type BaseMotionReturn, type BounceOptions, type CustomCursorOptions, type CustomCursorReturn, type EasingFunction, type EasingType, type ElementProgressOptions, type ElementProgressReturn, type EntranceType, type FadeInOptions, type GestureConfig, type GestureOptions$1 as GestureOptions, type GradientOptions, type HoverMotionOptions, type InViewOptions, type InViewReturn, type InteractionReturn, MOTION_PRESETS, type MagneticCursorOptions, type MagneticCursorReturn, Motion, type MotionCallback, type MotionConfig, type MotionDirection$1 as MotionDirection, type MotionEasing, type MotionEffects, type MotionElement, MotionEngine, type MotionFrame, type Motion$1 as MotionInstance, type MotionOptions, type MotionPreset, type MotionProgressCallback, type MotionProps, type MotionState$1 as MotionState, type MotionStateCallback, type MotionTrigger, type MotionType$1 as MotionType, type MouseOptions, type MouseReturn, type OptimizationConfig, type OrchestrationConfig, PAGE_MOTIONS, type PageMotionElement, type PageMotionRef, type PageMotionsConfig, type PageType, type PerformanceMetrics, PerformanceOptimizer, type PerformanceOptimizerMetrics, type PresetConfig, type PulseOptions, type ReducedMotionReturn, type RepeatOptions, type ScaleOptions, type ScrollRevealMotionType, type ScrollRevealOptions, type SlideOptions, type SmoothScrollOptions, type SmoothScrollReturn, type SpringConfig, type SpringOptions, type ToggleMotionOptions, TransitionEffects, type TransitionOptions, type TransitionType, type TypewriterOptions, type TypewriterReturn, type UseStaggerOptions, type UseStaggerReturn, type UseUnifiedMotionOptions, type WindowSizeOptions, type WindowSizeReturn, applyEasing, easeIn, easeInOut, easeInOutQuad, easeInQuad, easeOut, easeOutQuad, easingPresets, getAvailableEasings, getEasing, getMotionPreset, getPagePreset, getPresetEasing, isEasingFunction, isValidEasing, linear, mergeWithPreset, motionEngine, performanceOptimizer, safeApplyEasing, transitionEffects, useBounceIn, useClickToggle, useCustomCursor, useElementProgress, useFadeIn, useFocusToggle, useGesture, useGestureMotion, useGradient, useHoverMotion, useInView, useMagneticCursor, useMotionState, useMouse, usePageMotions, usePulse, useReducedMotion, useRepeat, useScaleIn, useScrollProgress, useScrollReveal, useSimplePageMotion, useSlideDown, useSlideLeft, useSlideRight, useSlideUp, useSmartMotion, useSmoothScroll, useSpringMotion, useStagger, useToggleMotion, useTypewriter, useUnifiedMotion, useWindowSize };
+export { type AutoFadeConfig, type AutoMotionConfig, type AutoPlayConfig, type AutoScaleConfig, type AutoSlideConfig, BaseMotionOptions, BaseMotionReturn, type BlurInOptions, type BlurInReturn, BounceOptions, type ButtonEffectOptions, type CardListOptions, type ClipRevealOptions, type ClipRevealReturn, type CountUpOptions, type CountUpReturn, type CustomCursorOptions, type CustomCursorReturn, type ElementProgressOptions, type ElementProgressReturn, EntranceType, FadeInOptions, type GameLoopConfig, type GameState, GradientOptions, HoverMotionOptions, InViewOptions, InViewReturn, InteractionReturn, type InteractiveConfig, type InteractiveState, type KeyboardToggleConfig, type LanguageConfig, type LayoutMotionConfig, type LayoutState, type LoadingSpinnerOptions, type MagneticCursorOptions, type MagneticCursorReturn, Motion, type MotionEffects, MotionElement, type MotionFromToConfig, type MotionProps, MouseOptions, MouseReturn, type NavigationOptions, PageMotionRef, PageMotionsConfig, PageType, type PerformanceMonitorConfig, type PerformanceMonitorState, PulseOptions, ReducedMotionReturn, RepeatOptions, ScaleOptions, type ScrollDirectionConfig, type ScrollPositionToggleConfig, ScrollRevealMotionType, ScrollRevealOptions, type ScrollToggleOptions, type SequenceConfig, type SkeletonOptions, SlideOptions, type SmoothScrollOptions, type SmoothScrollReturn, SpringOptions, type StickyToggleConfig, ToggleMotionOptions, type TypewriterOptions, type TypewriterReturn, type MotionConfig as UseMotionConfig, type OrchestrationConfig as UseOrchestrationConfig, type UseStaggerOptions, type UseStaggerReturn, type UseUnifiedMotionOptions, type ViewportToggleConfig, type VisibilityToggleOptions, WindowSizeOptions, WindowSizeReturn, createLayoutTransition, observeElement, useAutoFade, useAutoPlay, useAutoScale, useAutoSlide, useBlurIn, useBounceIn, useButtonEffect, useCardList, useClickToggle, useClipReveal, useCountUp, useCustomCursor, useElementProgress, useFadeIn, useFocusToggle, useGameLoop, useGesture, useGestureMotion, useGradient, useHoverMotion, useInView, useInteractive, useKeyboardToggle, useLanguageAwareMotion, useLayoutMotion, useLoadingSpinner, useMagneticCursor, useMotion, useMotionOrchestra, useMotionState, useMouse, useNavigation, useOrchestration, usePageMotions, usePerformanceMonitor, usePulse, useReducedMotion, useRepeat, useScaleIn, useScrollDirection, useScrollPositionToggle, useScrollProgress, useScrollReveal, useScrollToggle, useSequence, useSimplePageMotion, useSkeleton, useSlideDown, useSlideLeft, useSlideRight, useSlideUp, useSmartMotion, useSmoothScroll, useSpringMotion, useStagger, useStickyToggle, useToggleMotion, useTypewriter, useUnifiedMotion, useViewportToggle, useVisibilityToggle, useWindowSize };