@mp-front/components 0.0.1-next-0

package/dist/components/input/number/useInputNumber.d.ts

@@ -0,0 +1,382 @@
+import { InputNumberProps } from './number.types';
+export declare const useInputNumber: (props: InputNumberProps) => {
+    step?: number;
+    size?: import('../..').Size;
+    icon?: React.ReactNode;
+    leftIcon?: React.ReactNode;
+    error?: boolean;
+    check?: boolean;
+    clear?: boolean;
+    variant?: "default" | "underline";
+    value?: string | number | readonly string[];
+    className?: string;
+    color?: string;
+    ref?: import('react').Ref<HTMLInputElement>;
+    values?: {
+        [key: string]: import('motion-dom').MotionValue<number> | import('motion-dom').MotionValue<string>;
+    };
+    children?: React.ReactNode | import('motion-dom').MotionValue<number> | import('motion-dom').MotionValue<string>;
+    form?: string;
+    slot?: string;
+    style?: import('framer-motion').MotionStyle;
+    title?: string;
+    animate?: import('motion-dom').TargetAndTransition | import('motion-dom').VariantLabels | boolean | import('motion-dom').LegacyAnimationControls;
+    pattern?: string;
+    key?: import('react').Key;
+    defaultChecked?: boolean;
+    defaultValue?: string | number | readonly string[];
+    suppressContentEditableWarning?: boolean;
+    suppressHydrationWarning?: boolean;
+    accessKey?: string;
+    autoCapitalize?: "off" | "none" | "on" | "sentences" | "words" | "characters" | (string & {});
+    autoFocus?: boolean;
+    contentEditable?: (boolean | "true" | "false") | "inherit" | "plaintext-only";
+    contextMenu?: string;
+    dir?: string;
+    draggable?: boolean | "true" | "false";
+    enterKeyHint?: "search" | "enter" | "done" | "go" | "next" | "previous" | "send";
+    hidden?: boolean;
+    id?: string;
+    lang?: string;
+    nonce?: string;
+    spellCheck?: boolean | "true" | "false";
+    tabIndex?: number;
+    translate?: "yes" | "no";
+    radioGroup?: string;
+    role?: import('react').AriaRole;
+    about?: string;
+    content?: string;
+    datatype?: string;
+    inlist?: any;
+    property?: string;
+    rel?: string;
+    resource?: string;
+    rev?: string;
+    typeof?: string;
+    vocab?: string;
+    autoCorrect?: string;
+    autoSave?: string;
+    itemProp?: string;
+    itemScope?: boolean;
+    itemType?: string;
+    itemID?: string;
+    itemRef?: string;
+    results?: number;
+    security?: string;
+    unselectable?: "off" | "on";
+    popover?: "" | "auto" | "manual";
+    popoverTargetAction?: "toggle" | "show" | "hide";
+    popoverTarget?: string;
+    inert?: boolean;
+    inputMode?: "text" | "search" | "none" | "tel" | "url" | "email" | "numeric" | "decimal";
+    is?: string;
+    "aria-activedescendant"?: string;
+    "aria-atomic"?: boolean | "true" | "false";
+    "aria-autocomplete"?: "none" | "list" | "inline" | "both";
+    "aria-braillelabel"?: string;
+    "aria-brailleroledescription"?: string;
+    "aria-busy"?: boolean | "true" | "false";
+    "aria-checked"?: boolean | "true" | "false" | "mixed";
+    "aria-colcount"?: number;
+    "aria-colindex"?: number;
+    "aria-colindextext"?: string;
+    "aria-colspan"?: number;
+    "aria-controls"?: string;
+    "aria-current"?: boolean | "true" | "false" | "time" | "page" | "step" | "location" | "date";
+    "aria-describedby"?: string;
+    "aria-description"?: string;
+    "aria-details"?: string;
+    "aria-disabled"?: boolean | "true" | "false";
+    "aria-dropeffect"?: "link" | "none" | "copy" | "execute" | "move" | "popup";
+    "aria-errormessage"?: string;
+    "aria-expanded"?: boolean | "true" | "false";
+    "aria-flowto"?: string;
+    "aria-grabbed"?: boolean | "true" | "false";
+    "aria-haspopup"?: boolean | "true" | "false" | "dialog" | "menu" | "grid" | "listbox" | "tree";
+    "aria-hidden"?: boolean | "true" | "false";
+    "aria-invalid"?: boolean | "true" | "false" | "grammar" | "spelling";
+    "aria-keyshortcuts"?: string;
+    "aria-label"?: string;
+    "aria-labelledby"?: string;
+    "aria-level"?: number;
+    "aria-live"?: "off" | "assertive" | "polite";
+    "aria-modal"?: boolean | "true" | "false";
+    "aria-multiline"?: boolean | "true" | "false";
+    "aria-multiselectable"?: boolean | "true" | "false";
+    "aria-orientation"?: "vertical" | "horizontal";
+    "aria-owns"?: string;
+    "aria-placeholder"?: string;
+    "aria-posinset"?: number;
+    "aria-pressed"?: boolean | "true" | "false" | "mixed";
+    "aria-readonly"?: boolean | "true" | "false";
+    "aria-relevant"?: "text" | "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text additions" | "text removals";
+    "aria-required"?: boolean | "true" | "false";
+    "aria-roledescription"?: string;
+    "aria-rowcount"?: number;
+    "aria-rowindex"?: number;
+    "aria-rowindextext"?: string;
+    "aria-rowspan"?: number;
+    "aria-selected"?: boolean | "true" | "false";
+    "aria-setsize"?: number;
+    "aria-sort"?: "none" | "ascending" | "descending" | "other";
+    "aria-valuemax"?: number;
+    "aria-valuemin"?: number;
+    "aria-valuenow"?: number;
+    "aria-valuetext"?: string;
+    dangerouslySetInnerHTML?: {
+        __html: string | TrustedHTML;
+    };
+    onCopy?: import('react').ClipboardEventHandler<HTMLInputElement>;
+    onCopyCapture?: import('react').ClipboardEventHandler<HTMLInputElement>;
+    onCut?: import('react').ClipboardEventHandler<HTMLInputElement>;
+    onCutCapture?: import('react').ClipboardEventHandler<HTMLInputElement>;
+    onPaste?: import('react').ClipboardEventHandler<HTMLInputElement>;
+    onPasteCapture?: import('react').ClipboardEventHandler<HTMLInputElement>;
+    onCompositionEnd?: import('react').CompositionEventHandler<HTMLInputElement>;
+    onCompositionEndCapture?: import('react').CompositionEventHandler<HTMLInputElement>;
+    onCompositionStart?: import('react').CompositionEventHandler<HTMLInputElement>;
+    onCompositionStartCapture?: import('react').CompositionEventHandler<HTMLInputElement>;
+    onCompositionUpdate?: import('react').CompositionEventHandler<HTMLInputElement>;
+    onCompositionUpdateCapture?: import('react').CompositionEventHandler<HTMLInputElement>;
+    onFocus?: import('react').FocusEventHandler<HTMLInputElement>;
+    onFocusCapture?: import('react').FocusEventHandler<HTMLInputElement>;
+    onBlur?: import('react').FocusEventHandler<HTMLInputElement>;
+    onBlurCapture?: import('react').FocusEventHandler<HTMLInputElement>;
+    onChangeCapture?: import('react').FormEventHandler<HTMLInputElement>;
+    onBeforeInput?: import('react').FormEventHandler<HTMLInputElement>;
+    onBeforeInputCapture?: import('react').FormEventHandler<HTMLInputElement>;
+    onInput?: import('react').FormEventHandler<HTMLInputElement>;
+    onInputCapture?: import('react').FormEventHandler<HTMLInputElement>;
+    onReset?: import('react').FormEventHandler<HTMLInputElement>;
+    onResetCapture?: import('react').FormEventHandler<HTMLInputElement>;
+    onSubmit?: import('react').FormEventHandler<HTMLInputElement>;
+    onSubmitCapture?: import('react').FormEventHandler<HTMLInputElement>;
+    onInvalid?: import('react').FormEventHandler<HTMLInputElement>;
+    onInvalidCapture?: import('react').FormEventHandler<HTMLInputElement>;
+    onLoad?: import('react').ReactEventHandler<HTMLInputElement>;
+    onLoadCapture?: import('react').ReactEventHandler<HTMLInputElement>;
+    onError?: import('react').ReactEventHandler<HTMLInputElement>;
+    onErrorCapture?: import('react').ReactEventHandler<HTMLInputElement>;
+    onKeyDown?: import('react').KeyboardEventHandler<HTMLInputElement>;
+    onKeyDownCapture?: import('react').KeyboardEventHandler<HTMLInputElement>;
+    onKeyPress?: import('react').KeyboardEventHandler<HTMLInputElement>;
+    onKeyPressCapture?: import('react').KeyboardEventHandler<HTMLInputElement>;
+    onKeyUp?: import('react').KeyboardEventHandler<HTMLInputElement>;
+    onKeyUpCapture?: import('react').KeyboardEventHandler<HTMLInputElement>;
+    onAbort?: import('react').ReactEventHandler<HTMLInputElement>;
+    onAbortCapture?: import('react').ReactEventHandler<HTMLInputElement>;
+    onCanPlay?: import('react').ReactEventHandler<HTMLInputElement>;
+    onCanPlayCapture?: import('react').ReactEventHandler<HTMLInputElement>;
+    onCanPlayThrough?: import('react').ReactEventHandler<HTMLInputElement>;
+    onCanPlayThroughCapture?: import('react').ReactEventHandler<HTMLInputElement>;
+    onDurationChange?: import('react').ReactEventHandler<HTMLInputElement>;
+    onDurationChangeCapture?: import('react').ReactEventHandler<HTMLInputElement>;
+    onEmptied?: import('react').ReactEventHandler<HTMLInputElement>;
+    onEmptiedCapture?: import('react').ReactEventHandler<HTMLInputElement>;
+    onEncrypted?: import('react').ReactEventHandler<HTMLInputElement>;
+    onEncryptedCapture?: import('react').ReactEventHandler<HTMLInputElement>;
+    onEnded?: import('react').ReactEventHandler<HTMLInputElement>;
+    onEndedCapture?: import('react').ReactEventHandler<HTMLInputElement>;
+    onLoadedData?: import('react').ReactEventHandler<HTMLInputElement>;
+    onLoadedDataCapture?: import('react').ReactEventHandler<HTMLInputElement>;
+    onLoadedMetadata?: import('react').ReactEventHandler<HTMLInputElement>;
+    onLoadedMetadataCapture?: import('react').ReactEventHandler<HTMLInputElement>;
+    onLoadStart?: import('react').ReactEventHandler<HTMLInputElement>;
+    onLoadStartCapture?: import('react').ReactEventHandler<HTMLInputElement>;
+    onPause?: import('react').ReactEventHandler<HTMLInputElement>;
+    onPauseCapture?: import('react').ReactEventHandler<HTMLInputElement>;
+    onPlay?: import('react').ReactEventHandler<HTMLInputElement>;
+    onPlayCapture?: import('react').ReactEventHandler<HTMLInputElement>;
+    onPlaying?: import('react').ReactEventHandler<HTMLInputElement>;
+    onPlayingCapture?: import('react').ReactEventHandler<HTMLInputElement>;
+    onProgress?: import('react').ReactEventHandler<HTMLInputElement>;
+    onProgressCapture?: import('react').ReactEventHandler<HTMLInputElement>;
+    onRateChange?: import('react').ReactEventHandler<HTMLInputElement>;
+    onRateChangeCapture?: import('react').ReactEventHandler<HTMLInputElement>;
+    onResize?: import('react').ReactEventHandler<HTMLInputElement>;
+    onResizeCapture?: import('react').ReactEventHandler<HTMLInputElement>;
+    onSeeked?: import('react').ReactEventHandler<HTMLInputElement>;
+    onSeekedCapture?: import('react').ReactEventHandler<HTMLInputElement>;
+    onSeeking?: import('react').ReactEventHandler<HTMLInputElement>;
+    onSeekingCapture?: import('react').ReactEventHandler<HTMLInputElement>;
+    onStalled?: import('react').ReactEventHandler<HTMLInputElement>;
+    onStalledCapture?: import('react').ReactEventHandler<HTMLInputElement>;
+    onSuspend?: import('react').ReactEventHandler<HTMLInputElement>;
+    onSuspendCapture?: import('react').ReactEventHandler<HTMLInputElement>;
+    onTimeUpdate?: import('react').ReactEventHandler<HTMLInputElement>;
+    onTimeUpdateCapture?: import('react').ReactEventHandler<HTMLInputElement>;
+    onVolumeChange?: import('react').ReactEventHandler<HTMLInputElement>;
+    onVolumeChangeCapture?: import('react').ReactEventHandler<HTMLInputElement>;
+    onWaiting?: import('react').ReactEventHandler<HTMLInputElement>;
+    onWaitingCapture?: import('react').ReactEventHandler<HTMLInputElement>;
+    onAuxClick?: import('react').MouseEventHandler<HTMLInputElement>;
+    onAuxClickCapture?: import('react').MouseEventHandler<HTMLInputElement>;
+    onClick?: import('react').MouseEventHandler<HTMLInputElement>;
+    onClickCapture?: import('react').MouseEventHandler<HTMLInputElement>;
+    onContextMenu?: import('react').MouseEventHandler<HTMLInputElement>;
+    onContextMenuCapture?: import('react').MouseEventHandler<HTMLInputElement>;
+    onDoubleClick?: import('react').MouseEventHandler<HTMLInputElement>;
+    onDoubleClickCapture?: import('react').MouseEventHandler<HTMLInputElement>;
+    onDrag?: (event: MouseEvent | TouchEvent | PointerEvent, info: import('motion-dom').PanInfo) => void;
+    onDragCapture?: import('react').DragEventHandler<HTMLInputElement>;
+    onDragEnd?: (event: MouseEvent | TouchEvent | PointerEvent, info: import('motion-dom').PanInfo) => void;
+    onDragEndCapture?: import('react').DragEventHandler<HTMLInputElement>;
+    onDragEnter?: import('react').DragEventHandler<HTMLInputElement>;
+    onDragEnterCapture?: import('react').DragEventHandler<HTMLInputElement>;
+    onDragExit?: import('react').DragEventHandler<HTMLInputElement>;
+    onDragExitCapture?: import('react').DragEventHandler<HTMLInputElement>;
+    onDragLeave?: import('react').DragEventHandler<HTMLInputElement>;
+    onDragLeaveCapture?: import('react').DragEventHandler<HTMLInputElement>;
+    onDragOver?: import('react').DragEventHandler<HTMLInputElement>;
+    onDragOverCapture?: import('react').DragEventHandler<HTMLInputElement>;
+    onDragStart?: (event: MouseEvent | TouchEvent | PointerEvent, info: import('motion-dom').PanInfo) => void;
+    onDragStartCapture?: import('react').DragEventHandler<HTMLInputElement>;
+    onDrop?: import('react').DragEventHandler<HTMLInputElement>;
+    onDropCapture?: import('react').DragEventHandler<HTMLInputElement>;
+    onMouseDown?: import('react').MouseEventHandler<HTMLInputElement>;
+    onMouseDownCapture?: import('react').MouseEventHandler<HTMLInputElement>;
+    onMouseEnter?: import('react').MouseEventHandler<HTMLInputElement>;
+    onMouseLeave?: import('react').MouseEventHandler<HTMLInputElement>;
+    onMouseMove?: import('react').MouseEventHandler<HTMLInputElement>;
+    onMouseMoveCapture?: import('react').MouseEventHandler<HTMLInputElement>;
+    onMouseOut?: import('react').MouseEventHandler<HTMLInputElement>;
+    onMouseOutCapture?: import('react').MouseEventHandler<HTMLInputElement>;
+    onMouseOver?: import('react').MouseEventHandler<HTMLInputElement>;
+    onMouseOverCapture?: import('react').MouseEventHandler<HTMLInputElement>;
+    onMouseUp?: import('react').MouseEventHandler<HTMLInputElement>;
+    onMouseUpCapture?: import('react').MouseEventHandler<HTMLInputElement>;
+    onSelect?: import('react').ReactEventHandler<HTMLInputElement>;
+    onSelectCapture?: import('react').ReactEventHandler<HTMLInputElement>;
+    onTouchCancel?: import('react').TouchEventHandler<HTMLInputElement>;
+    onTouchCancelCapture?: import('react').TouchEventHandler<HTMLInputElement>;
+    onTouchEnd?: import('react').TouchEventHandler<HTMLInputElement>;
+    onTouchEndCapture?: import('react').TouchEventHandler<HTMLInputElement>;
+    onTouchMove?: import('react').TouchEventHandler<HTMLInputElement>;
+    onTouchMoveCapture?: import('react').TouchEventHandler<HTMLInputElement>;
+    onTouchStart?: import('react').TouchEventHandler<HTMLInputElement>;
+    onTouchStartCapture?: import('react').TouchEventHandler<HTMLInputElement>;
+    onPointerDown?: import('react').PointerEventHandler<HTMLInputElement>;
+    onPointerDownCapture?: import('react').PointerEventHandler<HTMLInputElement>;
+    onPointerMove?: import('react').PointerEventHandler<HTMLInputElement>;
+    onPointerMoveCapture?: import('react').PointerEventHandler<HTMLInputElement>;
+    onPointerUp?: import('react').PointerEventHandler<HTMLInputElement>;
+    onPointerUpCapture?: import('react').PointerEventHandler<HTMLInputElement>;
+    onPointerCancel?: import('react').PointerEventHandler<HTMLInputElement>;
+    onPointerCancelCapture?: import('react').PointerEventHandler<HTMLInputElement>;
+    onPointerEnter?: import('react').PointerEventHandler<HTMLInputElement>;
+    onPointerLeave?: import('react').PointerEventHandler<HTMLInputElement>;
+    onPointerOver?: import('react').PointerEventHandler<HTMLInputElement>;
+    onPointerOverCapture?: import('react').PointerEventHandler<HTMLInputElement>;
+    onPointerOut?: import('react').PointerEventHandler<HTMLInputElement>;
+    onPointerOutCapture?: import('react').PointerEventHandler<HTMLInputElement>;
+    onGotPointerCapture?: import('react').PointerEventHandler<HTMLInputElement>;
+    onGotPointerCaptureCapture?: import('react').PointerEventHandler<HTMLInputElement>;
+    onLostPointerCapture?: import('react').PointerEventHandler<HTMLInputElement>;
+    onLostPointerCaptureCapture?: import('react').PointerEventHandler<HTMLInputElement>;
+    onScroll?: import('react').UIEventHandler<HTMLInputElement>;
+    onScrollCapture?: import('react').UIEventHandler<HTMLInputElement>;
+    onWheel?: import('react').WheelEventHandler<HTMLInputElement>;
+    onWheelCapture?: import('react').WheelEventHandler<HTMLInputElement>;
+    onAnimationStart?: (definition: import('motion-dom').AnimationDefinition) => void;
+    onAnimationStartCapture?: import('react').AnimationEventHandler<HTMLInputElement>;
+    onAnimationEnd?: import('react').AnimationEventHandler<HTMLInputElement>;
+    onAnimationEndCapture?: import('react').AnimationEventHandler<HTMLInputElement>;
+    onAnimationIteration?: import('react').AnimationEventHandler<HTMLInputElement>;
+    onAnimationIterationCapture?: import('react').AnimationEventHandler<HTMLInputElement>;
+    onToggle?: import('react').ToggleEventHandler<HTMLInputElement>;
+    onBeforeToggle?: import('react').ToggleEventHandler<HTMLInputElement>;
+    onTransitionCancel?: import('react').TransitionEventHandler<HTMLInputElement>;
+    onTransitionCancelCapture?: import('react').TransitionEventHandler<HTMLInputElement>;
+    onTransitionEnd?: import('react').TransitionEventHandler<HTMLInputElement>;
+    onTransitionEndCapture?: import('react').TransitionEventHandler<HTMLInputElement>;
+    onTransitionRun?: import('react').TransitionEventHandler<HTMLInputElement>;
+    onTransitionRunCapture?: import('react').TransitionEventHandler<HTMLInputElement>;
+    onTransitionStart?: import('react').TransitionEventHandler<HTMLInputElement>;
+    onTransitionStartCapture?: import('react').TransitionEventHandler<HTMLInputElement>;
+    inherit?: boolean;
+    list?: string;
+    disabled?: boolean;
+    formAction?: string | ((formData: FormData) => void | Promise<void>);
+    formEncType?: string;
+    formMethod?: string;
+    formNoValidate?: boolean;
+    formTarget?: string;
+    name?: string;
+    type?: import('react').HTMLInputTypeAttribute;
+    initial?: import('motion-dom').TargetAndTransition | import('motion-dom').VariantLabels | boolean;
+    exit?: import('motion-dom').TargetAndTransition | import('motion-dom').VariantLabels;
+    variants?: import('motion-dom').Variants;
+    transition?: import('motion-dom').Transition;
+    onUpdate?: (latest: import('motion-dom').ResolvedValues) => void;
+    onAnimationComplete?: (definition: import('motion-dom').AnimationDefinition) => void;
+    onBeforeLayoutMeasure?: (box: import('motion-utils').Box) => void;
+    onLayoutMeasure?: (box: import('motion-utils').Box, prevBox: import('motion-utils').Box) => void;
+    onLayoutAnimationStart?: () => void;
+    onLayoutAnimationComplete?: () => void;
+    onPan?: (event: PointerEvent, info: import('motion-dom').PanInfo) => void;
+    onPanStart?: (event: PointerEvent, info: import('motion-dom').PanInfo) => void;
+    onPanSessionStart?: (event: PointerEvent, info: import('motion-dom').EventInfo) => void;
+    onPanEnd?: (event: PointerEvent, info: import('motion-dom').PanInfo) => void;
+    onTap?: (event: MouseEvent | TouchEvent | PointerEvent, info: import('motion-dom').TapInfo) => void;
+    onTapStart?: (event: MouseEvent | TouchEvent | PointerEvent, info: import('motion-dom').TapInfo) => void;
+    onTapCancel?: (event: MouseEvent | TouchEvent | PointerEvent, info: import('motion-dom').TapInfo) => void;
+    whileTap?: import('motion-dom').VariantLabels | import('motion-dom').TargetAndTransition;
+    globalTapTarget?: boolean;
+    whileHover?: import('motion-dom').VariantLabels | import('motion-dom').TargetAndTransition;
+    onHoverStart?: (event: MouseEvent, info: import('motion-dom').EventInfo) => void;
+    onHoverEnd?: (event: MouseEvent, info: import('motion-dom').EventInfo) => void;
+    whileFocus?: import('motion-dom').VariantLabels | import('motion-dom').TargetAndTransition;
+    whileInView?: import('motion-dom').VariantLabels | import('motion-dom').TargetAndTransition;
+    onViewportEnter?: import('motion-dom').ViewportEventHandler;
+    onViewportLeave?: import('motion-dom').ViewportEventHandler;
+    viewport?: import('motion-dom').ViewportOptions;
+    onDirectionLock?: (axis: "x" | "y") => void;
+    onDragTransitionEnd?: () => void;
+    drag?: boolean | "x" | "y";
+    whileDrag?: import('motion-dom').VariantLabels | import('motion-dom').TargetAndTransition;
+    dragDirectionLock?: boolean;
+    dragPropagation?: boolean;
+    dragConstraints?: false | Partial<import('motion-utils').BoundingBox> | {
+        current: Element | null;
+    };
+    dragElastic?: import('motion-dom').DragElastic;
+    dragMomentum?: boolean;
+    dragTransition?: import('motion-dom').InertiaOptions;
+    dragControls?: any;
+    dragSnapToOrigin?: boolean;
+    dragListener?: boolean;
+    onMeasureDragConstraints?: (constraints: import('motion-utils').BoundingBox) => import('motion-utils').BoundingBox | void;
+    _dragX?: import('motion-dom').MotionValue<number>;
+    _dragY?: import('motion-dom').MotionValue<number>;
+    layout?: boolean | "position" | "size" | "preserve-aspect";
+    layoutId?: string;
+    layoutDependency?: any;
+    layoutScroll?: boolean;
+    layoutRoot?: boolean;
+    "data-framer-portal-id"?: string;
+    layoutCrossfade?: boolean;
+    custom?: any;
+    ignoreStrict?: boolean;
+    transformTemplate?: import('motion-dom').TransformTemplate;
+    "data-framer-appear-id"?: string;
+    height?: string | number;
+    width?: string | number;
+    multiple?: boolean;
+    src?: string;
+    alt?: string;
+    checked?: boolean;
+    required?: boolean;
+    accept?: string;
+    autoComplete?: import('react').HTMLInputAutoCompleteAttribute;
+    capture?: boolean | "user" | "environment";
+    maxLength?: number;
+    minLength?: number;
+    placeholder?: string;
+    readOnly?: boolean;
+    displayValue: string;
+    handleChange: (e: React.ChangeEvent<HTMLInputElement>) => void;
+    handleFocus: (e: React.FocusEvent<HTMLInputElement>) => void;
+    handleBlur: (e: React.FocusEvent<HTMLInputElement>) => void;
+    handleClear: () => void;
+};
+//# sourceMappingURL=useInputNumber.d.ts.map

