aliveicon 1.0.28 → 1.0.30

package/dist/types/icons/c/Chevrons-Down-Up.d.ts

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

package/dist/types/icons/c/Chevrons-Down.d.ts

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

package/dist/types/icons/c/Chevrons-Left-Right-Ellipse.d.ts

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

package/dist/types/icons/c/Chevrons-Left-Right.d.ts

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

package/dist/types/icons/c/Chevrons-Left.d.ts

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

package/dist/types/icons/c/Chevrons-Right-Left.d.ts

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

package/dist/types/icons/c/Chevrons-Right.d.ts

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

package/dist/types/icons/c/Chevrons-Up-Down.d.ts

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

package/dist/types/icons/c/Chevrons-Up.d.ts

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

package/dist/types/icons/c/Chrome.d.ts

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

package/dist/types/icons/c/Chruch.d.ts

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

package/dist/types/icons/c/Cigarette-Off.d.ts

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

package/dist/types/icons/c/Cigarette.d.ts

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

package/dist/types/icons/c/Circle-Alert.d.ts

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

package/dist/types/icons/c/Circle-Arrow-Down.d.ts

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

package/dist/types/icons/c/Circle-Arrow-Left.d.ts

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

package/dist/types/icons/c/Circle-Arrow-Right.d.ts

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

package/dist/types/icons/c/Circle-Arrow-Up.d.ts

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

package/dist/types/icons/c/Circle-Check-Big.d.ts

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

package/dist/types/icons/c/Circle-Check.d.ts

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

package/dist/types/icons/c/Circle-Chevron-Down.d.ts

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

package/dist/types/icons/c/Circle-Chevron-Left.d.ts

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

package/dist/types/icons/c/Circle-Chevron-Right.d.ts

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

package/dist/types/icons/c/Circle-Chevron-Up.d.ts

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

package/dist/types/icons/c/Circle-Dashed-2.d.ts

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

package/dist/types/icons/c/Circle-Dashed.d.ts

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

package/dist/types/icons/c/Circle-Devide.d.ts

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

package/dist/types/icons/c/Circle-Doller-Sign.d.ts

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

package/dist/types/icons/c/Circle-Dot-Dashed.d.ts

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

package/dist/types/icons/c/Circle-Dot.d.ts

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

package/dist/types/icons/c/Circle-Ellipse.d.ts

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

package/dist/types/icons/c/Circle-Equal.d.ts

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

package/dist/types/icons/c/Circle-Fading-Arrow-Up.d.ts

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

package/dist/types/icons/c/Circle-Fading-Plus.d.ts

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

package/dist/types/icons/c/Circle-Gauge.d.ts

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

package/dist/types/icons/c/Circle-Help.d.ts

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

package/dist/types/icons/c/Circle-Minus.d.ts

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

package/dist/types/icons/c/Circle-Off.d.ts

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

package/dist/types/icons/c/Circle-Parking-Off.d.ts

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