Huge News!Announcing our $40M Series B led by Abstract Ventures.Learn More →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

uniforms-bootstrap4

Package Overview
Dependencies
Maintainers
1
Versions
191
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

uniforms-bootstrap4 - npm Package Compare versions

Comparing version 3.5.5 to 3.6.0

222

es5/AutoForm.d.ts

@@ -1,2 +0,222 @@

declare const _default: any;
/// <reference types="react" />
declare const _default: {
new <Model, Props extends import("uniforms").AutoFormProps<Model> = import("uniforms").AutoFormProps<Model>, State extends import("uniforms").AutoFormState<Model> = import("uniforms").AutoFormState<Model>>(props: Props): {
componentDidUpdate(prevProps: Props, prevState: State, snapshot: never): void;
getNativeFormProps(): Record<string, any>;
getModel(mode: import("uniforms").ModelTransformMode): State["model"];
onChange(key: string, value: any): void;
__reset(state: State): Partial<State>;
validate: (key?: string | undefined, value?: any) => Promise<any>;
validateModel: (originalModel: any) => Promise<any>;
getContextError(): any;
getContext(): import("uniforms").Context<Model>;
onSubmit(event?: import("react").SyntheticEvent<Element, Event> | undefined): Promise<any>;
onValidate(key?: string | undefined, value?: any): Promise<any>;
onValidateModel(originalModel: Props["model"]): Promise<any>;
componentDidMount(): void;
componentWillUnmount(): void;
delayId?: any;
mounted: boolean;
reset: () => void;
change: (key: string, value: any) => void;
submit: (event?: import("react").SyntheticEvent<Element, Event> | undefined) => Promise<any>;
randomId: () => string;
getContextName(): string[];
getContextModel(): import("uniforms").DeepPartial<Model>;
getContextState(): {
disabled: boolean;
label: boolean;
placeholder: boolean;
readOnly: boolean;
showInlineError: boolean;
};
getContextSchema(): import("uniforms").Bridge;
getContextOnChange(): (key: string, value: any) => void;
getContextOnSubmit(): (event?: import("react").SyntheticEvent<Element, Event> | undefined) => any;
onReset(): void;
render(): JSX.Element;
context: any;
setState<K extends keyof State>(state: State | Pick<State, K> | ((prevState: Readonly<State>, props: Readonly<Props>) => State | Pick<State, K> | null) | null, callback?: (() => void) | undefined): void;
forceUpdate(callback?: (() => void) | undefined): void;
readonly props: Readonly<Props> & Readonly<{
children?: import("react").ReactNode;
}>;
state: Readonly<State>;
refs: {
[key: string]: import("react").ReactInstance;
};
shouldComponentUpdate?(nextProps: Readonly<Props>, nextState: Readonly<State>, nextContext: any): boolean;
componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
getSnapshotBeforeUpdate?(prevProps: Readonly<Props>, prevState: Readonly<State>): any;
componentWillMount?(): void;
UNSAFE_componentWillMount?(): void;
componentWillReceiveProps?(nextProps: Readonly<Props>, nextContext: any): void;
UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Props>, nextContext: any): void;
componentWillUpdate?(nextProps: Readonly<Props>, nextState: Readonly<State>, nextContext: any): void;
UNSAFE_componentWillUpdate?(nextProps: Readonly<Props>, nextState: Readonly<State>, nextContext: any): void;
};
Auto: typeof import("uniforms").Auto;
displayName: string;
Validated: typeof import("uniforms").Validated;
defaultProps: {
onValidate(model: unknown, error: any): any;
validate: string;
autosave: boolean;
autosaveDelay: number;
error: null;
label: boolean;
model: any;
noValidate: boolean;
onSubmit(): void;
} & {
autosave: boolean;
autosaveDelay: number;
error: null;
label: boolean;
model: any;
noValidate: boolean;
onSubmit(): void;
};
contextType?: import("react").Context<any> | undefined;
Quick: typeof import("uniforms").Quick;
} & {
new <Model_1, Props_1 extends import("uniforms").ValidatedFormProps<Model_1> = import("uniforms").ValidatedFormProps<Model_1>, State_1 extends import("uniforms").ValidatedFormState<Model_1> = import("uniforms").ValidatedFormState<Model_1>>(props: Props_1): {
validate: (key?: string | undefined, value?: any) => Promise<any>;
validateModel: (originalModel: any) => Promise<any>;
getContextError(): any;
getContext(): import("uniforms").Context<Model_1>;
getNativeFormProps(): Record<string, any>;
componentDidUpdate(prevProps: Props_1, prevState: State_1, snapshot: never): void;
onChange(key: string, value: any): void;
__reset(state: State_1): Partial<State_1>;
onSubmit(event?: import("react").SyntheticEvent<Element, Event> | undefined): Promise<any>;
onValidate(key?: string | undefined, value?: any): Promise<any>;
onValidateModel(originalModel: Props_1["model"]): Promise<any>;
componentDidMount(): void;
componentWillUnmount(): void;
delayId?: any;
mounted: boolean;
reset: () => void;
change: (key: string, value: any) => void;
submit: (event?: import("react").SyntheticEvent<Element, Event> | undefined) => Promise<any>;
randomId: () => string;
getContextName(): string[];
getContextModel(): import("uniforms").DeepPartial<Model_1>;
getContextState(): {
disabled: boolean;
label: boolean;
placeholder: boolean;
readOnly: boolean;
showInlineError: boolean;
};
getContextSchema(): import("uniforms").Bridge;
getContextOnChange(): (key: string, value: any) => void;
getContextOnSubmit(): (event?: import("react").SyntheticEvent<Element, Event> | undefined) => any;
getModel(mode?: import("uniforms").ModelTransformMode | undefined, model?: import("uniforms").DeepPartial<Model_1> | undefined): import("uniforms").DeepPartial<Model_1>;
onReset(): void;
render(): JSX.Element;
context: any;
setState<K_1 extends keyof State_1>(state: State_1 | Pick<State_1, K_1> | ((prevState: Readonly<State_1>, props: Readonly<Props_1>) => State_1 | Pick<State_1, K_1> | null) | null, callback?: (() => void) | undefined): void;
forceUpdate(callback?: (() => void) | undefined): void;
readonly props: Readonly<Props_1> & Readonly<{
children?: import("react").ReactNode;
}>;
state: Readonly<State_1>;
refs: {
[key: string]: import("react").ReactInstance;
};
shouldComponentUpdate?(nextProps: Readonly<Props_1>, nextState: Readonly<State_1>, nextContext: any): boolean;
componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
getSnapshotBeforeUpdate?(prevProps: Readonly<Props_1>, prevState: Readonly<State_1>): any;
componentWillMount?(): void;
UNSAFE_componentWillMount?(): void;
componentWillReceiveProps?(nextProps: Readonly<Props_1>, nextContext: any): void;
UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Props_1>, nextContext: any): void;
componentWillUpdate?(nextProps: Readonly<Props_1>, nextState: Readonly<State_1>, nextContext: any): void;
UNSAFE_componentWillUpdate?(nextProps: Readonly<Props_1>, nextState: Readonly<State_1>, nextContext: any): void;
};
Validated: typeof import("uniforms").Validated;
displayName: string;
defaultProps: {
onValidate(model: unknown, error: any): any;
validate: string;
autosave: boolean;
autosaveDelay: number;
error: null;
label: boolean;
model: any;
noValidate: boolean;
onSubmit(): void;
};
contextType?: import("react").Context<any> | undefined;
} & {
new <Model_2, Props_2 extends import("uniforms").QuickFormProps<Model_2> = import("uniforms").QuickFormProps<Model_2>, State_2 extends import("uniforms").QuickFormState<Model_2> = import("uniforms").QuickFormState<Model_2>>(props: Props_2): {
getNativeFormProps(): Record<string, any>;
getAutoField(): import("react").ComponentType<{
name: string;
}>;
getErrorsField(): import("react").ComponentType<{}>;
getSubmitField(): import("react").ComponentType<{}>;
componentDidMount(): void;
componentDidUpdate(prevProps: Props_2, prevState: State_2, snapshot: never): void;
componentWillUnmount(): void;
delayId?: any;
mounted: boolean;
reset: () => void;
change: (key: string, value: any) => void;
submit: (event?: import("react").SyntheticEvent<Element, Event> | undefined) => Promise<any>;
randomId: () => string;
getContext(): import("uniforms").Context<Model_2>;
getContextName(): string[];
getContextError(): any;
getContextModel(): import("uniforms").DeepPartial<Model_2>;
getContextState(): {
disabled: boolean;
label: boolean;
placeholder: boolean;
readOnly: boolean;
showInlineError: boolean;
};
getContextSchema(): import("uniforms").Bridge;
getContextOnChange(): (key: string, value: any) => void;
getContextOnSubmit(): (event?: import("react").SyntheticEvent<Element, Event> | undefined) => any;
getModel(mode?: import("uniforms").ModelTransformMode | undefined, model?: import("uniforms").DeepPartial<Model_2> | undefined): import("uniforms").DeepPartial<Model_2>;
onChange(key: string, value: any): void;
__reset(state: State_2): Partial<State_2>;
onReset(): void;
onSubmit(event?: import("react").SyntheticEvent<Element, Event> | undefined): Promise<any>;
render(): JSX.Element;
context: any;
setState<K_2 extends keyof State_2>(state: State_2 | Pick<State_2, K_2> | ((prevState: Readonly<State_2>, props: Readonly<Props_2>) => State_2 | Pick<State_2, K_2> | null) | null, callback?: (() => void) | undefined): void;
forceUpdate(callback?: (() => void) | undefined): void;
readonly props: Readonly<Props_2> & Readonly<{
children?: import("react").ReactNode;
}>;
state: Readonly<State_2>;
refs: {
[key: string]: import("react").ReactInstance;
};
shouldComponentUpdate?(nextProps: Readonly<Props_2>, nextState: Readonly<State_2>, nextContext: any): boolean;
componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
getSnapshotBeforeUpdate?(prevProps: Readonly<Props_2>, prevState: Readonly<State_2>): any;
componentWillMount?(): void;
UNSAFE_componentWillMount?(): void;
componentWillReceiveProps?(nextProps: Readonly<Props_2>, nextContext: any): void;
UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Props_2>, nextContext: any): void;
componentWillUpdate?(nextProps: Readonly<Props_2>, nextState: Readonly<State_2>, nextContext: any): void;
UNSAFE_componentWillUpdate?(nextProps: Readonly<Props_2>, nextState: Readonly<State_2>, nextContext: any): void;
};
Quick: typeof import("uniforms").Quick;
displayName: string;
defaultProps: {
autosave: boolean;
autosaveDelay: number;
error: null;
label: boolean;
model: any;
noValidate: boolean;
onSubmit(): void;
};
contextType?: import("react").Context<any> | undefined;
} & typeof import("uniforms").BaseForm;
export default _default;

