aliveicon 1.0.30 → 1.0.32

package/dist/types/icons/r/Replace-All.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+interface ReplaceAllHandle {
+    startAnimation: () => void;
+    stopAnimation: () => void;
+}
+interface ReplaceAllProps extends React.HTMLAttributes<HTMLDivElement> {
+    size?: number;
+    className?: string;
+    style?: React.CSSProperties;
+    autoAnimateOnLoad?: boolean;
+    hoverable?: boolean;
+    loopOnHover?: boolean;
+    animateOnClick?: boolean;
+}
+declare const ReplaceAll: React.ForwardRefExoticComponent<ReplaceAllProps & React.RefAttributes<ReplaceAllHandle>>;
+export { ReplaceAll };

package/dist/types/icons/r/Replace.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+interface ReplaceHandle {
+    startAnimation: () => void;
+    stopAnimation: () => void;
+}
+interface ReplaceProps extends React.HTMLAttributes<HTMLDivElement> {
+    size?: number;
+    className?: string;
+    style?: React.CSSProperties;
+    autoAnimateOnLoad?: boolean;
+    hoverable?: boolean;
+    loopOnHover?: boolean;
+    animateOnClick?: boolean;
+}
+declare const Replace: React.ForwardRefExoticComponent<ReplaceProps & React.RefAttributes<ReplaceHandle>>;
+export { Replace };

package/dist/types/icons/r/Reply-All.d.ts

@@ -0,0 +1,15 @@
+interface ReplyAllHandle {
+    startAnimation: () => void;
+    stopAnimation: () => void;
+}
+interface ReplyAllProps extends React.HTMLAttributes<HTMLDivElement> {
+    size?: number;
+    className?: string;
+    style?: React.CSSProperties;
+    autoAnimateOnLoad?: boolean;
+    hoverable?: boolean;
+    loopOnHover?: boolean;
+    animateOnClick?: boolean;
+}
+declare const ReplyAll: import("react").ForwardRefExoticComponent<ReplyAllProps & import("react").RefAttributes<ReplyAllHandle>>;
+export { ReplyAll };

package/dist/types/icons/r/Reply.d.ts

@@ -0,0 +1,15 @@
+interface ReplyHandle {
+    startAnimation: () => void;
+    stopAnimation: () => void;
+}
+interface ReplyProps extends React.HTMLAttributes<HTMLDivElement> {
+    size?: number;
+    className?: string;
+    style?: React.CSSProperties;
+    autoAnimateOnLoad?: boolean;
+    hoverable?: boolean;
+    loopOnHover?: boolean;
+    animateOnClick?: boolean;
+}
+declare const Reply: import("react").ForwardRefExoticComponent<ReplyProps & import("react").RefAttributes<ReplyHandle>>;
+export { Reply };

package/dist/types/icons/r/Rewind.d.ts

@@ -0,0 +1,15 @@
+interface RewindHandle {
+    startAnimation: () => void;
+    stopAnimation: () => void;
+}
+interface RewindProps extends React.HTMLAttributes<HTMLDivElement> {
+    size?: number;
+    className?: string;
+    style?: React.CSSProperties;
+    autoAnimateOnLoad?: boolean;
+    hoverable?: boolean;
+    loopOnHover?: boolean;
+    animateOnClick?: boolean;
+}
+declare const Rewind: import("react").ForwardRefExoticComponent<RewindProps & import("react").RefAttributes<RewindHandle>>;
+export { Rewind };

package/dist/types/icons/r/Ribbon.d.ts

@@ -0,0 +1,15 @@
+interface RibbonHandle {
+    startAnimation: () => void;
+    stopAnimation: () => void;
+}
+interface RibbonProps extends React.HTMLAttributes<HTMLDivElement> {
+    size?: number;
+    className?: string;
+    style?: React.CSSProperties;
+    autoAnimateOnLoad?: boolean;
+    hoverable?: boolean;
+    loopOnHover?: boolean;
+    animateOnClick?: boolean;
+}
+declare const Ribbon: import("react").ForwardRefExoticComponent<RibbonProps & import("react").RefAttributes<RibbonHandle>>;
+export { Ribbon };

