@overmap-ai/forms 1.0.15 → 1.0.17-blank-value-updates.1

package/dist/forms/fields/BaseField/hooks.d.ts

@@ -0,0 +1,394 @@
+import { ValueOfField } from '../../typings';
+import { AnyField, ComponentProps } from '../typings';
+export declare const useFormikInput: <TField extends AnyField>(props: ComponentProps<TField>) => readonly [{
+    readonly helpText: string | null;
+    readonly size: import('@overmap-ai/blocks').TextSize | undefined;
+    readonly severity: "danger" | undefined;
+    readonly inputId: string;
+    readonly labelId: string;
+    readonly label: string;
+    readonly showInputOnly: boolean | undefined;
+    readonly fieldProps: {
+        onChange: (value: ValueOfField<TField> | undefined) => void;
+        onBlur: (value: ValueOfField<TField> | undefined) => void;
+        value: ValueOfField<TField> | undefined;
+        name: string;
+        multiple?: boolean;
+        checked?: boolean;
+    };
+    readonly helpers: import('formik').FieldHelperProps<ValueOfField<TField> | undefined>;
+    readonly field: TField;
+    readonly touched: boolean;
+}, {
+    readonly "aria-labelledby": string;
+    readonly children?: import('react').ReactNode | undefined;
+    readonly form?: string | undefined;
+    readonly label?: string | undefined;
+    readonly span?: number | undefined;
+    readonly cite?: string | undefined;
+    readonly data?: string | undefined;
+    readonly slot?: string | undefined;
+    readonly style?: import('react').CSSProperties | undefined;
+    readonly summary?: string | undefined;
+    readonly title?: string | undefined;
+    readonly pattern?: string | undefined;
+    readonly key?: import('react').Key | null | undefined;
+    readonly disabled?: boolean | undefined;
+    readonly formAction?: string | undefined | ((formData: FormData) => void | Promise<void>) | import('react').DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_FORM_ACTIONS[keyof import('react').DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_FORM_ACTIONS];
+    readonly formEncType?: string | undefined;
+    readonly formMethod?: string | undefined;
+    readonly formNoValidate?: boolean | undefined;
+    readonly formTarget?: string | undefined;
+    readonly defaultChecked?: boolean | undefined;
+    readonly suppressContentEditableWarning?: boolean | undefined;
+    readonly suppressHydrationWarning?: boolean | undefined;
+    readonly accessKey?: string | undefined;
+    readonly autoCapitalize?: "off" | "none" | "on" | "sentences" | "words" | "characters" | undefined | (string & {});
+    readonly autoFocus?: boolean | undefined;
+    readonly className?: string | undefined;
+    readonly contentEditable?: (boolean | "true" | "false") | "inherit" | "plaintext-only" | undefined;
+    readonly contextMenu?: string | undefined;
+    readonly draggable?: (boolean | "true" | "false") | undefined;
+    readonly enterKeyHint?: "enter" | "done" | "go" | "next" | "previous" | "search" | "send" | undefined;
+    readonly hidden?: boolean | undefined;
+    readonly lang?: string | undefined;
+    readonly nonce?: string | undefined;
+    readonly spellCheck?: (boolean | "true" | "false") | undefined;
+    readonly tabIndex?: number | undefined;
+    readonly translate?: "yes" | "no" | undefined;
+    readonly radioGroup?: string | undefined;
+    readonly role?: import('react').AriaRole | undefined;
+    readonly about?: string | undefined;
+    readonly content?: string | undefined;
+    readonly datatype?: string | undefined;
+    readonly inlist?: any;
+    readonly prefix?: string | undefined;
+    readonly property?: string | undefined;
+    readonly rel?: string | undefined;
+    readonly resource?: string | undefined;
+    readonly rev?: string | undefined;
+    readonly typeof?: string | undefined;
+    readonly vocab?: string | undefined;
+    readonly autoCorrect?: string | undefined;
+    readonly autoSave?: string | undefined;
+    readonly itemProp?: string | undefined;
+    readonly itemScope?: boolean | undefined;
+    readonly itemType?: string | undefined;
+    readonly itemID?: string | undefined;
+    readonly itemRef?: string | undefined;
+    readonly results?: number | undefined;
+    readonly security?: string | undefined;
+    readonly unselectable?: "on" | "off" | undefined;
+    readonly popover?: "" | "auto" | "manual" | undefined;
+    readonly popoverTargetAction?: "toggle" | "show" | "hide" | undefined;
+    readonly popoverTarget?: string | undefined;
+    readonly inert?: boolean | undefined;
+    readonly inputMode?: "none" | "text" | "tel" | "url" | "email" | "numeric" | "decimal" | "search" | undefined;
+    readonly is?: string | undefined;
+    readonly "aria-activedescendant"?: string | undefined;
+    readonly "aria-atomic"?: (boolean | "true" | "false") | undefined;
+    readonly "aria-autocomplete"?: "none" | "inline" | "list" | "both" | undefined;
+    readonly "aria-braillelabel"?: string | undefined;
+    readonly "aria-brailleroledescription"?: string | undefined;
+    readonly "aria-busy"?: (boolean | "true" | "false") | undefined;
+    readonly "aria-checked"?: boolean | "false" | "mixed" | "true" | undefined;
+    readonly "aria-colcount"?: number | undefined;
+    readonly "aria-colindex"?: number | undefined;
+    readonly "aria-colindextext"?: string | undefined;
+    readonly "aria-colspan"?: number | undefined;
+    readonly "aria-controls"?: string | undefined;
+    readonly "aria-current"?: boolean | "false" | "true" | "page" | "step" | "location" | "date" | "time" | undefined;
+    readonly "aria-describedby"?: string | undefined;
+    readonly "aria-description"?: string | undefined;
+    readonly "aria-details"?: string | undefined;
+    readonly "aria-disabled"?: (boolean | "true" | "false") | undefined;
+    readonly "aria-dropeffect"?: "none" | "copy" | "execute" | "link" | "move" | "popup" | undefined;
+    readonly "aria-errormessage"?: string | undefined;
+    readonly "aria-expanded"?: (boolean | "true" | "false") | undefined;
+    readonly "aria-flowto"?: string | undefined;
+    readonly "aria-grabbed"?: (boolean | "true" | "false") | undefined;
+    readonly "aria-haspopup"?: boolean | "false" | "true" | "menu" | "listbox" | "tree" | "grid" | "dialog" | undefined;
+    readonly "aria-hidden"?: (boolean | "true" | "false") | undefined;
+    readonly "aria-invalid"?: boolean | "false" | "true" | "grammar" | "spelling" | undefined;
+    readonly "aria-keyshortcuts"?: string | undefined;
+    readonly "aria-label"?: string | undefined;
+    readonly "aria-level"?: number | undefined;
+    readonly "aria-live"?: "off" | "assertive" | "polite" | undefined;
+    readonly "aria-modal"?: (boolean | "true" | "false") | undefined;
+    readonly "aria-multiline"?: (boolean | "true" | "false") | undefined;
+    readonly "aria-multiselectable"?: (boolean | "true" | "false") | undefined;
+    readonly "aria-orientation"?: "horizontal" | "vertical" | undefined;
+    readonly "aria-owns"?: string | undefined;
+    readonly "aria-placeholder"?: string | undefined;
+    readonly "aria-posinset"?: number | undefined;
+    readonly "aria-pressed"?: boolean | "false" | "mixed" | "true" | undefined;
+    readonly "aria-readonly"?: (boolean | "true" | "false") | undefined;
+    readonly "aria-relevant"?: "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text" | "text additions" | "text removals" | undefined;
+    readonly "aria-required"?: (boolean | "true" | "false") | undefined;
+    readonly "aria-roledescription"?: string | undefined;
+    readonly "aria-rowcount"?: number | undefined;
+    readonly "aria-rowindex"?: number | undefined;
+    readonly "aria-rowindextext"?: string | undefined;
+    readonly "aria-rowspan"?: number | undefined;
+    readonly "aria-selected"?: (boolean | "true" | "false") | undefined;
+    readonly "aria-setsize"?: number | undefined;
+    readonly "aria-sort"?: "none" | "ascending" | "descending" | "other" | undefined;
+    readonly "aria-valuemax"?: number | undefined;
+    readonly "aria-valuemin"?: number | undefined;
+    readonly "aria-valuenow"?: number | undefined;
+    readonly "aria-valuetext"?: string | undefined;
+    readonly dangerouslySetInnerHTML?: {
+        __html: string | TrustedHTML;
+    } | undefined;
+    readonly onCopy?: import('react').ClipboardEventHandler<HTMLElement> | undefined;
+    readonly onCopyCapture?: import('react').ClipboardEventHandler<HTMLElement> | undefined;
+    readonly onCut?: import('react').ClipboardEventHandler<HTMLElement> | undefined;
+    readonly onCutCapture?: import('react').ClipboardEventHandler<HTMLElement> | undefined;
+    readonly onPaste?: import('react').ClipboardEventHandler<HTMLElement> | undefined;
+    readonly onPasteCapture?: import('react').ClipboardEventHandler<HTMLElement> | undefined;
+    readonly onCompositionEnd?: import('react').CompositionEventHandler<HTMLElement> | undefined;
+    readonly onCompositionEndCapture?: import('react').CompositionEventHandler<HTMLElement> | undefined;
+    readonly onCompositionStart?: import('react').CompositionEventHandler<HTMLElement> | undefined;
+    readonly onCompositionStartCapture?: import('react').CompositionEventHandler<HTMLElement> | undefined;
+    readonly onCompositionUpdate?: import('react').CompositionEventHandler<HTMLElement> | undefined;
+    readonly onCompositionUpdateCapture?: import('react').CompositionEventHandler<HTMLElement> | undefined;
+    readonly onFocus?: import('react').FocusEventHandler<HTMLElement> | undefined;
+    readonly onFocusCapture?: import('react').FocusEventHandler<HTMLElement> | undefined;
+    readonly onBlurCapture?: import('react').FocusEventHandler<HTMLElement> | undefined;
+    readonly onChangeCapture?: import('react').FormEventHandler<HTMLElement> | undefined;
+    readonly onBeforeInput?: import('react').FormEventHandler<HTMLElement> | undefined;
+    readonly onBeforeInputCapture?: import('react').FormEventHandler<HTMLElement> | undefined;
+    readonly onInput?: import('react').FormEventHandler<HTMLElement> | undefined;
+    readonly onInputCapture?: import('react').FormEventHandler<HTMLElement> | undefined;
+    readonly onReset?: import('react').FormEventHandler<HTMLElement> | undefined;
+    readonly onResetCapture?: import('react').FormEventHandler<HTMLElement> | undefined;
+    readonly onSubmit?: import('react').FormEventHandler<HTMLElement> | undefined;
+    readonly onSubmitCapture?: import('react').FormEventHandler<HTMLElement> | undefined;
+    readonly onInvalid?: import('react').FormEventHandler<HTMLElement> | undefined;
+    readonly onInvalidCapture?: import('react').FormEventHandler<HTMLElement> | undefined;
+    readonly onLoad?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onLoadCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onError?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onErrorCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onKeyDown?: import('react').KeyboardEventHandler<HTMLElement> | undefined;
+    readonly onKeyDownCapture?: import('react').KeyboardEventHandler<HTMLElement> | undefined;
+    readonly onKeyPress?: import('react').KeyboardEventHandler<HTMLElement> | undefined;
+    readonly onKeyPressCapture?: import('react').KeyboardEventHandler<HTMLElement> | undefined;
+    readonly onKeyUp?: import('react').KeyboardEventHandler<HTMLElement> | undefined;
+    readonly onKeyUpCapture?: import('react').KeyboardEventHandler<HTMLElement> | undefined;
+    readonly onAbort?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onAbortCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onCanPlay?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onCanPlayCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onCanPlayThrough?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onCanPlayThroughCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onDurationChange?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onDurationChangeCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onEmptied?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onEmptiedCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onEncrypted?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onEncryptedCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onEnded?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onEndedCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onLoadedData?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onLoadedDataCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onLoadedMetadata?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onLoadedMetadataCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onLoadStart?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onLoadStartCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onPause?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onPauseCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onPlay?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onPlayCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onPlaying?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onPlayingCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onProgress?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onProgressCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onRateChange?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onRateChangeCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onResize?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onResizeCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onSeeked?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onSeekedCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onSeeking?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onSeekingCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onStalled?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onStalledCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onSuspend?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onSuspendCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onTimeUpdate?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onTimeUpdateCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onVolumeChange?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onVolumeChangeCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onWaiting?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onWaitingCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onAuxClick?: import('react').MouseEventHandler<HTMLElement> | undefined;
+    readonly onAuxClickCapture?: import('react').MouseEventHandler<HTMLElement> | undefined;
+    readonly onClick?: import('react').MouseEventHandler<HTMLElement> | undefined;
+    readonly onClickCapture?: import('react').MouseEventHandler<HTMLElement> | undefined;
+    readonly onContextMenu?: import('react').MouseEventHandler<HTMLElement> | undefined;
+    readonly onContextMenuCapture?: import('react').MouseEventHandler<HTMLElement> | undefined;
+    readonly onDoubleClick?: import('react').MouseEventHandler<HTMLElement> | undefined;
+    readonly onDoubleClickCapture?: import('react').MouseEventHandler<HTMLElement> | undefined;
+    readonly onDrag?: import('react').DragEventHandler<HTMLElement> | undefined;
+    readonly onDragCapture?: import('react').DragEventHandler<HTMLElement> | undefined;
+    readonly onDragEnd?: import('react').DragEventHandler<HTMLElement> | undefined;
+    readonly onDragEndCapture?: import('react').DragEventHandler<HTMLElement> | undefined;
+    readonly onDragEnter?: import('react').DragEventHandler<HTMLElement> | undefined;
+    readonly onDragEnterCapture?: import('react').DragEventHandler<HTMLElement> | undefined;
+    readonly onDragExit?: import('react').DragEventHandler<HTMLElement> | undefined;
+    readonly onDragExitCapture?: import('react').DragEventHandler<HTMLElement> | undefined;
+    readonly onDragLeave?: import('react').DragEventHandler<HTMLElement> | undefined;
+    readonly onDragLeaveCapture?: import('react').DragEventHandler<HTMLElement> | undefined;
+    readonly onDragOver?: import('react').DragEventHandler<HTMLElement> | undefined;
+    readonly onDragOverCapture?: import('react').DragEventHandler<HTMLElement> | undefined;
+    readonly onDragStart?: import('react').DragEventHandler<HTMLElement> | undefined;
+    readonly onDragStartCapture?: import('react').DragEventHandler<HTMLElement> | undefined;
+    readonly onDrop?: import('react').DragEventHandler<HTMLElement> | undefined;
+    readonly onDropCapture?: import('react').DragEventHandler<HTMLElement> | undefined;
+    readonly onMouseDown?: import('react').MouseEventHandler<HTMLElement> | undefined;
+    readonly onMouseDownCapture?: import('react').MouseEventHandler<HTMLElement> | undefined;
+    readonly onMouseEnter?: import('react').MouseEventHandler<HTMLElement> | undefined;
+    readonly onMouseLeave?: import('react').MouseEventHandler<HTMLElement> | undefined;
+    readonly onMouseMove?: import('react').MouseEventHandler<HTMLElement> | undefined;
+    readonly onMouseMoveCapture?: import('react').MouseEventHandler<HTMLElement> | undefined;
+    readonly onMouseOut?: import('react').MouseEventHandler<HTMLElement> | undefined;
+    readonly onMouseOutCapture?: import('react').MouseEventHandler<HTMLElement> | undefined;
+    readonly onMouseOver?: import('react').MouseEventHandler<HTMLElement> | undefined;
+    readonly onMouseOverCapture?: import('react').MouseEventHandler<HTMLElement> | undefined;
+    readonly onMouseUp?: import('react').MouseEventHandler<HTMLElement> | undefined;
+    readonly onMouseUpCapture?: import('react').MouseEventHandler<HTMLElement> | undefined;
+    readonly onSelect?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onSelectCapture?: import('react').ReactEventHandler<HTMLElement> | undefined;
+    readonly onTouchCancel?: import('react').TouchEventHandler<HTMLElement> | undefined;
+    readonly onTouchCancelCapture?: import('react').TouchEventHandler<HTMLElement> | undefined;
+    readonly onTouchEnd?: import('react').TouchEventHandler<HTMLElement> | undefined;
+    readonly onTouchEndCapture?: import('react').TouchEventHandler<HTMLElement> | undefined;
+    readonly onTouchMove?: import('react').TouchEventHandler<HTMLElement> | undefined;
+    readonly onTouchMoveCapture?: import('react').TouchEventHandler<HTMLElement> | undefined;
+    readonly onTouchStart?: import('react').TouchEventHandler<HTMLElement> | undefined;
+    readonly onTouchStartCapture?: import('react').TouchEventHandler<HTMLElement> | undefined;
+    readonly onPointerDown?: import('react').PointerEventHandler<HTMLElement> | undefined;
+    readonly onPointerDownCapture?: import('react').PointerEventHandler<HTMLElement> | undefined;
+    readonly onPointerMove?: import('react').PointerEventHandler<HTMLElement> | undefined;
+    readonly onPointerMoveCapture?: import('react').PointerEventHandler<HTMLElement> | undefined;
+    readonly onPointerUp?: import('react').PointerEventHandler<HTMLElement> | undefined;
+    readonly onPointerUpCapture?: import('react').PointerEventHandler<HTMLElement> | undefined;
+    readonly onPointerCancel?: import('react').PointerEventHandler<HTMLElement> | undefined;
+    readonly onPointerCancelCapture?: import('react').PointerEventHandler<HTMLElement> | undefined;
+    readonly onPointerEnter?: import('react').PointerEventHandler<HTMLElement> | undefined;
+    readonly onPointerLeave?: import('react').PointerEventHandler<HTMLElement> | undefined;
+    readonly onPointerOver?: import('react').PointerEventHandler<HTMLElement> | undefined;
+    readonly onPointerOverCapture?: import('react').PointerEventHandler<HTMLElement> | undefined;
+    readonly onPointerOut?: import('react').PointerEventHandler<HTMLElement> | undefined;
+    readonly onPointerOutCapture?: import('react').PointerEventHandler<HTMLElement> | undefined;
+    readonly onGotPointerCapture?: import('react').PointerEventHandler<HTMLElement> | undefined;
+    readonly onGotPointerCaptureCapture?: import('react').PointerEventHandler<HTMLElement> | undefined;
+    readonly onLostPointerCapture?: import('react').PointerEventHandler<HTMLElement> | undefined;
+    readonly onLostPointerCaptureCapture?: import('react').PointerEventHandler<HTMLElement> | undefined;
+    readonly onScroll?: import('react').UIEventHandler<HTMLElement> | undefined;
+    readonly onScrollCapture?: import('react').UIEventHandler<HTMLElement> | undefined;
+    readonly onWheel?: import('react').WheelEventHandler<HTMLElement> | undefined;
+    readonly onWheelCapture?: import('react').WheelEventHandler<HTMLElement> | undefined;
+    readonly onAnimationStart?: import('react').AnimationEventHandler<HTMLElement> | undefined;
+    readonly onAnimationStartCapture?: import('react').AnimationEventHandler<HTMLElement> | undefined;
+    readonly onAnimationEnd?: import('react').AnimationEventHandler<HTMLElement> | undefined;
+    readonly onAnimationEndCapture?: import('react').AnimationEventHandler<HTMLElement> | undefined;
+    readonly onAnimationIteration?: import('react').AnimationEventHandler<HTMLElement> | undefined;
+    readonly onAnimationIterationCapture?: import('react').AnimationEventHandler<HTMLElement> | undefined;
+    readonly onToggle?: import('react').ToggleEventHandler<HTMLElement> | undefined;
+    readonly onBeforeToggle?: import('react').ToggleEventHandler<HTMLElement> | undefined;
+    readonly onTransitionCancel?: import('react').TransitionEventHandler<HTMLElement> | undefined;
+    readonly onTransitionCancelCapture?: import('react').TransitionEventHandler<HTMLElement> | undefined;
+    readonly onTransitionEnd?: import('react').TransitionEventHandler<HTMLElement> | undefined;
+    readonly onTransitionEndCapture?: import('react').TransitionEventHandler<HTMLElement> | undefined;
+    readonly onTransitionRun?: import('react').TransitionEventHandler<HTMLElement> | undefined;
+    readonly onTransitionRunCapture?: import('react').TransitionEventHandler<HTMLElement> | undefined;
+    readonly onTransitionStart?: import('react').TransitionEventHandler<HTMLElement> | undefined;
+    readonly onTransitionStartCapture?: import('react').TransitionEventHandler<HTMLElement> | undefined;
+    readonly list?: string | undefined;
+    readonly default?: boolean | undefined;
+    readonly height?: number | string | undefined;
+    readonly max?: number | string | undefined;
+    readonly media?: string | undefined;
+    readonly method?: string | undefined;
+    readonly min?: number | string | undefined;
+    readonly target?: string | undefined;
+    readonly width?: number | string | undefined;
+    readonly crossOrigin?: "" | "anonymous" | "use-credentials" | undefined;
+    readonly href?: string | undefined;
+    readonly step?: number | string | undefined;
+    readonly accept?: string | undefined;
+    readonly acceptCharset?: string | undefined;
+    readonly action?: string | undefined | ((formData: FormData) => void | Promise<void>) | import('react').DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_FORM_ACTIONS[keyof import('react').DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_FORM_ACTIONS];
+    readonly allowFullScreen?: boolean | undefined;
+    readonly allowTransparency?: boolean | undefined;
+    readonly alt?: string | undefined;
+    readonly as?: string | undefined;
+    readonly async?: boolean | undefined;
+    readonly autoComplete?: string | undefined;
+    readonly autoPlay?: boolean | undefined;
+    readonly capture?: boolean | "user" | "environment" | undefined;
+    readonly cellPadding?: number | string | undefined;
+    readonly cellSpacing?: number | string | undefined;
+    readonly charSet?: string | undefined;
+    readonly challenge?: string | undefined;
+    readonly checked?: boolean | undefined;
+    readonly classID?: string | undefined;
+    readonly cols?: number | undefined;
+    readonly colSpan?: number | undefined;
+    readonly controls?: boolean | undefined;
+    readonly coords?: string | undefined;
+    readonly dateTime?: string | undefined;
+    readonly defer?: boolean | undefined;
+    readonly download?: any;
+    readonly encType?: string | undefined;
+    readonly frameBorder?: number | string | undefined;
+    readonly headers?: string | undefined;
+    readonly high?: number | undefined;
+    readonly hrefLang?: string | undefined;
+    readonly htmlFor?: string | undefined;
+    readonly httpEquiv?: string | undefined;
+    readonly integrity?: string | undefined;
+    readonly keyParams?: string | undefined;
+    readonly keyType?: string | undefined;
+    readonly kind?: string | undefined;
+    readonly loop?: boolean | undefined;
+    readonly low?: number | undefined;
+    readonly manifest?: string | undefined;
+    readonly marginHeight?: number | undefined;
+    readonly marginWidth?: number | undefined;
+    readonly maxLength?: number | undefined;
+    readonly mediaGroup?: string | undefined;
+    readonly minLength?: number | undefined;
+    readonly multiple?: boolean | undefined;
+    readonly muted?: boolean | undefined;
+    readonly noValidate?: boolean | undefined;
+    readonly open?: boolean | undefined;
+    readonly optimum?: number | undefined;
+    readonly placeholder?: string | undefined;
+    readonly playsInline?: boolean | undefined;
+    readonly poster?: string | undefined;
+    readonly preload?: string | undefined;
+    readonly readOnly?: boolean | undefined;
+    readonly required?: boolean | undefined;
+    readonly reversed?: boolean | undefined;
+    readonly rows?: number | undefined;
+    readonly rowSpan?: number | undefined;
+    readonly sandbox?: string | undefined;
+    readonly scope?: string | undefined;
+    readonly scoped?: boolean | undefined;
+    readonly scrolling?: string | undefined;
+    readonly seamless?: boolean | undefined;
+    readonly selected?: boolean | undefined;
+    readonly shape?: string | undefined;
+    readonly sizes?: string | undefined;
+    readonly src?: string | undefined;
+    readonly srcDoc?: string | undefined;
+    readonly srcLang?: string | undefined;
+    readonly srcSet?: string | undefined;
+    readonly start?: number | undefined;
+    readonly useMap?: string | undefined;
+    readonly wmode?: string | undefined;
+    readonly wrap?: string | undefined;
+}];

