mirror of
https://github.com/angular/angular.git
synced 2026-09-14 13:54:52 +08:00
Andrew Scott
dfe7be4d2a
The static `ɵprov` field emitted on `@Injectable()` classes uses `ɵɵInjectableDeclaration<T>`.
When a subclass extends a generic `@Injectable()` base class with contravariant parameters
(such as callback/transformer methods depending on generic type parameters), TypeScript's
static side inheritance check (`typeof Sub extends typeof Super`) fails with `TS2417` because
`ɵɵInjectableDeclaration<Sub>` is not assignable to `ɵɵInjectableDeclaration<Super<any>>`.
Using `any` (`o.DYNAMIC_TYPE`) in `createInjectableType` avoids strict variance checks on
static inheritance for internal Ivy definitions and aligns with other Ivy declaration types.
(cherry picked from commit caeab598c9)
1040 lines
44 KiB
Markdown
1040 lines
44 KiB
Markdown
## API Report File for "@angular/forms"
|
|
|
|
> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
|
|
|
|
```ts
|
|
|
|
import { AfterViewInit } from '@angular/core';
|
|
import { ChangeDetectorRef } from '@angular/core';
|
|
import { ElementRef } from '@angular/core';
|
|
import { EventEmitter } from '@angular/core';
|
|
import * as i0 from '@angular/core';
|
|
import { InjectionToken } from '@angular/core';
|
|
import { Injector } from '@angular/core';
|
|
import { ModuleWithProviders } from '@angular/core';
|
|
import { Observable } from 'rxjs';
|
|
import { OnChanges } from '@angular/core';
|
|
import { OnDestroy } from '@angular/core';
|
|
import { OnInit } from '@angular/core';
|
|
import { Renderer2 } from '@angular/core';
|
|
import { SimpleChanges } from '@angular/core';
|
|
import { Version } from '@angular/core';
|
|
import { ɵControlDirectiveHost } from '@angular/core';
|
|
|
|
// @public
|
|
export abstract class AbstractControl<TValue = any, TRawValue extends TValue = TValue, TValueWithOptionalControlStates = any> {
|
|
constructor(validators: ValidatorFn | ValidatorFn[] | null, asyncValidators: AsyncValidatorFn | AsyncValidatorFn[] | null);
|
|
addAsyncValidators(validators: AsyncValidatorFn | AsyncValidatorFn[]): void;
|
|
addValidators(validators: ValidatorFn | ValidatorFn[]): void;
|
|
get asyncValidator(): AsyncValidatorFn | null;
|
|
set asyncValidator(asyncValidatorFn: AsyncValidatorFn | null);
|
|
clearAsyncValidators(): void;
|
|
clearValidators(): void;
|
|
get dirty(): boolean;
|
|
disable(opts?: {
|
|
onlySelf?: boolean;
|
|
emitEvent?: boolean;
|
|
}): void;
|
|
get disabled(): boolean;
|
|
enable(opts?: {
|
|
onlySelf?: boolean;
|
|
emitEvent?: boolean;
|
|
}): void;
|
|
get enabled(): boolean;
|
|
readonly errors: ValidationErrors | null;
|
|
readonly events: Observable<ControlEvent<TValue>>;
|
|
get<P extends string | readonly (string | number)[]>(path: P): AbstractControl<ɵGetProperty<TRawValue, P>> | null;
|
|
get<P extends string | Array<string | number>>(path: P): AbstractControl<ɵGetProperty<TRawValue, P>> | null;
|
|
getError(errorCode: string, path?: Array<string | number> | string): any;
|
|
getRawValue(): any;
|
|
hasAsyncValidator(validator: AsyncValidatorFn): boolean;
|
|
hasError(errorCode: string, path?: Array<string | number> | string): boolean;
|
|
hasValidator(validator: ValidatorFn): boolean;
|
|
get invalid(): boolean;
|
|
markAllAsDirty(opts?: {
|
|
emitEvent?: boolean;
|
|
}): void;
|
|
markAllAsTouched(opts?: {
|
|
emitEvent?: boolean;
|
|
}): void;
|
|
markAsDirty(opts?: {
|
|
onlySelf?: boolean;
|
|
emitEvent?: boolean;
|
|
}): void;
|
|
markAsPending(opts?: {
|
|
onlySelf?: boolean;
|
|
emitEvent?: boolean;
|
|
}): void;
|
|
markAsPristine(opts?: {
|
|
onlySelf?: boolean;
|
|
emitEvent?: boolean;
|
|
}): void;
|
|
markAsTouched(opts?: {
|
|
onlySelf?: boolean;
|
|
emitEvent?: boolean;
|
|
}): void;
|
|
markAsUntouched(opts?: {
|
|
onlySelf?: boolean;
|
|
emitEvent?: boolean;
|
|
}): void;
|
|
get parent(): FormGroup | FormArray | null;
|
|
abstract patchValue(value: TValue, options?: Object): void;
|
|
get pending(): boolean;
|
|
get pristine(): boolean;
|
|
removeAsyncValidators(validators: AsyncValidatorFn | AsyncValidatorFn[]): void;
|
|
removeValidators(validators: ValidatorFn | ValidatorFn[]): void;
|
|
abstract reset(value?: TValueWithOptionalControlStates, options?: Object): void;
|
|
get root(): AbstractControl;
|
|
setAsyncValidators(validators: AsyncValidatorFn | AsyncValidatorFn[] | null): void;
|
|
setErrors(errors: ValidationErrors | null, opts?: {
|
|
emitEvent?: boolean;
|
|
}): void;
|
|
setParent(parent: FormGroup | FormArray | null): void;
|
|
setValidators(validators: ValidatorFn | ValidatorFn[] | null): void;
|
|
abstract setValue(value: TRawValue, options?: Object): void;
|
|
get status(): FormControlStatus;
|
|
readonly statusChanges: Observable<FormControlStatus>;
|
|
get touched(): boolean;
|
|
get untouched(): boolean;
|
|
get updateOn(): FormHooks;
|
|
updateValueAndValidity(opts?: {
|
|
onlySelf?: boolean;
|
|
emitEvent?: boolean;
|
|
}): void;
|
|
get valid(): boolean;
|
|
get validator(): ValidatorFn | null;
|
|
set validator(validatorFn: ValidatorFn | null);
|
|
readonly value: TValue;
|
|
readonly valueChanges: Observable<TValue>;
|
|
}
|
|
|
|
// @public
|
|
export abstract class AbstractControlDirective {
|
|
get asyncValidator(): AsyncValidatorFn | null;
|
|
abstract get control(): AbstractControl | null;
|
|
get dirty(): boolean | null;
|
|
get disabled(): boolean | null;
|
|
get enabled(): boolean | null;
|
|
get errors(): ValidationErrors | null;
|
|
getError(errorCode: string, path?: Array<string | number> | string): any;
|
|
hasError(errorCode: string, path?: Array<string | number> | string): boolean;
|
|
get invalid(): boolean | null;
|
|
get path(): string[] | null;
|
|
get pending(): boolean | null;
|
|
get pristine(): boolean | null;
|
|
reset(value?: any): void;
|
|
get status(): string | null;
|
|
get statusChanges(): Observable<any> | null;
|
|
get touched(): boolean | null;
|
|
get untouched(): boolean | null;
|
|
get valid(): boolean | null;
|
|
get validator(): ValidatorFn | null;
|
|
get value(): any;
|
|
get valueChanges(): Observable<any> | null;
|
|
}
|
|
|
|
// @public
|
|
export interface AbstractControlOptions {
|
|
asyncValidators?: AsyncValidatorFn | AsyncValidatorFn[] | null;
|
|
updateOn?: 'change' | 'blur' | 'submit';
|
|
validators?: ValidatorFn | ValidatorFn[] | null;
|
|
}
|
|
|
|
// @public
|
|
export abstract class AbstractFormDirective extends ControlContainer implements Form, OnChanges, OnDestroy {
|
|
constructor(validators: (Validator | ValidatorFn)[], asyncValidators: (AsyncValidator | AsyncValidatorFn)[], callSetDisabledState?: SetDisabledStateOption | undefined);
|
|
addControl(dir: FormControlName): FormControl;
|
|
addFormArray(dir: FormArrayName): void;
|
|
addFormGroup(dir: FormGroupName): void;
|
|
abstract get control(): AbstractControl;
|
|
directives: FormControlName[];
|
|
abstract form: AbstractControl;
|
|
get formDirective(): Form;
|
|
getControl(dir: FormControlName): FormControl;
|
|
getFormArray(dir: FormArrayName): FormArray;
|
|
getFormGroup(dir: FormGroupName): FormGroup;
|
|
// (undocumented)
|
|
ngOnChanges(changes: SimpleChanges): void;
|
|
// (undocumented)
|
|
ngOnDestroy(): void;
|
|
abstract ngSubmit: EventEmitter<any>;
|
|
// (undocumented)
|
|
protected onChanges(changes: SimpleChanges): void;
|
|
// (undocumented)
|
|
protected onDestroy(): void;
|
|
onReset(): void;
|
|
onSubmit($event: Event): boolean;
|
|
get path(): string[];
|
|
removeControl(dir: FormControlName): void;
|
|
removeFormArray(dir: FormArrayName): void;
|
|
removeFormGroup(dir: FormGroupName): void;
|
|
resetForm(value?: any, options?: {
|
|
onlySelf?: boolean;
|
|
emitEvent?: boolean;
|
|
}): void;
|
|
get submitted(): boolean;
|
|
updateModel(dir: FormControlName, value: any): void;
|
|
// (undocumented)
|
|
static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractFormDirective, never, never, {}, {}, never, never, true, never>;
|
|
// (undocumented)
|
|
static ɵfac: i0.ɵɵFactoryDeclaration<AbstractFormDirective, [{ optional: true; self: true; }, { optional: true; self: true; }, { optional: true; }]>;
|
|
}
|
|
|
|
// @public
|
|
export class AbstractFormGroupDirective extends ControlContainer implements OnInit, OnDestroy {
|
|
get control(): FormGroup;
|
|
get formDirective(): Form | null;
|
|
ngOnDestroy(): void;
|
|
ngOnInit(): void;
|
|
get path(): string[];
|
|
// (undocumented)
|
|
static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractFormGroupDirective, never, never, {}, {}, never, never, false, never>;
|
|
// (undocumented)
|
|
static ɵfac: i0.ɵɵFactoryDeclaration<AbstractFormGroupDirective, never>;
|
|
}
|
|
|
|
// @public
|
|
export interface AsyncValidator extends Validator {
|
|
validate(control: AbstractControl): Promise<ValidationErrors | null> | Observable<ValidationErrors | null>;
|
|
}
|
|
|
|
// @public
|
|
export interface AsyncValidatorFn {
|
|
// (undocumented)
|
|
(control: AbstractControl): Promise<ValidationErrors | null> | Observable<ValidationErrors | null>;
|
|
}
|
|
|
|
// @public
|
|
export class CheckboxControlValueAccessor extends BuiltInControlValueAccessor implements ControlValueAccessor {
|
|
writeValue(value: any): void;
|
|
// (undocumented)
|
|
static ɵdir: i0.ɵɵDirectiveDeclaration<CheckboxControlValueAccessor, "input[type=checkbox]:not([ngNoCva])[formControlName],input[type=checkbox]:not([ngNoCva])[formControl],input[type=checkbox]:not([ngNoCva])[ngModel]", never, {}, {}, never, never, false, never>;
|
|
// (undocumented)
|
|
static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxControlValueAccessor, never>;
|
|
}
|
|
|
|
// @public
|
|
export class CheckboxRequiredValidator extends RequiredValidator {
|
|
// (undocumented)
|
|
static ɵdir: i0.ɵɵDirectiveDeclaration<CheckboxRequiredValidator, "input[type=checkbox][required][formControlName],input[type=checkbox][required][formControl],input[type=checkbox][required][ngModel]", never, {}, {}, never, never, false, never>;
|
|
// (undocumented)
|
|
static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxRequiredValidator, never>;
|
|
}
|
|
|
|
// @public
|
|
export const COMPOSITION_BUFFER_MODE: InjectionToken<boolean>;
|
|
|
|
// @public
|
|
export type ControlConfig<T> = [
|
|
T | FormControlState<T>,
|
|
(ValidatorFn | ValidatorFn[])?,
|
|
(AsyncValidatorFn | AsyncValidatorFn[])?
|
|
];
|
|
|
|
// @public
|
|
export abstract class ControlContainer extends AbstractControlDirective {
|
|
get formDirective(): Form | null;
|
|
name: string | number | null;
|
|
get path(): string[] | null;
|
|
}
|
|
|
|
// @public
|
|
export abstract class ControlEvent<T = any> {
|
|
abstract readonly source: AbstractControl<unknown>;
|
|
}
|
|
|
|
// @public
|
|
export interface ControlValueAccessor {
|
|
registerOnChange(fn: any): void;
|
|
registerOnTouched(fn: any): void;
|
|
setDisabledState?(isDisabled: boolean): void;
|
|
writeValue(obj: any): void;
|
|
}
|
|
|
|
// @public
|
|
export class DefaultValueAccessor extends BaseControlValueAccessor implements ControlValueAccessor {
|
|
constructor(renderer: Renderer2, elementRef: ElementRef, _compositionMode: boolean);
|
|
writeValue(value: any): void;
|
|
// (undocumented)
|
|
static ɵdir: i0.ɵɵDirectiveDeclaration<DefaultValueAccessor, "input:not([type=checkbox]):not([ngNoCva])[formControlName],textarea:not([ngNoCva])[formControlName],input:not([type=checkbox]):not([ngNoCva])[formControl],textarea:not([ngNoCva])[formControl],input:not([type=checkbox]):not([ngNoCva])[ngModel],textarea:not([ngNoCva])[ngModel],[ngDefaultControl]", never, {}, {}, never, never, false, never>;
|
|
// (undocumented)
|
|
static ɵfac: i0.ɵɵFactoryDeclaration<DefaultValueAccessor, [null, null, { optional: true; }]>;
|
|
}
|
|
|
|
// @public
|
|
export class EmailValidator extends AbstractValidatorDirective {
|
|
email: boolean | string;
|
|
enabled(input: boolean): boolean;
|
|
// (undocumented)
|
|
static ɵdir: i0.ɵɵDirectiveDeclaration<EmailValidator, "[email][formControlName],[email][formControl],[email][ngModel]", never, { "email": { "alias": "email"; "required": false; }; }, {}, never, never, false, never>;
|
|
// (undocumented)
|
|
static ɵfac: i0.ɵɵFactoryDeclaration<EmailValidator, never>;
|
|
}
|
|
|
|
// @public
|
|
export interface Form {
|
|
addControl(dir: NgControl): void;
|
|
addFormGroup(dir: AbstractFormGroupDirective): void;
|
|
getControl(dir: NgControl): FormControl;
|
|
getFormGroup(dir: AbstractFormGroupDirective): FormGroup;
|
|
removeControl(dir: NgControl): void;
|
|
removeFormGroup(dir: AbstractFormGroupDirective): void;
|
|
updateModel(dir: NgControl, value: any): void;
|
|
}
|
|
|
|
// @public
|
|
export class FormArray<TControl extends AbstractControl<any> = any> extends AbstractControl<ɵTypedOrUntyped<TControl, ɵFormArrayValue<TControl>, any>, ɵTypedOrUntyped<TControl, ɵFormArrayRawValue<TControl>, any>> {
|
|
constructor(controls: Array<TControl>, validatorOrOpts?: ValidatorFn | ValidatorFn[] | AbstractControlOptions | null, asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null);
|
|
at(index: number): ɵTypedOrUntyped<TControl, TControl, AbstractControl<any>>;
|
|
clear(options?: {
|
|
emitEvent?: boolean;
|
|
}): void;
|
|
// (undocumented)
|
|
controls: ɵTypedOrUntyped<TControl, Array<TControl>, Array<AbstractControl<any>>>;
|
|
getRawValue(): ɵFormArrayRawValue<TControl>;
|
|
insert(index: number, control: TControl, options?: {
|
|
emitEvent?: boolean;
|
|
}): void;
|
|
get length(): number;
|
|
patchValue(value: ɵFormArrayValue<TControl>, options?: {
|
|
onlySelf?: boolean;
|
|
emitEvent?: boolean;
|
|
}): void;
|
|
push(control: TControl | Array<TControl>, options?: {
|
|
emitEvent?: boolean;
|
|
}): void;
|
|
removeAt(index: number, options?: {
|
|
emitEvent?: boolean;
|
|
}): void;
|
|
reset(value?: ɵTypedOrUntyped<TControl, ɵFormArrayValue<TControl>, any>, options?: {
|
|
onlySelf?: boolean;
|
|
emitEvent?: boolean;
|
|
overwriteDefaultValue?: boolean;
|
|
}): void;
|
|
setControl(index: number, control: TControl, options?: {
|
|
emitEvent?: boolean;
|
|
}): void;
|
|
setValue(value: ɵFormArrayRawValue<TControl>, options?: {
|
|
onlySelf?: boolean;
|
|
emitEvent?: boolean;
|
|
}): void;
|
|
}
|
|
|
|
// @public
|
|
export class FormArrayDirective extends AbstractFormDirective {
|
|
get control(): FormArray;
|
|
form: FormArray;
|
|
ngSubmit: EventEmitter<any>;
|
|
// (undocumented)
|
|
static ɵdir: i0.ɵɵDirectiveDeclaration<FormArrayDirective, "[formArray]", ["ngForm"], { "form": { "alias": "formArray"; "required": false; }; }, { "ngSubmit": "ngSubmit"; }, never, never, false, never>;
|
|
// (undocumented)
|
|
static ɵfac: i0.ɵɵFactoryDeclaration<FormArrayDirective, never>;
|
|
}
|
|
|
|
// @public
|
|
export class FormArrayName extends ControlContainer implements OnInit, OnDestroy {
|
|
constructor(parent: ControlContainer, validators: (Validator | ValidatorFn)[], asyncValidators: (AsyncValidator | AsyncValidatorFn)[]);
|
|
get control(): FormArray;
|
|
get formDirective(): AbstractFormDirective | null;
|
|
name: string | number | null;
|
|
ngOnDestroy(): void;
|
|
ngOnInit(): void;
|
|
get path(): string[];
|
|
// (undocumented)
|
|
static ɵdir: i0.ɵɵDirectiveDeclaration<FormArrayName, "[formArrayName]", never, { "name": { "alias": "formArrayName"; "required": false; }; }, {}, never, never, false, never>;
|
|
// (undocumented)
|
|
static ɵfac: i0.ɵɵFactoryDeclaration<FormArrayName, [{ optional: true; host: true; skipSelf: true; }, { optional: true; self: true; }, { optional: true; self: true; }]>;
|
|
}
|
|
|
|
// @public
|
|
export class FormBuilder {
|
|
array<T>(controls: Array<T>, validatorOrOpts?: ValidatorFn | ValidatorFn[] | AbstractControlOptions | null, asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null): FormArray<ɵElement<T, null>>;
|
|
// @deprecated (undocumented)
|
|
control<T>(formState: T | FormControlState<T>, opts: FormControlOptions & {
|
|
initialValueIsDefault: true;
|
|
}): FormControl<T>;
|
|
// (undocumented)
|
|
control<T>(formState: T | FormControlState<T>, opts: FormControlOptions & {
|
|
nonNullable: true;
|
|
}): FormControl<T>;
|
|
// @deprecated (undocumented)
|
|
control<T>(formState: T | FormControlState<T>, opts: FormControlOptions, asyncValidator: AsyncValidatorFn | AsyncValidatorFn[]): FormControl<T | null>;
|
|
// (undocumented)
|
|
control<T>(formState: T | FormControlState<T>, validatorOrOpts?: ValidatorFn | ValidatorFn[] | FormControlOptions | null, asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null): FormControl<T | null>;
|
|
group<T extends {}>(controls: T, options?: AbstractControlOptions | null): FormGroup<ɵNullableFormControls<T>>;
|
|
// @deprecated
|
|
group(controls: {
|
|
[key: string]: any;
|
|
}, options: {
|
|
[key: string]: any;
|
|
}): FormGroup;
|
|
get nonNullable(): NonNullableFormBuilder;
|
|
record<T>(controls: {
|
|
[key: string]: T;
|
|
}, options?: AbstractControlOptions | null): FormRecord<ɵElement<T, null>>;
|
|
// (undocumented)
|
|
static ɵfac: i0.ɵɵFactoryDeclaration<FormBuilder, never>;
|
|
// (undocumented)
|
|
static ɵprov: i0.ɵɵInjectableDeclaration<any>;
|
|
}
|
|
|
|
// @public
|
|
export interface FormControl<TValue = any> extends AbstractControl<TValue> {
|
|
defaultValue: TValue;
|
|
getRawValue(): TValue;
|
|
patchValue(value: TValue, options?: {
|
|
onlySelf?: boolean;
|
|
emitEvent?: boolean;
|
|
emitModelToViewChange?: boolean;
|
|
emitViewToModelChange?: boolean;
|
|
}): void;
|
|
registerOnChange(fn: Function): void;
|
|
registerOnDisabledChange(fn: (isDisabled: boolean) => void): void;
|
|
reset(formState?: TValue | FormControlState<TValue>, options?: {
|
|
onlySelf?: boolean;
|
|
emitEvent?: boolean;
|
|
overwriteDefaultValue?: boolean;
|
|
}): void;
|
|
setValue(value: TValue, options?: {
|
|
onlySelf?: boolean;
|
|
emitEvent?: boolean;
|
|
emitModelToViewChange?: boolean;
|
|
emitViewToModelChange?: boolean;
|
|
}): void;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export const FormControl: ɵFormControlCtor;
|
|
|
|
// @public
|
|
export class FormControlDirective extends NgControl implements OnChanges, OnDestroy {
|
|
constructor(validators: (Validator | ValidatorFn)[], asyncValidators: (AsyncValidator | AsyncValidatorFn)[], valueAccessors: ControlValueAccessor[], _ngModelWarningConfig: string | null, callSetDisabledState?: SetDisabledStateOption | undefined, renderer?: Renderer2, injector?: Injector);
|
|
get control(): FormControl;
|
|
form: FormControl;
|
|
set isDisabled(isDisabled: boolean);
|
|
// @deprecated (undocumented)
|
|
model: any;
|
|
ngOnChanges(changes: SimpleChanges): void;
|
|
ngOnDestroy(): void;
|
|
get path(): string[];
|
|
// @deprecated (undocumented)
|
|
update: EventEmitter<any>;
|
|
viewModel: any;
|
|
viewToModelUpdate(newValue: any): void;
|
|
// (undocumented)
|
|
static ɵdir: i0.ɵɵDirectiveDeclaration<FormControlDirective, "[formControl]", ["ngForm"], { "form": { "alias": "formControl"; "required": false; }; "isDisabled": { "alias": "disabled"; "required": false; }; "model": { "alias": "ngModel"; "required": false; }; }, { "update": "ngModelChange"; }, never, never, false, never>;
|
|
// (undocumented)
|
|
static ɵfac: i0.ɵɵFactoryDeclaration<FormControlDirective, [{ optional: true; self: true; }, { optional: true; self: true; }, { optional: true; self: true; }, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }]>;
|
|
}
|
|
|
|
// @public
|
|
export class FormControlName extends NgControl implements OnChanges, OnDestroy {
|
|
constructor(parent: ControlContainer, validators: (Validator | ValidatorFn)[], asyncValidators: (AsyncValidator | AsyncValidatorFn)[], valueAccessors: ControlValueAccessor[], _ngModelWarningConfig: string | null, renderer?: Renderer2, injector?: Injector);
|
|
readonly control: FormControl;
|
|
get formDirective(): any;
|
|
set isDisabled(isDisabled: boolean);
|
|
// @deprecated (undocumented)
|
|
model: any;
|
|
name: string | number | null;
|
|
ngOnChanges(changes: SimpleChanges): void;
|
|
ngOnDestroy(): void;
|
|
get path(): string[];
|
|
// @deprecated (undocumented)
|
|
update: EventEmitter<any>;
|
|
viewToModelUpdate(newValue: any): void;
|
|
// (undocumented)
|
|
static ɵdir: i0.ɵɵDirectiveDeclaration<FormControlName, "[formControlName]", never, { "name": { "alias": "formControlName"; "required": false; }; "isDisabled": { "alias": "disabled"; "required": false; }; "model": { "alias": "ngModel"; "required": false; }; }, { "update": "ngModelChange"; }, never, never, false, never>;
|
|
// (undocumented)
|
|
static ɵfac: i0.ɵɵFactoryDeclaration<FormControlName, [{ optional: true; host: true; skipSelf: true; }, { optional: true; self: true; }, { optional: true; self: true; }, { optional: true; self: true; }, { optional: true; }, { optional: true; }, { optional: true; }]>;
|
|
}
|
|
|
|
// @public
|
|
export interface FormControlOptions extends AbstractControlOptions {
|
|
// @deprecated (undocumented)
|
|
initialValueIsDefault?: boolean;
|
|
nonNullable?: boolean;
|
|
}
|
|
|
|
// @public
|
|
export interface FormControlState<T> {
|
|
// (undocumented)
|
|
disabled: boolean;
|
|
// (undocumented)
|
|
value: T;
|
|
}
|
|
|
|
// @public
|
|
export type FormControlStatus = 'VALID' | 'INVALID' | 'PENDING' | 'DISABLED';
|
|
|
|
// @public
|
|
export class FormGroup<TControl extends {
|
|
[K in keyof TControl]: AbstractControl<any>;
|
|
} = any> extends AbstractControl<ɵTypedOrUntyped<TControl, ɵFormGroupValue<TControl>, any>, ɵTypedOrUntyped<TControl, ɵFormGroupRawValue<TControl>, any>, ɵTypedOrUntyped<TControl, ɵFormGroupArgumentValue<TControl>, any>> {
|
|
constructor(controls: TControl, validatorOrOpts?: ValidatorFn | ValidatorFn[] | AbstractControlOptions | null, asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null);
|
|
addControl(this: FormGroup<{
|
|
[key: string]: AbstractControl<any>;
|
|
}>, name: string, control: AbstractControl, options?: {
|
|
emitEvent?: boolean;
|
|
}): void;
|
|
// (undocumented)
|
|
addControl<K extends string & keyof TControl>(name: K, control: Required<TControl>[K], options?: {
|
|
emitEvent?: boolean;
|
|
}): void;
|
|
contains<K extends string>(controlName: K): boolean;
|
|
// (undocumented)
|
|
contains(this: FormGroup<{
|
|
[key: string]: AbstractControl<any>;
|
|
}>, controlName: string): boolean;
|
|
// (undocumented)
|
|
controls: ɵTypedOrUntyped<TControl, TControl, {
|
|
[key: string]: AbstractControl<any>;
|
|
}>;
|
|
getRawValue(): ɵTypedOrUntyped<TControl, ɵFormGroupRawValue<TControl>, any>;
|
|
patchValue(value: ɵFormGroupValue<TControl>, options?: {
|
|
onlySelf?: boolean;
|
|
emitEvent?: boolean;
|
|
}): void;
|
|
registerControl<K extends string & keyof TControl>(name: K, control: TControl[K]): TControl[K];
|
|
// (undocumented)
|
|
registerControl(this: FormGroup<{
|
|
[key: string]: AbstractControl<any>;
|
|
}>, name: string, control: AbstractControl<any>): AbstractControl<any>;
|
|
// (undocumented)
|
|
removeControl(this: FormGroup<{
|
|
[key: string]: AbstractControl<any>;
|
|
}>, name: string, options?: {
|
|
emitEvent?: boolean;
|
|
}): void;
|
|
// (undocumented)
|
|
removeControl<S extends string>(name: ɵOptionalKeys<TControl> & S, options?: {
|
|
emitEvent?: boolean;
|
|
}): void;
|
|
reset(value?: ɵTypedOrUntyped<TControl, ɵFormGroupArgumentValue<TControl>, any>, options?: {
|
|
onlySelf?: boolean;
|
|
emitEvent?: boolean;
|
|
overwriteDefaultValue?: boolean;
|
|
}): void;
|
|
setControl<K extends string & keyof TControl>(name: K, control: TControl[K], options?: {
|
|
emitEvent?: boolean;
|
|
}): void;
|
|
// (undocumented)
|
|
setControl(this: FormGroup<{
|
|
[key: string]: AbstractControl<any>;
|
|
}>, name: string, control: AbstractControl, options?: {
|
|
emitEvent?: boolean;
|
|
}): void;
|
|
setValue(value: ɵFormGroupRawValue<TControl>, options?: {
|
|
onlySelf?: boolean;
|
|
emitEvent?: boolean;
|
|
}): void;
|
|
}
|
|
|
|
// @public
|
|
export class FormGroupDirective extends AbstractFormDirective {
|
|
get control(): FormGroup;
|
|
form: FormGroup;
|
|
ngSubmit: EventEmitter<any>;
|
|
// (undocumented)
|
|
static ɵdir: i0.ɵɵDirectiveDeclaration<FormGroupDirective, "[formGroup]", ["ngForm"], { "form": { "alias": "formGroup"; "required": false; }; }, { "ngSubmit": "ngSubmit"; }, never, never, false, never>;
|
|
// (undocumented)
|
|
static ɵfac: i0.ɵɵFactoryDeclaration<FormGroupDirective, never>;
|
|
}
|
|
|
|
// @public
|
|
export class FormGroupName extends AbstractFormGroupDirective implements OnInit, OnDestroy {
|
|
constructor(parent: ControlContainer, validators: (Validator | ValidatorFn)[], asyncValidators: (AsyncValidator | AsyncValidatorFn)[]);
|
|
name: string | number | null;
|
|
// (undocumented)
|
|
static ɵdir: i0.ɵɵDirectiveDeclaration<FormGroupName, "[formGroupName]", never, { "name": { "alias": "formGroupName"; "required": false; }; }, {}, never, never, false, never>;
|
|
// (undocumented)
|
|
static ɵfac: i0.ɵɵFactoryDeclaration<FormGroupName, [{ optional: true; host: true; skipSelf: true; }, { optional: true; self: true; }, { optional: true; self: true; }]>;
|
|
}
|
|
|
|
// @public
|
|
export class FormRecord<TControl extends AbstractControl = AbstractControl> extends FormGroup<{
|
|
[key: string]: TControl;
|
|
}> {
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export interface FormRecord<TControl> {
|
|
addControl(name: string, control: TControl, options?: {
|
|
emitEvent?: boolean;
|
|
}): void;
|
|
contains(controlName: string): boolean;
|
|
getRawValue(): {
|
|
[key: string]: ɵRawValue<TControl>;
|
|
};
|
|
patchValue(value: {
|
|
[key: string]: ɵValue<TControl>;
|
|
}, options?: {
|
|
onlySelf?: boolean;
|
|
emitEvent?: boolean;
|
|
}): void;
|
|
registerControl(name: string, control: TControl): TControl;
|
|
removeControl(name: string, options?: {
|
|
emitEvent?: boolean;
|
|
}): void;
|
|
reset(value?: {
|
|
[key: string]: ɵValue<TControl> | FormControlState<ɵValue<TControl>>;
|
|
}, options?: {
|
|
onlySelf?: boolean;
|
|
emitEvent?: boolean;
|
|
}): void;
|
|
setControl(name: string, control: TControl, options?: {
|
|
emitEvent?: boolean;
|
|
}): void;
|
|
setValue(value: {
|
|
[key: string]: ɵRawValue<TControl>;
|
|
}, options?: {
|
|
onlySelf?: boolean;
|
|
emitEvent?: boolean;
|
|
}): void;
|
|
}
|
|
|
|
// @public
|
|
export class FormResetEvent extends ControlEvent {
|
|
constructor(source: AbstractControl);
|
|
// (undocumented)
|
|
readonly source: AbstractControl;
|
|
}
|
|
|
|
// @public
|
|
export class FormsModule {
|
|
static withConfig(opts: {
|
|
callSetDisabledState?: SetDisabledStateOption;
|
|
}): ModuleWithProviders<FormsModule>;
|
|
// (undocumented)
|
|
static ɵfac: i0.ɵɵFactoryDeclaration<FormsModule, never>;
|
|
// (undocumented)
|
|
static ɵinj: i0.ɵɵInjectorDeclaration<FormsModule>;
|
|
// (undocumented)
|
|
static ɵmod: i0.ɵɵNgModuleDeclaration<FormsModule, [typeof NgModel, typeof NgModelGroup, typeof NgForm], never, [typeof ɵInternalFormsSharedModule, typeof NgModel, typeof NgModelGroup, typeof NgForm]>;
|
|
}
|
|
|
|
// @public
|
|
export class FormSubmittedEvent extends ControlEvent {
|
|
constructor(source: AbstractControl);
|
|
// (undocumented)
|
|
readonly source: AbstractControl;
|
|
}
|
|
|
|
// @public
|
|
export const isFormArray: (control: unknown) => control is FormArray;
|
|
|
|
// @public
|
|
export const isFormControl: (control: unknown) => control is FormControl;
|
|
|
|
// @public
|
|
export const isFormGroup: (control: unknown) => control is FormGroup;
|
|
|
|
// @public
|
|
export const isFormRecord: (control: unknown) => control is FormRecord;
|
|
|
|
// @public
|
|
export class MaxLengthValidator extends AbstractValidatorDirective {
|
|
maxlength: string | number | null;
|
|
// (undocumented)
|
|
static ɵdir: i0.ɵɵDirectiveDeclaration<MaxLengthValidator, "[maxlength][formControlName],[maxlength][formControl],[maxlength][ngModel]", never, { "maxlength": { "alias": "maxlength"; "required": false; }; }, {}, never, never, false, never>;
|
|
// (undocumented)
|
|
static ɵfac: i0.ɵɵFactoryDeclaration<MaxLengthValidator, never>;
|
|
}
|
|
|
|
// @public
|
|
export class MaxValidator extends AbstractValidatorDirective {
|
|
max: string | number | null;
|
|
// (undocumented)
|
|
static ɵdir: i0.ɵɵDirectiveDeclaration<MaxValidator, "input[type=number][max][formControlName],input[type=number][max][formControl],input[type=number][max][ngModel]", never, { "max": { "alias": "max"; "required": false; }; }, {}, never, never, false, never>;
|
|
// (undocumented)
|
|
static ɵfac: i0.ɵɵFactoryDeclaration<MaxValidator, never>;
|
|
}
|
|
|
|
// @public
|
|
export class MinLengthValidator extends AbstractValidatorDirective {
|
|
minlength: string | number | null;
|
|
// (undocumented)
|
|
static ɵdir: i0.ɵɵDirectiveDeclaration<MinLengthValidator, "[minlength][formControlName],[minlength][formControl],[minlength][ngModel]", never, { "minlength": { "alias": "minlength"; "required": false; }; }, {}, never, never, false, never>;
|
|
// (undocumented)
|
|
static ɵfac: i0.ɵɵFactoryDeclaration<MinLengthValidator, never>;
|
|
}
|
|
|
|
// @public
|
|
export class MinValidator extends AbstractValidatorDirective {
|
|
min: string | number | null;
|
|
// (undocumented)
|
|
static ɵdir: i0.ɵɵDirectiveDeclaration<MinValidator, "input[type=number][min][formControlName],input[type=number][min][formControl],input[type=number][min][ngModel]", never, { "min": { "alias": "min"; "required": false; }; }, {}, never, never, false, never>;
|
|
// (undocumented)
|
|
static ɵfac: i0.ɵɵFactoryDeclaration<MinValidator, never>;
|
|
}
|
|
|
|
// @public
|
|
export const NG_ASYNC_VALIDATORS: InjectionToken<readonly (Function | Validator)[]>;
|
|
|
|
// @public
|
|
export const NG_VALIDATORS: InjectionToken<readonly (Function | Validator)[]>;
|
|
|
|
// @public
|
|
export const NG_VALUE_ACCESSOR: InjectionToken<readonly ControlValueAccessor[]>;
|
|
|
|
// @public
|
|
export abstract class NgControl extends AbstractControlDirective {
|
|
constructor(injector?: Injector, renderer?: Renderer2, rawValueAccessors?: ControlValueAccessor[]);
|
|
protected customControlBindings: {
|
|
value?: unknown;
|
|
disabled?: boolean;
|
|
touched?: boolean;
|
|
dirty?: boolean;
|
|
valid?: boolean;
|
|
invalid?: boolean;
|
|
pending?: boolean;
|
|
required?: boolean;
|
|
errors?: ValidationErrors | null;
|
|
} | null;
|
|
// (undocumented)
|
|
protected isCustomControlBased: boolean;
|
|
name: string | number | null;
|
|
// (undocumented)
|
|
protected ngControlUpdate(host: ɵControlDirectiveHost, bindRequired: boolean): void;
|
|
protected parseErrorsValidator: ValidatorFn | null;
|
|
// (undocumented)
|
|
protected removeParseErrorsValidator(control: AbstractControl | null | undefined): void;
|
|
// (undocumented)
|
|
protected get selectedValueAccessor(): ControlValueAccessor | null;
|
|
// (undocumented)
|
|
protected setupCustomControl(): void;
|
|
protected get shouldBindRequired(): boolean;
|
|
valueAccessor: ControlValueAccessor | null;
|
|
abstract viewToModelUpdate(newValue: any): void;
|
|
}
|
|
|
|
// @public
|
|
export class NgControlStatus extends AbstractControlStatus {
|
|
constructor(cd: NgControl);
|
|
// (undocumented)
|
|
static ɵdir: i0.ɵɵDirectiveDeclaration<NgControlStatus, "[formControlName],[ngModel],[formControl]", never, {}, {}, never, never, false, never>;
|
|
// (undocumented)
|
|
static ɵfac: i0.ɵɵFactoryDeclaration<NgControlStatus, [{ self: true; }]>;
|
|
}
|
|
|
|
// @public
|
|
export class NgControlStatusGroup extends AbstractControlStatus {
|
|
constructor(cd: ControlContainer);
|
|
// (undocumented)
|
|
static ɵdir: i0.ɵɵDirectiveDeclaration<NgControlStatusGroup, "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],[formArray],form:not([ngNoForm]),[ngForm]", never, {}, {}, never, never, false, never>;
|
|
// (undocumented)
|
|
static ɵfac: i0.ɵɵFactoryDeclaration<NgControlStatusGroup, [{ optional: true; self: true; }]>;
|
|
}
|
|
|
|
// @public
|
|
export class NgForm extends ControlContainer implements Form, AfterViewInit {
|
|
constructor(validators: (Validator | ValidatorFn)[], asyncValidators: (AsyncValidator | AsyncValidatorFn)[], callSetDisabledState?: SetDisabledStateOption | undefined);
|
|
addControl(dir: NgModel): void;
|
|
addFormGroup(dir: NgModelGroup): void;
|
|
get control(): FormGroup;
|
|
get controls(): {
|
|
[key: string]: AbstractControl;
|
|
};
|
|
form: FormGroup;
|
|
get formDirective(): Form;
|
|
getControl(dir: NgModel): FormControl;
|
|
getFormGroup(dir: NgModelGroup): FormGroup;
|
|
ngAfterViewInit(): void;
|
|
ngSubmit: EventEmitter<any>;
|
|
onReset(): void;
|
|
onSubmit($event: Event): boolean;
|
|
options: {
|
|
updateOn?: FormHooks;
|
|
};
|
|
get path(): string[];
|
|
removeControl(dir: NgModel): void;
|
|
removeFormGroup(dir: NgModelGroup): void;
|
|
resetForm(value?: any): void;
|
|
setValue(value: {
|
|
[key: string]: any;
|
|
}): void;
|
|
get submitted(): boolean;
|
|
updateModel(dir: NgControl, value: any): void;
|
|
// (undocumented)
|
|
static ɵdir: i0.ɵɵDirectiveDeclaration<NgForm, "form:not([ngNoForm]):not([formGroup]):not([formArray]),ng-form,[ngForm]", ["ngForm"], { "options": { "alias": "ngFormOptions"; "required": false; }; }, { "ngSubmit": "ngSubmit"; }, never, never, false, never>;
|
|
// (undocumented)
|
|
static ɵfac: i0.ɵɵFactoryDeclaration<NgForm, [{ optional: true; self: true; }, { optional: true; self: true; }, { optional: true; }]>;
|
|
}
|
|
|
|
// @public
|
|
export class NgModel extends NgControl implements OnChanges, OnDestroy {
|
|
constructor(parent: ControlContainer, validators: (Validator | ValidatorFn)[], asyncValidators: (AsyncValidator | AsyncValidatorFn)[], valueAccessors: ControlValueAccessor[], _changeDetectorRef?: (ChangeDetectorRef | null) | undefined, callSetDisabledState?: SetDisabledStateOption | undefined, injector?: Injector, renderer?: Renderer2);
|
|
// (undocumented)
|
|
readonly control: FormControl;
|
|
get formDirective(): any;
|
|
isDisabled: boolean;
|
|
model: any;
|
|
name: string;
|
|
static ngAcceptInputType_isDisabled: boolean | string;
|
|
ngOnChanges(changes: SimpleChanges): void;
|
|
ngOnDestroy(): void;
|
|
options: {
|
|
name?: string;
|
|
standalone?: boolean;
|
|
updateOn?: FormHooks;
|
|
};
|
|
get path(): string[];
|
|
protected get shouldBindRequired(): boolean;
|
|
update: EventEmitter<any>;
|
|
viewModel: any;
|
|
viewToModelUpdate(newValue: any): void;
|
|
// (undocumented)
|
|
static ɵdir: i0.ɵɵDirectiveDeclaration<NgModel, "[ngModel]:not([formControlName]):not([formControl])", ["ngModel"], { "name": { "alias": "name"; "required": false; }; "isDisabled": { "alias": "disabled"; "required": false; }; "model": { "alias": "ngModel"; "required": false; }; "options": { "alias": "ngModelOptions"; "required": false; }; }, { "update": "ngModelChange"; }, never, never, false, never>;
|
|
// (undocumented)
|
|
static ɵfac: i0.ɵɵFactoryDeclaration<NgModel, [{ optional: true; host: true; }, { optional: true; self: true; }, { optional: true; self: true; }, { optional: true; self: true; }, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }]>;
|
|
}
|
|
|
|
// @public
|
|
export class NgModelGroup extends AbstractFormGroupDirective implements OnInit, OnDestroy {
|
|
constructor(parent: ControlContainer, validators: (Validator | ValidatorFn)[], asyncValidators: (AsyncValidator | AsyncValidatorFn)[]);
|
|
name: string;
|
|
// (undocumented)
|
|
static ɵdir: i0.ɵɵDirectiveDeclaration<NgModelGroup, "[ngModelGroup]", ["ngModelGroup"], { "name": { "alias": "ngModelGroup"; "required": false; }; }, {}, never, never, false, never>;
|
|
// (undocumented)
|
|
static ɵfac: i0.ɵɵFactoryDeclaration<NgModelGroup, [{ host: true; skipSelf: true; }, { optional: true; self: true; }, { optional: true; self: true; }]>;
|
|
}
|
|
|
|
// @public
|
|
export class NgSelectOption implements OnDestroy {
|
|
constructor(_element: ElementRef, _renderer: Renderer2, _select: SelectControlValueAccessor);
|
|
id: string;
|
|
ngOnDestroy(): void;
|
|
set ngValue(value: any);
|
|
set value(value: any);
|
|
// (undocumented)
|
|
static ɵdir: i0.ɵɵDirectiveDeclaration<NgSelectOption, "option", never, { "ngValue": { "alias": "ngValue"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, never, false, never>;
|
|
// (undocumented)
|
|
static ɵfac: i0.ɵɵFactoryDeclaration<NgSelectOption, [null, null, { optional: true; host: true; }]>;
|
|
}
|
|
|
|
// @public
|
|
export abstract class NonNullableFormBuilder {
|
|
abstract array<T>(controls: Array<T>, validatorOrOpts?: ValidatorFn | ValidatorFn[] | AbstractControlOptions | null, asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null): FormArray<ɵElement<T, never>>;
|
|
abstract control<T>(formState: T | FormControlState<T>, validatorOrOpts?: ValidatorFn | ValidatorFn[] | AbstractControlOptions | null, asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null): FormControl<T>;
|
|
abstract group<T extends {}>(controls: T, options?: AbstractControlOptions | null): FormGroup<ɵNonNullableFormControls<T>>;
|
|
abstract record<T>(controls: {
|
|
[key: string]: T;
|
|
}, options?: AbstractControlOptions | null): FormRecord<ɵElement<T, never>>;
|
|
// (undocumented)
|
|
static ɵfac: i0.ɵɵFactoryDeclaration<NonNullableFormBuilder, never>;
|
|
// (undocumented)
|
|
static ɵprov: i0.ɵɵInjectableDeclaration<any>;
|
|
}
|
|
|
|
// @public
|
|
export class NumberValueAccessor extends BuiltInControlValueAccessor implements ControlValueAccessor {
|
|
registerOnChange(fn: (_: number | null) => void): void;
|
|
writeValue(value: number): void;
|
|
// (undocumented)
|
|
static ɵdir: i0.ɵɵDirectiveDeclaration<NumberValueAccessor, "input[type=number]:not([ngNoCva])[formControlName],input[type=number]:not([ngNoCva])[formControl],input[type=number]:not([ngNoCva])[ngModel]", never, {}, {}, never, never, false, never>;
|
|
// (undocumented)
|
|
static ɵfac: i0.ɵɵFactoryDeclaration<NumberValueAccessor, never>;
|
|
}
|
|
|
|
// @public
|
|
export class PatternValidator extends AbstractValidatorDirective {
|
|
pattern: string | RegExp;
|
|
// (undocumented)
|
|
static ɵdir: i0.ɵɵDirectiveDeclaration<PatternValidator, "[pattern][formControlName],[pattern][formControl],[pattern][ngModel]", never, { "pattern": { "alias": "pattern"; "required": false; }; }, {}, never, never, false, never>;
|
|
// (undocumented)
|
|
static ɵfac: i0.ɵɵFactoryDeclaration<PatternValidator, never>;
|
|
}
|
|
|
|
// @public
|
|
export class PristineChangeEvent extends ControlEvent {
|
|
constructor(pristine: boolean, source: AbstractControl);
|
|
// (undocumented)
|
|
readonly pristine: boolean;
|
|
// (undocumented)
|
|
readonly source: AbstractControl;
|
|
}
|
|
|
|
// @public
|
|
export class RadioControlValueAccessor extends BuiltInControlValueAccessor implements ControlValueAccessor, OnDestroy, OnInit {
|
|
constructor(renderer: Renderer2, elementRef: ElementRef, _registry: RadioControlRegistry, _injector: Injector);
|
|
fireUncheck(value: any): void;
|
|
formControlName: string;
|
|
name: string;
|
|
ngOnDestroy(): void;
|
|
ngOnInit(): void;
|
|
onChange: () => void;
|
|
registerOnChange(fn: (_: any) => {}): void;
|
|
setDisabledState(isDisabled: boolean): void;
|
|
value: any;
|
|
writeValue(value: any): void;
|
|
// (undocumented)
|
|
static ɵdir: i0.ɵɵDirectiveDeclaration<RadioControlValueAccessor, "input[type=radio]:not([ngNoCva])[formControlName],input[type=radio]:not([ngNoCva])[formControl],input[type=radio]:not([ngNoCva])[ngModel]", never, { "name": { "alias": "name"; "required": false; }; "formControlName": { "alias": "formControlName"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, never, false, never>;
|
|
// (undocumented)
|
|
static ɵfac: i0.ɵɵFactoryDeclaration<RadioControlValueAccessor, never>;
|
|
}
|
|
|
|
// @public
|
|
export class RangeValueAccessor extends BuiltInControlValueAccessor implements ControlValueAccessor {
|
|
registerOnChange(fn: (_: number | null) => void): void;
|
|
writeValue(value: any): void;
|
|
// (undocumented)
|
|
static ɵdir: i0.ɵɵDirectiveDeclaration<RangeValueAccessor, "input[type=range]:not([ngNoCva])[formControlName],input[type=range]:not([ngNoCva])[formControl],input[type=range]:not([ngNoCva])[ngModel]", never, {}, {}, never, never, false, never>;
|
|
// (undocumented)
|
|
static ɵfac: i0.ɵɵFactoryDeclaration<RangeValueAccessor, never>;
|
|
}
|
|
|
|
// @public
|
|
export class ReactiveFormsModule {
|
|
static withConfig(opts: {
|
|
warnOnNgModelWithFormControl?: 'never' | 'once' | 'always';
|
|
callSetDisabledState?: SetDisabledStateOption;
|
|
}): ModuleWithProviders<ReactiveFormsModule>;
|
|
// (undocumented)
|
|
static ɵfac: i0.ɵɵFactoryDeclaration<ReactiveFormsModule, never>;
|
|
// (undocumented)
|
|
static ɵinj: i0.ɵɵInjectorDeclaration<ReactiveFormsModule>;
|
|
// (undocumented)
|
|
static ɵmod: i0.ɵɵNgModuleDeclaration<ReactiveFormsModule, [typeof FormControlDirective, typeof FormGroupDirective, typeof FormArrayDirective, typeof FormControlName, typeof FormGroupName, typeof FormArrayName], never, [typeof ɵInternalFormsSharedModule, typeof FormControlDirective, typeof FormGroupDirective, typeof FormArrayDirective, typeof FormControlName, typeof FormGroupName, typeof FormArrayName]>;
|
|
}
|
|
|
|
// @public
|
|
export class RequiredValidator extends AbstractValidatorDirective {
|
|
enabled(input: boolean): boolean;
|
|
required: boolean | string;
|
|
// (undocumented)
|
|
static ɵdir: i0.ɵɵDirectiveDeclaration<RequiredValidator, ":not([type=checkbox])[required][formControlName],:not([type=checkbox])[required][formControl],:not([type=checkbox])[required][ngModel]", never, { "required": { "alias": "required"; "required": false; }; }, {}, never, never, false, never>;
|
|
// (undocumented)
|
|
static ɵfac: i0.ɵɵFactoryDeclaration<RequiredValidator, never>;
|
|
}
|
|
|
|
// @public
|
|
export class SelectControlValueAccessor extends BuiltInControlValueAccessor implements ControlValueAccessor {
|
|
set compareWith(fn: (o1: any, o2: any) => boolean);
|
|
registerOnChange(fn: (value: any) => any): void;
|
|
value: any;
|
|
writeValue(value: any): void;
|
|
// (undocumented)
|
|
static ɵdir: i0.ɵɵDirectiveDeclaration<SelectControlValueAccessor, "select:not([multiple]):not([ngNoCva])[formControlName],select:not([multiple]):not([ngNoCva])[formControl],select:not([multiple]):not([ngNoCva])[ngModel]", never, { "compareWith": { "alias": "compareWith"; "required": false; }; }, {}, never, never, false, never>;
|
|
// (undocumented)
|
|
static ɵfac: i0.ɵɵFactoryDeclaration<SelectControlValueAccessor, never>;
|
|
}
|
|
|
|
// @public
|
|
export class SelectMultipleControlValueAccessor extends BuiltInControlValueAccessor implements ControlValueAccessor {
|
|
set compareWith(fn: (o1: any, o2: any) => boolean);
|
|
registerOnChange(fn: (value: any) => any): void;
|
|
value: any;
|
|
writeValue(value: any): void;
|
|
// (undocumented)
|
|
static ɵdir: i0.ɵɵDirectiveDeclaration<SelectMultipleControlValueAccessor, "select[multiple]:not([ngNoCva])[formControlName],select[multiple]:not([ngNoCva])[formControl],select[multiple]:not([ngNoCva])[ngModel]", never, { "compareWith": { "alias": "compareWith"; "required": false; }; }, {}, never, never, false, never>;
|
|
// (undocumented)
|
|
static ɵfac: i0.ɵɵFactoryDeclaration<SelectMultipleControlValueAccessor, never>;
|
|
}
|
|
|
|
// @public
|
|
export type SetDisabledStateOption = 'whenDisabledForLegacyCode' | 'always';
|
|
|
|
// @public
|
|
export class StatusChangeEvent extends ControlEvent {
|
|
constructor(status: FormControlStatus, source: AbstractControl);
|
|
// (undocumented)
|
|
readonly source: AbstractControl;
|
|
// (undocumented)
|
|
readonly status: FormControlStatus;
|
|
}
|
|
|
|
// @public
|
|
export class TouchedChangeEvent extends ControlEvent {
|
|
constructor(touched: boolean, source: AbstractControl);
|
|
// (undocumented)
|
|
readonly source: AbstractControl;
|
|
// (undocumented)
|
|
readonly touched: boolean;
|
|
}
|
|
|
|
// @public
|
|
export type UntypedFormArray = FormArray<any>;
|
|
|
|
// @public (undocumented)
|
|
export const UntypedFormArray: UntypedFormArrayCtor;
|
|
|
|
// @public
|
|
export class UntypedFormBuilder extends FormBuilder {
|
|
array(controlsConfig: any[], validatorOrOpts?: ValidatorFn | ValidatorFn[] | AbstractControlOptions | null, asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null): UntypedFormArray;
|
|
control(formState: any, validatorOrOpts?: ValidatorFn | ValidatorFn[] | FormControlOptions | null, asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null): UntypedFormControl;
|
|
group(controlsConfig: {
|
|
[key: string]: any;
|
|
}, options?: AbstractControlOptions | null): UntypedFormGroup;
|
|
// @deprecated (undocumented)
|
|
group(controlsConfig: {
|
|
[key: string]: any;
|
|
}, options: {
|
|
[key: string]: any;
|
|
}): UntypedFormGroup;
|
|
// (undocumented)
|
|
static ɵfac: i0.ɵɵFactoryDeclaration<UntypedFormBuilder, never>;
|
|
// (undocumented)
|
|
static ɵprov: i0.ɵɵInjectableDeclaration<any>;
|
|
}
|
|
|
|
// @public
|
|
export type UntypedFormControl = FormControl<any>;
|
|
|
|
// @public (undocumented)
|
|
export const UntypedFormControl: UntypedFormControlCtor;
|
|
|
|
// @public
|
|
export type UntypedFormGroup = FormGroup<any>;
|
|
|
|
// @public (undocumented)
|
|
export const UntypedFormGroup: UntypedFormGroupCtor;
|
|
|
|
// @public
|
|
export type ValidationErrors = {
|
|
[key: string]: any;
|
|
};
|
|
|
|
// @public
|
|
export interface Validator {
|
|
registerOnValidatorChange?(fn: () => void): void;
|
|
validate(control: AbstractControl): ValidationErrors | null;
|
|
}
|
|
|
|
// @public
|
|
export interface ValidatorFn {
|
|
// (undocumented)
|
|
(control: AbstractControl): ValidationErrors | null;
|
|
}
|
|
|
|
// @public
|
|
export class Validators {
|
|
static compose(validators: null): null;
|
|
// (undocumented)
|
|
static compose(validators: (ValidatorFn | null | undefined)[]): ValidatorFn | null;
|
|
static composeAsync(validators: (AsyncValidatorFn | null)[]): AsyncValidatorFn | null;
|
|
static email(control: AbstractControl): ValidationErrors | null;
|
|
static max(max: number): ValidatorFn;
|
|
static maxLength(maxLength: number): ValidatorFn;
|
|
static min(min: number): ValidatorFn;
|
|
static minLength(minLength: number): ValidatorFn;
|
|
static nullValidator(control: AbstractControl): ValidationErrors | null;
|
|
static pattern(pattern: string | RegExp): ValidatorFn;
|
|
static required(control: AbstractControl): ValidationErrors | null;
|
|
static requiredTrue(control: AbstractControl): ValidationErrors | null;
|
|
}
|
|
|
|
// @public
|
|
export class ValueChangeEvent<T> extends ControlEvent<T> {
|
|
constructor(value: T, source: AbstractControl);
|
|
// (undocumented)
|
|
readonly source: AbstractControl;
|
|
// (undocumented)
|
|
readonly value: T;
|
|
}
|
|
|
|
// @public (undocumented)
|
|
export const VERSION: Version;
|
|
|
|
// (No @packageDocumentation comment for this package)
|
|
|
|
```
|