package/dist/components/input/number/useInputNumber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useInputNumber.d.ts","sourceRoot":"","sources":["../../../../src/lib/components/input/number/useInputNumber.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AAEjD,eAAO,MAAM,cAAc,UAAW,gBAAgB;;;WAFlC,MAAQ,SAAQ;eAEpC,MAAI,SAAS;;;;;;;;;;;;eA2De,MAC1B,SAEC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAKK,KAAK,CAAC,WAAW,CAAC,gBAAgB,CAAC;qBAanC,KAAK,CAAC,UAAU,CAAC,gBAAgB,CAAC;oBAUlC,KAAK,CAAC,UAAU,CAAC,gBAAgB,CAAC;;CAsBzC,CAAA"}

package/dist/components/input/text/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './text.component';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/input/text/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/components/input/text/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA"}

package/dist/components/input/text/text.component.d.ts

@@ -0,0 +1,4 @@
+import { InputProps } from './text.types';
+declare const InputText: ({ error, size, check, icon, leftIcon, clear, disabled, variant, className, ...props }: InputProps) => import("react/jsx-runtime").JSX.Element;
+export default InputText;
+//# sourceMappingURL=text.component.d.ts.map

package/dist/components/input/text/text.component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.component.d.ts","sourceRoot":"","sources":["../../../../src/lib/components/input/text/text.component.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAGzC,QAAA,MAAM,SAAS,0FAWZ,UAAU,4CA4DZ,CAAA;AAED,eAAe,SAAS,CAAA"}