package/dist/types/icons/r/Rocket.d.ts

@@ -0,0 +1,16 @@
+import { type HTMLAttributes } from 'react';
+export interface RocketHandle {
+    startAnimation: () => void;
+    stopAnimation: () => void;
+}
+interface RocketProps extends HTMLAttributes<HTMLDivElement> {
+    size?: number;
+    className?: string;
+    style?: React.CSSProperties;
+    autoAnimateOnLoad?: boolean;
+    hoverable?: boolean;
+    loopOnHover?: boolean;
+    animateOnClick?: boolean;
+}
+declare const Rocket: import("react").ForwardRefExoticComponent<RocketProps & import("react").RefAttributes<RocketHandle>>;
+export { Rocket };

package/dist/types/icons/r/Roller-Coaster.d.ts

@@ -0,0 +1,14 @@
+import { type HTMLAttributes } from 'react';
+interface RollerCoasterHandle {
+    startAnimation: () => void;
+    stopAnimation: () => void;
+}
+interface RollerCoasterProps extends HTMLAttributes<HTMLDivElement> {
+    size?: number;
+    autoAnimateOnLoad?: boolean;
+    hoverable?: boolean;
+    loopOnHover?: boolean;
+    animateOnClick?: boolean;
+}
+declare const RollerCoaster: import("react").ForwardRefExoticComponent<RollerCoasterProps & import("react").RefAttributes<RollerCoasterHandle>>;
+export { RollerCoaster };

package/dist/types/icons/r/Rolling-Chair.d.ts

@@ -0,0 +1,14 @@
+import { type HTMLAttributes } from 'react';
+interface RockingChairHandle {
+    startAnimation: () => void;
+    stopAnimation: () => void;
+}
+interface RockingChairProps extends HTMLAttributes<HTMLDivElement> {
+    size?: number;
+    autoAnimateOnLoad?: boolean;
+    hoverable?: boolean;
+    loopOnHover?: boolean;
+    animateOnClick?: boolean;
+}
+declare const RockingChair: import("react").ForwardRefExoticComponent<RockingChairProps & import("react").RefAttributes<RockingChairHandle>>;
+export { RockingChair };

package/dist/types/icons/r/Rotate-3D.d.ts

@@ -0,0 +1,14 @@
+import { type HTMLAttributes } from 'react';
+interface Rotate3dHandle {
+    startAnimation: () => void;
+    stopAnimation: () => void;
+}
+interface Rotate3dProps extends HTMLAttributes<HTMLDivElement> {
+    size?: number;
+    autoAnimateOnLoad?: boolean;
+    hoverable?: boolean;
+    loopOnHover?: boolean;
+    animateOnClick?: boolean;
+}
+declare const Rotate3d: import("react").ForwardRefExoticComponent<Rotate3dProps & import("react").RefAttributes<Rotate3dHandle>>;
+export { Rotate3d };

package/dist/types/icons/r/Rotate-ccw.d.ts

@@ -0,0 +1,15 @@
+import { type HTMLMotionProps } from 'framer-motion';
+import React from 'react';
+interface RotateCcwHandle {
+    startAnimation: () => void;
+    stopAnimation: () => void;
+}
+interface RotateCcwProps extends HTMLMotionProps<'div'> {
+    size?: number;
+    autoAnimateOnLoad?: boolean;
+    hoverable?: boolean;
+    loopOnHover?: boolean;
+    animateOnClick?: boolean;
+}
+declare const RotateCcw: React.ForwardRefExoticComponent<Omit<RotateCcwProps, "ref"> & React.RefAttributes<RotateCcwHandle>>;
+export { RotateCcw };

package/dist/types/icons/u/USB.d.ts

