@tempots/beatui 0.16.0 → 0.18.0

package/dist/types/components/form/input/color-input.d.ts

@@ -1,2 +1,9 @@
+import { Value } from '@tempots/dom';
 import { InputOptions } from './input-options';
-export declare const ColorInput: (options: InputOptions<string>) => import("@tempots/dom").Renderable;
+export type ColorInputOptions = InputOptions<string> & {
+    displayValue?: Value<boolean>;
+    size?: Value<number>;
+    withAlpha?: Value<boolean>;
+    colorTextFormat?: Value<'hex' | 'rgb' | 'hsl' | 'hwb' | 'oklch'>;
+};
+export declare const ColorInput: (options: ColorInputOptions) => import("@tempots/dom").Renderable;

package/dist/types/components/form/input/combobox-input.d.ts

@@ -0,0 +1,16 @@
+import { Merge, Renderable, Signal, TNode, Value } from '@tempots/dom';
+import { InputOptions } from './input-options';
+import { BaseControllerOptions, ControllerOptions } from '../control';
+import { DropdownOption } from './option';
+export type ComboboxOptions<T> = Merge<InputOptions<T>, {
+    loadOptions: (search: string) => Promise<DropdownOption<T>[]>;
+    renderOption: (value: Signal<T>) => TNode;
+    renderValue?: (value: Signal<T>) => TNode;
+    equality?: (a: T, b: T) => boolean;
+    placeholder?: Value<string>;
+    searchPlaceholder?: Value<string>;
+    debounceMs?: number;
+}>;
+export declare const ComboboxInput: <T>(options: ComboboxOptions<T>) => Renderable;
+export declare const BaseComboboxControl: <T>(options: BaseControllerOptions<T, ComboboxOptions<T>>) => Renderable;
+export declare const ComboboxControl: <T>(options: ControllerOptions<T, ComboboxOptions<T>>) => Renderable;

package/dist/types/components/form/input/combobox-tags-input.d.ts

@@ -0,0 +1,16 @@
+import { TNode, Value } from '@tempots/dom';
+import { InputOptions } from './input-options';
+import { DropdownOption } from './option';
+import { BaseControllerOptions, ControllerOptions } from '../control';
+export type ComboboxTagsOptions<T> = {
+    options: Value<DropdownOption<T>[]>;
+    equality?: (a: T, b: T) => boolean;
+    placeholder?: Value<string>;
+    searchPlaceholder?: Value<string>;
+    filter?: (q: string, opt: {
+        label: string;
+    }) => boolean;
+} & InputOptions<T[]>;
+export declare function ComboboxTagsInput<T>(options: ComboboxTagsOptions<T>): import("@tempots/dom").Renderable;
+export declare function BaseComboboxTagsControl<T>(options: BaseControllerOptions<T[], ComboboxTagsOptions<T>>): TNode;
+export declare function ComboboxTagsControl<T>(options: ControllerOptions<T[], ComboboxTagsOptions<T>>): import("@tempots/dom").Renderable;

package/dist/types/components/form/input/dropdown-base.d.ts

@@ -0,0 +1,19 @@
+import { Signal, TNode, Value } from '@tempots/dom';
+import { InputOptions } from './input-options';
+import { DropdownOption } from './option';
+export type DropdownBaseOptions<T> = InputOptions<T> & {
+    role: 'combobox' | 'dropdown';
+    display: TNode;
+    optionsSource: Value<DropdownOption<T>[]>;
+    allowSpaceToggle?: Value<boolean>;
+    onBeforeOpen?: () => void;
+    onAfterOpen?: () => void;
+    buildListboxContent: (ctx: {
+        dropdownId: string;
+        listboxId: string;
+        focusedValue: Signal<T | null>;
+        handleKeyDown: (ev: KeyboardEvent) => void;
+        onSelect: (value: T) => void;
+    }) => TNode;
+};
+export declare const DropdownBase: <T>(options: DropdownBaseOptions<T>) => import("@tempots/dom").Renderable;