3

es5/BaseForm.d.ts

@@ -1,2 +0,3 @@

declare const _default: any;
import { BaseForm } from 'uniforms';
declare const _default: typeof BaseForm;
export default _default;

72

es5/QuickForm.d.ts

@@ -1,2 +0,72 @@

declare const _default: any;
/// <reference types="react" />
declare const _default: {
new <Model, Props extends import("uniforms").QuickFormProps<Model> = import("uniforms").QuickFormProps<Model>, State extends import("uniforms").QuickFormState<Model> = import("uniforms").QuickFormState<Model>>(props: Props): {
getNativeFormProps(): Record<string, any>;
getAutoField(): import("react").ComponentType<{
name: string;
}>;
getErrorsField(): import("react").ComponentType<{}>;
getSubmitField(): import("react").ComponentType<{}>;
componentDidMount(): void;
componentDidUpdate(prevProps: Props, prevState: State, snapshot: never): void;
componentWillUnmount(): void;
delayId?: any;
mounted: boolean;
reset: () => void;
change: (key: string, value: any) => void;
submit: (event?: import("react").SyntheticEvent<Element, Event> | undefined) => Promise<any>;
randomId: () => string;
getContext(): import("uniforms").Context<Model>;
getContextName(): string[];
getContextError(): any;
getContextModel(): import("uniforms").DeepPartial<Model>;
getContextState(): {
disabled: boolean;
label: boolean;
placeholder: boolean;
readOnly: boolean;
showInlineError: boolean;
};
getContextSchema(): import("uniforms").Bridge;
getContextOnChange(): (key: string, value: any) => void;
getContextOnSubmit(): (event?: import("react").SyntheticEvent<Element, Event> | undefined) => any;
getModel(mode?: import("uniforms").ModelTransformMode | undefined, model?: import("uniforms").DeepPartial<Model> | undefined): import("uniforms").DeepPartial<Model>;
onChange(key: string, value: any): void;
__reset(state: State): Partial<State>;
onReset(): void;
onSubmit(event?: import("react").SyntheticEvent<Element, Event> | undefined): Promise<any>;
render(): JSX.Element;
context: any;
setState<K extends keyof State>(state: State | Pick<State, K> | ((prevState: Readonly<State>, props: Readonly<Props>) => State | Pick<State, K> | null) | null, callback?: (() => void) | undefined): void;
forceUpdate(callback?: (() => void) | undefined): void;
readonly props: Readonly<Props> & Readonly<{
children?: import("react").ReactNode;
}>;
state: Readonly<State>;
refs: {
[key: string]: import("react").ReactInstance;
};
shouldComponentUpdate?(nextProps: Readonly<Props>, nextState: Readonly<State>, nextContext: any): boolean;
componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
getSnapshotBeforeUpdate?(prevProps: Readonly<Props>, prevState: Readonly<State>): any;
componentWillMount?(): void;
UNSAFE_componentWillMount?(): void;
componentWillReceiveProps?(nextProps: Readonly<Props>, nextContext: any): void;
UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Props>, nextContext: any): void;
componentWillUpdate?(nextProps: Readonly<Props>, nextState: Readonly<State>, nextContext: any): void;
UNSAFE_componentWillUpdate?(nextProps: Readonly<Props>, nextState: Readonly<State>, nextContext: any): void;
};
Quick: typeof import("uniforms").Quick;
displayName: string;
defaultProps: {
autosave: boolean;
autosaveDelay: number;
error: null;
label: boolean;
model: any;
noValidate: boolean;
onSubmit(): void;
};
contextType?: import("react").Context<any> | undefined;
} & typeof import("uniforms").BaseForm;
export default _default;

73

es5/ValidatedForm.d.ts

@@ -1,2 +0,73 @@

declare const _default: any;
/// <reference types="react" />
declare const _default: {
new <Model, Props extends import("uniforms").ValidatedFormProps<Model> = import("uniforms").ValidatedFormProps<Model>, State extends import("uniforms").ValidatedFormState<Model> = import("uniforms").ValidatedFormState<Model>>(props: Props): {
validate: (key?: string | undefined, value?: any) => Promise<any>;
validateModel: (originalModel: any) => Promise<any>;
getContextError(): any;
getContext(): import("uniforms").Context<Model>;
getNativeFormProps(): Record<string, any>;
componentDidUpdate(prevProps: Props, prevState: State, snapshot: never): void;
onChange(key: string, value: any): void;
__reset(state: State): Partial<State>;
onSubmit(event?: import("react").SyntheticEvent<Element, Event> | undefined): Promise<any>;
onValidate(key?: string | undefined, value?: any): Promise<any>;
onValidateModel(originalModel: Props["model"]): Promise<any>;
componentDidMount(): void;
componentWillUnmount(): void;
delayId?: any;
mounted: boolean;
reset: () => void;
change: (key: string, value: any) => void;
submit: (event?: import("react").SyntheticEvent<Element, Event> | undefined) => Promise<any>;
randomId: () => string;
getContextName(): string[];
getContextModel(): import("uniforms").DeepPartial<Model>;
getContextState(): {
disabled: boolean;
label: boolean;
placeholder: boolean;
readOnly: boolean;
showInlineError: boolean;
};
getContextSchema(): import("uniforms").Bridge;
getContextOnChange(): (key: string, value: any) => void;
getContextOnSubmit(): (event?: import("react").SyntheticEvent<Element, Event> | undefined) => any;
getModel(mode?: import("uniforms").ModelTransformMode | undefined, model?: import("uniforms").DeepPartial<Model> | undefined): import("uniforms").DeepPartial<Model>;
onReset(): void;
render(): JSX.Element;
context: any;
setState<K extends keyof State>(state: State | Pick<State, K> | ((prevState: Readonly<State>, props: Readonly<Props>) => State | Pick<State, K> | null) | null, callback?: (() => void) | undefined): void;
forceUpdate(callback?: (() => void) | undefined): void;
readonly props: Readonly<Props> & Readonly<{
children?: import("react").ReactNode;
}>;
state: Readonly<State>;
refs: {
[key: string]: import("react").ReactInstance;
};
shouldComponentUpdate?(nextProps: Readonly<Props>, nextState: Readonly<State>, nextContext: any): boolean;
componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
getSnapshotBeforeUpdate?(prevProps: Readonly<Props>, prevState: Readonly<State>): any;
componentWillMount?(): void;
UNSAFE_componentWillMount?(): void;
componentWillReceiveProps?(nextProps: Readonly<Props>, nextContext: any): void;
UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Props>, nextContext: any): void;
componentWillUpdate?(nextProps: Readonly<Props>, nextState: Readonly<State>, nextContext: any): void;
UNSAFE_componentWillUpdate?(nextProps: Readonly<Props>, nextState: Readonly<State>, nextContext: any): void;
};
Validated: typeof import("uniforms").Validated;
displayName: string;
defaultProps: {
onValidate(model: unknown, error: any): any;
validate: string;
autosave: boolean;
autosaveDelay: number;
error: null;
label: boolean;
model: any;
noValidate: boolean;
onSubmit(): void;
};
contextType?: import("react").Context<any> | undefined;
} & typeof import("uniforms").BaseForm;
export default _default;

142

es5/ValidatedQuickForm.d.ts

@@ -1,2 +0,142 @@

