lizaui 3.0.11

package/dist/components/button/spinner.d.ts

@@ -0,0 +1,3 @@
+declare const Spinner: () => import("react/jsx-runtime").JSX.Element;
+export default Spinner;
+//# sourceMappingURL=spinner.d.ts.map

package/dist/components/button/spinner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spinner.d.ts","sourceRoot":"","sources":["../../../src/components/button/spinner.tsx"],"names":[],"mappings":"AAAA,QAAA,MAAM,OAAO,+CASZ,CAAC;AACF,eAAe,OAAO,CAAC"}

package/dist/components/button/use-button.d.ts

@@ -0,0 +1,328 @@
+import { ReactRef } from '../../functions';
+import { button, ButtonVariantProps } from '../../theme/color/button';
+import { SlotsToClasses } from '../../types';
+import { ReactNode, MouseEventHandler, HTMLAttributes } from 'react';
+import { RippleProps } from '../ripple/ripple';
+export interface UseButtonProps extends ButtonVariantProps, Omit<HTMLAttributes<HTMLElement>, keyof ButtonVariantProps> {
+    ref?: ReactRef<HTMLButtonElement | null>;
+    id?: string;
+    classNames?: SlotsToClasses<ReturnType<typeof button>>;
+    className?: string;
+    asChild?: boolean;
+    children?: ReactNode;
+    isIconOnly?: boolean;
+    isLoading?: boolean;
+    disabled?: boolean;
+    startContent?: ReactNode;
+    endContent?: ReactNode;
+    spinner?: ReactNode;
+    spinnerPlacement?: "start" | "end";
+    type?: "button" | "submit" | "reset";
+}
+export declare function useButton(props: UseButtonProps): {
+    domRef: import('react').RefObject<HTMLButtonElement | null>;
+    isIconOnly: boolean;
+    Component: string | import('react').ForwardRefExoticComponent<import('@radix-ui/react-slot').SlotProps & import('react').RefAttributes<HTMLElement>>;
+    children: ReactNode;
+    isLoading: boolean;
+    spinner: string | number | bigint | boolean | import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>> | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import('react').ReactPortal | import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | null;
+    spinnerPlacement: "start" | "end";
+    startContent: import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>> | null;
+    endContent: import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>> | null;
+    getButtonProps: () => {
+        ref?: ReactRef<HTMLButtonElement | null>;
+        isDisabled?: boolean | undefined;
+        size?: "sm" | "md" | "lg" | undefined;
+        color?: "primary" | "secondary" | "success" | "warning" | "danger" | "default" | undefined;
+        radius?: "sm" | "md" | "lg" | "full" | "none" | undefined;
+        variant?: "flat" | "shadow" | "solid" | "bordered" | "faded" | "light" | "ghost" | undefined;
+        fullWidth?: boolean | undefined;
+        isInGroup?: boolean | undefined;
+        disableAnimation?: boolean | undefined;
+        title?: string | undefined | undefined;
+        content?: string | undefined | undefined;
+        translate?: "yes" | "no" | undefined | undefined;
+        prefix?: string | undefined | undefined;
+        slot?: string | undefined | undefined;
+        style?: import('react').CSSProperties | undefined;
+        defaultChecked?: boolean | undefined | undefined;
+        defaultValue?: string | number | readonly string[] | undefined;
+        suppressContentEditableWarning?: boolean | undefined | undefined;
+        suppressHydrationWarning?: boolean | undefined | undefined;
+        accessKey?: string | undefined | undefined;
+        autoCapitalize?: "off" | "none" | "on" | "sentences" | "words" | "characters" | undefined | (string & {}) | undefined;
+        autoFocus?: boolean | undefined | undefined;
+        contentEditable?: (boolean | "true" | "false") | "inherit" | "plaintext-only" | undefined;
+        contextMenu?: string | undefined | undefined;
+        dir?: string | undefined | undefined;
+        draggable?: (boolean | "true" | "false") | undefined;
+        enterKeyHint?: "enter" | "done" | "go" | "next" | "previous" | "search" | "send" | undefined | undefined;
+        hidden?: boolean | undefined | undefined;
+        lang?: string | undefined | undefined;
+        nonce?: string | undefined | undefined;
+        spellCheck?: (boolean | "true" | "false") | undefined;
+        tabIndex?: number | undefined | undefined;
+        radioGroup?: string | undefined | undefined;
+        role?: import('react').AriaRole | undefined;
+        about?: string | undefined | undefined;
+        datatype?: string | undefined | undefined;
+        inlist?: any;
+        property?: string | undefined | undefined;
+        rel?: string | undefined | undefined;
+        resource?: string | undefined | undefined;
+        rev?: string | undefined | undefined;
+        typeof?: string | undefined | undefined;
+        vocab?: string | undefined | undefined;
+        autoCorrect?: string | undefined | undefined;
+        autoSave?: string | undefined | undefined;
+        itemProp?: string | undefined | undefined;
+        itemScope?: boolean | undefined | undefined;
+        itemType?: string | undefined | undefined;
+        itemID?: string | undefined | undefined;
+        itemRef?: string | undefined | undefined;
+        results?: number | undefined | undefined;
+        security?: string | undefined | undefined;
+        unselectable?: "on" | "off" | undefined | undefined;
+        popover?: "" | "auto" | "manual" | undefined | undefined;
+        popoverTargetAction?: "toggle" | "show" | "hide" | undefined | undefined;
+        popoverTarget?: string | undefined | undefined;
+        inert?: boolean | undefined | undefined;
+        inputMode?: "none" | "text" | "tel" | "url" | "email" | "numeric" | "decimal" | "search" | undefined | undefined;
+        is?: string | undefined | undefined;
+        exportparts?: string | undefined | undefined;
+        part?: string | undefined | undefined;
+        "aria-activedescendant"?: string | undefined | undefined;
+        "aria-atomic"?: (boolean | "true" | "false") | undefined;
+        "aria-autocomplete"?: "none" | "inline" | "list" | "both" | undefined | undefined;
+        "aria-braillelabel"?: string | undefined | undefined;
+        "aria-brailleroledescription"?: string | undefined | undefined;
+        "aria-busy"?: (boolean | "true" | "false") | undefined;
+        "aria-checked"?: boolean | "false" | "mixed" | "true" | undefined | undefined;
+        "aria-colcount"?: number | undefined | undefined;
+        "aria-colindex"?: number | undefined | undefined;
+        "aria-colindextext"?: string | undefined | undefined;
+        "aria-colspan"?: number | undefined | undefined;
+        "aria-controls"?: string | undefined | undefined;
+        "aria-current"?: boolean | "false" | "true" | "page" | "step" | "location" | "date" | "time" | undefined | undefined;
+        "aria-describedby"?: string | undefined | undefined;
+        "aria-description"?: string | undefined | undefined;
+        "aria-details"?: string | undefined | undefined;
+        "aria-disabled": boolean | "true" | "false";
+        "aria-dropeffect"?: "none" | "copy" | "execute" | "link" | "move" | "popup" | undefined | undefined;
+        "aria-errormessage"?: string | undefined | undefined;
+        "aria-expanded"?: (boolean | "true" | "false") | undefined;
+        "aria-flowto"?: string | undefined | undefined;
+        "aria-grabbed"?: (boolean | "true" | "false") | undefined;
+        "aria-haspopup"?: boolean | "false" | "true" | "menu" | "listbox" | "tree" | "grid" | "dialog" | undefined | undefined;
+        "aria-hidden"?: (boolean | "true" | "false") | undefined;
+        "aria-invalid"?: boolean | "false" | "true" | "grammar" | "spelling" | undefined | undefined;
+        "aria-keyshortcuts"?: string | undefined | undefined;
+        "aria-label"?: string | undefined | undefined;
+        "aria-labelledby"?: string | undefined | undefined;
+        "aria-level"?: number | undefined | undefined;
+        "aria-live"?: "off" | "assertive" | "polite" | undefined | undefined;
+        "aria-modal"?: (boolean | "true" | "false") | undefined;
+        "aria-multiline"?: (boolean | "true" | "false") | undefined;
+        "aria-multiselectable"?: (boolean | "true" | "false") | undefined;
+        "aria-orientation"?: "horizontal" | "vertical" | undefined | undefined;
+        "aria-owns"?: string | undefined | undefined;
+        "aria-placeholder"?: string | undefined | undefined;
+        "aria-posinset"?: number | undefined | undefined;
+        "aria-pressed"?: boolean | "false" | "mixed" | "true" | undefined | undefined;
+        "aria-readonly"?: (boolean | "true" | "false") | undefined;
+        "aria-relevant"?: "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text" | "text additions" | "text removals" | undefined | undefined;
+        "aria-required"?: (boolean | "true" | "false") | undefined;
+        "aria-roledescription"?: string | undefined | undefined;
+        "aria-rowcount"?: number | undefined | undefined;
+        "aria-rowindex"?: number | undefined | undefined;
+        "aria-rowindextext"?: string | undefined | undefined;
+        "aria-rowspan"?: number | undefined | undefined;
+        "aria-selected"?: (boolean | "true" | "false") | undefined;
+        "aria-setsize"?: number | undefined | undefined;
+        "aria-sort"?: "none" | "ascending" | "descending" | "other" | undefined | undefined;
+        "aria-valuemax"?: number | undefined | undefined;
+        "aria-valuemin"?: number | undefined | undefined;
+        "aria-valuenow"?: number | undefined | undefined;
+        "aria-valuetext"?: string | undefined | undefined;
+        dangerouslySetInnerHTML?: {
+            __html: string | TrustedHTML;
+        } | undefined | undefined;
+        onCopy?: import('react').ClipboardEventHandler<HTMLElement> | undefined;
+        onCopyCapture?: import('react').ClipboardEventHandler<HTMLElement> | undefined;
+        onCut?: import('react').ClipboardEventHandler<HTMLElement> | undefined;
+        onCutCapture?: import('react').ClipboardEventHandler<HTMLElement> | undefined;
+        onPaste?: import('react').ClipboardEventHandler<HTMLElement> | undefined;
+        onPasteCapture?: import('react').ClipboardEventHandler<HTMLElement> | undefined;
+        onCompositionEnd?: import('react').CompositionEventHandler<HTMLElement> | undefined;
+        onCompositionEndCapture?: import('react').CompositionEventHandler<HTMLElement> | undefined;
+        onCompositionStart?: import('react').CompositionEventHandler<HTMLElement> | undefined;
+        onCompositionStartCapture?: import('react').CompositionEventHandler<HTMLElement> | undefined;
+        onCompositionUpdate?: import('react').CompositionEventHandler<HTMLElement> | undefined;
+        onCompositionUpdateCapture?: import('react').CompositionEventHandler<HTMLElement> | undefined;
+        onFocus?: import('react').FocusEventHandler<HTMLElement> | undefined;
+        onFocusCapture?: import('react').FocusEventHandler<HTMLElement> | undefined;
+        onBlur?: import('react').FocusEventHandler<HTMLElement> | undefined;
+        onBlurCapture?: import('react').FocusEventHandler<HTMLElement> | undefined;
+        onChange?: import('react').FormEventHandler<HTMLElement> | undefined;
+        onChangeCapture?: import('react').FormEventHandler<HTMLElement> | undefined;
+        onBeforeInput?: import('react').FormEventHandler<HTMLElement> | undefined;
+        onBeforeInputCapture?: import('react').FormEventHandler<HTMLElement> | undefined;
+        onInput?: import('react').FormEventHandler<HTMLElement> | undefined;
+        onInputCapture?: import('react').FormEventHandler<HTMLElement> | undefined;
+        onReset?: import('react').FormEventHandler<HTMLElement> | undefined;
+        onResetCapture?: import('react').FormEventHandler<HTMLElement> | undefined;
+        onSubmit?: import('react').FormEventHandler<HTMLElement> | undefined;
+        onSubmitCapture?: import('react').FormEventHandler<HTMLElement> | undefined;
+        onInvalid?: import('react').FormEventHandler<HTMLElement> | undefined;
+        onInvalidCapture?: import('react').FormEventHandler<HTMLElement> | undefined;
+        onLoad?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onLoadCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onError?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onErrorCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onKeyDown?: import('react').KeyboardEventHandler<HTMLElement> | undefined;
+        onKeyDownCapture?: import('react').KeyboardEventHandler<HTMLElement> | undefined;
+        onKeyPress?: import('react').KeyboardEventHandler<HTMLElement> | undefined;
+        onKeyPressCapture?: import('react').KeyboardEventHandler<HTMLElement> | undefined;
+        onKeyUp?: import('react').KeyboardEventHandler<HTMLElement> | undefined;
+        onKeyUpCapture?: import('react').KeyboardEventHandler<HTMLElement> | undefined;
+        onAbort?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onAbortCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onCanPlay?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onCanPlayCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onCanPlayThrough?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onCanPlayThroughCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onDurationChange?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onDurationChangeCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onEmptied?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onEmptiedCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onEncrypted?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onEncryptedCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onEnded?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onEndedCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onLoadedData?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onLoadedDataCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onLoadedMetadata?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onLoadedMetadataCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onLoadStart?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onLoadStartCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onPause?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onPauseCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onPlay?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onPlayCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onPlaying?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onPlayingCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onProgress?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onProgressCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onRateChange?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onRateChangeCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onSeeked?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onSeekedCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onSeeking?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onSeekingCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onStalled?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onStalledCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onSuspend?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onSuspendCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onTimeUpdate?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onTimeUpdateCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onVolumeChange?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onVolumeChangeCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onWaiting?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onWaitingCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onAuxClick?: MouseEventHandler<HTMLElement> | undefined;
+        onAuxClickCapture?: MouseEventHandler<HTMLElement> | undefined;
+        onClickCapture?: MouseEventHandler<HTMLElement> | undefined;
+        onContextMenu?: MouseEventHandler<HTMLElement> | undefined;
+        onContextMenuCapture?: MouseEventHandler<HTMLElement> | undefined;
+        onDoubleClick?: MouseEventHandler<HTMLElement> | undefined;
+        onDoubleClickCapture?: MouseEventHandler<HTMLElement> | undefined;
+        onDrag?: import('react').DragEventHandler<HTMLElement> | undefined;
+        onDragCapture?: import('react').DragEventHandler<HTMLElement> | undefined;
+        onDragEnd?: import('react').DragEventHandler<HTMLElement> | undefined;
+        onDragEndCapture?: import('react').DragEventHandler<HTMLElement> | undefined;
+        onDragEnter?: import('react').DragEventHandler<HTMLElement> | undefined;
+        onDragEnterCapture?: import('react').DragEventHandler<HTMLElement> | undefined;
+        onDragExit?: import('react').DragEventHandler<HTMLElement> | undefined;
+        onDragExitCapture?: import('react').DragEventHandler<HTMLElement> | undefined;
+        onDragLeave?: import('react').DragEventHandler<HTMLElement> | undefined;
+        onDragLeaveCapture?: import('react').DragEventHandler<HTMLElement> | undefined;
+        onDragOver?: import('react').DragEventHandler<HTMLElement> | undefined;
+        onDragOverCapture?: import('react').DragEventHandler<HTMLElement> | undefined;
+        onDragStart?: import('react').DragEventHandler<HTMLElement> | undefined;
+        onDragStartCapture?: import('react').DragEventHandler<HTMLElement> | undefined;
+        onDrop?: import('react').DragEventHandler<HTMLElement> | undefined;
+        onDropCapture?: import('react').DragEventHandler<HTMLElement> | undefined;
+        onMouseDown?: MouseEventHandler<HTMLElement> | undefined;
+        onMouseDownCapture?: MouseEventHandler<HTMLElement> | undefined;
+        onMouseEnter?: MouseEventHandler<HTMLElement> | undefined;
+        onMouseLeave?: MouseEventHandler<HTMLElement> | undefined;
+        onMouseMove?: MouseEventHandler<HTMLElement> | undefined;
+        onMouseMoveCapture?: MouseEventHandler<HTMLElement> | undefined;
+        onMouseOut?: MouseEventHandler<HTMLElement> | undefined;
+        onMouseOutCapture?: MouseEventHandler<HTMLElement> | undefined;
+        onMouseOver?: MouseEventHandler<HTMLElement> | undefined;
+        onMouseOverCapture?: MouseEventHandler<HTMLElement> | undefined;
+        onMouseUp?: MouseEventHandler<HTMLElement> | undefined;
+        onMouseUpCapture?: MouseEventHandler<HTMLElement> | undefined;
+        onSelect?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onSelectCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+        onTouchCancel?: import('react').TouchEventHandler<HTMLElement> | undefined;
+        onTouchCancelCapture?: import('react').TouchEventHandler<HTMLElement> | undefined;
+        onTouchEnd?: import('react').TouchEventHandler<HTMLElement> | undefined;
+        onTouchEndCapture?: import('react').TouchEventHandler<HTMLElement> | undefined;
+        onTouchMove?: import('react').TouchEventHandler<HTMLElement> | undefined;
+        onTouchMoveCapture?: import('react').TouchEventHandler<HTMLElement> | undefined;
+        onTouchStart?: import('react').TouchEventHandler<HTMLElement> | undefined;
+        onTouchStartCapture?: import('react').TouchEventHandler<HTMLElement> | undefined;
+        onPointerDown: import('react').PointerEventHandler<HTMLElement>;
+        onPointerDownCapture?: import('react').PointerEventHandler<HTMLElement> | undefined;
+        onPointerMove?: import('react').PointerEventHandler<HTMLElement> | undefined;
+        onPointerMoveCapture?: import('react').PointerEventHandler<HTMLElement> | undefined;
+        onPointerUp?: import('react').PointerEventHandler<HTMLElement> | undefined;
+        onPointerUpCapture?: import('react').PointerEventHandler<HTMLElement> | undefined;
+        onPointerCancel?: import('react').PointerEventHandler<HTMLElement> | undefined;
+        onPointerCancelCapture?: import('react').PointerEventHandler<HTMLElement> | undefined;
+        onPointerEnter?: import('react').PointerEventHandler<HTMLElement> | undefined;
+        onPointerLeave?: import('react').PointerEventHandler<HTMLElement> | undefined;
+        onPointerOver?: import('react').PointerEventHandler<HTMLElement> | undefined;
+        onPointerOverCapture?: import('react').PointerEventHandler<HTMLElement> | undefined;
+        onPointerOut?: import('react').PointerEventHandler<HTMLElement> | undefined;
+        onPointerOutCapture?: import('react').PointerEventHandler<HTMLElement> | undefined;
+        onGotPointerCapture?: import('react').PointerEventHandler<HTMLElement> | undefined;
+        onGotPointerCaptureCapture?: import('react').PointerEventHandler<HTMLElement> | undefined;
+        onLostPointerCapture?: import('react').PointerEventHandler<HTMLElement> | undefined;
+        onLostPointerCaptureCapture?: import('react').PointerEventHandler<HTMLElement> | undefined;
+        onScroll?: import('react').UIEventHandler<HTMLElement> | undefined;
+        onScrollCapture?: import('react').UIEventHandler<HTMLElement> | undefined;
+        onScrollEnd?: import('react').UIEventHandler<HTMLElement> | undefined;
+        onScrollEndCapture?: import('react').UIEventHandler<HTMLElement> | undefined;
+        onWheel?: import('react').WheelEventHandler<HTMLElement> | undefined;
+        onWheelCapture?: import('react').WheelEventHandler<HTMLElement> | undefined;
+        onAnimationStart?: import('react').AnimationEventHandler<HTMLElement> | undefined;
+        onAnimationStartCapture?: import('react').AnimationEventHandler<HTMLElement> | undefined;
+        onAnimationEnd?: import('react').AnimationEventHandler<HTMLElement> | undefined;
+        onAnimationEndCapture?: import('react').AnimationEventHandler<HTMLElement> | undefined;
+        onAnimationIteration?: import('react').AnimationEventHandler<HTMLElement> | undefined;
+        onAnimationIterationCapture?: import('react').AnimationEventHandler<HTMLElement> | undefined;
+        onToggle?: import('react').ToggleEventHandler<HTMLElement> | undefined;
+        onBeforeToggle?: import('react').ToggleEventHandler<HTMLElement> | undefined;
+        onTransitionCancel?: import('react').TransitionEventHandler<HTMLElement> | undefined;
+        onTransitionCancelCapture?: import('react').TransitionEventHandler<HTMLElement> | undefined;
+        onTransitionEnd?: import('react').TransitionEventHandler<HTMLElement> | undefined;
+        onTransitionEndCapture?: import('react').TransitionEventHandler<HTMLElement> | undefined;
+        onTransitionRun?: import('react').TransitionEventHandler<HTMLElement> | undefined;
+        onTransitionRunCapture?: import('react').TransitionEventHandler<HTMLElement> | undefined;
+        onTransitionStart?: import('react').TransitionEventHandler<HTMLElement> | undefined;
+        onTransitionStartCapture?: import('react').TransitionEventHandler<HTMLElement> | undefined;
+        className: string;
+        "data-disabled": boolean | "true" | "false";
+        "data-loading": boolean | "true" | "false";
+        onClick: MouseEventHandler<HTMLElement>;
+        "data-slot": string;
+        id: string;
+        type: "button" | "reset" | "submit";
+    };
+    getRippleProps: () => RippleProps;
+};
+export type UseButtonReturn = ReturnType<typeof useButton>;
+//# sourceMappingURL=use-button.d.ts.map