@@ -0,0 +1,15 @@
+interface USBHandle {
+    startAnimation: () => void;
+    stopAnimation: () => void;
+}
+interface USBProps extends React.HTMLAttributes<HTMLDivElement> {
+    size?: number;
+    className?: string;
+    style?: React.CSSProperties;
+    autoAnimateOnLoad?: boolean;
+    hoverable?: boolean;
+    loopOnHover?: boolean;
+    animateOnClick?: boolean;
+}
+declare const USB: import("react").ForwardRefExoticComponent<USBProps & import("react").RefAttributes<USBHandle>>;
+export { USB };

package/dist/types/icons/u/Umbrella-Off.d.ts

@@ -0,0 +1,15 @@
+interface UmbrellaOffHandle {
+    startAnimation: () => void;
+    stopAnimation: () => void;
+}
+interface UmbrellaOffProps extends React.HTMLAttributes<HTMLDivElement> {
+    size?: number;
+    className?: string;
+    style?: React.CSSProperties;
+    autoAnimateOnLoad?: boolean;
+    hoverable?: boolean;
+    loopOnHover?: boolean;
+    animateOnClick?: boolean;
+}
+declare const UmbrellaOff: import("react").ForwardRefExoticComponent<UmbrellaOffProps & import("react").RefAttributes<UmbrellaOffHandle>>;
+export { UmbrellaOff };

package/dist/types/icons/u/Umbrella.d.ts

@@ -0,0 +1,15 @@
+interface UmbrellaHandle {
+    startAnimation: () => void;
+    stopAnimation: () => void;
+}
+interface UmbrellaProps extends React.HTMLAttributes<HTMLDivElement> {
+    size?: number;
+    className?: string;
+    style?: React.CSSProperties;
+    autoAnimateOnLoad?: boolean;
+    hoverable?: boolean;
+    loopOnHover?: boolean;
+    animateOnClick?: boolean;
+}
+declare const Umbrella: import("react").ForwardRefExoticComponent<UmbrellaProps & import("react").RefAttributes<UmbrellaHandle>>;
+export { Umbrella };

package/dist/types/icons/u/Underline.d.ts

@@ -0,0 +1,15 @@
+interface UnderlineHandle {
+    startAnimation: () => void;
+    stopAnimation: () => void;
+}
+interface UnderlineProps extends React.HTMLAttributes<HTMLDivElement> {
+    size?: number;
+    className?: string;
+    style?: React.CSSProperties;
+    autoAnimateOnLoad?: boolean;
+    hoverable?: boolean;
+    loopOnHover?: boolean;
+    animateOnClick?: boolean;
+}
+declare const Underline: import("react").ForwardRefExoticComponent<UnderlineProps & import("react").RefAttributes<UnderlineHandle>>;
+export { Underline };

package/dist/types/icons/u/Undo-2.d.ts

@@ -0,0 +1,15 @@
+interface Undo2Handle {
+    startAnimation: () => void;
+    stopAnimation: () => void;
+}
+interface Undo2Props extends React.HTMLAttributes<HTMLDivElement> {
+    size?: number;
+    className?: string;
+    style?: React.CSSProperties;
+    autoAnimateOnLoad?: boolean;
+    hoverable?: boolean;
+    loopOnHover?: boolean;
+    animateOnClick?: boolean;
+}
+declare const Undo2: import("react").ForwardRefExoticComponent<Undo2Props & import("react").RefAttributes<Undo2Handle>>;
+export { Undo2 };

package/dist/types/icons/u/Undo-Dot.d.ts

@@ -0,0 +1,15 @@
+interface UndoDotHandle {
+    startAnimation: () => void;
+    stopAnimation: () => void;
+}
+interface UndoDotProps extends React.HTMLAttributes<HTMLDivElement> {
+    size?: number;
+    className?: string;
+    style?: React.CSSProperties;
+    autoAnimateOnLoad?: boolean;
+    hoverable?: boolean;
+    loopOnHover?: boolean;
+    animateOnClick?: boolean;
+}
+declare const UndoDot: import("react").ForwardRefExoticComponent<UndoDotProps & import("react").RefAttributes<UndoDotHandle>>;
+export { UndoDot };

