@povio/ui 0.0.1

package/src/components/inputs/Input/TextInput/TextInput.d.ts

@@ -0,0 +1,19 @@
+import { Ref } from 'react';
+import { AriaTextFieldProps } from 'react-aria';
+import { InputProps as AriaInputProps } from 'react-aria-components';
+import { FieldValues } from 'react-hook-form';
+import { FormFieldProps } from '#ui/components/inputs/FormField/FormField';
+import { InputContentProps } from '#ui/components/inputs/Input/shared/InputContent';
+import { ControlProps } from '#ui/components/inputs/shared/form.types';
+import { InputVariantProps } from '#ui/components/inputs/shared/input.cva';
+type AllowedHTMLInputTypeAttribute = "email" | "hidden" | "tel" | "text" | "url";
+interface TextInputBaseProps extends FormFieldProps, InputVariantProps, Omit<InputContentProps, "ref" | "value" | "onChange">, Omit<AriaInputProps, "value" | "defaultValue" | "onChange" | "disabled" | "required" | "type" | "size" | "className" | keyof AriaTextFieldProps>, Omit<AriaTextFieldProps<HTMLInputElement>, "label"> {
+    ref?: Ref<HTMLInputElement>;
+    inputClassName?: string;
+    type?: AllowedHTMLInputTypeAttribute;
+}
+export interface TextInputProps extends TextInputBaseProps {
+}
+export type ControlledTextInputProps<TFieldValues extends FieldValues> = ControlProps<TextInputProps, TFieldValues>;
+export declare const TextInput: <TFieldValues extends FieldValues>(props: ControlledTextInputProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/src/components/inputs/Input/shared/InputContent.d.ts

@@ -0,0 +1,27 @@
+import { CSSProperties, FC, ReactElement, ReactNode, SVGProps } from 'react';
+import { InlineIconButtonProps } from '#ui/components/buttons/InlineIconButton/InlineIconButton';
+import { FormFieldHeaderProps } from '#ui/components/inputs/FormField/FormFieldHeader';
+import { InputVariantProps } from '#ui/components/inputs/shared/input.cva';
+export interface InputContentProps {
+    className?: string;
+    unit?: string;
+    isLoading?: boolean;
+    isDisabled?: boolean;
+    action?: {
+        icon: InlineIconButtonProps["icon"];
+        onClick: () => void;
+        altText: string;
+        className?: string;
+    };
+    leadingIcon?: FC<SVGProps<SVGSVGElement>> | ReactElement;
+    trailingIcon?: FC<SVGProps<SVGSVGElement>> | ReactElement;
+    isClearable?: boolean;
+    value?: string;
+    onChange?: (value: string) => void;
+    headerProps?: FormFieldHeaderProps;
+}
+interface InputContentComponentProps extends InputContentProps, InputVariantProps {
+    children: (style: CSSProperties) => ReactNode;
+}
+export declare const InputContent: ({ leadingIcon: LeadingIcon, trailingIcon: TrailingIcon, unit, isLoading, isDisabled, action, isClearable, value, onChange, children, headerProps, as, size, }: InputContentComponentProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/src/components/inputs/Inputs/Form.d.ts

@@ -0,0 +1,26 @@
+import { ReactNode } from 'react';
+import { SubmitErrorHandler, SubmitHandler, UseFormReturn } from 'react-hook-form';
+import { z } from 'zod';
+import { InputComponentProps, InputDefBaseProps } from '#ui/components/inputs/Inputs/InputItem';
+import { AllowedComponentType, DefaultComponentType } from '#ui/helpers/dynamicInputs';
+type Capitalize<T extends string> = T extends `${infer First}${infer Rest}` ? `${Uppercase<First>}${Rest}` : T;
+type FieldProps<TProps = {}> = {
+    label: string;
+    placeholder?: string;
+} & TProps;
+type FieldComponentProps<TSchema extends z.ZodObject<any>, K extends keyof z.infer<TSchema>, T extends AllowedComponentType<TSchema["shape"][K]> | undefined = undefined> = FieldProps<InputDefBaseProps<InputComponentProps<T extends AllowedComponentType<TSchema["shape"][K]> ? T : DefaultComponentType<TSchema["shape"][K]>>>> & {
+    inputType?: T extends AllowedComponentType<TSchema["shape"][K]> ? T : never;
+};
+type FieldComponents<TSchema extends z.ZodObject<any>> = {
+    [K in keyof Required<z.infer<TSchema>> as Capitalize<K & string>]: <T extends AllowedComponentType<TSchema["shape"][K]> | undefined = undefined>(props: FieldComponentProps<TSchema, K, T>) => ReactNode;
+};
+interface FormProps<TSchema extends z.ZodObject<any>, TSchemaType extends Record<string, any> = z.infer<TSchema>> {
+    form: UseFormReturn<TSchemaType>;
+    schema: TSchema;
+    onSubmit: SubmitHandler<TSchemaType>;
+    onError?: SubmitErrorHandler<TSchemaType>;
+    className?: string;
+    children: (components: FieldComponents<TSchema>) => ReactNode;
+}
+export declare function Form<TSchema extends z.ZodObject<any>>({ form, schema, onSubmit, onError, className, children, }: FormProps<TSchema>): import("react/jsx-runtime").JSX.Element;
+export {};

package/src/components/inputs/Inputs/InputItem.d.ts

@@ -0,0 +1,73 @@
+import { ComponentProps, JSXElementConstructor, ReactElement, ReactNode } from 'react';
+import { Control, UseFormReturn } from 'react-hook-form';
+import { z } from 'zod';
+import { HasRequiredProperty } from '#ui/types/common';
+declare const componentRegistry: {
+    readonly toggle: <TFieldValues extends import('react-hook-form').FieldValues>(props: import('#ui/components/inputs/Toggle/Toggle').ControlledToggleProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
+    readonly checkbox: <TFieldValues extends import('react-hook-form').FieldValues>(props: import('#ui/components/inputs/Checkbox/Checkbox').ControlledCheckboxProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
+    readonly numberInput: <TFieldValues extends import('react-hook-form').FieldValues>(props: import('#ui/components/inputs/Input/NumberInput/NumberInput').ControlledNumberInputProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
+    readonly slider: <TFieldValues extends import('react-hook-form').FieldValues, IsRange extends boolean = false>(props: import('#ui/components/inputs/Slider/Slider').ControlledSliderProps<TFieldValues, IsRange>) => import("react/jsx-runtime").JSX.Element;
+    readonly textInput: <TFieldValues extends import('react-hook-form').FieldValues>(props: import('#ui/components/inputs/Input/TextInput/TextInput').ControlledTextInputProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
+    readonly passwordInput: <TFieldValues extends import('react-hook-form').FieldValues>(props: import('#ui/components/inputs/Input/PasswordInput/PasswordInput').ControlledPasswordInputProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
+    readonly textArea: <TFieldValues extends import('react-hook-form').FieldValues>(props: import('#ui/components/inputs/Input/TextArea/TextArea').ControlledTextAreaProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
+    readonly select: <TFieldValues extends import('react-hook-form').FieldValues, TKey extends import('react-aria').Key = import('react-aria').Key, TInitialSelectItem = import('../Selection/shared/select.types').DefaultInitialSelectItem<TKey>>(props: import('#ui/components/inputs/Selection/Select/Select').ControlledSelectProps<TFieldValues, TKey, TInitialSelectItem>) => import("react/jsx-runtime").JSX.Element;
+    readonly autocomplete: <TFieldValues extends import('react-hook-form').FieldValues, TKey extends import('react-aria').Key = import('react-aria').Key, TInitialSelectItem = import('../Selection/shared/select.types').DefaultInitialSelectItem<TKey>>(props: import('#ui/components/inputs/Selection/Autocomplete/Autocomplete').ControlledAutocompleteProps<TFieldValues, TKey, TInitialSelectItem>) => import("react/jsx-runtime").JSX.Element;
+    readonly queryAutocomplete: <TFieldValues extends import('react-hook-form').FieldValues, TSelectItem extends import('../Selection/shared/select.types').SelectItem<any>, TQueryFn extends (...args: any) => import('@tanstack/react-query').UseQueryResult<TSelectItem[]>>({ query, queryParams, queryOptions, ...props }: import('#ui/types/common').OmitDiscriminatedUnion<import('#ui/components/inputs/Selection/Autocomplete/Autocomplete').AutocompleteProps<Exclude<ReturnType<TQueryFn>["data"], undefined>[0] extends {
+        id: infer InferredKey extends import('react-aria').Key;
+    } ? InferredKey : never>, "onChange" | "value" | "isLoading" | "items" | "selectionMode" | "showSelectionBar" | "showSelectAllOption" | "initialSelection" | "showSelectionContent" | "onSearchChange"> & (import('../Selection/shared/select.types').GroupedSelectControlProps<TFieldValues, Exclude<ReturnType<TQueryFn>["data"], undefined>[0] extends {
+        id: infer InferredKey extends import('react-aria').Key;
+    } ? InferredKey : never> & {
+        query: Parameters<TQueryFn>[0] extends {
+            search?: string;
+        } ? TQueryFn : never;
+        queryParams?: Omit<Parameters<TQueryFn>[0], "search"> | undefined;
+        queryOptions?: Parameters<TQueryFn>[1] | undefined;
+    })) => import("react/jsx-runtime").JSX.Element;
+    readonly segment: <TFieldValues extends import('react-hook-form').FieldValues, TKey extends import('react-aria').Key = import('react-aria').Key>(props: import('../../..').ControlledSegmentProps<TFieldValues, TKey>) => import("react/jsx-runtime").JSX.Element;
+    readonly datePicker: <TFieldValues extends import('react-hook-form').FieldValues>({ fullIso, minValue, maxValue, ...props }: import('#ui/components/inputs/DateTime/DatePicker/DatePicker').ControlledDatePickerProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
+    readonly dateTimePicker: <TFieldValues extends import('react-hook-form').FieldValues>({ fullIso, ...props }: import('#ui/components/inputs/DateTime/DateTimePicker/DateTimePicker').ControlledDateTimePickerProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
+    readonly timePicker: <TFieldValues extends import('react-hook-form').FieldValues>(props: import('#ui/components/inputs/DateTime/TimePicker/TimePicker').ControlledTimePickerProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
+    readonly dateRangePicker: <TFieldValues extends import('react-hook-form').FieldValues>({ fullIso, minValue, maxValue, ...props }: import('#ui/components/inputs/DateTime/DateRangePicker/DateRangePicker').ControlledDateRangePickerProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
+    readonly textEditor: <TFieldValues extends import('react-hook-form').FieldValues>(props: import('#ui/components/inputs/TextEditor/TextEditor').ControlledTextEditorProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
+    readonly unknown: null;
+};
+export type InputComponentRegistry = typeof componentRegistry;
+export type InputComponentType = keyof InputComponentRegistry;
+interface InputItemProps<TSchema extends z.ZodObject<any>, TSchemaType extends Record<string, any> = z.infer<TSchema>> {
+    form: UseFormReturn<TSchemaType>;
+    inputDef: InputDef<TSchemaType>;
+}
+export type InputDef<TSchemaType extends Record<string, any>> = {
+    [T in InputComponentType]: T extends "unknown" ? never : {
+        [K in keyof TSchemaType]: TypeBasedInputDef<TSchemaType, T, K> | RenderBasedInputDef<TSchemaType, K>;
+    }[keyof TSchemaType];
+}[InputComponentType];
+type TypeBasedInputDef<TSchemaType extends Record<string, any>, T extends InputComponentType, K extends keyof TSchemaType> = {
+    type: T;
+    name: K;
+    label: string;
+    placeholder?: string;
+    inputWrapper?: InputWrapperType;
+    render?: never;
+} & (HasRequiredProperty<InputDefBaseProps<InputComponentProps<T>>> extends true ? {
+    props?: InputDefBaseProps<InputComponentProps<T>>;
+} : {
+    props: InputDefBaseProps<InputComponentProps<T>>;
+});
+interface RenderBasedInputDef<TSchemaType extends Record<string, any>, K extends keyof TSchemaType> {
+    type?: never;
+    name: K;
+    label?: never;
+    placeholder?: never;
+    props?: never;
+    inputWrapper?: never;
+    render: (formControl: {
+        control: Control<TSchemaType>;
+        name: K;
+    }, form: UseFormReturn<TSchemaType>) => ReactElement;
+}
+export type InputWrapperType = (children: ReactNode, label: string) => ReactElement;
+export type InputComponentProps<T extends InputComponentType> = InputComponentRegistry[T] extends keyof React.JSX.IntrinsicElements | JSXElementConstructor<any> ? ComponentProps<InputComponentRegistry[T]> : null;
+export type InputDefBaseProps<TProps> = Omit<TProps, "formControl" | "label" | "placeholder" | "children">;
+export declare function InputItem<TSchema extends z.ZodObject<any>, TSchemaType extends Record<string, any> = z.infer<TSchema>>({ form, inputDef }: InputItemProps<TSchema, TSchemaType>): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/src/components/inputs/Inputs/Inputs.d.ts

@@ -0,0 +1,10 @@
+import { ReactNode } from 'react';
+import { UseFormReturn } from 'react-hook-form';
+import { z } from 'zod';
+import { InputDef } from './InputItem';
+export interface InputsProps<TSchema extends z.ZodObject<any>, TSchemaType extends Record<string, any> = z.infer<TSchema>> {
+    form: UseFormReturn<TSchemaType>;
+    inputDefs: Array<InputDef<TSchemaType>>;
+    children?: (inputs: Record<keyof TSchemaType, ReactNode>) => ReactNode;
+}
+export declare function Inputs<TSchema extends z.ZodObject<any>, TSchemaType extends Record<string, any> = z.infer<TSchema>>({ form, inputDefs, children, }: InputsProps<TSchema, TSchemaType>): 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> | import("react/jsx-runtime").JSX.Element[] | null | undefined;

package/src/components/inputs/RadioGroup/RadioGroup.d.ts

@@ -0,0 +1,18 @@
+import { ReactElement, Ref } from 'react';
+import { RadioGroupProps as AriaRadioGroupProps } from 'react-aria-components';
+import { FieldValues } from 'react-hook-form';
+import { FormFieldProps } from '#ui/components/inputs/FormField/FormField';
+import { RadioVariantProps } from '#ui/components/inputs/RadioGroup/radio.cva';
+import { ControlProps } from '#ui/components/inputs/shared/form.types';
+interface RadioGroupBaseProps extends Omit<FormFieldProps, "variant">, RadioVariantProps, Omit<AriaRadioGroupProps, "className"> {
+    ref?: Ref<HTMLDivElement>;
+    options: {
+        label: string | ReactElement;
+        value: string;
+    }[];
+}
+export interface RadioGroupProps extends RadioGroupBaseProps {
+}
+export type ControlledRadioGroupProps<TFieldValues extends FieldValues> = ControlProps<RadioGroupProps, TFieldValues>;
+export declare const RadioGroup: <TFieldValues extends FieldValues>(props: ControlledRadioGroupProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/src/components/inputs/RadioGroup/radio.cva.d.ts

@@ -0,0 +1,11 @@
+import { VariantProps } from 'class-variance-authority';
+import { TypographyVariantProps } from '#ui/components/text/Typography/typography.cva';
+export declare const radio: (props?: ({
+    variant?: "default" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface RadioVariantProps extends VariantProps<typeof radio> {
+}
+export declare const radioIndicatorClass = "group flex items-center gap-2";
+export declare const radioTypography: (props: {
+    variant?: "default" | null | undefined;
+}) => TypographyVariantProps | undefined;

package/src/components/inputs/Selection/Autocomplete/Autocomplete.d.ts

@@ -0,0 +1,8 @@
+import { Key } from 'react-aria-components';
+import { FieldValues } from 'react-hook-form';
+import { SelectBaseProps } from '#ui/components/inputs/Selection/shared/SelectBase';
+import { DefaultInitialSelectItem, GroupedSelectControlProps, GroupedSelectProps } from '#ui/components/inputs/Selection/shared/select.types';
+import { OmitDiscriminatedUnion } from '#ui/types/common';
+export type AutocompleteProps<TKey extends Key = Key, TInitialSelectItem = DefaultInitialSelectItem<TKey>> = OmitDiscriminatedUnion<SelectBaseProps<TKey, TInitialSelectItem>, "isSearchable">;
+export type ControlledAutocompleteProps<TFieldValues extends FieldValues, TKey extends Key = Key, TInitialSelectItem = DefaultInitialSelectItem<TKey>> = Omit<AutocompleteProps<TKey, TInitialSelectItem>, keyof GroupedSelectProps> & GroupedSelectControlProps<TFieldValues, TKey, TInitialSelectItem>;
+export declare const Autocomplete: <TFieldValues extends FieldValues, TKey extends Key = Key, TInitialSelectItem = DefaultInitialSelectItem<TKey>>(props: ControlledAutocompleteProps<TFieldValues, TKey, TInitialSelectItem>) => import("react/jsx-runtime").JSX.Element;

package/src/components/inputs/Selection/Autocomplete/QueryAutocomplete.d.ts

@@ -0,0 +1,19 @@
+import { UseQueryResult } from '@tanstack/react-query';
+import { Key } from 'react-aria-components';
+import { FieldValues } from 'react-hook-form';
+import { AutocompleteProps } from '#ui/components/inputs/Selection/Autocomplete/Autocomplete';
+import { GroupedSelectControlProps, GroupedSelectProps, SelectItem } from '#ui/components/inputs/Selection/shared/select.types';
+import { OmitDiscriminatedUnion } from '#ui/types/common';
+type QueryFn<TSelectItem extends SelectItem = SelectItem> = (...args: any) => UseQueryResult<Array<TSelectItem>>;
+type TKey<TQueryFn extends QueryFn> = Exclude<ReturnType<TQueryFn>["data"], undefined>[0] extends {
+    id: infer InferredKey extends Key;
+} ? InferredKey : never;
+type QueryAutocompleteProps<TFieldValues extends FieldValues, TSelectItem extends SelectItem<any>, TQueryFn extends QueryFn<TSelectItem>> = OmitDiscriminatedUnion<AutocompleteProps<TKey<TQueryFn>>, "items" | "onSearchChange" | "isLoading" | keyof GroupedSelectProps> & GroupedSelectControlProps<TFieldValues, TKey<TQueryFn>> & {
+    query: Parameters<TQueryFn>[0] extends {
+        search?: string;
+    } ? TQueryFn : never;
+    queryParams?: Omit<Parameters<TQueryFn>[0], "search">;
+    queryOptions?: Parameters<TQueryFn>[1];
+};
+export declare const QueryAutocomplete: <TFieldValues extends FieldValues, TSelectItem extends SelectItem<any>, TQueryFn extends QueryFn<TSelectItem>>({ query, queryParams, queryOptions, ...props }: QueryAutocompleteProps<TFieldValues, TSelectItem, TQueryFn>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/src/components/inputs/Selection/Select/Select.d.ts

@@ -0,0 +1,8 @@
+import { Key } from 'react-aria-components';
+import { FieldValues } from 'react-hook-form';
+import { SelectBaseProps } from '#ui/components/inputs/Selection/shared/SelectBase';
+import { DefaultInitialSelectItem, GroupedSelectControlProps, GroupedSelectProps, SelectAsyncProps } from '#ui/components/inputs/Selection/shared/select.types';
+import { OmitDiscriminatedUnion } from '#ui/types/common';
+export type SelectProps<TKey extends Key = Key, TInitialSelectItem = DefaultInitialSelectItem<TKey>> = OmitDiscriminatedUnion<SelectBaseProps<TKey, TInitialSelectItem>, "initialSelection" | "mapInitialToSelectItem" | keyof SelectAsyncProps>;
+export type ControlledSelectProps<TFieldValues extends FieldValues, TKey extends Key = Key, TInitialSelectItem = DefaultInitialSelectItem<TKey>> = Omit<SelectProps<TKey, TInitialSelectItem>, keyof GroupedSelectProps> & GroupedSelectControlProps<TFieldValues, TKey>;
+export declare const Select: <TFieldValues extends FieldValues, TKey extends Key = Key, TInitialSelectItem = DefaultInitialSelectItem<TKey>>(props: ControlledSelectProps<TFieldValues, TKey, TInitialSelectItem>) => import("react/jsx-runtime").JSX.Element;

package/src/components/inputs/Selection/shared/SelectBase.d.ts

@@ -0,0 +1,24 @@
+import { ReactElement, Ref } from 'react';
+import { AriaButtonProps } from 'react-aria';
+import { Key } from 'react-aria-components';
+import { FormFieldProps } from '#ui/components/inputs/FormField/FormField';
+import { DefaultInitialSelectItem, GroupedSelectProps, SelectAsyncProps, SelectItem, SelectNewItemProps } from '#ui/components/inputs/Selection/shared/select.types';
+import { InputVariantProps } from '#ui/components/inputs/shared/input.cva';
+export type SelectBaseProps<TKey extends Key = Key, TInitialSelectItem = DefaultInitialSelectItem<TKey>> = FormFieldProps & GroupedSelectProps<TKey, TInitialSelectItem> & SelectNewItemProps & SelectAsyncProps & InputVariantProps & Pick<AriaButtonProps, "onBlur"> & {
+    ref?: Ref<HTMLDivElement>;
+    className?: string;
+    placeholder?: string;
+    hideDropdownIcon?: boolean;
+    isSearchable?: boolean;
+    isClearable?: boolean;
+    isClientSearchDisabled?: boolean;
+    ignoreTriggerWidth?: boolean;
+    items: SelectItem<TKey>[];
+    inputClassName?: string;
+    containerClassName?: string;
+    customTrigger?: ReactElement;
+    onInputChange?: (value: string) => void;
+    onSearchChange?: (value: string) => void;
+    mapInitialToSelectItem?: (item: TInitialSelectItem) => SelectItem<TKey>;
+};
+export declare const SelectBase: <TKey extends Key = Key, TInitialSelectItem = DefaultInitialSelectItem<TKey>>(dProps: SelectBaseProps<TKey, TInitialSelectItem>) => import("react/jsx-runtime").JSX.Element;

package/src/components/inputs/Selection/shared/SelectDesktop.d.ts

@@ -0,0 +1,5 @@
+import { Key } from 'react-aria-components';
+import { SelectBaseProps } from '#ui/components/inputs/Selection/shared/SelectBase';
+type SelectDesktopProps<TKey extends Key = Key> = SelectBaseProps<TKey>;
+export declare const SelectDesktop: <TKey extends Key = Key>({ ref, error, ignoreTriggerWidth, showSelectionContent, inputClassName, containerClassName, customTrigger, onBlur, ...props }: SelectDesktopProps<TKey>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/src/components/inputs/Selection/shared/SelectInput.d.ts

@@ -0,0 +1,15 @@
+import { AriaFieldProps } from 'react-aria';
+import { ComboBoxState } from 'react-stately';
+import { FormFieldHeaderProps } from '#ui/components/inputs/FormField/FormFieldHeader';
+import { SelectBaseProps } from '#ui/components/inputs/Selection/shared/SelectBase';
+import { SelectItem } from '#ui/components/inputs/Selection/shared/select.types';
+import { InputVariantProps } from '#ui/components/inputs/shared/input.cva';
+interface SelectInputProps extends InputVariantProps, Pick<SelectBaseProps, "ref" | "placeholder" | "isDisabled" | "hideDropdownIcon" | "isSearchable" | "isClearable" | "onBlur" | "showSelectionContent" | "inputClassName"> {
+    isInvalid?: boolean;
+    className?: string;
+    fieldProps?: AriaFieldProps;
+    headerProps?: FormFieldHeaderProps;
+    onCloseComboBox?: (state: ComboBoxState<SelectItem> | null) => void;
+}
+export declare const SelectInput: ({ ref, placeholder, variant, as, size, isDisabled, isInvalid, className, hideDropdownIcon, isSearchable, isClearable, showSelectionContent, inputClassName, fieldProps, headerProps, onCloseComboBox, onBlur, ...props }: SelectInputProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/src/components/inputs/Selection/shared/SelectListBox.d.ts

@@ -0,0 +1,9 @@
+import { AriaListBoxProps } from 'react-aria';
+import { SelectBaseProps } from '#ui/components/inputs/Selection/shared/SelectBase';
+import { SelectItem } from '#ui/components/inputs/Selection/shared/select.types';
+export interface SelectListBoxProps extends Pick<SelectBaseProps, "label" | "newItemRender" | "onLoadMore" | "selectionMode" | "isSearchable">, Omit<AriaListBoxProps<SelectItem>, "children" | "aria-label" | "selectionMode" | "items" | "selectedKeys" | "onSelectionChange" | "escapeKeyBehavior" | "shouldSelectOnPressUp" | "label"> {
+    className?: string;
+    isScrollable?: boolean;
+    onClose?: () => void;
+}
+export declare const SelectListBox: ({ label, selectionMode, isSearchable, isScrollable, newItemRender, onLoadMore, className, onClose, ...props }: SelectListBoxProps) => import("react/jsx-runtime").JSX.Element;

package/src/components/inputs/Selection/shared/SelectListBoxItem.d.ts

@@ -0,0 +1,8 @@
+import { SelectBaseProps } from '#ui/components/inputs/Selection/shared/SelectBase';
+import { SelectItem } from '#ui/components/inputs/Selection/shared/select.types';
+interface SelectListBoxItemProps extends Pick<SelectBaseProps, "isSearchable" | "newItemRender">, SelectItem {
+    isNewItem?: boolean;
+}
+export declare const SelectListBoxItem: ({ isSearchable, isNewItem, newItemRender, id, label, content, isDisabled, }: SelectListBoxItemProps) => import("react/jsx-runtime").JSX.Element;
+export declare const selectListBoxItemClass: string;
+export {};

package/src/components/inputs/Selection/shared/SelectListBoxItemSelectAll.d.ts

@@ -0,0 +1,4 @@
+import { SelectItem } from '#ui/components/inputs/Selection/shared/select.types';
+type SelectListBoxItemSelectAllProps = SelectItem;
+export declare const SelectListBoxItemSelectAll: ({ id, label, isDisabled }: SelectListBoxItemSelectAllProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/src/components/inputs/Selection/shared/SelectListBoxLoadingItem.d.ts

@@ -0,0 +1,6 @@
+import { SelectItem } from '#ui/components/inputs/Selection/shared/select.types';
+interface SelectListBoxLoadingItemProps extends Omit<SelectItem, "isDisabled"> {
+    onLoadMore?: () => void;
+}
+export declare const SelectListBoxLoadingItem: ({ id, label, onLoadMore }: SelectListBoxLoadingItemProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/src/components/inputs/Selection/shared/SelectListBoxSelectionBar.d.ts

@@ -0,0 +1,5 @@
+interface SelectListBoxSelectionBarProps {
+    className?: string;
+}
+export declare const SelectListBoxSelectionBar: ({ className }: SelectListBoxSelectionBarProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/src/components/inputs/Selection/shared/SelectMobile.d.ts

@@ -0,0 +1,5 @@
+import { Key } from 'react-aria-components';
+import { SelectBaseProps } from '#ui/components/inputs/Selection/shared/SelectBase';
+type SelectMobileProps<TKey extends Key = Key> = SelectBaseProps<TKey>;
+export declare const SelectMobile: <TKey extends Key = Key>({ ref, error, showSelectionContent, inputClassName, containerClassName, customTrigger, onBlur, ...props }: SelectMobileProps<TKey>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/src/components/inputs/Selection/shared/select.context.d.ts

@@ -0,0 +1,30 @@
+import { PropsWithChildren } from 'react';
+import { Key } from 'react-aria-components';
+import { SelectBaseProps } from '#ui/components/inputs/Selection/shared/SelectBase';
+import { ExtendedSelectItem, GroupedSelectProps, SelectItem } from '#ui/components/inputs/Selection/shared/select.types';
+export declare namespace SelectContext {
+    interface FieldState {
+        value: Key | Key[] | null;
+        inputValue: string;
+        searchValue: string;
+    }
+    export type Type = {
+        fieldState: FieldState;
+        isOpen: boolean;
+        setIsOpen: (isOpen: boolean) => void;
+        isDebouncing: boolean;
+        onChange: (val: Key | Key[]) => void;
+        onClear: () => void;
+        onSelectAll: () => void;
+        onRemove: (val: Key) => void;
+        listItems: ExtendedSelectItem[];
+        selectableListItems: SelectItem[];
+        selectedItems: SelectItem[];
+        selectedIds: Key[];
+        isMultiple: boolean;
+    } & Pick<SelectBaseProps, "onInputChange" | "isLoading" | "hasLoadMore">;
+    export type ProviderProps = GroupedSelectProps & Pick<SelectBaseProps, "items" | "onInputChange" | "onSearchChange" | "showSelectAllOption" | "showNewItemOption" | "newItemMinLength" | "onNewItemOption" | "isLoading" | "hasLoadMore" | "mapInitialToSelectItem" | "isSearchable" | "isClientSearchDisabled">;
+    export const Provider: ({ items, onInputChange, onSearchChange, showSelectAllOption, showNewItemOption, newItemMinLength, onNewItemOption, isLoading, hasLoadMore, isClientSearchDisabled, children, mapInitialToSelectItem, ...props }: PropsWithChildren<ProviderProps>) => import("react/jsx-runtime").JSX.Element;
+    export const useSelect: () => Type;
+    export {};
+}

package/src/components/inputs/Selection/shared/select.types.d.ts

@@ -0,0 +1,55 @@
+import { ReactElement } from 'react';
+import { Key } from 'react-aria-components';
+import { FieldValues } from 'react-hook-form';
+import { ControlProps } from '#ui/components/inputs/shared/form.types';
+export interface SelectItem<TKey extends Key = Key> {
+    id: TKey;
+    label: string;
+    content?: string | ReactElement;
+    isDisabled?: boolean;
+}
+export interface ExtendedSelectItem<TKey extends Key = Key> extends SelectItem<TKey> {
+    isNewItem?: boolean;
+    isSelectAllItem?: boolean;
+    isLoadingItem?: boolean;
+}
+export interface DefaultInitialSelectItem<TKey extends Key = Key> {
+    id: TKey;
+    label?: string;
+    name?: string;
+}
+export interface SingleSelectProps<TKey extends Key = Key, TInitialSelectItem = DefaultInitialSelectItem<TKey>> {
+    selectionMode?: "single";
+    value?: TKey | undefined | null;
+    onChange?: (value: TKey | null) => void;
+    showSelectionBar?: never;
+    showSelectAllOption?: never;
+    initialSelection?: TInitialSelectItem | null;
+    showSelectionContent?: boolean;
+}
+export interface MultiSelectProps<TKey extends Key = Key, TInitialSelectItem = DefaultInitialSelectItem<TKey>> {
+    selectionMode: "multiple";
+    value?: TKey[];
+    onChange?: (value: TKey[]) => void;
+    showSelectionBar?: boolean;
+    showSelectAllOption?: boolean;
+    initialSelection?: TInitialSelectItem[] | null;
+    showSelectionContent?: never;
+}
+export type GroupedSelectProps<TKey extends Key = Key, TInitialSelectItem = DefaultInitialSelectItem<TKey>> = MultiSelectProps<TKey, TInitialSelectItem> | SingleSelectProps<TKey, TInitialSelectItem>;
+export type GroupedSelectControlProps<TFieldValues extends FieldValues, TKey extends Key = Key, TInitialSelectItem = DefaultInitialSelectItem<TKey>> = ({
+    selectionMode: MultiSelectProps["selectionMode"];
+} & ControlProps<MultiSelectProps<TKey, TInitialSelectItem>, TFieldValues>) | ({
+    selectionMode?: SingleSelectProps["selectionMode"];
+} & ControlProps<SingleSelectProps<TKey, TInitialSelectItem>, TFieldValues>);
+export interface SelectNewItemProps {
+    showNewItemOption?: boolean;
+    newItemMinLength?: number;
+    onNewItemOption?: (value: string) => void;
+    newItemRender?: (label: string) => ReactElement;
+}
+export interface SelectAsyncProps {
+    isLoading?: boolean;
+    hasLoadMore?: boolean;
+    onLoadMore?: () => void;
+}

package/src/components/inputs/Selection/shared/useSelectItems.d.ts

@@ -0,0 +1,23 @@
+import { Key } from 'react-aria-components';
+import { SelectBaseProps } from '#ui/components/inputs/Selection/shared/SelectBase';
+import { ExtendedSelectItem, SelectItem } from '#ui/components/inputs/Selection/shared/select.types';
+export declare const SelectAllItemId = "all-item-id";
+export declare const NewItemId = "new-item-id";
+export declare const LoadingItemId = "loading-item-id";
+export declare const ReservedItemIds: string[];
+interface UseSelectItemsProps extends Pick<SelectBaseProps, "showSelectAllOption" | "showNewItemOption" | "newItemMinLength" | "isLoading" | "hasLoadMore" | "isClientSearchDisabled"> {
+    initialSelectedItems?: SelectItem[] | SelectItem | null;
+    selectedItems?: SelectItem[] | SelectItem | null;
+    cachedItems: SelectItem[];
+    inputValue: string;
+    showAll: boolean;
+    isMultiple: boolean;
+}
+export declare function useSelectItems({ initialSelectedItems, selectedItems, cachedItems, inputValue, showAll, isMultiple, showSelectAllOption, showNewItemOption, newItemMinLength, isLoading, hasLoadMore, isClientSearchDisabled, }: UseSelectItemsProps): {
+    allItems: SelectItem<Key>[];
+    allListItems: ExtendedSelectItem<Key>[];
+    filteredListItems: ExtendedSelectItem<Key>[];
+    listItems: ExtendedSelectItem<Key>[];
+    selectableListItems: ExtendedSelectItem<Key>[];
+};
+export {};

package/src/components/inputs/Slider/Slider.d.ts

@@ -0,0 +1,18 @@
+import { Ref } from 'react';
+import { SliderProps as AriaSliderProps } from 'react-aria-components';
+import { FieldValues } from 'react-hook-form';
+import { FormFieldProps } from '#ui/components/inputs/FormField/FormField';
+import { ControlProps } from '#ui/components/inputs/shared/form.types';
+type SliderValue<IsRange extends boolean = false> = IsRange extends false ? number : number[];
+interface SliderBaseProps<IsRange extends boolean = false> extends FormFieldProps, Omit<AriaSliderProps, "value" | "defaultValue" | "onChange" | "className"> {
+    ref?: Ref<HTMLDivElement>;
+    unit?: string;
+    isRange?: IsRange;
+    defaultValue?: SliderValue<IsRange>;
+    value?: SliderValue<IsRange>;
+    onChange?: (value: SliderValue<IsRange>) => void;
+}
+export type SliderProps<IsRange extends boolean = false> = SliderBaseProps<IsRange>;
+export type ControlledSliderProps<TFieldValues extends FieldValues, IsRange extends boolean = false> = ControlProps<SliderProps<IsRange>, TFieldValues>;
+export declare const Slider: <TFieldValues extends FieldValues, IsRange extends boolean = false>(props: ControlledSliderProps<TFieldValues, IsRange>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/src/components/inputs/TextEditor/TextEditor.d.ts

@@ -0,0 +1,20 @@
+import { JSONContent } from '@tiptap/react';
+import { Ref } from 'react';
+import { FieldValues } from 'react-hook-form';
+import { FormFieldProps } from '#ui/components/inputs/FormField/FormField';
+import { ControlProps } from '#ui/components/inputs/shared/form.types';
+export interface TextEditorValue {
+    html?: string | null;
+    json?: JSONContent | null;
+}
+export interface TextEditorBaseProps extends FormFieldProps {
+    ref?: Ref<HTMLDivElement>;
+    placeholder?: string;
+    value?: TextEditorValue | null;
+    onChange?: (value: TextEditorValue | null) => void;
+    onBlur?: () => void;
+    as?: "default" | "filter" | "floating" | "inline" | null;
+}
+export type TextEditorProps = TextEditorBaseProps;
+export type ControlledTextEditorProps<TFieldValues extends FieldValues> = ControlProps<TextEditorProps, TFieldValues>;
+export declare const TextEditor: <TFieldValues extends FieldValues>(props: ControlledTextEditorProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;

package/src/components/inputs/TextEditor/Toolbar/ColorPicker.d.ts

@@ -0,0 +1,7 @@
+interface ColorPickerProps {
+    colors: string[];
+    value: string | undefined;
+    onChange: (value: string) => void;
+}
+export declare const ColorPicker: ({ colors, value, onChange }: ColorPickerProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/src/components/inputs/TextEditor/Toolbar/ColorPickerDropdown.d.ts

@@ -0,0 +1,10 @@
+import { ReactElement } from 'react';
+interface ColorPickerDropdownProps {
+    colors: string[];
+    value: string | undefined;
+    onChange: (color: string) => void;
+    isDisabled?: boolean;
+    children: ReactElement;
+}
+export declare const ColorPickerDropdown: ({ colors, value, onChange, isDisabled, children }: ColorPickerDropdownProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/src/components/inputs/TextEditor/Toolbar/HyperlinkAction.d.ts

@@ -0,0 +1,2 @@
+import { TextEditorSharedProps } from '#ui/components/inputs/TextEditor/textEditor.types';
+export declare const HyperlinkAction: ({ editor }: TextEditorSharedProps) => import("react/jsx-runtime").JSX.Element | null;

package/src/components/inputs/TextEditor/Toolbar/TextAlignSelect.d.ts

@@ -0,0 +1,2 @@
+import { TextEditorSharedProps } from '#ui/components/inputs/TextEditor/textEditor.types';
+export declare const TextAlignSelect: ({ editor }: TextEditorSharedProps) => import("react/jsx-runtime").JSX.Element | null;

package/src/components/inputs/TextEditor/Toolbar/TextColorSelect.d.ts

@@ -0,0 +1,2 @@
+import { TextEditorSharedProps } from '#ui/components/inputs/TextEditor/textEditor.types';
+export declare const TextColorSelect: ({ editor }: TextEditorSharedProps) => import("react/jsx-runtime").JSX.Element | null;

package/src/components/inputs/TextEditor/Toolbar/TextEditorToolbar.d.ts

@@ -0,0 +1,6 @@
+import { Editor } from '@tiptap/react';
+interface Props {
+    editor: Editor | null;
+}
+export declare const TextEditorToolbar: ({ editor }: Props) => import("react/jsx-runtime").JSX.Element | null;
+export {};

package/src/components/inputs/TextEditor/Toolbar/TextHighlightSelect.d.ts

@@ -0,0 +1,2 @@
+import { TextEditorSharedProps } from '#ui/components/inputs/TextEditor/textEditor.types';
+export declare const TextHighlightSelect: ({ editor }: TextEditorSharedProps) => import("react/jsx-runtime").JSX.Element | null;

package/src/components/inputs/TextEditor/Toolbar/TextListActions.d.ts

@@ -0,0 +1,2 @@
+import { TextEditorSharedProps } from '#ui/components/inputs/TextEditor/textEditor.types';
+export declare const TextListActions: ({ editor }: TextEditorSharedProps) => import("react/jsx-runtime").JSX.Element | null;

package/src/components/inputs/TextEditor/Toolbar/TextMarksActions.d.ts

@@ -0,0 +1,2 @@
+import { TextEditorSharedProps } from '#ui/components/inputs/TextEditor/textEditor.types';
+export declare const TextMarksActions: ({ editor }: TextEditorSharedProps) => import("react/jsx-runtime").JSX.Element | null;

package/src/components/inputs/TextEditor/Toolbar/TextStyleSelect.d.ts

@@ -0,0 +1,2 @@
+import { TextEditorSharedProps } from '#ui/components/inputs/TextEditor/textEditor.types';
+export declare const TextStyleSelect: ({ editor }: TextEditorSharedProps) => import("react/jsx-runtime").JSX.Element | null;

package/src/components/inputs/TextEditor/textEditor.types.d.ts

@@ -0,0 +1,5 @@
+import { Editor } from '@tiptap/react';
+export interface TextEditorSharedProps {
+    editor: Editor;
+}
+export declare const defaultColors: string[];

package/src/components/inputs/Toggle/Toggle.d.ts

@@ -0,0 +1,14 @@
+import { Ref } from 'react';
+import { SwitchProps as AriaSwitchProps } from 'react-aria-components';
+import { FieldValues } from 'react-hook-form';
+import { FormFieldErrorProps } from '#ui/components/inputs/FormField/FormFieldError';
+import { ControlProps } from '#ui/components/inputs/shared/form.types';
+import { ToggleVariantProps } from '#ui/components/inputs/Toggle/toggle.cva';
+interface ToggleBaseProps extends FormFieldErrorProps, ToggleVariantProps, Omit<AriaSwitchProps, "className"> {
+    ref?: Ref<HTMLLabelElement>;
+    children?: string;
+}
+export type ToggleProps = ToggleBaseProps;
+export type ControlledToggleProps<TFieldValues extends FieldValues> = ControlProps<ToggleProps, TFieldValues, "isSelected">;
+export declare const Toggle: <TFieldValues extends FieldValues>(props: ControlledToggleProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/src/components/inputs/Toggle/toggle.cva.d.ts

@@ -0,0 +1,10 @@
+import { VariantProps } from 'class-variance-authority';
+import { TypographyVariantProps } from '#ui/components/text/Typography/typography.cva';
+export declare const toggle: (props?: ({
+    variant?: "default" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface ToggleVariantProps extends VariantProps<typeof toggle> {
+}
+export declare const toggleTypography: (props: {
+    variant?: "default" | null | undefined;
+}) => TypographyVariantProps | undefined;

package/src/components/inputs/shared/CheckContent.d.ts

@@ -0,0 +1,7 @@
+import { PropsWithChildren } from 'react';
+import { TypographyVariantProps } from '#ui/components/text/Typography/typography.cva';
+interface CheckContentProps {
+    typography?: TypographyVariantProps;
+}
+export declare const CheckContent: ({ children, ...props }: PropsWithChildren<CheckContentProps>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/src/components/inputs/shared/InputClear.d.ts

@@ -0,0 +1,6 @@
+interface InputClearProps {
+    onClear: () => void;
+    className?: string;
+}
+export declare const InputClear: ({ onClear, className }: InputClearProps) => import("react/jsx-runtime").JSX.Element;
+export {};