@types/redux-form

Version 8.3.11
Published 1 year ago
36.5 kB
2 dependencies
MIT license

Install

npm i @types/redux-form

yarn add @types/redux-form

pnpm add @types/redux-form

Overview

TypeScript definitions for redux-form

Index

Variables

variable actionTypes

const actionTypes: ActionTypes;

variable FormName

const FormName: FunctionComponent<FormNameProps>;

variable getFormAsyncErrors

const getFormAsyncErrors: ErrorSelector<{}, {}, string>;

variable getFormError

const getFormError: ErrorSelector<{}, {}, string>;

variable getFormInitialValues

const getFormInitialValues: DataSelector<{}, {}>;

variable getFormMeta

const getFormMeta: DataSelector<{}, {}>;

variable getFormNames

const getFormNames: NamesSelector<{}>;

variable getFormSubmitErrors

const getFormSubmitErrors: ErrorSelector<{}, {}, string>;

variable getFormSyncErrors

const getFormSyncErrors: ErrorSelector<{}, {}, string>;

variable getFormSyncWarnings

const getFormSyncWarnings: ErrorSelector<{}, {}, string>;

variable getFormValues

const getFormValues: DataSelector<{}, {}>;

variable hasSubmitFailed

const hasSubmitFailed: BooleanSelector<{}>;

variable hasSubmitSucceeded

const hasSubmitSucceeded: BooleanSelector<{}>;

variable isAsyncValidating

const isAsyncValidating: BooleanSelector<{}>;

variable isDirty

const isDirty: FormOrFieldsBooleanSelector<{}>;

variable isInvalid

const isInvalid: BooleanSelector<{}>;

variable isPristine

const isPristine: FormOrFieldsBooleanSelector<{}>;

variable isSubmitting

const isSubmitting: BooleanSelector<{}>;

variable isValid

const isValid: BooleanSelector<{}>;

variable reducer

const reducer: FormReducer;

variable ReduxFormContext

const ReduxFormContext: Context<FormContext>;

Functions

function arrayInsert

arrayInsert: (
    form: string,
    field: string,
    index: number,
    value: any
) => FormAction;

function arrayMove

arrayMove: (form: string, field: string, from: number, to: number) => FormAction;

function arrayPop

arrayPop: (form: string, field: string) => FormAction;

function arrayPush

arrayPush: (form: string, field: string, value: any) => FormAction;

function arrayRemove

arrayRemove: (form: string, field: string, index: number) => FormAction;

function arrayRemoveAll

arrayRemoveAll: (form: string, field: string) => FormAction;

function arrayShift

arrayShift: (form: string, field: string) => FormAction;

function arraySplice

arraySplice: (
    form: string,
    field: string,
    index: number,
    removeNum: number,
    value: any
) => FormAction;

function arraySwap

arraySwap: (
    form: string,
    field: string,
    indexA: number,
    indexB: number
) => FormAction;

function arrayUnshift

arrayUnshift: (form: string, field: string, value: any) => FormAction;

function autofill

autofill: (form: string, field: string, value: any) => FormAction;

function blur

blur: (form: string, field: string, value: any, touch?: boolean) => FormAction;

function change

change: (
    form: string,
    field: string,
    value: any,
    touch?: boolean,
    persistentSubmitErrors?: boolean
) => FormAction;

function clearAsyncError

clearAsyncError: (form: string, field: string) => FormAction;

function clearFields

clearFields: (
    form: string,
    keepTouched: boolean,
    persistentSubmitErrors: boolean,
    ...fields: string[]
) => FormAction;

function clearSubmit

clearSubmit: (form: string) => FormAction;

function clearSubmitErrors

clearSubmitErrors: (form: string) => FormAction;

function destroy

destroy: (...form: string[]) => FormAction;

function focus

focus: (form: string, field: string) => FormAction;

function formValues

formValues: {
    <Values, P = {}>(obj: Values): (
        component: ComponentType<P & { [K in keyof Values]: any }>
    ) => ComponentClass<P & { [K in keyof Values]: any }>;
    <FormData = {}, K extends keyof FormData = keyof FormData, P = {}>(
        ...names: K[]
    ): (
        component: ComponentType<P & Pick<FormData, K>>
    ) => ComponentClass<P & Pick<FormData, K>>;
};

function formValueSelector

formValueSelector: <State = {}>(
    form: string,
    getFormState?: (state: State) => FormStateMap
) => (state: State, ...field: string[]) => any;

function initialize

initialize: {
    (
        form: string,
        data: any,
        keepDirty?: boolean,
        options?: Partial<InitializeOptions>
    ): FormAction;
    (form: string, data: any, options?: Partial<InitializeOptions>): FormAction;
};

