@hua-labs/motion-core 2.3.0 → 2.4.1

package/dist/index.d.mts

@@ -1,494 +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, d as EntranceMotionReturn, S as SlideOptions, e as ScaleOptions, f as BounceOptions, g as PulseOptions, h as SpringOptions, G as GradientOptions, H as HoverMotionOptions, i as ScrollRevealOptions, R as RepeatOptions, T as ToggleMotionOptions, I as InteractionReturn, j as InViewOptions, k as InViewReturn, l as MouseOptions, m as MouseReturn, n as ReducedMotionReturn, W as WindowSizeOptions, o as WindowSizeReturn, p as ScrollRevealMotionType } from './springPhysics-BZVRi9PQ.mjs';
+export { A as AutoMotionReturn, q as BuiltInProfileName, D as DeepPartial, r as EasingFunction, s as EasingType, t as GestureConfig, u as GestureOptions, v as MOTION_PRESETS, w as MotionCallback, x as MotionConfig, y as MotionDirection, z as MotionEasing, C as MotionEngine, J as MotionFrame, K as MotionInstance, L as MotionOptions, N as MotionPreset, O as MotionProfile, Q as MotionProfileBase, U as MotionProfileEntrance, V as MotionProfileInteraction, X as MotionProfileProvider, Y as MotionProfileProviderProps, Z as MotionProfileSpring, _ as MotionProfileStagger, $ as MotionProgressCallback, a0 as MotionState, a1 as MotionStateCallback, a2 as MotionTrigger, a3 as MotionType, a4 as ObserverReturn, a5 as OrchestrationConfig, a6 as PAGE_MOTIONS, a7 as PageMotionElement, a8 as PerformanceMetrics, a9 as PresetConfig, aa as ReducedMotionStrategy, ab as SequenceOrchestrationConfig, ac as SpringConfig, ad as SpringPhysicsConfig, ae as SpringResult, af as StyleMotionReturn, ag as ToggleMotionReturn, ah as TransitionEffects, ai as TransitionOptions, aj as TransitionType, ak as applyEasing, al as calculateSpring, am as easeIn, an as easeInOut, ao as easeInOutQuad, ap as easeInQuad, aq as easeOut, ar as easeOutQuad, as as easingPresets, at as getAvailableEasings, au as getEasing, av as getMotionPreset, aw as getPagePreset, ax as getPresetEasing, ay as hua, az as isEasingFunction, aA as isValidEasing, aB as linear, aC as mergeProfileOverrides, aD as mergeWithPreset, aE as motionEngine, aF as neutral, aG as resolveProfile, aH as safeApplyEasing, aI as transitionEffects, aJ as useMotionProfile } from './springPhysics-BZVRi9PQ.mjs';
 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;