package/dist/types/components/form/input/dropdown-input.d.ts

@@ -0,0 +1,14 @@
+import { Renderable, Value, Merge } from '@tempots/dom';
+import { InputOptions } from './input-options';
+import { BaseControllerOptions, ControllerOptions } from '../control';
+import { DropdownOption } from './option';
+export type DropdownOptions<T> = Merge<InputOptions<T>, {
+    options: Value<DropdownOption<T>[]>;
+    unselectedLabel?: Value<string>;
+    equality?: (a: T, b: T) => boolean;
+    placeholder?: Value<string>;
+    searchable?: Value<boolean>;
+}>;
+export declare const DropdownInput: <T>(options: DropdownOptions<T>) => Renderable;
+export declare const BaseDropdownControl: <T>(options: BaseControllerOptions<T, DropdownOptions<T>>) => Renderable;
+export declare const DropdownControl: <T>(options: ControllerOptions<T, DropdownOptions<T>>) => Renderable;

package/dist/types/components/form/input/duration-input.d.ts

@@ -0,0 +1,3 @@
+import { InputOptions } from './input-options';
+import { Duration } from '@/temporal';
+export declare const DurationInput: (options: InputOptions<Duration>) => import("@tempots/dom").Renderable;

package/dist/types/components/form/input/duration-mask.d.ts

@@ -0,0 +1,12 @@
+export declare const DURATION_PARTIAL_RE: RegExp;
+export declare const DURATION_FULL_RE: RegExp;
+export declare function durationMaskConfig(parse: (s: string) => unknown): {
+    mask: null;
+    allowMode: "custom";
+    allow: (c: string) => boolean;
+    pipe: (conformed: string) => string | false;
+    completion: {
+        mode: "custom";
+        isComplete: (conformed: string) => boolean;
+    };
+};

package/dist/types/components/form/input/editable-text.d.ts

@@ -4,5 +4,6 @@ export type EditableTextOptions = {
     onChange: (value: string) => void;
     placeholder?: Value<string>;
     startEditing?: Value<boolean>;
+    disabled?: Value<boolean>;
 };
-export declare const EditableText: ({ startEditing, value, onChange, placeholder, }: EditableTextOptions) => Renderable;
+export declare const EditableText: ({ startEditing, value, onChange, placeholder, disabled, }: EditableTextOptions) => Renderable;

package/dist/types/components/form/input/file-input.d.ts

@@ -1,11 +1,11 @@
 import { Value } from '@tempots/dom';
 import { InputOptions } from './input-options';
 import { Merge } from '@tempots/std';
