@digo-labs/ui 0.1.7

package/dist/components/table-of-contents.d.ts

@@ -0,0 +1,22 @@
+import { ComponentProps } from 'react';
+import { ComponentStylesProps } from '../utils/styles';
+export interface TocItemData {
+    depth: 2 | 3;
+    value: string;
+    slug: string;
+}
+export declare function useTocHeadings(pathname: string): TocItemData[];
+type Properties = RootProperties & ComponentStylesProps<'tableOfContents'>;
+export declare function TableOfContents(properties: Properties): import("react/jsx-runtime").JSX.Element;
+type RootProperties = ComponentProps<'nav'>;
+export declare function TableOfContentsHeader(properties: ComponentProps<'span'>): import("react/jsx-runtime").JSX.Element;
+export type TocOffsets = Record<2 | 3, number>;
+interface ItemsProperties {
+    items: TocItemData[];
+    activeSlugs: string[];
+    itemOffsets?: TocOffsets;
+    lineOffsets?: TocOffsets;
+    lineWidth?: number;
+}
+export declare function TableOfContentsItems(properties: ItemsProperties): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/tabs.d.ts

@@ -0,0 +1,9 @@
+import { Tabs as TabsPrimitive } from '@base-ui/react/tabs';
+import { ComponentStylesProps } from '../utils/styles';
+type Properties = RootProperties & ComponentStylesProps<'tabs'>;
+export declare function Tabs(properties: Properties): import("react/jsx-runtime").JSX.Element;
+type RootProperties = TabsPrimitive.Root.Props;
+export declare function TabsList(properties: TabsPrimitive.List.Props): import("react/jsx-runtime").JSX.Element;
+export declare function TabsTab(properties: TabsPrimitive.Tab.Props): import("react/jsx-runtime").JSX.Element;
+export declare function TabsPanel(properties: TabsPrimitive.Panel.Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/text-area.d.ts

@@ -0,0 +1,9 @@
+import { TextareaAutosizeProps } from 'react-textarea-autosize';
+import { ComponentStylesProps } from '../utils/styles';
+type RootProperties = Omit<TextareaAutosizeProps, 'size'>;
+export interface TextAreaProperties extends RootProperties, ComponentStylesProps<'textArea'> {
+    unstyled?: boolean;
+    resize?: boolean;
+}
+export declare function TextArea(properties: TextAreaProperties): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/tint-image.d.ts

@@ -0,0 +1,7 @@
+import { ComponentProps } from 'react';
+import { Image } from './image';
+import { ComponentStylesProps } from '../utils/styles';
+type Properties = RootProperties & ComponentStylesProps<'tintImage'>;
+export declare function TintImage(properties: Properties): import("react/jsx-runtime").JSX.Element;
+type RootProperties = ComponentProps<typeof Image>;
+export {};

package/dist/components/toast.d.ts

@@ -0,0 +1,9 @@
+import { Toast } from '@base-ui/react/toast';
+import { ComponentStylesProps } from '../utils/styles';
+export declare const toastManager: import('@base-ui/react').ToastManager<any>;
+type ToastPosition = 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';
+interface ProviderProperties extends Toast.Provider.Props, ComponentStylesProps<'toast'> {
+    position?: ToastPosition;
+}
+export declare function ToastProvider(properties: ProviderProperties): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/toggle-group.d.ts

@@ -0,0 +1,10 @@
+import { Toggle, Separator } from '..';
+import { ComponentProps } from 'react';
+import { ToggleGroup as ToggleGroupPrimitive } from '@base-ui/react/toggle-group';
+import { ComponentStylesProps } from '../utils/styles';
+type Properties = RootProperties & ComponentStylesProps<'toggleGroup'>;
+export declare function ToggleGroup(properties: Properties): import("react/jsx-runtime").JSX.Element;
+type RootProperties = ToggleGroupPrimitive.Props;
+export declare function ToggleGroupItem(properties: ComponentProps<typeof Toggle>): import("react/jsx-runtime").JSX.Element;
+export declare function ToggleGroupSeparator(properties: ComponentProps<typeof Separator>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/toggle.d.ts

@@ -0,0 +1,6 @@
+import { Toggle as TogglePrimitive } from '@base-ui/react/toggle';
+import { ComponentStylesProps } from '../utils/styles';
+type Properties = RootProperties & ComponentStylesProps<'toggle'>;
+export declare function Toggle(properties: Properties): import("react/jsx-runtime").JSX.Element;
+type RootProperties = TogglePrimitive.Props;
+export {};

package/dist/components/tooltip.d.ts

@@ -0,0 +1,21 @@
+import { ReactElement, ReactNode } from 'react';
+import { Tooltip as TooltipPrimitive } from '@base-ui/react/tooltip';
+import { ComponentStylesProps } from '../utils/styles';
+interface TooltipPayload extends ComponentStylesProps<'tooltip'> {
+    content: ReactNode;
+    side?: TooltipPrimitive.Positioner.Props['side'];
+    align?: TooltipPrimitive.Positioner.Props['align'];
+    sideOffset?: TooltipPrimitive.Positioner.Props['sideOffset'];
+}
+interface ProviderProperties extends ComponentStylesProps<'tooltip'> {
+    delay?: number;
+    closeDelay?: number;
+    timeout?: number;
+    children?: ReactNode;
+}
+export declare function TooltipProvider(properties: ProviderProperties): import("react/jsx-runtime").JSX.Element;
+interface TooltipProperties extends TooltipPayload {
+    children: ReactElement;
+}
+export declare function Tooltip(properties: TooltipProperties): import("react/jsx-runtime").JSX.Element | undefined;
+export {};

package/dist/cursors/cursor-bracket.d.ts

@@ -0,0 +1,11 @@
+import { CursorSpring } from '..';
+interface Properties {
+    spring?: CursorSpring;
+    size?: number;
+    offset?: number;
+    color?: string;
+    lineLength?: number;
+    borderWidth?: number;
+}
+export declare function CursorBracket(properties: Properties): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/cursors/cursor-clipping.d.ts

@@ -0,0 +1,9 @@
+import { CursorSpring } from '..';
+import { ReactNode } from 'react';
+interface Properties {
+    children: ReactNode;
+    radius?: number;
+    spring?: CursorSpring;
+}
+export declare function CursorClipping(properties: Properties): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/cursors/cursor-container.d.ts

@@ -0,0 +1,18 @@
+import { ReactNode } from 'react';
+import { MotionValue, SpringOptions } from 'motion/react';
+export type CursorSpring = SpringOptions;
+interface Properties {
+    children: ReactNode;
+    className?: string;
+    showNativeCursor?: boolean;
+}
+export declare function CursorContainer(properties: Properties): import("react/jsx-runtime").JSX.Element;
+export declare function useCursorTracking(spring?: CursorSpring): {
+    x: MotionValue<number>;
+    y: MotionValue<number>;
+    active: boolean;
+    pressed: boolean;
+    width: number;
+    height: number;
+};
+export {};

package/dist/effects/border-glow.d.ts

@@ -0,0 +1,23 @@
+import { Color } from '..';
+import { ReactNode } from 'react';
+interface BorderGlowClassNames {
+    root?: string;
+    content?: string;
+}
+interface Properties {
+    children?: ReactNode;
+    className?: string;
+    classNames?: BorderGlowClassNames;
+    edgeSensitivity?: number;
+    glowColor?: Color;
+    backgroundColor?: string;
+    borderRadius?: number;
+    glowRadius?: number;
+    glowIntensity?: number;
+    coneSpread?: number;
+    animated?: boolean;
+    colors?: Color[];
+    fillOpacity?: number;
+}
+export declare function BorderGlow(properties: Properties): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/effects/border-trail.d.ts

@@ -0,0 +1,10 @@
+import { CSSProperties } from 'react';
+import { Transition } from 'motion/react';
+export type BorderTrailProps = {
+    className?: string;
+    size?: number;
+    transition?: Transition;
+    onAnimationComplete?: () => void;
+    style?: CSSProperties;
+};
+export declare function BorderTrail(properties: BorderTrailProps): import("react/jsx-runtime").JSX.Element;

package/dist/effects/counter.d.ts

@@ -0,0 +1,14 @@
+import { CSSProperties } from 'react';
+import { SpringOptions } from 'framer-motion';
+import { ComponentStylesProps } from '../utils/styles';
+type Properties = RootProperties & ComponentStylesProps<'counter'>;
+export declare function Counter(properties: Properties): import("react/jsx-runtime").JSX.Element;
+interface RootProperties {
+    value: number;
+    places?: number;
+    className?: string;
+    style?: CSSProperties;
+    containerHeight?: number;
+    spring?: SpringOptions;
+}
+export {};

package/dist/effects/cube-scene.d.ts

@@ -0,0 +1,11 @@
+import { ReactNode } from 'react';
+type CubeFaces = [ReactNode, ReactNode, ReactNode, ReactNode, ReactNode, ReactNode];
+interface SceneProperties {
+    percentage: number;
+    children?: CubeFaces;
+    width?: number;
+    height?: number;
+    className?: string;
+}
+export declare function CubeScene(properties: SceneProperties): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/effects/dark-veil.d.ts

@@ -0,0 +1,12 @@
+interface Properties {
+    hueShift?: number;
+    noiseIntensity?: number;
+    scanlineIntensity?: number;
+    speed?: number;
+    scanlineFrequency?: number;
+    warpAmount?: number;
+    resolutionScale?: number;
+    className?: string;
+}
+export declare function DarkVeil(properties: Properties): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/effects/dissolve-overlay.d.ts

@@ -0,0 +1,15 @@
+import { Color } from '..';
+interface Properties {
+    dissolve: boolean;
+    color?: Color;
+    duration?: number;
+    easing?: string;
+    noiseScale?: number;
+    edgeSoftness?: number;
+    displacementStrength?: number;
+    noiseSpeed?: number;
+    onFinish?: () => void;
+    className?: string;
+}
+export declare function DissolveOverlay(properties: Properties): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/effects/dot-grid.d.ts

@@ -0,0 +1,19 @@
+import { CSSProperties } from 'react';
+export interface DotGridProperties {
+    dotSize?: number;
+    gap?: number;
+    baseColor?: string;
+    activeColor?: string;
+    proximity?: number;
+    speedTrigger?: number;
+    shockRadius?: number;
+    shockStrength?: number;
+    maxSpeed?: number;
+    resistance?: number;
+    returnDuration?: number;
+    className?: string;
+    style?: CSSProperties;
+    onClick?: (x: number, y: number) => void;
+    onMove?: (x: number, y: number) => void;
+}
+export declare function DotGrid(properties: DotGridProperties): import("react/jsx-runtime").JSX.Element;

package/dist/effects/draggable-container.d.ts

@@ -0,0 +1,10 @@
+import { CSSProperties, ReactNode } from 'react';
+interface Properties {
+    children: ReactNode;
+    className?: string;
+    contentClasses?: string;
+    cursor?: boolean;
+    style?: CSSProperties;
+}
+export declare function DraggableContainer(properties: Properties): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/effects/faulty-terminal.d.ts

@@ -0,0 +1,25 @@
+import { Color } from '..';
+import { default as React } from 'react';
+type Vec2 = [number, number];
+interface FaultyTerminalProperties extends React.HTMLAttributes<HTMLDivElement> {
+    scale?: number;
+    gridMul?: Vec2;
+    digitSize?: number;
+    timeScale?: number;
+    pause?: boolean;
+    scanlineIntensity?: number;
+    glitchAmount?: number;
+    flickerAmount?: number;
+    noiseAmp?: number;
+    chromaticAberration?: number;
+    dither?: number | boolean;
+    curvature?: number;
+    tint?: Color;
+    mouseReact?: boolean;
+    mouseStrength?: number;
+    dpr?: number;
+    pageLoadAnimation?: boolean;
+    brightness?: number;
+}
+export declare function FaultyTerminal(properties: FaultyTerminalProperties): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/effects/floating-lines.d.ts

@@ -0,0 +1,25 @@
+type WavePosition = {
+    x: number;
+    y: number;
+    rotate: number;
+};
+type Properties = {
+    linesGradient?: string[];
+    enabledWaves?: Array<'top' | 'middle' | 'bottom'>;
+    lineCount?: number | number[];
+    lineDistance?: number | number[];
+    topWavePosition?: WavePosition;
+    middleWavePosition?: WavePosition;
+    bottomWavePosition?: WavePosition;
+    animationSpeed?: number;
+    interactive?: boolean;
+    bendRadius?: number;
+    bendStrength?: number;
+    mouseDamping?: number;
+    parallax?: boolean;
+    parallaxStrength?: number;
+    mixBlendMode?: React.CSSProperties['mixBlendMode'];
+    className?: string;
+};
+export declare function FloatingLines(properties: Properties): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/effects/glass-container.d.ts

@@ -0,0 +1,13 @@
+import { ReactNode } from 'react';
+interface Properties {
+    borderRadiusPx?: number;
+    blurIntensity?: 'sm' | 'md' | 'lg' | 'xl';
+    glowIntensity?: 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    shadowIntensity?: 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    contentClasses?: string;
+    className?: string;
+    children: ReactNode;
+    onClick?: () => void;
+}
+export declare function GlassContainer(properties: Properties): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/effects/grainient.d.ts

@@ -0,0 +1,28 @@
+import { Color } from '..';
+interface Properties {
+    timeSpeed?: number;
+    colorBalance?: number;
+    warpStrength?: number;
+    warpFrequency?: number;
+    warpSpeed?: number;
+    warpAmplitude?: number;
+    blendAngle?: number;
+    blendSoftness?: number;
+    rotationAmount?: number;
+    noiseScale?: number;
+    grainAmount?: number;
+    grainScale?: number;
+    grainAnimated?: boolean;
+    contrast?: number;
+    gamma?: number;
+    saturation?: number;
+    centerX?: number;
+    centerY?: number;
+    zoom?: number;
+    color1?: Color;
+    color2?: Color;
+    color3?: Color;
+    className?: string;
+}
+export declare function Grainient(properties: Properties): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/effects/image-transition.d.ts

@@ -0,0 +1,24 @@
+import { CSSProperties } from 'react';
+export declare enum ImageTransitionType {
+    A = "A",
+    B = "B",
+    C = "C",
+    D = "D",
+    E = "E",
+    F = "F",
+    G = "G",
+    H = "H",
+    I = "I",
+    J = "J",
+    K = "K",
+    M = "M",
+    N = "N"
+}
+interface Properties {
+    src: string;
+    effect?: ImageTransitionType;
+    style?: CSSProperties;
+    className?: string;
+}
+export declare function ImageTransition(properties: Properties): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/effects/infinite-menu.d.ts

@@ -0,0 +1,19 @@
+export interface InfiniteMenuItem {
+    id: string;
+    imageUrl: string;
+}
+export interface InfiniteMenuOptions {
+    discSize?: number;
+    damping?: number;
+    snapStrength?: number;
+    cameraDistance?: number;
+    sphereRadius?: number;
+}
+interface Properties extends InfiniteMenuOptions {
+    items: InfiniteMenuItem[];
+    className?: string;
+    onItemSelected?: (item: InfiniteMenuItem) => void;
+    onDragChange?: (drag: boolean) => void;
+}
+export declare function InfiniteMenu(properties: Properties): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/effects/iridescence.d.ts

@@ -0,0 +1,12 @@
+import { CSSProperties } from 'react';
+interface Properties {
+    color?: [number, number, number];
+    speed?: number;
+    opacity?: number;
+    amplitude?: number;
+    mouseReact?: boolean;
+    className?: string;
+    style?: CSSProperties;
+}
+export declare function Iridescence(properties: Properties): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/effects/letter-swap.d.ts

@@ -0,0 +1,8 @@
+type AnimationDirection = 'topToBottom' | 'bottomToTop' | 'rightToLeft' | 'leftToRight';
+interface LetterSwapProperties {
+    letter: string;
+    className?: string;
+    direction?: AnimationDirection;
+}
+export declare function LetterSwap(properties: LetterSwapProperties): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/effects/marquee-bar.d.ts

@@ -0,0 +1,6 @@
+interface MarqueeBarProperties {
+    direction?: 'left' | 'right' | 'up' | 'down';
+    className?: string;
+}
+export declare function MarqueeBar(properties: MarqueeBarProperties): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/effects/marquee.d.ts

@@ -0,0 +1,26 @@
+import { CSSProperties, ReactNode, RefObject } from 'react';
+import { SpringOptions } from 'motion/react';
+interface SimpleMarqueeProperties {
+    children: ReactNode;
+    className?: string;
+    direction?: 'left' | 'right' | 'up' | 'down';
+    baseVelocity?: number;
+    easing?: (value: number) => number;
+    slowdownOnHover?: boolean;
+    slowDownFactor?: number;
+    slowDownSpringConfig?: SpringOptions;
+    useScrollVelocity?: boolean;
+    scrollAwareDirection?: boolean;
+    scrollSpringConfig?: SpringOptions;
+    scrollContainer?: RefObject<HTMLElement> | HTMLElement | null;
+    repeat?: number;
+    draggable?: boolean;
+    dragSensitivity?: number;
+    dragVelocityDecay?: number;
+    dragAwareDirection?: boolean;
+    dragAngle?: number;
+    grabCursor?: boolean;
+    style?: CSSProperties;
+}
+export declare function Marquee(properites: SimpleMarqueeProperties): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/effects/noise.d.ts

@@ -0,0 +1,10 @@
+interface NoiseProperties {
+    patternSize?: number;
+    patternScaleX?: number;
+    patternScaleY?: number;
+    patternRefreshInterval?: number;
+    patternAlpha?: number;
+    className?: string;
+}
+export declare function Noise(properties: NoiseProperties): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/effects/orb.d.ts

@@ -0,0 +1,15 @@
+import { CSSProperties } from 'react';
+type ColorRGB = [number, number, number];
+interface Properties {
+    hue?: number;
+    className?: string;
+    innerRadius?: number;
+    noiseScale?: number;
+    rotationSpeed?: number;
+    color1?: ColorRGB;
+    color2?: ColorRGB;
+    color3?: ColorRGB;
+    style?: CSSProperties;
+}
+export declare function Orb(properties: Properties): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/effects/text-morph.d.ts

@@ -0,0 +1,14 @@
+import { Transition, Variants } from 'motion/react';
+import { CSSProperties } from 'react';
+export interface TextMorphProperties {
+    children: string;
+    className?: string;
+    style?: CSSProperties;
+    variants?: Variants;
+    transition?: Transition;
+    damping?: number;
+    stiffness?: number;
+    mass?: number;
+    onFinish?: () => void;
+}
+export declare function TextMorph(properties: TextMorphProperties): import("react/jsx-runtime").JSX.Element;

package/dist/effects/text-pressure.d.ts

@@ -0,0 +1,13 @@
+interface TextPressureProps {
+    text?: string;
+    width?: boolean;
+    weight?: boolean;
+    italic?: boolean;
+    alpha?: boolean;
+    flex?: boolean;
+    scale?: boolean;
+    className?: string;
+    minFontSize?: number;
+}
+export declare function TextPressure(properties: TextPressureProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/effects/text-roll.d.ts

@@ -0,0 +1,22 @@
+import { VariantLabels, Target, TargetAndTransition, Transition } from 'motion/react';
+interface Properties {
+    children: string;
+    duration?: number;
+    getEnterDelay?: (index: number) => number;
+    getExitDelay?: (index: number) => number;
+    className?: string;
+    transition?: Transition;
+    variants?: {
+        enter: {
+            initial: Target | VariantLabels | boolean;
+            animate: TargetAndTransition | VariantLabels;
+        };
+        exit: {
+            initial: Target | VariantLabels | boolean;
+            animate: TargetAndTransition | VariantLabels;
+        };
+    };
+    onAnimationComplete?: () => void;
+}
+export declare function TextRoll(properties: Properties): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/effects/text-scramble.d.ts

@@ -0,0 +1,16 @@
+import { CSSProperties } from 'react';
+import { MotionProps } from 'motion/react';
+interface Properties extends MotionProps {
+    children: string;
+    duration?: number;
+    delay?: number;
+    characterSet?: 'default' | 'binary';
+    as?: React.ElementType;
+    className?: string;
+    style?: CSSProperties;
+    trigger?: boolean;
+    triggerOnMouse?: boolean;
+    onScrambleComplete?: () => void;
+}
+export declare function TextScramble(properties: Properties): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/effects/text-shimmer-wave.d.ts

@@ -0,0 +1,16 @@
+import { Transition } from 'motion/react';
+interface Properties {
+    children: string;
+    as?: React.ElementType;
+    className?: string;
+    duration?: number;
+    zDistance?: number;
+    xDistance?: number;
+    yDistance?: number;
+    spread?: number;
+    scaleDistance?: number;
+    rotateYDistance?: number;
+    transition?: Transition;
+}
+export declare function TextShimmerWave(properties: Properties): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/effects/text-shimmer.d.ts

@@ -0,0 +1,13 @@
+import { ElementType } from 'react';
+import { ComponentStylesProps } from '../utils/styles';
+type Properties = RootProperties & ComponentStylesProps<'textShimmer'>;
+export declare function TextShimmer(properties: Properties): import("react/jsx-runtime").JSX.Element;
+interface RootProperties {
+    children: string;
+    as?: ElementType;
+    className?: string;
+    duration?: number;
+    spread?: number;
+    highlightColor?: string;
+}
+export {};

package/dist/effects/text-swap-letter.d.ts

@@ -0,0 +1,6 @@
+interface TextSwapLetterProperties {
+    word: string;
+    className?: string;
+}
+export declare function TextSwapLetter(properties: TextSwapLetterProperties): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/effects/text-type.d.ts

@@ -0,0 +1,27 @@
+import { ElementType, HTMLAttributes, ReactNode } from 'react';
+interface Properties extends HTMLAttributes<HTMLElement> {
+    className?: string;
+    showCursor?: boolean;
+    hideCursorWhileTyping?: boolean;
+    hideCursorOnComplete?: boolean;
+    cursorCharacter?: '|' | '█' | '▮' | '▌' | '_' | ReactNode;
+    cursorBlinkDuration?: number;
+    cursorClassName?: string;
+    text: string | string[];
+    as?: ElementType;
+    typingSpeed?: number;
+    initialDelay?: number;
+    pauseDuration?: number;
+    deletingSpeed?: number;
+    loop?: boolean;
+    textColors?: string[];
+    variableSpeed?: {
+        min: number;
+        max: number;
+    };
+    onSentenceComplete?: (sentence: string, index: number) => void;
+    startOnVisible?: boolean;
+    reverseMode?: boolean;
+}
+export declare function TextType(properties: Properties): import('react').ReactElement<any, string | import('react').JSXElementConstructor<any>>;
+export {};

package/dist/hooks/use-animated-value.d.ts

@@ -0,0 +1 @@
+export declare function useAnimatedValue(duration: number): [number, () => void];

package/dist/hooks/use-element-size.d.ts

@@ -0,0 +1,5 @@
+export declare function useElementSize<T extends HTMLElement>(): {
+    width: number;
+    height: number;
+    ref: import('react').RefObject<T | null>;
+};