package/dist/components/button/use-button.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-button.d.ts","sourceRoot":"","sources":["../../../src/components/button/use-button.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AACjE,OAAO,EAAE,MAAM,EAAE,KAAK,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AACvE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAK9C,OAAO,KAAK,EAAE,SAAS,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAC1E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAGpD,MAAM,WAAW,cAAe,SAAQ,kBAAkB,EAAE,IAAI,CAAC,cAAc,CAAC,WAAW,CAAC,EAAE,MAAM,kBAAkB,CAAC;IACtH,GAAG,CAAC,EAAE,QAAQ,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAAC;IACzC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,UAAU,CAAC,EAAE,cAAc,CAAC,UAAU,CAAC,OAAO,MAAM,CAAC,CAAC,CAAC;IACvD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,YAAY,CAAC,EAAE,SAAS,CAAC;IACzB,UAAU,CAAC,EAAE,SAAS,CAAC;IACvB,OAAO,CAAC,EAAE,SAAS,CAAC;IACpB,gBAAgB,CAAC,EAAE,OAAO,GAAG,KAAK,CAAC;IAChC,IAAI,CAAC,EAAE,QAAQ,GAAG,QAAQ,GAAG,OAAO,CAAC;CACxC;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,cAAc;;;;;;;;;;;cAhBxC,QAAQ,CAAC,iBAAiB,GAAG,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAwGC,WAAW;EAiBpD;AAED,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC,OAAO,SAAS,CAAC,CAAC"}