-export type FileInputOptions = Merge<InputOptions<File[]>, {
+import { FileInputMode } from './files-input';
+export type FileInputOptions = Merge<InputOptions<File | undefined>, {
     accept?: Value<string>;
-    allowMultiple?: Value<boolean>;
-    maxFiles?: Value<number>;
     maxFileSize?: Value<number>;
+    mode?: Value<FileInputMode>;
     showFileList?: Value<boolean>;
 }>;
 export declare const FileInput: (options: FileInputOptions) => import("@tempots/dom").Renderable;

package/dist/types/components/form/input/files-input.d.ts

@@ -0,0 +1,12 @@
+import { Value, TNode } from '@tempots/dom';
+import { InputOptions } from './input-options';
+import { Merge } from '@tempots/std';
+export type FileInputMode = 'default' | 'compact';
+export type FilesInputOptions = Merge<InputOptions<File[]>, {
+    accept?: Value<string>;
+    maxFiles?: Value<number>;
+    maxFileSize?: Value<number>;
+    mode?: Value<FileInputMode>;
+    showFileList?: Value<boolean>;
+}>;
+export declare const FilesInput: (options: FilesInputOptions, ...children: TNode[]) => import("@tempots/dom").Renderable;

package/dist/types/components/form/input/index.d.ts

@@ -1,24 +1,64 @@
 export * from './appearance-selector';
+export * from './base64-input';
+export * from './base64s-input';
 export * from './checkbox-input';
 export * from './color-input';
-export * from './combobox';
+export * from './dropdown-input';
+export * from './dropdown-base';
+export * from './combobox-input';
+export * from './select-tags-input';
+export * from './combobox-tags-input';
 export * from './date-input';
 export * from './date-time-input';
 export * from './editable-text';
 export * from './email-input';
 export * from './file-input';
+export * from './files-input';
 export * from './input-container';
 export * from './input-options';
 export * from './input-wrapper';
 export * from './lazy-native-select';
+export * from './list-input';
+export * from './mask-input';
 export * from './native-select';
 export * from './nullable-date-input';
 export * from './nullable-date-time-input';
+export * from './nullable-email-input';
+export * from './nullable-mask-input';
+export * from './nullable-password-input';
 export * from './nullable-text-area';
 export * from './nullable-text-input';
 export * from './number-input';
+export * from './nullable-number-input';
+export * from './option';
+export * from './bigint-input';
+export * from './nullable-bigint-input';
 export * from './password-input';
+export * from './segmented-input';
+export * from './switch';
 export * from './tags-input';
 export * from './text-area';
 export * from './text-input';
-export * from './switch';
+export * from './uuid-input';
+export * from './nullable-uuid-input';
+export * from './rating-input';
+export * from './nullable-rating-input';
+export * from './slider-input';
+export * from './plain-date-input';
+export * from './nullable-plain-date-input';
+export * from './plain-time-input';
+export * from './nullable-plain-time-input';
+export * from './plain-date-time-input';
+export * from './nullable-plain-date-time-input';
+export * from './instant-input';
+export * from './nullable-instant-input';
+export * from './zoned-date-time-input';
+export * from './nullable-zoned-date-time-input';
+export * from './plain-year-month-input';
+export * from './nullable-plain-year-month-input';
+export * from './plain-month-day-input';
+export * from './nullable-plain-month-day-input';
+export * from './duration-input';
+export * from './nullable-duration-input';
+export * from './url-input';
+export * from './nullable-url-input';

package/dist/types/components/form/input/input-container.d.ts

@@ -1,6 +1,5 @@
 import { TNode, Value } from '@tempots/dom';
-export declare const InputContainer: ({ baseContainer, child, disabled, input, before, after, hasError, focusableSelector, growInput, }: {
-    child?: TNode;
+export declare const InputContainer: ({ baseContainer, disabled, input, before, after, hasError, focusableSelector, growInput, }: {
     disabled?: Value<boolean>;
     input: TNode;
     before?: TNode;
@@ -9,4 +8,4 @@ export declare const InputContainer: ({ baseContainer, child, disabled, input, b
     focusableSelector?: string;
     growInput?: Value<boolean>;
     baseContainer?: Value<boolean>;
-}) => import("@tempots/dom").Renderable;
+}, ...children: TNode[]) => import("@tempots/dom").Renderable;

package/dist/types/components/form/input/input-options.d.ts

@@ -1,6 +1,5 @@
 import { TNode, Value } from '@tempots/dom';
 import { Merge } from '@tempots/std';
-import { Controller } from '../controller/controller';
 export type CommonInputOptions = {
     autocomplete?: Value<string>;
     autofocus?: Value<boolean>;
@@ -21,15 +20,3 @@ export type InputOptions<V> = Merge<CommonInputOptions, {
     onBlur?: () => void;
 }>;
 export declare const CommonInputAttributes: ({ autocomplete, autofocus, class: cls, disabled, name, placeholder, id, required, hasError, }: CommonInputOptions) => import("@tempots/dom").Renderable<import("@tempots/dom").DOMContext>;
-export declare const inputOptionsFromController: <T>(controller: Controller<T>) => {
-    id: string;
-    disabled: import("@tempots/dom").Signal<boolean>;
-    value: import("@tempots/dom").Signal<T>;
-    hasError: import("@tempots/dom").Signal<boolean>;
-};
-export declare const inputOptionsFromMappedController: <T, U>(controller: Controller<U>, map: (value: U) => T) => {
-    value: import("@tempots/dom").Computed<T>;
-    id: string;
-    disabled: import("@tempots/dom").Signal<boolean>;
-    hasError: import("@tempots/dom").Signal<boolean>;
-};

package/dist/types/components/form/input/input-wrapper.d.ts

@@ -4,7 +4,7 @@ export type InputWrapperOptions = {
     label?: TNode;
     context?: TNode;
     description?: TNode;
-    error?: Value<TNode | null>;
+    error?: TNode;
     required?: Value<boolean>;
     content: TNode;
     labelFor?: Value<string>;

package/dist/types/components/form/input/instant-input.d.ts

@@ -0,0 +1,3 @@
+import { InputOptions } from './input-options';
+import { Instant } from '@/temporal';
+export declare const InstantInput: (options: InputOptions<Instant>) => import("@tempots/dom").Renderable;

package/dist/types/components/form/input/lazy-native-select.d.ts

@@ -1,6 +1,6 @@
 import { Signal, Value } from '@tempots/dom';
 import { InputOptions } from './input-options';
-import { SelectOption } from './native-select';
+import { SelectOption } from './option';
 export type LazyNativeSelectOptions<T, R> = InputOptions<T> & {
     request: Signal<R>;
     load: (options: {

package/dist/types/components/form/input/list-input.d.ts

@@ -0,0 +1,14 @@
+import { ElementPosition, Signal, TNode } from '@tempots/dom';
+import { ArrayController, Controller } from '../controller/controller';
+export type ListInputPayload<T> = {
+    list: ArrayController<T[]>;
+    item: Controller<T>;
+    position: ElementPosition;
+    remove: () => void;
+    move: (direction: MoveDirection) => void;
+    canMove: (direction: MovableDirection) => Signal<boolean>;
+    cannotMove: (direction: MovableDirection) => Signal<boolean>;
+};
+export type MoveDirection = 'up' | 'down' | 'first' | 'last';
+export type MovableDirection = 'up' | 'down';
+export declare function ListInput<T>(controller: ArrayController<T[]>, element: (payload: ListInputPayload<T>) => TNode, separator?: (pos: ElementPosition) => TNode): import("@tempots/dom").Renderable<import("@tempots/dom").DOMContext>;

package/dist/types/components/form/input/mask-input.d.ts

@@ -0,0 +1,94 @@
+import { Value, Renderable } from '@tempots/dom';
+import { Merge } from '@tempots/std';
+import { InputOptions } from './input-options';
+export type MaskToken = {
+    type: 'literal';
+    char: string;
+} | {
+    type: 'pattern';
+    name?: string;
+    pattern: RegExp;
+    optional?: boolean;
+    transform?: (char: string) => string;
+} | {
+    type: 'any';
+    optional?: boolean;
+    transform?: (char: string) => string;
+};
+export type Mask = string | Array<string | RegExp | MaskToken> | null;
+export interface PipeMeta {
+    raw: string;
+    previousConformed: string;
+    cursor: number;
+    completed: boolean;
+}
+export type PipeResult = string | {
+    value: string;
+    cursor?: number;
+} | false;
+export interface UnmaskOptions {
+    strategy?: 'none' | 'strip' | 'custom';
+    unmask?: (conformed: string) => string;
+}
+export interface CompletionOptions {
+    mode?: 'mask' | 'min' | 'custom';
+    minChars?: number;
+    isComplete?: (conformed: string) => boolean;
+}
+export interface CursorBehavior {
+    policy?: 'smart' | 'sticky';
+    backspaceRubberBand?: boolean;
+}
+export interface PlaceholderOptions {
+    guide?: boolean;
+    placeholderChar?: string;
+    keepCharPositions?: boolean;
+}
+export interface MaskDictionary {
+    [symbol: string]: {
+        pattern: RegExp;
+        optional?: boolean;
+        transform?: (char: string) => string;
+    };
+}
+export type DynamicMask = (raw: string, meta: PipeMeta) => Mask;
+export interface MaskedInputOptions {
+    value?: string;
+    defaultValue?: string;
+    mask: Value<Mask | DynamicMask>;
+    definitions?: Value<MaskDictionary>;
+    useDefaultDefinitions?: Value<boolean>;
+    placeholder?: Value<string>;
+    placeholderOptions?: Value<PlaceholderOptions>;
+    extraLiterals?: Value<string[]>;
+    prefix?: Value<string>;
+    suffix?: Value<string>;
+    autofix?: Value<'none' | 'pad' | 'truncate'>;
+    autoclear?: Value<boolean>;
+    cursor?: Value<CursorBehavior>;
+    pipe?: (conformed: string, meta: PipeMeta) => PipeResult;
+    completion?: Value<CompletionOptions>;
+    unmask?: Value<UnmaskOptions>;
+    allowMode?: Value<'all' | 'digits' | 'letters' | 'alphanumeric' | 'custom'>;
+    allow?: (char: string) => boolean;
+    maxLengthHard?: Value<number>;
+    debounceMs?: Value<number>;
+    compositionSafe?: Value<boolean>;
+    onAccept?: (next: {
+        raw: string;
+        conformed: string;
+        completed: boolean;
+        cursor: number;
+        numericParsed?: number;
+    }) => void;
+    onComplete?: (finalValue: {
+        raw: string;
+        conformed: string;
+        numericParsed?: number;
+    }) => void;
+}
+export type MaskInputOptions = Merge<InputOptions<string>, Omit<MaskedInputOptions, 'value' | 'defaultValue' | 'onAccept' | 'onComplete'> & {
+    onAccept?: MaskedInputOptions['onAccept'];
+    onComplete?: MaskedInputOptions['onComplete'];
+}>;
+export declare const MaskInput: (options: MaskInputOptions) => Renderable;

package/dist/types/components/form/input/native-select.d.ts

@@ -1,31 +1,12 @@
 import { Renderable, Value } from '@tempots/dom';
 import { InputOptions } from './input-options';
-export type ValueOption<T> = {
-    type: 'value';
-    value: T;
-    label: string;
-    disabled?: boolean;
-};
-export type GroupOption<T> = {
-    type: 'group';
-    group: string;
-    options: ValueOption<T>[];
-    disabled?: boolean;
-};
-export type BreakOption = {
-    type: 'break';
-};
-export type SelectOption<T> = ValueOption<T> | GroupOption<T> | BreakOption;
-export declare const SelectOption: {
-    value: <T>(value: T, label: string, disabled?: boolean) => ValueOption<T>;
-    group: <T>(group: string, options: (ValueOption<T> | BreakOption)[], disabled?: boolean) => GroupOption<T>;
-    break: BreakOption;
-    getOptionValues: <T>(options: SelectOption<T>[]) => T[];
-    contains: <T>(options: SelectOption<T>[], value: T, equality?: (a: T, b: T) => boolean) => boolean;
-};
+import { BaseControllerOptions, ControllerOptions } from '../control';
+import { SelectOption } from './option';
 export type NativeSelectOptions<T> = InputOptions<T> & {
     options: Value<SelectOption<T>[]>;
     unselectedLabel?: Value<string>;
     equality?: (a: T, b: T) => boolean;
 };
 export declare const NativeSelect: <T>(options: NativeSelectOptions<T>) => Renderable;
+export declare function BaseNativeSelectControl<T>(options: BaseControllerOptions<T, NativeSelectOptions<T>>): Renderable;
+export declare function NativeSelectControl<T>(options: ControllerOptions<T, NativeSelectOptions<T>>): Renderable;

package/dist/types/components/form/input/nullable-base64-input.d.ts

@@ -0,0 +1,8 @@
+import { Value } from '@tempots/dom';
+import { type Base64InputOptions } from './base64-input';
+export type NullableBase64InputOptions = Omit<Base64InputOptions, 'value' | 'onChange' | 'onInput'> & {
+    value: Value<string | null>;
+    onChange?: (value: string | null) => void;
+    onInput?: (value: string | null) => void;
+};
+export declare const NullableBase64Input: (options: NullableBase64InputOptions) => import("@tempots/dom").Renderable;

package/dist/types/components/form/input/nullable-bigint-input.d.ts

@@ -0,0 +1,9 @@
+import { Value } from '@tempots/dom';
+import { Merge } from '@tempots/std';
+import { InputOptions } from './input-options';
+export type NullableBigintInputOptions = Merge<InputOptions<bigint | null>, {
+    step?: Value<bigint>;
+    min?: Value<bigint>;
+    max?: Value<bigint>;
+}>;
+export declare const NullableBigintInput: (options: NullableBigintInputOptions) => import("@tempots/dom").Renderable;

package/dist/types/components/form/input/nullable-duration-input.d.ts

@@ -0,0 +1,3 @@
+import { InputOptions } from './input-options';
+import type { Duration } from '@/temporal/types';
+export declare const NullableDurationInput: (options: InputOptions<Duration | null>) => import("@tempots/dom").Renderable;

package/dist/types/components/form/input/nullable-email-input.d.ts

@@ -0,0 +1,2 @@
+import { InputOptions } from './input-options';
+export declare const NullableEmailInput: (options: InputOptions<null | string>) => import("@tempots/dom").Renderable;

package/dist/types/components/form/input/nullable-instant-input.d.ts

@@ -0,0 +1,3 @@
+import { InputOptions } from './input-options';
+import { Instant } from '@/temporal';
+export declare const NullableInstantInput: (options: InputOptions<Instant | null>) => import("@tempots/dom").Renderable;

package/dist/types/components/form/input/nullable-mask-input.d.ts

@@ -0,0 +1,5 @@
+import { Merge } from '@tempots/dom';
+import { InputOptions } from './input-options';
+import { MaskInputOptions } from './mask-input';
+export type NullableMaskInputOptions = Merge<InputOptions<null | string>, Omit<MaskInputOptions, 'value' | 'onChange' | 'onInput'>>;
+export declare const NullableMaskInput: (options: NullableMaskInputOptions) => import("@tempots/dom").Renderable;

package/dist/types/components/form/input/nullable-number-input.d.ts

@@ -0,0 +1,9 @@
+import { Value } from '@tempots/dom';
+import { InputOptions } from './input-options';
+import { Merge } from '@tempots/std';
+export type NullableNumberInputOptions = Merge<InputOptions<number | null>, {
+    step?: Value<number>;
+    min?: Value<number>;
+    max?: Value<number>;
+}>;
+export declare const NullableNumberInput: (options: NullableNumberInputOptions) => import("@tempots/dom").Renderable;

package/dist/types/components/form/input/nullable-password-input.d.ts

@@ -0,0 +1,2 @@
+import { InputOptions } from './input-options';
+export declare const NullablePasswordInput: (options: InputOptions<null | string>) => import("@tempots/dom").Renderable;

package/dist/types/components/form/input/nullable-plain-date-input.d.ts

@@ -0,0 +1,3 @@
+import { InputOptions } from './input-options';
+import { PlainDate } from '@/temporal';
+export declare const NullablePlainDateInput: (options: InputOptions<PlainDate | null>) => import("@tempots/dom").Renderable;

package/dist/types/components/form/input/nullable-plain-date-time-input.d.ts

@@ -0,0 +1,3 @@
+import { InputOptions } from './input-options';
+import { PlainDateTime } from '@/temporal';
+export declare const NullablePlainDateTimeInput: (options: InputOptions<PlainDateTime | null>) => import("@tempots/dom").Renderable;

package/dist/types/components/form/input/nullable-plain-month-day-input.d.ts

@@ -0,0 +1,3 @@
+import { InputOptions } from './input-options';
+import { PlainMonthDay } from '@/temporal';
+export declare const NullablePlainMonthDayInput: (options: InputOptions<PlainMonthDay | null>) => import("@tempots/dom").Renderable;

package/dist/types/components/form/input/nullable-plain-time-input.d.ts

@@ -0,0 +1,3 @@
+import { InputOptions } from './input-options';
+import { PlainTime } from '@/temporal';
+export declare const NullablePlainTimeInput: (options: InputOptions<PlainTime | null>) => import("@tempots/dom").Renderable;

package/dist/types/components/form/input/nullable-plain-year-month-input.d.ts

@@ -0,0 +1,3 @@
+import { InputOptions } from './input-options';
+import { PlainYearMonth } from '@/temporal';
+export declare const NullablePlainYearMonthInput: (options: InputOptions<PlainYearMonth | null>) => import("@tempots/dom").Renderable;

package/dist/types/components/form/input/nullable-rating-input.d.ts

@@ -0,0 +1,14 @@
+import { Value } from '@tempots/dom';
+import { InputOptions } from './input-options';
+import { ThemeColorName } from '@/tokens';
+import { ControlSize } from '../../theme/types';
+export type NullableRatingInputOptions = InputOptions<number | null> & {
+    max?: Value<number>;
+    fullColor?: Value<ThemeColorName>;
+    emptyColor?: Value<ThemeColorName>;
+    fullIcon?: Value<string>;
+    emptyIcon?: Value<string>;
+    size?: Value<ControlSize>;
+    rounding?: Value<number>;
+};
+export declare const NullableRatingInput: (options: NullableRatingInputOptions) => import("@tempots/dom").Renderable;

package/dist/types/components/form/input/nullable-url-input.d.ts

@@ -0,0 +1,2 @@
+import { InputOptions } from './input-options';
+export declare const NullableUrlInput: (options: InputOptions<null | string>) => import("@tempots/dom").Renderable;

package/dist/types/components/form/input/nullable-utils.d.ts

@@ -0,0 +1,2 @@
+import { TNode, Value } from '@tempots/dom';
+export declare function NullableResetAfter<V>(value: Value<V | null>, disabled?: Value<boolean>, onChange?: (v: V | null) => void): TNode;

package/dist/types/components/form/input/nullable-uuid-input.d.ts

@@ -0,0 +1,2 @@
+import { InputOptions } from './input-options';
+export declare const NullableUUIDInput: (options: InputOptions<string | null>) => import("@tempots/dom").Renderable;

package/dist/types/components/form/input/nullable-zoned-date-time-input.d.ts

@@ -0,0 +1,3 @@
+import { InputOptions } from './input-options';
+import { ZonedDateTime } from '@/temporal';
+export declare const NullableZonedDateTimeInput: (options: InputOptions<ZonedDateTime | null>) => import("@tempots/dom").Renderable;

package/dist/types/components/form/input/option.d.ts

@@ -0,0 +1,38 @@
+import { TNode } from '@tempots/dom';
+export type ValueOption<T> = {
+    type: 'value';
+    value: T;
+    label: string;
+    disabled?: boolean;
+    before?: TNode;
+    after?: TNode;
+};
+export type GroupOption<T> = {
+    type: 'group';
+    group: string;
+    options: ValueOption<T>[];
+    disabled?: boolean;
+    before?: TNode;
+    after?: TNode;
+};
+export type BreakOption = {
+    type: 'break';
+};
+export type SelectOption<T> = ValueOption<T> | GroupOption<T> | BreakOption;
+export type DropdownOption<T> = ValueOption<T> | GroupOption<T> | BreakOption;
+export type AnyOption<T> = SelectOption<T> | DropdownOption<T>;
+export declare const Option: {
+    value: <T>(value: T, label: string, { disabled, before, after, }?: {
+        disabled?: boolean;
+        before?: TNode;
+        after?: TNode;
+    }) => ValueOption<T>;
+    group: <T>(group: string, options: (ValueOption<T> | BreakOption)[], { disabled, before, after, }?: {
+        disabled?: boolean;
+        before?: TNode;
+        after?: TNode;
+    }) => GroupOption<T>;
+    break: BreakOption;
+    getValues: <T>(options: AnyOption<T>[]) => T[];
+    contains: <T>(options: AnyOption<T>[], value: T, equality?: (a: T, b: T) => boolean) => boolean;
+};

package/dist/types/components/form/input/plain-date-input.d.ts

@@ -0,0 +1,3 @@
+import { InputOptions } from './input-options';
+import { PlainDate } from '@/temporal';
+export declare const PlainDateInput: (options: InputOptions<PlainDate>) => import("@tempots/dom").Renderable;

package/dist/types/components/form/input/plain-date-time-input.d.ts

@@ -0,0 +1,3 @@
+import { InputOptions } from './input-options';
+import { PlainDateTime } from '@/temporal';
+export declare const PlainDateTimeInput: (options: InputOptions<PlainDateTime>) => import("@tempots/dom").Renderable;

package/dist/types/components/form/input/plain-month-day-input.d.ts

@@ -0,0 +1,3 @@
+import { InputOptions } from './input-options';
+import { PlainMonthDay } from '@/temporal';
+export declare const PlainMonthDayInput: (options: InputOptions<PlainMonthDay>) => import("@tempots/dom").Renderable;

package/dist/types/components/form/input/plain-time-input.d.ts

@@ -0,0 +1,3 @@
+import { InputOptions } from './input-options';
+import { PlainTime } from '@/temporal';
+export declare const PlainTimeInput: (options: InputOptions<PlainTime>) => import("@tempots/dom").Renderable;

package/dist/types/components/form/input/plain-year-month-input.d.ts

@@ -0,0 +1,3 @@
+import { InputOptions } from './input-options';
+import { PlainYearMonth } from '@/temporal';
+export declare const PlainYearMonthInput: (options: InputOptions<PlainYearMonth>) => import("@tempots/dom").Renderable;

package/dist/types/components/form/input/rating-input.d.ts

@@ -0,0 +1,15 @@
+import { Value } from '@tempots/dom';
+import { InputOptions } from './input-options';
+import { ThemeColorName } from '@/tokens';
+import { ControlSize } from '../../theme/types';
+type RatingInputOptions = InputOptions<number> & {
+    max?: Value<number>;
+    fullColor?: Value<ThemeColorName>;
+    emptyColor?: Value<ThemeColorName>;
+    fullIcon?: Value<string>;
+    emptyIcon?: Value<string>;
+    size?: Value<ControlSize>;
+    rounding?: Value<number>;
+};
+export declare const RatingInput: (options: RatingInputOptions) => import("@tempots/dom").Renderable;
+export {};

package/dist/types/components/form/input/segmented-input.d.ts

@@ -0,0 +1,10 @@
+import { TNode, Value } from '@tempots/dom';
+import { ControlSize } from '../../theme';
+export interface SegmentedInputOptions<T extends Record<string, TNode>, K extends keyof T = keyof T> {
+    options: T;
+    value: Value<K>;
+    onChange?: (value: K) => void;
+    size?: Value<ControlSize>;
+    disabled?: Value<boolean>;
+}
+export declare function SegmentedInput<T extends Record<string, TNode>>({ options, value, onChange, size, disabled, }: SegmentedInputOptions<T, keyof T>, ...children: TNode[]): import("@tempots/dom").Renderable;