package/dist/components/input/text/text.stories.d.ts

@@ -0,0 +1,17 @@
+import { Meta, StoryObj } from '@storybook/react';
+import { Input } from '../..';
+declare const meta: Meta<typeof Input.Text>;
+export default meta;
+type Story = StoryObj<typeof Input.Text>;
+export declare const Default: Story;
+export declare const WithIcon: Story;
+export declare const WithRightIcon: Story;
+export declare const Underline: Story;
+export declare const ErrorState: Story;
+export declare const CheckState: Story;
+export declare const Disabled: Story;
+export declare const WithoutClear: Story;
+export declare const Sizes: Story;
+export declare const Variants: Story;
+export declare const AllStates: Story;
+//# sourceMappingURL=text.stories.d.ts.map

package/dist/components/input/text/text.stories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.stories.d.ts","sourceRoot":"","sources":["../../../../src/lib/components/input/text/text.stories.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAEtD,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAA;AAEpC,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,OAAO,KAAK,CAAC,IAAI,CA6BjC,CAAA;AAED,eAAe,IAAI,CAAA;AACnB,KAAK,KAAK,GAAG,QAAQ,CAAC,OAAO,KAAK,CAAC,IAAI,CAAC,CAAA;AAExC,eAAO,MAAM,OAAO,EAAE,KAIrB,CAAA;AAED,eAAO,MAAM,QAAQ,EAAE,KAKtB,CAAA;AAED,eAAO,MAAM,aAAa,EAAE,KAK3B,CAAA;AAED,eAAO,MAAM,SAAS,EAAE,KAKvB,CAAA;AAED,eAAO,MAAM,UAAU,EAAE,KAKxB,CAAA;AAED,eAAO,MAAM,UAAU,EAAE,KAKxB,CAAA;AAED,eAAO,MAAM,QAAQ,EAAE,KAKtB,CAAA;AAED,eAAO,MAAM,YAAY,EAAE,KAK1B,CAAA;AAED,eAAO,MAAM,KAAK,EAAE,KASnB,CAAA;AAED,eAAO,MAAM,QAAQ,EAAE,KAYtB,CAAA;AAED,eAAO,MAAM,SAAS,EAAE,KAkBvB,CAAA"}