package/dist/components/calendar/date-picker/date-picker.d.ts

@@ -0,0 +1,3 @@
+import { CalendarProps } from './interface/date-picker.interface';
+export declare const CalendarPicker: ({ id, value, showDoubleView, className, color, minDate, maxDate, showCalendar, loading, widthCalendar, locale, format, disabled, error, label, touched, required, onChange, onCloseCalendar, onOpenCalendar, tileDisabled, onClearCalendar, onInvalidChange, onKeyDown, onKeyUp, onBlur, type, size, tileContent, }: CalendarProps) => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=date-picker.d.ts.map

package/dist/components/calendar/date-picker/date-picker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"date-picker.d.ts","sourceRoot":"","sources":["../../../../src/components/calendar/date-picker/date-picker.tsx"],"names":[],"mappings":"AAAA,OAAO,kCAAkC,CAAC;AAC1C,OAAO,uCAAuC,CAAC;AAC/C,OAAO,4DAA4D,CAAC;AAepE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAOvE,eAAO,MAAM,cAAc,GAAI,qTA8B5B,aAAa,4CAuKf,CAAC"}

package/dist/components/calendar/date-picker/date-picker.style.d.ts

@@ -0,0 +1,9 @@
+import { ColorProps, ExcludeType, SizeProps } from '../../../types';
+export declare const CalendarStyle: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components/dist/types').Substitute<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
+    color?: ExcludeType<ColorProps, "secondary">;
+    showcalendar: string;
+    widthcalendar: number;
+    error?: string;
+    size?: ExcludeType<SizeProps, "xs">;
+}>> & string;
+//# sourceMappingURL=date-picker.style.d.ts.map