declare const _default: any;
/// <reference types="react" />
declare const _default: {
new <Model, Props extends import("uniforms").ValidatedFormProps<Model> = import("uniforms").ValidatedFormProps<Model>, State extends import("uniforms").ValidatedFormState<Model> = import("uniforms").ValidatedFormState<Model>>(props: Props): {
validate: (key?: string | undefined, value?: any) => Promise<any>;
validateModel: (originalModel: any) => Promise<any>;
getContextError(): any;
getContext(): import("uniforms").Context<Model>;
getNativeFormProps(): Record<string, any>;
componentDidUpdate(prevProps: Props, prevState: State, snapshot: never): void;
onChange(key: string, value: any): void;
__reset(state: State): Partial<State>;
onSubmit(event?: import("react").SyntheticEvent<Element, Event> | undefined): Promise<any>;
onValidate(key?: string | undefined, value?: any): Promise<any>;
onValidateModel(originalModel: Props["model"]): Promise<any>;
componentDidMount(): void;
componentWillUnmount(): void;
delayId?: any;
mounted: boolean;
reset: () => void;
change: (key: string, value: any) => void;
submit: (event?: import("react").SyntheticEvent<Element, Event> | undefined) => Promise<any>;
randomId: () => string;
getContextName(): string[];
getContextModel(): import("uniforms").DeepPartial<Model>;
getContextState(): {
disabled: boolean;
label: boolean;
placeholder: boolean;
readOnly: boolean;
showInlineError: boolean;
};
getContextSchema(): import("uniforms").Bridge;
getContextOnChange(): (key: string, value: any) => void;
getContextOnSubmit(): (event?: import("react").SyntheticEvent<Element, Event> | undefined) => any;
getModel(mode?: import("uniforms").ModelTransformMode | undefined, model?: import("uniforms").DeepPartial<Model> | undefined): import("uniforms").DeepPartial<Model>;
onReset(): void;
render(): JSX.Element;
context: any;
setState<K extends keyof State>(state: State | Pick<State, K> | ((prevState: Readonly<State>, props: Readonly<Props>) => State | Pick<State, K> | null) | null, callback?: (() => void) | undefined): void;
forceUpdate(callback?: (() => void) | undefined): void;
readonly props: Readonly<Props> & Readonly<{
children?: import("react").ReactNode;
}>;
state: Readonly<State>;
refs: {
[key: string]: import("react").ReactInstance;
};
shouldComponentUpdate?(nextProps: Readonly<Props>, nextState: Readonly<State>, nextContext: any): boolean;
componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
getSnapshotBeforeUpdate?(prevProps: Readonly<Props>, prevState: Readonly<State>): any;
componentWillMount?(): void;
UNSAFE_componentWillMount?(): void;
componentWillReceiveProps?(nextProps: Readonly<Props>, nextContext: any): void;
UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Props>, nextContext: any): void;
componentWillUpdate?(nextProps: Readonly<Props>, nextState: Readonly<State>, nextContext: any): void;
UNSAFE_componentWillUpdate?(nextProps: Readonly<Props>, nextState: Readonly<State>, nextContext: any): void;
};
Validated: typeof import("uniforms").Validated;
displayName: string;
defaultProps: {
onValidate(model: unknown, error: any): any;
validate: string;
autosave: boolean;
autosaveDelay: number;
error: null;
label: boolean;
model: any;
noValidate: boolean;
onSubmit(): void;
};
contextType?: import("react").Context<any> | undefined;
} & {
new <Model_1, Props_1 extends import("uniforms").QuickFormProps<Model_1> = import("uniforms").QuickFormProps<Model_1>, State_1 extends import("uniforms").QuickFormState<Model_1> = import("uniforms").QuickFormState<Model_1>>(props: Props_1): {
getNativeFormProps(): Record<string, any>;
getAutoField(): import("react").ComponentType<{
name: string;
}>;
getErrorsField(): import("react").ComponentType<{}>;
getSubmitField(): import("react").ComponentType<{}>;
componentDidMount(): void;
componentDidUpdate(prevProps: Props_1, prevState: State_1, snapshot: never): void;
componentWillUnmount(): void;
delayId?: any;
mounted: boolean;
reset: () => void;
change: (key: string, value: any) => void;
submit: (event?: import("react").SyntheticEvent<Element, Event> | undefined) => Promise<any>;
randomId: () => string;
getContext(): import("uniforms").Context<Model_1>;
getContextName(): string[];
getContextError(): any;
getContextModel(): import("uniforms").DeepPartial<Model_1>;
getContextState(): {
disabled: boolean;
label: boolean;
placeholder: boolean;
readOnly: boolean;
showInlineError: boolean;
};
getContextSchema(): import("uniforms").Bridge;
getContextOnChange(): (key: string, value: any) => void;
getContextOnSubmit(): (event?: import("react").SyntheticEvent<Element, Event> | undefined) => any;
getModel(mode?: import("uniforms").ModelTransformMode | undefined, model?: import("uniforms").DeepPartial<Model_1> | undefined): import("uniforms").DeepPartial<Model_1>;
onChange(key: string, value: any): void;
__reset(state: State_1): Partial<State_1>;
onReset(): void;
onSubmit(event?: import("react").SyntheticEvent<Element, Event> | undefined): Promise<any>;
render(): JSX.Element;
context: any;
setState<K_1 extends keyof State_1>(state: State_1 | Pick<State_1, K_1> | ((prevState: Readonly<State_1>, props: Readonly<Props_1>) => State_1 | Pick<State_1, K_1> | null) | null, callback?: (() => void) | undefined): void;
forceUpdate(callback?: (() => void) | undefined): void;
readonly props: Readonly<Props_1> & Readonly<{
children?: import("react").ReactNode;
}>;
state: Readonly<State_1>;
refs: {
[key: string]: import("react").ReactInstance;
};
shouldComponentUpdate?(nextProps: Readonly<Props_1>, nextState: Readonly<State_1>, nextContext: any): boolean;
componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
getSnapshotBeforeUpdate?(prevProps: Readonly<Props_1>, prevState: Readonly<State_1>): any;
componentWillMount?(): void;
UNSAFE_componentWillMount?(): void;
componentWillReceiveProps?(nextProps: Readonly<Props_1>, nextContext: any): void;
UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Props_1>, nextContext: any): void;
componentWillUpdate?(nextProps: Readonly<Props_1>, nextState: Readonly<State_1>, nextContext: any): void;
UNSAFE_componentWillUpdate?(nextProps: Readonly<Props_1>, nextState: Readonly<State_1>, nextContext: any): void;
};
Quick: typeof import("uniforms").Quick;
displayName: string;
defaultProps: {
autosave: boolean;
autosaveDelay: number;
error: null;
label: boolean;
model: any;
noValidate: boolean;
onSubmit(): void;
};
contextType?: import("react").Context<any> | undefined;
} & typeof import("uniforms").BaseForm;
export default _default;

222

es6/AutoForm.d.ts

@@ -1,2 +0,222 @@