function reduxForm

reduxForm: <FormData = {}, P = {}, ErrorType = string>(
    config:
        | ConfigProps<FormData, P, ErrorType>
        | Partial<ConfigProps<FormData, P, ErrorType>>
) => FormDecorator<FormData, P, ErrorType>;

function registerField

registerField: (form: string, name: string, type: FieldType) => FormAction;

function reset

reset: (form: string) => FormAction;

function resetSection

resetSection: (form: string, ...sections: string[]) => FormAction;

function setSubmitFailed

setSubmitFailed: (form: string, ...fields: string[]) => FormAction;

function setSubmitSucceeded

setSubmitSucceeded: (form: string, ...fields: string[]) => FormAction;

function startAsyncValidation

startAsyncValidation: (form: string) => FormAction;

function startSubmit

startSubmit: (form: string) => FormAction;

function stopAsyncValidation

stopAsyncValidation: (form: string, errors?: FormErrors<any, any>) => FormAction;

function stopSubmit

stopSubmit: (form: string, errors?: FormErrors<any, any>) => FormAction;

function submit

submit: (form: string) => FormAction;

function touch

touch: (form: string, ...fields: string[]) => FormAction;

function unregisterField

unregisterField: (form: string, name: string) => FormAction;

function untouch

untouch: (form: string, ...fields: string[]) => FormAction;

function updateSyncErrors

updateSyncErrors: <T = any>(
    form: string,
    syncErrors: FormErrors<any, T>,
    error: T
) => FormAction;

function updateSyncWarnings

updateSyncWarnings: <T = any>(
    form: string,
    syncWarnings: FormWarnings<any, T>,
    warning: T
) => FormAction;

Classes

class Field

class Field<
    P extends GenericFieldHTMLAttributes | BaseFieldProps =
        | GenericFieldHTMLAttributes
        | BaseFieldProps
> extends Component<P> {}

property dirty

dirty: boolean;

property name

name: string;

property pristine

pristine: boolean;

property value

value: any;

method getRenderedComponent

getRenderedComponent: () => Component<WrappedFieldProps & P>;

class FieldArray

class FieldArray<P = {}, FieldValue = any>
    extends Component<BaseFieldArrayProps<P, FieldValue>>
    implements GenericFieldArray<FieldValue, P> {}

property name

name: string;

property valid

valid: boolean;

method getRenderedComponent

getRenderedComponent: () => Component<WrappedFieldArrayProps<FieldValue> & P>;

class Fields

class Fields<P = {}>
    extends Component<BaseFieldsProps<P> & P>
    implements GenericFields<P> {}

property dirty

dirty: boolean;

property names

names: string[];

property pristine

pristine: boolean;

property values

values: { [name: string]: any };

method getRenderedComponent

getRenderedComponent: () => Component<
    BaseFieldsProps<{}> & WrappedFieldsProps & P
>;

class Form

class Form<FormData = {}, P = {}, ErrorType = string>
    extends Component<FormProps<FormData, P, ErrorType>>
    implements GenericForm<FormData, P, ErrorType> {}

class FormSection

class FormSection<P = {}> extends Component<FormSectionProps<P> & P> {}

class GenericForm

class GenericForm<FormData, P, ErrorType> extends Component<
    FormProps<FormData, P, ErrorType>
> {}

class SubmissionError

class SubmissionError<FormData = {}, ErrorType = string> extends Error {}

constructor

constructor(errors: { [P in keyof FormData]?: any } & ErrorOther<ErrorType>);

property errors

errors: { [P in keyof FormData]?: any } & ErrorOther<ErrorType>;

Interfaces

interface ActionTypes

interface ActionTypes {}

property ARRAY_INSERT

ARRAY_INSERT: string;

property ARRAY_MOVE

ARRAY_MOVE: string;

property ARRAY_POP

ARRAY_POP: string;

property ARRAY_PUSH

ARRAY_PUSH: string;

property ARRAY_REMOVE

ARRAY_REMOVE: string;

property ARRAY_REMOVE_ALL

ARRAY_REMOVE_ALL: string;

property ARRAY_SHIFT

ARRAY_SHIFT: string;

property ARRAY_SPLICE

ARRAY_SPLICE: string;

property ARRAY_SWAP

ARRAY_SWAP: string;

property ARRAY_UNSHIFT

ARRAY_UNSHIFT: string;

property AUTOFILL

AUTOFILL: string;

property BLUR

BLUR: string;

property CHANGE

CHANGE: string;

property CLEAR_ASYNC_ERROR

CLEAR_ASYNC_ERROR: string;

property CLEAR_FIELDS

CLEAR_FIELDS: string;

property CLEAR_SUBMIT

CLEAR_SUBMIT: string;