package/dist/forms/fields/BaseField/index.d.ts

@@ -0,0 +1,4 @@
+export * from './BaseField';
+export * from './hooks';
+export * from './layouts';
+export * from './typings';

package/dist/{fields → forms/fields}/BaseField/layouts.d.ts

@@ -1,18 +1,24 @@
-import { Flex, Severity, ThemeOptions } from "@overmap-ai/blocks";
-import { ReactElement, ComponentProps, ReactNode } from "react";
-export type Color = ThemeOptions["accentColor"];
+import { TextSize } from '@overmap-ai/blocks';
+import { ReactElement, ReactNode } from 'react';
+import { Severity } from '../../typings';
 interface InputWithLabelProps {
+    size?: TextSize;
     severity: Severity | undefined;
     inputId: string;
     labelId: string;
     label: string;
+    image: File | Promise<File> | undefined;
     children: ReactNode;
-    flexProps?: ComponentProps<typeof Flex>;
+    className?: string;
 }
 export declare const InputWithLabel: (props: InputWithLabelProps) => import("react/jsx-runtime").JSX.Element;
-interface InputWithLabelAndHelpTextProps {
+interface InputWithHelpTextProps {
     severity: Severity | undefined;
     helpText: string | null;
+    children: ReactElement;
+}
+export declare const InputWithHelpText: (props: InputWithHelpTextProps) => import("react/jsx-runtime").JSX.Element;
+interface InputWithLabelAndHelpTextProps extends InputWithHelpTextProps {
     children: ReactElement<InputWithLabelProps>;
 }
 export declare const InputWithLabelAndHelpText: (props: InputWithLabelAndHelpTextProps) => import("react/jsx-runtime").JSX.Element;

package/dist/{fields → forms/fields}/BaseField/typings.d.ts

@@ -1,5 +1,5 @@
-import { BaseSerializedField } from "@overmap-ai/core";
-import { InputFieldLevelValidator, InputFormLevelValidator } from '..';
+import { BaseSerializedField } from '../../typings';
+import { InputFieldLevelValidator, InputFormLevelValidator } from '../typings';
 export interface FieldOptions<TValue> extends BaseSerializedField {
     fieldValidators?: InputFieldLevelValidator<TValue>[];
     formValidators?: InputFormLevelValidator<TValue>[];

package/dist/forms/fields/BooleanField/BooleanField.d.ts

@@ -0,0 +1,22 @@
+import { ReactNode } from 'react';
+import { RiCheckboxCircleLine } from 'react-icons/ri';
+import { ISerializedField, SerializedBooleanField } from '../../typings';
+import { BaseField, ChildFieldOptions } from '../BaseField';
+import { ComponentProps } from '../typings';
+export declare const emptyBooleanField: {
+    type: string;
+    label: string;
+    description: string;
+    required: boolean;
+};
+export declare class BooleanField extends BaseField<boolean, "boolean"> {
+    static readonly fieldTypeName = "Checkbox";
+    static readonly fieldTypeDescription = "Perfect for both optional and required yes/no questions.";
+    readonly onlyValidateAfterTouched = false;
+    static Icon: typeof RiCheckboxCircleLine;
+    constructor(options: ChildFieldOptions<boolean>);
+    protected isBlank(value: boolean | undefined): boolean;
+    serialize(): SerializedBooleanField;
+    static deserialize(data: ISerializedField): BooleanField;
+    getInput(props: ComponentProps<BooleanField>): ReactNode;
+}

package/dist/forms/fields/BooleanField/BooleanInput.d.ts

@@ -0,0 +1,3 @@
+import { ComponentProps } from '../typings';
+import { BooleanField } from './BooleanField';
+export declare const BooleanInput: import('react').MemoExoticComponent<(props: ComponentProps<BooleanField>) => import("react/jsx-runtime").JSX.Element>;

package/dist/forms/fields/BooleanField/index.d.ts

@@ -0,0 +1,2 @@
+export * from './BooleanField';
+export * from './BooleanInput';

package/dist/{fields → forms/fields}/CustomField/CustomField.d.ts

@@ -1,9 +1,15 @@
-import { FieldTypeIdentifier, FieldValue } from "@overmap-ai/core";
-import { BaseField, ChildFieldOptions } from "../BaseField";
-import { FC, ReactNode } from "react";
-import { GetInputProps, ISerializedOnlyField } from "../typings";
-export interface CustomFieldOptions<TValue> extends ChildFieldOptions<TValue> {
-}
+import { ISerializedOnlyField } from '@overmap-ai/core';
+import { FC, ReactNode } from 'react';
+import { FieldTypeIdentifier, FieldValue } from '../../typings';
+import { BaseField, ChildFieldOptions } from '../BaseField';
+import { GetInputProps } from '../typings';
+export type CustomFieldOptions<TValue> = ChildFieldOptions<TValue>;
+export declare const emptyCustomField: {
+    type: string;
+    label: string;
+    description: string;
+    required: boolean;
+};
 export declare class CustomField<TValue extends FieldValue, 
 /** The options passed to constructor */
 TFieldOptions extends CustomFieldOptions<TValue>, 

package/dist/{fields → forms/fields}/CustomField/FieldInputClonerField/FieldInputCloner.d.ts

@@ -1,8 +1,7 @@
-/// <reference types="react" />
-import { FieldInputClonerProps } from "./typings.ts";
+import { FieldInputClonerProps } from './typings';
 /**
  * Used to dynamically "clone" a field's input for use in conditional sections. When a field is selected for a
  * condition, we need to render the same input in the condition section, so the user can input a value for the
  * condition.
  */
-export declare const FieldInputCloner: import("react").NamedExoticComponent<FieldInputClonerProps>;
+export declare const FieldInputCloner: import('react').MemoExoticComponent<(props: FieldInputClonerProps) => import('react').ReactNode>;

package/dist/{fields → forms/fields}/CustomField/FieldInputClonerField/FieldInputClonerField.d.ts

@@ -1,6 +1,6 @@
-import { CustomField, CustomFieldOptions } from "../CustomField";
-import { FieldValue, ISerializedField } from "@overmap-ai/core";
-import { FieldInputClonerProps } from "./index";
+import { FieldValue, ISerializedField } from '../../../typings';
+import { CustomField, CustomFieldOptions } from '../CustomField';
+import { FieldInputClonerProps } from './index';
 export interface FieldInputClonerFieldOptions extends CustomFieldOptions<unknown> {
     /** Given an identifier, should return the options of the field with the
      * corresponding identifier (the field being cloned) */

package/dist/forms/fields/CustomField/FieldInputClonerField/index.d.ts

@@ -0,0 +1,3 @@
+export * from './FieldInputCloner';
+export * from './FieldInputClonerField';
+export * from './typings';

package/dist/forms/fields/CustomField/FieldInputClonerField/typings.d.ts

@@ -0,0 +1,5 @@
+import { FieldValue } from '../../../typings';
+import { AnyField, ComponentProps, GetInputProps } from '../../typings';
+import { CustomField } from '../CustomField';
+import { FieldInputClonerFieldOptions } from './FieldInputClonerField';
+export type FieldInputClonerProps = ComponentProps<CustomField<FieldValue, FieldInputClonerFieldOptions, GetInputProps<AnyField>>>;

package/dist/forms/fields/CustomField/index.d.ts

@@ -0,0 +1 @@
+export * from './CustomField';

package/dist/forms/fields/DateField/DateField.d.ts

@@ -0,0 +1,21 @@
+import { ReactNode } from 'react';
+import { RiCalendarLine } from 'react-icons/ri';
+import { ISerializedField, SerializedDateField } from '../../typings';
+import { BaseField, ChildFieldOptions } from '../BaseField';
+import { GetInputProps } from '../typings';
+export declare const emptyDateField: {
+    type: string;
+    label: string;
+    description: string;
+    required: boolean;
+};
+export declare class DateField extends BaseField<string, "date"> {
+    static readonly fieldTypeName = "Date";
+    static readonly fieldTypeDescription = "Allows specifying a date.";
+    static Icon: typeof RiCalendarLine;
+    readonly onlyValidateAfterTouched = false;
+    constructor(options: ChildFieldOptions<string>);
+    serialize(): SerializedDateField;
+    static deserialize(data: ISerializedField): DateField;
+    getInput(props: GetInputProps<this>): ReactNode;
+}

package/dist/forms/fields/DateField/DateInput.d.ts

@@ -0,0 +1,3 @@
+import { ComponentProps } from '../typings';
+import { DateField } from './DateField';
+export declare const DateInput: import('react').MemoExoticComponent<(props: ComponentProps<DateField>) => import("react/jsx-runtime").JSX.Element>;

package/dist/forms/fields/DateField/index.d.ts

@@ -0,0 +1,2 @@
+export * from './DateField';
+export * from './DateInput';

package/dist/{fields → forms/fields}/FieldSection/FieldSection.d.ts

@@ -1,9 +1,7 @@
-import { BaseSerializedObject, ISerializedField, SerializedCondition, SerializedFieldSection } from "@overmap-ai/core";
-import { GetInputProps } from '..';
-import { AnyField } from '../typings';
-import { BaseFormElement } from '../BaseField';
-import React from "react";
-import { Form } from '../../typings';
+import { ReactNode } from 'react';
+import { FormikFormRevision } from '../../builder';
+import { BaseSerializedObject, FormValues, ISerializedField, SerializedCondition, SerializedFieldSection } from '../../typings';
+import { AnyField, BaseFormElement, BooleanField, GetInputProps } from '../index';
 interface FieldSectionOptions extends Omit<BaseSerializedObject, "type"> {
     label?: string | null;
     conditional?: boolean;
@@ -17,13 +15,19 @@ export declare class FieldSection extends BaseFormElement<"section"> {
     readonly fields: AnyField[];
     readonly condition: SerializedCondition | null;
     constructor(options: FieldSectionOptions);
-    static getFieldCreationSchema(options: ISerializedField[]): BaseFormElement[];
+    static getFieldCreationSchema(options: ISerializedField[], parentPath?: string): ({
+        field: BooleanField;
+        showDirectly: boolean;
+    } | {
+        field: FieldSection;
+        showDirectly: boolean;
+    })[];
     static deserialize(data: ISerializedField): FieldSection;
     conditional(): this is {
         condition: SerializedCondition;
     };
     serialize(): SerializedFieldSection;
-    getErrors(allValues: Form): Record<string, string>;
-    getInput(props: GetInputProps<this>): React.ReactNode;
+    getErrors(allValues: FormValues | FormikFormRevision): Record<string, string>;
+    getInput(props: GetInputProps<this>): ReactNode;
 }
 export {};

package/dist/forms/fields/FieldSection/FieldSectionLayout.d.ts

@@ -0,0 +1,6 @@
+import { ComponentProps } from '../typings';
+import { FieldSection } from './FieldSection';
+/**
+ * Used by FieldSection to render a section of fields.
+ */
+export declare const FieldSectionLayout: import('react').MemoExoticComponent<(props: ComponentProps<FieldSection>) => import("react/jsx-runtime").JSX.Element | null>;

package/dist/forms/fields/FieldSection/index.d.ts

@@ -0,0 +1 @@
+export * from './FieldSection';