@e-burgos/tucu-ui 1.0.0

package/components/forms/checkbox.d.ts

@@ -0,0 +1,38 @@
+export interface CheckboxProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'size'> {
+    /** The size of the component */
+    size?: 'sm' | 'md' | 'lg';
+    /** Change input color */
+    color?: 'primary' | 'secondary' | 'danger' | 'info' | 'success' | 'warning';
+    /** Available directions of the label are: */
+    labelPlacement?: 'start' | 'end';
+    /** Whether the input is disabled */
+    disabled?: boolean;
+    /** Set field label */
+    label?: React.ReactNode;
+    /** Show error message using this prop */
+    error?: string;
+    /** Add helper text. It could be string or a React component */
+    helperText?: React.ReactNode;
+    /** Use className prop to apply style for entire component */
+    className?: string;
+    /** Use activeClassName prop to apply style on active component from checkboxGroup */
+    activeClassName?: string;
+    /** Use containerClassName prop to apply some additional style for label and checkbox container */
+    containerClassName?: string;
+    /** Use iconClassName prop to apply some additonal style for check mark icon */
+    iconClassName?: string;
+    /** Use labelClassName prop to apply some addition style for the field label */
+    labelClassName?: string;
+    /** Add custom classes for the input filed extra style */
+    inputClassName?: string;
+    /** This prop allows you to customize the error message style */
+    errorClassName?: string;
+    /** This prop allows you to customize the helper message style */
+    helperClassName?: string;
+}
+/**
+ * A simplified checkbox component that uses a single color-based styling approach.
+ * The checkbox changes appearance based on its state (unchecked, checked, hover, focus, disabled).
+ */
+export declare const Checkbox: import('react').ForwardRefExoticComponent<CheckboxProps & import('react').RefAttributes<HTMLInputElement>>;
+export default Checkbox;

package/components/forms/field-error-text.d.ts

@@ -0,0 +1,19 @@
+import { default as React } from 'react';
+declare const fieldErrorClasses: {
+    base: string;
+    size: {
+        sm: string;
+        DEFAULT: string;
+        lg: string;
+        xl: string;
+    };
+};
+export interface FieldErrorProps extends React.HTMLAttributes<HTMLDivElement | HTMLSpanElement> {
+    tag?: 'div' | 'span';
+    error: string | null | undefined;
+    size?: keyof typeof fieldErrorClasses.size;
+    className?: string;
+    id?: string;
+}
+export declare function FieldError({ tag, error, size, className, id, ...props }: FieldErrorProps): import("react/jsx-runtime").JSX.Element;
+export default FieldError;

package/components/forms/field-helper-text.d.ts

@@ -0,0 +1,18 @@
+import { default as React } from 'react';
+declare const helperTextClasses: {
+    base: string;
+    size: {
+        sm: string;
+        DEFAULT: string;
+        lg: string;
+        xl: string;
+    };
+};
+export interface FieldHelperTextProps extends React.HTMLAttributes<HTMLDivElement | HTMLSpanElement> {
+    tag?: 'div' | 'span';
+    size?: keyof typeof helperTextClasses.size;
+    className?: string;
+    id?: string;
+}
+export declare function FieldHelperText({ size, tag, children, className, id, ...props }: React.PropsWithChildren<FieldHelperTextProps>): import("react/jsx-runtime").JSX.Element;
+export default FieldHelperText;

package/components/forms/file-input.d.ts

@@ -0,0 +1,8 @@
+export declare function FileInput({ className, label, placeholderText, multiple, accept, }: {
+    className?: string;
+    label?: string;
+    placeholderText?: string;
+    multiple?: boolean;
+    accept?: 'img' | 'pdf' | 'csv' | 'imgAndPdf' | 'all';
+}): import("react/jsx-runtime").JSX.Element;
+export default FileInput;

package/components/forms/form-system/example/error-container-example.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+export declare const ErrorContainerExample: React.FC;
+export default ErrorContainerExample;