property CLEAR_SUBMIT_ERRORS

CLEAR_SUBMIT_ERRORS: string;

property DESTROY

DESTROY: string;

property FOCUS

FOCUS: string;

property INITIALIZE

INITIALIZE: string;

property REGISTER_FIELD

REGISTER_FIELD: string;

property RESET

RESET: string;

property RESET_SECTION

RESET_SECTION: string;

property SET_SUBMIT_FAILED

SET_SUBMIT_FAILED: string;

property SET_SUBMIT_SUCCEEDED

SET_SUBMIT_SUCCEEDED: string;

property START_ASYNC_VALIDATION

START_ASYNC_VALIDATION: string;

property START_SUBMIT

START_SUBMIT: string;

property STOP_ASYNC_VALIDATION

STOP_ASYNC_VALIDATION: string;

property STOP_SUBMIT

STOP_SUBMIT: string;

property SUBMIT

SUBMIT: string;

property TOUCH

TOUCH: string;

property UNREGISTER_FIELD

UNREGISTER_FIELD: string;

property UNTOUCH

UNTOUCH: string;

property UPDATE_SYNC_ERRORS

UPDATE_SYNC_ERRORS: string;

property UPDATE_SYNC_WARNINGS

UPDATE_SYNC_WARNINGS: string;

interface AsyncValidateCallback

interface AsyncValidateCallback<FormData, ErrorType> {}

property asyncErrors

asyncErrors?: FormErrors<FormData, ErrorType> | undefined;

property blurredField

blurredField?: string | undefined;

property initialized

initialized: boolean;

property pristine

pristine: boolean;

property syncValidationPasses

syncValidationPasses: boolean;

property trigger

trigger: 'blur' | 'submit';

interface BaseFieldProps

interface BaseFieldProps<P = {}> extends Partial<CommonFieldProps> {}

property component

component?:
    | ComponentType<WrappedFieldProps & P>
    | 'input'
    | 'select'
    | 'textarea'
    | undefined;

property format

format?: Formatter | null | undefined;

property forwardRef

forwardRef?: boolean | undefined;

property immutableProps

immutableProps?: string[] | undefined;

property name

name: string;

property normalize

normalize?: Normalizer | undefined;

property parse

parse?: Parser | undefined;

property props

props?: P | undefined;

property validate

validate?: Validator | Validator[] | undefined;

property warn

warn?: Validator | Validator[] | undefined;

interface BaseFieldsProps

interface BaseFieldsProps<P = {}> {}

property component

component?: ComponentType<any> | undefined;

property format

format?: Formatter | null | undefined;

property forwardRef

forwardRef?: boolean | undefined;

property names

names: string[];

property parse

parse?: Parser | undefined;

property props

props?: P | undefined;

property validate

validate?: FieldsWarnerOrValidator | undefined;

property warn

warn?: FieldsWarnerOrValidator | undefined;

interface CommonFieldInputProps

interface CommonFieldInputProps {}

property name

name: string;

property onDragStart

onDragStart: EventHandler<DragEvent<any>>;

property onDrop

onDrop: EventHandler<DragEvent<any>>;

property onFocus

onFocus: EventHandler<FocusEvent<any>>;

interface CommonFieldProps

interface CommonFieldProps extends CommonFieldInputProps {}

property onBlur

onBlur: EventWithDataHandler<FocusEvent<any>>;

property onChange

onChange: EventWithDataHandler<ChangeEvent<any>>;

interface ConfigProps

interface ConfigProps<FormData = {}, P = {}, ErrorType = string> {}

property asyncBlurFields

asyncBlurFields?: string[] | undefined;

property asyncChangeFields

asyncChangeFields?: string[] | undefined;

property destroyOnUnmount

destroyOnUnmount?: boolean | undefined;

property enableReinitialize

enableReinitialize?: boolean | undefined;

property forceUnregisterOnUnmount

forceUnregisterOnUnmount?: boolean | undefined;

property form

form: string;

property getFormState

getFormState?: GetFormState | undefined;

property immutableProps

immutableProps?: string[] | undefined;

property initialValues

initialValues?: Partial<FormData> | undefined;

property keepDirtyOnReinitialize

keepDirtyOnReinitialize?: boolean | undefined;

property keepValues

keepValues?: boolean | undefined;

property onSubmit

onSubmit?:
    | FormSubmitHandler<FormData, P, ErrorType>
    | SubmitHandler<FormData, P, ErrorType>
    | undefined;

property persistentSubmitErrors

persistentSubmitErrors?: boolean | undefined;

property propNamespace

propNamespace?: string | undefined;

property pure

pure?: boolean | undefined;

property submitAsSideEffect

submitAsSideEffect?: boolean | undefined;