package/dist/types/icons/u/Undo.d.ts

@@ -0,0 +1,15 @@
+interface UndoHandle {
+    startAnimation: () => void;
+    stopAnimation: () => void;
+}
+interface UndoProps extends React.HTMLAttributes<HTMLDivElement> {
+    size?: number;
+    className?: string;
+    style?: React.CSSProperties;
+    autoAnimateOnLoad?: boolean;
+    hoverable?: boolean;
+    loopOnHover?: boolean;
+    animateOnClick?: boolean;
+}
+declare const Undo: import("react").ForwardRefExoticComponent<UndoProps & import("react").RefAttributes<UndoHandle>>;
+export { Undo };

package/dist/types/icons/u/Unfold-Horizontal.d.ts

@@ -0,0 +1,15 @@
+interface UnfoldHorizontalHandle {
+    startAnimation: () => void;
+    stopAnimation: () => void;
+}
+interface UnfoldHorizontalProps extends React.HTMLAttributes<HTMLDivElement> {
+    size?: number;
+    className?: string;
+    style?: React.CSSProperties;
+    autoAnimateOnLoad?: boolean;
+    hoverable?: boolean;
+    loopOnHover?: boolean;
+    animateOnClick?: boolean;
+}
+declare const UnfoldHorizontal: import("react").ForwardRefExoticComponent<UnfoldHorizontalProps & import("react").RefAttributes<UnfoldHorizontalHandle>>;
+export { UnfoldHorizontal };

package/dist/types/icons/u/Unfold-Verticle.d.ts

@@ -0,0 +1,15 @@
+interface UnfoldVerticalHandle {
+    startAnimation: () => void;
+    stopAnimation: () => void;
+}
+interface UnfoldVerticalProps extends React.HTMLAttributes<HTMLDivElement> {
+    size?: number;
+    className?: string;
+    style?: React.CSSProperties;
+    autoAnimateOnLoad?: boolean;
+    hoverable?: boolean;
+    loopOnHover?: boolean;
+    animateOnClick?: boolean;
+}
+declare const UnfoldVertical: import("react").ForwardRefExoticComponent<UnfoldVerticalProps & import("react").RefAttributes<UnfoldVerticalHandle>>;
+export { UnfoldVertical };

package/dist/types/icons/u/Ungroup.d.ts

@@ -0,0 +1,15 @@
+interface UngroupHandle {
+    startAnimation: () => void;
+    stopAnimation: () => void;
+}
+interface UngroupProps extends React.HTMLAttributes<HTMLDivElement> {
+    size?: number;
+    className?: string;
+    style?: React.CSSProperties;
+    autoAnimateOnLoad?: boolean;
+    hoverable?: boolean;
+    loopOnHover?: boolean;
+    animateOnClick?: boolean;
+}
+declare const Ungroup: import("react").ForwardRefExoticComponent<UngroupProps & import("react").RefAttributes<UngroupHandle>>;
+export { Ungroup };

package/dist/types/icons/u/University.d.ts

@@ -0,0 +1,15 @@
+export interface UniversityHandle {
+    startAnimation: () => void;
+    stopAnimation: () => void;
+}
+export interface UniversityProps extends React.HTMLAttributes<HTMLDivElement> {
+    size?: number;
+    className?: string;
+    style?: React.CSSProperties;
+    autoAnimateOnLoad?: boolean;
+    hoverable?: boolean;
+    loopOnHover?: boolean;
+    animateOnClick?: boolean;
+}
+declare const University: import("react").ForwardRefExoticComponent<UniversityProps & import("react").RefAttributes<UniversityHandle>>;
+export { University };

package/dist/types/icons/u/Unlink-2.d.ts