package/dist/components/calendar/date-picker/date-picker.style.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"date-picker.style.d.ts","sourceRoot":"","sources":["../../../../src/components/calendar/date-picker/date-picker.style.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAGlE,eAAO,MAAM,aAAa;YACjB,WAAW,CAAC,UAAU,EAAE,WAAW,CAAC;kBAC9B,MAAM;mBACL,MAAM;YACb,MAAM;WACP,WAAW,CAAC,SAAS,EAAE,IAAI,CAAC;YAgZnC,CAAC"}

package/dist/components/calendar/date-picker/interface/date-picker.interface.d.ts

@@ -0,0 +1,38 @@
+import { ColorProps, ExcludeType, SizeProps } from '../../../../types';
+import { ValueCalendar } from '../../interface/calendar-shared.interface';
+import { TileContentFunc } from 'react-calendar';
+export interface CalendarProps {
+    id?: string;
+    value: ValueCalendar;
+    onChange: (value: ValueCalendar) => void;
+    showDoubleView?: boolean;
+    className?: string;
+    color?: ExcludeType<ColorProps, "secondary">;
+    minDate?: Date;
+    maxDate?: Date;
+    showCalendar?: boolean;
+    onCloseCalendar?: () => void;
+    onClearCalendar?: () => void;
+    onOpenCalendar?: () => void;
+    loading?: boolean;
+    widthCalendar?: number;
+    disabled?: boolean;
+    error?: string;
+    label?: string;
+    touched?: boolean;
+    required?: boolean;
+    isErrorText?: boolean;
+    tileContent?: React.ReactNode | TileContentFunc;
+    tileDisabled?: ({ date }: {
+        date: Date;
+    }) => boolean;
+    locale?: "es" | "en";
+    format?: "MM/dd/yyyy" | "MM-dd-yyyy" | "dd/MM/yyyy" | "dd-MM-yyyy" | "yyyy/MM/dd" | "yyyy-MM-dd";
+    type?: "date-picker" | "date-range-picker";
+    onInvalidChange?: () => void;
+    size?: ExcludeType<SizeProps, "xs">;
+    onKeyUp?: (event: any) => void;
+    onKeyDown?: (event: any) => void;
+    onBlur?: (event: any) => void;
+}
+//# sourceMappingURL=date-picker.interface.d.ts.map