property touchOnBlur

touchOnBlur?: boolean | undefined;

property touchOnChange

touchOnChange?: boolean | undefined;

property updateUnregisteredFields

updateUnregisteredFields?: boolean | undefined;

method asyncValidate

asyncValidate: (
    values: FormData,
    dispatch: Dispatch<any>,
    props: DecoratedFormProps<FormData, P, ErrorType>,
    blurredField: string
) => Promise<any>;

method onChange

onChange: (
    values: Partial<FormData>,
    dispatch: Dispatch<any>,
    props: DecoratedFormProps<FormData, P, ErrorType>,
    previousValues: Partial<FormData>
) => void;

method onSubmitFail

onSubmitFail: (
    errors: FormErrors<FormData, ErrorType> | undefined,
    dispatch: Dispatch<any>,
    submitError: any,
    props: DecoratedFormProps<FormData, P, ErrorType>
) => void;

method onSubmitSuccess

onSubmitSuccess: (
    result: any,
    dispatch: Dispatch<any>,
    props: DecoratedFormProps<FormData, P, ErrorType>
) => void;

method shouldAsyncValidate

shouldAsyncValidate: (
    params: AsyncValidateCallback<FormData, ErrorType>
) => boolean;

method shouldError

shouldError: (params: ValidateCallback<FormData, P, ErrorType>) => boolean;

method shouldValidate

shouldValidate: (params: ValidateCallback<FormData, P, ErrorType>) => boolean;

method shouldWarn

shouldWarn: (params: ValidateCallback<FormData, P, ErrorType>) => boolean;

method validate

validate: (
    values: FormData,
    props: DecoratedFormProps<FormData, P, ErrorType>
) => FormErrors<FormData, ErrorType>;

method warn

warn: (
    values: FormData,
    props: DecoratedFormProps<FormData, P, ErrorType>
) => FormWarnings<FormData>;

interface DecoratedComponentClass

interface DecoratedComponentClass<FormData, P> {}

construct signature

new (props?: P, context?: any): FormInstance<FormData, P>;

interface DecoratedFormActions

interface DecoratedFormActions<ErrorType> {}

property array

array: InjectedArrayProps;

property arrayInsert

arrayInsert: ArrayInsertAction;

property arrayMove

arrayMove: ArrayMoveAction;

property arrayPop

arrayPop: ArrayPopAction;

property arrayPush

arrayPush: ArrayPushAction;

property arrayRemove

arrayRemove: ArrayRemoveAction;

property arrayRemoveAll

arrayRemoveAll: ArrayRemoveAllAction;

property arrayShift

arrayShift: ArrayShiftAction;

property arraySplice

arraySplice: ArraySpliceAction;

property arraySwap

arraySwap: ArraySwapAction;

property arrayUnshift

arrayUnshift: ArrayUnshiftAction;

property autofill

autofill: AutoFillAction;

property blur

blur: BlurAction;

property change

change: ChangeAction;

property clearAsyncError

clearAsyncError: ClearAsyncErrorAction;

property clearFields

clearFields: ClearFieldsAction;

property clearSubmit

clearSubmit: ClearSubmitAction;

property clearSubmitErrors

clearSubmitErrors: ClearSubmitErrorsAction;

property destroy

destroy: DestroyAction;

property dispatch

dispatch: Dispatch;

property focus

focus: FocusAction;

property initialize

initialize: InitializeAction<ErrorType>;

property registerField

registerField: RegisterFieldAction;

property reset

reset: ResetAction;

property resetSection

resetSection: ResetSectionAction;

property setSubmitFailed

setSubmitFailed: SetSubmitFailedAction;

property setSubmitSucceeded

setSubmitSucceeded: SetSubmitSucceededAction;

property startAsyncValidation

startAsyncValidation: StartAsyncValidationAction;

property startSubmit

startSubmit: StartSubmitAction;

property stopAsyncValidation

stopAsyncValidation: StopAsyncValidationAction<ErrorType>;

property stopSubmit

stopSubmit: StopSubmitAction<ErrorType>;

property submit

submit: SubmitAction;

property touch

touch: TouchAction;

property unregisterField

unregisterField: UnregisterFieldAction;

property untouch

untouch: UntouchAction;

property updateSyncErrors

updateSyncErrors: UpdateSyncErrorsAction<ErrorType>;

property updateSyncWarnings

updateSyncWarnings: UpdateSyncWarningsAction<ErrorType>;

interface ErrorOther

interface ErrorOther<T = string> {}

interface EventOrValueHandler

interface EventOrValueHandler<Event> extends EventHandler<Event> {}

call signature

(value: any): void;

interface FieldArrayFieldsProps

interface FieldArrayFieldsProps<FieldValue> {}