declare const _default: any;
/// <reference types="react" />
declare const _default: {
new <Model, Props extends import("uniforms").AutoFormProps<Model> = import("uniforms").AutoFormProps<Model>, State extends import("uniforms").AutoFormState<Model> = import("uniforms").AutoFormState<Model>>(props: Props): {
componentDidUpdate(prevProps: Props, prevState: State, snapshot: never): void;
getNativeFormProps(): Record<string, any>;
getModel(mode: import("uniforms").ModelTransformMode): State["model"];
onChange(key: string, value: any): void;
__reset(state: State): Partial<State>;
validate: (key?: string | undefined, value?: any) => Promise<any>;
validateModel: (originalModel: any) => Promise<any>;
getContextError(): any;
getContext(): import("uniforms").Context<Model>;
onSubmit(event?: import("react").SyntheticEvent<Element, Event> | undefined): Promise<any>;
onValidate(key?: string | undefined, value?: any): Promise<any>;
onValidateModel(originalModel: Props["model"]): Promise<any>;
componentDidMount(): void;
componentWillUnmount(): void;
delayId?: any;
mounted: boolean;
reset: () => void;
change: (key: string, value: any) => void;
submit: (event?: import("react").SyntheticEvent<Element, Event> | undefined) => Promise<any>;
randomId: () => string;
getContextName(): string[];
getContextModel(): import("uniforms").DeepPartial<Model>;
getContextState(): {
disabled: boolean;
label: boolean;
placeholder: boolean;
readOnly: boolean;
showInlineError: boolean;
};
getContextSchema(): import("uniforms").Bridge;
getContextOnChange(): (key: string, value: any) => void;
getContextOnSubmit(): (event?: import("react").SyntheticEvent<Element, Event> | undefined) => any;
onReset(): void;
render(): JSX.Element;
context: any;
setState<K extends keyof State>(state: State | Pick<State, K> | ((prevState: Readonly<State>, props: Readonly<Props>) => State | Pick<State, K> | null) | null, callback?: (() => void) | undefined): void;
forceUpdate(callback?: (() => void) | undefined): void;
readonly props: Readonly<Props> & Readonly<{
children?: import("react").ReactNode;
}>;
state: Readonly<State>;
refs: {
[key: string]: import("react").ReactInstance;
};
shouldComponentUpdate?(nextProps: Readonly<Props>, nextState: Readonly<State>, nextContext: any): boolean;
componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
getSnapshotBeforeUpdate?(prevProps: Readonly<Props>, prevState: Readonly<State>): any;
componentWillMount?(): void;
UNSAFE_componentWillMount?(): void;
componentWillReceiveProps?(nextProps: Readonly<Props>, nextContext: any): void;
UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Props>, nextContext: any): void;
componentWillUpdate?(nextProps: Readonly<Props>, nextState: Readonly<State>, nextContext: any): void;
UNSAFE_componentWillUpdate?(nextProps: Readonly<Props>, nextState: Readonly<State>, nextContext: any): void;
};
Auto: typeof import("uniforms").Auto;
displayName: string;
Validated: typeof import("uniforms").Validated;
defaultProps: {
onValidate(model: unknown, error: any): any;
validate: string;
autosave: boolean;
autosaveDelay: number;
error: null;
label: boolean;
model: any;
noValidate: boolean;
onSubmit(): void;
} & {
autosave: boolean;
autosaveDelay: number;
error: null;
label: boolean;
model: any;
noValidate: boolean;
onSubmit(): void;
};
contextType?: import("react").Context<any> | undefined;
Quick: typeof import("uniforms").Quick;
} & {
new <Model_1, Props_1 extends import("uniforms").ValidatedFormProps<Model_1> = import("uniforms").ValidatedFormProps<Model_1>, State_1 extends import("uniforms").ValidatedFormState<Model_1> = import("uniforms").ValidatedFormState<Model_1>>(props: Props_1): {
validate: (key?: string | undefined, value?: any) => Promise<any>;
validateModel: (originalModel: any) => Promise<any>;
getContextError(): any;
getContext(): import("uniforms").Context<Model_1>;
getNativeFormProps(): Record<string, any>;
componentDidUpdate(prevProps: Props_1, prevState: State_1, snapshot: never): void;
onChange(key: string, value: any): void;
__reset(state: State_1): Partial<State_1>;
onSubmit(event?: import("react").SyntheticEvent<Element, Event> | undefined): Promise<any>;
onValidate(key?: string | undefined, value?: any): Promise<any>;
onValidateModel(originalModel: Props_1["model"]): Promise<any>;
componentDidMount(): void;
componentWillUnmount(): void;
delayId?: any;
mounted: boolean;
reset: () => void;
change: (key: string, value: any) => void;
submit: (event?: import("react").SyntheticEvent<Element, Event> | undefined) => Promise<any>;
randomId: () => string;
getContextName(): string[];
getContextModel(): import("uniforms").DeepPartial<Model_1>;
getContextState(): {
disabled: boolean;
label: boolean;
placeholder: boolean;
readOnly: boolean;
showInlineError: boolean;
};
getContextSchema(): import("uniforms").Bridge;
getContextOnChange(): (key: string, value: any) => void;
getContextOnSubmit(): (event?: import("react").SyntheticEvent<Element, Event> | undefined) => any;
getModel(mode?: import("uniforms").ModelTransformMode | undefined, model?: import("uniforms").DeepPartial<Model_1> | undefined): import("uniforms").DeepPartial<Model_1>;
onReset(): void;
render(): JSX.Element;
context: any;
setState<K_1 extends keyof State_1>(state: State_1 | Pick<State_1, K_1> | ((prevState: Readonly<State_1>, props: Readonly<Props_1>) => State_1 | Pick<State_1, K_1> | null) | null, callback?: (() => void) | undefined): void;
forceUpdate(callback?: (() => void) | undefined): void;
readonly props: Readonly<Props_1> & Readonly<{
children?: import("react").ReactNode;
}>;
state: Readonly<State_1>;
refs: {
[key: string]: import("react").ReactInstance;
};
shouldComponentUpdate?(nextProps: Readonly<Props_1>, nextState: Readonly<State_1>, nextContext: any): boolean;
componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
getSnapshotBeforeUpdate?(prevProps: Readonly<Props_1>, prevState: Readonly<State_1>): any;
componentWillMount?(): void;
UNSAFE_componentWillMount?(): void;
componentWillReceiveProps?(nextProps: Readonly<Props_1>, nextContext: any): void;
UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Props_1>, nextContext: any): void;
componentWillUpdate?(nextProps: Readonly<Props_1>, nextState: Readonly<State_1>, nextContext: any): void;
UNSAFE_componentWillUpdate?(nextProps: Readonly<Props_1>, nextState: Readonly<State_1>, nextContext: any): void;
};
Validated: typeof import("uniforms").Validated;
displayName: string;
defaultProps: {
onValidate(model: unknown, error: any): any;
validate: string;
autosave: boolean;
autosaveDelay: number;
error: null;
label: boolean;
model: any;
noValidate: boolean;
onSubmit(): void;
};
contextType?: import("react").Context<any> | undefined;
} & {
new <Model_2, Props_2 extends import("uniforms").QuickFormProps<Model_2> = import("uniforms").QuickFormProps<Model_2>, State_2 extends import("uniforms").QuickFormState<Model_2> = import("uniforms").QuickFormState<Model_2>>(props: Props_2): {
getNativeFormProps(): Record<string, any>;
getAutoField(): import("react").ComponentType<{
name: string;
}>;
getErrorsField(): import("react").ComponentType<{}>;
getSubmitField(): import("react").ComponentType<{}>;
componentDidMount(): void;
componentDidUpdate(prevProps: Props_2, prevState: State_2, snapshot: never): void;
componentWillUnmount(): void;
delayId?: any;
mounted: boolean;
reset: () => void;
change: (key: string, value: any) => void;
submit: (event?: import("react").SyntheticEvent<Element, Event> | undefined) => Promise<any>;
randomId: () => string;
getContext(): import("uniforms").Context<Model_2>;
getContextName(): string[];
getContextError(): any;
getContextModel(): import("uniforms").DeepPartial<Model_2>;
getContextState(): {
disabled: boolean;
label: boolean;
placeholder: boolean;
readOnly: boolean;
showInlineError: boolean;
};
getContextSchema(): import("uniforms").Bridge;
getContextOnChange(): (key: string, value: any) => void;
getContextOnSubmit(): (event?: import("react").SyntheticEvent<Element, Event> | undefined) => any;
getModel(mode?: import("uniforms").ModelTransformMode | undefined, model?: import("uniforms").DeepPartial<Model_2> | undefined): import("uniforms").DeepPartial<Model_2>;
onChange(key: string, value: any): void;
__reset(state: State_2): Partial<State_2>;
onReset(): void;
onSubmit(event?: import("react").SyntheticEvent<Element, Event> | undefined): Promise<any>;
render(): JSX.Element;
context: any;
setState<K_2 extends keyof State_2>(state: State_2 | Pick<State_2, K_2> | ((prevState: Readonly<State_2>, props: Readonly<Props_2>) => State_2 | Pick<State_2, K_2> | null) | null, callback?: (() => void) | undefined): void;
forceUpdate(callback?: (() => void) | undefined): void;
readonly props: Readonly<Props_2> & Readonly<{
children?: import("react").ReactNode;
}>;
state: Readonly<State_2>;
refs: {
[key: string]: import("react").ReactInstance;
};
shouldComponentUpdate?(nextProps: Readonly<Props_2>, nextState: Readonly<State_2>, nextContext: any): boolean;
componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
getSnapshotBeforeUpdate?(prevProps: Readonly<Props_2>, prevState: Readonly<State_2>): any;
componentWillMount?(): void;
UNSAFE_componentWillMount?(): void;
componentWillReceiveProps?(nextProps: Readonly<Props_2>, nextContext: any): void;
UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Props_2>, nextContext: any): void;
componentWillUpdate?(nextProps: Readonly<Props_2>, nextState: Readonly<State_2>, nextContext: any): void;
UNSAFE_componentWillUpdate?(nextProps: Readonly<Props_2>, nextState: Readonly<State_2>, nextContext: any): void;
};
Quick: typeof import("uniforms").Quick;
displayName: string;
defaultProps: {
autosave: boolean;
autosaveDelay: number;
error: null;
label: boolean;
model: any;
noValidate: boolean;
onSubmit(): void;
};
contextType?: import("react").Context<any> | undefined;
} & typeof import("uniforms").BaseForm;
export default _default;

3

es6/BaseForm.d.ts

@@ -1,2 +0,3 @@

declare const _default: any;
import { BaseForm } from 'uniforms';
declare const _default: typeof BaseForm;
export default _default;

72

es6/QuickForm.d.ts

@@ -1,2 +0,72 @@

declare const _default: any;
/// <reference types="react" />
declare const _default: {
new <Model, Props extends import("uniforms").QuickFormProps<Model> = import("uniforms").QuickFormProps<Model>, State extends import("uniforms").QuickFormState<Model> = import("uniforms").QuickFormState<Model>>(props: Props): {
getNativeFormProps(): Record<string, any>;
getAutoField(): import("react").ComponentType<{
name: string;
}>;
getErrorsField(): import("react").ComponentType<{}>;
getSubmitField(): import("react").ComponentType<{}>;
componentDidMount(): void;
componentDidUpdate(prevProps: Props, prevState: State, snapshot: never): void;
componentWillUnmount(): void;
delayId?: any;
mounted: boolean;
reset: () => void;
change: (key: string, value: any) => void;
submit: (event?: import("react").SyntheticEvent<Element, Event> | undefined) => Promise<any>;
randomId: () => string;
getContext(): import("uniforms").Context<Model>;
getContextName(): string[];
getContextError(): any;
getContextModel(): import("uniforms").DeepPartial<Model>;
getContextState(): {
disabled: boolean;
label: boolean;
placeholder: boolean;
readOnly: boolean;
showInlineError: boolean;
};
getContextSchema(): import("uniforms").Bridge;
getContextOnChange(): (key: string, value: any) => void;
getContextOnSubmit(): (event?: import("react").SyntheticEvent<Element, Event> | undefined) => any;
getModel(mode?: import("uniforms").ModelTransformMode | undefined, model?: import("uniforms").DeepPartial<Model> | undefined): import("uniforms").DeepPartial<Model>;
onChange(key: string, value: any): void;
__reset(state: State): Partial<State>;
onReset(): void;
onSubmit(event?: import("react").SyntheticEvent<Element, Event> | undefined): Promise<any>;
render(): JSX.Element;
context: any;
setState<K extends keyof State>(state: State | Pick<State, K> | ((prevState: Readonly<State>, props: Readonly<Props>) => State | Pick<State, K> | null) | null, callback?: (() => void) | undefined): void;
forceUpdate(callback?: (() => void) | undefined): void;
readonly props: Readonly<Props> & Readonly<{
children?: import("react").ReactNode;
}>;
state: Readonly<State>;
refs: {
[key: string]: import("react").ReactInstance;
};
shouldComponentUpdate?(nextProps: Readonly<Props>, nextState: Readonly<State>, nextContext: any): boolean;
componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
getSnapshotBeforeUpdate?(prevProps: Readonly<Props>, prevState: Readonly<State>): any;
componentWillMount?(): void;
UNSAFE_componentWillMount?(): void;
componentWillReceiveProps?(nextProps: Readonly<Props>, nextContext: any): void;
UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Props>, nextContext: any): void;
componentWillUpdate?(nextProps: Readonly<Props>, nextState: Readonly<State>, nextContext: any): void;
UNSAFE_componentWillUpdate?(nextProps: Readonly<Props>, nextState: Readonly<State>, nextContext: any): void;
};
Quick: typeof import("uniforms").Quick;
displayName: string;
defaultProps: {
autosave: boolean;
autosaveDelay: number;
error: null;
label: boolean;
model: any;
noValidate: boolean;
onSubmit(): void;
};
contextType?: import("react").Context<any> | undefined;
} & typeof import("uniforms").BaseForm;
export default _default;