package/dist/components/calendar/date-picker/interface/date-picker.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"date-picker.interface.d.ts","sourceRoot":"","sources":["../../../../../src/components/calendar/date-picker/interface/date-picker.interface.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAClE,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,2CAA2C,CAAC;AAC/E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEtD,MAAM,WAAW,aAAa;IAC1B,EAAE,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,aAAa,CAAC;IACrB,QAAQ,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAC;IACzC,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB,KAAK,CAAC,EAAE,WAAW,CAAC,UAAU,EAAE,WAAW,CAAC,CAAC;IAC7C,OAAO,CAAC,EAAE,IAAI,CAAC;IACf,OAAO,CAAC,EAAE,IAAI,CAAC;IACf,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,eAAe,CAAC,EAAE,MAAM,IAAI,CAAC;IAC7B,eAAe,CAAC,EAAE,MAAM,IAAI,CAAC;IAC7B,cAAc,CAAC,EAAE,MAAM,IAAI,CAAC;IAC5B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,WAAW,CAAC,EAAE,KAAK,CAAC,SAAS,GAAG,eAAe,CAAA;IAClD,YAAY,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE;QAAE,IAAI,EAAE,IAAI,CAAA;KAAE,KAAK,OAAO,CAAC;IACrD,MAAM,CAAC,EAAE,IAAI,GAAG,IAAI,CAAC;IACrB,MAAM,CAAC,EAAE,YAAY,GAAG,YAAY,GAAG,YAAY,GAAG,YAAY,GAAG,YAAY,GAAG,YAAY,CAAC;IACjG,IAAI,CAAC,EAAE,aAAa,GAAG,mBAAmB,CAAC;IAC3C,eAAe,CAAC,EAAE,MAAM,IAAI,CAAC;IAC7B,IAAI,CAAC,EAAE,WAAW,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;IACpC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC;IAC/B,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC;IACjC,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC;CAC9B"}