property length

length: number;

property name

name: string;

method forEach

forEach: (callback: FieldIterate<FieldValue>) => void;

method get

get: (index: number) => FieldValue;

method getAll

getAll: () => FieldValue[];

method insert

insert: (index: number, value: FieldValue) => void;

method map

map: <R>(callback: FieldIterate<FieldValue, R>) => R[];

method move

move: (from: number, to: number) => void;

method pop

pop: () => FieldValue;

method push

push: (value: FieldValue) => void;

method remove

remove: (index: number) => void;

method removeAll

removeAll: () => void;

method shift

shift: () => FieldValue;

method splice

splice: (index: number, removeNum: number | null, value: FieldValue) => void;

method swap

swap: (indexA: number, indexB: number) => void;

method unshift

unshift: (value: FieldValue) => void;

interface FieldArrayMetaProps

interface FieldArrayMetaProps {}

property dirty

dirty: boolean;

property error

error?: any;

property form

form: string;

property invalid

invalid: boolean;

property pristine

pristine: boolean;

property submitFailed

submitFailed: boolean;

property submitting

submitting: boolean;

property valid

valid: boolean;

property warning

warning?: any;

interface FieldState

interface FieldState {}

property active

active?: boolean | undefined;

property touched

touched?: boolean | undefined;

property visited

visited?: boolean | undefined;

interface FormAction

interface FormAction extends Action {}

property error

error?: any;

property meta

meta?: any;

property payload

payload?: any;

interface FormContext

interface FormContext {}

property asyncValidate

asyncValidate: {
    (name?: string, value?: any, trigger?: 'blur' | 'change'): Promise<any>;
};

property blur

blur: (name: string, value: any) => void;

property change

change: (name: string, value: any) => void;

property focus

focus: (name: string) => void;

property form

form: string;

property getFormState

getFormState: GetFormState;

property getValues

getValues: { (): any };

property prefixName

prefixName?: string | undefined;

property register

register: (
    name: string,
    type: string,
    getValidator?: () => Validator | Validator[],
    getWarner?: () => Validator | Validator[]
) => void;

property registerInnerOnSubmit

registerInnerOnSubmit: (innerOnSubmit: () => void) => void;

property sectionPrefix

sectionPrefix?: string | undefined;

property unregister

unregister: (name: string) => void;

interface FormInstance

interface FormInstance<FormData, P> extends Component<P> {}

property dirty

dirty: boolean;

property invalid

invalid: boolean;

property pristine

pristine: boolean;

property registeredFields

registeredFields: RegisteredFieldState[];

property valid

valid: boolean;

property values

values: Partial<FormData>;

property wrappedInstance

wrappedInstance?: HTMLElement | undefined;

method reset

reset: () => void;

method resetSection

resetSection: (...sections: string[]) => void;

method submit

submit: () => Promise<any>;

interface FormNameProps

interface FormNameProps {}

property children

children: (props: {
    form: string;
    sectionPrefix?: string | undefined;
}) => ReactNode;

interface FormReducer

interface FormReducer extends Reducer<FormStateMap> {}

method plugin

plugin: (reducers: FormReducerMapObject) => Reducer<FormStateMap>;

interface FormReducerMapObject

interface FormReducerMapObject {}

index signature

[formName: string]: Reducer<any>;

interface FormSectionProps

interface FormSectionProps<P> {}

property component

component?: ComponentType<P> | undefined;

property name

name: string;

interface FormState

interface FormState {}

property active

active?: string | undefined;

property anyTouched

anyTouched?: boolean | undefined;

property error

error?: any;

property fields

fields?: { [name: string]: FieldState } | undefined;

property registeredFields

registeredFields: RegisteredFieldState[];

property submitErrors

submitErrors?: { [fieldName: string]: string } | undefined;

property submitFailed

submitFailed?: boolean | undefined;

property submitting

submitting?: boolean | undefined;

property values

values?: { [fieldName: string]: any } | undefined;

interface FormStateMap

interface FormStateMap {}

index signature

[formName: string]: FormState;

interface FormSubmitProp

interface FormSubmitProp<FormData = {}, P = {}, ErrorType = string> {}

property onSubmit

onSubmit?: FormSubmitHandler<FormData, P, ErrorType> | undefined;

interface GenericField

interface GenericField<P> extends Component<BaseFieldProps<P> & P> {}

property dirty

dirty: boolean;

property name

name: string;

property pristine

pristine: boolean;

property value

value: any;

method getRenderedComponent

getRenderedComponent: () => Component<WrappedFieldProps & P>;

interface GenericFieldArray

interface GenericFieldArray<FieldValue = any, P = {}>
    extends Component<BaseFieldArrayProps<P, FieldValue>> {}