package/dist/components/input/text/text.test.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=text.test.d.ts.map

package/dist/components/input/text/text.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.test.d.ts","sourceRoot":"","sources":["../../../../src/lib/components/input/text/text.test.tsx"],"names":[],"mappings":"AAEA,OAAO,2BAA2B,CAAA"}

package/dist/components/input/text/text.types.d.ts

@@ -0,0 +1,6 @@
+import { BaseInputProps } from '../common';
+export interface InputProps extends BaseInputProps {
+    value?: string;
+    onChange?: (e: React.ChangeEvent<HTMLInputElement>) => void;
+}
+//# sourceMappingURL=text.types.d.ts.map

package/dist/components/input/text/text.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.types.d.ts","sourceRoot":"","sources":["../../../../src/lib/components/input/text/text.types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAA;AAE1C,MAAM,WAAW,UAAW,SAAQ,cAAc;IAChD,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,QAAQ,CAAC,EAAE,CAAC,CAAC,EAAE,KAAK,CAAC,WAAW,CAAC,gBAAgB,CAAC,KAAK,IAAI,CAAA;CAC5D"}

package/dist/components/list/index.d.ts

@@ -0,0 +1,3 @@
+export * as List from './list.component';
+export type { ListProps, ListItem } from './list.types';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/list/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/components/list/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,kBAAkB,CAAA;AACxC,YAAY,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA"}

