├── ANGULAR_PACKAGE
├── BUILD_INFO
├── LICENSE
├── README.md
├── fesm2022
    ├── forms.mjs
    └── forms.mjs.map
├── index.d.ts
└── package.json


/ANGULAR_PACKAGE:
--------------------------------------------------------------------------------
1 | This file is used by the npm/yarn_install rule to detect APF. See https://github.com/bazelbuild/rules_nodejs/issues/927
2 | 


--------------------------------------------------------------------------------
/BUILD_INFO:
--------------------------------------------------------------------------------
1 | Fri Jun 6 22:27:02 UTC 2025
2 | 21fc93bf4b2183114d7703dbea4e57c30b54c66e
3 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License
 2 | 
 3 | Copyright (c) 2010-2025 Google LLC. https://angular.dev/license
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in
13 | all copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | THE SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | Angular
2 | =======
3 | 
4 | The sources for this package are in the main [Angular](https://github.com/angular/angular) repo. Please file issues and pull requests against that repo.
5 | 
6 | Usage information and reference details can be found in [Angular documentation](https://angular.dev/overview).
7 | 
8 | License: MIT
9 | 


--------------------------------------------------------------------------------
/index.d.ts:
--------------------------------------------------------------------------------
   1 | /**
   2 |  * @license Angular v20.1.0-next.0+sha-21fc93b
   3 |  * (c) 2010-2025 Google LLC. https://angular.io/
   4 |  * License: MIT
   5 |  */
   6 | 
   7 | import * as i0 from '@angular/core';
   8 | import { InjectionToken, Renderer2, ElementRef, OnDestroy, OnChanges, SimpleChanges, OnInit, Injector, EventEmitter, ChangeDetectorRef, AfterViewInit, Version, ModuleWithProviders } from '@angular/core';
   9 | import { Observable } from 'rxjs';
  10 | 
  11 | /**
  12 |  * @description
  13 |  *
  14 |  * Adds `novalidate` attribute to all forms by default.
  15 |  *
  16 |  * `novalidate` is used to disable browser's native form validation.
  17 |  *
  18 |  * If you want to use native validation with Angular forms, just add `ngNativeValidate` attribute:
  19 |  *
  20 |  * ```html
  21 |  * <form ngNativeValidate></form>
  22 |  * ```
  23 |  *
  24 |  * @publicApi
  25 |  * @ngModule ReactiveFormsModule
  26 |  * @ngModule FormsModule
  27 |  */
  28 | declare class ɵNgNoValidate {
  29 |     static ɵfac: i0.ɵɵFactoryDeclaration<ɵNgNoValidate, never>;
  30 |     static ɵdir: i0.ɵɵDirectiveDeclaration<ɵNgNoValidate, "form:not([ngNoForm]):not([ngNativeValidate])", never, {}, {}, never, never, false, never>;
  31 | }
  32 | 
  33 | /**
  34 |  * @description
  35 |  * Defines an interface that acts as a bridge between the Angular forms API and a
  36 |  * native element in the DOM.
  37 |  *
  38 |  * Implement this interface to create a custom form control directive
  39 |  * that integrates with Angular forms.
  40 |  *
  41 |  * @see {@link DefaultValueAccessor}
  42 |  *
  43 |  * @publicApi
  44 |  */
  45 | interface ControlValueAccessor {
  46 |     /**
  47 |      * @description
  48 |      * Writes a new value to the element.
  49 |      *
  50 |      * This method is called by the forms API to write to the view when programmatic
  51 |      * changes from model to view are requested.
  52 |      *
  53 |      * @usageNotes
  54 |      * ### Write a value to the element
  55 |      *
  56 |      * The following example writes a value to the native DOM element.
  57 |      *
  58 |      * ```ts
  59 |      * writeValue(value: any): void {
  60 |      *   this._renderer.setProperty(this._elementRef.nativeElement, 'value', value);
  61 |      * }
  62 |      * ```
  63 |      *
  64 |      * @param obj The new value for the element
  65 |      */
  66 |     writeValue(obj: any): void;
  67 |     /**
  68 |      * @description
  69 |      * Registers a callback function that is called when the control's value
  70 |      * changes in the UI.
  71 |      *
  72 |      * This method is called by the forms API on initialization to update the form
  73 |      * model when values propagate from the view to the model.
  74 |      *
  75 |      * When implementing the `registerOnChange` method in your own value accessor,
  76 |      * save the given function so your class calls it at the appropriate time.
  77 |      *
  78 |      * @usageNotes
  79 |      * ### Store the change function
  80 |      *
  81 |      * The following example stores the provided function as an internal method.
  82 |      *
  83 |      * ```ts
  84 |      * registerOnChange(fn: (_: any) => void): void {
  85 |      *   this._onChange = fn;
  86 |      * }
  87 |      * ```
  88 |      *
  89 |      * When the value changes in the UI, call the registered
  90 |      * function to allow the forms API to update itself:
  91 |      *
  92 |      * ```ts
  93 |      * host: {
  94 |      *    '(change)': '_onChange($event.target.value)'
  95 |      * }
  96 |      * ```
  97 |      *
  98 |      * @param fn The callback function to register
  99 |      */
 100 |     registerOnChange(fn: any): void;
 101 |     /**
 102 |      * @description
 103 |      * Registers a callback function that is called by the forms API on initialization
 104 |      * to update the form model on blur.
 105 |      *
 106 |      * When implementing `registerOnTouched` in your own value accessor, save the given
 107 |      * function so your class calls it when the control should be considered
 108 |      * blurred or "touched".
 109 |      *
 110 |      * @usageNotes
 111 |      * ### Store the callback function
 112 |      *
 113 |      * The following example stores the provided function as an internal method.
 114 |      *
 115 |      * ```ts
 116 |      * registerOnTouched(fn: any): void {
 117 |      *   this._onTouched = fn;
 118 |      * }
 119 |      * ```
 120 |      *
 121 |      * On blur (or equivalent), your class should call the registered function to allow
 122 |      * the forms API to update itself:
 123 |      *
 124 |      * ```ts
 125 |      * host: {
 126 |      *    '(blur)': '_onTouched()'
 127 |      * }
 128 |      * ```
 129 |      *
 130 |      * @param fn The callback function to register
 131 |      */
 132 |     registerOnTouched(fn: any): void;
 133 |     /**
 134 |      * @description
 135 |      * Function that is called by the forms API when the control status changes to
 136 |      * or from 'DISABLED'. Depending on the status, it enables or disables the
 137 |      * appropriate DOM element.
 138 |      *
 139 |      * @usageNotes
 140 |      * The following is an example of writing the disabled property to a native DOM element:
 141 |      *
 142 |      * ```ts
 143 |      * setDisabledState(isDisabled: boolean): void {
 144 |      *   this._renderer.setProperty(this._elementRef.nativeElement, 'disabled', isDisabled);
 145 |      * }
 146 |      * ```
 147 |      *
 148 |      * @param isDisabled The disabled status to set on the element
 149 |      */
 150 |     setDisabledState?(isDisabled: boolean): void;
 151 | }
 152 | /**
 153 |  * Base class for all ControlValueAccessor classes defined in Forms package.
 154 |  * Contains common logic and utility functions.
 155 |  *
 156 |  * Note: this is an *internal-only* class and should not be extended or used directly in
 157 |  * applications code.
 158 |  */
 159 | declare class BaseControlValueAccessor {
 160 |     private _renderer;
 161 |     private _elementRef;
 162 |     /**
 163 |      * The registered callback function called when a change or input event occurs on the input
 164 |      * element.
 165 |      * @docs-private
 166 |      */
 167 |     onChange: (_: any) => void;
 168 |     /**
 169 |      * The registered callback function called when a blur event occurs on the input element.
 170 |      * @docs-private
 171 |      */
 172 |     onTouched: () => void;
 173 |     constructor(_renderer: Renderer2, _elementRef: ElementRef);
 174 |     /**
 175 |      * Helper method that sets a property on a target element using the current Renderer
 176 |      * implementation.
 177 |      * @docs-private
 178 |      */
 179 |     protected setProperty(key: string, value: any): void;
 180 |     /**
 181 |      * Registers a function called when the control is touched.
 182 |      * @docs-private
 183 |      */
 184 |     registerOnTouched(fn: () => void): void;
 185 |     /**
 186 |      * Registers a function called when the control value changes.
 187 |      * @docs-private
 188 |      */
 189 |     registerOnChange(fn: (_: any) => {}): void;
 190 |     /**
 191 |      * Sets the "disabled" property on the range input element.
 192 |      * @docs-private
 193 |      */
 194 |     setDisabledState(isDisabled: boolean): void;
 195 |     static ɵfac: i0.ɵɵFactoryDeclaration<BaseControlValueAccessor, never>;
 196 |     static ɵdir: i0.ɵɵDirectiveDeclaration<BaseControlValueAccessor, never, never, {}, {}, never, never, true, never>;
 197 | }
 198 | /**
 199 |  * Base class for all built-in ControlValueAccessor classes (except DefaultValueAccessor, which is
 200 |  * used in case no other CVAs can be found). We use this class to distinguish between default CVA,
 201 |  * built-in CVAs and custom CVAs, so that Forms logic can recognize built-in CVAs and treat custom
 202 |  * ones with higher priority (when both built-in and custom CVAs are present).
 203 |  *
 204 |  * Note: this is an *internal-only* class and should not be extended or used directly in
 205 |  * applications code.
 206 |  */
 207 | declare class BuiltInControlValueAccessor extends BaseControlValueAccessor {
 208 |     static ɵfac: i0.ɵɵFactoryDeclaration<BuiltInControlValueAccessor, never>;
 209 |     static ɵdir: i0.ɵɵDirectiveDeclaration<BuiltInControlValueAccessor, never, never, {}, {}, never, never, true, never>;
 210 | }
 211 | /**
 212 |  * Used to provide a `ControlValueAccessor` for form controls.
 213 |  *
 214 |  * See `DefaultValueAccessor` for how to implement one.
 215 |  *
 216 |  * @publicApi
 217 |  */
 218 | declare const NG_VALUE_ACCESSOR: InjectionToken<readonly ControlValueAccessor[]>;
 219 | 
 220 | /**
 221 |  * @description
 222 |  * The `ControlValueAccessor` for writing select control values and listening to select control
 223 |  * changes. The value accessor is used by the `FormControlDirective`, `FormControlName`, and
 224 |  * `NgModel` directives.
 225 |  *
 226 |  * @usageNotes
 227 |  *
 228 |  * ### Using select controls in a reactive form
 229 |  *
 230 |  * The following examples show how to use a select control in a reactive form.
 231 |  *
 232 |  * {@example forms/ts/reactiveSelectControl/reactive_select_control_example.ts region='Component'}
 233 |  *
 234 |  * ### Using select controls in a template-driven form
 235 |  *
 236 |  * To use a select in a template-driven form, simply add an `ngModel` and a `name`
 237 |  * attribute to the main `<select>` tag.
 238 |  *
 239 |  * {@example forms/ts/selectControl/select_control_example.ts region='Component'}
 240 |  *
 241 |  * ### Customizing option selection
 242 |  *
 243 |  * Angular uses object identity to select option. It's possible for the identities of items
 244 |  * to change while the data does not. This can happen, for example, if the items are produced
 245 |  * from an RPC to the server, and that RPC is re-run. Even if the data hasn't changed, the
 246 |  * second response will produce objects with different identities.
 247 |  *
 248 |  * To customize the default option comparison algorithm, `<select>` supports `compareWith` input.
 249 |  * `compareWith` takes a **function** which has two arguments: `option1` and `option2`.
 250 |  * If `compareWith` is given, Angular selects option by the return value of the function.
 251 |  *
 252 |  * ```ts
 253 |  * const selectedCountriesControl = new FormControl();
 254 |  * ```
 255 |  *
 256 |  * ```html
 257 |  * <select [compareWith]="compareFn"  [formControl]="selectedCountriesControl">
 258 |  *    @for(country of countries; track $index) {
 259 |  *        <option[ngValue]="country">{{country.name}}</option>
 260 |  *    }
 261 |  * </select>
 262 |  *
 263 |  * compareFn(c1: Country, c2: Country): boolean {
 264 |  *     return c1 && c2 ? c1.id === c2.id : c1 === c2;
 265 |  * }
 266 |  * ```
 267 |  *
 268 |  * **Note:** We listen to the 'change' event because 'input' events aren't fired
 269 |  * for selects in IE, see:
 270 |  * https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/input_event#browser_compatibility
 271 |  *
 272 |  * @ngModule ReactiveFormsModule
 273 |  * @ngModule FormsModule
 274 |  * @publicApi
 275 |  */
 276 | declare class SelectControlValueAccessor extends BuiltInControlValueAccessor implements ControlValueAccessor {
 277 |     /** @docs-private */
 278 |     value: any;
 279 |     /**
 280 |      * @description
 281 |      * Tracks the option comparison algorithm for tracking identities when
 282 |      * checking for changes.
 283 |      */
 284 |     set compareWith(fn: (o1: any, o2: any) => boolean);
 285 |     private _compareWith;
 286 |     /**
 287 |      * Sets the "value" property on the select element.
 288 |      * @docs-private
 289 |      */
 290 |     writeValue(value: any): void;
 291 |     /**
 292 |      * Registers a function called when the control value changes.
 293 |      * @docs-private
 294 |      */
 295 |     registerOnChange(fn: (value: any) => any): void;
 296 |     static ɵfac: i0.ɵɵFactoryDeclaration<SelectControlValueAccessor, never>;
 297 |     static ɵdir: i0.ɵɵDirectiveDeclaration<SelectControlValueAccessor, "select:not([multiple])[formControlName],select:not([multiple])[formControl],select:not([multiple])[ngModel]", never, { "compareWith": { "alias": "compareWith"; "required": false; }; }, {}, never, never, false, never>;
 298 | }
 299 | /**
 300 |  * @description
 301 |  * Marks `<option>` as dynamic, so Angular can be notified when options change.
 302 |  *
 303 |  * @see {@link SelectControlValueAccessor}
 304 |  *
 305 |  * @ngModule ReactiveFormsModule
 306 |  * @ngModule FormsModule
 307 |  * @publicApi
 308 |  */
 309 | declare class NgSelectOption implements OnDestroy {
 310 |     private _element;
 311 |     private _renderer;
 312 |     private _select;
 313 |     /**
 314 |      * @description
 315 |      * ID of the option element
 316 |      */
 317 |     id: string;
 318 |     constructor(_element: ElementRef, _renderer: Renderer2, _select: SelectControlValueAccessor);
 319 |     /**
 320 |      * @description
 321 |      * Tracks the value bound to the option element. Unlike the value binding,
 322 |      * ngValue supports binding to objects.
 323 |      */
 324 |     set ngValue(value: any);
 325 |     /**
 326 |      * @description
 327 |      * Tracks simple string values bound to the option element.
 328 |      * For objects, use the `ngValue` input binding.
 329 |      */
 330 |     set value(value: any);
 331 |     /** @docs-private */
 332 |     ngOnDestroy(): void;
 333 |     static ɵfac: i0.ɵɵFactoryDeclaration<NgSelectOption, [null, null, { optional: true; host: true; }]>;
 334 |     static ɵdir: i0.ɵɵDirectiveDeclaration<NgSelectOption, "option", never, { "ngValue": { "alias": "ngValue"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, never, false, never>;
 335 | }
 336 | 
 337 | /**
 338 |  * @description
 339 |  * The `ControlValueAccessor` for writing multi-select control values and listening to multi-select
 340 |  * control changes. The value accessor is used by the `FormControlDirective`, `FormControlName`, and
 341 |  * `NgModel` directives.
 342 |  *
 343 |  * @see {@link SelectControlValueAccessor}
 344 |  *
 345 |  * @usageNotes
 346 |  *
 347 |  * ### Using a multi-select control
 348 |  *
 349 |  * The follow example shows you how to use a multi-select control with a reactive form.
 350 |  *
 351 |  * ```ts
 352 |  * const countryControl = new FormControl();
 353 |  * ```
 354 |  *
 355 |  * ```html
 356 |  * <select multiple name="countries" [formControl]="countryControl">
 357 |  *   @for(country of countries; track $index) {
 358 |  *      <option [ngValue]="country">{{ country.name }}</option>
 359 |  *   }
 360 |  * </select>
 361 |  * ```
 362 |  *
 363 |  * ### Customizing option selection
 364 |  *
 365 |  * To customize the default option comparison algorithm, `<select>` supports `compareWith` input.
 366 |  * See the `SelectControlValueAccessor` for usage.
 367 |  *
 368 |  * @ngModule ReactiveFormsModule
 369 |  * @ngModule FormsModule
 370 |  * @publicApi
 371 |  */
 372 | declare class SelectMultipleControlValueAccessor extends BuiltInControlValueAccessor implements ControlValueAccessor {
 373 |     /**
 374 |      * The current value.
 375 |      * @docs-private
 376 |      */
 377 |     value: any;
 378 |     /**
 379 |      * @description
 380 |      * Tracks the option comparison algorithm for tracking identities when
 381 |      * checking for changes.
 382 |      */
 383 |     set compareWith(fn: (o1: any, o2: any) => boolean);
 384 |     private _compareWith;
 385 |     /**
 386 |      * Sets the "value" property on one or of more of the select's options.
 387 |      * @docs-private
 388 |      */
 389 |     writeValue(value: any): void;
 390 |     /**
 391 |      * Registers a function called when the control value changes
 392 |      * and writes an array of the selected options.
 393 |      * @docs-private
 394 |      */
 395 |     registerOnChange(fn: (value: any) => any): void;
 396 |     static ɵfac: i0.ɵɵFactoryDeclaration<SelectMultipleControlValueAccessor, never>;
 397 |     static ɵdir: i0.ɵɵDirectiveDeclaration<SelectMultipleControlValueAccessor, "select[multiple][formControlName],select[multiple][formControl],select[multiple][ngModel]", never, { "compareWith": { "alias": "compareWith"; "required": false; }; }, {}, never, never, false, never>;
 398 | }
 399 | /**
 400 |  * @description
 401 |  * Marks `<option>` as dynamic, so Angular can be notified when options change.
 402 |  *
 403 |  * @see {@link SelectMultipleControlValueAccessor}
 404 |  *
 405 |  * @ngModule ReactiveFormsModule
 406 |  * @ngModule FormsModule
 407 |  * @publicApi
 408 |  */
 409 | declare class ɵNgSelectMultipleOption implements OnDestroy {
 410 |     private _element;
 411 |     private _renderer;
 412 |     private _select;
 413 |     id: string;
 414 |     constructor(_element: ElementRef, _renderer: Renderer2, _select: SelectMultipleControlValueAccessor);
 415 |     /**
 416 |      * @description
 417 |      * Tracks the value bound to the option element. Unlike the value binding,
 418 |      * ngValue supports binding to objects.
 419 |      */
 420 |     set ngValue(value: any);
 421 |     /**
 422 |      * @description
 423 |      * Tracks simple string values bound to the option element.
 424 |      * For objects, use the `ngValue` input binding.
 425 |      */
 426 |     set value(value: any);
 427 |     /** @docs-private */
 428 |     ngOnDestroy(): void;
 429 |     static ɵfac: i0.ɵɵFactoryDeclaration<ɵNgSelectMultipleOption, [null, null, { optional: true; host: true; }]>;
 430 |     static ɵdir: i0.ɵɵDirectiveDeclaration<ɵNgSelectMultipleOption, "option", never, { "ngValue": { "alias": "ngValue"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, never, false, never>;
 431 | }
 432 | 
 433 | /**
 434 |  * @description
 435 |  * Provide this token to control if form directives buffer IME input until
 436 |  * the "compositionend" event occurs.
 437 |  * @publicApi
 438 |  */
 439 | declare const COMPOSITION_BUFFER_MODE: InjectionToken<boolean>;
 440 | /**
 441 |  * The default `ControlValueAccessor` for writing a value and listening to changes on input
 442 |  * elements. The accessor is used by the `FormControlDirective`, `FormControlName`, and
 443 |  * `NgModel` directives.
 444 |  *
 445 |  *
 446 |  * @usageNotes
 447 |  *
 448 |  * ### Using the default value accessor
 449 |  *
 450 |  * The following example shows how to use an input element that activates the default value accessor
 451 |  * (in this case, a text field).
 452 |  *
 453 |  * ```ts
 454 |  * const firstNameControl = new FormControl();
 455 |  * ```
 456 |  *
 457 |  * ```html
 458 |  * <input type="text" [formControl]="firstNameControl">
 459 |  * ```
 460 |  *
 461 |  * This value accessor is used by default for `<input type="text">` and `<textarea>` elements, but
 462 |  * you could also use it for custom components that have similar behavior and do not require special
 463 |  * processing. In order to attach the default value accessor to a custom element, add the
 464 |  * `ngDefaultControl` attribute as shown below.
 465 |  *
 466 |  * ```html
 467 |  * <custom-input-component ngDefaultControl [(ngModel)]="value"></custom-input-component>
 468 |  * ```
 469 |  *
 470 |  * @ngModule ReactiveFormsModule
 471 |  * @ngModule FormsModule
 472 |  * @publicApi
 473 |  */
 474 | declare class DefaultValueAccessor extends BaseControlValueAccessor implements ControlValueAccessor {
 475 |     private _compositionMode;
 476 |     /** Whether the user is creating a composition string (IME events). */
 477 |     private _composing;
 478 |     constructor(renderer: Renderer2, elementRef: ElementRef, _compositionMode: boolean);
 479 |     /**
 480 |      * Sets the "value" property on the input element.
 481 |      * @docs-private
 482 |      */
 483 |     writeValue(value: any): void;
 484 |     static ɵfac: i0.ɵɵFactoryDeclaration<DefaultValueAccessor, [null, null, { optional: true; }]>;
 485 |     static ɵdir: i0.ɵɵDirectiveDeclaration<DefaultValueAccessor, "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]", never, {}, {}, never, never, false, never>;
 486 | }
 487 | 
 488 | /**
 489 |  * @description
 490 |  * The `ControlValueAccessor` for writing a number value and listening to number input changes.
 491 |  * The value accessor is used by the `FormControlDirective`, `FormControlName`, and `NgModel`
 492 |  * directives.
 493 |  *
 494 |  * @usageNotes
 495 |  *
 496 |  * ### Using a number input with a reactive form.
 497 |  *
 498 |  * The following example shows how to use a number input with a reactive form.
 499 |  *
 500 |  * ```ts
 501 |  * const totalCountControl = new FormControl();
 502 |  * ```
 503 |  *
 504 |  * ```html
 505 |  * <input type="number" [formControl]="totalCountControl">
 506 |  * ```
 507 |  *
 508 |  * @ngModule ReactiveFormsModule
 509 |  * @ngModule FormsModule
 510 |  * @publicApi
 511 |  */
 512 | declare class NumberValueAccessor extends BuiltInControlValueAccessor implements ControlValueAccessor {
 513 |     /**
 514 |      * Sets the "value" property on the input element.
 515 |      * @docs-private
 516 |      */
 517 |     writeValue(value: number): void;
 518 |     /**
 519 |      * Registers a function called when the control value changes.
 520 |      * @docs-private
 521 |      */
 522 |     registerOnChange(fn: (_: number | null) => void): void;
 523 |     static ɵfac: i0.ɵɵFactoryDeclaration<NumberValueAccessor, never>;
 524 |     static ɵdir: i0.ɵɵDirectiveDeclaration<NumberValueAccessor, "input[type=number][formControlName],input[type=number][formControl],input[type=number][ngModel]", never, {}, {}, never, never, false, never>;
 525 | }
 526 | 
 527 | /**
 528 |  * @description
 529 |  * The `ControlValueAccessor` for writing a range value and listening to range input changes.
 530 |  * The value accessor is used by the `FormControlDirective`, `FormControlName`, and  `NgModel`
 531 |  * directives.
 532 |  *
 533 |  * @usageNotes
 534 |  *
 535 |  * ### Using a range input with a reactive form
 536 |  *
 537 |  * The following example shows how to use a range input with a reactive form.
 538 |  *
 539 |  * ```ts
 540 |  * const ageControl = new FormControl();
 541 |  * ```
 542 |  *
 543 |  * ```html
 544 |  * <input type="range" [formControl]="ageControl">
 545 |  * ```
 546 |  *
 547 |  * @ngModule ReactiveFormsModule
 548 |  * @ngModule FormsModule
 549 |  * @publicApi
 550 |  */
 551 | declare class RangeValueAccessor extends BuiltInControlValueAccessor implements ControlValueAccessor {
 552 |     /**
 553 |      * Sets the "value" property on the input element.
 554 |      * @docs-private
 555 |      */
 556 |     writeValue(value: any): void;
 557 |     /**
 558 |      * Registers a function called when the control value changes.
 559 |      * @docs-private
 560 |      */
 561 |     registerOnChange(fn: (_: number | null) => void): void;
 562 |     static ɵfac: i0.ɵɵFactoryDeclaration<RangeValueAccessor, never>;
 563 |     static ɵdir: i0.ɵɵDirectiveDeclaration<RangeValueAccessor, "input[type=range][formControlName],input[type=range][formControl],input[type=range][ngModel]", never, {}, {}, never, never, false, never>;
 564 | }
 565 | 
 566 | /**
 567 |  * @description
 568 |  * A `ControlValueAccessor` for writing a value and listening to changes on a checkbox input
 569 |  * element.
 570 |  *
 571 |  * @usageNotes
 572 |  *
 573 |  * ### Using a checkbox with a reactive form.
 574 |  *
 575 |  * The following example shows how to use a checkbox with a reactive form.
 576 |  *
 577 |  * ```ts
 578 |  * const rememberLoginControl = new FormControl();
 579 |  * ```
 580 |  *
 581 |  * ```html
 582 |  * <input type="checkbox" [formControl]="rememberLoginControl">
 583 |  * ```
 584 |  *
 585 |  * @ngModule ReactiveFormsModule
 586 |  * @ngModule FormsModule
 587 |  * @publicApi
 588 |  */
 589 | declare class CheckboxControlValueAccessor extends BuiltInControlValueAccessor implements ControlValueAccessor {
 590 |     /**
 591 |      * Sets the "checked" property on the input element.
 592 |      * @docs-private
 593 |      */
 594 |     writeValue(value: any): void;
 595 |     static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxControlValueAccessor, never>;
 596 |     static ɵdir: i0.ɵɵDirectiveDeclaration<CheckboxControlValueAccessor, "input[type=checkbox][formControlName],input[type=checkbox][formControl],input[type=checkbox][ngModel]", never, {}, {}, never, never, false, never>;
 597 | }
 598 | 
 599 | /**
 600 |  * @description
 601 |  * Defines the map of errors returned from failed validation checks.
 602 |  *
 603 |  * @publicApi
 604 |  */
 605 | type ValidationErrors = {
 606 |     [key: string]: any;
 607 | };
 608 | /**
 609 |  * @description
 610 |  * An interface implemented by classes that perform synchronous validation.
 611 |  *
 612 |  * @usageNotes
 613 |  *
 614 |  * ### Provide a custom validator
 615 |  *
 616 |  * The following example implements the `Validator` interface to create a
 617 |  * validator directive with a custom error key.
 618 |  *
 619 |  * ```ts
 620 |  * @Directive({
 621 |  *   selector: '[customValidator]',
 622 |  *   providers: [{provide: NG_VALIDATORS, useExisting: CustomValidatorDirective, multi: true}]
 623 |  * })
 624 |  * class CustomValidatorDirective implements Validator {
 625 |  *   validate(control: AbstractControl): ValidationErrors|null {
 626 |  *     return {'custom': true};
 627 |  *   }
 628 |  * }
 629 |  * ```
 630 |  *
 631 |  * @publicApi
 632 |  */
 633 | interface Validator {
 634 |     /**
 635 |      * @description
 636 |      * Method that performs synchronous validation against the provided control.
 637 |      *
 638 |      * @param control The control to validate against.
 639 |      *
 640 |      * @returns A map of validation errors if validation fails,
 641 |      * otherwise null.
 642 |      */
 643 |     validate(control: AbstractControl): ValidationErrors | null;
 644 |     /**
 645 |      * @description
 646 |      * Registers a callback function to call when the validator inputs change.
 647 |      *
 648 |      * @param fn The callback function
 649 |      */
 650 |     registerOnValidatorChange?(fn: () => void): void;
 651 | }
 652 | /**
 653 |  * A base class for Validator-based Directives. The class contains common logic shared across such
 654 |  * Directives.
 655 |  *
 656 |  * For internal use only, this class is not intended for use outside of the Forms package.
 657 |  */
 658 | declare abstract class AbstractValidatorDirective implements Validator, OnChanges {
 659 |     private _validator;
 660 |     private _onChange;
 661 |     /** @docs-private */
 662 |     ngOnChanges(changes: SimpleChanges): void;
 663 |     /** @docs-private */
 664 |     validate(control: AbstractControl): ValidationErrors | null;
 665 |     /** @docs-private */
 666 |     registerOnValidatorChange(fn: () => void): void;
 667 |     /**
 668 |      * @description
 669 |      * Determines whether this validator should be active or not based on an input.
 670 |      * Base class implementation checks whether an input is defined (if the value is different from
 671 |      * `null` and `undefined`). Validator classes that extend this base class can override this
 672 |      * function with the logic specific to a particular validator directive.
 673 |      */
 674 |     enabled(input: unknown): boolean;
 675 |     static ɵfac: i0.ɵɵFactoryDeclaration<AbstractValidatorDirective, never>;
 676 |     static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractValidatorDirective, never, never, {}, {}, never, never, true, never>;
 677 | }
 678 | /**
 679 |  * A directive which installs the {@link MaxValidator} for any `formControlName`,
 680 |  * `formControl`, or control with `ngModel` that also has a `max` attribute.
 681 |  *
 682 |  * @see [Form Validation](guide/forms/form-validation)
 683 |  *
 684 |  * @usageNotes
 685 |  *
 686 |  * ### Adding a max validator
 687 |  *
 688 |  * The following example shows how to add a max validator to an input attached to an
 689 |  * ngModel binding.
 690 |  *
 691 |  * ```html
 692 |  * <input type="number" ngModel max="4">
 693 |  * ```
 694 |  *
 695 |  * @ngModule ReactiveFormsModule
 696 |  * @ngModule FormsModule
 697 |  * @publicApi
 698 |  */
 699 | declare class MaxValidator extends AbstractValidatorDirective {
 700 |     /**
 701 |      * @description
 702 |      * Tracks changes to the max bound to this directive.
 703 |      */
 704 |     max: string | number | null;
 705 |     static ɵfac: i0.ɵɵFactoryDeclaration<MaxValidator, never>;
 706 |     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>;
 707 | }
 708 | /**
 709 |  * A directive which installs the {@link MinValidator} for any `formControlName`,
 710 |  * `formControl`, or control with `ngModel` that also has a `min` attribute.
 711 |  *
 712 |  * @see [Form Validation](guide/forms/form-validation)
 713 |  *
 714 |  * @usageNotes
 715 |  *
 716 |  * ### Adding a min validator
 717 |  *
 718 |  * The following example shows how to add a min validator to an input attached to an
 719 |  * ngModel binding.
 720 |  *
 721 |  * ```html
 722 |  * <input type="number" ngModel min="4">
 723 |  * ```
 724 |  *
 725 |  * @ngModule ReactiveFormsModule
 726 |  * @ngModule FormsModule
 727 |  * @publicApi
 728 |  */
 729 | declare class MinValidator extends AbstractValidatorDirective {
 730 |     /**
 731 |      * @description
 732 |      * Tracks changes to the min bound to this directive.
 733 |      */
 734 |     min: string | number | null;
 735 |     static ɵfac: i0.ɵɵFactoryDeclaration<MinValidator, never>;
 736 |     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>;
 737 | }
 738 | /**
 739 |  * @description
 740 |  * An interface implemented by classes that perform asynchronous validation.
 741 |  *
 742 |  * @usageNotes
 743 |  *
 744 |  * ### Provide a custom async validator directive
 745 |  *
 746 |  * The following example implements the `AsyncValidator` interface to create an
 747 |  * async validator directive with a custom error key.
 748 |  *
 749 |  * ```ts
 750 |  * import { of } from 'rxjs';
 751 |  *
 752 |  * @Directive({
 753 |  *   selector: '[customAsyncValidator]',
 754 |  *   providers: [{provide: NG_ASYNC_VALIDATORS, useExisting: CustomAsyncValidatorDirective, multi:
 755 |  * true}]
 756 |  * })
 757 |  * class CustomAsyncValidatorDirective implements AsyncValidator {
 758 |  *   validate(control: AbstractControl): Observable<ValidationErrors|null> {
 759 |  *     return of({'custom': true});
 760 |  *   }
 761 |  * }
 762 |  * ```
 763 |  *
 764 |  * @publicApi
 765 |  */
 766 | interface AsyncValidator extends Validator {
 767 |     /**
 768 |      * @description
 769 |      * Method that performs async validation against the provided control.
 770 |      *
 771 |      * @param control The control to validate against.
 772 |      *
 773 |      * @returns A promise or observable that resolves a map of validation errors
 774 |      * if validation fails, otherwise null.
 775 |      */
 776 |     validate(control: AbstractControl): Promise<ValidationErrors | null> | Observable<ValidationErrors | null>;
 777 | }
 778 | /**
 779 |  * @description
 780 |  * A directive that adds the `required` validator to any controls marked with the
 781 |  * `required` attribute. The directive is provided with the `NG_VALIDATORS` multi-provider list.
 782 |  *
 783 |  * @see [Form Validation](guide/forms/form-validation)
 784 |  *
 785 |  * @usageNotes
 786 |  *
 787 |  * ### Adding a required validator using template-driven forms
 788 |  *
 789 |  * ```html
 790 |  * <input name="fullName" ngModel required>
 791 |  * ```
 792 |  *
 793 |  * @ngModule FormsModule
 794 |  * @ngModule ReactiveFormsModule
 795 |  * @publicApi
 796 |  */
 797 | declare class RequiredValidator extends AbstractValidatorDirective {
 798 |     /**
 799 |      * @description
 800 |      * Tracks changes to the required attribute bound to this directive.
 801 |      */
 802 |     required: boolean | string;
 803 |     /** @docs-private */
 804 |     enabled(input: boolean): boolean;
 805 |     static ɵfac: i0.ɵɵFactoryDeclaration<RequiredValidator, never>;
 806 |     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>;
 807 | }
 808 | /**
 809 |  * A Directive that adds the `required` validator to checkbox controls marked with the
 810 |  * `required` attribute. The directive is provided with the `NG_VALIDATORS` multi-provider list.
 811 |  *
 812 |  * @see [Form Validation](guide/forms/form-validation)
 813 |  *
 814 |  * @usageNotes
 815 |  *
 816 |  * ### Adding a required checkbox validator using template-driven forms
 817 |  *
 818 |  * The following example shows how to add a checkbox required validator to an input attached to an
 819 |  * ngModel binding.
 820 |  *
 821 |  * ```html
 822 |  * <input type="checkbox" name="active" ngModel required>
 823 |  * ```
 824 |  *
 825 |  * @publicApi
 826 |  * @ngModule FormsModule
 827 |  * @ngModule ReactiveFormsModule
 828 |  */
 829 | declare class CheckboxRequiredValidator extends RequiredValidator {
 830 |     static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxRequiredValidator, never>;
 831 |     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>;
 832 | }
 833 | /**
 834 |  * A directive that adds the `email` validator to controls marked with the
 835 |  * `email` attribute. The directive is provided with the `NG_VALIDATORS` multi-provider list.
 836 |  *
 837 |  * The email validation is based on the WHATWG HTML specification with some enhancements to
 838 |  * incorporate more RFC rules. More information can be found on the [Validators.email
 839 |  * page](api/forms/Validators#email).
 840 |  *
 841 |  * @see [Form Validation](guide/forms/form-validation)
 842 |  *
 843 |  * @usageNotes
 844 |  *
 845 |  * ### Adding an email validator
 846 |  *
 847 |  * The following example shows how to add an email validator to an input attached to an ngModel
 848 |  * binding.
 849 |  *
 850 |  * ```html
 851 |  * <input type="email" name="email" ngModel email>
 852 |  * <input type="email" name="email" ngModel email="true">
 853 |  * <input type="email" name="email" ngModel [email]="true">
 854 |  * ```
 855 |  *
 856 |  * @publicApi
 857 |  * @ngModule FormsModule
 858 |  * @ngModule ReactiveFormsModule
 859 |  */
 860 | declare class EmailValidator extends AbstractValidatorDirective {
 861 |     /**
 862 |      * @description
 863 |      * Tracks changes to the email attribute bound to this directive.
 864 |      */
 865 |     email: boolean | string;
 866 |     /** @docs-private */
 867 |     enabled(input: boolean): boolean;
 868 |     static ɵfac: i0.ɵɵFactoryDeclaration<EmailValidator, never>;
 869 |     static ɵdir: i0.ɵɵDirectiveDeclaration<EmailValidator, "[email][formControlName],[email][formControl],[email][ngModel]", never, { "email": { "alias": "email"; "required": false; }; }, {}, never, never, false, never>;
 870 | }
 871 | /**
 872 |  * @description
 873 |  * A function that receives a control and synchronously returns a map of
 874 |  * validation errors if present, otherwise null.
 875 |  *
 876 |  * @publicApi
 877 |  */
 878 | interface ValidatorFn {
 879 |     (control: AbstractControl): ValidationErrors | null;
 880 | }
 881 | /**
 882 |  * @description
 883 |  * A function that receives a control and returns a Promise or observable
 884 |  * that emits validation errors if present, otherwise null.
 885 |  *
 886 |  * @publicApi
 887 |  */
 888 | interface AsyncValidatorFn {
 889 |     (control: AbstractControl): Promise<ValidationErrors | null> | Observable<ValidationErrors | null>;
 890 | }
 891 | /**
 892 |  * A directive that adds minimum length validation to controls marked with the
 893 |  * `minlength` attribute. The directive is provided with the `NG_VALIDATORS` multi-provider list.
 894 |  *
 895 |  * @see [Form Validation](guide/forms/form-validation)
 896 |  *
 897 |  * @usageNotes
 898 |  *
 899 |  * ### Adding a minimum length validator
 900 |  *
 901 |  * The following example shows how to add a minimum length validator to an input attached to an
 902 |  * ngModel binding.
 903 |  *
 904 |  * ```html
 905 |  * <input name="firstName" ngModel minlength="4">
 906 |  * ```
 907 |  *
 908 |  * @ngModule ReactiveFormsModule
 909 |  * @ngModule FormsModule
 910 |  * @publicApi
 911 |  */
 912 | declare class MinLengthValidator extends AbstractValidatorDirective {
 913 |     /**
 914 |      * @description
 915 |      * Tracks changes to the minimum length bound to this directive.
 916 |      */
 917 |     minlength: string | number | null;
 918 |     static ɵfac: i0.ɵɵFactoryDeclaration<MinLengthValidator, never>;
 919 |     static ɵdir: i0.ɵɵDirectiveDeclaration<MinLengthValidator, "[minlength][formControlName],[minlength][formControl],[minlength][ngModel]", never, { "minlength": { "alias": "minlength"; "required": false; }; }, {}, never, never, false, never>;
 920 | }
 921 | /**
 922 |  * A directive that adds maximum length validation to controls marked with the
 923 |  * `maxlength` attribute. The directive is provided with the `NG_VALIDATORS` multi-provider list.
 924 |  *
 925 |  * @see [Form Validation](guide/forms/form-validation)
 926 |  *
 927 |  * @usageNotes
 928 |  *
 929 |  * ### Adding a maximum length validator
 930 |  *
 931 |  * The following example shows how to add a maximum length validator to an input attached to an
 932 |  * ngModel binding.
 933 |  *
 934 |  * ```html
 935 |  * <input name="firstName" ngModel maxlength="25">
 936 |  * ```
 937 |  *
 938 |  * @ngModule ReactiveFormsModule
 939 |  * @ngModule FormsModule
 940 |  * @publicApi
 941 |  */
 942 | declare class MaxLengthValidator extends AbstractValidatorDirective {
 943 |     /**
 944 |      * @description
 945 |      * Tracks changes to the maximum length bound to this directive.
 946 |      */
 947 |     maxlength: string | number | null;
 948 |     static ɵfac: i0.ɵɵFactoryDeclaration<MaxLengthValidator, never>;
 949 |     static ɵdir: i0.ɵɵDirectiveDeclaration<MaxLengthValidator, "[maxlength][formControlName],[maxlength][formControl],[maxlength][ngModel]", never, { "maxlength": { "alias": "maxlength"; "required": false; }; }, {}, never, never, false, never>;
 950 | }
 951 | /**
 952 |  * @description
 953 |  * A directive that adds regex pattern validation to controls marked with the
 954 |  * `pattern` attribute. The regex must match the entire control value.
 955 |  * The directive is provided with the `NG_VALIDATORS` multi-provider list.
 956 |  *
 957 |  * @see [Form Validation](guide/forms/form-validation)
 958 |  *
 959 |  * @usageNotes
 960 |  *
 961 |  * ### Adding a pattern validator
 962 |  *
 963 |  * The following example shows how to add a pattern validator to an input attached to an
 964 |  * ngModel binding.
 965 |  *
 966 |  * ```html
 967 |  * <input name="firstName" ngModel pattern="[a-zA-Z ]*">
 968 |  * ```
 969 |  *
 970 |  * @ngModule ReactiveFormsModule
 971 |  * @ngModule FormsModule
 972 |  * @publicApi
 973 |  */
 974 | declare class PatternValidator extends AbstractValidatorDirective {
 975 |     /**
 976 |      * @description
 977 |      * Tracks changes to the pattern bound to this directive.
 978 |      */
 979 |     pattern: string | RegExp;
 980 |     static ɵfac: i0.ɵɵFactoryDeclaration<PatternValidator, never>;
 981 |     static ɵdir: i0.ɵɵDirectiveDeclaration<PatternValidator, "[pattern][formControlName],[pattern][formControl],[pattern][ngModel]", never, { "pattern": { "alias": "pattern"; "required": false; }; }, {}, never, never, false, never>;
 982 | }
 983 | 
 984 | /**
 985 |  * FormArrayValue extracts the type of `.value` from a FormArray's element type, and wraps it in an
 986 |  * array.
 987 |  *
 988 |  * Angular uses this type internally to support Typed Forms; do not use it directly. The untyped
 989 |  * case falls back to any[].
 990 |  */
 991 | type ɵFormArrayValue<T extends AbstractControl<any>> = ɵTypedOrUntyped<T, Array<ɵValue<T>>, any[]>;
 992 | /**
 993 |  * FormArrayRawValue extracts the type of `.getRawValue()` from a FormArray's element type, and
 994 |  * wraps it in an array. The untyped case falls back to any[].
 995 |  *
 996 |  * Angular uses this type internally to support Typed Forms; do not use it directly.
 997 |  */
 998 | type ɵFormArrayRawValue<T extends AbstractControl<any>> = ɵTypedOrUntyped<T, Array<ɵRawValue<T>>, any[]>;
 999 | /**
1000 |  * Tracks the value and validity state of an array of `FormControl`,
1001 |  * `FormGroup` or `FormArray` instances.
1002 |  *
1003 |  * A `FormArray` aggregates the values of each child `FormControl` into an array.
1004 |  * It calculates its status by reducing the status values of its children. For example, if one of
1005 |  * the controls in a `FormArray` is invalid, the entire array becomes invalid.
1006 |  *
1007 |  * `FormArray` accepts one generic argument, which is the type of the controls inside.
1008 |  * If you need a heterogenous array, use {@link UntypedFormArray}.
1009 |  *
1010 |  * `FormArray` is one of the four fundamental building blocks used to define forms in Angular,
1011 |  * along with `FormControl`, `FormGroup`, and `FormRecord`.
1012 |  *
1013 |  * @usageNotes
1014 |  *
1015 |  * ### Create an array of form controls
1016 |  *
1017 |  * ```ts
1018 |  * const arr = new FormArray([
1019 |  *   new FormControl('Nancy', Validators.minLength(2)),
1020 |  *   new FormControl('Drew'),
1021 |  * ]);
1022 |  *
1023 |  * console.log(arr.value);   // ['Nancy', 'Drew']
1024 |  * console.log(arr.status);  // 'VALID'
1025 |  * ```
1026 |  *
1027 |  * ### Create a form array with array-level validators
1028 |  *
1029 |  * You include array-level validators and async validators. These come in handy
1030 |  * when you want to perform validation that considers the value of more than one child
1031 |  * control.
1032 |  *
1033 |  * The two types of validators are passed in separately as the second and third arg
1034 |  * respectively, or together as part of an options object.
1035 |  *
1036 |  * ```ts
1037 |  * const arr = new FormArray([
1038 |  *   new FormControl('Nancy'),
1039 |  *   new FormControl('Drew')
1040 |  * ], {validators: myValidator, asyncValidators: myAsyncValidator});
1041 |  * ```
1042 |  *
1043 |  * ### Set the updateOn property for all controls in a form array
1044 |  *
1045 |  * The options object is used to set a default value for each child
1046 |  * control's `updateOn` property. If you set `updateOn` to `'blur'` at the
1047 |  * array level, all child controls default to 'blur', unless the child
1048 |  * has explicitly specified a different `updateOn` value.
1049 |  *
1050 |  * ```ts
1051 |  * const arr = new FormArray([
1052 |  *    new FormControl()
1053 |  * ], {updateOn: 'blur'});
1054 |  * ```
1055 |  *
1056 |  * ### Adding or removing controls from a form array
1057 |  *
1058 |  * To change the controls in the array, use the `push`, `insert`, `removeAt` or `clear` methods
1059 |  * in `FormArray` itself. These methods ensure the controls are properly tracked in the
1060 |  * form's hierarchy. Do not modify the array of `AbstractControl`s used to instantiate
1061 |  * the `FormArray` directly, as that result in strange and unexpected behavior such
1062 |  * as broken change detection.
1063 |  *
1064 |  * @publicApi
1065 |  */
1066 | declare class FormArray<TControl extends AbstractControl<any> = any> extends AbstractControl<ɵTypedOrUntyped<TControl, ɵFormArrayValue<TControl>, any>, ɵTypedOrUntyped<TControl, ɵFormArrayRawValue<TControl>, any>> {
1067 |     /**
1068 |      * Creates a new `FormArray` instance.
1069 |      *
1070 |      * @param controls An array of child controls. Each child control is given an index
1071 |      * where it is registered.
1072 |      *
1073 |      * @param validatorOrOpts A synchronous validator function, or an array of
1074 |      * such functions, or an `AbstractControlOptions` object that contains validation functions
1075 |      * and a validation trigger.
1076 |      *
1077 |      * @param asyncValidator A single async validator or array of async validator functions
1078 |      *
1079 |      */
1080 |     constructor(controls: Array<TControl>, validatorOrOpts?: ValidatorFn | ValidatorFn[] | AbstractControlOptions | null, asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null);
1081 |     controls: ɵTypedOrUntyped<TControl, Array<TControl>, Array<AbstractControl<any>>>;
1082 |     /**
1083 |      * Get the `AbstractControl` at the given `index` in the array.
1084 |      *
1085 |      * @param index Index in the array to retrieve the control. If `index` is negative, it will wrap
1086 |      *     around from the back, and if index is greatly negative (less than `-length`), the result is
1087 |      * undefined. This behavior is the same as `Array.at(index)`.
1088 |      */
1089 |     at(index: number): ɵTypedOrUntyped<TControl, TControl, AbstractControl<any>>;
1090 |     /**
1091 |      * Insert a new `AbstractControl` at the end of the array.
1092 |      *
1093 |      * @param control Form control to be inserted
1094 |      * @param options Specifies whether this FormArray instance should emit events after a new
1095 |      *     control is added.
1096 |      * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
1097 |      * `valueChanges` observables emit events with the latest status and value when the control is
1098 |      * inserted. When false, no events are emitted.
1099 |      */
1100 |     push(control: TControl, options?: {
1101 |         emitEvent?: boolean;
1102 |     }): void;
1103 |     /**
1104 |      * Insert a new `AbstractControl` at the given `index` in the array.
1105 |      *
1106 |      * @param index Index in the array to insert the control. If `index` is negative, wraps around
1107 |      *     from the back. If `index` is greatly negative (less than `-length`), prepends to the array.
1108 |      * This behavior is the same as `Array.splice(index, 0, control)`.
1109 |      * @param control Form control to be inserted
1110 |      * @param options Specifies whether this FormArray instance should emit events after a new
1111 |      *     control is inserted.
1112 |      * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
1113 |      * `valueChanges` observables emit events with the latest status and value when the control is
1114 |      * inserted. When false, no events are emitted.
1115 |      */
1116 |     insert(index: number, control: TControl, options?: {
1117 |         emitEvent?: boolean;
1118 |     }): void;
1119 |     /**
1120 |      * Remove the control at the given `index` in the array.
1121 |      *
1122 |      * @param index Index in the array to remove the control.  If `index` is negative, wraps around
1123 |      *     from the back. If `index` is greatly negative (less than `-length`), removes the first
1124 |      *     element. This behavior is the same as `Array.splice(index, 1)`.
1125 |      * @param options Specifies whether this FormArray instance should emit events after a
1126 |      *     control is removed.
1127 |      * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
1128 |      * `valueChanges` observables emit events with the latest status and value when the control is
1129 |      * removed. When false, no events are emitted.
1130 |      */
1131 |     removeAt(index: number, options?: {
1132 |         emitEvent?: boolean;
1133 |     }): void;
1134 |     /**
1135 |      * Replace an existing control.
1136 |      *
1137 |      * @param index Index in the array to replace the control. If `index` is negative, wraps around
1138 |      *     from the back. If `index` is greatly negative (less than `-length`), replaces the first
1139 |      *     element. This behavior is the same as `Array.splice(index, 1, control)`.
1140 |      * @param control The `AbstractControl` control to replace the existing control
1141 |      * @param options Specifies whether this FormArray instance should emit events after an
1142 |      *     existing control is replaced with a new one.
1143 |      * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
1144 |      * `valueChanges` observables emit events with the latest status and value when the control is
1145 |      * replaced with a new one. When false, no events are emitted.
1146 |      */
1147 |     setControl(index: number, control: TControl, options?: {
1148 |         emitEvent?: boolean;
1149 |     }): void;
1150 |     /**
1151 |      * Length of the control array.
1152 |      */
1153 |     get length(): number;
1154 |     /**
1155 |      * Sets the value of the `FormArray`. It accepts an array that matches
1156 |      * the structure of the control.
1157 |      *
1158 |      * This method performs strict checks, and throws an error if you try
1159 |      * to set the value of a control that doesn't exist or if you exclude the
1160 |      * value of a control.
1161 |      *
1162 |      * @usageNotes
1163 |      * ### Set the values for the controls in the form array
1164 |      *
1165 |      * ```ts
1166 |      * const arr = new FormArray([
1167 |      *   new FormControl(),
1168 |      *   new FormControl()
1169 |      * ]);
1170 |      * console.log(arr.value);   // [null, null]
1171 |      *
1172 |      * arr.setValue(['Nancy', 'Drew']);
1173 |      * console.log(arr.value);   // ['Nancy', 'Drew']
1174 |      * ```
1175 |      *
1176 |      * @param value Array of values for the controls
1177 |      * @param options Configure options that determine how the control propagates changes and
1178 |      * emits events after the value changes
1179 |      *
1180 |      * * `onlySelf`: When true, each change only affects this control, and not its parent. Default
1181 |      * is false.
1182 |      * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
1183 |      * `valueChanges`
1184 |      * observables emit events with the latest status and value when the control value is updated.
1185 |      * When false, no events are emitted.
1186 |      * The configuration options are passed to the {@link AbstractControl#updateValueAndValidity
1187 |      * updateValueAndValidity} method.
1188 |      */
1189 |     setValue(value: ɵFormArrayRawValue<TControl>, options?: {
1190 |         onlySelf?: boolean;
1191 |         emitEvent?: boolean;
1192 |     }): void;
1193 |     /**
1194 |      * Patches the value of the `FormArray`. It accepts an array that matches the
1195 |      * structure of the control, and does its best to match the values to the correct
1196 |      * controls in the group.
1197 |      *
1198 |      * It accepts both super-sets and sub-sets of the array without throwing an error.
1199 |      *
1200 |      * @usageNotes
1201 |      * ### Patch the values for controls in a form array
1202 |      *
1203 |      * ```ts
1204 |      * const arr = new FormArray([
1205 |      *    new FormControl(),
1206 |      *    new FormControl()
1207 |      * ]);
1208 |      * console.log(arr.value);   // [null, null]
1209 |      *
1210 |      * arr.patchValue(['Nancy']);
1211 |      * console.log(arr.value);   // ['Nancy', null]
1212 |      * ```
1213 |      *
1214 |      * @param value Array of latest values for the controls
1215 |      * @param options Configure options that determine how the control propagates changes and
1216 |      * emits events after the value changes
1217 |      *
1218 |      * * `onlySelf`: When true, each change only affects this control, and not its parent. Default
1219 |      * is false.
1220 |      * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
1221 |      * `valueChanges` observables emit events with the latest status and value when the control
1222 |      * value is updated. When false, no events are emitted. The configuration options are passed to
1223 |      * the {@link AbstractControl#updateValueAndValidity updateValueAndValidity} method.
1224 |      */
1225 |     patchValue(value: ɵFormArrayValue<TControl>, options?: {
1226 |         onlySelf?: boolean;
1227 |         emitEvent?: boolean;
1228 |     }): void;
1229 |     /**
1230 |      * Resets the `FormArray` and all descendants are marked `pristine` and `untouched`, and the
1231 |      * value of all descendants to null or null maps.
1232 |      *
1233 |      * You reset to a specific form state by passing in an array of states
1234 |      * that matches the structure of the control. The state is a standalone value
1235 |      * or a form state object with both a value and a disabled status.
1236 |      *
1237 |      * @usageNotes
1238 |      * ### Reset the values in a form array
1239 |      *
1240 |      * ```ts
1241 |      * const arr = new FormArray([
1242 |      *    new FormControl(),
1243 |      *    new FormControl()
1244 |      * ]);
1245 |      * arr.reset(['name', 'last name']);
1246 |      *
1247 |      * console.log(arr.value);  // ['name', 'last name']
1248 |      * ```
1249 |      *
1250 |      * ### Reset the values in a form array and the disabled status for the first control
1251 |      *
1252 |      * ```ts
1253 |      * arr.reset([
1254 |      *   {value: 'name', disabled: true},
1255 |      *   'last'
1256 |      * ]);
1257 |      *
1258 |      * console.log(arr.value);  // ['last']
1259 |      * console.log(arr.at(0).status);  // 'DISABLED'
1260 |      * ```
1261 |      *
1262 |      * @param value Array of values for the controls
1263 |      * @param options Configure options that determine how the control propagates changes and
1264 |      * emits events after the value changes
1265 |      *
1266 |      * * `onlySelf`: When true, each change only affects this control, and not its parent. Default
1267 |      * is false.
1268 |      * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
1269 |      * `valueChanges`
1270 |      * observables emit events with the latest status and value when the control is reset.
1271 |      * When false, no events are emitted.
1272 |      * The configuration options are passed to the {@link AbstractControl#updateValueAndValidity
1273 |      * updateValueAndValidity} method.
1274 |      */
1275 |     reset(value?: ɵTypedOrUntyped<TControl, ɵFormArrayValue<TControl>, any>, options?: {
1276 |         onlySelf?: boolean;
1277 |         emitEvent?: boolean;
1278 |     }): void;
1279 |     /**
1280 |      * The aggregate value of the array, including any disabled controls.
1281 |      *
1282 |      * Reports all values regardless of disabled status.
1283 |      */
1284 |     getRawValue(): ɵFormArrayRawValue<TControl>;
1285 |     /**
1286 |      * Remove all controls in the `FormArray`.
1287 |      *
1288 |      * @param options Specifies whether this FormArray instance should emit events after all
1289 |      *     controls are removed.
1290 |      * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
1291 |      * `valueChanges` observables emit events with the latest status and value when all controls
1292 |      * in this FormArray instance are removed. When false, no events are emitted.
1293 |      *
1294 |      * @usageNotes
1295 |      * ### Remove all elements from a FormArray
1296 |      *
1297 |      * ```ts
1298 |      * const arr = new FormArray([
1299 |      *    new FormControl(),
1300 |      *    new FormControl()
1301 |      * ]);
1302 |      * console.log(arr.length);  // 2
1303 |      *
1304 |      * arr.clear();
1305 |      * console.log(arr.length);  // 0
1306 |      * ```
1307 |      *
1308 |      * It's a simpler and more efficient alternative to removing all elements one by one:
1309 |      *
1310 |      * ```ts
1311 |      * const arr = new FormArray([
1312 |      *    new FormControl(),
1313 |      *    new FormControl()
1314 |      * ]);
1315 |      *
1316 |      * while (arr.length) {
1317 |      *    arr.removeAt(0);
1318 |      * }
1319 |      * ```
1320 |      */
1321 |     clear(options?: {
1322 |         emitEvent?: boolean;
1323 |     }): void;
1324 |     private _registerControl;
1325 | }
1326 | interface UntypedFormArrayCtor {
1327 |     new (controls: AbstractControl[], validatorOrOpts?: ValidatorFn | ValidatorFn[] | AbstractControlOptions | null, asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null): UntypedFormArray;
1328 |     /**
1329 |      * The presence of an explicit `prototype` property provides backwards-compatibility for apps that
1330 |      * manually inspect the prototype chain.
1331 |      */
1332 |     prototype: FormArray<any>;
1333 | }
1334 | /**
1335 |  * UntypedFormArray is a non-strongly-typed version of `FormArray`, which
1336 |  * permits heterogenous controls.
1337 |  */
1338 | type UntypedFormArray = FormArray<any>;
1339 | declare const UntypedFormArray: UntypedFormArrayCtor;
1340 | /**
1341 |  * @description
1342 |  * Asserts that the given control is an instance of `FormArray`
1343 |  *
1344 |  * @publicApi
1345 |  */
1346 | declare const isFormArray: (control: unknown) => control is FormArray;
1347 | 
1348 | /**
1349 |  * FormControlState is a boxed form value. It is an object with a `value` key and a `disabled` key.
1350 |  *
1351 |  * @publicApi
1352 |  */
1353 | interface FormControlState<T> {
1354 |     value: T;
1355 |     disabled: boolean;
1356 | }
1357 | /**
1358 |  * Interface for options provided to a `FormControl`.
1359 |  *
1360 |  * This interface extends all options from {@link AbstractControlOptions}, plus some options
1361 |  * unique to `FormControl`.
1362 |  *
1363 |  * @publicApi
1364 |  */
1365 | interface FormControlOptions extends AbstractControlOptions {
1366 |     /**
1367 |      * @description
1368 |      * Whether to use the initial value used to construct the `FormControl` as its default value
1369 |      * as well. If this option is false or not provided, the default value of a FormControl is `null`.
1370 |      * When a FormControl is reset without an explicit value, its value reverts to
1371 |      * its default value.
1372 |      */
1373 |     nonNullable?: boolean;
1374 |     /**
1375 |      * @deprecated Use `nonNullable` instead.
1376 |      */
1377 |     initialValueIsDefault?: boolean;
1378 | }
1379 | /**
1380 |  * Various available constructors for `FormControl`.
1381 |  * Do not use this interface directly. Instead, use `FormControl`:
1382 |  * ```ts
1383 |  * const fc = new FormControl('foo');
1384 |  * ```
1385 |  * This symbol is prefixed with ɵ to make plain that it is an internal symbol.
1386 |  */
1387 | interface ɵFormControlCtor {
1388 |     /**
1389 |      * Construct a FormControl with no initial value or validators.
1390 |      */
1391 |     new (): FormControl<any>;
1392 |     /**
1393 |      * Creates a new `FormControl` instance.
1394 |      *
1395 |      * @param value Initializes the control with an initial value,
1396 |      * or an object that defines the initial value and disabled state.
1397 |      *
1398 |      * @param opts A `FormControlOptions` object that contains validation functions and a
1399 |      * validation trigger. `nonNullable` have to be `true`
1400 |      */
1401 |     new <T = any>(value: FormControlState<T> | T, opts: FormControlOptions & {
1402 |         nonNullable: true;
1403 |     }): FormControl<T>;
1404 |     /**
1405 |      * @deprecated Use `nonNullable` instead.
1406 |      */
1407 |     new <T = any>(value: FormControlState<T> | T, opts: FormControlOptions & {
1408 |         initialValueIsDefault: true;
1409 |     }): FormControl<T>;
1410 |     /**
1411 |      * @deprecated When passing an `options` argument, the `asyncValidator` argument has no effect.
1412 |      */
1413 |     new <T = any>(value: FormControlState<T> | T, opts: FormControlOptions, asyncValidator: AsyncValidatorFn | AsyncValidatorFn[]): FormControl<T | null>;
1414 |     /**
1415 |      * Creates a new `FormControl` instance.
1416 |      *
1417 |      * @param value Initializes the control with an initial value,
1418 |      * or an object that defines the initial value and disabled state.
1419 |      *
1420 |      * @param validatorOrOpts A synchronous validator function, or an array of
1421 |      * such functions, or a `FormControlOptions` object that contains validation functions
1422 |      * and a validation trigger.
1423 |      *
1424 |      * @param asyncValidator A single async validator or array of async validator functions
1425 |      */
1426 |     new <T = any>(value: FormControlState<T> | T, validatorOrOpts?: ValidatorFn | ValidatorFn[] | FormControlOptions | null, asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null): FormControl<T | null>;
1427 |     /**
1428 |      * The presence of an explicit `prototype` property provides backwards-compatibility for apps that
1429 |      * manually inspect the prototype chain.
1430 |      */
1431 |     prototype: FormControl<any>;
1432 | }
1433 | /**
1434 |  * Tracks the value and validation status of an individual form control.
1435 |  *
1436 |  * This is one of the four fundamental building blocks of Angular forms, along with
1437 |  * `FormGroup`, `FormArray` and `FormRecord`. It extends the `AbstractControl` class that
1438 |  * implements most of the base functionality for accessing the value, validation status,
1439 |  * user interactions and events.
1440 |  *
1441 |  * `FormControl` takes a single generic argument, which describes the type of its value. This
1442 |  * argument always implicitly includes `null` because the control can be reset. To change this
1443 |  * behavior, set `nonNullable` or see the usage notes below.
1444 |  *
1445 |  * See [usage examples below](#usage-notes).
1446 |  *
1447 |  * @see {@link AbstractControl}
1448 |  * @see [Reactive Forms Guide](guide/forms/reactive-forms)
1449 |  * @see [Usage Notes](#usage-notes)
1450 |  *
1451 |  * @publicApi
1452 |  *
1453 |  * @overriddenImplementation ɵFormControlCtor
1454 |  *
1455 |  * @usageNotes
1456 |  *
1457 |  * ### Initializing Form Controls
1458 |  *
1459 |  * Instantiate a `FormControl`, with an initial value.
1460 |  *
1461 |  * ```ts
1462 |  * const control = new FormControl('some value');
1463 |  * console.log(control.value);     // 'some value'
1464 |  * ```
1465 |  *
1466 |  * The following example initializes the control with a form state object. The `value`
1467 |  * and `disabled` keys are required in this case.
1468 |  *
1469 |  * ```ts
1470 |  * const control = new FormControl({ value: 'n/a', disabled: true });
1471 |  * console.log(control.value);     // 'n/a'
1472 |  * console.log(control.status);    // 'DISABLED'
1473 |  * ```
1474 |  *
1475 |  * The following example initializes the control with a synchronous validator.
1476 |  *
1477 |  * ```ts
1478 |  * const control = new FormControl('', Validators.required);
1479 |  * console.log(control.value);      // ''
1480 |  * console.log(control.status);     // 'INVALID'
1481 |  * ```
1482 |  *
1483 |  * The following example initializes the control using an options object.
1484 |  *
1485 |  * ```ts
1486 |  * const control = new FormControl('', {
1487 |  *    validators: Validators.required,
1488 |  *    asyncValidators: myAsyncValidator
1489 |  * });
1490 |  * ```
1491 |  *
1492 |  * ### The single type argument
1493 |  *
1494 |  * `FormControl` accepts a generic argument, which describes the type of its value.
1495 |  * In most cases, this argument will be inferred.
1496 |  *
1497 |  * If you are initializing the control to `null`, or you otherwise wish to provide a
1498 |  * wider type, you may specify the argument explicitly:
1499 |  *
1500 |  * ```ts
1501 |  * let fc = new FormControl<string|null>(null);
1502 |  * fc.setValue('foo');
1503 |  * ```
1504 |  *
1505 |  * You might notice that `null` is always added to the type of the control.
1506 |  * This is because the control will become `null` if you call `reset`. You can change
1507 |  * this behavior by setting `{nonNullable: true}`.
1508 |  *
1509 |  * ### Configure the control to update on a blur event
1510 |  *
1511 |  * Set the `updateOn` option to `'blur'` to update on the blur `event`.
1512 |  *
1513 |  * ```ts
1514 |  * const control = new FormControl('', { updateOn: 'blur' });
1515 |  * ```
1516 |  *
1517 |  * ### Configure the control to update on a submit event
1518 |  *
1519 |  * Set the `updateOn` option to `'submit'` to update on a submit `event`.
1520 |  *
1521 |  * ```ts
1522 |  * const control = new FormControl('', { updateOn: 'submit' });
1523 |  * ```
1524 |  *
1525 |  * ### Reset the control back to a specific value
1526 |  *
1527 |  * You reset to a specific form state by passing through a standalone
1528 |  * value or a form state object that contains both a value and a disabled state
1529 |  * (these are the only two properties that cannot be calculated).
1530 |  *
1531 |  * ```ts
1532 |  * const control = new FormControl('Nancy');
1533 |  *
1534 |  * console.log(control.value); // 'Nancy'
1535 |  *
1536 |  * control.reset('Drew');
1537 |  *
1538 |  * console.log(control.value); // 'Drew'
1539 |  * ```
1540 |  *
1541 |  * ### Reset the control to its initial value
1542 |  *
1543 |  * If you wish to always reset the control to its initial value (instead of null),
1544 |  * you can pass the `nonNullable` option:
1545 |  *
1546 |  * ```ts
1547 |  * const control = new FormControl('Nancy', {nonNullable: true});
1548 |  *
1549 |  * console.log(control.value); // 'Nancy'
1550 |  *
1551 |  * control.reset();
1552 |  *
1553 |  * console.log(control.value); // 'Nancy'
1554 |  * ```
1555 |  *
1556 |  * ### Reset the control back to an initial value and disabled
1557 |  *
1558 |  * ```ts
1559 |  * const control = new FormControl('Nancy');
1560 |  *
1561 |  * console.log(control.value); // 'Nancy'
1562 |  * console.log(control.status); // 'VALID'
1563 |  *
1564 |  * control.reset({ value: 'Drew', disabled: true });
1565 |  *
1566 |  * console.log(control.value); // 'Drew'
1567 |  * console.log(control.status); // 'DISABLED'
1568 |  * ```
1569 |  */
1570 | interface FormControl<TValue = any> extends AbstractControl<TValue> {
1571 |     /**
1572 |      * The default value of this FormControl, used whenever the control is reset without an explicit
1573 |      * value. See {@link FormControlOptions#nonNullable} for more information on configuring
1574 |      * a default value.
1575 |      */
1576 |     readonly defaultValue: TValue;
1577 |     /**
1578 |      * Sets a new value for the form control.
1579 |      *
1580 |      * @param value The new value for the control.
1581 |      * @param options Configuration options that determine how the control propagates changes
1582 |      * and emits events when the value changes.
1583 |      * The configuration options are passed to the {@link AbstractControl#updateValueAndValidity
1584 |      * updateValueAndValidity} method.
1585 |      *
1586 |      * * `onlySelf`: When true, each change only affects this control, and not its parent. Default is
1587 |      * false.
1588 |      * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
1589 |      * `valueChanges`
1590 |      * observables emit events with the latest status and value when the control value is updated.
1591 |      * When false, no events are emitted.
1592 |      * * `emitModelToViewChange`: When true or not supplied  (the default), each change triggers an
1593 |      * `onChange` event to
1594 |      * update the view.
1595 |      * * `emitViewToModelChange`: When true or not supplied (the default), each change triggers an
1596 |      * `ngModelChange`
1597 |      * event to update the model.
1598 |      *
1599 |      */
1600 |     setValue(value: TValue, options?: {
1601 |         onlySelf?: boolean;
1602 |         emitEvent?: boolean;
1603 |         emitModelToViewChange?: boolean;
1604 |         emitViewToModelChange?: boolean;
1605 |     }): void;
1606 |     /**
1607 |      * Patches the value of a control.
1608 |      *
1609 |      * This function is functionally the same as {@link FormControl#setValue setValue} at this level.
1610 |      * It exists for symmetry with {@link FormGroup#patchValue patchValue} on `FormGroups` and
1611 |      * `FormArrays`, where it does behave differently.
1612 |      *
1613 |      * @see {@link FormControl#setValue} for options
1614 |      */
1615 |     patchValue(value: TValue, options?: {
1616 |         onlySelf?: boolean;
1617 |         emitEvent?: boolean;
1618 |         emitModelToViewChange?: boolean;
1619 |         emitViewToModelChange?: boolean;
1620 |     }): void;
1621 |     /**
1622 |      * Resets the form control, marking it `pristine` and `untouched`, and resetting
1623 |      * the value. The new value will be the provided value (if passed), `null`, or the initial value
1624 |      * if `nonNullable` was set in the constructor via {@link FormControlOptions}.
1625 |      *
1626 |      * ```ts
1627 |      * // By default, the control will reset to null.
1628 |      * const dog = new FormControl('spot');
1629 |      * dog.reset(); // dog.value is null
1630 |      *
1631 |      * // If this flag is set, the control will instead reset to the initial value.
1632 |      * const cat = new FormControl('tabby', {nonNullable: true});
1633 |      * cat.reset(); // cat.value is "tabby"
1634 |      *
1635 |      * // A value passed to reset always takes precedence.
1636 |      * const fish = new FormControl('finn', {nonNullable: true});
1637 |      * fish.reset('bubble'); // fish.value is "bubble"
1638 |      * ```
1639 |      *
1640 |      * @param formState Resets the control with an initial value,
1641 |      * or an object that defines the initial value and disabled state.
1642 |      *
1643 |      * @param options Configuration options that determine how the control propagates changes
1644 |      * and emits events after the value changes.
1645 |      *
1646 |      * * `onlySelf`: When true, each change only affects this control, and not its parent. Default is
1647 |      * false.
1648 |      * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
1649 |      * `valueChanges`
1650 |      * observables emit events with the latest status and value when the control is reset.
1651 |      * When false, no events are emitted.
1652 |      *
1653 |      */
1654 |     reset(formState?: TValue | FormControlState<TValue>, options?: {
1655 |         onlySelf?: boolean;
1656 |         emitEvent?: boolean;
1657 |     }): void;
1658 |     /**
1659 |      * For a simple FormControl, the raw value is equivalent to the value.
1660 |      */
1661 |     getRawValue(): TValue;
1662 |     /**
1663 |      * Register a listener for change events.
1664 |      *
1665 |      * @param fn The method that is called when the value changes
1666 |      */
1667 |     registerOnChange(fn: Function): void;
1668 |     /**
1669 |      * Register a listener for disabled events.
1670 |      *
1671 |      * @param fn The method that is called when the disabled status changes.
1672 |      */
1673 |     registerOnDisabledChange(fn: (isDisabled: boolean) => void): void;
1674 | }
1675 | declare const FormControl: ɵFormControlCtor;
1676 | interface UntypedFormControlCtor {
1677 |     new (): UntypedFormControl;
1678 |     new (formState?: any, validatorOrOpts?: ValidatorFn | ValidatorFn[] | FormControlOptions | null, asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null): UntypedFormControl;
1679 |     /**
1680 |      * The presence of an explicit `prototype` property provides backwards-compatibility for apps that
1681 |      * manually inspect the prototype chain.
1682 |      */
1683 |     prototype: FormControl<any>;
1684 | }
1685 | /**
1686 |  * UntypedFormControl is a non-strongly-typed version of `FormControl`.
1687 |  */
1688 | type UntypedFormControl = FormControl<any>;
1689 | declare const UntypedFormControl: UntypedFormControlCtor;
1690 | /**
1691 |  * @description
1692 |  * Asserts that the given control is an instance of `FormControl`
1693 |  *
1694 |  * @publicApi
1695 |  */
1696 | declare const isFormControl: (control: unknown) => control is FormControl;
1697 | 
1698 | /**
1699 |  * FormGroupValue extracts the type of `.value` from a FormGroup's inner object type. The untyped
1700 |  * case falls back to {[key: string]: any}.
1701 |  *
1702 |  * Angular uses this type internally to support Typed Forms; do not use it directly.
1703 |  *
1704 |  * For internal use only.
1705 |  */
1706 | type ɵFormGroupArgumentValue<T extends {
1707 |     [K in keyof T]?: AbstractControl<any>;
1708 | }> = ɵTypedOrUntyped<T, Partial<{
1709 |     [K in keyof T]: ɵValue<T[K]> | FormControlState<ɵValue<T[K]>>;
1710 | }>, {
1711 |     [key: string]: any;
1712 | }>;
1713 | type ɵFormGroupValue<T extends {
1714 |     [K in keyof T]?: AbstractControl<any>;
1715 | }> = ɵTypedOrUntyped<T, Partial<{
1716 |     [K in keyof T]: ɵValue<T[K]>;
1717 | }>, {
1718 |     [key: string]: any;
1719 | }>;
1720 | /**
1721 |  * FormGroupRawValue extracts the type of `.getRawValue()` from a FormGroup's inner object type. The
1722 |  * untyped case falls back to {[key: string]: any}.
1723 |  *
1724 |  * Angular uses this type internally to support Typed Forms; do not use it directly.
1725 |  *
1726 |  * For internal use only.
1727 |  */
1728 | type ɵFormGroupRawValue<T extends {
1729 |     [K in keyof T]?: AbstractControl<any>;
1730 | }> = ɵTypedOrUntyped<T, {
1731 |     [K in keyof T]: ɵRawValue<T[K]>;
1732 | }, {
1733 |     [key: string]: any;
1734 | }>;
1735 | /**
1736 |  * OptionalKeys returns the union of all optional keys in the object.
1737 |  *
1738 |  * Angular uses this type internally to support Typed Forms; do not use it directly.
1739 |  */
1740 | type ɵOptionalKeys<T> = {
1741 |     [K in keyof T]-?: undefined extends T[K] ? K : never;
1742 | }[keyof T];
1743 | /**
1744 |  * Tracks the value and validity state of a group of `FormControl` instances.
1745 |  *
1746 |  * A `FormGroup` aggregates the values of each child `FormControl` into one object,
1747 |  * with each control name as the key.  It calculates its status by reducing the status values
1748 |  * of its children. For example, if one of the controls in a group is invalid, the entire
1749 |  * group becomes invalid.
1750 |  *
1751 |  * `FormGroup` is one of the four fundamental building blocks used to define forms in Angular,
1752 |  * along with `FormControl`, `FormArray`, and `FormRecord`.
1753 |  *
1754 |  * When instantiating a `FormGroup`, pass in a collection of child controls as the first
1755 |  * argument. The key for each child registers the name for the control.
1756 |  *
1757 |  * `FormGroup` is intended for use cases where the keys are known ahead of time.
1758 |  * If you need to dynamically add and remove controls, use {@link FormRecord} instead.
1759 |  *
1760 |  * `FormGroup` accepts an optional type parameter `TControl`, which is an object type with inner
1761 |  * control types as values.
1762 |  *
1763 |  * @usageNotes
1764 |  *
1765 |  * ### Create a form group with 2 controls
1766 |  *
1767 |  * ```ts
1768 |  * const form = new FormGroup({
1769 |  *   first: new FormControl('Nancy', Validators.minLength(2)),
1770 |  *   last: new FormControl('Drew'),
1771 |  * });
1772 |  *
1773 |  * console.log(form.value);   // {first: 'Nancy', last; 'Drew'}
1774 |  * console.log(form.status);  // 'VALID'
1775 |  * ```
1776 |  *
1777 |  * ### The type argument, and optional controls
1778 |  *
1779 |  * `FormGroup` accepts one generic argument, which is an object containing its inner controls.
1780 |  * This type will usually be inferred automatically, but you can always specify it explicitly if you
1781 |  * wish.
1782 |  *
1783 |  * If you have controls that are optional (i.e. they can be removed, you can use the `?` in the
1784 |  * type):
1785 |  *
1786 |  * ```ts
1787 |  * const form = new FormGroup<{
1788 |  *   first: FormControl<string|null>,
1789 |  *   middle?: FormControl<string|null>, // Middle name is optional.
1790 |  *   last: FormControl<string|null>,
1791 |  * }>({
1792 |  *   first: new FormControl('Nancy'),
1793 |  *   last: new FormControl('Drew'),
1794 |  * });
1795 |  * ```
1796 |  *
1797 |  * ### Create a form group with a group-level validator
1798 |  *
1799 |  * You include group-level validators as the second arg, or group-level async
1800 |  * validators as the third arg. These come in handy when you want to perform validation
1801 |  * that considers the value of more than one child control.
1802 |  *
1803 |  * ```ts
1804 |  * const form = new FormGroup({
1805 |  *   password: new FormControl('', Validators.minLength(2)),
1806 |  *   passwordConfirm: new FormControl('', Validators.minLength(2)),
1807 |  * }, passwordMatchValidator);
1808 |  *
1809 |  *
1810 |  * function passwordMatchValidator(g: FormGroup) {
1811 |  *    return g.get('password').value === g.get('passwordConfirm').value
1812 |  *       ? null : {'mismatch': true};
1813 |  * }
1814 |  * ```
1815 |  *
1816 |  * Like `FormControl` instances, you choose to pass in
1817 |  * validators and async validators as part of an options object.
1818 |  *
1819 |  * ```ts
1820 |  * const form = new FormGroup({
1821 |  *   password: new FormControl('')
1822 |  *   passwordConfirm: new FormControl('')
1823 |  * }, { validators: passwordMatchValidator, asyncValidators: otherValidator });
1824 |  * ```
1825 |  *
1826 |  * ### Set the updateOn property for all controls in a form group
1827 |  *
1828 |  * The options object is used to set a default value for each child
1829 |  * control's `updateOn` property. If you set `updateOn` to `'blur'` at the
1830 |  * group level, all child controls default to 'blur', unless the child
1831 |  * has explicitly specified a different `updateOn` value.
1832 |  *
1833 |  * ```ts
1834 |  * const c = new FormGroup({
1835 |  *   one: new FormControl()
1836 |  * }, { updateOn: 'blur' });
1837 |  * ```
1838 |  *
1839 |  * ### Using a FormGroup with optional controls
1840 |  *
1841 |  * It is possible to have optional controls in a FormGroup. An optional control can be removed later
1842 |  * using `removeControl`, and can be omitted when calling `reset`. Optional controls must be
1843 |  * declared optional in the group's type.
1844 |  *
1845 |  * ```ts
1846 |  * const c = new FormGroup<{one?: FormControl<string>}>({
1847 |  *   one: new FormControl('')
1848 |  * });
1849 |  * ```
1850 |  *
1851 |  * Notice that `c.value.one` has type `string|null|undefined`. This is because calling `c.reset({})`
1852 |  * without providing the optional key `one` will cause it to become `null`.
1853 |  *
1854 |  * @publicApi
1855 |  */
1856 | declare class FormGroup<TControl extends {
1857 |     [K in keyof TControl]: AbstractControl<any>;
1858 | } = any> extends AbstractControl<ɵTypedOrUntyped<TControl, ɵFormGroupValue<TControl>, any>, ɵTypedOrUntyped<TControl, ɵFormGroupRawValue<TControl>, any>, ɵTypedOrUntyped<TControl, ɵFormGroupArgumentValue<TControl>, any>> {
1859 |     /**
1860 |      * Creates a new `FormGroup` instance.
1861 |      *
1862 |      * @param controls A collection of child controls. The key for each child is the name
1863 |      * under which it is registered.
1864 |      *
1865 |      * @param validatorOrOpts A synchronous validator function, or an array of
1866 |      * such functions, or an `AbstractControlOptions` object that contains validation functions
1867 |      * and a validation trigger.
1868 |      *
1869 |      * @param asyncValidator A single async validator or array of async validator functions
1870 |      *
1871 |      */
1872 |     constructor(controls: TControl, validatorOrOpts?: ValidatorFn | ValidatorFn[] | AbstractControlOptions | null, asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null);
1873 |     controls: ɵTypedOrUntyped<TControl, TControl, {
1874 |         [key: string]: AbstractControl<any>;
1875 |     }>;
1876 |     /**
1877 |      * Registers a control with the group's list of controls. In a strongly-typed group, the control
1878 |      * must be in the group's type (possibly as an optional key).
1879 |      *
1880 |      * This method does not update the value or validity of the control.
1881 |      * Use {@link FormGroup#addControl addControl} instead.
1882 |      *
1883 |      * @param name The control name to register in the collection
1884 |      * @param control Provides the control for the given name
1885 |      */
1886 |     registerControl<K extends string & keyof TControl>(name: K, control: TControl[K]): TControl[K];
1887 |     registerControl(this: FormGroup<{
1888 |         [key: string]: AbstractControl<any>;
1889 |     }>, name: string, control: AbstractControl<any>): AbstractControl<any>;
1890 |     /**
1891 |      * Add a control to this group. In a strongly-typed group, the control must be in the group's type
1892 |      * (possibly as an optional key).
1893 |      *
1894 |      * If a control with a given name already exists, it would *not* be replaced with a new one.
1895 |      * If you want to replace an existing control, use the {@link FormGroup#setControl setControl}
1896 |      * method instead. This method also updates the value and validity of the control.
1897 |      *
1898 |      * @param name The control name to add to the collection
1899 |      * @param control Provides the control for the given name
1900 |      * @param options Specifies whether this FormGroup instance should emit events after a new
1901 |      *     control is added.
1902 |      * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
1903 |      * `valueChanges` observables emit events with the latest status and value when the control is
1904 |      * added. When false, no events are emitted.
1905 |      */
1906 |     addControl(this: FormGroup<{
1907 |         [key: string]: AbstractControl<any>;
1908 |     }>, name: string, control: AbstractControl, options?: {
1909 |         emitEvent?: boolean;
1910 |     }): void;
1911 |     addControl<K extends string & keyof TControl>(name: K, control: Required<TControl>[K], options?: {
1912 |         emitEvent?: boolean;
1913 |     }): void;
1914 |     removeControl(this: FormGroup<{
1915 |         [key: string]: AbstractControl<any>;
1916 |     }>, name: string, options?: {
1917 |         emitEvent?: boolean;
1918 |     }): void;
1919 |     removeControl<S extends string>(name: ɵOptionalKeys<TControl> & S, options?: {
1920 |         emitEvent?: boolean;
1921 |     }): void;
1922 |     /**
1923 |      * Replace an existing control. In a strongly-typed group, the control must be in the group's type
1924 |      * (possibly as an optional key).
1925 |      *
1926 |      * If a control with a given name does not exist in this `FormGroup`, it will be added.
1927 |      *
1928 |      * @param name The control name to replace in the collection
1929 |      * @param control Provides the control for the given name
1930 |      * @param options Specifies whether this FormGroup instance should emit events after an
1931 |      *     existing control is replaced.
1932 |      * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
1933 |      * `valueChanges` observables emit events with the latest status and value when the control is
1934 |      * replaced with a new one. When false, no events are emitted.
1935 |      */
1936 |     setControl<K extends string & keyof TControl>(name: K, control: TControl[K], options?: {
1937 |         emitEvent?: boolean;
1938 |     }): void;
1939 |     setControl(this: FormGroup<{
1940 |         [key: string]: AbstractControl<any>;
1941 |     }>, name: string, control: AbstractControl, options?: {
1942 |         emitEvent?: boolean;
1943 |     }): void;
1944 |     /**
1945 |      * Check whether there is an enabled control with the given name in the group.
1946 |      *
1947 |      * Reports false for disabled controls. If you'd like to check for existence in the group
1948 |      * only, use {@link AbstractControl#get get} instead.
1949 |      *
1950 |      * @param controlName The control name to check for existence in the collection
1951 |      *
1952 |      * @returns false for disabled controls, true otherwise.
1953 |      */
1954 |     contains<K extends string>(controlName: K): boolean;
1955 |     contains(this: FormGroup<{
1956 |         [key: string]: AbstractControl<any>;
1957 |     }>, controlName: string): boolean;
1958 |     /**
1959 |      * Sets the value of the `FormGroup`. It accepts an object that matches
1960 |      * the structure of the group, with control names as keys.
1961 |      *
1962 |      * @usageNotes
1963 |      * ### Set the complete value for the form group
1964 |      *
1965 |      * ```ts
1966 |      * const form = new FormGroup({
1967 |      *   first: new FormControl(),
1968 |      *   last: new FormControl()
1969 |      * });
1970 |      *
1971 |      * console.log(form.value);   // {first: null, last: null}
1972 |      *
1973 |      * form.setValue({first: 'Nancy', last: 'Drew'});
1974 |      * console.log(form.value);   // {first: 'Nancy', last: 'Drew'}
1975 |      * ```
1976 |      *
1977 |      * @throws When strict checks fail, such as setting the value of a control
1978 |      * that doesn't exist or if you exclude a value of a control that does exist.
1979 |      *
1980 |      * @param value The new value for the control that matches the structure of the group.
1981 |      * @param options Configuration options that determine how the control propagates changes
1982 |      * and emits events after the value changes.
1983 |      * The configuration options are passed to the {@link AbstractControl#updateValueAndValidity
1984 |      * updateValueAndValidity} method.
1985 |      *
1986 |      * * `onlySelf`: When true, each change only affects this control, and not its parent. Default is
1987 |      * false.
1988 |      * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
1989 |      * `valueChanges`
1990 |      * observables emit events with the latest status and value when the control value is updated.
1991 |      * When false, no events are emitted.
1992 |      */
1993 |     setValue(value: ɵFormGroupRawValue<TControl>, options?: {
1994 |         onlySelf?: boolean;
1995 |         emitEvent?: boolean;
1996 |     }): void;
1997 |     /**
1998 |      * Patches the value of the `FormGroup`. It accepts an object with control
1999 |      * names as keys, and does its best to match the values to the correct controls
2000 |      * in the group.
2001 |      *
2002 |      * It accepts both super-sets and sub-sets of the group without throwing an error.
2003 |      *
2004 |      * @usageNotes
2005 |      * ### Patch the value for a form group
2006 |      *
2007 |      * ```ts
2008 |      * const form = new FormGroup({
2009 |      *    first: new FormControl(),
2010 |      *    last: new FormControl()
2011 |      * });
2012 |      * console.log(form.value);   // {first: null, last: null}
2013 |      *
2014 |      * form.patchValue({first: 'Nancy'});
2015 |      * console.log(form.value);   // {first: 'Nancy', last: null}
2016 |      * ```
2017 |      *
2018 |      * @param value The object that matches the structure of the group.
2019 |      * @param options Configuration options that determine how the control propagates changes and
2020 |      * emits events after the value is patched.
2021 |      * * `onlySelf`: When true, each change only affects this control and not its parent. Default is
2022 |      * true.
2023 |      * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
2024 |      * `valueChanges` observables emit events with the latest status and value when the control value
2025 |      * is updated. When false, no events are emitted. The configuration options are passed to
2026 |      * the {@link AbstractControl#updateValueAndValidity updateValueAndValidity} method.
2027 |      */
2028 |     patchValue(value: ɵFormGroupValue<TControl>, options?: {
2029 |         onlySelf?: boolean;
2030 |         emitEvent?: boolean;
2031 |     }): void;
2032 |     /**
2033 |      * Resets the `FormGroup`, marks all descendants `pristine` and `untouched` and sets
2034 |      * the value of all descendants to their default values, or null if no defaults were provided.
2035 |      *
2036 |      * You reset to a specific form state by passing in a map of states
2037 |      * that matches the structure of your form, with control names as keys. The state
2038 |      * is a standalone value or a form state object with both a value and a disabled
2039 |      * status.
2040 |      *
2041 |      * @param value Resets the control with an initial value,
2042 |      * or an object that defines the initial value and disabled state.
2043 |      *
2044 |      * @param options Configuration options that determine how the control propagates changes
2045 |      * and emits events when the group is reset.
2046 |      * * `onlySelf`: When true, each change only affects this control, and not its parent. Default is
2047 |      * false.
2048 |      * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
2049 |      * `valueChanges`
2050 |      * observables emit events with the latest status and value when the control is reset.
2051 |      * When false, no events are emitted.
2052 |      * The configuration options are passed to the {@link AbstractControl#updateValueAndValidity
2053 |      * updateValueAndValidity} method.
2054 |      *
2055 |      * @usageNotes
2056 |      *
2057 |      * ### Reset the form group values
2058 |      *
2059 |      * ```ts
2060 |      * const form = new FormGroup({
2061 |      *   first: new FormControl('first name'),
2062 |      *   last: new FormControl('last name')
2063 |      * });
2064 |      *
2065 |      * console.log(form.value);  // {first: 'first name', last: 'last name'}
2066 |      *
2067 |      * form.reset({ first: 'name', last: 'last name' });
2068 |      *
2069 |      * console.log(form.value);  // {first: 'name', last: 'last name'}
2070 |      * ```
2071 |      *
2072 |      * ### Reset the form group values and disabled status
2073 |      *
2074 |      * ```ts
2075 |      * const form = new FormGroup({
2076 |      *   first: new FormControl('first name'),
2077 |      *   last: new FormControl('last name')
2078 |      * });
2079 |      *
2080 |      * form.reset({
2081 |      *   first: {value: 'name', disabled: true},
2082 |      *   last: 'last'
2083 |      * });
2084 |      *
2085 |      * console.log(form.value);  // {last: 'last'}
2086 |      * console.log(form.get('first').status);  // 'DISABLED'
2087 |      * ```
2088 |      */
2089 |     reset(value?: ɵTypedOrUntyped<TControl, ɵFormGroupArgumentValue<TControl>, any>, options?: {
2090 |         onlySelf?: boolean;
2091 |         emitEvent?: boolean;
2092 |     }): void;
2093 |     /**
2094 |      * The aggregate value of the `FormGroup`, including any disabled controls.
2095 |      *
2096 |      * Retrieves all values regardless of disabled status.
2097 |      */
2098 |     getRawValue(): ɵTypedOrUntyped<TControl, ɵFormGroupRawValue<TControl>, any>;
2099 | }
2100 | interface UntypedFormGroupCtor {
2101 |     new (controls: {
2102 |         [key: string]: AbstractControl;
2103 |     }, validatorOrOpts?: ValidatorFn | ValidatorFn[] | AbstractControlOptions | null, asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null): UntypedFormGroup;
2104 |     /**
2105 |      * The presence of an explicit `prototype` property provides backwards-compatibility for apps that
2106 |      * manually inspect the prototype chain.
2107 |      */
2108 |     prototype: FormGroup<any>;
2109 | }
2110 | /**
2111 |  * UntypedFormGroup is a non-strongly-typed version of `FormGroup`.
2112 |  */
2113 | type UntypedFormGroup = FormGroup<any>;
2114 | declare const UntypedFormGroup: UntypedFormGroupCtor;
2115 | /**
2116 |  * @description
2117 |  * Asserts that the given control is an instance of `FormGroup`
2118 |  *
2119 |  * @publicApi
2120 |  */
2121 | declare const isFormGroup: (control: unknown) => control is FormGroup;
2122 | /**
2123 |  * Tracks the value and validity state of a collection of `FormControl` instances, each of which has
2124 |  * the same value type.
2125 |  *
2126 |  * `FormRecord` is very similar to {@link FormGroup}, except it can be used with a dynamic keys,
2127 |  * with controls added and removed as needed.
2128 |  *
2129 |  * `FormRecord` accepts one generic argument, which describes the type of the controls it contains.
2130 |  *
2131 |  * @usageNotes
2132 |  *
2133 |  * ```ts
2134 |  * let numbers = new FormRecord({bill: new FormControl('415-123-456')});
2135 |  * numbers.addControl('bob', new FormControl('415-234-567'));
2136 |  * numbers.removeControl('bill');
2137 |  * ```
2138 |  *
2139 |  * @publicApi
2140 |  */
2141 | declare class FormRecord<TControl extends AbstractControl = AbstractControl> extends FormGroup<{
2142 |     [key: string]: TControl;
2143 | }> {
2144 | }
2145 | interface FormRecord<TControl> {
2146 |     /**
2147 |      * Registers a control with the records's list of controls.
2148 |      *
2149 |      * See `FormGroup#registerControl` for additional information.
2150 |      */
2151 |     registerControl(name: string, control: TControl): TControl;
2152 |     /**
2153 |      * Add a control to this group.
2154 |      *
2155 |      * See `FormGroup#addControl` for additional information.
2156 |      */
2157 |     addControl(name: string, control: TControl, options?: {
2158 |         emitEvent?: boolean;
2159 |     }): void;
2160 |     /**
2161 |      * Remove a control from this group.
2162 |      *
2163 |      * See `FormGroup#removeControl` for additional information.
2164 |      */
2165 |     removeControl(name: string, options?: {
2166 |         emitEvent?: boolean;
2167 |     }): void;
2168 |     /**
2169 |      * Replace an existing control.
2170 |      *
2171 |      * See `FormGroup#setControl` for additional information.
2172 |      */
2173 |     setControl(name: string, control: TControl, options?: {
2174 |         emitEvent?: boolean;
2175 |     }): void;
2176 |     /**
2177 |      * Check whether there is an enabled control with the given name in the group.
2178 |      *
2179 |      * See `FormGroup#contains` for additional information.
2180 |      */
2181 |     contains(controlName: string): boolean;
2182 |     /**
2183 |      * Sets the value of the `FormRecord`. It accepts an object that matches
2184 |      * the structure of the group, with control names as keys.
2185 |      *
2186 |      * See `FormGroup#setValue` for additional information.
2187 |      */
2188 |     setValue(value: {
2189 |         [key: string]: ɵRawValue<TControl>;
2190 |     }, options?: {
2191 |         onlySelf?: boolean;
2192 |         emitEvent?: boolean;
2193 |     }): void;
2194 |     /**
2195 |      * Patches the value of the `FormRecord`. It accepts an object with control
2196 |      * names as keys, and does its best to match the values to the correct controls
2197 |      * in the group.
2198 |      *
2199 |      * See `FormGroup#patchValue` for additional information.
2200 |      */
2201 |     patchValue(value: {
2202 |         [key: string]: ɵValue<TControl>;
2203 |     }, options?: {
2204 |         onlySelf?: boolean;
2205 |         emitEvent?: boolean;
2206 |     }): void;
2207 |     /**
2208 |      * Resets the `FormRecord`, marks all descendants `pristine` and `untouched` and sets
2209 |      * the value of all descendants to null.
2210 |      *
2211 |      * See `FormGroup#reset` for additional information.
2212 |      */
2213 |     reset(value?: {
2214 |         [key: string]: ɵValue<TControl> | FormControlState<ɵValue<TControl>>;
2215 |     }, options?: {
2216 |         onlySelf?: boolean;
2217 |         emitEvent?: boolean;
2218 |     }): void;
2219 |     /**
2220 |      * The aggregate value of the `FormRecord`, including any disabled controls.
2221 |      *
2222 |      * See `FormGroup#getRawValue` for additional information.
2223 |      */
2224 |     getRawValue(): {
2225 |         [key: string]: ɵRawValue<TControl>;
2226 |     };
2227 | }
2228 | /**
2229 |  * @description
2230 |  * Asserts that the given control is an instance of `FormRecord`
2231 |  *
2232 |  * @publicApi
2233 |  */
2234 | declare const isFormRecord: (control: unknown) => control is FormRecord;
2235 | 
2236 | /**
2237 |  * A form can have several different statuses. Each
2238 |  * possible status is returned as a string literal.
2239 |  *
2240 |  * * **VALID**: Reports that a control is valid, meaning that no errors exist in the input
2241 |  * value.
2242 |  * * **INVALID**: Reports that a control is invalid, meaning that an error exists in the input
2243 |  * value.
2244 |  * * **PENDING**: Reports that a control is pending, meaning that async validation is
2245 |  * occurring and errors are not yet available for the input value.
2246 |  * * **DISABLED**: Reports that a control is
2247 |  * disabled, meaning that the control is exempt from ancestor calculations of validity or value.
2248 |  *
2249 |  * @publicApi
2250 |  */
2251 | type FormControlStatus = 'VALID' | 'INVALID' | 'PENDING' | 'DISABLED';
2252 | /**
2253 |  * Base class for every event sent by `AbstractControl.events()`
2254 |  *
2255 |  * @publicApi
2256 |  */
2257 | declare abstract class ControlEvent<T = any> {
2258 |     /**
2259 |      * Form control from which this event is originated.
2260 |      *
2261 |      * Note: the type of the control can't be infered from T as the event can be emitted by any of child controls
2262 |      */
2263 |     abstract readonly source: AbstractControl<unknown>;
2264 | }
2265 | /**
2266 |  * Event fired when the value of a control changes.
2267 |  *
2268 |  * @publicApi
2269 |  */
2270 | declare class ValueChangeEvent<T> extends ControlEvent<T> {
2271 |     readonly value: T;
2272 |     readonly source: AbstractControl;
2273 |     constructor(value: T, source: AbstractControl);
2274 | }
2275 | /**
2276 |  * Event fired when the control's pristine state changes (pristine <=> dirty).
2277 |  *
2278 |  * @publicApi */
2279 | declare class PristineChangeEvent extends ControlEvent {
2280 |     readonly pristine: boolean;
2281 |     readonly source: AbstractControl;
2282 |     constructor(pristine: boolean, source: AbstractControl);
2283 | }
2284 | /**
2285 |  * Event fired when the control's touched status changes (touched <=> untouched).
2286 |  *
2287 |  * @publicApi
2288 |  */
2289 | declare class TouchedChangeEvent extends ControlEvent {
2290 |     readonly touched: boolean;
2291 |     readonly source: AbstractControl;
2292 |     constructor(touched: boolean, source: AbstractControl);
2293 | }
2294 | /**
2295 |  * Event fired when the control's status changes.
2296 |  *
2297 |  * @publicApi
2298 |  */
2299 | declare class StatusChangeEvent extends ControlEvent {
2300 |     readonly status: FormControlStatus;
2301 |     readonly source: AbstractControl;
2302 |     constructor(status: FormControlStatus, source: AbstractControl);
2303 | }
2304 | /**
2305 |  * Event fired when a form is submitted
2306 |  *
2307 |  * @publicApi
2308 |  */
2309 | declare class FormSubmittedEvent extends ControlEvent {
2310 |     readonly source: AbstractControl;
2311 |     constructor(source: AbstractControl);
2312 | }
2313 | /**
2314 |  * Event fired when a form is reset.
2315 |  *
2316 |  * @publicApi
2317 |  */
2318 | declare class FormResetEvent extends ControlEvent {
2319 |     readonly source: AbstractControl;
2320 |     constructor(source: AbstractControl);
2321 | }
2322 | type FormHooks = 'change' | 'blur' | 'submit';
2323 | /**
2324 |  * Interface for options provided to an `AbstractControl`.
2325 |  *
2326 |  * @publicApi
2327 |  */
2328 | interface AbstractControlOptions {
2329 |     /**
2330 |      * @description
2331 |      * The list of validators applied to a control.
2332 |      */
2333 |     validators?: ValidatorFn | ValidatorFn[] | null;
2334 |     /**
2335 |      * @description
2336 |      * The list of async validators applied to control.
2337 |      */
2338 |     asyncValidators?: AsyncValidatorFn | AsyncValidatorFn[] | null;
2339 |     /**
2340 |      * @description
2341 |      * The event name for control to update upon.
2342 |      */
2343 |     updateOn?: 'change' | 'blur' | 'submit';
2344 | }
2345 | type ɵIsAny<T, Y, N> = 0 extends 1 & T ? Y : N;
2346 | /**
2347 |  * `TypedOrUntyped` allows one of two different types to be selected, depending on whether the Forms
2348 |  * class it's applied to is typed or not.
2349 |  *
2350 |  * This is for internal Angular usage to support typed forms; do not directly use it.
2351 |  */
2352 | type ɵTypedOrUntyped<T, Typed, Untyped> = ɵIsAny<T, Untyped, Typed>;
2353 | /**
2354 |  * Value gives the value type corresponding to a control type.
2355 |  *
2356 |  * Note that the resulting type will follow the same rules as `.value` on your control, group, or
2357 |  * array, including `undefined` for each group element which might be disabled.
2358 |  *
2359 |  * If you are trying to extract a value type for a data model, you probably want {@link RawValue},
2360 |  * which will not have `undefined` in group keys.
2361 |  *
2362 |  * @usageNotes
2363 |  *
2364 |  * ### `FormControl` value type
2365 |  *
2366 |  * You can extract the value type of a single control:
2367 |  *
2368 |  * ```ts
2369 |  * type NameControl = FormControl<string>;
2370 |  * type NameValue = Value<NameControl>;
2371 |  * ```
2372 |  *
2373 |  * The resulting type is `string`.
2374 |  *
2375 |  * ### `FormGroup` value type
2376 |  *
2377 |  * Imagine you have an interface defining the controls in your group. You can extract the shape of
2378 |  * the values as follows:
2379 |  *
2380 |  * ```ts
2381 |  * interface PartyFormControls {
2382 |  *   address: FormControl<string>;
2383 |  * }
2384 |  *
2385 |  * // Value operates on controls; the object must be wrapped in a FormGroup.
2386 |  * type PartyFormValues = Value<FormGroup<PartyFormControls>>;
2387 |  * ```
2388 |  *
2389 |  * The resulting type is `{address: string|undefined}`.
2390 |  *
2391 |  * ### `FormArray` value type
2392 |  *
2393 |  * You can extract values from FormArrays as well:
2394 |  *
2395 |  * ```ts
2396 |  * type GuestNamesControls = FormArray<FormControl<string>>;
2397 |  *
2398 |  * type NamesValues = Value<GuestNamesControls>;
2399 |  * ```
2400 |  *
2401 |  * The resulting type is `string[]`.
2402 |  *
2403 |  * **Internal: not for public use.**
2404 |  */
2405 | type ɵValue<T extends AbstractControl | undefined> = T extends AbstractControl<any, any> ? T['value'] : never;
2406 | /**
2407 |  * RawValue gives the raw value type corresponding to a control type.
2408 |  *
2409 |  * Note that the resulting type will follow the same rules as `.getRawValue()` on your control,
2410 |  * group, or array. This means that all controls inside a group will be required, not optional,
2411 |  * regardless of their disabled state.
2412 |  *
2413 |  * You may also wish to use {@link ɵValue}, which will have `undefined` in group keys (which can be
2414 |  * disabled).
2415 |  *
2416 |  * @usageNotes
2417 |  *
2418 |  * ### `FormGroup` raw value type
2419 |  *
2420 |  * Imagine you have an interface defining the controls in your group. You can extract the shape of
2421 |  * the raw values as follows:
2422 |  *
2423 |  * ```ts
2424 |  * interface PartyFormControls {
2425 |  *   address: FormControl<string>;
2426 |  * }
2427 |  *
2428 |  * // RawValue operates on controls; the object must be wrapped in a FormGroup.
2429 |  * type PartyFormValues = RawValue<FormGroup<PartyFormControls>>;
2430 |  * ```
2431 |  *
2432 |  * The resulting type is `{address: string}`. (Note the absence of `undefined`.)
2433 |  *
2434 |  *  **Internal: not for public use.**
2435 |  */
2436 | type ɵRawValue<T extends AbstractControl | undefined> = T extends AbstractControl<any, any> ? T['setValue'] extends (v: infer R) => void ? R : never : never;
2437 | /**
2438 |  * Tokenize splits a string literal S by a delimiter D.
2439 |  */
2440 | type ɵTokenize<S extends string, D extends string> = string extends S ? string[] : S extends `${infer T}${D}${infer U}` ? [T, ...ɵTokenize<U, D>] : [S];
2441 | /**
2442 |  * CoerceStrArrToNumArr accepts an array of strings, and converts any numeric string to a number.
2443 |  */
2444 | type ɵCoerceStrArrToNumArr<S> = S extends [infer Head, ...infer Tail] ? Head extends `${number}` ? [number, ...ɵCoerceStrArrToNumArr<Tail>] : [Head, ...ɵCoerceStrArrToNumArr<Tail>] : [];
2445 | /**
2446 |  * Navigate takes a type T and an array K, and returns the type of T[K[0]][K[1]][K[2]]...
2447 |  */
2448 | type ɵNavigate<T, K extends Array<string | number>> = T extends object ? K extends [infer Head, ...infer Tail] ? Head extends keyof T ? Tail extends (string | number)[] ? [] extends Tail ? T[Head] : ɵNavigate<T[Head], Tail> : any : never : any : any;
2449 | /**
2450 |  * ɵWriteable removes readonly from all keys.
2451 |  */
2452 | type ɵWriteable<T> = {
2453 |     -readonly [P in keyof T]: T[P];
2454 | };
2455 | /**
2456 |  * GetProperty takes a type T and some property names or indices K.
2457 |  * If K is a dot-separated string, it is tokenized into an array before proceeding.
2458 |  * Then, the type of the nested property at K is computed: T[K[0]][K[1]][K[2]]...
2459 |  * This works with both objects, which are indexed by property name, and arrays, which are indexed
2460 |  * numerically.
2461 |  *
2462 |  * For internal use only.
2463 |  */
2464 | type ɵGetProperty<T, K> = K extends string ? ɵGetProperty<T, ɵCoerceStrArrToNumArr<ɵTokenize<K, '.'>>> : ɵWriteable<K> extends Array<string | number> ? ɵNavigate<T, ɵWriteable<K>> : any;
2465 | /**
2466 |  * This is the base class for `FormControl`, `FormGroup`, and `FormArray`.
2467 |  *
2468 |  * It provides some of the shared behavior that all controls and groups of controls have, like
2469 |  * running validators, calculating status, and resetting state. It also defines the properties
2470 |  * that are shared between all sub-classes, like `value`, `valid`, and `dirty`. It shouldn't be
2471 |  * instantiated directly.
2472 |  *
2473 |  * The first type parameter TValue represents the value type of the control (`control.value`).
2474 |  * The optional type parameter TRawValue  represents the raw value type (`control.getRawValue()`).
2475 |  *
2476 |  * @see [Forms Guide](guide/forms)
2477 |  * @see [Reactive Forms Guide](guide/forms/reactive-forms)
2478 |  * @see [Dynamic Forms Guide](guide/forms/dynamic-forms)
2479 |  *
2480 |  * @publicApi
2481 |  */
2482 | declare abstract class AbstractControl<TValue = any, TRawValue extends TValue = TValue, TValueWithOptionalControlStates = any> {
2483 |     private _parent;
2484 |     private _asyncValidationSubscription;
2485 |     /**
2486 |      * The current value of the control.
2487 |      *
2488 |      * * For a `FormControl`, the current value.
2489 |      * * For an enabled `FormGroup`, the values of enabled controls as an object
2490 |      * with a key-value pair for each member of the group.
2491 |      * * For a disabled `FormGroup`, the values of all controls as an object
2492 |      * with a key-value pair for each member of the group.
2493 |      * * For a `FormArray`, the values of enabled controls as an array.
2494 |      *
2495 |      */
2496 |     readonly value: TValue;
2497 |     /**
2498 |      * Initialize the AbstractControl instance.
2499 |      *
2500 |      * @param validators The function or array of functions that is used to determine the validity of
2501 |      *     this control synchronously.
2502 |      * @param asyncValidators The function or array of functions that is used to determine validity of
2503 |      *     this control asynchronously.
2504 |      */
2505 |     constructor(validators: ValidatorFn | ValidatorFn[] | null, asyncValidators: AsyncValidatorFn | AsyncValidatorFn[] | null);
2506 |     /**
2507 |      * Returns the function that is used to determine the validity of this control synchronously.
2508 |      * If multiple validators have been added, this will be a single composed function.
2509 |      * See `Validators.compose()` for additional information.
2510 |      */
2511 |     get validator(): ValidatorFn | null;
2512 |     set validator(validatorFn: ValidatorFn | null);
2513 |     /**
2514 |      * Returns the function that is used to determine the validity of this control asynchronously.
2515 |      * If multiple validators have been added, this will be a single composed function.
2516 |      * See `Validators.compose()` for additional information.
2517 |      */
2518 |     get asyncValidator(): AsyncValidatorFn | null;
2519 |     set asyncValidator(asyncValidatorFn: AsyncValidatorFn | null);
2520 |     /**
2521 |      * The parent control.
2522 |      */
2523 |     get parent(): FormGroup | FormArray | null;
2524 |     /**
2525 |      * The validation status of the control.
2526 |      *
2527 |      * @see {@link FormControlStatus}
2528 |      *
2529 |      * These status values are mutually exclusive, so a control cannot be
2530 |      * both valid AND invalid or invalid AND disabled.
2531 |      */
2532 |     get status(): FormControlStatus;
2533 |     private set status(value);
2534 |     private readonly statusReactive;
2535 |     /**
2536 |      * A control is `valid` when its `status` is `VALID`.
2537 |      *
2538 |      * @see {@link AbstractControl.status}
2539 |      *
2540 |      * @returns True if the control has passed all of its validation tests,
2541 |      * false otherwise.
2542 |      */
2543 |     get valid(): boolean;
2544 |     /**
2545 |      * A control is `invalid` when its `status` is `INVALID`.
2546 |      *
2547 |      * @see {@link AbstractControl.status}
2548 |      *
2549 |      * @returns True if this control has failed one or more of its validation checks,
2550 |      * false otherwise.
2551 |      */
2552 |     get invalid(): boolean;
2553 |     /**
2554 |      * A control is `pending` when its `status` is `PENDING`.
2555 |      *
2556 |      * @see {@link AbstractControl.status}
2557 |      *
2558 |      * @returns True if this control is in the process of conducting a validation check,
2559 |      * false otherwise.
2560 |      */
2561 |     get pending(): boolean;
2562 |     /**
2563 |      * A control is `disabled` when its `status` is `DISABLED`.
2564 |      *
2565 |      * Disabled controls are exempt from validation checks and
2566 |      * are not included in the aggregate value of their ancestor
2567 |      * controls.
2568 |      *
2569 |      * @see {@link AbstractControl.status}
2570 |      *
2571 |      * @returns True if the control is disabled, false otherwise.
2572 |      */
2573 |     get disabled(): boolean;
2574 |     /**
2575 |      * A control is `enabled` as long as its `status` is not `DISABLED`.
2576 |      *
2577 |      * @returns True if the control has any status other than 'DISABLED',
2578 |      * false if the status is 'DISABLED'.
2579 |      *
2580 |      * @see {@link AbstractControl.status}
2581 |      *
2582 |      */
2583 |     get enabled(): boolean;
2584 |     /**
2585 |      * An object containing any errors generated by failing validation,
2586 |      * or null if there are no errors.
2587 |      */
2588 |     readonly errors: ValidationErrors | null;
2589 |     /**
2590 |      * A control is `pristine` if the user has not yet changed
2591 |      * the value in the UI.
2592 |      *
2593 |      * @returns True if the user has not yet changed the value in the UI; compare `dirty`.
2594 |      * Programmatic changes to a control's value do not mark it dirty.
2595 |      */
2596 |     get pristine(): boolean;
2597 |     private set pristine(value);
2598 |     private readonly pristineReactive;
2599 |     /**
2600 |      * A control is `dirty` if the user has changed the value
2601 |      * in the UI.
2602 |      *
2603 |      * @returns True if the user has changed the value of this control in the UI; compare `pristine`.
2604 |      * Programmatic changes to a control's value do not mark it dirty.
2605 |      */
2606 |     get dirty(): boolean;
2607 |     /**
2608 |      * True if the control is marked as `touched`.
2609 |      *
2610 |      * A control is marked `touched` once the user has triggered
2611 |      * a `blur` event on it.
2612 |      */
2613 |     get touched(): boolean;
2614 |     private set touched(value);
2615 |     private readonly touchedReactive;
2616 |     /**
2617 |      * True if the control has not been marked as touched
2618 |      *
2619 |      * A control is `untouched` if the user has not yet triggered
2620 |      * a `blur` event on it.
2621 |      */
2622 |     get untouched(): boolean;
2623 |     /**
2624 |      * A multicasting observable that emits an event every time the state of the control changes.
2625 |      * It emits for value, status, pristine or touched changes.
2626 |      *
2627 |      * **Note**: On value change, the emit happens right after a value of this control is updated. The
2628 |      * value of a parent control (for example if this FormControl is a part of a FormGroup) is updated
2629 |      * later, so accessing a value of a parent control (using the `value` property) from the callback
2630 |      * of this event might result in getting a value that has not been updated yet. Subscribe to the
2631 |      * `events` of the parent control instead.
2632 |      * For other event types, the events are emitted after the parent control has been updated.
2633 |      *
2634 |      */
2635 |     readonly events: Observable<ControlEvent<TValue>>;
2636 |     /**
2637 |      * A multicasting observable that emits an event every time the value of the control changes, in
2638 |      * the UI or programmatically. It also emits an event each time you call enable() or disable()
2639 |      * without passing along {emitEvent: false} as a function argument.
2640 |      *
2641 |      * **Note**: the emit happens right after a value of this control is updated. The value of a
2642 |      * parent control (for example if this FormControl is a part of a FormGroup) is updated later, so
2643 |      * accessing a value of a parent control (using the `value` property) from the callback of this
2644 |      * event might result in getting a value that has not been updated yet. Subscribe to the
2645 |      * `valueChanges` event of the parent control instead.
2646 |      */
2647 |     readonly valueChanges: Observable<TValue>;
2648 |     /**
2649 |      * A multicasting observable that emits an event every time the validation `status` of the control
2650 |      * recalculates.
2651 |      *
2652 |      * @see {@link FormControlStatus}
2653 |      * @see {@link AbstractControl.status}
2654 |      */
2655 |     readonly statusChanges: Observable<FormControlStatus>;
2656 |     /**
2657 |      * Reports the update strategy of the `AbstractControl` (meaning
2658 |      * the event on which the control updates itself).
2659 |      * Possible values: `'change'` | `'blur'` | `'submit'`
2660 |      * Default value: `'change'`
2661 |      */
2662 |     get updateOn(): FormHooks;
2663 |     /**
2664 |      * Sets the synchronous validators that are active on this control.  Calling
2665 |      * this overwrites any existing synchronous validators.
2666 |      *
2667 |      * When you add or remove a validator at run time, you must call
2668 |      * `updateValueAndValidity()` for the new validation to take effect.
2669 |      *
2670 |      * If you want to add a new validator without affecting existing ones, consider
2671 |      * using `addValidators()` method instead.
2672 |      */
2673 |     setValidators(validators: ValidatorFn | ValidatorFn[] | null): void;
2674 |     /**
2675 |      * Sets the asynchronous validators that are active on this control. Calling this
2676 |      * overwrites any existing asynchronous validators.
2677 |      *
2678 |      * When you add or remove a validator at run time, you must call
2679 |      * `updateValueAndValidity()` for the new validation to take effect.
2680 |      *
2681 |      * If you want to add a new validator without affecting existing ones, consider
2682 |      * using `addAsyncValidators()` method instead.
2683 |      */
2684 |     setAsyncValidators(validators: AsyncValidatorFn | AsyncValidatorFn[] | null): void;
2685 |     /**
2686 |      * Add a synchronous validator or validators to this control, without affecting other validators.
2687 |      *
2688 |      * When you add or remove a validator at run time, you must call
2689 |      * `updateValueAndValidity()` for the new validation to take effect.
2690 |      *
2691 |      * Adding a validator that already exists will have no effect. If duplicate validator functions
2692 |      * are present in the `validators` array, only the first instance would be added to a form
2693 |      * control.
2694 |      *
2695 |      * @param validators The new validator function or functions to add to this control.
2696 |      */
2697 |     addValidators(validators: ValidatorFn | ValidatorFn[]): void;
2698 |     /**
2699 |      * Add an asynchronous validator or validators to this control, without affecting other
2700 |      * validators.
2701 |      *
2702 |      * When you add or remove a validator at run time, you must call
2703 |      * `updateValueAndValidity()` for the new validation to take effect.
2704 |      *
2705 |      * Adding a validator that already exists will have no effect.
2706 |      *
2707 |      * @param validators The new asynchronous validator function or functions to add to this control.
2708 |      */
2709 |     addAsyncValidators(validators: AsyncValidatorFn | AsyncValidatorFn[]): void;
2710 |     /**
2711 |      * Remove a synchronous validator from this control, without affecting other validators.
2712 |      * Validators are compared by function reference; you must pass a reference to the exact same
2713 |      * validator function as the one that was originally set. If a provided validator is not found,
2714 |      * it is ignored.
2715 |      *
2716 |      * @usageNotes
2717 |      *
2718 |      * ### Reference to a ValidatorFn
2719 |      *
2720 |      * ```
2721 |      * // Reference to the RequiredValidator
2722 |      * const ctrl = new FormControl<string | null>('', Validators.required);
2723 |      * ctrl.removeValidators(Validators.required);
2724 |      *
2725 |      * // Reference to anonymous function inside MinValidator
2726 |      * const minValidator = Validators.min(3);
2727 |      * const ctrl = new FormControl<string | null>('', minValidator);
2728 |      * expect(ctrl.hasValidator(minValidator)).toEqual(true)
2729 |      * expect(ctrl.hasValidator(Validators.min(3))).toEqual(false)
2730 |      *
2731 |      * ctrl.removeValidators(minValidator);
2732 |      * ```
2733 |      *
2734 |      * When you add or remove a validator at run time, you must call
2735 |      * `updateValueAndValidity()` for the new validation to take effect.
2736 |      *
2737 |      * @param validators The validator or validators to remove.
2738 |      */
2739 |     removeValidators(validators: ValidatorFn | ValidatorFn[]): void;
2740 |     /**
2741 |      * Remove an asynchronous validator from this control, without affecting other validators.
2742 |      * Validators are compared by function reference; you must pass a reference to the exact same
2743 |      * validator function as the one that was originally set. If a provided validator is not found, it
2744 |      * is ignored.
2745 |      *
2746 |      * When you add or remove a validator at run time, you must call
2747 |      * `updateValueAndValidity()` for the new validation to take effect.
2748 |      *
2749 |      * @param validators The asynchronous validator or validators to remove.
2750 |      */
2751 |     removeAsyncValidators(validators: AsyncValidatorFn | AsyncValidatorFn[]): void;
2752 |     /**
2753 |      * Check whether a synchronous validator function is present on this control. The provided
2754 |      * validator must be a reference to the exact same function that was provided.
2755 |      *
2756 |      * @usageNotes
2757 |      *
2758 |      * ### Reference to a ValidatorFn
2759 |      *
2760 |      * ```
2761 |      * // Reference to the RequiredValidator
2762 |      * const ctrl = new FormControl<number | null>(0, Validators.required);
2763 |      * expect(ctrl.hasValidator(Validators.required)).toEqual(true)
2764 |      *
2765 |      * // Reference to anonymous function inside MinValidator
2766 |      * const minValidator = Validators.min(3);
2767 |      * const ctrl = new FormControl<number | null>(0, minValidator);
2768 |      * expect(ctrl.hasValidator(minValidator)).toEqual(true)
2769 |      * expect(ctrl.hasValidator(Validators.min(3))).toEqual(false)
2770 |      * ```
2771 |      *
2772 |      * @param validator The validator to check for presence. Compared by function reference.
2773 |      * @returns Whether the provided validator was found on this control.
2774 |      */
2775 |     hasValidator(validator: ValidatorFn): boolean;
2776 |     /**
2777 |      * Check whether an asynchronous validator function is present on this control. The provided
2778 |      * validator must be a reference to the exact same function that was provided.
2779 |      *
2780 |      * @param validator The asynchronous validator to check for presence. Compared by function
2781 |      *     reference.
2782 |      * @returns Whether the provided asynchronous validator was found on this control.
2783 |      */
2784 |     hasAsyncValidator(validator: AsyncValidatorFn): boolean;
2785 |     /**
2786 |      * Empties out the synchronous validator list.
2787 |      *
2788 |      * When you add or remove a validator at run time, you must call
2789 |      * `updateValueAndValidity()` for the new validation to take effect.
2790 |      *
2791 |      */
2792 |     clearValidators(): void;
2793 |     /**
2794 |      * Empties out the async validator list.
2795 |      *
2796 |      * When you add or remove a validator at run time, you must call
2797 |      * `updateValueAndValidity()` for the new validation to take effect.
2798 |      *
2799 |      */
2800 |     clearAsyncValidators(): void;
2801 |     /**
2802 |      * Marks the control as `touched`. A control is touched by focus and
2803 |      * blur events that do not change the value.
2804 |      *
2805 |      * @see {@link markAsUntouched()}
2806 |      * @see {@link markAsDirty()}
2807 |      * @see {@link markAsPristine()}
2808 |      *
2809 |      * @param opts Configuration options that determine how the control propagates changes
2810 |      * and emits events after marking is applied.
2811 |      * * `onlySelf`: When true, mark only this control. When false or not supplied,
2812 |      * marks all direct ancestors. Default is false.
2813 |      * * `emitEvent`: When true or not supplied (the default), the `events`
2814 |      * observable emits a `TouchedChangeEvent` with the `touched` property being `true`.
2815 |      * When false, no events are emitted.
2816 |      */
2817 |     markAsTouched(opts?: {
2818 |         onlySelf?: boolean;
2819 |         emitEvent?: boolean;
2820 |     }): void;
2821 |     /**
2822 |      * Marks the control and all its descendant controls as `dirty`.
2823 |      * @see {@link markAsDirty()}
2824 |      *
2825 |      * @param opts Configuration options that determine how the control propagates changes
2826 |      * and emits events after marking is applied.
2827 |      * * `emitEvent`: When true or not supplied (the default), the `events`
2828 |      * observable emits a `PristineChangeEvent` with the `pristine` property being `false`.
2829 |      * When false, no events are emitted.
2830 |      */
2831 |     markAllAsDirty(opts?: {
2832 |         emitEvent?: boolean;
2833 |     }): void;
2834 |     /**
2835 |      * Marks the control and all its descendant controls as `touched`.
2836 |      * @see {@link markAsTouched()}
2837 |      *
2838 |      * @param opts Configuration options that determine how the control propagates changes
2839 |      * and emits events after marking is applied.
2840 |      * * `emitEvent`: When true or not supplied (the default), the `events`
2841 |      * observable emits a `TouchedChangeEvent` with the `touched` property being `true`.
2842 |      * When false, no events are emitted.
2843 |      */
2844 |     markAllAsTouched(opts?: {
2845 |         emitEvent?: boolean;
2846 |     }): void;
2847 |     /**
2848 |      * Marks the control as `untouched`.
2849 |      *
2850 |      * If the control has any children, also marks all children as `untouched`
2851 |      * and recalculates the `touched` status of all parent controls.
2852 |      *
2853 |      * @see {@link markAsTouched()}
2854 |      * @see {@link markAsDirty()}
2855 |      * @see {@link markAsPristine()}
2856 |      *
2857 |      * @param opts Configuration options that determine how the control propagates changes
2858 |      * and emits events after the marking is applied.
2859 |      * * `onlySelf`: When true, mark only this control. When false or not supplied,
2860 |      * marks all direct ancestors. Default is false.
2861 |      * * `emitEvent`: When true or not supplied (the default), the `events`
2862 |      * observable emits a `TouchedChangeEvent` with the `touched` property being `false`.
2863 |      * When false, no events are emitted.
2864 |      */
2865 |     markAsUntouched(opts?: {
2866 |         onlySelf?: boolean;
2867 |         emitEvent?: boolean;
2868 |     }): void;
2869 |     /**
2870 |      * Marks the control as `dirty`. A control becomes dirty when
2871 |      * the control's value is changed through the UI; compare `markAsTouched`.
2872 |      *
2873 |      * @see {@link markAsTouched()}
2874 |      * @see {@link markAsUntouched()}
2875 |      * @see {@link markAsPristine()}
2876 |      *
2877 |      * @param opts Configuration options that determine how the control propagates changes
2878 |      * and emits events after marking is applied.
2879 |      * * `onlySelf`: When true, mark only this control. When false or not supplied,
2880 |      * marks all direct ancestors. Default is false.
2881 |      * * `emitEvent`: When true or not supplied (the default), the `events`
2882 |      * observable emits a `PristineChangeEvent` with the `pristine` property being `false`.
2883 |      * When false, no events are emitted.
2884 |      */
2885 |     markAsDirty(opts?: {
2886 |         onlySelf?: boolean;
2887 |         emitEvent?: boolean;
2888 |     }): void;
2889 |     /**
2890 |      * Marks the control as `pristine`.
2891 |      *
2892 |      * If the control has any children, marks all children as `pristine`,
2893 |      * and recalculates the `pristine` status of all parent
2894 |      * controls.
2895 |      *
2896 |      * @see {@link markAsTouched()}
2897 |      * @see {@link markAsUntouched()}
2898 |      * @see {@link markAsDirty()}
2899 |      *
2900 |      * @param opts Configuration options that determine how the control emits events after
2901 |      * marking is applied.
2902 |      * * `onlySelf`: When true, mark only this control. When false or not supplied,
2903 |      * marks all direct ancestors. Default is false.
2904 |      * * `emitEvent`: When true or not supplied (the default), the `events`
2905 |      * observable emits a `PristineChangeEvent` with the `pristine` property being `true`.
2906 |      * When false, no events are emitted.
2907 |      */
2908 |     markAsPristine(opts?: {
2909 |         onlySelf?: boolean;
2910 |         emitEvent?: boolean;
2911 |     }): void;
2912 |     /**
2913 |      * Marks the control as `pending`.
2914 |      *
2915 |      * A control is pending while the control performs async validation.
2916 |      *
2917 |      * @see {@link AbstractControl.status}
2918 |      *
2919 |      * @param opts Configuration options that determine how the control propagates changes and
2920 |      * emits events after marking is applied.
2921 |      * * `onlySelf`: When true, mark only this control. When false or not supplied,
2922 |      * marks all direct ancestors. Default is false.
2923 |      * * `emitEvent`: When true or not supplied (the default), the `statusChanges`
2924 |      * observable emits an event with the latest status the control is marked pending
2925 |      * and the `events` observable emits a `StatusChangeEvent` with the `status` property being
2926 |      * `PENDING` When false, no events are emitted.
2927 |      *
2928 |      */
2929 |     markAsPending(opts?: {
2930 |         onlySelf?: boolean;
2931 |         emitEvent?: boolean;
2932 |     }): void;
2933 |     /**
2934 |      * Disables the control. This means the control is exempt from validation checks and
2935 |      * excluded from the aggregate value of any parent. Its status is `DISABLED`.
2936 |      *
2937 |      * If the control has children, all children are also disabled.
2938 |      *
2939 |      * @see {@link AbstractControl.status}
2940 |      *
2941 |      * @param opts Configuration options that determine how the control propagates
2942 |      * changes and emits events after the control is disabled.
2943 |      * * `onlySelf`: When true, mark only this control. When false or not supplied,
2944 |      * marks all direct ancestors. Default is false.
2945 |      * * `emitEvent`: When true or not supplied (the default), the `statusChanges`,
2946 |      * `valueChanges` and `events`
2947 |      * observables emit events with the latest status and value when the control is disabled.
2948 |      * When false, no events are emitted.
2949 |      */
2950 |     disable(opts?: {
2951 |         onlySelf?: boolean;
2952 |         emitEvent?: boolean;
2953 |     }): void;
2954 |     /**
2955 |      * Enables the control. This means the control is included in validation checks and
2956 |      * the aggregate value of its parent. Its status recalculates based on its value and
2957 |      * its validators.
2958 |      *
2959 |      * By default, if the control has children, all children are enabled.
2960 |      *
2961 |      * @see {@link AbstractControl.status}
2962 |      *
2963 |      * @param opts Configure options that control how the control propagates changes and
2964 |      * emits events when marked as untouched
2965 |      * * `onlySelf`: When true, mark only this control. When false or not supplied,
2966 |      * marks all direct ancestors. Default is false.
2967 |      * * `emitEvent`: When true or not supplied (the default), the `statusChanges`,
2968 |      * `valueChanges` and `events`
2969 |      * observables emit events with the latest status and value when the control is enabled.
2970 |      * When false, no events are emitted.
2971 |      */
2972 |     enable(opts?: {
2973 |         onlySelf?: boolean;
2974 |         emitEvent?: boolean;
2975 |     }): void;
2976 |     private _updateAncestors;
2977 |     /**
2978 |      * Sets the parent of the control
2979 |      *
2980 |      * @param parent The new parent.
2981 |      */
2982 |     setParent(parent: FormGroup | FormArray | null): void;
2983 |     /**
2984 |      * Sets the value of the control. Abstract method (implemented in sub-classes).
2985 |      */
2986 |     abstract setValue(value: TRawValue, options?: Object): void;
2987 |     /**
2988 |      * Patches the value of the control. Abstract method (implemented in sub-classes).
2989 |      */
2990 |     abstract patchValue(value: TValue, options?: Object): void;
2991 |     /**
2992 |      * Resets the control. Abstract method (implemented in sub-classes).
2993 |      */
2994 |     abstract reset(value?: TValueWithOptionalControlStates, options?: Object): void;
2995 |     /**
2996 |      * The raw value of this control. For most control implementations, the raw value will include
2997 |      * disabled children.
2998 |      */
2999 |     getRawValue(): any;
3000 |     /**
3001 |      * Recalculates the value and validation status of the control.
3002 |      *
3003 |      * By default, it also updates the value and validity of its ancestors.
3004 |      *
3005 |      * @param opts Configuration options determine how the control propagates changes and emits events
3006 |      * after updates and validity checks are applied.
3007 |      * * `onlySelf`: When true, only update this control. When false or not supplied,
3008 |      * update all direct ancestors. Default is false.
3009 |      * * `emitEvent`: When true or not supplied (the default), the `statusChanges`,
3010 |      * `valueChanges` and `events`
3011 |      * observables emit events with the latest status and value when the control is updated.
3012 |      * When false, no events are emitted.
3013 |      */
3014 |     updateValueAndValidity(opts?: {
3015 |         onlySelf?: boolean;
3016 |         emitEvent?: boolean;
3017 |     }): void;
3018 |     private _setInitialStatus;
3019 |     private _runValidator;
3020 |     private _runAsyncValidator;
3021 |     private _cancelExistingSubscription;
3022 |     /**
3023 |      * Sets errors on a form control when running validations manually, rather than automatically.
3024 |      *
3025 |      * Calling `setErrors` also updates the validity of the parent control.
3026 |      *
3027 |      * @param opts Configuration options that determine how the control propagates
3028 |      * changes and emits events after the control errors are set.
3029 |      * * `emitEvent`: When true or not supplied (the default), the `statusChanges`
3030 |      * observable emits an event after the errors are set.
3031 |      *
3032 |      * @usageNotes
3033 |      *
3034 |      * ### Manually set the errors for a control
3035 |      *
3036 |      * ```ts
3037 |      * const login = new FormControl('someLogin');
3038 |      * login.setErrors({
3039 |      *   notUnique: true
3040 |      * });
3041 |      *
3042 |      * expect(login.valid).toEqual(false);
3043 |      * expect(login.errors).toEqual({ notUnique: true });
3044 |      *
3045 |      * login.setValue('someOtherLogin');
3046 |      *
3047 |      * expect(login.valid).toEqual(true);
3048 |      * ```
3049 |      */
3050 |     setErrors(errors: ValidationErrors | null, opts?: {
3051 |         emitEvent?: boolean;
3052 |     }): void;
3053 |     /**
3054 |      * Retrieves a child control given the control's name or path.
3055 |      *
3056 |      * This signature for get supports strings and `const` arrays (`.get(['foo', 'bar'] as const)`).
3057 |      */
3058 |     get<P extends string | readonly (string | number)[]>(path: P): AbstractControl<ɵGetProperty<TRawValue, P>> | null;
3059 |     /**
3060 |      * Retrieves a child control given the control's name or path.
3061 |      *
3062 |      * This signature for `get` supports non-const (mutable) arrays. Inferred type
3063 |      * information will not be as robust, so prefer to pass a `readonly` array if possible.
3064 |      */
3065 |     get<P extends string | Array<string | number>>(path: P): AbstractControl<ɵGetProperty<TRawValue, P>> | null;
3066 |     /**
3067 |      * @description
3068 |      * Reports error data for the control with the given path.
3069 |      *
3070 |      * @param errorCode The code of the error to check
3071 |      * @param path A list of control names that designates how to move from the current control
3072 |      * to the control that should be queried for errors.
3073 |      *
3074 |      * @usageNotes
3075 |      * For example, for the following `FormGroup`:
3076 |      *
3077 |      * ```ts
3078 |      * form = new FormGroup({
3079 |      *   address: new FormGroup({ street: new FormControl() })
3080 |      * });
3081 |      * ```
3082 |      *
3083 |      * The path to the 'street' control from the root form would be 'address' -> 'street'.
3084 |      *
3085 |      * It can be provided to this method in one of two formats:
3086 |      *
3087 |      * 1. An array of string control names, e.g. `['address', 'street']`
3088 |      * 1. A period-delimited list of control names in one string, e.g. `'address.street'`
3089 |      *
3090 |      * @returns error data for that particular error. If the control or error is not present,
3091 |      * null is returned.
3092 |      */
3093 |     getError(errorCode: string, path?: Array<string | number> | string): any;
3094 |     /**
3095 |      * @description
3096 |      * Reports whether the control with the given path has the error specified.
3097 |      *
3098 |      * @param errorCode The code of the error to check
3099 |      * @param path A list of control names that designates how to move from the current control
3100 |      * to the control that should be queried for errors.
3101 |      *
3102 |      * @usageNotes
3103 |      * For example, for the following `FormGroup`:
3104 |      *
3105 |      * ```ts
3106 |      * form = new FormGroup({
3107 |      *   address: new FormGroup({ street: new FormControl() })
3108 |      * });
3109 |      * ```
3110 |      *
3111 |      * The path to the 'street' control from the root form would be 'address' -> 'street'.
3112 |      *
3113 |      * It can be provided to this method in one of two formats:
3114 |      *
3115 |      * 1. An array of string control names, e.g. `['address', 'street']`
3116 |      * 1. A period-delimited list of control names in one string, e.g. `'address.street'`
3117 |      *
3118 |      * If no path is given, this method checks for the error on the current control.
3119 |      *
3120 |      * @returns whether the given error is present in the control at the given path.
3121 |      *
3122 |      * If the control is not present, false is returned.
3123 |      */
3124 |     hasError(errorCode: string, path?: Array<string | number> | string): boolean;
3125 |     /**
3126 |      * Retrieves the top-level ancestor of this control.
3127 |      */
3128 |     get root(): AbstractControl;
3129 |     private _calculateStatus;
3130 |     /**
3131 |      * Internal implementation of the `setValidators` method. Needs to be separated out into a
3132 |      * different method, because it is called in the constructor and it can break cases where
3133 |      * a control is extended.
3134 |      */
3135 |     private _assignValidators;
3136 |     /**
3137 |      * Internal implementation of the `setAsyncValidators` method. Needs to be separated out into a
3138 |      * different method, because it is called in the constructor and it can break cases where
3139 |      * a control is extended.
3140 |      */
3141 |     private _assignAsyncValidators;
3142 | }
3143 | 
3144 | /**
3145 |  * @description
3146 |  * Base class for control directives.
3147 |  *
3148 |  * This class is only used internally in the `ReactiveFormsModule` and the `FormsModule`.
3149 |  *
3150 |  * @publicApi
3151 |  */
3152 | declare abstract class AbstractControlDirective {
3153 |     /**
3154 |      * @description
3155 |      * A reference to the underlying control.
3156 |      *
3157 |      * @returns the control that backs this directive. Most properties fall through to that instance.
3158 |      */
3159 |     abstract get control(): AbstractControl | null;
3160 |     /**
3161 |      * @description
3162 |      * Reports the value of the control if it is present, otherwise null.
3163 |      */
3164 |     get value(): any;
3165 |     /**
3166 |      * @description
3167 |      * Reports whether the control is valid. A control is considered valid if no
3168 |      * validation errors exist with the current value.
3169 |      * If the control is not present, null is returned.
3170 |      */
3171 |     get valid(): boolean | null;
3172 |     /**
3173 |      * @description
3174 |      * Reports whether the control is invalid, meaning that an error exists in the input value.
3175 |      * If the control is not present, null is returned.
3176 |      */
3177 |     get invalid(): boolean | null;
3178 |     /**
3179 |      * @description
3180 |      * Reports whether a control is pending, meaning that async validation is occurring and
3181 |      * errors are not yet available for the input value. If the control is not present, null is
3182 |      * returned.
3183 |      */
3184 |     get pending(): boolean | null;
3185 |     /**
3186 |      * @description
3187 |      * Reports whether the control is disabled, meaning that the control is disabled
3188 |      * in the UI and is exempt from validation checks and excluded from aggregate
3189 |      * values of ancestor controls. If the control is not present, null is returned.
3190 |      */
3191 |     get disabled(): boolean | null;
3192 |     /**
3193 |      * @description
3194 |      * Reports whether the control is enabled, meaning that the control is included in ancestor
3195 |      * calculations of validity or value. If the control is not present, null is returned.
3196 |      */
3197 |     get enabled(): boolean | null;
3198 |     /**
3199 |      * @description
3200 |      * Reports the control's validation errors. If the control is not present, null is returned.
3201 |      */
3202 |     get errors(): ValidationErrors | null;
3203 |     /**
3204 |      * @description
3205 |      * Reports whether the control is pristine, meaning that the user has not yet changed
3206 |      * the value in the UI. If the control is not present, null is returned.
3207 |      */
3208 |     get pristine(): boolean | null;
3209 |     /**
3210 |      * @description
3211 |      * Reports whether the control is dirty, meaning that the user has changed
3212 |      * the value in the UI. If the control is not present, null is returned.
3213 |      */
3214 |     get dirty(): boolean | null;
3215 |     /**
3216 |      * @description
3217 |      * Reports whether the control is touched, meaning that the user has triggered
3218 |      * a `blur` event on it. If the control is not present, null is returned.
3219 |      */
3220 |     get touched(): boolean | null;
3221 |     /**
3222 |      * @description
3223 |      * Reports the validation status of the control. Possible values include:
3224 |      * 'VALID', 'INVALID', 'DISABLED', and 'PENDING'.
3225 |      * If the control is not present, null is returned.
3226 |      */
3227 |     get status(): string | null;
3228 |     /**
3229 |      * @description
3230 |      * Reports whether the control is untouched, meaning that the user has not yet triggered
3231 |      * a `blur` event on it. If the control is not present, null is returned.
3232 |      */
3233 |     get untouched(): boolean | null;
3234 |     /**
3235 |      * @description
3236 |      * Returns a multicasting observable that emits a validation status whenever it is
3237 |      * calculated for the control. If the control is not present, null is returned.
3238 |      */
3239 |     get statusChanges(): Observable<any> | null;
3240 |     /**
3241 |      * @description
3242 |      * Returns a multicasting observable of value changes for the control that emits every time the
3243 |      * value of the control changes in the UI or programmatically.
3244 |      * If the control is not present, null is returned.
3245 |      */
3246 |     get valueChanges(): Observable<any> | null;
3247 |     /**
3248 |      * @description
3249 |      * Returns an array that represents the path from the top-level form to this control.
3250 |      * Each index is the string name of the control on that level.
3251 |      */
3252 |     get path(): string[] | null;
3253 |     /**
3254 |      * Contains the result of merging synchronous validators into a single validator function
3255 |      * (combined using `Validators.compose`).
3256 |      */
3257 |     private _composedValidatorFn;
3258 |     /**
3259 |      * Contains the result of merging asynchronous validators into a single validator function
3260 |      * (combined using `Validators.composeAsync`).
3261 |      */
3262 |     private _composedAsyncValidatorFn;
3263 |     /**
3264 |      * @description
3265 |      * Synchronous validator function composed of all the synchronous validators registered with this
3266 |      * directive.
3267 |      */
3268 |     get validator(): ValidatorFn | null;
3269 |     /**
3270 |      * @description
3271 |      * Asynchronous validator function composed of all the asynchronous validators registered with
3272 |      * this directive.
3273 |      */
3274 |     get asyncValidator(): AsyncValidatorFn | null;
3275 |     private _onDestroyCallbacks;
3276 |     /**
3277 |      * @description
3278 |      * Resets the control with the provided value if the control is present.
3279 |      */
3280 |     reset(value?: any): void;
3281 |     /**
3282 |      * @description
3283 |      * Reports whether the control with the given path has the error specified.
3284 |      *
3285 |      * @param errorCode The code of the error to check
3286 |      * @param path A list of control names that designates how to move from the current control
3287 |      * to the control that should be queried for errors.
3288 |      *
3289 |      * @usageNotes
3290 |      * For example, for the following `FormGroup`:
3291 |      *
3292 |      * ```ts
3293 |      * form = new FormGroup({
3294 |      *   address: new FormGroup({ street: new FormControl() })
3295 |      * });
3296 |      * ```
3297 |      *
3298 |      * The path to the 'street' control from the root form would be 'address' -> 'street'.
3299 |      *
3300 |      * It can be provided to this method in one of two formats:
3301 |      *
3302 |      * 1. An array of string control names, e.g. `['address', 'street']`
3303 |      * 1. A period-delimited list of control names in one string, e.g. `'address.street'`
3304 |      *
3305 |      * If no path is given, this method checks for the error on the current control.
3306 |      *
3307 |      * @returns whether the given error is present in the control at the given path.
3308 |      *
3309 |      * If the control is not present, false is returned.
3310 |      */
3311 |     hasError(errorCode: string, path?: Array<string | number> | string): boolean;
3312 |     /**
3313 |      * @description
3314 |      * Reports error data for the control with the given path.
3315 |      *
3316 |      * @param errorCode The code of the error to check
3317 |      * @param path A list of control names that designates how to move from the current control
3318 |      * to the control that should be queried for errors.
3319 |      *
3320 |      * @usageNotes
3321 |      * For example, for the following `FormGroup`:
3322 |      *
3323 |      * ```ts
3324 |      * form = new FormGroup({
3325 |      *   address: new FormGroup({ street: new FormControl() })
3326 |      * });
3327 |      * ```
3328 |      *
3329 |      * The path to the 'street' control from the root form would be 'address' -> 'street'.
3330 |      *
3331 |      * It can be provided to this method in one of two formats:
3332 |      *
3333 |      * 1. An array of string control names, e.g. `['address', 'street']`
3334 |      * 1. A period-delimited list of control names in one string, e.g. `'address.street'`
3335 |      *
3336 |      * @returns error data for that particular error. If the control or error is not present,
3337 |      * null is returned.
3338 |      */
3339 |     getError(errorCode: string, path?: Array<string | number> | string): any;
3340 | }
3341 | 
3342 | /**
3343 |  * @description
3344 |  * A base class that all `FormControl`-based directives extend. It binds a `FormControl`
3345 |  * object to a DOM element.
3346 |  *
3347 |  * @publicApi
3348 |  */
3349 | declare abstract class NgControl extends AbstractControlDirective {
3350 |     /**
3351 |      * @description
3352 |      * The name for the control
3353 |      */
3354 |     name: string | number | null;
3355 |     /**
3356 |      * @description
3357 |      * The value accessor for the control
3358 |      */
3359 |     valueAccessor: ControlValueAccessor | null;
3360 |     /**
3361 |      * @description
3362 |      * The callback method to update the model from the view when requested
3363 |      *
3364 |      * @param newValue The new value for the view
3365 |      */
3366 |     abstract viewToModelUpdate(newValue: any): void;
3367 | }
3368 | 
3369 | /**
3370 |  * @description
3371 |  * Class used by Angular to track radio buttons. For internal use only.
3372 |  */
3373 | declare class RadioControlRegistry {
3374 |     private _accessors;
3375 |     /**
3376 |      * @description
3377 |      * Adds a control to the internal registry. For internal use only.
3378 |      */
3379 |     add(control: NgControl, accessor: RadioControlValueAccessor): void;
3380 |     /**
3381 |      * @description
3382 |      * Removes a control from the internal registry. For internal use only.
3383 |      */
3384 |     remove(accessor: RadioControlValueAccessor): void;
3385 |     /**
3386 |      * @description
3387 |      * Selects a radio button. For internal use only.
3388 |      */
3389 |     select(accessor: RadioControlValueAccessor): void;
3390 |     private _isSameGroup;
3391 |     static ɵfac: i0.ɵɵFactoryDeclaration<RadioControlRegistry, never>;
3392 |     static ɵprov: i0.ɵɵInjectableDeclaration<RadioControlRegistry>;
3393 | }
3394 | /**
3395 |  * @description
3396 |  * The `ControlValueAccessor` for writing radio control values and listening to radio control
3397 |  * changes. The value accessor is used by the `FormControlDirective`, `FormControlName`, and
3398 |  * `NgModel` directives.
3399 |  *
3400 |  * @usageNotes
3401 |  *
3402 |  * ### Using radio buttons with reactive form directives
3403 |  *
3404 |  * The follow example shows how to use radio buttons in a reactive form. When using radio buttons in
3405 |  * a reactive form, radio buttons in the same group should have the same `formControlName`.
3406 |  * Providing a `name` attribute is optional.
3407 |  *
3408 |  * {@example forms/ts/reactiveRadioButtons/reactive_radio_button_example.ts region='Reactive'}
3409 |  *
3410 |  * @ngModule ReactiveFormsModule
3411 |  * @ngModule FormsModule
3412 |  * @publicApi
3413 |  */
3414 | declare class RadioControlValueAccessor extends BuiltInControlValueAccessor implements ControlValueAccessor, OnDestroy, OnInit {
3415 |     private _registry;
3416 |     private _injector;
3417 |     private setDisabledStateFired;
3418 |     /**
3419 |      * The registered callback function called when a change event occurs on the input element.
3420 |      * Note: we declare `onChange` here (also used as host listener) as a function with no arguments
3421 |      * to override the `onChange` function (which expects 1 argument) in the parent
3422 |      * `BaseControlValueAccessor` class.
3423 |      * @docs-private
3424 |      */
3425 |     onChange: () => void;
3426 |     /**
3427 |      * @description
3428 |      * Tracks the name of the radio input element.
3429 |      */
3430 |     name: string;
3431 |     /**
3432 |      * @description
3433 |      * Tracks the name of the `FormControl` bound to the directive. The name corresponds
3434 |      * to a key in the parent `FormGroup` or `FormArray`.
3435 |      */
3436 |     formControlName: string;
3437 |     /**
3438 |      * @description
3439 |      * Tracks the value of the radio input element
3440 |      */
3441 |     value: any;
3442 |     private callSetDisabledState;
3443 |     constructor(renderer: Renderer2, elementRef: ElementRef, _registry: RadioControlRegistry, _injector: Injector);
3444 |     /** @docs-private */
3445 |     ngOnInit(): void;
3446 |     /** @docs-private */
3447 |     ngOnDestroy(): void;
3448 |     /**
3449 |      * Sets the "checked" property value on the radio input element.
3450 |      * @docs-private
3451 |      */
3452 |     writeValue(value: any): void;
3453 |     /**
3454 |      * Registers a function called when the control value changes.
3455 |      * @docs-private
3456 |      */
3457 |     registerOnChange(fn: (_: any) => {}): void;
3458 |     /** @docs-private */
3459 |     setDisabledState(isDisabled: boolean): void;
3460 |     /**
3461 |      * Sets the "value" on the radio input element and unchecks it.
3462 |      *
3463 |      * @param value
3464 |      */
3465 |     fireUncheck(value: any): void;
3466 |     private _checkName;
3467 |     static ɵfac: i0.ɵɵFactoryDeclaration<RadioControlValueAccessor, never>;
3468 |     static ɵdir: i0.ɵɵDirectiveDeclaration<RadioControlValueAccessor, "input[type=radio][formControlName],input[type=radio][formControl],input[type=radio][ngModel]", never, { "name": { "alias": "name"; "required": false; }; "formControlName": { "alias": "formControlName"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, never, false, never>;
3469 | }
3470 | 
3471 | /**
3472 |  * @description
3473 |  * A base class for code shared between the `NgModelGroup` and `FormGroupName` directives.
3474 |  *
3475 |  * @publicApi
3476 |  */
3477 | declare class AbstractFormGroupDirective extends ControlContainer implements OnInit, OnDestroy {
3478 |     /** @docs-private */
3479 |     ngOnInit(): void;
3480 |     /** @docs-private */
3481 |     ngOnDestroy(): void;
3482 |     /**
3483 |      * @description
3484 |      * The `FormGroup` bound to this directive.
3485 |      */
3486 |     get control(): FormGroup;
3487 |     /**
3488 |      * @description
3489 |      * The path to this group from the top-level directive.
3490 |      */
3491 |     get path(): string[];
3492 |     /**
3493 |      * @description
3494 |      * The top-level directive for this group if present, otherwise null.
3495 |      */
3496 |     get formDirective(): Form | null;
3497 |     static ɵfac: i0.ɵɵFactoryDeclaration<AbstractFormGroupDirective, never>;
3498 |     static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractFormGroupDirective, never, never, {}, {}, never, never, false, never>;
3499 | }
3500 | 
3501 | /**
3502 |  * @description
3503 |  * An interface implemented by `FormGroupDirective` and `NgForm` directives.
3504 |  *
3505 |  * Only used by the `ReactiveFormsModule` and `FormsModule`.
3506 |  *
3507 |  * @publicApi
3508 |  */
3509 | interface Form {
3510 |     /**
3511 |      * @description
3512 |      * Add a control to this form.
3513 |      *
3514 |      * @param dir The control directive to add to the form.
3515 |      */
3516 |     addControl(dir: NgControl): void;
3517 |     /**
3518 |      * @description
3519 |      * Remove a control from this form.
3520 |      *
3521 |      * @param dir: The control directive to remove from the form.
3522 |      */
3523 |     removeControl(dir: NgControl): void;
3524 |     /**
3525 |      * @description
3526 |      * The control directive from which to get the `FormControl`.
3527 |      *
3528 |      * @param dir: The control directive.
3529 |      */
3530 |     getControl(dir: NgControl): FormControl;
3531 |     /**
3532 |      * @description
3533 |      * Add a group of controls to this form.
3534 |      *
3535 |      * @param dir: The control group directive to add.
3536 |      */
3537 |     addFormGroup(dir: AbstractFormGroupDirective): void;
3538 |     /**
3539 |      * @description
3540 |      * Remove a group of controls to this form.
3541 |      *
3542 |      * @param dir: The control group directive to remove.
3543 |      */
3544 |     removeFormGroup(dir: AbstractFormGroupDirective): void;
3545 |     /**
3546 |      * @description
3547 |      * The `FormGroup` associated with a particular `AbstractFormGroupDirective`.
3548 |      *
3549 |      * @param dir: The form group directive from which to get the `FormGroup`.
3550 |      */
3551 |     getFormGroup(dir: AbstractFormGroupDirective): FormGroup;
3552 |     /**
3553 |      * @description
3554 |      * Update the model for a particular control with a new value.
3555 |      *
3556 |      * @param dir: The control directive to update.
3557 |      * @param value: The new value for the control.
3558 |      */
3559 |     updateModel(dir: NgControl, value: any): void;
3560 | }
3561 | 
3562 | /**
3563 |  * @description
3564 |  * A base class for directives that contain multiple registered instances of `NgControl`.
3565 |  * Only used by the forms module.
3566 |  *
3567 |  * @publicApi
3568 |  */
3569 | declare abstract class ControlContainer extends AbstractControlDirective {
3570 |     /**
3571 |      * @description
3572 |      * The name for the control
3573 |      */
3574 |     name: string | number | null;
3575 |     /**
3576 |      * @description
3577 |      * The top-level form directive for the control.
3578 |      */
3579 |     get formDirective(): Form | null;
3580 |     /**
3581 |      * @description
3582 |      * The path to this group.
3583 |      */
3584 |     get path(): string[] | null;
3585 | }
3586 | 
3587 | declare class AbstractControlStatus {
3588 |     private _cd;
3589 |     constructor(cd: AbstractControlDirective | null);
3590 |     protected get isTouched(): boolean;
3591 |     protected get isUntouched(): boolean;
3592 |     protected get isPristine(): boolean;
3593 |     protected get isDirty(): boolean;
3594 |     protected get isValid(): boolean;
3595 |     protected get isInvalid(): boolean;
3596 |     protected get isPending(): boolean;
3597 |     protected get isSubmitted(): boolean;
3598 | }
3599 | /**
3600 |  * @description
3601 |  * Directive automatically applied to Angular form controls that sets CSS classes
3602 |  * based on control status.
3603 |  *
3604 |  * @usageNotes
3605 |  *
3606 |  * ### CSS classes applied
3607 |  *
3608 |  * The following classes are applied as the properties become true:
3609 |  *
3610 |  * * ng-valid
3611 |  * * ng-invalid
3612 |  * * ng-pending
3613 |  * * ng-pristine
3614 |  * * ng-dirty
3615 |  * * ng-untouched
3616 |  * * ng-touched
3617 |  *
3618 |  * @ngModule ReactiveFormsModule
3619 |  * @ngModule FormsModule
3620 |  * @publicApi
3621 |  */
3622 | declare class NgControlStatus extends AbstractControlStatus {
3623 |     constructor(cd: NgControl);
3624 |     static ɵfac: i0.ɵɵFactoryDeclaration<NgControlStatus, [{ self: true; }]>;
3625 |     static ɵdir: i0.ɵɵDirectiveDeclaration<NgControlStatus, "[formControlName],[ngModel],[formControl]", never, {}, {}, never, never, false, never>;
3626 | }
3627 | /**
3628 |  * @description
3629 |  * Directive automatically applied to Angular form groups that sets CSS classes
3630 |  * based on control status (valid/invalid/dirty/etc). On groups, this includes the additional
3631 |  * class ng-submitted.
3632 |  *
3633 |  * @see {@link NgControlStatus}
3634 |  *
3635 |  * @ngModule ReactiveFormsModule
3636 |  * @ngModule FormsModule
3637 |  * @publicApi
3638 |  */
3639 | declare class NgControlStatusGroup extends AbstractControlStatus {
3640 |     constructor(cd: ControlContainer);
3641 |     static ɵfac: i0.ɵɵFactoryDeclaration<NgControlStatusGroup, [{ optional: true; self: true; }]>;
3642 |     static ɵdir: i0.ɵɵDirectiveDeclaration<NgControlStatusGroup, "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]", never, {}, {}, never, never, false, never>;
3643 | }
3644 | 
3645 | /**
3646 |  * @description
3647 |  * Syncs a `FormControl` in an existing `FormGroup` to a form control
3648 |  * element by name.
3649 |  *
3650 |  * @see [Reactive Forms Guide](guide/forms/reactive-forms)
3651 |  * @see {@link FormControl}
3652 |  * @see {@link AbstractControl}
3653 |  *
3654 |  * @usageNotes
3655 |  *
3656 |  * ### Register `FormControl` within a group
3657 |  *
3658 |  * The following example shows how to register multiple form controls within a form group
3659 |  * and set their value.
3660 |  *
3661 |  * {@example forms/ts/simpleFormGroup/simple_form_group_example.ts region='Component'}
3662 |  *
3663 |  * To see `formControlName` examples with different form control types, see:
3664 |  *
3665 |  * * Radio buttons: `RadioControlValueAccessor`
3666 |  * * Selects: `SelectControlValueAccessor`
3667 |  *
3668 |  * ### Use with ngModel is deprecated
3669 |  *
3670 |  * Support for using the `ngModel` input property and `ngModelChange` event with reactive
3671 |  * form directives has been deprecated in Angular v6 and is scheduled for removal in
3672 |  * a future version of Angular.
3673 |  *
3674 |  * @ngModule ReactiveFormsModule
3675 |  * @publicApi
3676 |  */
3677 | declare class FormControlName extends NgControl implements OnChanges, OnDestroy {
3678 |     private _ngModelWarningConfig;
3679 |     private _added;
3680 |     /**
3681 |      * @description
3682 |      * Tracks the `FormControl` instance bound to the directive.
3683 |      */
3684 |     readonly control: FormControl;
3685 |     /**
3686 |      * @description
3687 |      * Tracks the name of the `FormControl` bound to the directive. The name corresponds
3688 |      * to a key in the parent `FormGroup` or `FormArray`.
3689 |      * Accepts a name as a string or a number.
3690 |      * The name in the form of a string is useful for individual forms,
3691 |      * while the numerical form allows for form controls to be bound
3692 |      * to indices when iterating over controls in a `FormArray`.
3693 |      */
3694 |     name: string | number | null;
3695 |     /**
3696 |      * @description
3697 |      * Triggers a warning in dev mode that this input should not be used with reactive forms.
3698 |      */
3699 |     set isDisabled(isDisabled: boolean);
3700 |     /** @deprecated as of v6 */
3701 |     model: any;
3702 |     /** @deprecated as of v6 */
3703 |     update: EventEmitter<any>;
3704 |     constructor(parent: ControlContainer, validators: (Validator | ValidatorFn)[], asyncValidators: (AsyncValidator | AsyncValidatorFn)[], valueAccessors: ControlValueAccessor[], _ngModelWarningConfig: string | null);
3705 |     /** @docs-private */
3706 |     ngOnChanges(changes: SimpleChanges): void;
3707 |     /** @docs-private */
3708 |     ngOnDestroy(): void;
3709 |     /**
3710 |      * @description
3711 |      * Sets the new value for the view model and emits an `ngModelChange` event.
3712 |      *
3713 |      * @param newValue The new value for the view model.
3714 |      */
3715 |     viewToModelUpdate(newValue: any): void;
3716 |     /**
3717 |      * @description
3718 |      * Returns an array that represents the path from the top-level form to this control.
3719 |      * Each index is the string name of the control on that level.
3720 |      */
3721 |     get path(): string[];
3722 |     /**
3723 |      * @description
3724 |      * The top-level directive for this group if present, otherwise null.
3725 |      */
3726 |     get formDirective(): any;
3727 |     private _setUpControl;
3728 |     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; }]>;
3729 |     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>;
3730 | }
3731 | 
3732 | /**
3733 |  * @description
3734 |  *
3735 |  * Binds an existing `FormGroup` or `FormRecord` to a DOM element.
3736 |  *
3737 |  * This directive accepts an existing `FormGroup` instance. It will then use this
3738 |  * `FormGroup` instance to match any child `FormControl`, `FormGroup`/`FormRecord`,
3739 |  * and `FormArray` instances to child `FormControlName`, `FormGroupName`,
3740 |  * and `FormArrayName` directives.
3741 |  *
3742 |  * @see [Reactive Forms Guide](guide/forms/reactive-forms)
3743 |  * @see {@link AbstractControl}
3744 |  *
3745 |  * @usageNotes
3746 |  * ### Register Form Group
3747 |  *
3748 |  * The following example registers a `FormGroup` with first name and last name controls,
3749 |  * and listens for the *ngSubmit* event when the button is clicked.
3750 |  *
3751 |  * {@example forms/ts/simpleFormGroup/simple_form_group_example.ts region='Component'}
3752 |  *
3753 |  * @ngModule ReactiveFormsModule
3754 |  * @publicApi
3755 |  */
3756 | declare class FormGroupDirective extends ControlContainer implements Form, OnChanges, OnDestroy {
3757 |     private callSetDisabledState?;
3758 |     /**
3759 |      * @description
3760 |      * Reports whether the form submission has been triggered.
3761 |      */
3762 |     get submitted(): boolean;
3763 |     private set submitted(value);
3764 |     private readonly _submittedReactive;
3765 |     /**
3766 |      * Reference to an old form group input value, which is needed to cleanup
3767 |      * old instance in case it was replaced with a new one.
3768 |      */
3769 |     private _oldForm;
3770 |     /**
3771 |      * Callback that should be invoked when controls in FormGroup or FormArray collection change
3772 |      * (added or removed). This callback triggers corresponding DOM updates.
3773 |      */
3774 |     private readonly _onCollectionChange;
3775 |     /**
3776 |      * @description
3777 |      * Tracks the list of added `FormControlName` instances
3778 |      */
3779 |     directives: FormControlName[];
3780 |     /**
3781 |      * @description
3782 |      * Tracks the `FormGroup` bound to this directive.
3783 |      */
3784 |     form: FormGroup;
3785 |     /**
3786 |      * @description
3787 |      * Emits an event when the form submission has been triggered.
3788 |      */
3789 |     ngSubmit: EventEmitter<any>;
3790 |     constructor(validators: (Validator | ValidatorFn)[], asyncValidators: (AsyncValidator | AsyncValidatorFn)[], callSetDisabledState?: SetDisabledStateOption | undefined);
3791 |     /** @docs-private */
3792 |     ngOnChanges(changes: SimpleChanges): void;
3793 |     /** @docs-private */
3794 |     ngOnDestroy(): void;
3795 |     /**
3796 |      * @description
3797 |      * Returns this directive's instance.
3798 |      */
3799 |     get formDirective(): Form;
3800 |     /**
3801 |      * @description
3802 |      * Returns the `FormGroup` bound to this directive.
3803 |      */
3804 |     get control(): FormGroup;
3805 |     /**
3806 |      * @description
3807 |      * Returns an array representing the path to this group. Because this directive
3808 |      * always lives at the top level of a form, it always an empty array.
3809 |      */
3810 |     get path(): string[];
3811 |     /**
3812 |      * @description
3813 |      * Method that sets up the control directive in this group, re-calculates its value
3814 |      * and validity, and adds the instance to the internal list of directives.
3815 |      *
3816 |      * @param dir The `FormControlName` directive instance.
3817 |      */
3818 |     addControl(dir: FormControlName): FormControl;
3819 |     /**
3820 |      * @description
3821 |      * Retrieves the `FormControl` instance from the provided `FormControlName` directive
3822 |      *
3823 |      * @param dir The `FormControlName` directive instance.
3824 |      */
3825 |     getControl(dir: FormControlName): FormControl;
3826 |     /**
3827 |      * @description
3828 |      * Removes the `FormControlName` instance from the internal list of directives
3829 |      *
3830 |      * @param dir The `FormControlName` directive instance.
3831 |      */
3832 |     removeControl(dir: FormControlName): void;
3833 |     /**
3834 |      * Adds a new `FormGroupName` directive instance to the form.
3835 |      *
3836 |      * @param dir The `FormGroupName` directive instance.
3837 |      */
3838 |     addFormGroup(dir: FormGroupName): void;
3839 |     /**
3840 |      * Performs the necessary cleanup when a `FormGroupName` directive instance is removed from the
3841 |      * view.
3842 |      *
3843 |      * @param dir The `FormGroupName` directive instance.
3844 |      */
3845 |     removeFormGroup(dir: FormGroupName): void;
3846 |     /**
3847 |      * @description
3848 |      * Retrieves the `FormGroup` for a provided `FormGroupName` directive instance
3849 |      *
3850 |      * @param dir The `FormGroupName` directive instance.
3851 |      */
3852 |     getFormGroup(dir: FormGroupName): FormGroup;
3853 |     /**
3854 |      * Performs the necessary setup when a `FormArrayName` directive instance is added to the view.
3855 |      *
3856 |      * @param dir The `FormArrayName` directive instance.
3857 |      */
3858 |     addFormArray(dir: FormArrayName): void;
3859 |     /**
3860 |      * Performs the necessary cleanup when a `FormArrayName` directive instance is removed from the
3861 |      * view.
3862 |      *
3863 |      * @param dir The `FormArrayName` directive instance.
3864 |      */
3865 |     removeFormArray(dir: FormArrayName): void;
3866 |     /**
3867 |      * @description
3868 |      * Retrieves the `FormArray` for a provided `FormArrayName` directive instance.
3869 |      *
3870 |      * @param dir The `FormArrayName` directive instance.
3871 |      */
3872 |     getFormArray(dir: FormArrayName): FormArray;
3873 |     /**
3874 |      * Sets the new value for the provided `FormControlName` directive.
3875 |      *
3876 |      * @param dir The `FormControlName` directive instance.
3877 |      * @param value The new value for the directive's control.
3878 |      */
3879 |     updateModel(dir: FormControlName, value: any): void;
3880 |     /**
3881 |      * @description
3882 |      * Method called with the "submit" event is triggered on the form.
3883 |      * Triggers the `ngSubmit` emitter to emit the "submit" event as its payload.
3884 |      *
3885 |      * @param $event The "submit" event object
3886 |      */
3887 |     onSubmit($event: Event): boolean;
3888 |     /**
3889 |      * @description
3890 |      * Method called when the "reset" event is triggered on the form.
3891 |      */
3892 |     onReset(): void;
3893 |     /**
3894 |      * @description
3895 |      * Resets the form to an initial value and resets its submitted status.
3896 |      *
3897 |      * @param value The new value for the form, `undefined` by default
3898 |      */
3899 |     resetForm(value?: any, options?: {
3900 |         onlySelf?: boolean;
3901 |         emitEvent?: boolean;
3902 |     }): void;
3903 |     private _setUpFormContainer;
3904 |     private _cleanUpFormContainer;
3905 |     private _updateRegistrations;
3906 |     private _updateValidators;
3907 |     static ɵfac: i0.ɵɵFactoryDeclaration<FormGroupDirective, [{ optional: true; self: true; }, { optional: true; self: true; }, { optional: true; }]>;
3908 |     static ɵdir: i0.ɵɵDirectiveDeclaration<FormGroupDirective, "[formGroup]", ["ngForm"], { "form": { "alias": "formGroup"; "required": false; }; }, { "ngSubmit": "ngSubmit"; }, never, never, false, never>;
3909 | }
3910 | 
3911 | /**
3912 |  * @description
3913 |  *
3914 |  * Syncs a nested `FormGroup` or `FormRecord` to a DOM element.
3915 |  *
3916 |  * This directive can only be used with a parent `FormGroupDirective`.
3917 |  *
3918 |  * It accepts the string name of the nested `FormGroup` or `FormRecord` to link, and
3919 |  * looks for a `FormGroup` or `FormRecord` registered with that name in the parent
3920 |  * `FormGroup` instance you passed into `FormGroupDirective`.
3921 |  *
3922 |  * Use nested form groups to validate a sub-group of a
3923 |  * form separately from the rest or to group the values of certain
3924 |  * controls into their own nested object.
3925 |  *
3926 |  * @see [Reactive Forms Guide](guide/forms/reactive-forms)
3927 |  *
3928 |  * @usageNotes
3929 |  *
3930 |  * ### Access the group by name
3931 |  *
3932 |  * The following example uses the `AbstractControl.get` method to access the
3933 |  * associated `FormGroup`
3934 |  *
3935 |  * ```ts
3936 |  *   this.form.get('name');
3937 |  * ```
3938 |  *
3939 |  * ### Access individual controls in the group
3940 |  *
3941 |  * The following example uses the `AbstractControl.get` method to access
3942 |  * individual controls within the group using dot syntax.
3943 |  *
3944 |  * ```ts
3945 |  *   this.form.get('name.first');
3946 |  * ```
3947 |  *
3948 |  * ### Register a nested `FormGroup`.
3949 |  *
3950 |  * The following example registers a nested *name* `FormGroup` within an existing `FormGroup`,
3951 |  * and provides methods to retrieve the nested `FormGroup` and individual controls.
3952 |  *
3953 |  * {@example forms/ts/nestedFormGroup/nested_form_group_example.ts region='Component'}
3954 |  *
3955 |  * @ngModule ReactiveFormsModule
3956 |  * @publicApi
3957 |  */
3958 | declare class FormGroupName extends AbstractFormGroupDirective implements OnInit, OnDestroy {
3959 |     /**
3960 |      * @description
3961 |      * Tracks the name of the `FormGroup` bound to the directive. The name corresponds
3962 |      * to a key in the parent `FormGroup` or `FormArray`.
3963 |      * Accepts a name as a string or a number.
3964 |      * The name in the form of a string is useful for individual forms,
3965 |      * while the numerical form allows for form groups to be bound
3966 |      * to indices when iterating over groups in a `FormArray`.
3967 |      */
3968 |     name: string | number | null;
3969 |     constructor(parent: ControlContainer, validators: (Validator | ValidatorFn)[], asyncValidators: (AsyncValidator | AsyncValidatorFn)[]);
3970 |     static ɵfac: i0.ɵɵFactoryDeclaration<FormGroupName, [{ optional: true; host: true; skipSelf: true; }, { optional: true; self: true; }, { optional: true; self: true; }]>;
3971 |     static ɵdir: i0.ɵɵDirectiveDeclaration<FormGroupName, "[formGroupName]", never, { "name": { "alias": "formGroupName"; "required": false; }; }, {}, never, never, false, never>;
3972 | }
3973 | /**
3974 |  * @description
3975 |  *
3976 |  * Syncs a nested `FormArray` to a DOM element.
3977 |  *
3978 |  * This directive is designed to be used with a parent `FormGroupDirective` (selector:
3979 |  * `[formGroup]`).
3980 |  *
3981 |  * It accepts the string name of the nested `FormArray` you want to link, and
3982 |  * will look for a `FormArray` registered with that name in the parent
3983 |  * `FormGroup` instance you passed into `FormGroupDirective`.
3984 |  *
3985 |  * @see [Reactive Forms Guide](guide/forms/reactive-forms)
3986 |  * @see {@link AbstractControl}
3987 |  *
3988 |  * @usageNotes
3989 |  *
3990 |  * ### Example
3991 |  *
3992 |  * {@example forms/ts/nestedFormArray/nested_form_array_example.ts region='Component'}
3993 |  *
3994 |  * @ngModule ReactiveFormsModule
3995 |  * @publicApi
3996 |  */
3997 | declare class FormArrayName extends ControlContainer implements OnInit, OnDestroy {
3998 |     /**
3999 |      * @description
4000 |      * Tracks the name of the `FormArray` bound to the directive. The name corresponds
4001 |      * to a key in the parent `FormGroup` or `FormArray`.
4002 |      * Accepts a name as a string or a number.
4003 |      * The name in the form of a string is useful for individual forms,
4004 |      * while the numerical form allows for form arrays to be bound
4005 |      * to indices when iterating over arrays in a `FormArray`.
4006 |      */
4007 |     name: string | number | null;
4008 |     constructor(parent: ControlContainer, validators: (Validator | ValidatorFn)[], asyncValidators: (AsyncValidator | AsyncValidatorFn)[]);
4009 |     /**
4010 |      * A lifecycle method called when the directive's inputs are initialized. For internal use only.
4011 |      * @throws If the directive does not have a valid parent.
4012 |      * @docs-private
4013 |      */
4014 |     ngOnInit(): void;
4015 |     /**
4016 |      * A lifecycle method called before the directive's instance is destroyed. For internal use only.
4017 |      * @docs-private
4018 |      */
4019 |     ngOnDestroy(): void;
4020 |     /**
4021 |      * @description
4022 |      * The `FormArray` bound to this directive.
4023 |      */
4024 |     get control(): FormArray;
4025 |     /**
4026 |      * @description
4027 |      * The top-level directive for this group if present, otherwise null.
4028 |      */
4029 |     get formDirective(): FormGroupDirective | null;
4030 |     /**
4031 |      * @description
4032 |      * Returns an array that represents the path from the top-level form to this control.
4033 |      * Each index is the string name of the control on that level.
4034 |      */
4035 |     get path(): string[];
4036 |     static ɵfac: i0.ɵɵFactoryDeclaration<FormArrayName, [{ optional: true; host: true; skipSelf: true; }, { optional: true; self: true; }, { optional: true; self: true; }]>;
4037 |     static ɵdir: i0.ɵɵDirectiveDeclaration<FormArrayName, "[formArrayName]", never, { "name": { "alias": "formArrayName"; "required": false; }; }, {}, never, never, false, never>;
4038 | }
4039 | 
4040 | /**
4041 |  * The type for CALL_SET_DISABLED_STATE. If `always`, then ControlValueAccessor will always call
4042 |  * `setDisabledState` when attached, which is the most correct behavior. Otherwise, it will only be
4043 |  * called when disabled, which is the legacy behavior for compatibility.
4044 |  *
4045 |  * @publicApi
4046 |  * @see {@link FormsModule#withconfig}
4047 |  */
4048 | type SetDisabledStateOption = 'whenDisabledForLegacyCode' | 'always';
4049 | 
4050 | /**
4051 |  * @description
4052 |  * Creates a `FormControl` instance from a [domain
4053 |  * model](https://en.wikipedia.org/wiki/Domain_model) and binds it to a form control element.
4054 |  *
4055 |  * The `FormControl` instance tracks the value, user interaction, and
4056 |  * validation status of the control and keeps the view synced with the model. If used
4057 |  * within a parent form, the directive also registers itself with the form as a child
4058 |  * control.
4059 |  *
4060 |  * This directive is used by itself or as part of a larger form. Use the
4061 |  * `ngModel` selector to activate it.
4062 |  *
4063 |  * It accepts a domain model as an optional `Input`. If you have a one-way binding
4064 |  * to `ngModel` with `[]` syntax, changing the domain model's value in the component
4065 |  * class sets the value in the view. If you have a two-way binding with `[()]` syntax
4066 |  * (also known as 'banana-in-a-box syntax'), the value in the UI always syncs back to
4067 |  * the domain model in your class.
4068 |  *
4069 |  * To inspect the properties of the associated `FormControl` (like the validity state),
4070 |  * export the directive into a local template variable using `ngModel` as the key (ex:
4071 |  * `#myVar="ngModel"`). You can then access the control using the directive's `control` property.
4072 |  * However, the most commonly used properties (like `valid` and `dirty`) also exist on the control
4073 |  * for direct access. See a full list of properties directly available in
4074 |  * `AbstractControlDirective`.
4075 |  *
4076 |  * @see {@link RadioControlValueAccessor}
4077 |  * @see {@link SelectControlValueAccessor}
4078 |  *
4079 |  * @usageNotes
4080 |  *
4081 |  * ### Using ngModel on a standalone control
4082 |  *
4083 |  * The following examples show a simple standalone control using `ngModel`:
4084 |  *
4085 |  * {@example forms/ts/simpleNgModel/simple_ng_model_example.ts region='Component'}
4086 |  *
4087 |  * When using the `ngModel` within `<form>` tags, you'll also need to supply a `name` attribute
4088 |  * so that the control can be registered with the parent form under that name.
4089 |  *
4090 |  * In the context of a parent form, it's often unnecessary to include one-way or two-way binding,
4091 |  * as the parent form syncs the value for you. You access its properties by exporting it into a
4092 |  * local template variable using `ngForm` such as (`#f="ngForm"`). Use the variable where
4093 |  * needed on form submission.
4094 |  *
4095 |  * If you do need to populate initial values into your form, using a one-way binding for
4096 |  * `ngModel` tends to be sufficient as long as you use the exported form's value rather
4097 |  * than the domain model's value on submit.
4098 |  *
4099 |  * ### Using ngModel within a form
4100 |  *
4101 |  * The following example shows controls using `ngModel` within a form:
4102 |  *
4103 |  * {@example forms/ts/simpleForm/simple_form_example.ts region='Component'}
4104 |  *
4105 |  * ### Using a standalone ngModel within a group
4106 |  *
4107 |  * The following example shows you how to use a standalone ngModel control
4108 |  * within a form. This controls the display of the form, but doesn't contain form data.
4109 |  *
4110 |  * ```html
4111 |  * <form>
4112 |  *   <input name="login" ngModel placeholder="Login">
4113 |  *   <input type="checkbox" ngModel [ngModelOptions]="{standalone: true}"> Show more options?
4114 |  * </form>
4115 |  * <!-- form value: {login: ''} -->
4116 |  * ```
4117 |  *
4118 |  * ### Setting the ngModel `name` attribute through options
4119 |  *
4120 |  * The following example shows you an alternate way to set the name attribute. Here,
4121 |  * an attribute identified as name is used within a custom form control component. To still be able
4122 |  * to specify the NgModel's name, you must specify it using the `ngModelOptions` input instead.
4123 |  *
4124 |  * ```html
4125 |  * <form>
4126 |  *   <my-custom-form-control name="Nancy" ngModel [ngModelOptions]="{name: 'user'}">
4127 |  *   </my-custom-form-control>
4128 |  * </form>
4129 |  * <!-- form value: {user: ''} -->
4130 |  * ```
4131 |  *
4132 |  * @ngModule FormsModule
4133 |  * @publicApi
4134 |  */
4135 | declare class NgModel extends NgControl implements OnChanges, OnDestroy {
4136 |     private _changeDetectorRef?;
4137 |     private callSetDisabledState?;
4138 |     readonly control: FormControl;
4139 |     /** @docs-private */
4140 |     static ngAcceptInputType_isDisabled: boolean | string;
4141 |     /**
4142 |      * Internal reference to the view model value.
4143 |      * @docs-private
4144 |      */
4145 |     viewModel: any;
4146 |     /**
4147 |      * @description
4148 |      * Tracks the name bound to the directive. If a parent form exists, it
4149 |      * uses this name as a key to retrieve this control's value.
4150 |      */
4151 |     name: string;
4152 |     /**
4153 |      * @description
4154 |      * Tracks whether the control is disabled.
4155 |      */
4156 |     isDisabled: boolean;
4157 |     /**
4158 |      * @description
4159 |      * Tracks the value bound to this directive.
4160 |      */
4161 |     model: any;
4162 |     /**
4163 |      * @description
4164 |      * Tracks the configuration options for this `ngModel` instance.
4165 |      *
4166 |      * **name**: An alternative to setting the name attribute on the form control element. See
4167 |      * the [example](api/forms/NgModel#using-ngmodel-on-a-standalone-control) for using `NgModel`
4168 |      * as a standalone control.
4169 |      *
4170 |      * **standalone**: When set to true, the `ngModel` will not register itself with its parent form,
4171 |      * and acts as if it's not in the form. Defaults to false. If no parent form exists, this option
4172 |      * has no effect.
4173 |      *
4174 |      * **updateOn**: Defines the event upon which the form control value and validity update.
4175 |      * Defaults to 'change'. Possible values: `'change'` | `'blur'` | `'submit'`.
4176 |      *
4177 |      */
4178 |     options: {
4179 |         name?: string;
4180 |         standalone?: boolean;
4181 |         updateOn?: FormHooks;
4182 |     };
4183 |     /**
4184 |      * @description
4185 |      * Event emitter for producing the `ngModelChange` event after
4186 |      * the view model updates.
4187 |      */
4188 |     update: EventEmitter<any>;
4189 |     constructor(parent: ControlContainer, validators: (Validator | ValidatorFn)[], asyncValidators: (AsyncValidator | AsyncValidatorFn)[], valueAccessors: ControlValueAccessor[], _changeDetectorRef?: (ChangeDetectorRef | null) | undefined, callSetDisabledState?: SetDisabledStateOption | undefined);
4190 |     /** @docs-private */
4191 |     ngOnChanges(changes: SimpleChanges): void;
4192 |     /** @docs-private */
4193 |     ngOnDestroy(): void;
4194 |     /**
4195 |      * @description
4196 |      * Returns an array that represents the path from the top-level form to this control.
4197 |      * Each index is the string name of the control on that level.
4198 |      */
4199 |     get path(): string[];
4200 |     /**
4201 |      * @description
4202 |      * The top-level directive for this control if present, otherwise null.
4203 |      */
4204 |     get formDirective(): any;
4205 |     /**
4206 |      * @description
4207 |      * Sets the new value for the view model and emits an `ngModelChange` event.
4208 |      *
4209 |      * @param newValue The new value emitted by `ngModelChange`.
4210 |      */
4211 |     viewToModelUpdate(newValue: any): void;
4212 |     private _setUpControl;
4213 |     private _setUpdateStrategy;
4214 |     private _isStandalone;
4215 |     private _setUpStandalone;
4216 |     private _checkForErrors;
4217 |     private _checkName;
4218 |     private _updateValue;
4219 |     private _updateDisabled;
4220 |     private _getPath;
4221 |     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; }]>;
4222 |     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>;
4223 | }
4224 | 
4225 | /**
4226 |  * @description
4227 |  * Creates and binds a `FormGroup` instance to a DOM element.
4228 |  *
4229 |  * This directive can only be used as a child of `NgForm` (within `<form>` tags).
4230 |  *
4231 |  * Use this directive to validate a sub-group of your form separately from the
4232 |  * rest of your form, or if some values in your domain model make more sense
4233 |  * to consume together in a nested object.
4234 |  *
4235 |  * Provide a name for the sub-group and it will become the key
4236 |  * for the sub-group in the form's full value. If you need direct access, export the directive into
4237 |  * a local template variable using `ngModelGroup` (ex: `#myGroup="ngModelGroup"`).
4238 |  *
4239 |  * @usageNotes
4240 |  *
4241 |  * ### Consuming controls in a grouping
4242 |  *
4243 |  * The following example shows you how to combine controls together in a sub-group
4244 |  * of the form.
4245 |  *
4246 |  * {@example forms/ts/ngModelGroup/ng_model_group_example.ts region='Component'}
4247 |  *
4248 |  * @ngModule FormsModule
4249 |  * @publicApi
4250 |  */
4251 | declare class NgModelGroup extends AbstractFormGroupDirective implements OnInit, OnDestroy {
4252 |     /**
4253 |      * @description
4254 |      * Tracks the name of the `NgModelGroup` bound to the directive. The name corresponds
4255 |      * to a key in the parent `NgForm`.
4256 |      */
4257 |     name: string;
4258 |     constructor(parent: ControlContainer, validators: (Validator | ValidatorFn)[], asyncValidators: (AsyncValidator | AsyncValidatorFn)[]);
4259 |     static ɵfac: i0.ɵɵFactoryDeclaration<NgModelGroup, [{ host: true; skipSelf: true; }, { optional: true; self: true; }, { optional: true; self: true; }]>;
4260 |     static ɵdir: i0.ɵɵDirectiveDeclaration<NgModelGroup, "[ngModelGroup]", ["ngModelGroup"], { "name": { "alias": "ngModelGroup"; "required": false; }; }, {}, never, never, false, never>;
4261 | }
4262 | 
4263 | /**
4264 |  * @description
4265 |  * Creates a top-level `FormGroup` instance and binds it to a form
4266 |  * to track aggregate form value and validation status.
4267 |  *
4268 |  * As soon as you import the `FormsModule`, this directive becomes active by default on
4269 |  * all `<form>` tags.  You don't need to add a special selector.
4270 |  *
4271 |  * You optionally export the directive into a local template variable using `ngForm` as the key
4272 |  * (ex: `#myForm="ngForm"`). This is optional, but useful.  Many properties from the underlying
4273 |  * `FormGroup` instance are duplicated on the directive itself, so a reference to it
4274 |  * gives you access to the aggregate value and validity status of the form, as well as
4275 |  * user interaction properties like `dirty` and `touched`.
4276 |  *
4277 |  * To register child controls with the form, use `NgModel` with a `name`
4278 |  * attribute. You may use `NgModelGroup` to create sub-groups within the form.
4279 |  *
4280 |  * If necessary, listen to the directive's `ngSubmit` event to be notified when the user has
4281 |  * triggered a form submission. The `ngSubmit` event emits the original form
4282 |  * submission event.
4283 |  *
4284 |  * In template driven forms, all `<form>` tags are automatically tagged as `NgForm`.
4285 |  * To import the `FormsModule` but skip its usage in some forms,
4286 |  * for example, to use native HTML5 validation, add the `ngNoForm` and the `<form>`
4287 |  * tags won't create an `NgForm` directive. In reactive forms, using `ngNoForm` is
4288 |  * unnecessary because the `<form>` tags are inert. In that case, you would
4289 |  * refrain from using the `formGroup` directive.
4290 |  *
4291 |  * @usageNotes
4292 |  *
4293 |  * ### Listening for form submission
4294 |  *
4295 |  * The following example shows how to capture the form values from the "ngSubmit" event.
4296 |  *
4297 |  * {@example forms/ts/simpleForm/simple_form_example.ts region='Component'}
4298 |  *
4299 |  * ### Setting the update options
4300 |  *
4301 |  * The following example shows you how to change the "updateOn" option from its default using
4302 |  * ngFormOptions.
4303 |  *
4304 |  * ```html
4305 |  * <form [ngFormOptions]="{updateOn: 'blur'}">
4306 |  *    <input name="one" ngModel>  <!-- this ngModel will update on blur -->
4307 |  * </form>
4308 |  * ```
4309 |  *
4310 |  * ### Native DOM validation UI
4311 |  *
4312 |  * In order to prevent the native DOM form validation UI from interfering with Angular's form
4313 |  * validation, Angular automatically adds the `novalidate` attribute on any `<form>` whenever
4314 |  * `FormModule` or `ReactiveFormModule` are imported into the application.
4315 |  * If you want to explicitly enable native DOM validation UI with Angular forms, you can add the
4316 |  * `ngNativeValidate` attribute to the `<form>` element:
4317 |  *
4318 |  * ```html
4319 |  * <form ngNativeValidate>
4320 |  *   ...
4321 |  * </form>
4322 |  * ```
4323 |  *
4324 |  * @ngModule FormsModule
4325 |  * @publicApi
4326 |  */
4327 | declare class NgForm extends ControlContainer implements Form, AfterViewInit {
4328 |     private callSetDisabledState?;
4329 |     /**
4330 |      * @description
4331 |      * Returns whether the form submission has been triggered.
4332 |      */
4333 |     get submitted(): boolean;
4334 |     private readonly submittedReactive;
4335 |     private _directives;
4336 |     /**
4337 |      * @description
4338 |      * The `FormGroup` instance created for this form.
4339 |      */
4340 |     form: FormGroup;
4341 |     /**
4342 |      * @description
4343 |      * Event emitter for the "ngSubmit" event
4344 |      */
4345 |     ngSubmit: EventEmitter<any>;
4346 |     /**
4347 |      * @description
4348 |      * Tracks options for the `NgForm` instance.
4349 |      *
4350 |      * **updateOn**: Sets the default `updateOn` value for all child `NgModels` below it
4351 |      * unless explicitly set by a child `NgModel` using `ngModelOptions`). Defaults to 'change'.
4352 |      * Possible values: `'change'` | `'blur'` | `'submit'`.
4353 |      *
4354 |      */
4355 |     options: {
4356 |         updateOn?: FormHooks;
4357 |     };
4358 |     constructor(validators: (Validator | ValidatorFn)[], asyncValidators: (AsyncValidator | AsyncValidatorFn)[], callSetDisabledState?: SetDisabledStateOption | undefined);
4359 |     /** @docs-private */
4360 |     ngAfterViewInit(): void;
4361 |     /**
4362 |      * @description
4363 |      * The directive instance.
4364 |      */
4365 |     get formDirective(): Form;
4366 |     /**
4367 |      * @description
4368 |      * The internal `FormGroup` instance.
4369 |      */
4370 |     get control(): FormGroup;
4371 |     /**
4372 |      * @description
4373 |      * Returns an array representing the path to this group. Because this directive
4374 |      * always lives at the top level of a form, it is always an empty array.
4375 |      */
4376 |     get path(): string[];
4377 |     /**
4378 |      * @description
4379 |      * Returns a map of the controls in this group.
4380 |      */
4381 |     get controls(): {
4382 |         [key: string]: AbstractControl;
4383 |     };
4384 |     /**
4385 |      * @description
4386 |      * Method that sets up the control directive in this group, re-calculates its value
4387 |      * and validity, and adds the instance to the internal list of directives.
4388 |      *
4389 |      * @param dir The `NgModel` directive instance.
4390 |      */
4391 |     addControl(dir: NgModel): void;
4392 |     /**
4393 |      * @description
4394 |      * Retrieves the `FormControl` instance from the provided `NgModel` directive.
4395 |      *
4396 |      * @param dir The `NgModel` directive instance.
4397 |      */
4398 |     getControl(dir: NgModel): FormControl;
4399 |     /**
4400 |      * @description
4401 |      * Removes the `NgModel` instance from the internal list of directives
4402 |      *
4403 |      * @param dir The `NgModel` directive instance.
4404 |      */
4405 |     removeControl(dir: NgModel): void;
4406 |     /**
4407 |      * @description
4408 |      * Adds a new `NgModelGroup` directive instance to the form.
4409 |      *
4410 |      * @param dir The `NgModelGroup` directive instance.
4411 |      */
4412 |     addFormGroup(dir: NgModelGroup): void;
4413 |     /**
4414 |      * @description
4415 |      * Removes the `NgModelGroup` directive instance from the form.
4416 |      *
4417 |      * @param dir The `NgModelGroup` directive instance.
4418 |      */
4419 |     removeFormGroup(dir: NgModelGroup): void;
4420 |     /**
4421 |      * @description
4422 |      * Retrieves the `FormGroup` for a provided `NgModelGroup` directive instance
4423 |      *
4424 |      * @param dir The `NgModelGroup` directive instance.
4425 |      */
4426 |     getFormGroup(dir: NgModelGroup): FormGroup;
4427 |     /**
4428 |      * Sets the new value for the provided `NgControl` directive.
4429 |      *
4430 |      * @param dir The `NgControl` directive instance.
4431 |      * @param value The new value for the directive's control.
4432 |      */
4433 |     updateModel(dir: NgControl, value: any): void;
4434 |     /**
4435 |      * @description
4436 |      * Sets the value for this `FormGroup`.
4437 |      *
4438 |      * @param value The new value
4439 |      */
4440 |     setValue(value: {
4441 |         [key: string]: any;
4442 |     }): void;
4443 |     /**
4444 |      * @description
4445 |      * Method called when the "submit" event is triggered on the form.
4446 |      * Triggers the `ngSubmit` emitter to emit the "submit" event as its payload.
4447 |      *
4448 |      * @param $event The "submit" event object
4449 |      */
4450 |     onSubmit($event: Event): boolean;
4451 |     /**
4452 |      * @description
4453 |      * Method called when the "reset" event is triggered on the form.
4454 |      */
4455 |     onReset(): void;
4456 |     /**
4457 |      * @description
4458 |      * Resets the form to an initial value and resets its submitted status.
4459 |      *
4460 |      * @param value The new value for the form.
4461 |      */
4462 |     resetForm(value?: any): void;
4463 |     private _setUpdateStrategy;
4464 |     private _findContainer;
4465 |     static ɵfac: i0.ɵɵFactoryDeclaration<NgForm, [{ optional: true; self: true; }, { optional: true; self: true; }, { optional: true; }]>;
4466 |     static ɵdir: i0.ɵɵDirectiveDeclaration<NgForm, "form:not([ngNoForm]):not([formGroup]),ng-form,[ngForm]", ["ngForm"], { "options": { "alias": "ngFormOptions"; "required": false; }; }, { "ngSubmit": "ngSubmit"; }, never, never, false, never>;
4467 | }
4468 | 
4469 | /**
4470 |  * @description
4471 |  * Synchronizes a standalone `FormControl` instance to a form control element.
4472 |  *
4473 |  * Note that support for using the `ngModel` input property and `ngModelChange` event with reactive
4474 |  * form directives was deprecated in Angular v6 and is scheduled for removal in
4475 |  * a future version of Angular.
4476 |  *
4477 |  * @see [Reactive Forms Guide](guide/forms/reactive-forms)
4478 |  * @see {@link FormControl}
4479 |  * @see {@link AbstractControl}
4480 |  *
4481 |  * @usageNotes
4482 |  *
4483 |  * The following example shows how to register a standalone control and set its value.
4484 |  *
4485 |  * {@example forms/ts/simpleFormControl/simple_form_control_example.ts region='Component'}
4486 |  *
4487 |  * @ngModule ReactiveFormsModule
4488 |  * @publicApi
4489 |  */
4490 | declare class FormControlDirective extends NgControl implements OnChanges, OnDestroy {
4491 |     private _ngModelWarningConfig;
4492 |     private callSetDisabledState?;
4493 |     /**
4494 |      * Internal reference to the view model value.
4495 |      * @docs-private
4496 |      */
4497 |     viewModel: any;
4498 |     /**
4499 |      * @description
4500 |      * Tracks the `FormControl` instance bound to the directive.
4501 |      */
4502 |     form: FormControl;
4503 |     /**
4504 |      * @description
4505 |      * Triggers a warning in dev mode that this input should not be used with reactive forms.
4506 |      */
4507 |     set isDisabled(isDisabled: boolean);
4508 |     /** @deprecated as of v6 */
4509 |     model: any;
4510 |     /** @deprecated as of v6 */
4511 |     update: EventEmitter<any>;
4512 |     constructor(validators: (Validator | ValidatorFn)[], asyncValidators: (AsyncValidator | AsyncValidatorFn)[], valueAccessors: ControlValueAccessor[], _ngModelWarningConfig: string | null, callSetDisabledState?: SetDisabledStateOption | undefined);
4513 |     /** @docs-private */
4514 |     ngOnChanges(changes: SimpleChanges): void;
4515 |     /** @docs-private */
4516 |     ngOnDestroy(): void;
4517 |     /**
4518 |      * @description
4519 |      * Returns an array that represents the path from the top-level form to this control.
4520 |      * Each index is the string name of the control on that level.
4521 |      */
4522 |     get path(): string[];
4523 |     /**
4524 |      * @description
4525 |      * The `FormControl` bound to this directive.
4526 |      */
4527 |     get control(): FormControl;
4528 |     /**
4529 |      * @description
4530 |      * Sets the new value for the view model and emits an `ngModelChange` event.
4531 |      *
4532 |      * @param newValue The new value for the view model.
4533 |      */
4534 |     viewToModelUpdate(newValue: any): void;
4535 |     private _isControlChanged;
4536 |     static ɵfac: i0.ɵɵFactoryDeclaration<FormControlDirective, [{ optional: true; self: true; }, { optional: true; self: true; }, { optional: true; self: true; }, { optional: true; }, { optional: true; }]>;
4537 |     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>;
4538 | }
4539 | 
4540 | /**
4541 |  * Internal module used for sharing directives between FormsModule and ReactiveFormsModule
4542 |  */
4543 | declare class ɵInternalFormsSharedModule {
4544 |     static ɵfac: i0.ɵɵFactoryDeclaration<ɵInternalFormsSharedModule, never>;
4545 |     static ɵmod: i0.ɵɵNgModuleDeclaration<ɵInternalFormsSharedModule, [typeof ɵNgNoValidate, typeof NgSelectOption, typeof ɵNgSelectMultipleOption, typeof DefaultValueAccessor, typeof NumberValueAccessor, typeof RangeValueAccessor, typeof CheckboxControlValueAccessor, typeof SelectControlValueAccessor, typeof SelectMultipleControlValueAccessor, typeof RadioControlValueAccessor, typeof NgControlStatus, typeof NgControlStatusGroup, typeof RequiredValidator, typeof MinLengthValidator, typeof MaxLengthValidator, typeof PatternValidator, typeof CheckboxRequiredValidator, typeof EmailValidator, typeof MinValidator, typeof MaxValidator], never, [typeof ɵNgNoValidate, typeof NgSelectOption, typeof ɵNgSelectMultipleOption, typeof DefaultValueAccessor, typeof NumberValueAccessor, typeof RangeValueAccessor, typeof CheckboxControlValueAccessor, typeof SelectControlValueAccessor, typeof SelectMultipleControlValueAccessor, typeof RadioControlValueAccessor, typeof NgControlStatus, typeof NgControlStatusGroup, typeof RequiredValidator, typeof MinLengthValidator, typeof MaxLengthValidator, typeof PatternValidator, typeof CheckboxRequiredValidator, typeof EmailValidator, typeof MinValidator, typeof MaxValidator]>;
4546 |     static ɵinj: i0.ɵɵInjectorDeclaration<ɵInternalFormsSharedModule>;
4547 | }
4548 | 
4549 | /**
4550 |  * The union of all validator types that can be accepted by a ControlConfig.
4551 |  */
4552 | type ValidatorConfig = ValidatorFn | AsyncValidatorFn | ValidatorFn[] | AsyncValidatorFn[];
4553 | /**
4554 |  * The compiler may not always be able to prove that the elements of the control config are a tuple
4555 |  * (i.e. occur in a fixed order). This slightly looser type is used for inference, to catch cases
4556 |  * where the compiler cannot prove order and position.
4557 |  *
4558 |  * For example, consider the simple case `fb.group({foo: ['bar', Validators.required]})`. The
4559 |  * compiler will infer this as an array, not as a tuple.
4560 |  */
4561 | type PermissiveControlConfig<T> = Array<T | FormControlState<T> | ValidatorConfig>;
4562 | /**
4563 |  * Helper type to allow the compiler to accept [XXXX, { updateOn: string }] as a valid shorthand
4564 |  * argument for .group()
4565 |  */
4566 | interface PermissiveAbstractControlOptions extends Omit<AbstractControlOptions, 'updateOn'> {
4567 |     updateOn?: string;
4568 | }
4569 | /** A map of nullable form controls. */
4570 | type ɵNullableFormControls<T> = {
4571 |     [K in keyof T]: ɵElement<T[K], null>;
4572 | };
4573 | /** A map of non-nullable form controls. */
4574 | type ɵNonNullableFormControls<T> = {
4575 |     [K in keyof T]: ɵElement<T[K], never>;
4576 | };
4577 | /**
4578 |  * ControlConfig<T> is a tuple containing a value of type T, plus optional validators and async
4579 |  * validators.
4580 |  *
4581 |  * @publicApi
4582 |  */
4583 | type ControlConfig<T> = [
4584 |     T | FormControlState<T>,
4585 |     (ValidatorFn | ValidatorFn[])?,
4586 |     (AsyncValidatorFn | AsyncValidatorFn[])?
4587 | ];
4588 | /**
4589 |  * FormBuilder accepts values in various container shapes, as well as raw values.
4590 |  * Element returns the appropriate corresponding model class, given the container T.
4591 |  * The flag N, if not never, makes the resulting `FormControl` have N in its type.
4592 |  */
4593 | type ɵElement<T, N extends null> = [
4594 |     T
4595 | ] extends [FormControl<infer U>] ? FormControl<U> : [
4596 |     T
4597 | ] extends [FormControl<infer U> | undefined] ? FormControl<U> : [
4598 |     T
4599 | ] extends [FormGroup<infer U>] ? FormGroup<U> : [
4600 |     T
4601 | ] extends [FormGroup<infer U> | undefined] ? FormGroup<U> : [
4602 |     T
4603 | ] extends [FormRecord<infer U>] ? FormRecord<U> : [
4604 |     T
4605 | ] extends [FormRecord<infer U> | undefined] ? FormRecord<U> : [
4606 |     T
4607 | ] extends [FormArray<infer U>] ? FormArray<U> : [
4608 |     T
4609 | ] extends [FormArray<infer U> | undefined] ? FormArray<U> : [
4610 |     T
4611 | ] extends [AbstractControl<infer U>] ? AbstractControl<U> : [
4612 |     T
4613 | ] extends [AbstractControl<infer U> | undefined] ? AbstractControl<U> : [
4614 |     T
4615 | ] extends [FormControlState<infer U>] ? FormControl<U | N> : [
4616 |     T
4617 | ] extends [PermissiveControlConfig<infer U>] ? FormControl<Exclude<U, ValidatorConfig | PermissiveAbstractControlOptions> | N> : FormControl<T | N>;
4618 | /**
4619 |  * @description
4620 |  * Creates an `AbstractControl` from a user-specified configuration.
4621 |  *
4622 |  * The `FormBuilder` provides syntactic sugar that shortens creating instances of a
4623 |  * `FormControl`, `FormGroup`, or `FormArray`. It reduces the amount of boilerplate needed to
4624 |  * build complex forms.
4625 |  *
4626 |  * @see [Reactive Forms Guide](guide/forms/reactive-forms)
4627 |  *
4628 |  * @publicApi
4629 |  */
4630 | declare class FormBuilder {
4631 |     private useNonNullable;
4632 |     /**
4633 |      * @description
4634 |      * Returns a FormBuilder in which automatically constructed `FormControl` elements
4635 |      * have `{nonNullable: true}` and are non-nullable.
4636 |      *
4637 |      * **Constructing non-nullable controls**
4638 |      *
4639 |      * When constructing a control, it will be non-nullable, and will reset to its initial value.
4640 |      *
4641 |      * ```ts
4642 |      * let nnfb = new FormBuilder().nonNullable;
4643 |      * let name = nnfb.control('Alex'); // FormControl<string>
4644 |      * name.reset();
4645 |      * console.log(name); // 'Alex'
4646 |      * ```
4647 |      *
4648 |      * **Constructing non-nullable groups or arrays**
4649 |      *
4650 |      * When constructing a group or array, all automatically created inner controls will be
4651 |      * non-nullable, and will reset to their initial values.
4652 |      *
4653 |      * ```ts
4654 |      * let nnfb = new FormBuilder().nonNullable;
4655 |      * let name = nnfb.group({who: 'Alex'}); // FormGroup<{who: FormControl<string>}>
4656 |      * name.reset();
4657 |      * console.log(name); // {who: 'Alex'}
4658 |      * ```
4659 |      * **Constructing *nullable* fields on groups or arrays**
4660 |      *
4661 |      * It is still possible to have a nullable field. In particular, any `FormControl` which is
4662 |      * *already* constructed will not be altered. For example:
4663 |      *
4664 |      * ```ts
4665 |      * let nnfb = new FormBuilder().nonNullable;
4666 |      * // FormGroup<{who: FormControl<string|null>}>
4667 |      * let name = nnfb.group({who: new FormControl('Alex')});
4668 |      * name.reset(); console.log(name); // {who: null}
4669 |      * ```
4670 |      *
4671 |      * Because the inner control is constructed explicitly by the caller, the builder has
4672 |      * no control over how it is created, and cannot exclude the `null`.
4673 |      */
4674 |     get nonNullable(): NonNullableFormBuilder;
4675 |     /**
4676 |      * @description
4677 |      * Constructs a new `FormGroup` instance. Accepts a single generic argument, which is an object
4678 |      * containing all the keys and corresponding inner control types.
4679 |      *
4680 |      * @param controls A collection of child controls. The key for each child is the name
4681 |      * under which it is registered.
4682 |      *
4683 |      * @param options Configuration options object for the `FormGroup`. The object should have the
4684 |      * `AbstractControlOptions` type and might contain the following fields:
4685 |      * * `validators`: A synchronous validator function, or an array of validator functions.
4686 |      * * `asyncValidators`: A single async validator or array of async validator functions.
4687 |      * * `updateOn`: The event upon which the control should be updated (options: 'change' | 'blur'
4688 |      * | submit').
4689 |      */
4690 |     group<T extends {}>(controls: T, options?: AbstractControlOptions | null): FormGroup<ɵNullableFormControls<T>>;
4691 |     /**
4692 |      * @description
4693 |      * Constructs a new `FormGroup` instance.
4694 |      *
4695 |      * @deprecated This API is not typesafe and can result in issues with Closure Compiler renaming.
4696 |      * Use the `FormBuilder#group` overload with `AbstractControlOptions` instead.
4697 |      * Note that `AbstractControlOptions` expects `validators` and `asyncValidators` to be valid
4698 |      * validators. If you have custom validators, make sure their validation function parameter is
4699 |      * `AbstractControl` and not a sub-class, such as `FormGroup`. These functions will be called
4700 |      * with an object of type `AbstractControl` and that cannot be automatically downcast to a
4701 |      * subclass, so TypeScript sees this as an error. For example, change the `(group: FormGroup) =>
4702 |      * ValidationErrors|null` signature to be `(group: AbstractControl) => ValidationErrors|null`.
4703 |      *
4704 |      * @param controls A record of child controls. The key for each child is the name
4705 |      * under which the control is registered.
4706 |      *
4707 |      * @param options Configuration options object for the `FormGroup`. The legacy configuration
4708 |      * object consists of:
4709 |      * * `validator`: A synchronous validator function, or an array of validator functions.
4710 |      * * `asyncValidator`: A single async validator or array of async validator functions
4711 |      * Note: the legacy format is deprecated and might be removed in one of the next major versions
4712 |      * of Angular.
4713 |      */
4714 |     group(controls: {
4715 |         [key: string]: any;
4716 |     }, options: {
4717 |         [key: string]: any;
4718 |     }): FormGroup;
4719 |     /**
4720 |      * @description
4721 |      * Constructs a new `FormRecord` instance. Accepts a single generic argument, which is an object
4722 |      * containing all the keys and corresponding inner control types.
4723 |      *
4724 |      * @param controls A collection of child controls. The key for each child is the name
4725 |      * under which it is registered.
4726 |      *
4727 |      * @param options Configuration options object for the `FormRecord`. The object should have the
4728 |      * `AbstractControlOptions` type and might contain the following fields:
4729 |      * * `validators`: A synchronous validator function, or an array of validator functions.
4730 |      * * `asyncValidators`: A single async validator or array of async validator functions.
4731 |      * * `updateOn`: The event upon which the control should be updated (options: 'change' | 'blur'
4732 |      * | submit').
4733 |      */
4734 |     record<T>(controls: {
4735 |         [key: string]: T;
4736 |     }, options?: AbstractControlOptions | null): FormRecord<ɵElement<T, null>>;
4737 |     /** @deprecated Use `nonNullable` instead. */
4738 |     control<T>(formState: T | FormControlState<T>, opts: FormControlOptions & {
4739 |         initialValueIsDefault: true;
4740 |     }): FormControl<T>;
4741 |     control<T>(formState: T | FormControlState<T>, opts: FormControlOptions & {
4742 |         nonNullable: true;
4743 |     }): FormControl<T>;
4744 |     /**
4745 |      * @deprecated When passing an `options` argument, the `asyncValidator` argument has no effect.
4746 |      */
4747 |     control<T>(formState: T | FormControlState<T>, opts: FormControlOptions, asyncValidator: AsyncValidatorFn | AsyncValidatorFn[]): FormControl<T | null>;
4748 |     control<T>(formState: T | FormControlState<T>, validatorOrOpts?: ValidatorFn | ValidatorFn[] | FormControlOptions | null, asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null): FormControl<T | null>;
4749 |     /**
4750 |      * Constructs a new `FormArray` from the given array of configurations,
4751 |      * validators and options. Accepts a single generic argument, which is the type of each control
4752 |      * inside the array.
4753 |      *
4754 |      * @param controls An array of child controls or control configs. Each child control is given an
4755 |      *     index when it is registered.
4756 |      *
4757 |      * @param validatorOrOpts A synchronous validator function, or an array of such functions, or an
4758 |      *     `AbstractControlOptions` object that contains
4759 |      * validation functions and a validation trigger.
4760 |      *
4761 |      * @param asyncValidator A single async validator or array of async validator functions.
4762 |      */
4763 |     array<T>(controls: Array<T>, validatorOrOpts?: ValidatorFn | ValidatorFn[] | AbstractControlOptions | null, asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null): FormArray<ɵElement<T, null>>;
4764 |     static ɵfac: i0.ɵɵFactoryDeclaration<FormBuilder, never>;
4765 |     static ɵprov: i0.ɵɵInjectableDeclaration<FormBuilder>;
4766 | }
4767 | /**
4768 |  * @description
4769 |  * `NonNullableFormBuilder` is similar to {@link FormBuilder}, but automatically constructed
4770 |  * {@link FormControl} elements have `{nonNullable: true}` and are non-nullable.
4771 |  *
4772 |  * @publicApi
4773 |  */
4774 | declare abstract class NonNullableFormBuilder {
4775 |     /**
4776 |      * Similar to `FormBuilder#group`, except any implicitly constructed `FormControl`
4777 |      * will be non-nullable (i.e. it will have `nonNullable` set to true). Note
4778 |      * that already-constructed controls will not be altered.
4779 |      */
4780 |     abstract group<T extends {}>(controls: T, options?: AbstractControlOptions | null): FormGroup<ɵNonNullableFormControls<T>>;
4781 |     /**
4782 |      * Similar to `FormBuilder#record`, except any implicitly constructed `FormControl`
4783 |      * will be non-nullable (i.e. it will have `nonNullable` set to true). Note
4784 |      * that already-constructed controls will not be altered.
4785 |      */
4786 |     abstract record<T>(controls: {
4787 |         [key: string]: T;
4788 |     }, options?: AbstractControlOptions | null): FormRecord<ɵElement<T, never>>;
4789 |     /**
4790 |      * Similar to `FormBuilder#array`, except any implicitly constructed `FormControl`
4791 |      * will be non-nullable (i.e. it will have `nonNullable` set to true). Note
4792 |      * that already-constructed controls will not be altered.
4793 |      */
4794 |     abstract array<T>(controls: Array<T>, validatorOrOpts?: ValidatorFn | ValidatorFn[] | AbstractControlOptions | null, asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null): FormArray<ɵElement<T, never>>;
4795 |     /**
4796 |      * Similar to `FormBuilder#control`, except this overridden version of `control` forces
4797 |      * `nonNullable` to be `true`, resulting in the control always being non-nullable.
4798 |      */
4799 |     abstract control<T>(formState: T | FormControlState<T>, validatorOrOpts?: ValidatorFn | ValidatorFn[] | AbstractControlOptions | null, asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null): FormControl<T>;
4800 |     static ɵfac: i0.ɵɵFactoryDeclaration<NonNullableFormBuilder, never>;
4801 |     static ɵprov: i0.ɵɵInjectableDeclaration<NonNullableFormBuilder>;
4802 | }
4803 | /**
4804 |  * UntypedFormBuilder is the same as `FormBuilder`, but it provides untyped controls.
4805 |  */
4806 | declare class UntypedFormBuilder extends FormBuilder {
4807 |     /**
4808 |      * Like `FormBuilder#group`, except the resulting group is untyped.
4809 |      */
4810 |     group(controlsConfig: {
4811 |         [key: string]: any;
4812 |     }, options?: AbstractControlOptions | null): UntypedFormGroup;
4813 |     /**
4814 |      * @deprecated This API is not typesafe and can result in issues with Closure Compiler renaming.
4815 |      * Use the `FormBuilder#group` overload with `AbstractControlOptions` instead.
4816 |      */
4817 |     group(controlsConfig: {
4818 |         [key: string]: any;
4819 |     }, options: {
4820 |         [key: string]: any;
4821 |     }): UntypedFormGroup;
4822 |     /**
4823 |      * Like `FormBuilder#control`, except the resulting control is untyped.
4824 |      */
4825 |     control(formState: any, validatorOrOpts?: ValidatorFn | ValidatorFn[] | FormControlOptions | null, asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null): UntypedFormControl;
4826 |     /**
4827 |      * Like `FormBuilder#array`, except the resulting array is untyped.
4828 |      */
4829 |     array(controlsConfig: any[], validatorOrOpts?: ValidatorFn | ValidatorFn[] | AbstractControlOptions | null, asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null): UntypedFormArray;
4830 |     static ɵfac: i0.ɵɵFactoryDeclaration<UntypedFormBuilder, never>;
4831 |     static ɵprov: i0.ɵɵInjectableDeclaration<UntypedFormBuilder>;
4832 | }
4833 | 
4834 | /**
4835 |  * @description
4836 |  * An `InjectionToken` for registering additional synchronous validators used with
4837 |  * `AbstractControl`s.
4838 |  *
4839 |  * @see {@link NG_ASYNC_VALIDATORS}
4840 |  *
4841 |  * @usageNotes
4842 |  *
4843 |  * ### Providing a custom validator
4844 |  *
4845 |  * The following example registers a custom validator directive. Adding the validator to the
4846 |  * existing collection of validators requires the `multi: true` option.
4847 |  *
4848 |  * ```ts
4849 |  * @Directive({
4850 |  *   selector: '[customValidator]',
4851 |  *   providers: [{provide: NG_VALIDATORS, useExisting: CustomValidatorDirective, multi: true}]
4852 |  * })
4853 |  * class CustomValidatorDirective implements Validator {
4854 |  *   validate(control: AbstractControl): ValidationErrors | null {
4855 |  *     return { 'custom': true };
4856 |  *   }
4857 |  * }
4858 |  * ```
4859 |  *
4860 |  * @publicApi
4861 |  */
4862 | declare const NG_VALIDATORS: InjectionToken<readonly (Function | Validator)[]>;
4863 | /**
4864 |  * @description
4865 |  * An `InjectionToken` for registering additional asynchronous validators used with
4866 |  * `AbstractControl`s.
4867 |  *
4868 |  * @see {@link NG_VALIDATORS}
4869 |  *
4870 |  * @usageNotes
4871 |  *
4872 |  * ### Provide a custom async validator directive
4873 |  *
4874 |  * The following example implements the `AsyncValidator` interface to create an
4875 |  * async validator directive with a custom error key.
4876 |  *
4877 |  * ```ts
4878 |  * @Directive({
4879 |  *   selector: '[customAsyncValidator]',
4880 |  *   providers: [{provide: NG_ASYNC_VALIDATORS, useExisting: CustomAsyncValidatorDirective, multi:
4881 |  * true}]
4882 |  * })
4883 |  * class CustomAsyncValidatorDirective implements AsyncValidator {
4884 |  *   validate(control: AbstractControl): Promise<ValidationErrors|null> {
4885 |  *     return Promise.resolve({'custom': true});
4886 |  *   }
4887 |  * }
4888 |  * ```
4889 |  *
4890 |  * @publicApi
4891 |  */
4892 | declare const NG_ASYNC_VALIDATORS: InjectionToken<readonly (Function | Validator)[]>;
4893 | /**
4894 |  * @description
4895 |  * Provides a set of built-in validators that can be used by form controls.
4896 |  *
4897 |  * A validator is a function that processes a `FormControl` or collection of
4898 |  * controls and returns an error map or null. A null map means that validation has passed.
4899 |  *
4900 |  * @see [Form Validation](guide/forms/form-validation)
4901 |  *
4902 |  * @publicApi
4903 |  */
4904 | declare class Validators {
4905 |     /**
4906 |      * @description
4907 |      * Validator that requires the control's value to be greater than or equal to the provided number.
4908 |      *
4909 |      * @usageNotes
4910 |      *
4911 |      * ### Validate against a minimum of 3
4912 |      *
4913 |      * ```ts
4914 |      * const control = new FormControl(2, Validators.min(3));
4915 |      *
4916 |      * console.log(control.errors); // {min: {min: 3, actual: 2}}
4917 |      * ```
4918 |      *
4919 |      * @returns A validator function that returns an error map with the
4920 |      * `min` property if the validation check fails, otherwise `null`.
4921 |      *
4922 |      * @see {@link /api/forms/AbstractControl#updateValueAndValidity updateValueAndValidity}
4923 |      *
4924 |      */
4925 |     static min(min: number): ValidatorFn;
4926 |     /**
4927 |      * @description
4928 |      * Validator that requires the control's value to be less than or equal to the provided number.
4929 |      *
4930 |      * @usageNotes
4931 |      *
4932 |      * ### Validate against a maximum of 15
4933 |      *
4934 |      * ```ts
4935 |      * const control = new FormControl(16, Validators.max(15));
4936 |      *
4937 |      * console.log(control.errors); // {max: {max: 15, actual: 16}}
4938 |      * ```
4939 |      *
4940 |      * @returns A validator function that returns an error map with the
4941 |      * `max` property if the validation check fails, otherwise `null`.
4942 |      *
4943 |      * @see {@link /api/forms/AbstractControl#updateValueAndValidity updateValueAndValidity}
4944 |      *
4945 |      */
4946 |     static max(max: number): ValidatorFn;
4947 |     /**
4948 |      * @description
4949 |      * Validator that requires the control have a non-empty value.
4950 |      *
4951 |      * @usageNotes
4952 |      *
4953 |      * ### Validate that the field is non-empty
4954 |      *
4955 |      * ```ts
4956 |      * const control = new FormControl('', Validators.required);
4957 |      *
4958 |      * console.log(control.errors); // {required: true}
4959 |      * ```
4960 |      *
4961 |      * @returns An error map with the `required` property
4962 |      * if the validation check fails, otherwise `null`.
4963 |      *
4964 |      * @see {@link /api/forms/AbstractControl#updateValueAndValidity updateValueAndValidity}
4965 |      *
4966 |      */
4967 |     static required(control: AbstractControl): ValidationErrors | null;
4968 |     /**
4969 |      * @description
4970 |      * Validator that requires the control's value be true. This validator is commonly
4971 |      * used for required checkboxes.
4972 |      *
4973 |      * @usageNotes
4974 |      *
4975 |      * ### Validate that the field value is true
4976 |      *
4977 |      * ```ts
4978 |      * const control = new FormControl('some value', Validators.requiredTrue);
4979 |      *
4980 |      * console.log(control.errors); // {required: true}
4981 |      * ```
4982 |      *
4983 |      * @returns An error map that contains the `required` property
4984 |      * set to `true` if the validation check fails, otherwise `null`.
4985 |      *
4986 |      * @see {@link /api/forms/AbstractControl#updateValueAndValidity updateValueAndValidity}
4987 |      *
4988 |      */
4989 |     static requiredTrue(control: AbstractControl): ValidationErrors | null;
4990 |     /**
4991 |      * @description
4992 |      * Validator that requires the control's value pass an email validation test.
4993 |      *
4994 |      * Tests the value using a [regular
4995 |      * expression](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions)
4996 |      * pattern suitable for common use cases. The pattern is based on the definition of a valid email
4997 |      * address in the [WHATWG HTML
4998 |      * specification](https://html.spec.whatwg.org/multipage/input.html#valid-e-mail-address) with
4999 |      * some enhancements to incorporate more RFC rules (such as rules related to domain names and the
5000 |      * lengths of different parts of the address).
5001 |      *
5002 |      * The differences from the WHATWG version include:
5003 |      * - Disallow `local-part` (the part before the `@` symbol) to begin or end with a period (`.`).
5004 |      * - Disallow `local-part` to be longer than 64 characters.
5005 |      * - Disallow the whole address to be longer than 254 characters.
5006 |      *
5007 |      * If this pattern does not satisfy your business needs, you can use `Validators.pattern()` to
5008 |      * validate the value against a different pattern.
5009 |      *
5010 |      * @usageNotes
5011 |      *
5012 |      * ### Validate that the field matches a valid email pattern
5013 |      *
5014 |      * ```ts
5015 |      * const control = new FormControl('bad@', Validators.email);
5016 |      *
5017 |      * console.log(control.errors); // {email: true}
5018 |      * ```
5019 |      *
5020 |      * @returns An error map with the `email` property
5021 |      * if the validation check fails, otherwise `null`.
5022 |      *
5023 |      * @see {@link /api/forms/AbstractControl#updateValueAndValidity updateValueAndValidity}
5024 |      *
5025 |      */
5026 |     static email(control: AbstractControl): ValidationErrors | null;
5027 |     /**
5028 |      * @description
5029 |      * Validator that requires the number of items in the control's value to be greater than or equal
5030 |      * to the provided minimum length. This validator is also provided by default if you use
5031 |      * the HTML5 `minlength` attribute. Note that the `minLength` validator is intended to be used
5032 |      * only for types that have a numeric `length` or `size` property, such as strings, arrays or
5033 |      * sets. The `minLength` validator logic is also not invoked for values when their `length` or
5034 |      * `size` property is 0 (for example in case of an empty string or an empty array), to support
5035 |      * optional controls. You can use the standard `required` validator if empty values should not be
5036 |      * considered valid.
5037 |      *
5038 |      * @usageNotes
5039 |      *
5040 |      * ### Validate that the field has a minimum of 3 characters
5041 |      *
5042 |      * ```ts
5043 |      * const control = new FormControl('ng', Validators.minLength(3));
5044 |      *
5045 |      * console.log(control.errors); // {minlength: {requiredLength: 3, actualLength: 2}}
5046 |      * ```
5047 |      *
5048 |      * ```html
5049 |      * <input minlength="5">
5050 |      * ```
5051 |      *
5052 |      * @returns A validator function that returns an error map with the
5053 |      * `minlength` property if the validation check fails, otherwise `null`.
5054 |      *
5055 |      * @see {@link /api/forms/AbstractControl#updateValueAndValidity updateValueAndValidity}
5056 |      *
5057 |      */
5058 |     static minLength(minLength: number): ValidatorFn;
5059 |     /**
5060 |      * @description
5061 |      * Validator that requires the number of items in the control's value to be less than or equal
5062 |      * to the provided maximum length. This validator is also provided by default if you use
5063 |      * the HTML5 `maxlength` attribute. Note that the `maxLength` validator is intended to be used
5064 |      * only for types that have a numeric `length` or `size` property, such as strings, arrays or
5065 |      * sets.
5066 |      *
5067 |      * @usageNotes
5068 |      *
5069 |      * ### Validate that the field has maximum of 5 characters
5070 |      *
5071 |      * ```ts
5072 |      * const control = new FormControl('Angular', Validators.maxLength(5));
5073 |      *
5074 |      * console.log(control.errors); // {maxlength: {requiredLength: 5, actualLength: 7}}
5075 |      * ```
5076 |      *
5077 |      * ```html
5078 |      * <input maxlength="5">
5079 |      * ```
5080 |      *
5081 |      * @returns A validator function that returns an error map with the
5082 |      * `maxlength` property if the validation check fails, otherwise `null`.
5083 |      *
5084 |      * @see {@link /api/forms/AbstractControl#updateValueAndValidity updateValueAndValidity}
5085 |      *
5086 |      */
5087 |     static maxLength(maxLength: number): ValidatorFn;
5088 |     /**
5089 |      * @description
5090 |      * Validator that requires the control's value to match a regex pattern. This validator is also
5091 |      * provided by default if you use the HTML5 `pattern` attribute.
5092 |      *
5093 |      * @usageNotes
5094 |      *
5095 |      * ### Validate that the field only contains letters or spaces
5096 |      *
5097 |      * ```ts
5098 |      * const control = new FormControl('1', Validators.pattern('[a-zA-Z ]*'));
5099 |      *
5100 |      * console.log(control.errors); // {pattern: {requiredPattern: '^[a-zA-Z ]*$', actualValue: '1'}}
5101 |      * ```
5102 |      *
5103 |      * ```html
5104 |      * <input pattern="[a-zA-Z ]*">
5105 |      * ```
5106 |      *
5107 |      * ### Pattern matching with the global or sticky flag
5108 |      *
5109 |      * `RegExp` objects created with the `g` or `y` flags that are passed into `Validators.pattern`
5110 |      * can produce different results on the same input when validations are run consecutively. This is
5111 |      * due to how the behavior of `RegExp.prototype.test` is
5112 |      * specified in [ECMA-262](https://tc39.es/ecma262/#sec-regexpbuiltinexec)
5113 |      * (`RegExp` preserves the index of the last match when the global or sticky flag is used).
5114 |      * Due to this behavior, it is recommended that when using
5115 |      * `Validators.pattern` you **do not** pass in a `RegExp` object with either the global or sticky
5116 |      * flag enabled.
5117 |      *
5118 |      * ```ts
5119 |      * // Not recommended (since the `g` flag is used)
5120 |      * const controlOne = new FormControl('1', Validators.pattern(/foo/g));
5121 |      *
5122 |      * // Good
5123 |      * const controlTwo = new FormControl('1', Validators.pattern(/foo/));
5124 |      * ```
5125 |      *
5126 |      * @param pattern A regular expression to be used as is to test the values, or a string.
5127 |      * If a string is passed, the `^` character is prepended and the `$` character is
5128 |      * appended to the provided string (if not already present), and the resulting regular
5129 |      * expression is used to test the values.
5130 |      *
5131 |      * @returns A validator function that returns an error map with the
5132 |      * `pattern` property if the validation check fails, otherwise `null`.
5133 |      *
5134 |      * @see {@link /api/forms/AbstractControl#updateValueAndValidity updateValueAndValidity}
5135 |      *
5136 |      */
5137 |     static pattern(pattern: string | RegExp): ValidatorFn;
5138 |     /**
5139 |      * @description
5140 |      * Validator that performs no operation.
5141 |      *
5142 |      * @see {@link /api/forms/AbstractControl#updateValueAndValidity updateValueAndValidity}
5143 |      *
5144 |      */
5145 |     static nullValidator(control: AbstractControl): ValidationErrors | null;
5146 |     /**
5147 |      * @description
5148 |      * Compose multiple validators into a single function that returns the union
5149 |      * of the individual error maps for the provided control.
5150 |      *
5151 |      * @returns A validator function that returns an error map with the
5152 |      * merged error maps of the validators if the validation check fails, otherwise `null`.
5153 |      *
5154 |      * @see {@link /api/forms/AbstractControl#updateValueAndValidity updateValueAndValidity}
5155 |      *
5156 |      */
5157 |     static compose(validators: null): null;
5158 |     static compose(validators: (ValidatorFn | null | undefined)[]): ValidatorFn | null;
5159 |     /**
5160 |      * @description
5161 |      * Compose multiple async validators into a single function that returns the union
5162 |      * of the individual error objects for the provided control.
5163 |      *
5164 |      * @returns A validator function that returns an error map with the
5165 |      * merged error objects of the async validators if the validation check fails, otherwise `null`.
5166 |      *
5167 |      * @see {@link /api/forms/AbstractControl#updateValueAndValidity updateValueAndValidity}
5168 |      *
5169 |      */
5170 |     static composeAsync(validators: (AsyncValidatorFn | null)[]): AsyncValidatorFn | null;
5171 | }
5172 | 
5173 | /**
5174 |  * @module
5175 |  * @description
5176 |  * Entry point for all public APIs of the forms package.
5177 |  */
5178 | 
5179 | /**
5180 |  * @publicApi
5181 |  */
5182 | declare const VERSION: Version;
5183 | 
5184 | /**
5185 |  * Exports the required providers and directives for template-driven forms,
5186 |  * making them available for import by NgModules that import this module.
5187 |  *
5188 |  * @see [Forms Overview](guide/forms)
5189 |  * @see [Template-driven Forms Guide](guide/forms)
5190 |  *
5191 |  * @publicApi
5192 |  */
5193 | declare class FormsModule {
5194 |     /**
5195 |      * @description
5196 |      * Provides options for configuring the forms module.
5197 |      *
5198 |      * @param opts An object of configuration options
5199 |      * * `callSetDisabledState` Configures whether to `always` call `setDisabledState`, which is more
5200 |      * correct, or to only call it `whenDisabled`, which is the legacy behavior.
5201 |      */
5202 |     static withConfig(opts: {
5203 |         callSetDisabledState?: SetDisabledStateOption;
5204 |     }): ModuleWithProviders<FormsModule>;
5205 |     static ɵfac: i0.ɵɵFactoryDeclaration<FormsModule, never>;
5206 |     static ɵmod: i0.ɵɵNgModuleDeclaration<FormsModule, [typeof NgModel, typeof NgModelGroup, typeof NgForm], never, [typeof ɵInternalFormsSharedModule, typeof NgModel, typeof NgModelGroup, typeof NgForm]>;
5207 |     static ɵinj: i0.ɵɵInjectorDeclaration<FormsModule>;
5208 | }
5209 | /**
5210 |  * Exports the required infrastructure and directives for reactive forms,
5211 |  * making them available for import by NgModules that import this module.
5212 |  *
5213 |  * @see [Forms Overview](guide/forms)
5214 |  * @see [Reactive Forms Guide](guide/forms/reactive-forms)
5215 |  *
5216 |  * @publicApi
5217 |  */
5218 | declare class ReactiveFormsModule {
5219 |     /**
5220 |      * @description
5221 |      * Provides options for configuring the reactive forms module.
5222 |      *
5223 |      * @param opts An object of configuration options
5224 |      * * `warnOnNgModelWithFormControl` Configures when to emit a warning when an `ngModel`
5225 |      * binding is used with reactive form directives.
5226 |      * * `callSetDisabledState` Configures whether to `always` call `setDisabledState`, which is more
5227 |      * correct, or to only call it `whenDisabled`, which is the legacy behavior.
5228 |      */
5229 |     static withConfig(opts: {
5230 |         /** @deprecated as of v6 */ warnOnNgModelWithFormControl?: 'never' | 'once' | 'always';
5231 |         callSetDisabledState?: SetDisabledStateOption;
5232 |     }): ModuleWithProviders<ReactiveFormsModule>;
5233 |     static ɵfac: i0.ɵɵFactoryDeclaration<ReactiveFormsModule, never>;
5234 |     static ɵmod: i0.ɵɵNgModuleDeclaration<ReactiveFormsModule, [typeof FormControlDirective, typeof FormGroupDirective, typeof FormControlName, typeof FormGroupName, typeof FormArrayName], never, [typeof ɵInternalFormsSharedModule, typeof FormControlDirective, typeof FormGroupDirective, typeof FormControlName, typeof FormGroupName, typeof FormArrayName]>;
5235 |     static ɵinj: i0.ɵɵInjectorDeclaration<ReactiveFormsModule>;
5236 | }
5237 | 
5238 | export { AbstractControl, AbstractControlDirective, AbstractFormGroupDirective, COMPOSITION_BUFFER_MODE, CheckboxControlValueAccessor, CheckboxRequiredValidator, ControlContainer, ControlEvent, DefaultValueAccessor, EmailValidator, FormArray, FormArrayName, FormBuilder, FormControl, FormControlDirective, FormControlName, FormGroup, FormGroupDirective, FormGroupName, FormRecord, FormResetEvent, FormSubmittedEvent, FormsModule, MaxLengthValidator, MaxValidator, MinLengthValidator, MinValidator, NG_ASYNC_VALIDATORS, NG_VALIDATORS, NG_VALUE_ACCESSOR, NgControl, NgControlStatus, NgControlStatusGroup, NgForm, NgModel, NgModelGroup, NgSelectOption, NonNullableFormBuilder, NumberValueAccessor, PatternValidator, PristineChangeEvent, RadioControlValueAccessor, RangeValueAccessor, ReactiveFormsModule, RequiredValidator, SelectControlValueAccessor, SelectMultipleControlValueAccessor, StatusChangeEvent, TouchedChangeEvent, UntypedFormArray, UntypedFormBuilder, UntypedFormControl, UntypedFormGroup, VERSION, Validators, ValueChangeEvent, isFormArray, isFormControl, isFormGroup, isFormRecord, ɵInternalFormsSharedModule, ɵNgNoValidate, ɵNgSelectMultipleOption };
5239 | export type { AbstractControlOptions, AsyncValidator, AsyncValidatorFn, ControlConfig, ControlValueAccessor, Form, FormControlOptions, FormControlState, FormControlStatus, SetDisabledStateOption, ValidationErrors, Validator, ValidatorFn, ɵCoerceStrArrToNumArr, ɵElement, ɵFormArrayRawValue, ɵFormArrayValue, ɵFormControlCtor, ɵFormGroupRawValue, ɵFormGroupValue, ɵGetProperty, ɵNavigate, ɵOptionalKeys, ɵRawValue, ɵTokenize, ɵTypedOrUntyped, ɵValue, ɵWriteable };
5240 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "@angular/forms",
 3 |   "version": "20.1.0-next.0+sha-21fc93b",
 4 |   "description": "Angular - directives and services for creating forms",
 5 |   "author": "angular",
 6 |   "license": "MIT",
 7 |   "engines": {
 8 |     "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
 9 |   },
10 |   "dependencies": {
11 |     "tslib": "^2.3.0"
12 |   },
13 |   "peerDependencies": {
14 |     "@angular/core": "20.1.0-next.0+sha-21fc93b",
15 |     "@angular/common": "20.1.0-next.0+sha-21fc93b",
16 |     "@angular/platform-browser": "20.1.0-next.0+sha-21fc93b",
17 |     "rxjs": "^6.5.3 || ^7.4.0"
18 |   },
19 |   "repository": {
20 |     "type": "git",
21 |     "url": "https://github.com/angular/angular.git",
22 |     "directory": "packages/forms"
23 |   },
24 |   "ng-update": {
25 |     "packageGroup": [
26 |       "@angular/core",
27 |       "@angular/bazel",
28 |       "@angular/common",
29 |       "@angular/compiler",
30 |       "@angular/compiler-cli",
31 |       "@angular/animations",
32 |       "@angular/elements",
33 |       "@angular/platform-browser",
34 |       "@angular/platform-browser-dynamic",
35 |       "@angular/forms",
36 |       "@angular/platform-server",
37 |       "@angular/upgrade",
38 |       "@angular/router",
39 |       "@angular/language-service",
40 |       "@angular/localize",
41 |       "@angular/service-worker"
42 |     ]
43 |   },
44 |   "sideEffects": false,
45 |   "module": "./fesm2022/forms.mjs",
46 |   "typings": "./index.d.ts",
47 |   "type": "module",
48 |   "exports": {
49 |     "./package.json": {
50 |       "default": "./package.json"
51 |     },
52 |     ".": {
53 |       "types": "./index.d.ts",
54 |       "default": "./fesm2022/forms.mjs"
55 |     }
56 |   }
57 | }


--------------------------------------------------------------------------------