property name

name: string;

property valid

valid: boolean;

method getRenderedComponent

getRenderedComponent: () => Component<WrappedFieldArrayProps<FieldValue> & P>;

interface GenericFields

interface GenericFields<P> extends Component<BaseFieldsProps<P> & P> {}

property dirty

dirty: boolean;

property names

names: string[];

property pristine

pristine: boolean;

property values

values: { [name: string]: any };

method getRenderedComponent

getRenderedComponent: () => Component<
    BaseFieldsProps<{}> & WrappedFieldsProps & P
>;

interface InitializeOptions

interface InitializeOptions {}

property keepDirty

keepDirty: boolean;

property keepSubmitSucceeded

keepSubmitSucceeded: boolean;

property keepValues

keepValues: boolean;

property updateUnregisteredFields

updateUnregisteredFields: boolean;

interface InjectedArrayProps

interface InjectedArrayProps {}

method insert

insert: (field: string, index: number, value: any) => void;

method move

move: (field: string, from: number, to: number) => void;

method pop

pop: (field: string) => void;

method push

push: (field: string, value: any) => void;

method remove

remove: (field: string, index: number) => void;

method removeAll

removeAll: (field: string) => void;

method shift

shift: (field: string) => void;

method splice

splice: (field: string, index: number, removeNum: number, value: any) => void;

method swap

swap: (field: string, indexA: number, indexB: number) => void;

method unshift

unshift: (field: string, value: any) => void;

interface InjectedFormProps

interface InjectedFormProps<FormData = {}, P = {}, ErrorType = string> {}

property anyTouched

anyTouched: boolean;

property array

array: InjectedArrayProps;

property asyncValidating

asyncValidating: string | boolean;

property dirty

dirty: boolean;

property error

error: ErrorType;

property form

form: string;

property handleSubmit

handleSubmit: SubmitHandler<FormData, P, ErrorType>;

property initialized

initialized: boolean;

property initialValues

initialValues: Partial<FormData>;

property invalid

invalid: boolean;

property pristine

pristine: boolean;

property submitFailed

submitFailed: boolean;

property submitSucceeded

submitSucceeded: boolean;

property submitting

submitting: boolean;

property valid

valid: boolean;

property warning

warning: any;

method asyncValidate

asyncValidate: () => void;

method autofill

autofill: (field: string, value: any) => void;

method blur

blur: (field: string, value: any) => void;

method change

change: (field: string, value: any) => void;

method clearAsyncError

clearAsyncError: (field: string) => void;

method clearSubmit

clearSubmit: () => void;

method destroy

destroy: () => void;

method initialize

initialize: (data: Partial<FormData>) => void;

method reset

reset: () => void;

method touch

touch: (...field: string[]) => void;

method untouch

untouch: (...field: string[]) => void;

interface RegisteredField

interface RegisteredField {}

property count

count: number;

property name

name: string;

property type

type: 'Field' | 'FieldArray';

interface RegisteredFieldState

interface RegisteredFieldState {}

property name

name: string;

property type

type: FieldType;

interface SubmitHandler

interface SubmitHandler<FormData = {}, P = {}, ErrorType = string> {}

call signature

(
    submit: FormSubmitHandler<FormData, P, ErrorType>,
    props?: DecoratedFormProps<FormData, P, ErrorType>,
    valid?: boolean,
    asyncValidate?: any,
    fields?: string[]
): any;

call signature

(event: SyntheticEvent<any>): void;

interface ValidateCallback

interface ValidateCallback<FormData, P, ErrorType> {}

property fieldValidatorKeys

fieldValidatorKeys: string[];

property initialRender

initialRender: boolean;

property lastFieldValidatorKeys

lastFieldValidatorKeys: string[];

property nextProps

nextProps: DecoratedFormProps<FormData, P, ErrorType>;

property props

props: DecoratedFormProps<FormData, P, ErrorType>;

property structure

structure: any;

property values

values: FormData;

interface WarningOther

interface WarningOther<T = void> {}

interface WrappedFieldArrayProps

interface WrappedFieldArrayProps<FieldValue = any> {}

property fields

fields: FieldArrayFieldsProps<FieldValue>;

property meta

meta: FieldArrayMetaProps;

interface WrappedFieldInputProps

interface WrappedFieldInputProps extends CommonFieldInputProps {}

property checked

checked?: boolean | undefined;

property onBlur

onBlur: EventOrValueHandler<FocusEvent<any>>;

property onChange

onChange: EventOrValueHandler<ChangeEvent<any>>;

property value

value: any;

interface WrappedFieldMetaProps

interface WrappedFieldMetaProps {}

property active

active?: boolean | undefined;