package/dist/components/list/list.component.d.ts

@@ -0,0 +1,68 @@
+import { ListProps } from './list.types';
+/**
+ * Componente de lista para mostrar elementos con opciones de paginación, estilos personalizables y soporte para interactividad.
+ *
+ * Este componente permite renderizar listas de elementos con características avanzadas como:
+ * - Paginación opcional para manejar grandes cantidades de datos
+ * - Tamaños predefinidos (sm, md, lg, xl)
+ * - Estilos personalizables (bordes, sombras, altura)
+ * - Soporte para elementos clickeables y enlaces
+ * - Mensaje personalizable cuando la lista está vacía
+ * - Animaciones de entrada usando Framer Motion
+ *
+ * @component
+ * @param {ListProps} props - Las propiedades del componente
+ * @param {ListItem[]} props.items - Array de elementos a mostrar en la lista
+ * @param {string} [props.title] - Título opcional que se muestra encima de la lista
+ * @param {'sm' | 'md' | 'lg' | 'xl'} [props.size='md'] - Tamaño del componente
+ * @param {boolean} [props.withPagination=false] - Indica si se debe mostrar paginación
+ * @param {number} [props.currentPage=1] - Página actual (base 1)
+ * @param {number} [props.itemsPerPage=10] - Cantidad de elementos por página
+ * @param {(page: number) => void} [props.onPageChange] - Callback ejecutado cuando cambia la página
+ * @param {boolean} [props.showBorder=true] - Indica si se muestra el borde del contenedor
+ * @param {boolean} [props.showShadow=true] - Indica si se muestra la sombra del contenedor
+ * @param {string} [props.height] - Altura personalizada del contenedor (ej: '20rem', '400px')
+ * @param {string} [props.className=''] - Clases CSS adicionales para el contenedor principal
+ * @param {string} [props.titleClassName=''] - Clases CSS adicionales para el título
+ * @param {string} [props.itemClassName=''] - Clases CSS adicionales para cada elemento de la lista
+ * @param {string} [props.emptyMessage='No items to display'] - Mensaje mostrado cuando no hay elementos
+ * @param {(event: React.AnimationEvent) => void} [props.onAnimationStart] - Callback cuando inicia la animación CSS
+ * @param {(event: React.AnimationEvent) => void} [props.onAnimationEnd] - Callback cuando termina la animación CSS
+ * @param {(event: React.AnimationEvent) => void} [props.onAnimationIteration] - Callback en cada iteración de animación CSS
+ * @returns {JSX.Element} El componente List renderizado
+ *
+ * @example
+ * ```tsx
+ * // Lista básica
+ * <List items={[
+ *   { id: 1, content: 'Item 1' },
+ *   { id: 2, content: 'Item 2' }
+ * ]} />
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Lista con título y paginación
+ * <List
+ *   title="My List"
+ *   items={items}
+ *   size="md"
+ *   withPagination
+ *   itemsPerPage={5}
+ *   currentPage={1}
+ *   onPageChange={(page) => setCurrentPage(page)}
+ * />
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Lista con enlaces y elementos clickeables
+ * <List items={[
+ *   { id: 1, content: 'Link Item', href: '/page' },
+ *   { id: 2, content: 'Button Item', onClick: () => alert('clicked') }
+ * ]} />
+ * ```
+ */
+declare const List: ({ items, title, size, withPagination, currentPage, itemsPerPage, onPageChange, showBorder, showShadow, height, className, titleClassName, itemClassName, emptyMessage, onAnimationStart, onAnimationEnd, onAnimationIteration, ...props }: ListProps) => import("react/jsx-runtime").JSX.Element;
+export default List;
+//# sourceMappingURL=list.component.d.ts.map

