cross-state 0.9.2 → 0.10.0

package/dist/types/core/urlStore.d.ts

@@ -1,6 +1,5 @@
-import { type Update } from './commonTypes';
-import { Store, type StoreOptions } from './store';
-import { type Path, type Value } from '../lib/path';
+import { type Cancel } from './commonTypes';
+import { type Store, type StoreOptions } from './store';
 export interface UrlStoreOptions<T> extends StoreOptions {
     key: string;
     type?: 'search' | 'hash';
@@ -13,14 +12,7 @@ export interface UrlStoreOptionsWithDefaults<T> extends UrlStoreOptions<T> {
     defaultValue: T;
 }
 export type UrlStoreOptionsRequired<T> = UrlStoreOptions<T> & Required<Pick<UrlStoreOptions<T>, 'type' | 'serialize' | 'deserialize' | 'defaultValue'>>;
-export declare class UrlStore<T> extends Store<T> {
-    readonly options: UrlStoreOptionsRequired<T>;
-    private serializedDefaultValue;
-    constructor(options: UrlStoreOptionsRequired<T>);
-    set(update: Update<T>): void;
-    set<P extends Path<T>>(path: P, update: Update<Value<T, P>>): void;
-    protected watchUrl(): () => void;
-    protected updateUrl(value: T | undefined): void;
-}
-export declare function createUrlStore<T>(options: UrlStoreOptionsWithDefaults<T>): UrlStore<T>;
-export declare function createUrlStore<T>(options: UrlStoreOptions<T>): UrlStore<T | undefined>;
+export declare function connectUrl<T>(store: Store<T>, options: UrlStoreOptionsWithDefaults<T>): Cancel;
+export declare function connectUrl<T>(store: Store<T | undefined>, options: UrlStoreOptions<T>): Cancel;
+export declare function createUrlStore<T>(options: UrlStoreOptionsWithDefaults<T>): Store<T>;
+export declare function createUrlStore<T>(options: UrlStoreOptions<T>): Store<T | undefined>;

package/dist/types/immer/immerMethods.d.ts

@@ -3,7 +3,7 @@ import type { Store } from '../core/store';
 import { type Path, type Value } from '../lib/path';
 type Recipe<T> = (draft: Draft<T>) => void;
 declare function update<T>(this: Store<T>, recipe: Recipe<T>): void;
-declare function update<T, P extends Path<T>>(this: Store<T>, path: P, recipe: Recipe<Value<T, P>>): void;
+declare function update<T, const P extends Path<T>>(this: Store<T>, path: P, recipe: Recipe<Value<T, P>>): void;
 export declare const immerMethods: {
     update: typeof update;
 };

package/dist/types/index2.d.ts

@@ -0,0 +1,2 @@
+export { calcDuration } from './lib/calcDuration';
+export * from './core';

package/dist/types/lib/autobind.d.ts

@@ -0,0 +1 @@
+export declare const autobind: <TClass extends abstract new (...args: any) => any = abstract new (...args: any) => any>(_class: TClass, _context?: ClassDecoratorContext<TClass> | undefined) => TClass;

package/dist/types/lib/path.d.ts

@@ -1,13 +1,13 @@
 import type { ArrayToStringPath, Array_, IsAny, IsNever, Object_, OptionalPropertyOf, StringToArrayPath, StringToNumber } from './typeHelpers';
 export type KeyType = string | number | symbol;
 export type GetKeys<T extends Object_ | Array_> = T extends Array_ ? T extends readonly [] ? never : '0' extends keyof T ? StringToNumber<keyof T> : number : keyof T;
-export type _PathAsArray<T, Optional, MaxDepth, Depth extends 1[]> = true extends IsAny<T> ? KeyType[] : T extends never ? never : T extends Object_ ? Depth['length'] extends MaxDepth ? string[] : T extends Map<infer K extends KeyType, infer V> ? [K] | [K, ..._PathAsArray<V, Optional, MaxDepth, [...Depth, 1]>] : T extends Set<any> ? [number] : {
-    [K in GetKeys<T>]: (Optional extends true ? (K extends OptionalPropertyOf<T> ? [K] : never) : [K]) | [K, ..._PathAsArray<T[K], Optional, MaxDepth, [...Depth, 1]>];
+export type _PathAsArray<T, Optional, MaxDepth, Depth extends 1[]> = true extends IsAny<T> ? readonly KeyType[] : T extends never ? never : T extends Object_ ? Depth['length'] extends MaxDepth ? readonly string[] : T extends Map<infer K extends KeyType, infer V> ? readonly [K] | readonly [K, ..._PathAsArray<V, Optional, MaxDepth, [...Depth, 1]>] : T extends Set<any> ? readonly [number] : {
+    [K in GetKeys<T>]: (Optional extends true ? K extends OptionalPropertyOf<T> ? readonly [K] : never : readonly [K]) | readonly [K, ..._PathAsArray<T[K], Optional, MaxDepth, [...Depth, 1]>];
 }[GetKeys<T>] : never;
 export type PathAsArray<T, Optional extends boolean = false, MaxDepth extends number = 5> = _PathAsArray<T, Optional, MaxDepth, []>;
 export type PathAsString<T, Optional extends boolean = false, MaxDepth extends number = 5> = ArrayToStringPath<PathAsArray<T, Optional, MaxDepth>>;
-export type Path<T, Optional extends boolean = false, MaxDepth extends number = 5> = (PathAsString<T, Optional, MaxDepth> & string) | PathAsArray<T, Optional, MaxDepth>;
-export type Value<T, P> = true extends IsAny<T> | IsAny<P> ? any : true extends IsNever<T> | IsNever<P> ? never : P extends string ? Value<T, StringToArrayPath<P>> : P extends [infer First extends KeyType, ...infer Rest extends KeyType[]] ? T extends Map<any, infer V> | Set<infer V> ? Value<V, Rest> | undefined : T extends Array_ ? any[] extends T ? Value<T[First & keyof T], Rest> | undefined : Value<T[First & keyof T], Rest> : T extends Object_ ? Record<any, any> extends T ? Value<T[First], Rest> | undefined : Value<T[First], Rest> : never : T;
+export type Path<T, Optional extends boolean = false, MaxDepth extends number = 5> = PathAsString<T, Optional, MaxDepth> | PathAsArray<T, Optional, MaxDepth>;
+export type Value<T, P> = P extends readonly [] ? T : true extends IsAny<T> | IsAny<P> ? any : true extends IsNever<T> | IsNever<P> ? never : P extends string ? Value<T, StringToArrayPath<P>> : P extends readonly [infer First extends KeyType, ...infer Rest extends readonly KeyType[]] ? T extends Map<any, infer V> | Set<infer V> ? Value<V, Rest> | undefined : T extends Array_ ? any[] extends T ? Value<T[First & keyof T], Rest> | undefined : Value<T[First & keyof T], Rest> : T extends Object_ ? Record<any, any> extends T ? Value<T[First], Rest> | undefined : Value<T[First], Rest> : never : never;
 export type _WildcardPathAsArray<T, MaxDepth, Depth extends 1[]> = [] | (0 extends 1 & T ? KeyType[] : T extends never ? never : T extends Object_ ? Depth['length'] extends MaxDepth ? string[] : T extends Map<infer K extends KeyType, infer V> ? ['*'] | [K] | [K, ..._WildcardPathAsArray<V, MaxDepth, [...Depth, 1]>] : T extends Set<any> ? ['*'] | [number] : {
     [K in GetKeys<T>]: ['*'] | [K] | [K, ..._WildcardPathAsArray<T[K], MaxDepth, [...Depth, 1]>];
 }[GetKeys<T>] : never);
@@ -15,5 +15,8 @@ export type WildcardPathAsArray<T, MaxDepth extends number = 5> = _WildcardPathA
 ]>;
 export type WildcardPathAsString<T, MaxDepth extends number = 5> = ArrayToStringPath<_WildcardPathAsArray<T, MaxDepth, []>>;
 export type WildcardPath<T, MaxDepth extends number = 5> = WildcardPathAsString<T, MaxDepth> | WildcardPathAsArray<T, MaxDepth>;
-export type WildcardValue<T, P> = true extends IsAny<T> | IsAny<P> ? any : true extends IsNever<T> | IsNever<P> ? never : P extends string ? WildcardValue<T, StringToArrayPath<P>> : P extends [infer First extends KeyType, ...infer Rest extends KeyType[]] ? T extends Map<any, infer V> | Set<infer V> ? WildcardValue<V, Rest> | (First extends '*' ? never : undefined) : T extends Array_ ? First extends '*' ? T[number] : any[] extends T ? WildcardValue<T[First & keyof T], Rest> | undefined : First extends keyof T ? WildcardValue<T[First], Rest> : undefined : T extends Object_ ? First extends '*' ? T[keyof T] : Record<any, any> extends T ? WildcardValue<T[First], Rest> | undefined : WildcardValue<T[First], Rest> : never : T;
-export type WildcardMatch<S, W> = S extends string ? WildcardMatch<StringToArrayPath<S>, W> : W extends string ? WildcardMatch<S, StringToArrayPath<W>> : [S, W] extends [[], []] ? true : [S, W] extends [[infer SFirst, ...infer SRest], [infer WFirst, ...infer WRest]] ? [WFirst, WRest['length']] extends ['*' | SFirst, SRest['length']] ? WildcardMatch<SRest, WRest> : false : false;
+export type WildcardValue<T, P> = true extends IsAny<T> | IsAny<P> ? any : true extends IsNever<T> | IsNever<P> ? never : P extends string ? WildcardValue<T, StringToArrayPath<P>> : P extends readonly [infer First extends KeyType, ...infer Rest extends KeyType[]] ? T extends Map<any, infer V> | Set<infer V> ? WildcardValue<V, Rest> | (First extends '*' ? never : undefined) : T extends Array_ ? First extends '*' ? T[number] : any[] extends T ? WildcardValue<T[First & keyof T], Rest> | undefined : First extends keyof T ? WildcardValue<T[First], Rest> : undefined : T extends Object_ ? First extends '*' ? T[keyof T] : Record<any, any> extends T ? WildcardValue<T[First], Rest> | undefined : WildcardValue<T[First], Rest> : never : T;
+export type WildcardMatch<S, W> = S extends string ? WildcardMatch<StringToArrayPath<S>, W> : W extends string ? WildcardMatch<S, StringToArrayPath<W>> : [S, W] extends [readonly [], readonly []] ? true : [S, W] extends [
+    readonly [infer SFirst, ...infer SRest],
+    readonly [infer WFirst, ...infer WRest]
+] ? [WFirst, WRest['length']] extends ['*' | SFirst, SRest['length']] ? WildcardMatch<SRest, WRest> : false : false;

package/dist/types/lib/typeHelpers.d.ts

@@ -2,8 +2,8 @@ import { type KeyType } from './path';
 export type Object_ = Record<string | number | symbol, any>;
 export type Array_ = readonly any[];
 export type StringToNumber<T> = T extends `${infer K extends number}` ? K : never;
-export type ArrayToStringPath<T> = T extends [] ? '' : T extends [infer First extends string | number, ...infer Rest] ? First extends `${string}.${string}` ? never : Rest extends [] ? `${First}` : `${First}.${ArrayToStringPath<Rest>}` : T extends KeyType[] ? string : never;
-export type StringToArrayPath<T> = T extends '' ? [] : T extends `${infer First}.${infer Rest}` ? [First, ...StringToArrayPath<Rest>] : [T];
+export type ArrayToStringPath<T> = T extends readonly [] ? '' : T extends readonly [infer First extends string | number, ...infer Rest] ? First extends `${string}.${string}` ? never : Rest extends readonly [] ? `${First}` : `${First}.${ArrayToStringPath<Rest>}` : T extends readonly KeyType[] ? string : never;
+export type StringToArrayPath<T> = T extends '' ? readonly [] : T extends `${infer First}.${infer Rest}` ? readonly [First, ...StringToArrayPath<Rest>] : readonly [T];
 export type OptionalPropertyOf<T> = Exclude<{
     [K in keyof T]: T extends Record<K, T[K]> ? never : K;
 }[keyof T], undefined>;

package/dist/types/react/form/form.d.ts

@@ -1,11 +1,13 @@
-import { type ComponentPropsWithoutRef, type ReactNode } from 'react';
+import { type ComponentPropsWithoutRef, type HTMLProps } from 'react';
 import { type UseStoreOptions } from '../useStore';
 import { type FormErrorProps } from './formError';
-import { type FormInputComponent, type FormInputProps } from './formInput';
+import { type FormFieldComponent, type FormFieldProps } from './formField';
+import { Scope, type UrlStoreOptions } from '../../core';
 import { type PathAsString, type Value, type WildcardPathAsString, type WildcardValue } from '../../lib/path';
 export interface FormOptions<TDraft, TOriginal> {
     defaultValue: TDraft;
     validations?: Validations<TDraft, TOriginal>;
+    urlState?: boolean | UrlStoreOptions<TDraft>;
 }
 export type Validations<TDraft, TOriginal> = {
     [P in WildcardPathAsString<TDraft>]?: Record<string, Validation<WildcardValue<TDraft, P>, TDraft, TOriginal>>;
@@ -24,13 +26,17 @@ export interface Field<TDraft, TOriginal, TPath extends PathAsString<TDraft>> {
 }
 export declare class Form<TDraft, TOriginal extends TDraft = TDraft> {
     readonly options: FormOptions<TDraft, TOriginal>;
-    private context;
-    private state;
+    context: import("react").Context<{
+        original: TOriginal | undefined;
+        options: FormOptions<TDraft, TOriginal>;
+    }>;
+    state: Scope<{
+        draft?: TDraft | undefined;
+        touched: Set<string>;
+        errors: Map<string, string[]>;
+        hasTriggeredValidations?: boolean | undefined;
+    }>;
     constructor(options: FormOptions<TDraft, TOriginal>);
-    Provider({ children, original, defaultValue, validations, }: {
-        children?: ReactNode;
-        original?: TOriginal;
-    } & Partial<FormOptions<TDraft, TOriginal>>): import("react/jsx-runtime").JSX.Element;
     useForm(): {
         original: TOriginal | undefined;
         draft: import("../../core").Store<TDraft>;
@@ -44,7 +50,10 @@ export declare class Form<TDraft, TOriginal extends TDraft = TDraft> {
     useField<TPath extends PathAsString<TDraft>>(path: TPath, useStoreOptions?: UseStoreOptions): Field<TDraft, TOriginal, TPath>;
     useHasChanges(): boolean;
     useIsValid(): boolean;
-    Input<TPath extends PathAsString<TDraft>, TComponent extends FormInputComponent<any> = (props: ComponentPropsWithoutRef<'input'>) => JSX.Element>(props: FormInputProps<TDraft, TPath, TComponent>): JSX.Element;
+    Form({ original, defaultValue, validations, urlState, ...formProps }: {
+        original?: TOriginal;
+    } & Partial<FormOptions<TDraft, TOriginal>> & Omit<HTMLProps<HTMLFormElement>, 'defaultValue'>): import("react/jsx-runtime").JSX.Element;
+    Field<TPath extends PathAsString<TDraft>, TComponent extends FormFieldComponent<any> = (props: ComponentPropsWithoutRef<'input'>) => JSX.Element>(props: FormFieldProps<TDraft, TPath, TComponent>): JSX.Element;
     Error<TPath extends PathAsString<TDraft>>({ name }: FormErrorProps<TDraft, TPath>): any;
 }
 export declare function createForm<TDraft, TOriginal extends TDraft = TDraft>(options: FormOptions<TDraft, TOriginal>): Form<TDraft, TOriginal>;

package/dist/types/react/form/formField.d.ts

@@ -0,0 +1,53 @@
+import { type ComponentPropsWithoutRef, type ElementType, type HTMLProps } from 'react';
+import { type Form } from './form';
+import { type PathAsString } from '../../index';
+import { type Value } from '../../lib/path';
+export type FormFieldComponent<T> = ElementType<{
+    id: string;
+    value: T;
+    onChange: (event: {
+        target: {
+            value: T;
+        };
+    } | T | undefined, ...args: any[]) => void;
+    onFocus: (...args: any[]) => void;
+    onBlur: (...args: any[]) => void;
+}>;
+type FieldValue<T extends FormFieldComponent<any>> = ComponentPropsWithoutRef<T & 'input'> extends {
+    value: infer U;
+} ? U : ComponentPropsWithoutRef<T & 'input'> extends {
+    value?: infer U;
+} ? U | undefined : never;
+type FieldChangeValue<T extends FormFieldComponent<any>> = ComponentPropsWithoutRef<T & 'input'> extends {
+    onChange?: (update: infer U) => void;
+} ? U extends {
+    target: {
+        value: infer V;
+    };
+} ? V : U : never;
+export type FormFieldProps<TDraft, TPath extends PathAsString<TDraft>, TComponent extends FormFieldComponent<any>> = {
+    name: TPath;
+    commitOnBlur?: boolean;
+    commitDebounce?: number;
+    inputFilter?: (value: FieldChangeValue<TComponent>) => boolean;
+    onChange?: ComponentPropsWithoutRef<TComponent>['onChange'];
+    onBlur?: ComponentPropsWithoutRef<TComponent>['onBlur'];
+} & (TComponent extends 'input' | ((props: HTMLProps<HTMLInputElement>) => JSX.Element) ? {
+    component?: TComponent;
+} | {
+    children?: TComponent;
+} : {
+    component: TComponent;
+} | {
+    children: TComponent;
+}) & Omit<ComponentPropsWithoutRef<TComponent>, 'form' | 'name' | 'component' | 'commitOnBlur' | 'commitDebounce' | 'value' | 'onChange' | 'onBlur' | 'children'> & (Value<TDraft, TPath> extends FieldValue<TComponent> ? {
+    serialize?: (value: Value<TDraft, TPath>) => FieldValue<TComponent>;
+} : {
+    serialize: (value: Value<TDraft, TPath>) => FieldValue<TComponent>;
+}) & (FieldChangeValue<TComponent> extends Value<TDraft, TPath> ? {
+    deserialize?: (value: FieldChangeValue<TComponent>) => Value<TDraft, TPath>;
+} : {
+    deserialize: (value: FieldChangeValue<TComponent>) => Value<TDraft, TPath>;
+});
+export declare function FormField<TDraft, TPath extends PathAsString<TDraft>, TComponent extends FormFieldComponent<any>>(this: Form<TDraft, any>, { name, commitOnBlur, commitDebounce, inputFilter, serialize, deserialize, ...restProps }: FormFieldProps<TDraft, TPath, TComponent>): JSX.Element;
+export {};

package/dist/types/react/form/index.d.ts

@@ -1,3 +1,3 @@
 export { type Field, Form, type FormOptions, type Validation, type Validations, createForm, } from './form';
 export { type FormErrorProps } from './formError';
-export { type FormInputComponent, type FormInputProps } from './formInput';
+export { type FormFieldComponent, type FormFieldProps } from './formField';

package/dist/types/react/index.d.ts

@@ -6,3 +6,4 @@ export { useCache, type UseCacheArray, type UseCacheValue } from './useCache';
 export { useDecoupledState, type UseDecoupledStateOptions } from './useDecoupledState';
 export { useProp } from './useProp';
 export { useStore, type UseStoreOptions } from './useStore';
+export { useUrlParamScope } from './useUrlParamScope';

package/dist/types/react/reactMethods.d.ts

@@ -4,6 +4,6 @@ export declare const reactMethods: {
     useStore<T>(this: Store<T>, options?: UseStoreOptions): T;
     useProp<T_1>(this: Store<T_1>, options?: UseStoreOptions): [value: T_1, setValue: {
         (update: import("../core/commonTypes").Update<T_1>): void;
-        <P extends import("..").Path<T_1>>(path: P, update: import("../core/commonTypes").Update<import("..").Value<T_1, P>>): void;
+        <const P extends import("..").Path<T_1>>(path: P, update: import("../core/commonTypes").Update<import("..").Value<T_1, P>>): void;
     }];
 };

package/dist/types/react/register.d.ts

@@ -22,7 +22,7 @@ declare const scopeMethods: {
     useStore<T_1>(this: Scope<T_1>, options?: UseStoreOptions): T_1;
     useProp<T_2>(this: Scope<T_2>, options?: UseStoreOptions): [value: T_2, setValue: {
         (update: import("../core/commonTypes").Update<T_2>): void;
-        <P extends import("..").Path<T_2>>(path: P, update: import("../core/commonTypes").Update<import("..").Value<T_2, P>>): void;
+        <const P extends import("..").Path<T_2>>(path: P, update: import("../core/commonTypes").Update<import("..").Value<T_2, P>>): void;
     }];
     Provider<T_3>(this: Scope<T_3>, props: Omit<ScopeProps<T_3>, "scope">): import("react/jsx-runtime").JSX.Element;
 };

package/dist/types/react/scope.d.ts

@@ -1,4 +1,4 @@
-import type { ReactNode } from 'react';
+import type { Context, ReactNode } from 'react';
 import { type UseStoreOptions } from './useStore';
 import type { Store } from '../core/store';
 import type { Scope } from '../core';
@@ -7,10 +7,15 @@ export type ScopeProps<T> = {
     store?: Store<T>;
     children?: ReactNode;
 };
+declare module '../core' {
+    interface Scope<T> {
+        context?: Context<Store<T>>;
+    }
+}
 export declare function ScopeProvider<T>({ scope, store: inputStore, children }: ScopeProps<T>): import("react/jsx-runtime").JSX.Element;
 export declare function useScope<T>(scope: Scope<T>): Store<T>;
 export declare function useScopeStore<T>(scope: Scope<T>, options?: UseStoreOptions): T;
 export declare function useScopeProp<T>(scope: Scope<T>, options?: UseStoreOptions): [value: T, setValue: {
     (update: import("../core/commonTypes").Update<T>): void;
-    <P extends import("..").Path<T>>(path: P, update: import("../core/commonTypes").Update<import("..").Value<T, P>>): void;
+    <const P extends import("..").Path<T>>(path: P, update: import("../core/commonTypes").Update<import("..").Value<T, P>>): void;
 }];

package/dist/types/react/useUrlParamScope.d.ts

@@ -0,0 +1,4 @@
+export declare function useUrlParamScope({ key, type, }: {
+    key: string | string[];
+    type?: 'search' | 'hash';
+}): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cross-state",
-  "version": "0.9.2",
+  "version": "0.10.0",
   "description": "(React) state library",
   "license": "ISC",
   "repository": "schummar/schummar-state",
@@ -110,38 +110,38 @@
     "@schummar/eslint-config": "github:schummar/eslint-config",
     "@schummar/prettier-config": "github:schummar/prettier-config",
     "@schummar/runp": "1.12.0",
-    "@size-limit/preset-small-lib": "^8.2.4",
+    "@size-limit/preset-small-lib": "8.2.4",
     "@testing-library/react": "14.0.0",
-    "@types/react": "18.2.6",
-    "@types/react-dom": "18.2.4",
+    "@types/react": "18.2.12",
+    "@types/react-dom": "18.2.5",
     "@types/seedrandom": "3.0.5",
     "@types/use-sync-external-store": "0.0.3",
-    "@types/ws": "^8.5.4",
+    "@types/ws": "8.5.5",
     "@vitejs/plugin-react": "4.0.0",
-    "@vitest/coverage-c8": "0.31.1",
-    "eslint": "8.41.0",
+    "@vitest/coverage-v8": "0.32.0",
+    "esbuild": "0.18.2",
+    "eslint": "8.42.0",
     "happy-dom": "9.20.3",
     "immer": "10.0.2",
-    "jsdom": "22.0.0",
+    "jsdom": "22.1.0",
     "prettier": "2.8.8",
-    "publint": "^0.1.12",
+    "publint": "0.1.12",
     "react": "18.2.0",
     "react-dom": "18.2.0",
     "rimraf": "5.0.1",
     "seedrandom": "3.0.5",
-    "semantic-release": "21.0.2",
-    "size-limit": "^8.2.4",
+    "semantic-release": "21.0.5",
+    "size-limit": "8.2.4",
     "tsc-alias": "1.8.6",
-    "typescript": "5.0.4",
+    "typescript": "5.1.3",
     "use-sync-external-store": "1.2.0",
-    "vite": "4.3.8",
+    "vite": "4.3.9",
     "vite-tsconfig-paths": "4.2.0",
-    "vitest": "0.31.1",
-    "ws": "^8.13.0"
+    "vitest": "0.32.0"
   },
   "volta": {
     "node": "18.16.0",
-    "pnpm": "8.2.0"
+    "pnpm": "8.6.1"
   },
   "eslintConfig": {
     "extends": [

package/dist/types/react/form/formInput.d.ts

@@ -1,48 +0,0 @@
-import { type ComponentPropsWithoutRef, type ElementType, type HTMLProps } from 'react';
-import { type Form } from './form';
-import { type PathAsString } from '../../index';
-import { type Value } from '../../lib/path';
-export type FormInputComponent<T> = ElementType<{
-    id: string;
-    value: T;
-    onChange: (event: {
-        target: {
-            value: T;
-        };
-    } | T | undefined, ...args: any[]) => void;
-    onBlur: (...args: any[]) => void;
-}>;
-type InputValue<T extends FormInputComponent<any>> = ComponentPropsWithoutRef<T> extends {
-    value: infer U;
-} ? U : ComponentPropsWithoutRef<T> extends {
-    value?: infer U;
-} ? U | undefined : never;
-type InputChangeValue<T extends FormInputComponent<any>> = ComponentPropsWithoutRef<T> extends {
-    onChange?: (update: infer U) => void;
-} ? U extends {
-    target: {
-        value: infer V;
-    };
-} ? V : U : never;
-export type FormInputProps<TDraft, TPath extends PathAsString<TDraft>, TComponent extends FormInputComponent<any>> = {
-    name: TPath;
-    commitOnBlur?: boolean;
-    commitDebounce?: number;
-    inputFilter?: (value: InputChangeValue<TComponent>) => boolean;
-    onChange?: ComponentPropsWithoutRef<TComponent>['onChange'];
-    onBlur?: ComponentPropsWithoutRef<TComponent>['onBlur'];
-} & (TComponent extends 'input' | ((props: HTMLProps<HTMLInputElement>) => JSX.Element) ? {
-    component?: TComponent;
-} : {
-    component: TComponent;
-}) & Omit<ComponentPropsWithoutRef<TComponent>, 'form' | 'name' | 'component' | 'commitOnBlur' | 'commitDebounce' | 'value' | 'onChange' | 'onBlur'> & (Value<TDraft, TPath> extends InputValue<TComponent> ? {
-    serialize?: (value: Value<TDraft, TPath>) => InputValue<TComponent>;
-} : {
-    serialize: (value: Value<TDraft, TPath>) => InputValue<TComponent>;
-}) & (InputChangeValue<TComponent> extends Value<TDraft, TPath> ? {
-    deserialize?: (value: InputChangeValue<TComponent>) => Value<TDraft, TPath>;
-} : {
-    deserialize: (value: InputChangeValue<TComponent>) => Value<TDraft, TPath>;
-});
-export declare function FormInput<TDraft, TPath extends PathAsString<TDraft>, TComponent extends FormInputComponent<any>>(this: Form<TDraft, any>, { id, name, component, commitOnBlur, commitDebounce, inputFilter, serialize, deserialize, ...restProps }: FormInputProps<TDraft, TPath, TComponent>): JSX.Element;
-export {};