property asyncValidating

asyncValidating: boolean;

property autofilled

autofilled: boolean;

property dirty

dirty: boolean;

property dispatch

dispatch: Dispatch<any>;

property error

error?: any;

property form

form: string;

property initial

initial: any;

property invalid

invalid: boolean;

property pristine

pristine: boolean;

property submitFailed

submitFailed: boolean;

property submitting

submitting: boolean;

property touched

touched: boolean;

property valid

valid: boolean;

property visited

visited: boolean;

property warning

warning?: any;

interface WrappedFieldProps

interface WrappedFieldProps {}

property input

input: WrappedFieldInputProps;

property meta

meta: WrappedFieldMetaProps;

interface WrappedFieldsProps

interface WrappedFieldsProps {}

index signature

[name: string]: WrappedFieldsProps & WrappedFieldProps;

interface WrappedReduxFormContext

interface WrappedReduxFormContext {}

Type Aliases

type ArrayInsertAction

type ArrayInsertAction = (field: string, index: number, value: any) => void;

type ArrayMoveAction

type ArrayMoveAction = (field: string, from: number, to: number) => void;

type ArrayPopAction

type ArrayPopAction = (field: string) => void;

type ArrayPushAction

type ArrayPushAction = (field: string, value: any) => void;

type ArrayRemoveAction

type ArrayRemoveAction = (field: string, index: number) => void;

type ArrayRemoveAllAction

type ArrayRemoveAllAction = (field: string) => void;

type ArrayShiftAction

type ArrayShiftAction = (field: string) => void;

type ArraySpliceAction

type ArraySpliceAction = (
    field: string,
    index: number,
    removeNum: number,
    value: any
) => void;

type ArraySwapAction

type ArraySwapAction = (field: string, indexA: number, indexB: number) => void;

type ArrayUnshiftAction

type ArrayUnshiftAction = (field: string, value: any) => void;

type AutoFillAction

type AutoFillAction = (field: string, value: any) => void;

type BaseFieldArrayProps

type BaseFieldArrayProps<P = {}, FieldValue = any> = (P | { props?: P }) &
    _BaseFieldArrayProps<P, FieldValue>;

type BlurAction

type BlurAction = (field: string, value: any) => void;

type BooleanSelector

type BooleanSelector<State = {}> = (
    formName: string,
    getFormState?: GetFormState
) => (state: State) => boolean;

type ChangeAction

type ChangeAction = (field: string, value: any) => void;

type ClearAsyncErrorAction

type ClearAsyncErrorAction = (field: string) => void;

type ClearFieldsAction

type ClearFieldsAction = (
    keepTouched: boolean,
    persistentSubmitErrors: boolean,
    ...fields: string[]
) => void;

type ClearSubmitAction

type ClearSubmitAction = () => void;

type ClearSubmitErrorsAction

type ClearSubmitErrorsAction = () => void;

type DataSelector

type DataSelector<FormData = {}, State = {}> = (
    formName: string,
    getFormState?: GetFormState
) => (state: State) => FormData;

type DecoratedFormProps

type DecoratedFormProps<FormData = {}, P = {}, ErrorType = string> = P &
    Partial<ConfigProps<FormData, P, ErrorType>> &
    Partial<DecoratedFormState<FormData, ErrorType>> &
    Partial<DecoratedFormActions<ErrorType>> & {
        _reduxForm?: WrappedReduxFormContext | undefined;
    };

type DecoratedFormState

type DecoratedFormState<FormData, ErrorType> = FormState & {
    asyncErrors?: FormErrors<FormData, ErrorType> | undefined;
    asyncValidating: boolean;
    dirty: boolean;
    error?: any;
    initialized: boolean;
    invalid: boolean;
    pristine: boolean;
    submitSucceeded: boolean;
    syncErrors?: FormErrors<FormData, ErrorType> | undefined;
    syncWarnings?: FormWarnings<any, any> | undefined;
    triggerSubmit?: boolean | undefined;
    valid: boolean;
    validExceptSubmit: boolean;
    warning?: any;
};

type DestroyAction

type DestroyAction = () => void;

type ErrorSelector

type ErrorSelector<FormData = {}, State = {}, ErrorType = string> = (
    formName: string,
    getFormState?: GetFormState
) => (state: State) => FormErrors<FormData, ErrorType>;

type EventHandler

type EventHandler<Event> = (event: Event, name?: string) => void;

type EventWithDataHandler

type EventWithDataHandler<Event> = (
    event?: Event,
    newValue?: any,
    previousValue?: any,
    name?: string
) => void;

type FieldIterate

type FieldIterate<FieldValue, R = void> = (
    name: string,
    index: number,
    fields: FieldArrayFieldsProps<FieldValue>
) => R;