73

es6/ValidatedForm.d.ts

@@ -1,2 +0,73 @@

declare const _default: any;
/// <reference types="react" />
declare const _default: {
new <Model, Props extends import("uniforms").ValidatedFormProps<Model> = import("uniforms").ValidatedFormProps<Model>, State extends import("uniforms").ValidatedFormState<Model> = import("uniforms").ValidatedFormState<Model>>(props: Props): {
validate: (key?: string | undefined, value?: any) => Promise<any>;
validateModel: (originalModel: any) => Promise<any>;
getContextError(): any;
getContext(): import("uniforms").Context<Model>;
getNativeFormProps(): Record<string, any>;
componentDidUpdate(prevProps: Props, prevState: State, snapshot: never): void;
onChange(key: string, value: any): void;
__reset(state: State): Partial<State>;
onSubmit(event?: import("react").SyntheticEvent<Element, Event> | undefined): Promise<any>;
onValidate(key?: string | undefined, value?: any): Promise<any>;
onValidateModel(originalModel: Props["model"]): Promise<any>;
componentDidMount(): void;
componentWillUnmount(): void;
delayId?: any;
mounted: boolean;
reset: () => void;
change: (key: string, value: any) => void;
submit: (event?: import("react").SyntheticEvent<Element, Event> | undefined) => Promise<any>;
randomId: () => string;
getContextName(): string[];
getContextModel(): import("uniforms").DeepPartial<Model>;
getContextState(): {
disabled: boolean;
label: boolean;
placeholder: boolean;
readOnly: boolean;
showInlineError: boolean;
};
getContextSchema(): import("uniforms").Bridge;
getContextOnChange(): (key: string, value: any) => void;
getContextOnSubmit(): (event?: import("react").SyntheticEvent<Element, Event> | undefined) => any;
getModel(mode?: import("uniforms").ModelTransformMode | undefined, model?: import("uniforms").DeepPartial<Model> | undefined): import("uniforms").DeepPartial<Model>;
onReset(): void;
render(): JSX.Element;
context: any;
setState<K extends keyof State>(state: State | Pick<State, K> | ((prevState: Readonly<State>, props: Readonly<Props>) => State | Pick<State, K> | null) | null, callback?: (() => void) | undefined): void;
forceUpdate(callback?: (() => void) | undefined): void;
readonly props: Readonly<Props> & Readonly<{
children?: import("react").ReactNode;
}>;
state: Readonly<State>;
refs: {
[key: string]: import("react").ReactInstance;
};
shouldComponentUpdate?(nextProps: Readonly<Props>, nextState: Readonly<State>, nextContext: any): boolean;
componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
getSnapshotBeforeUpdate?(prevProps: Readonly<Props>, prevState: Readonly<State>): any;
componentWillMount?(): void;
UNSAFE_componentWillMount?(): void;
componentWillReceiveProps?(nextProps: Readonly<Props>, nextContext: any): void;
UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Props>, nextContext: any): void;
componentWillUpdate?(nextProps: Readonly<Props>, nextState: Readonly<State>, nextContext: any): void;
UNSAFE_componentWillUpdate?(nextProps: Readonly<Props>, nextState: Readonly<State>, nextContext: any): void;
};
Validated: typeof import("uniforms").Validated;
displayName: string;
defaultProps: {
onValidate(model: unknown, error: any): any;
validate: string;
autosave: boolean;
autosaveDelay: number;
error: null;
label: boolean;
model: any;
noValidate: boolean;
onSubmit(): void;
};
contextType?: import("react").Context<any> | undefined;
} & typeof import("uniforms").BaseForm;
export default _default;

142

es6/ValidatedQuickForm.d.ts

@@ -1,2 +0,142 @@

declare const _default: any;
/// <reference types="react" />
declare const _default: {
new <Model, Props extends import("uniforms").ValidatedFormProps<Model> = import("uniforms").ValidatedFormProps<Model>, State extends import("uniforms").ValidatedFormState<Model> = import("uniforms").ValidatedFormState<Model>>(props: Props): {
validate: (key?: string | undefined, value?: any) => Promise<any>;
validateModel: (originalModel: any) => Promise<any>;
getContextError(): any;
getContext(): import("uniforms").Context<Model>;
getNativeFormProps(): Record<string, any>;
componentDidUpdate(prevProps: Props, prevState: State, snapshot: never): void;
onChange(key: string, value: any): void;
__reset(state: State): Partial<State>;
onSubmit(event?: import("react").SyntheticEvent<Element, Event> | undefined): Promise<any>;
onValidate(key?: string | undefined, value?: any): Promise<any>;
onValidateModel(originalModel: Props["model"]): Promise<any>;
componentDidMount(): void;
componentWillUnmount(): void;
delayId?: any;
mounted: boolean;
reset: () => void;
change: (key: string, value: any) => void;
submit: (event?: import("react").SyntheticEvent<Element, Event> | undefined) => Promise<any>;
randomId: () => string;
getContextName(): string[];
getContextModel(): import("uniforms").DeepPartial<Model>;
getContextState(): {
disabled: boolean;
label: boolean;
placeholder: boolean;
readOnly: boolean;
showInlineError: boolean;
};
getContextSchema(): import("uniforms").Bridge;
getContextOnChange(): (key: string, value: any) => void;
getContextOnSubmit(): (event?: import("react").SyntheticEvent<Element, Event> | undefined) => any;
getModel(mode?: import("uniforms").ModelTransformMode | undefined, model?: import("uniforms").DeepPartial<Model> | undefined): import("uniforms").DeepPartial<Model>;
onReset(): void;
render(): JSX.Element;
context: any;
setState<K extends keyof State>(state: State | Pick<State, K> | ((prevState: Readonly<State>, props: Readonly<Props>) => State | Pick<State, K> | null) | null, callback?: (() => void) | undefined): void;
forceUpdate(callback?: (() => void) | undefined): void;
readonly props: Readonly<Props> & Readonly<{
children?: import("react").ReactNode;
}>;
state: Readonly<State>;
refs: {
[key: string]: import("react").ReactInstance;
};
shouldComponentUpdate?(nextProps: Readonly<Props>, nextState: Readonly<State>, nextContext: any): boolean;
componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
getSnapshotBeforeUpdate?(prevProps: Readonly<Props>, prevState: Readonly<State>): any;
componentWillMount?(): void;
UNSAFE_componentWillMount?(): void;
componentWillReceiveProps?(nextProps: Readonly<Props>, nextContext: any): void;
UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Props>, nextContext: any): void;
componentWillUpdate?(nextProps: Readonly<Props>, nextState: Readonly<State>, nextContext: any): void;
UNSAFE_componentWillUpdate?(nextProps: Readonly<Props>, nextState: Readonly<State>, nextContext: any): void;
};
Validated: typeof import("uniforms").Validated;
displayName: string;
defaultProps: {
onValidate(model: unknown, error: any): any;
validate: string;
autosave: boolean;
autosaveDelay: number;
error: null;
label: boolean;
model: any;
noValidate: boolean;
onSubmit(): void;
};
contextType?: import("react").Context<any> | undefined;
} & {
new <Model_1, Props_1 extends import("uniforms").QuickFormProps<Model_1> = import("uniforms").QuickFormProps<Model_1>, State_1 extends import("uniforms").QuickFormState<Model_1> = import("uniforms").QuickFormState<Model_1>>(props: Props_1): {
getNativeFormProps(): Record<string, any>;
getAutoField(): import("react").ComponentType<{
name: string;
}>;
getErrorsField(): import("react").ComponentType<{}>;
getSubmitField(): import("react").ComponentType<{}>;
componentDidMount(): void;
componentDidUpdate(prevProps: Props_1, prevState: State_1, snapshot: never): void;
componentWillUnmount(): void;
delayId?: any;
mounted: boolean;
reset: () => void;
change: (key: string, value: any) => void;
submit: (event?: import("react").SyntheticEvent<Element, Event> | undefined) => Promise<any>;
randomId: () => string;
getContext(): import("uniforms").Context<Model_1>;
getContextName(): string[];
getContextError(): any;
getContextModel(): import("uniforms").DeepPartial<Model_1>;
getContextState(): {
disabled: boolean;
label: boolean;
placeholder: boolean;
readOnly: boolean;
showInlineError: boolean;
};
getContextSchema(): import("uniforms").Bridge;
getContextOnChange(): (key: string, value: any) => void;
getContextOnSubmit(): (event?: import("react").SyntheticEvent<Element, Event> | undefined) => any;
getModel(mode?: import("uniforms").ModelTransformMode | undefined, model?: import("uniforms").DeepPartial<Model_1> | undefined): import("uniforms").DeepPartial<Model_1>;
onChange(key: string, value: any): void;
__reset(state: State_1): Partial<State_1>;
onReset(): void;
onSubmit(event?: import("react").SyntheticEvent<Element, Event> | undefined): Promise<any>;
render(): JSX.Element;
context: any;
setState<K_1 extends keyof State_1>(state: State_1 | Pick<State_1, K_1> | ((prevState: Readonly<State_1>, props: Readonly<Props_1>) => State_1 | Pick<State_1, K_1> | null) | null, callback?: (() => void) | undefined): void;
forceUpdate(callback?: (() => void) | undefined): void;
readonly props: Readonly<Props_1> & Readonly<{
children?: import("react").ReactNode;
}>;
state: Readonly<State_1>;
refs: {
[key: string]: import("react").ReactInstance;
};
shouldComponentUpdate?(nextProps: Readonly<Props_1>, nextState: Readonly<State_1>, nextContext: any): boolean;
componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
getSnapshotBeforeUpdate?(prevProps: Readonly<Props_1>, prevState: Readonly<State_1>): any;
componentWillMount?(): void;
UNSAFE_componentWillMount?(): void;
componentWillReceiveProps?(nextProps: Readonly<Props_1>, nextContext: any): void;
UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Props_1>, nextContext: any): void;
componentWillUpdate?(nextProps: Readonly<Props_1>, nextState: Readonly<State_1>, nextContext: any): void;
UNSAFE_componentWillUpdate?(nextProps: Readonly<Props_1>, nextState: Readonly<State_1>, nextContext: any): void;
};
Quick: typeof import("uniforms").Quick;
displayName: string;
defaultProps: {
autosave: boolean;
autosaveDelay: number;
error: null;
label: boolean;
model: any;
noValidate: boolean;
onSubmit(): void;
};
contextType?: import("react").Context<any> | undefined;
} & typeof import("uniforms").BaseForm;
export default _default;