package/dist/components/list/list.component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.component.d.ts","sourceRoot":"","sources":["../../../src/lib/components/list/list.component.tsx"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAYxC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,QAAA,MAAM,IAAI,8OAmBP,SAAS,4CAgDX,CAAA;AAED,eAAe,IAAI,CAAA"}

package/dist/components/list/list.container.d.ts

@@ -0,0 +1,6 @@
+import { ListContainerProps } from './list.types';
+/**
+ * Container component for the list items
+ */
+export declare const ListContainer: ({ paginatedItems, containerHeight, size, withPagination, showBorder, showShadow, emptyMessage, itemClassName, }: ListContainerProps) => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=list.container.d.ts.map

package/dist/components/list/list.container.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.container.d.ts","sourceRoot":"","sources":["../../../src/lib/components/list/list.container.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAA;AAIjD;;GAEG;AACH,eAAO,MAAM,aAAa,oHASvB,kBAAkB,4CA0BpB,CAAA"}

package/dist/components/list/list.empty.d.ts

@@ -0,0 +1,6 @@
+import { EmptyStateProps } from './list.types';
+/**
+ * Empty state component when list has no items
+ */
+export declare const EmptyState: ({ message, size }: EmptyStateProps) => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=list.empty.d.ts.map

package/dist/components/list/list.empty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.empty.d.ts","sourceRoot":"","sources":["../../../src/lib/components/list/list.empty.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAE9C;;GAEG;AACH,eAAO,MAAM,UAAU,sBAAuB,eAAe,4CAW5D,CAAA"}

