### File

`src/lib/model.ts`

### Extends

`BaseDefinitionMetadata` `FormOptions`

### Index

###### Properties

- Optional autoSubmit
- Optional providers

### Properties

autoSubmit
`autoSubmit: `boolean | number``
Type : `boolean | number`
Optional
true - after 5000ms the form is automatically submitted if valid number - after the set ms the is automatically submitted if valid

providers
`providers: `StaticProvider[]``
Type : `StaticProvider[]`
Optional

    import {
      AbstractType,
      InjectionToken,
      StaticProvider,
      Type,
    } from '@angular/core';
    import {
      AbstractControlOptions,
      AsyncValidatorFn,
      ValidatorFn,
    } from '@angular/forms';
    import { BaseDefinitionMetadata } from '@rxap/definition';
    import {
      Constructor,
      NonEmpty,
    } from '@rxap/utilities';
    import { RxapFormArray } from './form-array';
    import { RxapFormControl } from './form-control';
    import type { RxapFormGroup } from './form-group';
    import {
      AbstractControl,
      ControlOptions,
    } from './types';

    export interface InjectableValidator {
      validate?: ValidatorFn;
      asyncValidate?: AsyncValidatorFn;
    }

    /**
     * @internal
     */
    export interface _RxapAbstractControlOptions extends AbstractControlOptions {
      state?: any | (() => any);
      injectValidators?: Array<
        | Type<InjectableValidator>
        | InjectionToken<InjectableValidator>
        | AbstractType<InjectableValidator>
      >;
      controlType?: Constructor<RxapFormControl>;
      disabled?: boolean;
      readonly?: boolean;
    }

    export type RxapAbstractControlOptions<
      T extends Record<string, any> = Record<string, any>
    > = _RxapAbstractControlOptions & T;

    export interface RxapAbstractControlOptionsWithDefinition
      extends RxapAbstractControlOptions {
      definition: Constructor;
    }

    export interface FormDefinition<T = any,
      E extends object = any,
      JSON extends Record<string, any> = any,
    > {
      rxapFormGroup: RxapFormGroup<T, E>;

      /**
       * used to access the form definition metadata type save
       */
      rxapMetadata: FormDefinitionMetadata;

      /**
       * The Reuse hook is called when the instance is reused.
       * And can be used to reset or alter the local state of the instance.
       */
      rxapReuse?(): void;

      /**
       * Called to get the value that should be submitted. If not defined
       * the value property of the root RxapFormGroup instance will be used
       */
      getSubmitValue?(): JSON;

      /**
       * Called to get the value that should be submitted. If not defined
       * the value property of the root RxapFormGroup instance will be used
       */
      toJSON?(): JSON;
    }

    export interface FormDefinitionArray<T> extends Array<T> {
      rxapFormArray: RxapFormArray;
    }

    export type FormType<T> = Partial<
      FormDefinition<T>
    > &
      {
        [K in keyof T]: T[K] extends (infer U)[]
        ? FormDefinitionArray<FormType<U>> | FormDefinitionArray<RxapFormControl<U>> | RxapFormControl<T[K]> | RxapFormArray<U>
        : T[K] extends Record<string, any>
          ? (FormType<T[K]> & Partial<FormDefinition<T[K]>>) | RxapFormControl<T[K]>
          : RxapFormControl<NonEmpty<T[K]>>;
      };

    export interface FormOptions extends RxapAbstractControlOptions {
      id: string;
    }

    export interface FormDefinitionMetadata
      extends BaseDefinitionMetadata,
              FormOptions {
      providers?: StaticProvider[];
      /**
       * true - after 5000ms the form is automatically submitted if valid
       * number - after the set ms the is automatically submitted if valid
       */
      autoSubmit?: boolean | number;
    }

    export type ChangeFn<T = any> = (
      value: T,
      emitViewToModelChange: boolean,
    ) => void;

    export type SetValueFn<T = any> = (value: T, options?: ControlOptions) => void;

    export type FormBuilderFn<T extends (FormDefinition<Data> | FormType<Data>) = FormDefinition, Data = Record<string, any>> = (
      state: any,
      options: { controlId: string },
    ) => T | RxapFormControl;

    export type ControlInsertedFn = (
      index: number,
      controlOrDefinition: AbstractControl | FormDefinition,
    ) => void;
    export type ControlRemovedFn = (index: number) => void;

    export interface FormArrayOptions extends RxapAbstractControlOptions {
      builder: FormBuilderFn;
      controlId: string;
      controlInsertedFn: ControlInsertedFn;
      controlRemovedFn: ControlRemovedFn;
    }

    export interface FormGroupOptions extends RxapAbstractControlOptions {
      controlId: string;
    }

# results matching ""

# No results matching ""