222

esm/AutoForm.d.ts

@@ -1,2 +0,222 @@

declare const _default: any;
/// <reference types="react" />
declare const _default: {
new <Model, Props extends import("uniforms").AutoFormProps<Model> = import("uniforms").AutoFormProps<Model>, State extends import("uniforms").AutoFormState<Model> = import("uniforms").AutoFormState<Model>>(props: Props): {
componentDidUpdate(prevProps: Props, prevState: State, snapshot: never): void;
getNativeFormProps(): Record<string, any>;
getModel(mode: import("uniforms").ModelTransformMode): State["model"];
onChange(key: string, value: any): void;
__reset(state: State): Partial<State>;
validate: (key?: string | undefined, value?: any) => Promise<any>;
validateModel: (originalModel: any) => Promise<any>;
getContextError(): any;
getContext(): import("uniforms").Context<Model>;
onSubmit(event?: import("react").SyntheticEvent<Element, Event> | undefined): Promise<any>;
onValidate(key?: string | undefined, value?: any): Promise<any>;
onValidateModel(originalModel: Props["model"]): Promise<any>;
componentDidMount(): void;
componentWillUnmount(): void;
delayId?: any;
mounted: boolean;
reset: () => void;
change: (key: string, value: any) => void;
submit: (event?: import("react").SyntheticEvent<Element, Event> | undefined) => Promise<any>;
randomId: () => string;
getContextName(): string[];
getContextModel(): import("uniforms").DeepPartial<Model>;
getContextState(): {
disabled: boolean;
label: boolean;
placeholder: boolean;
readOnly: boolean;
showInlineError: boolean;
};
getContextSchema(): import("uniforms").Bridge;
getContextOnChange(): (key: string, value: any) => void;
getContextOnSubmit(): (event?: import("react").SyntheticEvent<Element, Event> | undefined) => any;
onReset(): void;
render(): JSX.Element;
context: any;
setState<K extends keyof State>(state: State | Pick<State, K> | ((prevState: Readonly<State>, props: Readonly<Props>) => State | Pick<State, K> | null) | null, callback?: (() => void) | undefined): void;
forceUpdate(callback?: (() => void) | undefined): void;
readonly props: Readonly<Props> & Readonly<{
children?: import("react").ReactNode;
}>;
state: Readonly<State>;
refs: {
[key: string]: import("react").ReactInstance;
};
shouldComponentUpdate?(nextProps: Readonly<Props>, nextState: Readonly<State>, nextContext: any): boolean;
componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
getSnapshotBeforeUpdate?(prevProps: Readonly<Props>, prevState: Readonly<State>): any;
componentWillMount?(): void;
UNSAFE_componentWillMount?(): void;
componentWillReceiveProps?(nextProps: Readonly<Props>, nextContext: any): void;
UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Props>, nextContext: any): void;
componentWillUpdate?(nextProps: Readonly<Props>, nextState: Readonly<State>, nextContext: any): void;
UNSAFE_componentWillUpdate?(nextProps: Readonly<Props>, nextState: Readonly<State>, nextContext: any): void;
};
Auto: typeof import("uniforms").Auto;
displayName: string;
Validated: typeof import("uniforms").Validated;
defaultProps: {
onValidate(model: unknown, error: any): any;
validate: string;
autosave: boolean;
autosaveDelay: number;
error: null;
label: boolean;
model: any;
noValidate: boolean;
onSubmit(): void;
} & {
autosave: boolean;
autosaveDelay: number;
error: null;
label: boolean;
model: any;
noValidate: boolean;
onSubmit(): void;
};
contextType?: import("react").Context<any> | undefined;
Quick: typeof import("uniforms").Quick;
} & {
new <Model_1, Props_1 extends import("uniforms").ValidatedFormProps<Model_1> = import("uniforms").ValidatedFormProps<Model_1>, State_1 extends import("uniforms").ValidatedFormState<Model_1> = import("uniforms").ValidatedFormState<Model_1>>(props: Props_1): {
validate: (key?: string | undefined, value?: any) => Promise<any>;
validateModel: (originalModel: any) => Promise<any>;
getContextError(): any;
getContext(): import("uniforms").Context<Model_1>;
getNativeFormProps(): Record<string, any>;
componentDidUpdate(prevProps: Props_1, prevState: State_1, snapshot: never): void;
onChange(key: string, value: any): void;
__reset(state: State_1): Partial<State_1>;
onSubmit(event?: import("react").SyntheticEvent<Element, Event> | undefined): Promise<any>;
onValidate(key?: string | undefined, value?: any): Promise<any>;
onValidateModel(originalModel: Props_1["model"]): Promise<any>;
componentDidMount(): void;
componentWillUnmount(): void;
delayId?: any;
mounted: boolean;
reset: () => void;
change: (key: string, value: any) => void;
submit: (event?: import("react").SyntheticEvent<Element, Event> | undefined) => Promise<any>;
randomId: () => string;
getContextName(): string[];
getContextModel(): import("uniforms").DeepPartial<Model_1>;
getContextState(): {
disabled: boolean;
label: boolean;
placeholder: boolean;
readOnly: boolean;
showInlineError: boolean;
};
getContextSchema(): import("uniforms").Bridge;
getContextOnChange(): (key: string, value: any) => void;
getContextOnSubmit(): (event?: import("react").SyntheticEvent<Element, Event> | undefined) => any;
getModel(mode?: import("uniforms").ModelTransformMode | undefined, model?: import("uniforms").DeepPartial<Model_1> | undefined): import("uniforms").DeepPartial<Model_1>;
onReset(): void;
render(): JSX.Element;
context: any;
setState<K_1 extends keyof State_1>(state: State_1 | Pick<State_1, K_1> | ((prevState: Readonly<State_1>, props: Readonly<Props_1>) => State_1 | Pick<State_1, K_1> | null) | null, callback?: (() => void) | undefined): void;
forceUpdate(callback?: (() => void) | undefined): void;
readonly props: Readonly<Props_1> & Readonly<{
children?: import("react").ReactNode;
}>;
state: Readonly<State_1>;
refs: {
[key: string]: import("react").ReactInstance;
};
shouldComponentUpdate?(nextProps: Readonly<Props_1>, nextState: Readonly<State_1>, nextContext: any): boolean;
componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
getSnapshotBeforeUpdate?(prevProps: Readonly<Props_1>, prevState: Readonly<State_1>): any;
componentWillMount?(): void;
UNSAFE_componentWillMount?(): void;
componentWillReceiveProps?(nextProps: Readonly<Props_1>, nextContext: any): void;
UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Props_1>, nextContext: any): void;
componentWillUpdate?(nextProps: Readonly<Props_1>, nextState: Readonly<State_1>, nextContext: any): void;
UNSAFE_componentWillUpdate?(nextProps: Readonly<Props_1>, nextState: Readonly<State_1>, nextContext: any): void;
};
Validated: typeof import("uniforms").Validated;
displayName: string;
defaultProps: {
onValidate(model: unknown, error: any): any;
validate: string;
autosave: boolean;
autosaveDelay: number;
error: null;
label: boolean;
model: any;
noValidate: boolean;
onSubmit(): void;
};
contextType?: import("react").Context<any> | undefined;
} & {
new <Model_2, Props_2 extends import("uniforms").QuickFormProps<Model_2> = import("uniforms").QuickFormProps<Model_2>, State_2 extends import("uniforms").QuickFormState<Model_2> = import("uniforms").QuickFormState<Model_2>>(props: Props_2): {
getNativeFormProps(): Record<string, any>;
getAutoField(): import("react").ComponentType<{
name: string;
}>;
getErrorsField(): import("react").ComponentType<{}>;
getSubmitField(): import("react").ComponentType<{}>;
componentDidMount(): void;
componentDidUpdate(prevProps: Props_2, prevState: State_2, snapshot: never): void;
componentWillUnmount(): void;
delayId?: any;
mounted: boolean;
reset: () => void;
change: (key: string, value: any) => void;
submit: (event?: import("react").SyntheticEvent<Element, Event> | undefined) => Promise<any>;
randomId: () => string;
getContext(): import("uniforms").Context<Model_2>;
getContextName(): string[];
getContextError(): any;
getContextModel(): import("uniforms").DeepPartial<Model_2>;
getContextState(): {
disabled: boolean;
label: boolean;
placeholder: boolean;
readOnly: boolean;
showInlineError: boolean;
};
getContextSchema(): import("uniforms").Bridge;
getContextOnChange(): (key: string, value: any) => void;
getContextOnSubmit(): (event?: import("react").SyntheticEvent<Element, Event> | undefined) => any;
getModel(mode?: import("uniforms").ModelTransformMode | undefined, model?: import("uniforms").DeepPartial<Model_2> | undefined): import("uniforms").DeepPartial<Model_2>;
onChange(key: string, value: any): void;
__reset(state: State_2): Partial<State_2>;
onReset(): void;
onSubmit(event?: import("react").SyntheticEvent<Element, Event> | undefined): Promise<any>;
render(): JSX.Element;
context: any;
setState<K_2 extends keyof State_2>(state: State_2 | Pick<State_2, K_2> | ((prevState: Readonly<State_2>, props: Readonly<Props_2>) => State_2 | Pick<State_2, K_2> | null) | null, callback?: (() => void) | undefined): void;
forceUpdate(callback?: (() => void) | undefined): void;
readonly props: Readonly<Props_2> & Readonly<{
children?: import("react").ReactNode;
}>;
state: Readonly<State_2>;
refs: {
[key: string]: import("react").ReactInstance;
};
shouldComponentUpdate?(nextProps: Readonly<Props_2>, nextState: Readonly<State_2>, nextContext: any): boolean;
componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
getSnapshotBeforeUpdate?(prevProps: Readonly<Props_2>, prevState: Readonly<State_2>): any;
componentWillMount?(): void;
UNSAFE_componentWillMount?(): void;
componentWillReceiveProps?(nextProps: Readonly<Props_2>, nextContext: any): void;
UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Props_2>, nextContext: any): void;
componentWillUpdate?(nextProps: Readonly<Props_2>, nextState: Readonly<State_2>, nextContext: any): void;
UNSAFE_componentWillUpdate?(nextProps: Readonly<Props_2>, nextState: Readonly<State_2>, nextContext: any): void;
};
Quick: typeof import("uniforms").Quick;
displayName: string;
defaultProps: {
autosave: boolean;
autosaveDelay: number;
error: null;
label: boolean;
model: any;
noValidate: boolean;
onSubmit(): void;
};
contextType?: import("react").Context<any> | undefined;
} & typeof import("uniforms").BaseForm;
export default _default;