-    /**
-     * 공통 전환 실행 헬퍼
-     */
-    private executeTransition;
-    /**
-     * 페이드 인/아웃 전환
-     */
-    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;
-
-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$1 {
-    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: 프리셋 기반 페이지 모션 (기존 방식)
  *
@@ -584,9 +99,9 @@ interface UseUnifiedMotionOptions extends Omit<BaseMotionOptions, 'autoStart'> {
 }
 declare function useUnifiedMotion<T extends MotionElement = HTMLDivElement>(options: UseUnifiedMotionOptions): BaseMotionReturn<T>;
 
-declare function useFadeIn<T extends MotionElement = HTMLDivElement>(options?: FadeInOptions): BaseMotionReturn<T>;
+declare function useFadeIn<T extends MotionElement = HTMLDivElement>(options?: FadeInOptions): EntranceMotionReturn<T>;
 
-declare function useSlideUp<T extends MotionElement = HTMLDivElement>(options?: SlideOptions): BaseMotionReturn<T>;
+declare function useSlideUp<T extends MotionElement = HTMLDivElement>(options?: SlideOptions): EntranceMotionReturn<T>;
 
 /**
  * useSlideLeft - 오른쪽에서 왼쪽으로 슬라이드하며 나타나는 애니메이션 훅
@@ -605,7 +120,7 @@ declare function useSlideUp<T extends MotionElement = HTMLDivElement>(options?:
  * );
  * ```
  */
-declare function useSlideLeft<T extends MotionElement = HTMLDivElement>(options?: Omit<SlideOptions, 'direction'>): BaseMotionReturn<T>;
+declare function useSlideLeft<T extends MotionElement = HTMLDivElement>(options?: Omit<SlideOptions, "direction">): EntranceMotionReturn<T>;
 
 /**
  * useSlideRight - 왼쪽에서 오른쪽으로 슬라이드하며 나타나는 애니메이션 훅
@@ -624,11 +139,11 @@ declare function useSlideLeft<T extends MotionElement = HTMLDivElement>(options?
  * );
  * ```
  */
-declare function useSlideRight<T extends MotionElement = HTMLDivElement>(options?: Omit<SlideOptions, 'direction'>): BaseMotionReturn<T>;
+declare function useSlideRight<T extends MotionElement = HTMLDivElement>(options?: Omit<SlideOptions, "direction">): EntranceMotionReturn<T>;
 
-declare function useScaleIn<T extends MotionElement = HTMLDivElement>(options?: ScaleOptions): BaseMotionReturn<T>;
+declare function useScaleIn<T extends MotionElement = HTMLDivElement>(options?: ScaleOptions): EntranceMotionReturn<T>;
 
-declare function useBounceIn<T extends MotionElement = HTMLDivElement>(options?: BounceOptions): BaseMotionReturn<T>;
+declare function useBounceIn<T extends MotionElement = HTMLDivElement>(options?: BounceOptions): EntranceMotionReturn<T>;
 
 declare function usePulse<T extends MotionElement = HTMLDivElement>(options?: PulseOptions): BaseMotionReturn<T>;
 
@@ -772,7 +287,7 @@ declare function useToggleMotion<T extends MotionElement = HTMLDivElement>(optio
  * );
  * ```
  */
-declare function useSlideDown<T extends MotionElement = HTMLDivElement>(options?: Omit<SlideOptions, 'direction'>): BaseMotionReturn<T>;
+declare function useSlideDown<T extends MotionElement = HTMLDivElement>(options?: Omit<SlideOptions, "direction">): EntranceMotionReturn<T>;
 
 /**
  * useInView - 요소의 뷰포트 가시성 감지 훅
@@ -833,9 +348,11 @@ declare function useMouse(options?: MouseOptions): MouseReturn;
  * Detects user's prefers-reduced-motion setting.
  * Used to reduce or disable motion for accessibility.
  *
+ * @returns {boolean} 모션 감소 선호 여부 / Whether reduced motion is preferred
+ *
  * @example
  * ```tsx
- * const { prefersReducedMotion } = useReducedMotion()
+ * const prefersReducedMotion = useReducedMotion()
  *
  * return (
  *   <motion.div
@@ -847,7 +364,19 @@ declare function useMouse(options?: MouseOptions): MouseReturn;
  * )
  * ```
  */
-declare function useReducedMotion(): ReducedMotionReturn;
+declare function useReducedMotion(): boolean;
+/**
+ * useReducedMotionObject - 객체 형태 반환 (backwards compat)
+ * Returns `{ prefersReducedMotion: boolean }` for backwards compatibility.
+ *
+ * @deprecated Use `useReducedMotion()` which returns `boolean` directly.
+ *
+ * @example
+ * ```tsx
+ * const { prefersReducedMotion } = useReducedMotionObject()
+ * ```
+ */
+declare function useReducedMotionObject(): ReducedMotionReturn;
 
 /**
  * useWindowSize - 윈도우 크기 추적 훅
@@ -1318,150 +847,6 @@ 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>;
-/**
- * 프리셋과 커스텀 설정을 병합
- */
-declare function mergeWithPreset(preset: MotionPreset, custom?: Partial<MotionPreset>): MotionPreset;
-/**
- * 페이지 타입으로 프리셋 가져오기
- */
-declare function getPagePreset(pageType: PageType): PageMotionsConfig;
-/**
- * 모션 타입으로 기본 프리셋 가져오기
- */
-declare function getMotionPreset(type: string): MotionPreset;
-
-/** 프로필 전체의 기본 모션 디폴트 */
-interface MotionProfileBase {
-    /** 기본 duration (ms) */
-    duration: number;
-    /** 기본 easing (CSS 또는 named preset) */
-    easing: string;
-    /** IntersectionObserver 임계값 */
-    threshold: number;
-    /** 한 번만 트리거할지 여부 */
-    triggerOnce: boolean;
-}
-/** 입장 애니메이션 디폴트 */
-interface MotionProfileEntrance {
-    slide: {
-        /** 슬라이드 거리 (px) */
-        distance: number;
-        /** 슬라이드 전용 이징 */
-        easing: string;
-    };
-    fade: {
-        /** 초기 투명도 */
-        initialOpacity: number;
-    };
-    scale: {
-        /** 초기 스케일 (useScrollReveal/useStagger용, 0.95 등 미세 변화) */
-        from: number;
-    };
-    bounce: {
-        /** 바운스 강도 */
-        intensity: number;
-        /** 바운스 전용 이징 */
-        easing: string;
-    };
-}
-/** 스태거 디폴트 */
-interface MotionProfileStagger {
-    /** 아이템 간 딜레이 (ms) */
-    perItem: number;
-    /** 첫 아이템 전 딜레이 (ms) */
-    baseDelay: number;
-}
-/** 인터랙션 디폴트 */
-interface MotionProfileInteraction {
-    hover: {
-        /** 호버 시 스케일 */
-        scale: number;
-        /** 호버 시 Y 오프셋 (px) */
-        y: number;
-        /** 호버 duration (ms) */
-        duration: number;
-        /** 호버 이징 */
-        easing: string;
-    };
-}
-/** 스프링 물리 디폴트 */
-interface MotionProfileSpring {
-    /** 질량 */
-    mass: number;
-    /** 강성 */
-    stiffness: number;
-    /** 감쇠 */
-    damping: number;
-    /** 정지 임계값 */
-    restDelta: number;
-    /** 정지 속도 */
-    restSpeed: number;
-}
-/** reduced motion 전략 */
-type ReducedMotionStrategy = 'skip' | 'fade-only' | 'minimal';
-/** 전체 Motion Profile */
-interface MotionProfile {
-    /** 프로필 이름 */
-    name: string;
-    /** 공통 디폴트 */
-    base: MotionProfileBase;
-    /** 입장 애니메이션 */
-    entrance: MotionProfileEntrance;
-    /** 스태거 */
-    stagger: MotionProfileStagger;
-    /** 인터랙션 */
-    interaction: MotionProfileInteraction;
-    /** 스프링 물리 */
-    spring: MotionProfileSpring;
-    /** reduced motion 전략 */
-    reducedMotion: ReducedMotionStrategy;
-}
-/** 내장 프로필 이름 */
-type BuiltInProfileName = 'neutral' | 'hua';
-/** DeepPartial 유틸리티 */
-type DeepPartial<T> = {
-    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
-};
-
-/**
- * neutral 프로필 — 기존 하드코딩 디폴트와 동일.
- * Provider 없을 때 fallback으로 사용되므로 하위 호환 100% 보장.
- */
-declare const neutral: MotionProfile;
-
-/**
- * HUA 프로필 — 스르륵 쫀뜩한 브랜드 시그니처.
- *
- * 특징:
- * - CSS ease-out 기반이되 끝에 미세한 오버슈트 (1.04~1.06)
- * - 도착점을 살짝 지나쳤다가 돌아오는 탄성
- * - 바운스 없이 쫀뜩 (높은 감쇠 + 높은 강성)
- * - neutral보다 짧은 duration, 좁은 distance → 더 정교한 느낌
- */
-declare const hua: MotionProfile;
-
-interface MotionProfileProviderProps {
-    /** 내장 프로필 이름 또는 커스텀 프로필 객체 */
-    profile?: BuiltInProfileName | MotionProfile;
-    /** 선택한 프로필 위에 부분 오버라이드 */
-    overrides?: DeepPartial<MotionProfile>;
-    children: React.ReactNode;
-}
-declare function MotionProfileProvider({ profile, overrides, children, }: MotionProfileProviderProps): react.FunctionComponentElement<react.ProviderProps<MotionProfile>>;
-/**
- * 현재 프로필을 가져옴.
- * Provider 밖에서 호출 시 neutral 프로필 반환 (하위 호환).
- */
-declare function useMotionProfile(): MotionProfile;
-
-/** 이름 또는 객체에서 프로필 resolve */
-declare function resolveProfile(profile: BuiltInProfileName | MotionProfile): MotionProfile;
-/** 프로필에 오버라이드를 깊은 병합 */
-declare function mergeProfileOverrides(base: MotionProfile, overrides: DeepPartial<MotionProfile>): MotionProfile;
-
 /**
  * Shared IntersectionObserver Pool
  *
@@ -1499,57 +884,522 @@ declare function observeElement(element: Element, callback: EntryCallback, optio
     rootMargin?: string;
 }, once?: boolean): () => void;
 
-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";
+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;
+
+/** The subset of BaseMotionReturn that useSequence actually consumes. */
+type SequenceMotionResult = Pick<BaseMotionReturn<MotionElement>, "start" | "stop" | "reset" | "ref"> & {
+    pause?: () => void;
+    resume?: () => void;
+};
+interface SequenceConfig {
+    autoStart?: boolean;
+    loop?: boolean;
+}
+/** @deprecated Use useOrchestration or useMotionOrchestra instead. */
+interface SequenceItem {
+    hook: () => SequenceMotionResult;
+    delay?: number;
+}
+/** @deprecated Use useOrchestration or useMotionOrchestra instead. */
+declare function useSequence(sequence: SequenceItem[], options?: SequenceConfig): {
+    start: () => void;
+    stop: () => void;
+    pause: () => void;
+    resume: () => void;
+    reset: () => void;
+    isPlaying: boolean;
+    currentIndex: number;
+    totalMotions: number;
+    ref: react.RefObject<MotionElement | null>;
+};
+
+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;
 };
-declare function getPresetEasing(preset: keyof typeof easingPresets): EasingFunction;
 
+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;
+}
 /**
- * Spring physics calculation (Hooke's Law + damping)
- *
- * Pure function — no side effects, fully testable.
+ * IntersectionObserver를 사용해 뷰포트 진입/이탈을 감지하는 훅.
+ * (구 hua-pro의 useVisibilityToggle — animation lifecycle 기반의
+ * motion-core useVisibilityToggle과 충돌을 피해 이름을 변경함)
  */
-interface SpringConfig {
-    stiffness: number;
-    damping: number;
-    mass: number;
-}
-interface SpringResult {
-    value: number;
-    velocity: number;
+declare function useViewportToggle(options?: ViewportToggleConfig): {
+    ref: react.RefObject<HTMLElement | null>;
+    isVisible: boolean;
+    mounted: boolean;
+};
+
+interface ScrollPositionToggleConfig {
+    threshold?: number;
+    showOnMount?: boolean;
+    smooth?: boolean;
 }
 /**
- * Calculate one step of a damped spring simulation.
- *
- * @param currentValue   Current position
- * @param currentVelocity Current velocity
- * @param targetValue    Equilibrium (target) position
- * @param deltaTime      Time step in seconds
- * @param config         Spring parameters (stiffness, damping, mass)
+ * window.pageYOffset 기준 스크롤 위치 임계값에 따라 가시성을 토글하는 훅.
+ * (구 hua-pro의 useScrollToggle — animation lifecycle 기반의
+ * motion-core useScrollToggle과 충돌을 피해 이름을 변경함)
  */
-declare function calculateSpring(currentValue: number, currentVelocity: number, targetValue: number, deltaTime: number, config: SpringConfig): SpringResult;
+declare function useScrollPositionToggle(options?: ScrollPositionToggleConfig): {
+    isVisible: boolean;
+    scrollToTop: () => void;
+    mounted: boolean;
+};
 
 type MotionAs = 'div' | 'span' | 'section' | 'article' | 'header' | 'footer' | 'main' | 'nav';
 interface MotionProps extends react__default.HTMLAttributes<HTMLElement> {
@@ -1584,6 +1434,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;
@@ -1624,4 +1576,4 @@ interface UseStaggerReturn {
  */
 declare function useStagger(options: UseStaggerOptions): UseStaggerReturn;
 
-export { type BaseMotionOptions, type BaseMotionReturn, type BounceOptions, type BuiltInProfileName, type ButtonEffectOptions, type CardListOptions, type CustomCursorOptions, type CustomCursorReturn, type DeepPartial, 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, type LoadingSpinnerOptions, 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 MotionProfile, type MotionProfileBase, type MotionProfileEntrance, type MotionProfileInteraction, MotionProfileProvider, type MotionProfileProviderProps, type MotionProfileSpring, type MotionProfileStagger, type MotionProgressCallback, type MotionProps, type MotionState$1 as MotionState, type MotionStateCallback, type MotionTrigger, type MotionType$1 as MotionType, type MouseOptions, type MouseReturn, type NavigationOptions, type OrchestrationConfig, PAGE_MOTIONS, type PageMotionElement, type PageMotionRef, type PageMotionsConfig, type PageType, type PerformanceMetrics, type PresetConfig, type PulseOptions, type ReducedMotionReturn, type ReducedMotionStrategy, type RepeatOptions, type ScaleOptions, type ScrollRevealMotionType, type ScrollRevealOptions, type ScrollToggleOptions, type SkeletonOptions, type SlideOptions, type SmoothScrollOptions, type SmoothScrollReturn, type SpringConfig$1 as SpringConfig, type SpringOptions, type SpringConfig as SpringPhysicsConfig, type SpringResult, type ToggleMotionOptions, TransitionEffects, type TransitionOptions, type TransitionType, type TypewriterOptions, type TypewriterReturn, type UseStaggerOptions, type UseStaggerReturn, type UseUnifiedMotionOptions, type VisibilityToggleOptions, type WindowSizeOptions, type WindowSizeReturn, applyEasing, calculateSpring, easeIn, easeInOut, easeInOutQuad, easeInQuad, easeOut, easeOutQuad, easingPresets, getAvailableEasings, getEasing, getMotionPreset, getPagePreset, getPresetEasing, hua, isEasingFunction, isValidEasing, linear, mergeProfileOverrides, mergeWithPreset, motionEngine, neutral, observeElement, resolveProfile, safeApplyEasing, transitionEffects, useBounceIn, useButtonEffect, useCardList, useClickToggle, useCustomCursor, useElementProgress, useFadeIn, useFocusToggle, useGesture, useGestureMotion, useGradient, useHoverMotion, useInView, useLoadingSpinner, useMagneticCursor, useMotionProfile, useMotionState, useMouse, useNavigation, usePageMotions, usePulse, useReducedMotion, useRepeat, useScaleIn, useScrollProgress, useScrollReveal, useScrollToggle, useSimplePageMotion, useSkeleton, useSlideDown, useSlideLeft, useSlideRight, useSlideUp, useSmartMotion, useSmoothScroll, useSpringMotion, useStagger, useToggleMotion, useTypewriter, useUnifiedMotion, useVisibilityToggle, 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, EntranceMotionReturn, 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, useReducedMotionObject, 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 };