type FieldsWarnerOrValidator

type FieldsWarnerOrValidator =
    | Validator
    | Validator[]
    | { [name: string]: Validator | Validator[] };

type FieldType

type FieldType = 'Field' | 'FieldArray';

type FocusAction

type FocusAction = (field: string) => void;

type Formatter

type Formatter = (value: any, name: string) => any;

type FormDecorator

type FormDecorator<FormData, P, ErrorType = string> = (
    component: ComponentType<P & InjectedFormProps<FormData, P, ErrorType>>
) => DecoratedComponentClass<FormData, DecoratedFormProps<FormData, P, ErrorType>>;

type FormErrors

type FormErrors<FormData = {}, T = string> = {
    [P in keyof FormData]?: ReactElement | T;
} & ErrorOther<T>;

type FormOrFieldsBooleanSelector

type FormOrFieldsBooleanSelector<State = {}> = (
    formName: string,
    getFormState?: GetFormState
) => (state: State, ...fields: string[]) => boolean;

type FormProps

type FormProps<FormData, P, ErrorType = string> = Omit<
    FormHTMLAttributes<HTMLFormElement>,
    'onSubmit'
> &
    FormSubmitProp<FormData, P, ErrorType>;

type FormSubmitHandler

type FormSubmitHandler<FormData = {}, P = {}, ErrorType = string> = (
    values: FormData,
    dispatch: Dispatch<any>,
    props: DecoratedFormProps<FormData, P, ErrorType>
    // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
) => void | FormErrors<FormData, ErrorType> | Promise<any>;

type FormWarnings

type FormWarnings<FormData = {}, T = void> = {
    [P in keyof FormData]?: ReactElement | string | WarningOther<T>;
};

type GenericFieldHTMLAttributes

type GenericFieldHTMLAttributes =
    | InputHTMLAttributes<HTMLInputElement>
    | SelectHTMLAttributes<HTMLSelectElement>
    | TextareaHTMLAttributes<HTMLTextAreaElement>;

type GetFormState

type GetFormState = (state: any) => FormStateMap;

type InitializeAction

type InitializeAction<FormData> = (
    initialValues: Partial<FormData>,
    keepDirty: boolean,
    otherMeta?: any
) => void;

type NamesSelector

type NamesSelector<State = {}> = (
    getFormState?: GetFormState
) => (state: State) => string[];

type Normalizer

type Normalizer = (
    value: any,
    previousValue?: any,
    allValues?: any,
    previousAllValues?: any
) => any;

type Omit

type Omit<T, K extends keyof T> = Pick<
    T,
    ({ [P in keyof T]: P } & { [P in K]: never } & {
        [x: string]: never;
        [x: number]: never;
    })[keyof T]
>;

type Parser

type Parser = (value: any, name: string) => any;

type RegisterFieldAction

type RegisterFieldAction = (name: string, type: FieldType) => void;

type ResetAction

type ResetAction = () => void;

type ResetSectionAction

type ResetSectionAction = () => void;

type SetSubmitFailedAction

type SetSubmitFailedAction = (...fields: string[]) => void;

type SetSubmitSucceededAction

type SetSubmitSucceededAction = (...fields: string[]) => void;

type StartAsyncValidationAction

type StartAsyncValidationAction = (field: string) => void;

type StartSubmitAction

type StartSubmitAction = () => void;

type StopAsyncValidationAction

type StopAsyncValidationAction<ErrorType> = (errors?: FormErrors<ErrorType>) => void;

type StopSubmitAction

type StopSubmitAction<ErrorType> = (errors?: FormErrors<ErrorType>) => void;

type SubmitAction

type SubmitAction = () => void;

type TouchAction

type TouchAction = (...fields: string[]) => void;

type UnregisterFieldAction

type UnregisterFieldAction = (name: string, destroyOnUnmount?: boolean) => void;

type UntouchAction

type UntouchAction = (...fields: string[]) => void;

type UpdateSyncErrorsAction

type UpdateSyncErrorsAction<ErrorType> = (
    syncErrors?: FormErrors<ErrorType>,
    error?: any
) => void;

type UpdateSyncWarningsAction

type UpdateSyncWarningsAction<ErrorType> = (
    syncErrors?: FormErrors<ErrorType>,
    error?: any
) => void;

type Validator

type Validator = (value: any, allValues?: any, props?: any, name?: any) => any;

Package Files (15)

Dependencies (2)

Dev Dependencies (0)

No dev dependencies.

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/redux-form.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/redux-form)

HTML

<a href="https://www.jsdocs.io/package/@types/redux-form"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 1 year ago.
Package analyzed in 7421 ms.
Missing or incorrect documentation? Open an issue for this package.