package/dist/components/calendar/icon/icon-calendar.d.ts

@@ -0,0 +1,11 @@
+export interface IconCalendarProps {
+    disabled?: boolean;
+    error?: string;
+}
+export interface IconCloseProps extends IconCalendarProps {
+    onClick: () => void;
+}
+export declare const IconCalendar: ({ disabled, error }: IconCalendarProps) => import("react/jsx-runtime").JSX.Element;
+export declare const IconCloseCalendar: ({ disabled, error, onClick }: IconCloseProps) => import("react/jsx-runtime").JSX.Element;
+export declare const IconTimeCalendar: ({ disabled, error }: IconCalendarProps) => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=icon-calendar.d.ts.map

package/dist/components/calendar/icon/icon-calendar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"icon-calendar.d.ts","sourceRoot":"","sources":["../../../../src/components/calendar/icon/icon-calendar.tsx"],"names":[],"mappings":"AAIA,MAAM,WAAW,iBAAiB;IACjC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;CACf;AACD,MAAM,WAAW,cAAe,SAAQ,iBAAiB;IACxD,OAAO,EAAE,MAAM,IAAI,CAAC;CACpB;AAED,eAAO,MAAM,YAAY,GAAI,qBAAqB,iBAAiB,4CAUlE,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,8BAA8B,cAAc,4CAc7E,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,qBAAqB,iBAAiB,4CAUtE,CAAC"}

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