package/components/forms/form-system/example/form-example.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+export declare const FormExample: React.FC;
+export default FormExample;

package/components/forms/form-system/example/form-methods-example.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+export declare const FormMethodsExample: React.FC;
+export default FormMethodsExample;

package/components/forms/form-system/example/validations.d.ts

@@ -0,0 +1,14 @@
+import { FormValidations } from '../types/validations.type';
+export interface FormValues {
+    name: string;
+    email: string;
+    password: string;
+    message: string;
+    acceptTerms: boolean;
+    age: number;
+    gender: string;
+    isDeveloper: boolean;
+    country: string;
+}
+export declare const defaultValues: FormValues;
+export declare const formValidations: FormValidations<FormValues>;

package/components/forms/form-system/form-field.d.ts

@@ -0,0 +1,14 @@
+import { default as React } from 'react';
+import { FieldValues, Path, RegisterOptions } from './hook-form';
+export interface FormFieldProps<TFormValues extends FieldValues> {
+    name: Path<TFormValues>;
+    label?: string;
+    helperText?: string;
+    className?: string;
+    rules?: Omit<RegisterOptions<TFormValues, Path<TFormValues>>, 'valueAsNumber' | 'valueAsDate' | 'setValueAs' | 'disabled'>;
+    children: React.ReactElement;
+    hideError?: boolean;
+    showHelper?: boolean;
+}
+export declare const FormField: <TFormValues extends FieldValues = FieldValues>({ name, label, helperText, className, rules, children, hideError, showHelper, }: FormFieldProps<TFormValues>) => import("react/jsx-runtime").JSX.Element;
+export default FormField;

package/components/forms/form-system/form.d.ts

@@ -0,0 +1,13 @@
+import { default as React } from 'react';
+import { SubmitHandler, UseFormProps, FieldValues, UseFormReturn } from './hook-form';
+import { FormValidations } from './types/validations.type';
+export type RenderFunction<TFormValues extends FieldValues> = (methods: UseFormReturn<TFormValues>) => React.ReactNode;
+type FormProps<TFormValues extends FieldValues> = {
+    onSubmit: SubmitHandler<TFormValues>;
+    children: React.ReactNode | RenderFunction<TFormValues>;
+    useFormProps?: UseFormProps<TFormValues>;
+    validationSchema?: FormValidations<TFormValues>;
+    className?: string;
+} & Omit<React.FormHTMLAttributes<HTMLFormElement>, 'onSubmit'>;
+export declare const Form: <TFormValues extends FieldValues = FieldValues>({ onSubmit, children, useFormProps, validationSchema, className, ...formProps }: FormProps<TFormValues>) => import("react/jsx-runtime").JSX.Element;
+export default Form;

package/components/forms/form-system/hook-form.d.ts

@@ -0,0 +1,3 @@
+import { SubmitHandler, UseFormProps, FieldValues, UseFormReturn, Controller, useFormContext, Path, FieldError as FormFieldError, RegisterOptions, FieldErrors } from 'react-hook-form';
+export type { FormFieldError, FieldErrors, RegisterOptions, Path, FieldValues, UseFormReturn, UseFormProps, SubmitHandler, };
+export { Controller, useFormContext };

package/components/forms/form-system/index.d.ts

@@ -0,0 +1,10 @@
+export * from './example/error-container-example';
+export * from './example/form-example';
+export * from './example/form-methods-example';
+export * from './example/validations';
+export * from './form-field';
+export * from './form';
+export * from './types/dependencies.type';
+export * from './types/extend-react-hook-form.type';
+export * from './types/validations.type';
+export * from './hook-form';

package/components/forms/form-system/types/dependencies.type.d.ts