3

esm/BaseForm.d.ts

@@ -1,2 +0,3 @@

declare const _default: any;
import { BaseForm } from 'uniforms';
declare const _default: typeof BaseForm;
export default _default;

72

esm/QuickForm.d.ts

@@ -1,2 +0,72 @@

declare const _default: any;
/// <reference types="react" />
declare const _default: {
new <Model, Props extends import("uniforms").QuickFormProps<Model> = import("uniforms").QuickFormProps<Model>, State extends import("uniforms").QuickFormState<Model> = import("uniforms").QuickFormState<Model>>(props: Props): {
getNativeFormProps(): Record<string, any>;
getAutoField(): import("react").ComponentType<{
name: string;
}>;
getErrorsField(): import("react").ComponentType<{}>;
getSubmitField(): import("react").ComponentType<{}>;
componentDidMount(): void;
componentDidUpdate(prevProps: Props, prevState: State, snapshot: never): void;
componentWillUnmount(): void;
delayId?: any;
mounted: boolean;
reset: () => void;
change: (key: string, value: any) => void;
submit: (event?: import("react").SyntheticEvent<Element, Event> | undefined) => Promise<any>;
randomId: () => string;
getContext(): import("uniforms").Context<Model>;
getContextName(): string[];
getContextError(): any;
getContextModel(): import("uniforms").DeepPartial<Model>;
getContextState(): {
disabled: boolean;
label: boolean;
placeholder: boolean;
readOnly: boolean;
showInlineError: boolean;
};
getContextSchema(): import("uniforms").Bridge;
getContextOnChange(): (key: string, value: any) => void;
getContextOnSubmit(): (event?: import("react").SyntheticEvent<Element, Event> | undefined) => any;
getModel(mode?: import("uniforms").ModelTransformMode | undefined, model?: import("uniforms").DeepPartial<Model> | undefined): import("uniforms").DeepPartial<Model>;
onChange(key: string, value: any): void;
__reset(state: State): Partial<State>;
onReset(): void;
onSubmit(event?: import("react").SyntheticEvent<Element, Event> | undefined): Promise<any>;
render(): JSX.Element;
context: any;
setState<K extends keyof State>(state: State | Pick<State, K> | ((prevState: Readonly<State>, props: Readonly<Props>) => State | Pick<State, K> | null) | null, callback?: (() => void) | undefined): void;
forceUpdate(callback?: (() => void) | undefined): void;
readonly props: Readonly<Props> & Readonly<{
children?: import("react").ReactNode;
}>;
state: Readonly<State>;
refs: {
[key: string]: import("react").ReactInstance;
};
shouldComponentUpdate?(nextProps: Readonly<Props>, nextState: Readonly<State>, nextContext: any): boolean;
componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
getSnapshotBeforeUpdate?(prevProps: Readonly<Props>, prevState: Readonly<State>): any;
componentWillMount?(): void;
UNSAFE_componentWillMount?(): void;
componentWillReceiveProps?(nextProps: Readonly<Props>, nextContext: any): void;
UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Props>, nextContext: any): void;
componentWillUpdate?(nextProps: Readonly<Props>, nextState: Readonly<State>, nextContext: any): void;
UNSAFE_componentWillUpdate?(nextProps: Readonly<Props>, nextState: Readonly<State>, nextContext: any): void;
};
Quick: typeof import("uniforms").Quick;
displayName: string;
defaultProps: {
autosave: boolean;
autosaveDelay: number;
error: null;
label: boolean;
model: any;
noValidate: boolean;
onSubmit(): void;
};
contextType?: import("react").Context<any> | undefined;
} & typeof import("uniforms").BaseForm;
export default _default;

73

esm/ValidatedForm.d.ts

@@ -1,2 +0,73 @@

declare const _default: any;
/// <reference types="react" />
declare const _default: {
new <Model, Props extends import("uniforms").ValidatedFormProps<Model> = import("uniforms").ValidatedFormProps<Model>, State extends import("uniforms").ValidatedFormState<Model> = import("uniforms").ValidatedFormState<Model>>(props: Props): {
validate: (key?: string | undefined, value?: any) => Promise<any>;
validateModel: (originalModel: any) => Promise<any>;
getContextError(): any;
getContext(): import("uniforms").Context<Model>;
getNativeFormProps(): Record<string, any>;
componentDidUpdate(prevProps: Props, prevState: State, snapshot: never): void;
onChange(key: string, value: any): void;
__reset(state: State): Partial<State>;
onSubmit(event?: import("react").SyntheticEvent<Element, Event> | undefined): Promise<any>;
onValidate(key?: string | undefined, value?: any): Promise<any>;
onValidateModel(originalModel: Props["model"]): Promise<any>;
componentDidMount(): void;
componentWillUnmount(): void;
delayId?: any;
mounted: boolean;
reset: () => void;
change: (key: string, value: any) => void;
submit: (event?: import("react").SyntheticEvent<Element, Event> | undefined) => Promise<any>;
randomId: () => string;
getContextName(): string[];
getContextModel(): import("uniforms").DeepPartial<Model>;
getContextState(): {
disabled: boolean;
label: boolean;
placeholder: boolean;
readOnly: boolean;
showInlineError: boolean;
};
getContextSchema(): import("uniforms").Bridge;
getContextOnChange(): (key: string, value: any) => void;
getContextOnSubmit(): (event?: import("react").SyntheticEvent<Element, Event> | undefined) => any;
getModel(mode?: import("uniforms").ModelTransformMode | undefined, model?: import("uniforms").DeepPartial<Model> | undefined): import("uniforms").DeepPartial<Model>;
onReset(): void;
render(): JSX.Element;
context: any;
setState<K extends keyof State>(state: State | Pick<State, K> | ((prevState: Readonly<State>, props: Readonly<Props>) => State | Pick<State, K> | null) | null, callback?: (() => void) | undefined): void;
forceUpdate(callback?: (() => void) | undefined): void;
readonly props: Readonly<Props> & Readonly<{
children?: import("react").ReactNode;
}>;
state: Readonly<State>;
refs: {
[key: string]: import("react").ReactInstance;
};
shouldComponentUpdate?(nextProps: Readonly<Props>, nextState: Readonly<State>, nextContext: any): boolean;
componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
getSnapshotBeforeUpdate?(prevProps: Readonly<Props>, prevState: Readonly<State>): any;
componentWillMount?(): void;
UNSAFE_componentWillMount?(): void;
componentWillReceiveProps?(nextProps: Readonly<Props>, nextContext: any): void;
UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Props>, nextContext: any): void;
componentWillUpdate?(nextProps: Readonly<Props>, nextState: Readonly<State>, nextContext: any): void;
UNSAFE_componentWillUpdate?(nextProps: Readonly<Props>, nextState: Readonly<State>, nextContext: any): void;
};
Validated: typeof import("uniforms").Validated;
displayName: string;
defaultProps: {
onValidate(model: unknown, error: any): any;
validate: string;
autosave: boolean;
autosaveDelay: number;
error: null;
label: boolean;
model: any;
noValidate: boolean;
onSubmit(): void;
};
contextType?: import("react").Context<any> | undefined;
} & typeof import("uniforms").BaseForm;
export default _default;