@@ -0,0 +1,15 @@
+interface Unlink2Handle {
+    startAnimation: () => void;
+    stopAnimation: () => void;
+}
+interface Unlink2Props extends React.HTMLAttributes<HTMLDivElement> {
+    size?: number;
+    className?: string;
+    style?: React.CSSProperties;
+    autoAnimateOnLoad?: boolean;
+    hoverable?: boolean;
+    loopOnHover?: boolean;
+    animateOnClick?: boolean;
+}
+declare const Unlink2: import("react").ForwardRefExoticComponent<Unlink2Props & import("react").RefAttributes<Unlink2Handle>>;
+export { Unlink2 };

package/dist/types/icons/u/Unlink.d.ts

@@ -0,0 +1,15 @@
+interface UnlinkHandle {
+    startAnimation: () => void;
+    stopAnimation: () => void;
+}
+interface UnlinkProps extends React.HTMLAttributes<HTMLDivElement> {
+    size?: number;
+    className?: string;
+    style?: React.CSSProperties;
+    autoAnimateOnLoad?: boolean;
+    hoverable?: boolean;
+    loopOnHover?: boolean;
+    animateOnClick?: boolean;
+}
+declare const Unlink: import("react").ForwardRefExoticComponent<UnlinkProps & import("react").RefAttributes<UnlinkHandle>>;
+export { Unlink };

package/dist/types/icons/u/Upload.d.ts

@@ -0,0 +1,15 @@
+interface UploadHandle {
+    startAnimation: () => void;
+    stopAnimation: () => void;
+}
+interface UploadProps extends React.HTMLAttributes<HTMLDivElement> {
+    size?: number;
+    className?: string;
+    style?: React.CSSProperties;
+    autoAnimateOnLoad?: boolean;
+    hoverable?: boolean;
+    loopOnHover?: boolean;
+    animateOnClick?: boolean;
+}
+declare const Upload: import("react").ForwardRefExoticComponent<UploadProps & import("react").RefAttributes<UploadHandle>>;
+export { Upload };

package/dist/types/icons/u/User-Check.d.ts

@@ -0,0 +1,15 @@
+interface UserCheckHandle {
+    startAnimation: () => void;
+    stopAnimation: () => void;
+}
+interface UserCheckProps extends React.HTMLAttributes<HTMLDivElement> {
+    size?: number;
+    className?: string;
+    style?: React.CSSProperties;
+    autoAnimateOnLoad?: boolean;
+    hoverable?: boolean;
+    loopOnHover?: boolean;
+    animateOnClick?: boolean;
+}
+declare const UserCheck: import("react").ForwardRefExoticComponent<UserCheckProps & import("react").RefAttributes<UserCheckHandle>>;
+export { UserCheck };

package/dist/types/icons/u/User-Cog.d.ts

@@ -0,0 +1,15 @@
+interface UserCogHandle {
+    startAnimation: () => void;
+    stopAnimation: () => void;
+}
+interface UserCogProps extends React.HTMLAttributes<HTMLDivElement> {
+    size?: number;
+    className?: string;
+    style?: React.CSSProperties;
+    autoAnimateOnLoad?: boolean;
+    hoverable?: boolean;
+    loopOnHover?: boolean;
+    animateOnClick?: boolean;
+}
+declare const UserCog: import("react").ForwardRefExoticComponent<UserCogProps & import("react").RefAttributes<UserCogHandle>>;
+export { UserCog };

package/dist/types/icons/u/User-Lock.d.ts

@@ -0,0 +1,15 @@
+interface UserLockHandle {
+    startAnimation: () => void;
+    stopAnimation: () => void;
+}
+interface UserLockProps extends React.HTMLAttributes<HTMLDivElement> {
+    size?: number;
+    className?: string;
+    style?: React.CSSProperties;
+    autoAnimateOnLoad?: boolean;
+    hoverable?: boolean;
+    loopOnHover?: boolean;
+    animateOnClick?: boolean;
+}
+declare const UserLock: import("react").ForwardRefExoticComponent<UserLockProps & import("react").RefAttributes<UserLockHandle>>;
+export { UserLock };

package/dist/types/icons/u/User-Minus.d.ts