package/dist/components/list/list.functions.d.ts

@@ -0,0 +1,36 @@
+import { ListItem } from './list.types';
+import { Size } from '../../types/common';
+/**
+ * Calculate paginated items based on current page and items per page
+ *
+ * @param items - Array of all items
+ * @param withPagination - Whether pagination is enabled
+ * @param currentPage - Current page number (1-indexed)
+ * @param itemsPerPage - Number of items per page
+ * @returns Paginated array of items
+ */
+export declare const usePaginatedItems: (items: ListItem[], withPagination: boolean, currentPage: number, itemsPerPage: number) => ListItem[];
+/**
+ * Calculate total number of pages
+ *
+ * @param totalItems - Total number of items
+ * @param itemsPerPage - Number of items per page
+ * @returns Total number of pages
+ */
+export declare const useTotalPages: (totalItems: number, itemsPerPage: number) => number;
+/**
+ * Get container height based on size or custom height
+ *
+ * @param size - Size of the list component
+ * @param customHeight - Optional custom height
+ * @returns Height value
+ */
+export declare const getContainerHeight: (size: Size, customHeight?: string) => string;
+/**
+ * Create page change handler
+ *
+ * @param onPageChange - Optional callback function for page changes
+ * @returns Handler function
+ */
+export declare const createPageChangeHandler: (onPageChange?: (page: number) => void) => (page: number) => void;
+//# sourceMappingURL=list.functions.d.ts.map

package/dist/components/list/list.functions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.functions.d.ts","sourceRoot":"","sources":["../../../src/lib/components/list/list.functions.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAEvC,OAAO,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAA;AAErC;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,UACrB,QAAQ,EAAE,kBACD,OAAO,eACV,MAAM,gBACL,MAAM,eASrB,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,eAAgB,MAAM,gBAAgB,MAAM,WAIrE,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,SAAU,IAAI,iBAAiB,MAAM,WAEnE,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,kBACnB,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,YAEvB,MAAM,SAKrB,CAAA"}

package/dist/components/list/list.item.d.ts

@@ -0,0 +1,6 @@
+import { ListItemComponentProps } from './list.types';
+/**
+ * Individual list item component
+ */
+export declare const ListItemComponent: ({ item, index, isLast, size, itemClassName, }: ListItemComponentProps) => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=list.item.d.ts.map

package/dist/components/list/list.item.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.item.d.ts","sourceRoot":"","sources":["../../../src/lib/components/list/list.item.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAA;AAErD;;GAEG;AACH,eAAO,MAAM,iBAAiB,kDAM3B,sBAAsB,4CAsCxB,CAAA"}