@@ -0,0 +1,2 @@
+export * from './date-picker/date-picker';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/calendar/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC"}

package/dist/components/calendar/interface/calendar-shared.interface.d.ts

@@ -0,0 +1,4 @@
+type ValuePiece = Date | null | string;
+export type ValueCalendar = ValuePiece | [ValuePiece, ValuePiece];
+export {};
+//# sourceMappingURL=calendar-shared.interface.d.ts.map

package/dist/components/calendar/interface/calendar-shared.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calendar-shared.interface.d.ts","sourceRoot":"","sources":["../../../../src/components/calendar/interface/calendar-shared.interface.ts"],"names":[],"mappings":"AAAA,KAAK,UAAU,GAAG,IAAI,GAAG,IAAI,GAAG,MAAM,CAAC;AAEvC,MAAM,MAAM,aAAa,GAAG,UAAU,GAAG,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC"}

package/dist/components/checkbox/checkbox-icon.d.ts

@@ -0,0 +1,9 @@
+import { UseCheckboxReturn } from './use-checkbox';
+type CheckboxIconProps = Partial<ReturnType<UseCheckboxReturn["getIconProps"]>>;
+/**
+ * CheckboxIcon is used to visually indicate the checked or indeterminate
+ * state of a checkbox.
+ */
+export declare function CheckboxIcon(props: CheckboxIconProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=checkbox-icon.d.ts.map

package/dist/components/checkbox/checkbox-icon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkbox-icon.d.ts","sourceRoot":"","sources":["../../../src/components/checkbox/checkbox-icon.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAExD,KAAK,iBAAiB,GAAG,OAAO,CAAC,UAAU,CAAC,iBAAiB,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;AA0ChF;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,iBAAiB,2CAKpD"}

package/dist/components/checkbox/checkbox.d.ts

@@ -0,0 +1,7 @@
+import { UseCheckboxProps } from './use-checkbox';
+export interface CheckboxProps extends UseCheckboxProps {
+    asChild?: boolean;
+}
+declare const Checkbox: import('react').ForwardRefExoticComponent<Omit<CheckboxProps, "ref"> & import('react').RefAttributes<HTMLInputElement>>;
+export default Checkbox;
+//# sourceMappingURL=checkbox.d.ts.map

package/dist/components/checkbox/checkbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkbox.d.ts","sourceRoot":"","sources":["../../../src/components/checkbox/checkbox.tsx"],"names":[],"mappings":"AAKA,OAAO,EAAe,KAAK,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAGpE,MAAM,WAAW,aAAc,SAAQ,gBAAgB;IACtD,OAAO,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,QAAA,MAAM,QAAQ,yHAwBZ,CAAC;AAIH,eAAe,QAAQ,CAAC"}

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

@@ -0,0 +1,5 @@
+import { default as Checkbox } from './checkbox';
+export type { CheckboxProps } from './checkbox';
+export { Checkbox };
+export { CheckboxIcon } from './checkbox-icon';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/checkbox/index.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,YAAY,CAAC;AAElC,YAAY,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,OAAO,EAAE,QAAQ,EAAE,CAAC;AACpB,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/components/checkbox/use-checkbox.d.ts

@@ -0,0 +1,57 @@
+import { ChangeEvent } from 'react';
+import { CheckboxSlots, CheckboxVariantProps } from '../../theme/color/checkbox';
+import { SlotsToClasses } from '../../types';
+export interface UseCheckboxProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof CheckboxVariantProps>, CheckboxVariantProps {
+    classNames?: SlotsToClasses<CheckboxSlots>;
+    className?: string;
+    icon?: React.ReactNode | ((props: CheckboxIconProps) => React.ReactNode);
+    children?: React.ReactNode;
+    isIndeterminate?: boolean;
+    ref?: React.Ref<HTMLInputElement>;
+    error?: string;
+    touched?: boolean;
+    required?: boolean;
+}
+export interface CheckboxIconProps {
+    id?: string;
+    isSelected: boolean;
+    isIndeterminate?: boolean;
+    disableAnimation?: boolean;
+    className?: string;
+}
+export declare function useCheckbox(props: UseCheckboxProps): {
+    Component: string;
+    icon: import('react').ReactNode | ((props: CheckboxIconProps) => React.ReactNode);
+    children: import('react').ReactNode;
+    isSelected: boolean;
+    isIndeterminate: boolean;
+    getBaseProps: () => {
+        className: string;
+        "data-disabled": boolean | "true" | "false";
+        "data-selected": boolean | "true" | "false";
+    };
+    getWrapperProps: () => {
+        "aria-hidden": boolean;
+        className: string;
+        "data-selected": boolean | "true" | "false";
+    };
+    getInputProps: () => {
+        ref: (node: HTMLInputElement | null) => void;
+        type: string;
+        id: string;
+        defaultChecked: boolean | undefined;
+        checked: boolean | undefined;
+        disabled: boolean | undefined;
+        required: boolean | undefined;
+        readOnly: boolean | undefined;
+        onChange: (e: ChangeEvent<HTMLInputElement>) => void;
+        className: string;
+    };
+    getLabelProps: () => {
+        htmlFor: string;
+        className: string;
+    };
+    getIconProps: () => CheckboxIconProps;
+};
+export type UseCheckboxReturn = ReturnType<typeof useCheckbox>;
+//# sourceMappingURL=use-checkbox.d.ts.map

package/dist/components/checkbox/use-checkbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-checkbox.d.ts","sourceRoot":"","sources":["../../../src/components/checkbox/use-checkbox.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuC,KAAK,WAAW,EAAE,MAAM,OAAO,CAAC;AAE9E,OAAO,EAAY,KAAK,aAAa,EAAE,KAAK,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AACjG,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAI9C,MAAM,WAAW,gBAAiB,SAAQ,IAAI,CAAC,KAAK,CAAC,mBAAmB,CAAC,gBAAgB,CAAC,EAAE,MAAM,oBAAoB,CAAC,EAAE,oBAAoB;IAC5I,UAAU,CAAC,EAAE,cAAc,CAAC,aAAa,CAAC,CAAC;IAC3C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,KAAK,CAAC,SAAS,GAAG,CAAC,CAAC,KAAK,EAAE,iBAAiB,KAAK,KAAK,CAAC,SAAS,CAAC,CAAC;IACzE,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IAC3B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,GAAG,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;IAClC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,iBAAiB;IACjC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,OAAO,CAAC;IACpB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,gBAAgB;;+CAjBhB,iBAAiB,KAAK,KAAK,CAAC,SAAS;;;;;;;;;;;;;;;;;;;;;;;sBA4ClE,WAAW,CAAC,gBAAgB,CAAC;;;;;;;wBAsDT,iBAAiB;EAqB1C;AAED,MAAM,MAAM,iBAAiB,GAAG,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC"}

package/dist/components/chip/chip.d.ts

@@ -0,0 +1,6 @@
+import { UseChipProps } from './use-chip';
+import * as React from "react";
+export type ChipProps = Omit<UseChipProps, "isOneChar" | "isCloseButtonFocusVisible">;
+declare const Chip: React.ForwardRefExoticComponent<Omit<ChipProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export default Chip;
+//# sourceMappingURL=chip.d.ts.map

package/dist/components/chip/chip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chip.d.ts","sourceRoot":"","sources":["../../../src/components/chip/chip.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAAW,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAGxD,MAAM,MAAM,SAAS,GAAG,IAAI,CAAC,YAAY,EAAE,WAAW,GAAG,2BAA2B,CAAC,CAAC;AAEtF,QAAA,MAAM,IAAI,+FA2BR,CAAC;AAIH,eAAe,IAAI,CAAC"}

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

@@ -0,0 +1,4 @@
+export type { ChipProps } from './chip';
+export { useChip } from './use-chip';
+export { default as Chip } from './chip';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/chip/index.ts"],"names":[],"mappings":"AACA,YAAY,EAAC,SAAS,EAAC,MAAM,QAAQ,CAAC;AAGtC,OAAO,EAAC,OAAO,EAAC,MAAM,YAAY,CAAC;AAGnC,OAAO,EAAC,OAAO,IAAI,IAAI,EAAC,MAAM,QAAQ,CAAC"}