@@ -0,0 +1,15 @@
+interface UserMinusHandle {
+    startAnimation: () => void;
+    stopAnimation: () => void;
+}
+interface UserMinusProps extends React.HTMLAttributes<HTMLDivElement> {
+    size?: number;
+    className?: string;
+    style?: React.CSSProperties;
+    autoAnimateOnLoad?: boolean;
+    hoverable?: boolean;
+    loopOnHover?: boolean;
+    animateOnClick?: boolean;
+}
+declare const UserMinus: import("react").ForwardRefExoticComponent<UserMinusProps & import("react").RefAttributes<UserMinusHandle>>;
+export { UserMinus };

package/dist/types/icons/u/User-Pen.d.ts

@@ -0,0 +1,15 @@
+interface UserPenHandle {
+    startAnimation: () => void;
+    stopAnimation: () => void;
+}
+interface UserPenProps extends React.HTMLAttributes<HTMLDivElement> {
+    size?: number;
+    className?: string;
+    style?: React.CSSProperties;
+    autoAnimateOnLoad?: boolean;
+    hoverable?: boolean;
+    loopOnHover?: boolean;
+    animateOnClick?: boolean;
+}
+declare const UserPen: import("react").ForwardRefExoticComponent<UserPenProps & import("react").RefAttributes<UserPenHandle>>;
+export { UserPen };

package/dist/types/icons/u/User-Plus.d.ts

@@ -0,0 +1,15 @@
+interface UserPlusHandle {
+    startAnimation: () => void;
+    stopAnimation: () => void;
+}
+interface UserPlusProps extends React.HTMLAttributes<HTMLDivElement> {
+    size?: number;
+    className?: string;
+    style?: React.CSSProperties;
+    autoAnimateOnLoad?: boolean;
+    hoverable?: boolean;
+    loopOnHover?: boolean;
+    animateOnClick?: boolean;
+}
+declare const UserPlus: import("react").ForwardRefExoticComponent<UserPlusProps & import("react").RefAttributes<UserPlusHandle>>;
+export { UserPlus };

package/dist/types/icons/u/User-Round-Check.d.ts

@@ -0,0 +1,15 @@
+interface UserRoundCheckHandle {
+    startAnimation: () => void;
+    stopAnimation: () => void;
+}
+interface UserRoundCheckProps extends React.HTMLAttributes<HTMLDivElement> {
+    size?: number;
+    className?: string;
+    style?: React.CSSProperties;
+    autoAnimateOnLoad?: boolean;
+    hoverable?: boolean;
+    loopOnHover?: boolean;
+    animateOnClick?: boolean;
+}
+declare const UserRoundCheck: import("react").ForwardRefExoticComponent<UserRoundCheckProps & import("react").RefAttributes<UserRoundCheckHandle>>;
+export { UserRoundCheck };

package/dist/types/icons/u/User-Round-Cog.d.ts

@@ -0,0 +1,15 @@
+interface UserRoundCogHandle {
+    startAnimation: () => void;
+    stopAnimation: () => void;
+}
+interface UserRoundCogProps extends React.HTMLAttributes<HTMLDivElement> {
+    size?: number;
+    className?: string;
+    style?: React.CSSProperties;
+    autoAnimateOnLoad?: boolean;
+    hoverable?: boolean;
+    loopOnHover?: boolean;
+    animateOnClick?: boolean;
+}
+declare const UserRoundCog: import("react").ForwardRefExoticComponent<UserRoundCogProps & import("react").RefAttributes<UserRoundCogHandle>>;
+export { UserRoundCog };

package/dist/types/icons/u/User-Round-Minus.d.ts

@@ -0,0 +1,15 @@
+interface UserRoundMinusHandle {
+    startAnimation: () => void;
+    stopAnimation: () => void;
+}
+interface UserRoundMinusProps extends React.HTMLAttributes<HTMLDivElement> {
+    size?: number;
+    className?: string;
+    style?: React.CSSProperties;
+    autoAnimateOnLoad?: boolean;
+    hoverable?: boolean;
+    loopOnHover?: boolean;
+    animateOnClick?: boolean;
+}
+declare const UserRoundMinus: import("react").ForwardRefExoticComponent<UserRoundMinusProps & import("react").RefAttributes<UserRoundMinusHandle>>;
+export { UserRoundMinus };

