uniforms/cjs/AutoForm.d.ts

Core package of uniforms.

import { BaseForm } from './BaseForm';
import { ValidatedQuickForm, ValidatedQuickFormProps, ValidatedQuickFormState } from './ValidatedQuickForm';
import { ModelTransformMode, UnknownObject } from './types';
export type AutoFormProps<Model extends UnknownObject> = ValidatedQuickFormProps<Model> & {
    onChangeModel?: (model: Model, details: {
        key: string;
        value: unknown;
        previousValue: unknown;
    }) => void;
};
export type AutoFormState<Model extends UnknownObject> = ValidatedQuickFormState<Model> & {
    model: Model;
};
export declare function Auto<Base extends typeof ValidatedQuickForm>(Base: Base): {
    new <Model extends UnknownObject, Props extends AutoFormProps<Model> = AutoFormProps<Model>, State extends AutoFormState<Model> = AutoFormState<Model>>(props: Props): {
        /**
         * Returns model value based on the `schema` model and `props.model`.
         * Latter one takes precedence. Does shallow copy.
         */
        mergeSchemaAndPropsModel(schema: Props["schema"], model: Props["model"]): Props["model"];
        componentDidUpdate(prevProps: Props, prevState: State, snapshot: never): void;
        getNativeFormProps(): {
            [key: string]: unknown;
            children?: import("react").ReactNode;
            id?: string;
            key: string;
            noValidate: boolean;
            onSubmit: (event?: import("react").SyntheticEvent) => Promise<unknown>;
        };
        getModel(mode: ModelTransformMode): State["model"];
        onChange(key: string, value: unknown): void;
        __reset(state: State): Partial<State>;
        validate: (key?: string, value?: unknown) => Promise<unknown>;
        validateModel: (originalModel: any) => Promise<unknown>;
        getContextError(): import("./types").Context<Model>["error"];
        getContext(): import("./types").Context<Model>;
        onSubmit(event?: import("react").SyntheticEvent): Promise<unknown>;
        onValidate(key?: string, value?: unknown): Promise<unknown>;
        onValidateModel(originalModel: Props["model"]): Promise<unknown>;
        componentDidMount(): void;
        componentWillUnmount(): void;
        delayId?: ReturnType<typeof setTimeout> | undefined;
        mounted: boolean;
        reset: () => void;
        change: (key: string, value: unknown) => void;
        submit: (event?: import("react").SyntheticEvent) => Promise<unknown>;
        randomId: () => string;
        getContextName(): import("./types").Context<Model>["name"];
        getContextModel(): Model;
        getContextState(): import("./types").Context<Model>["state"];
        getContextSchema(): import("./types").Context<Model>["schema"];
        getContextOnChange(): import("./types").Context<Model>["onChange"];
        getContextOnSubmit(): import("./types").Context<Model>["onSubmit"];
        onReset(): void;
        render(): import("react").JSX.Element;
        context: unknown;
        setState<K extends keyof State>(state: State | ((prevState: Readonly<State>, props: Readonly<Props>) => State | Pick<State, K> | null) | Pick<State, K> | null, callback?: (() => void) | undefined): void;
        forceUpdate(callback?: (() => void) | undefined): void;
        readonly props: Readonly<Props>;
        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 Auto;
    displayName: string;
    Validated: typeof import("./ValidatedForm").Validated;
    defaultProps: {
        onValidate(model: unknown, error: unknown): unknown;
        validate: string;
        autosave: boolean;
        autosaveDelay: number;
        error: null;
        model: any;
        noValidate: boolean;
        onSubmit(): void;
    } & {
        autosave: boolean;
        autosaveDelay: number;
        error: null;
        model: any;
        noValidate: boolean;
        onSubmit(): void;
    };
    contextType?: import("react").Context<any> | undefined;
    Quick: typeof import("./QuickForm").Quick;
} & Base;
export declare const AutoForm: {
    new <Model extends UnknownObject, Props extends AutoFormProps<Model> = AutoFormProps<Model>, State extends AutoFormState<Model> = AutoFormState<Model>>(props: Props): {
        /**
         * Returns model value based on the `schema` model and `props.model`.
         * Latter one takes precedence. Does shallow copy.
         */
        mergeSchemaAndPropsModel(schema: Props["schema"], model: Props["model"]): Props["model"];
        componentDidUpdate(prevProps: Props, prevState: State, snapshot: never): void;
        getNativeFormProps(): {
            [key: string]: unknown;
            children?: import("react").ReactNode;
            id?: string;
            key: string;
            noValidate: boolean;
            onSubmit: (event?: import("react").SyntheticEvent) => Promise<unknown>;
        };
        getModel(mode: ModelTransformMode): State["model"];
        onChange(key: string, value: unknown): void;
        __reset(state: State): Partial<State>;
        validate: (key?: string, value?: unknown) => Promise<unknown>;
        validateModel: (originalModel: any) => Promise<unknown>;
        getContextError(): import("./types").Context<Model>["error"];
        getContext(): import("./types").Context<Model>;
        onSubmit(event?: import("react").SyntheticEvent): Promise<unknown>;
        onValidate(key?: string, value?: unknown): Promise<unknown>;
        onValidateModel(originalModel: Props["model"]): Promise<unknown>;
        componentDidMount(): void;
        componentWillUnmount(): void;
        delayId?: ReturnType<typeof setTimeout> | undefined;
        mounted: boolean;
        reset: () => void;
        change: (key: string, value: unknown) => void;
        submit: (event?: import("react").SyntheticEvent) => Promise<unknown>;
        randomId: () => string;
        getContextName(): import("./types").Context<Model>["name"];
        getContextModel(): Model;
        getContextState(): import("./types").Context<Model>["state"];
        getContextSchema(): import("./types").Context<Model>["schema"];
        getContextOnChange(): import("./types").Context<Model>["onChange"];
        getContextOnSubmit(): import("./types").Context<Model>["onSubmit"];
        onReset(): void;
        render(): import("react").JSX.Element;
        context: unknown;
        setState<K extends keyof State>(state: State | ((prevState: Readonly<State>, props: Readonly<Props>) => State | Pick<State, K> | null) | Pick<State, K> | null, callback?: (() => void) | undefined): void;
        forceUpdate(callback?: (() => void) | undefined): void;
        readonly props: Readonly<Props>;
        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 Auto;
    displayName: string;
    Validated: typeof import("./ValidatedForm").Validated;
    defaultProps: {
        onValidate(model: unknown, error: unknown): unknown;
        validate: string;
        autosave: boolean;
        autosaveDelay: number;
        error: null;
        model: any;
        noValidate: boolean;
        onSubmit(): void;
    } & {
        autosave: boolean;
        autosaveDelay: number;
        error: null;
        model: any;
        noValidate: boolean;
        onSubmit(): void;
    };
    contextType?: import("react").Context<any> | undefined;
    Quick: typeof import("./QuickForm").Quick;
} & {
    new <Model extends UnknownObject, Props extends import("./ValidatedForm").ValidatedFormProps<Model> = import("./ValidatedForm").ValidatedFormProps<Model>, State extends import("./ValidatedForm").ValidatedFormState<Model> = import("./ValidatedForm").ValidatedFormState<Model>>(props: Props): {
        validate: (key?: string, value?: unknown) => Promise<unknown>;
        validateModel: (originalModel: any) => Promise<unknown>;
        getContextError(): import("./types").Context<Model>["error"];
        getContext(): import("./types").Context<Model>;
        getNativeFormProps(): {
            [key: string]: unknown;
            children?: import("react").ReactNode;
            id?: string;
            key: string;
            noValidate: boolean;
            onSubmit: (event?: import("react").SyntheticEvent) => Promise<unknown>;
        };
        componentDidUpdate(prevProps: Props, prevState: State, snapshot: never): void;
        onChange(key: string, value: unknown): void;
        __reset(state: State): Partial<State>;
        onSubmit(event?: import("react").SyntheticEvent): Promise<unknown>;
        onValidate(key?: string, value?: unknown): Promise<unknown>;
        onValidateModel(originalModel: Props["model"]): Promise<unknown>;
        componentDidMount(): void;
        componentWillUnmount(): void;
        delayId?: ReturnType<typeof setTimeout> | undefined;
        mounted: boolean;
        reset: () => void;
        change: (key: string, value: unknown) => void;
        submit: (event?: import("react").SyntheticEvent) => Promise<unknown>;
        randomId: () => string;
        getContextName(): import("./types").Context<Model>["name"];
        getContextModel(): Model;
        getContextState(): import("./types").Context<Model>["state"];
        getContextSchema(): import("./types").Context<Model>["schema"];
        getContextOnChange(): import("./types").Context<Model>["onChange"];
        getContextOnSubmit(): import("./types").Context<Model>["onSubmit"];
        getModel(mode?: ModelTransformMode, model?: Model): Model;
        onReset(): void;
        render(): import("react").JSX.Element;
        context: unknown;
        setState<K extends keyof State>(state: State | ((prevState: Readonly<State>, props: Readonly<Props>) => State | Pick<State, K> | null) | Pick<State, K> | null, callback?: (() => void) | undefined): void;
        forceUpdate(callback?: (() => void) | undefined): void;
        readonly props: Readonly<Props>;
        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("./ValidatedForm").Validated;
    displayName: string;
    defaultProps: {
        onValidate(model: unknown, error: unknown): unknown;
        validate: string;
        autosave: boolean;
        autosaveDelay: number;
        error: null;
        model: any;
        noValidate: boolean;
        onSubmit(): void;
    };
    contextType?: import("react").Context<any> | undefined;
} & {
    new <Model extends UnknownObject, Props extends import("./QuickForm").QuickFormProps<Model> = import("./QuickForm").QuickFormProps<Model>, State extends import("./QuickForm").QuickFormState<Model> = import("./QuickForm").QuickFormState<Model>>(props: Props): {
        getNativeFormProps(): {
            [key: string]: unknown;
            children?: import("react").ReactNode;
            id?: string;
            key: string;
            noValidate: boolean;
            onSubmit: (event?: import("react").SyntheticEvent) => Promise<unknown>;
        };
        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?: ReturnType<typeof setTimeout> | undefined;
        mounted: boolean;
        reset: () => void;
        change: (key: string, value: unknown) => void;
        submit: (event?: import("react").SyntheticEvent) => Promise<unknown>;
        randomId: () => string;
        getContext(): import("./types").Context<Model>;
        getContextName(): import("./types").Context<Model>["name"];
        getContextError(): import("./types").Context<Model>["error"];
        getContextModel(): Model;
        getContextState(): import("./types").Context<Model>["state"];
        getContextSchema(): import("./types").Context<Model>["schema"];
        getContextOnChange(): import("./types").Context<Model>["onChange"];
        getContextOnSubmit(): import("./types").Context<Model>["onSubmit"];
        getModel(mode?: ModelTransformMode, model?: Model): Model;
        onChange(key: string, value: unknown): void;
        __reset(state: State): Partial<State>;
        onReset(): void;
        onSubmit(event?: import("react").SyntheticEvent): Promise<unknown>;
        render(): import("react").JSX.Element;
        context: unknown;
        setState<K extends keyof State>(state: State | ((prevState: Readonly<State>, props: Readonly<Props>) => State | Pick<State, K> | null) | Pick<State, K> | null, callback?: (() => void) | undefined): void;
        forceUpdate(callback?: (() => void) | undefined): void;
        readonly props: Readonly<Props>;
        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("./QuickForm").Quick;
    displayName: string;
    defaultProps: {
        autosave: boolean;
        autosaveDelay: number;
        error: null;
        model: any;
        noValidate: boolean;
        onSubmit(): void;
    };
    contextType?: import("react").Context<any> | undefined;
} & typeof BaseForm;
export type AutoForm = typeof AutoForm;
//# sourceMappingURL=AutoForm.d.ts.map