@@ -0,0 +1,11 @@
+import { FieldValues, UseFormReturn } from '../hook-form';
+import { FieldPathInternal, ArrayKey } from './extend-react-hook-form.type';
+export type DependencyAction<TFieldValues extends FieldValues> = (formValues: Partial<TFieldValues>, methods: UseFormReturn<TFieldValues>, options: {
+    index: null | number;
+    name: string | null;
+}) => void;
+export type Dependency<TFieldValues extends FieldValues = FieldValues> = {
+    dependencies: FieldPathInternal<TFieldValues, ArrayKey>[];
+    callback: DependencyAction<TFieldValues>;
+};
+export type FormDependencies<TFieldValues extends FieldValues = FieldValues> = Dependency<TFieldValues>[];

package/components/forms/form-system/types/extend-react-hook-form.type.d.ts

@@ -0,0 +1,16 @@
+import { IsTuple, TupleKeys } from 'react-hook-form/dist/types/path/common';
+import { BrowserNativeObject, IsEqual, Primitive } from 'react-hook-form/dist/types/utils';
+import { ValidateResult } from 'react-hook-form/dist/types/validator';
+export type ArrayKey = '[number]';
+type AnyIsEqual<T1, T2> = T1 extends T2 ? IsEqual<T1, T2> extends true ? true : never : never;
+type PathImpl<K extends string | number, V, TraversedTypes, ArrayK extends string | number> = V extends Primitive | BrowserNativeObject ? `${K}` : true extends AnyIsEqual<TraversedTypes, V> ? `${K}` : `${K}` | `${K}.${FieldPathInternal<V, ArrayK, TraversedTypes | V>}`;
+export type FieldPathInternal<T, ArrayK extends string | number, TraversedTypes = T> = T extends ReadonlyArray<infer V> ? IsTuple<T> extends true ? {
+    [K in TupleKeys<T>]-?: PathImpl<K & string, T[K], TraversedTypes, ArrayK>;
+}[TupleKeys<T>] : PathImpl<ArrayK, V, TraversedTypes, ArrayK> : {
+    [K in keyof T]-?: PathImpl<K & string, T[K], TraversedTypes, ArrayK>;
+}[keyof T];
+export type InternalValidate<TFieldValue, TFormValues> = (value: TFieldValue, formValues: TFormValues, options: {
+    index: number | null;
+    name: string | null;
+}) => ValidateResult | Promise<ValidateResult>;
+export type { IsTuple, TupleKeys, BrowserNativeObject, IsEqual, Primitive, ValidateResult, };

package/components/forms/form-system/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './dependencies.type';
+export * from './extend-react-hook-form.type';
+export * from './validations.type';

package/components/forms/form-system/types/validations.type.d.ts

@@ -0,0 +1,9 @@
+import { FieldValues, RegisterOptions } from 'react-hook-form';
+import { FieldPath, FieldPathValue } from 'react-hook-form/dist/types/path';
+import { FieldPathInternal, ArrayKey, InternalValidate } from './extend-react-hook-form.type';
+export type Rules<TFieldValues extends FieldValues = FieldValues, TFieldName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = Omit<RegisterOptions<TFieldValues>, 'valueAsNumber' | 'valueAsDate' | 'setValueAs' | 'disabled' | 'validate'> & {
+    validate?: InternalValidate<FieldPathValue<TFieldValues, TFieldName>, TFieldValues> | Record<never, InternalValidate<FieldPathValue<TFieldValues, TFieldName>, TFieldValues>>;
+};
+export type FormValidations<TFieldValues extends FieldValues = FieldValues> = {
+    [key in FieldPathInternal<TFieldValues, ArrayKey>]?: Rules<TFieldValues>;
+};

package/components/forms/index.d.ts

@@ -0,0 +1,17 @@
+export * from './checkbox';
+export * from './field-error-text';
+export * from './field-helper-text';
+export * from './file-input';
+export * from './input-label';
+export * from './input-searcher';
+export * from './input-switch';
+export * from './input';
+export * from './input-select';
+export * from './pin-code';
+export * from './radio';
+export * from './radio-group';
+export * from './textarea';
+export * from './toggle-bar';
+export * from './uploader-two';
+export * from './uploader';
+export * from './form-system';

package/components/forms/input-label.d.ts

@@ -0,0 +1,9 @@
+export interface InputLabelProps {
+    title: string;
+    subTitle?: string;
+    important?: boolean;
+    className?: string;
+    titleClassName?: string;
+}
+export declare function InputLabel({ title, subTitle, important, className, titleClassName, }: InputLabelProps): import("react/jsx-runtime").JSX.Element;
+export default InputLabel;

package/components/forms/input-searcher.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+export declare function InputSearcher({ value: initialValue, onChange, debounce, ...props }: {
+    value: string | number;
+    onChange: (value: string | number) => void;
+    debounce?: number;
+} & Omit<React.InputHTMLAttributes<HTMLInputElement>, 'onChange'>): import("react/jsx-runtime").JSX.Element;
+export default InputSearcher;

package/components/forms/input-select.d.ts

@@ -0,0 +1,24 @@
+export type InputSelectOption = {
+    name: string;
+    value: string;
+};
+export interface InputSelectTypes {
+    options: InputSelectOption[];
+    selectedOption?: InputSelectOption;
+    onChange?: React.Dispatch<React.SetStateAction<InputSelectOption>> | ((value: InputSelectOption) => void);
+    children?: React.ReactNode;
+    onSelect?: (value: string) => void;
+    variant?: 'ghost' | 'solid' | 'transparent';
+    className?: string;
+    disabled?: boolean;
+    label?: string;
+    useUppercaseLabel?: boolean;
+    required?: boolean;
+    value?: string;
+    name?: string;
+    errorMessage?: string;
+    helperText?: string;
+    placeholder?: string;
+}
+export declare function InputSelect({ options, onChange, onSelect, variant, selectedOption: propSelectedOption, className, children, disabled, label, useUppercaseLabel, required, value, name, errorMessage, helperText, placeholder, }: InputSelectTypes): import("react/jsx-runtime").JSX.Element;
+export default InputSelect;

package/components/forms/input-switch.d.ts

@@ -0,0 +1,13 @@
+import { default as React } from 'react';
+export interface InputSwitchProps {
+    label?: string;
+    offLabel?: string;
+    onLabel?: string;
+    checked: boolean;
+    onChange: (checked: boolean) => void;
+    className?: string;
+    errorMessage?: string;
+    helperText?: string;
+}
+export declare const InputSwitch: React.FC<InputSwitchProps>;
+export default InputSwitch;

package/components/forms/input.d.ts

@@ -0,0 +1,14 @@
+export type InputProps = React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement> & {
+    label?: string;
+    error?: string;
+    className?: string;
+    inputClassName?: string;
+    labelClassName?: string;
+    useUppercaseLabel?: boolean;
+    helperText?: string;
+    suffix?: React.ReactNode;
+    suffixClassName?: string;
+    icon?: React.ReactNode;
+};
+export declare const Input: import('react').ForwardRefExoticComponent<Omit<InputProps, "ref"> & import('react').RefAttributes<HTMLInputElement>>;
+export default Input;

package/components/forms/pin-code.d.ts

@@ -0,0 +1,97 @@
+import { default as React } from 'react';
+declare const inputClasses: {
+    base: string;
+    error: string;
+    size: {
+        sm: string;
+        DEFAULT: string;
+        lg: string;
+        xl: string;
+    };
+    rounded: {
+        none: string;
+        sm: string;
+        DEFAULT: string;
+        lg: string;
+        full: string;
+    };
+    variant: {
+        active: {
+            base: string;
+            color: {
+                DEFAULT: string;
+                primary: string;
+                secondary: string;
+                danger: string;
+                info: string;
+                success: string;
+                warning: string;
+            };
+        };
+        flat: {
+            base: string;
+            color: {
+                DEFAULT: string;
+                primary: string;
+                secondary: string;
+                danger: string;
+                info: string;
+                success: string;
+                warning: string;
+            };
+        };
+        outline: {
+            base: string;
+            color: {
+                DEFAULT: string;
+                primary: string;
+                secondary: string;
+                danger: string;
+                info: string;
+                success: string;
+                warning: string;
+            };
+        };
+    };
+};
+export interface PinCodeProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'size' | 'type' | 'onChange'> {
+    /** Current value of the pin code */
+    value?: string;
+    /** Callback function called when pin code changes */
+    onChange?: (value: string) => void;
+    /** This Pin Code component only support these two types */
+    type?: 'text' | 'number';
+    /** Mask and unmask to hide and show pin code */
+    mask?: boolean;
+    /** Set pin code length */
+    length?: number;
+    /** Make pin code horizontally center */
+    center?: boolean;
+    /** Set placeholder text */
+    placeholder?: string;
+    /** The size of the component. `"sm"` is equivalent to the dense input styling. */
+    size?: keyof typeof inputClasses.size;
+    /** The rounded variants are: */
+    rounded?: keyof typeof inputClasses.rounded;
+    /** The variants of the component are: */
+    variant?: keyof typeof inputClasses.variant;
+    /** Change input color */
+    color?: keyof (typeof inputClasses.variant)['active']['color'];
+    /** Show error message using this prop */
+    error?: string;
+    /** Add custom classes for the input filed extra style */
+    inputClassName?: string;
+    /** This prop allows you to customize the error message style */
+    errorClassName?: string;
+    /** This prop allows you to add a helper text to the pin code component */
+    helperText?: string;
+    /** This prop allows you to add a helper text to the pin code component */
+    helperTextClassName?: string;
+}
+/**
+ * A basic widget for getting pin code. Here is the API documentation of the Pin Code component.
+ * And the rest of the props of PinCode are the same as the original html input field.
+ * You can use props like `disabled`, `placeholder`, `defaultValue` etc.
+ */
+export declare function PinCode({ type, value, onChange, mask, length, center, size, rounded, variant, color, placeholder, error, className, inputClassName, errorClassName, helperText, helperTextClassName, ...props }: PinCodeProps): import("react/jsx-runtime").JSX.Element;
+export default PinCode;

package/components/forms/radio-group.d.ts

@@ -0,0 +1,56 @@
+import { default as React } from 'react';
+import { RadioProps } from './radio';
+export interface RadioGroupProps {
+    /** Set field value */
+    value?: string | number;
+    /** Set default value for uncontrolled radio group */
+    defaultValue?: string | number;
+    /** The variants of the component are: */
+    variant?: RadioProps['variant'];
+    /** The size of the component. `"sm"` is equivalent to the dense input styling. */
+    size?: RadioProps['size'];
+    /** Change radio button color */
+    color?: RadioProps['color'];
+    /** Available directions of the label are: */
+    labelPlacement?: RadioProps['labelPlacement'];
+    /** Whether the radio group is disabled */
+    disabled?: boolean;
+    /** Set field label */
+    label?: React.ReactNode;
+    /** Show error message using this prop */
+    error?: string;
+    /** Add helper text. It could be string or a React component */
+    helperText?: React.ReactNode;
+    /** Use className prop to apply style for entire component */
+    className?: string;
+    /** Use containerClassName prop to apply some additional style for radio group container */
+    containerClassName?: string;
+    /** Use labelClassName prop to apply some addition style for the field label */
+    labelClassName?: string;
+    /** This prop allows you to customize the error message style */
+    errorClassName?: string;
+    /** This prop allows you to customize the helper message style */
+    helperClassName?: string;
+    /** Layout direction for radio options */
+    direction?: 'vertical' | 'horizontal';
+    /** Gap between radio options */
+    gap?: 'sm' | 'md' | 'lg' | 'xl';
+    /** Radio options */
+    options?: Array<{
+        name?: string;
+        label: React.ReactNode;
+        value: string | number;
+        disabled?: boolean;
+        [key: string]: any;
+    }>;
+    /** Children radio components */
+    children?: React.ReactNode;
+    /** onChange callback function */
+    onChange?: (value: string | number) => void;
+}
+/**
+ * A group of radio components that allows users to select one option from a set.
+ * RadioGroup can be used with either the options prop or with Radio components as children.
+ */
+export declare const RadioGroup: React.ForwardRefExoticComponent<RadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+export default RadioGroup;

package/components/forms/radio.d.ts

@@ -0,0 +1,87 @@
+import { default as React } from 'react';
+declare const inputClasses: {
+    base: string;
+    size: {
+        sm: string;
+        DEFAULT: string;
+        lg: string;
+        xl: string;
+    };
+    variant: {
+        outline: {
+            base: string;
+            color: {
+                DEFAULT: string;
+                primary: string;
+                secondary: string;
+                danger: string;
+                info: string;
+                success: string;
+                warning: string;
+            };
+        };
+        flat: {
+            base: string;
+            color: {
+                DEFAULT: string;
+                primary: string;
+                secondary: string;
+                danger: string;
+                info: string;
+                success: string;
+                warning: string;
+            };
+        };
+        active: {
+            base: string;
+            color: {
+                DEFAULT: string;
+                primary: string;
+                secondary: string;
+                danger: string;
+                info: string;
+                success: string;
+                warning: string;
+            };
+        };
+    };
+};
+export interface RadioProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'size'> {
+    /** The variants of the component are: */
+    variant?: keyof typeof inputClasses.variant;
+    /** The size of the component. `"sm"` is equivalent to the dense input styling. */
+    size?: keyof typeof inputClasses.size;
+    /** Change radio button color */
+    color?: keyof (typeof inputClasses.variant)['outline']['color'];
+    /** Available directions of the label are: */
+    labelPlacement?: 'start' | 'end';
+    /** Whether the input is disabled */
+    disabled?: boolean;
+    /** Set field label */
+    label?: React.ReactNode;
+    /** Show error message using this prop */
+    error?: string;
+    /** Add helper text. It could be string or a React component */
+    helperText?: React.ReactNode;
+    /** Use className prop to apply style for entire component */
+    className?: string;
+    /** Use activeClassName prop to apply style on active component from radioGroup */
+    activeClassName?: string;
+    /** Use containerClassName prop to apply some additional style for label and radio container */
+    containerClassName?: string;
+    /** Use labelClassName prop to apply some addition style for the field label */
+    labelClassName?: string;
+    /** Add custom classes for the input filed extra style */
+    inputClassName?: string;
+    /** This prop allows you to customize the error message style */
+    errorClassName?: string;
+    /** This prop allows you to customize the helper message style */
+    helperClassName?: string;
+}
+/**
+ * A basic widget for getting the user input of radio. Here is the API documentation of the Radio component.
+ * And the rest of the props of Checkbox are the same as the original html input field.
+ * You can use props like `value`, `disabled`, `onChange`, `onFocus`, `onBlur` etc.
+ */
+export declare const Radio: React.ForwardRefExoticComponent<RadioProps & React.RefAttributes<HTMLInputElement>>;
+export default Radio;

package/components/forms/textarea.d.ts

@@ -0,0 +1,10 @@
+export type TextareaProps = React.DetailedHTMLProps<React.TextareaHTMLAttributes<HTMLTextAreaElement>, HTMLTextAreaElement> & {
+    label?: string;
+    error?: string;
+    className?: string;
+    inputClassName?: string;
+    useUppercaseLabel?: boolean;
+    helperText?: string;
+};
+export declare const Textarea: import('react').ForwardRefExoticComponent<Omit<TextareaProps, "ref"> & import('react').RefAttributes<HTMLTextAreaElement>>;
+export default Textarea;

package/components/forms/toggle-bar.d.ts

@@ -0,0 +1,9 @@
+export interface ToggleBarProps {
+    title: string;
+    subTitle?: string;
+    icon?: React.ReactNode;
+    checked: boolean;
+    onChange: () => void;
+}
+export declare function ToggleBar({ title, subTitle, icon, checked, onChange, children, }: React.PropsWithChildren<ToggleBarProps>): import("react/jsx-runtime").JSX.Element;
+export default ToggleBar;

package/components/forms/uploader-two.d.ts

@@ -0,0 +1,44 @@
+import { ForwardedRef } from 'react';
+import { DropzoneRootProps, DropzoneInputProps } from 'react-dropzone';
+export declare const acceptedFileType: {
+    img: string;
+    pdf: string;
+    csv: string;
+    imgAndPdf: string;
+    all: string;
+};
+export interface UploadProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'accept' | 'children'> {
+    /** Specify type of the files */
+    accept: 'img' | 'pdf' | 'csv' | 'imgAndPdf' | 'all';
+    /** Pass multiple files */
+    multiple?: boolean;
+    /** Whether disable upload */
+    disabled?: boolean;
+    /** Pass children to customize file item style */
+    children?: React.ReactNode;
+    /** Pass field label */
+    label?: React.ReactNode;
+    /** Set your custom text to show in upload field */
+    placeholderText?: React.ReactNode;
+    /** To pass getRootProps of react-dropzone */
+    dropzoneRootProps?: DropzoneRootProps;
+    /** To pass getInputProps of react-dropzone */
+    dropzoneInputProps?: DropzoneInputProps;
+    /** Pass wrapperClassName to style the container */
+    wrapperClassName?: string;
+    /** Pass className to style the container */
+    className?: string;
+    /** Pass label className to style label */
+    labelClassName?: string;
+    /** Pass dropzoneRootClassName to style the container */
+    dropzoneRootClassName?: string;
+}
+/** Upload component allows user to upload files either from file explorer or by dragging and dropping.
+ * Here is the API documentation of Upload component. Rest of the props are same as html input field.
+ * You can use props like `disabled`, `multiple`, `capture` etc.
+ */
+export declare function Upload({ accept, children, label, dropzoneRootProps, dropzoneInputProps, placeholderText, dropzoneRootClassName, wrapperClassName, labelClassName, ...props }: React.PropsWithChildren<UploadProps>, ref: ForwardedRef<HTMLInputElement>): import("react/jsx-runtime").JSX.Element;
+declare const _default: import('react').ForwardRefExoticComponent<UploadProps & {
+    children?: import('react').ReactNode | undefined;
+} & import('react').RefAttributes<HTMLInputElement>>;
+export default _default;

package/components/forms/uploader.d.ts

@@ -0,0 +1,2 @@
+export declare function Uploader(): import("react/jsx-runtime").JSX.Element;
+export default Uploader;

package/components/icons/arrow-link-icon.d.ts

@@ -0,0 +1 @@
+export declare function ArrowLinkIcon(props: React.SVGAttributes<SVGElement>): import("react/jsx-runtime").JSX.Element;

package/components/icons/arrow-right.d.ts

@@ -0,0 +1 @@
+export declare function ArrowRight(props: React.SVGAttributes<SVGElement>): import("react/jsx-runtime").JSX.Element;

package/components/icons/arrow-up.d.ts

@@ -0,0 +1 @@
+export declare const ArrowUp: React.FC<React.SVGAttributes<SVGElement>>;

package/components/icons/bitcoin.d.ts

@@ -0,0 +1 @@
+export declare function Bitcoin(props: React.SVGAttributes<SVGElement>): import("react/jsx-runtime").JSX.Element;

package/components/icons/bnb.d.ts

@@ -0,0 +1 @@
+export declare function Bnb(props: React.SVGAttributes<SVGElement>): import("react/jsx-runtime").JSX.Element;

package/components/icons/book.d.ts

@@ -0,0 +1 @@
+export declare function BookIcon(props: React.SVGAttributes<SVGElement>): import("react/jsx-runtime").JSX.Element;

package/components/icons/brands/facebook.d.ts

@@ -0,0 +1 @@
+export declare function Facebook(props: React.SVGAttributes<SVGElement>): import("react/jsx-runtime").JSX.Element;

package/components/icons/brands/github.d.ts

@@ -0,0 +1 @@
+export declare function Github(props: React.SVGAttributes<SVGElement>): import("react/jsx-runtime").JSX.Element;