package/dist/types/icons/u/User-Round-Pen.d.ts

@@ -0,0 +1,15 @@
+interface UserRoundPenHandle {
+    startAnimation: () => void;
+    stopAnimation: () => void;
+}
+interface UserRoundPenProps extends React.HTMLAttributes<HTMLDivElement> {
+    size?: number;
+    className?: string;
+    style?: React.CSSProperties;
+    autoAnimateOnLoad?: boolean;
+    hoverable?: boolean;
+    loopOnHover?: boolean;
+    animateOnClick?: boolean;
+}
+declare const UserRoundPen: import("react").ForwardRefExoticComponent<UserRoundPenProps & import("react").RefAttributes<UserRoundPenHandle>>;
+export { UserRoundPen };

package/dist/types/icons/u/User-Round-Plus.d.ts

@@ -0,0 +1,15 @@
+interface UserRoundPlusHandle {
+    startAnimation: () => void;
+    stopAnimation: () => void;
+}
+interface UserRoundPlusProps extends React.HTMLAttributes<HTMLDivElement> {
+    size?: number;
+    className?: string;
+    style?: React.CSSProperties;
+    autoAnimateOnLoad?: boolean;
+    hoverable?: boolean;
+    loopOnHover?: boolean;
+    animateOnClick?: boolean;
+}
+declare const UserRoundPlus: import("react").ForwardRefExoticComponent<UserRoundPlusProps & import("react").RefAttributes<UserRoundPlusHandle>>;
+export { UserRoundPlus };

package/dist/types/icons/u/User-Round-Search.d.ts

@@ -0,0 +1,15 @@
+interface UserRoundSearchHandle {
+    startAnimation: () => void;
+    stopAnimation: () => void;
+}
+interface UserRoundSearchProps extends React.HTMLAttributes<HTMLDivElement> {
+    size?: number;
+    className?: string;
+    style?: React.CSSProperties;
+    autoAnimateOnLoad?: boolean;
+    hoverable?: boolean;
+    loopOnHover?: boolean;
+    animateOnClick?: boolean;
+}
+declare const UserRoundSearch: import("react").ForwardRefExoticComponent<UserRoundSearchProps & import("react").RefAttributes<UserRoundSearchHandle>>;
+export { UserRoundSearch };

package/dist/types/icons/u/User-Round-X.d.ts

@@ -0,0 +1,15 @@
+interface UserRoundXHandle {
+    startAnimation: () => void;
+    stopAnimation: () => void;
+}
+interface UserRoundXProps extends React.HTMLAttributes<HTMLDivElement> {
+    size?: number;
+    className?: string;
+    style?: React.CSSProperties;
+    autoAnimateOnLoad?: boolean;
+    hoverable?: boolean;
+    loopOnHover?: boolean;
+    animateOnClick?: boolean;
+}
+declare const UserRoundX: import("react").ForwardRefExoticComponent<UserRoundXProps & import("react").RefAttributes<UserRoundXHandle>>;
+export { UserRoundX };

package/dist/types/icons/u/User-Round.d.ts

@@ -0,0 +1,15 @@
+interface UserRoundHandle {
+    startAnimation: () => void;
+    stopAnimation: () => void;
+}
+interface UserRoundProps extends React.HTMLAttributes<HTMLDivElement> {
+    size?: number;
+    className?: string;
+    style?: React.CSSProperties;
+    autoAnimateOnLoad?: boolean;
+    hoverable?: boolean;
+    loopOnHover?: boolean;
+    animateOnClick?: boolean;
+}
+declare const UserRound: import("react").ForwardRefExoticComponent<UserRoundProps & import("react").RefAttributes<UserRoundHandle>>;
+export { UserRound };