142

esm/ValidatedQuickForm.d.ts

@@ -1,2 +0,142 @@

declare const _default: any;
/// <reference types="react" />
declare const _default: {
new <Model, Props extends import("uniforms").ValidatedFormProps<Model> = import("uniforms").ValidatedFormProps<Model>, State extends import("uniforms").ValidatedFormState<Model> = import("uniforms").ValidatedFormState<Model>>(props: Props): {
validate: (key?: string | undefined, value?: any) => Promise<any>;
validateModel: (originalModel: any) => Promise<any>;
getContextError(): any;
getContext(): import("uniforms").Context<Model>;
getNativeFormProps(): Record<string, any>;
componentDidUpdate(prevProps: Props, prevState: State, snapshot: never): void;
onChange(key: string, value: any): void;
__reset(state: State): Partial<State>;
onSubmit(event?: import("react").SyntheticEvent<Element, Event> | undefined): Promise<any>;
onValidate(key?: string | undefined, value?: any): Promise<any>;
onValidateModel(originalModel: Props["model"]): Promise<any>;
componentDidMount(): void;
componentWillUnmount(): void;
delayId?: any;
mounted: boolean;
reset: () => void;
change: (key: string, value: any) => void;
submit: (event?: import("react").SyntheticEvent<Element, Event> | undefined) => Promise<any>;
randomId: () => string;
getContextName(): string[];
getContextModel(): import("uniforms").DeepPartial<Model>;
getContextState(): {
disabled: boolean;
label: boolean;
placeholder: boolean;
readOnly: boolean;
showInlineError: boolean;
};
getContextSchema(): import("uniforms").Bridge;
getContextOnChange(): (key: string, value: any) => void;
getContextOnSubmit(): (event?: import("react").SyntheticEvent<Element, Event> | undefined) => any;
getModel(mode?: import("uniforms").ModelTransformMode | undefined, model?: import("uniforms").DeepPartial<Model> | undefined): import("uniforms").DeepPartial<Model>;
onReset(): void;
render(): JSX.Element;
context: any;
setState<K extends keyof State>(state: State | Pick<State, K> | ((prevState: Readonly<State>, props: Readonly<Props>) => State | Pick<State, K> | null) | null, callback?: (() => void) | undefined): void;
forceUpdate(callback?: (() => void) | undefined): void;
readonly props: Readonly<Props> & Readonly<{
children?: import("react").ReactNode;
}>;
state: Readonly<State>;
refs: {
[key: string]: import("react").ReactInstance;
};
shouldComponentUpdate?(nextProps: Readonly<Props>, nextState: Readonly<State>, nextContext: any): boolean;
componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
getSnapshotBeforeUpdate?(prevProps: Readonly<Props>, prevState: Readonly<State>): any;
componentWillMount?(): void;
UNSAFE_componentWillMount?(): void;
componentWillReceiveProps?(nextProps: Readonly<Props>, nextContext: any): void;
UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Props>, nextContext: any): void;
componentWillUpdate?(nextProps: Readonly<Props>, nextState: Readonly<State>, nextContext: any): void;
UNSAFE_componentWillUpdate?(nextProps: Readonly<Props>, nextState: Readonly<State>, nextContext: any): void;
};
Validated: typeof import("uniforms").Validated;
displayName: string;
defaultProps: {
onValidate(model: unknown, error: any): any;
validate: string;
autosave: boolean;
autosaveDelay: number;
error: null;
label: boolean;
model: any;
noValidate: boolean;
onSubmit(): void;
};
contextType?: import("react").Context<any> | undefined;
} & {
new <Model_1, Props_1 extends import("uniforms").QuickFormProps<Model_1> = import("uniforms").QuickFormProps<Model_1>, State_1 extends import("uniforms").QuickFormState<Model_1> = import("uniforms").QuickFormState<Model_1>>(props: Props_1): {
getNativeFormProps(): Record<string, any>;
getAutoField(): import("react").ComponentType<{
name: string;
}>;
getErrorsField(): import("react").ComponentType<{}>;
getSubmitField(): import("react").ComponentType<{}>;
componentDidMount(): void;
componentDidUpdate(prevProps: Props_1, prevState: State_1, snapshot: never): void;
componentWillUnmount(): void;
delayId?: any;
mounted: boolean;
reset: () => void;
change: (key: string, value: any) => void;
submit: (event?: import("react").SyntheticEvent<Element, Event> | undefined) => Promise<any>;
randomId: () => string;
getContext(): import("uniforms").Context<Model_1>;
getContextName(): string[];
getContextError(): any;
getContextModel(): import("uniforms").DeepPartial<Model_1>;
getContextState(): {
disabled: boolean;
label: boolean;
placeholder: boolean;
readOnly: boolean;
showInlineError: boolean;
};
getContextSchema(): import("uniforms").Bridge;
getContextOnChange(): (key: string, value: any) => void;
getContextOnSubmit(): (event?: import("react").SyntheticEvent<Element, Event> | undefined) => any;
getModel(mode?: import("uniforms").ModelTransformMode | undefined, model?: import("uniforms").DeepPartial<Model_1> | undefined): import("uniforms").DeepPartial<Model_1>;
onChange(key: string, value: any): void;
__reset(state: State_1): Partial<State_1>;
onReset(): void;
onSubmit(event?: import("react").SyntheticEvent<Element, Event> | undefined): Promise<any>;
render(): JSX.Element;
context: any;
setState<K_1 extends keyof State_1>(state: State_1 | Pick<State_1, K_1> | ((prevState: Readonly<State_1>, props: Readonly<Props_1>) => State_1 | Pick<State_1, K_1> | null) | null, callback?: (() => void) | undefined): void;
forceUpdate(callback?: (() => void) | undefined): void;
readonly props: Readonly<Props_1> & Readonly<{
children?: import("react").ReactNode;
}>;
state: Readonly<State_1>;
refs: {
[key: string]: import("react").ReactInstance;
};
shouldComponentUpdate?(nextProps: Readonly<Props_1>, nextState: Readonly<State_1>, nextContext: any): boolean;
componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
getSnapshotBeforeUpdate?(prevProps: Readonly<Props_1>, prevState: Readonly<State_1>): any;
componentWillMount?(): void;
UNSAFE_componentWillMount?(): void;
componentWillReceiveProps?(nextProps: Readonly<Props_1>, nextContext: any): void;
UNSAFE_componentWillReceiveProps?(nextProps: Readonly<Props_1>, nextContext: any): void;
componentWillUpdate?(nextProps: Readonly<Props_1>, nextState: Readonly<State_1>, nextContext: any): void;
UNSAFE_componentWillUpdate?(nextProps: Readonly<Props_1>, nextState: Readonly<State_1>, nextContext: any): void;
};
Quick: typeof import("uniforms").Quick;
displayName: string;
defaultProps: {
autosave: boolean;
autosaveDelay: number;
error: null;
label: boolean;
model: any;
noValidate: boolean;
onSubmit(): void;
};
contextType?: import("react").Context<any> | undefined;
} & typeof import("uniforms").BaseForm;
export default _default;

6

package.json
{
"name": "uniforms-bootstrap4",
"version": "3.5.5",
"version": "3.6.0",
"license": "MIT",

@@ -40,6 +40,6 @@ "main": "./es5/index.js",

"tslib": "^2.2.0",
"uniforms": "^3.5.5",
"uniforms": "^3.6.0",
"warning": "^4.0.0"
},
"gitHead": "8dd2d7435d4a19c695af6e06fe0d27f97eeb7c0b"
"gitHead": "8ec8ba7751b6ce4b205c49d2aca1ab460bd09e0a"
}
src/AutoForm.tsx

Sorry, the diff of this file is not supported yet

src/BaseForm.tsx

Sorry, the diff of this file is not supported yet

src/QuickForm.tsx

Sorry, the diff of this file is not supported yet

src/SubmitField.tsx

Sorry, the diff of this file is not supported yet

src/ValidatedForm.tsx

Sorry, the diff of this file is not supported yet

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc