@angular/forms 20.0.0 → 20.1.0-next.0

package/index.d.ts

@@ -1,11 +1,11 @@
 /**
- * @license Angular v20.0.0
+ * @license Angular v20.1.0-next.0
  * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */
 
 import * as i0 from '@angular/core';
-import { Renderer2, ElementRef, InjectionToken, OnDestroy, OnChanges, SimpleChanges, OnInit, Injector, EventEmitter, ChangeDetectorRef, AfterViewInit, Version, ModuleWithProviders } from '@angular/core';
+import { InjectionToken, Renderer2, ElementRef, OnDestroy, OnChanges, SimpleChanges, OnInit, Injector, EventEmitter, ChangeDetectorRef, AfterViewInit, Version, ModuleWithProviders } from '@angular/core';
 import { Observable } from 'rxjs';
 
 /**
@@ -255,9 +255,9 @@ declare const NG_VALUE_ACCESSOR: InjectionToken<readonly ControlValueAccessor[]>
  *
  * ```html
  * <select [compareWith]="compareFn"  [formControl]="selectedCountriesControl">
- *     <option *ngFor="let country of countries" [ngValue]="country">
- *         {{country.name}}
- *     </option>
+ *    @for(country of countries; track $index) {
+ *        <option[ngValue]="country">{{country.name}}</option>
+ *    }
  * </select>
  *
  * compareFn(c1: Country, c2: Country): boolean {
@@ -354,9 +354,9 @@ declare class NgSelectOption implements OnDestroy {
  *
  * ```html
  * <select multiple name="countries" [formControl]="countryControl">
- *   <option *ngFor="let country of countries" [ngValue]="country">
- *     {{ country.name }}
- *   </option>
+ *   @for(country of countries; track $index) {
+ *      <option [ngValue]="country">{{ country.name }}</option>
+ *   }
  * </select>
  * ```
  *
@@ -1346,283 +1346,240 @@ declare const UntypedFormArray: UntypedFormArrayCtor;
 declare const isFormArray: (control: unknown) => control is FormArray;
 
 /**
- * FormGroupValue extracts the type of `.value` from a FormGroup's inner object type. The untyped
- * case falls back to {[key: string]: any}.
- *
- * Angular uses this type internally to support Typed Forms; do not use it directly.
+ * FormControlState is a boxed form value. It is an object with a `value` key and a `disabled` key.
  *
- * For internal use only.
+ * @publicApi
  */
-type ɵFormGroupValue<T extends {
-    [K in keyof T]?: AbstractControl<any>;
-}> = ɵTypedOrUntyped<T, Partial<{
-    [K in keyof T]: ɵValue<T[K]>;
-}>, {
-    [key: string]: any;
-}>;
+interface FormControlState<T> {
+    value: T;
+    disabled: boolean;
+}
 /**
- * FormGroupRawValue extracts the type of `.getRawValue()` from a FormGroup's inner object type. The
- * untyped case falls back to {[key: string]: any}.
+ * Interface for options provided to a `FormControl`.
  *
- * Angular uses this type internally to support Typed Forms; do not use it directly.
+ * This interface extends all options from {@link AbstractControlOptions}, plus some options
+ * unique to `FormControl`.
  *
- * For internal use only.
+ * @publicApi
  */
-type ɵFormGroupRawValue<T extends {
-    [K in keyof T]?: AbstractControl<any>;
-}> = ɵTypedOrUntyped<T, {
-    [K in keyof T]: ɵRawValue<T[K]>;
-}, {
-    [key: string]: any;
-}>;
+interface FormControlOptions extends AbstractControlOptions {
+    /**
+     * @description
+     * Whether to use the initial value used to construct the `FormControl` as its default value
+     * as well. If this option is false or not provided, the default value of a FormControl is `null`.
+     * When a FormControl is reset without an explicit value, its value reverts to
+     * its default value.
+     */
+    nonNullable?: boolean;
+    /**
+     * @deprecated Use `nonNullable` instead.
+     */
+    initialValueIsDefault?: boolean;
+}
 /**
- * OptionalKeys returns the union of all optional keys in the object.
- *
- * Angular uses this type internally to support Typed Forms; do not use it directly.
+ * Various available constructors for `FormControl`.
+ * Do not use this interface directly. Instead, use `FormControl`:
+ * ```ts
+ * const fc = new FormControl('foo');
+ * ```
+ * This symbol is prefixed with ɵ to make plain that it is an internal symbol.
  */
-type ɵOptionalKeys<T> = {
-    [K in keyof T]-?: undefined extends T[K] ? K : never;
-}[keyof T];
+interface ɵFormControlCtor {
+    /**
+     * Construct a FormControl with no initial value or validators.
+     */
+    new (): FormControl<any>;
+    /**
+     * Creates a new `FormControl` instance.
+     *
+     * @param value Initializes the control with an initial value,
+     * or an object that defines the initial value and disabled state.
+     *
+     * @param opts A `FormControlOptions` object that contains validation functions and a
+     * validation trigger. `nonNullable` have to be `true`
+     */
+    new <T = any>(value: FormControlState<T> | T, opts: FormControlOptions & {
+        nonNullable: true;
+    }): FormControl<T>;
+    /**
+     * @deprecated Use `nonNullable` instead.
+     */
+    new <T = any>(value: FormControlState<T> | T, opts: FormControlOptions & {
+        initialValueIsDefault: true;
+    }): FormControl<T>;
+    /**
+     * @deprecated When passing an `options` argument, the `asyncValidator` argument has no effect.
+     */
+    new <T = any>(value: FormControlState<T> | T, opts: FormControlOptions, asyncValidator: AsyncValidatorFn | AsyncValidatorFn[]): FormControl<T | null>;
+    /**
+     * Creates a new `FormControl` instance.
+     *
+     * @param value Initializes the control with an initial value,
+     * or an object that defines the initial value and disabled state.
+     *
+     * @param validatorOrOpts A synchronous validator function, or an array of
+     * such functions, or a `FormControlOptions` object that contains validation functions
+     * and a validation trigger.
+     *
+     * @param asyncValidator A single async validator or array of async validator functions
+     */
+    new <T = any>(value: FormControlState<T> | T, validatorOrOpts?: ValidatorFn | ValidatorFn[] | FormControlOptions | null, asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null): FormControl<T | null>;
+    /**
+     * The presence of an explicit `prototype` property provides backwards-compatibility for apps that
+     * manually inspect the prototype chain.
+     */
+    prototype: FormControl<any>;
+}
 /**
- * Tracks the value and validity state of a group of `FormControl` instances.
+ * Tracks the value and validation status of an individual form control.
  *
- * A `FormGroup` aggregates the values of each child `FormControl` into one object,
- * with each control name as the key.  It calculates its status by reducing the status values
- * of its children. For example, if one of the controls in a group is invalid, the entire
- * group becomes invalid.
+ * This is one of the four fundamental building blocks of Angular forms, along with
+ * `FormGroup`, `FormArray` and `FormRecord`. It extends the `AbstractControl` class that
+ * implements most of the base functionality for accessing the value, validation status,
+ * user interactions and events.
  *
- * `FormGroup` is one of the four fundamental building blocks used to define forms in Angular,
- * along with `FormControl`, `FormArray`, and `FormRecord`.
+ * `FormControl` takes a single generic argument, which describes the type of its value. This
+ * argument always implicitly includes `null` because the control can be reset. To change this
+ * behavior, set `nonNullable` or see the usage notes below.
  *
- * When instantiating a `FormGroup`, pass in a collection of child controls as the first
- * argument. The key for each child registers the name for the control.
+ * See [usage examples below](#usage-notes).
  *
- * `FormGroup` is intended for use cases where the keys are known ahead of time.
- * If you need to dynamically add and remove controls, use {@link FormRecord} instead.
+ * @see {@link AbstractControl}
+ * @see [Reactive Forms Guide](guide/forms/reactive-forms)
+ * @see [Usage Notes](#usage-notes)
  *
- * `FormGroup` accepts an optional type parameter `TControl`, which is an object type with inner
- * control types as values.
+ * @publicApi
+ *
+ * @overriddenImplementation ɵFormControlCtor
  *
  * @usageNotes
  *
- * ### Create a form group with 2 controls
+ * ### Initializing Form Controls
+ *
+ * Instantiate a `FormControl`, with an initial value.
  *
  * ```ts
- * const form = new FormGroup({
- *   first: new FormControl('Nancy', Validators.minLength(2)),
- *   last: new FormControl('Drew'),
- * });
+ * const control = new FormControl('some value');
+ * console.log(control.value);     // 'some value'
+ * ```
  *
- * console.log(form.value);   // {first: 'Nancy', last; 'Drew'}
- * console.log(form.status);  // 'VALID'
+ * The following example initializes the control with a form state object. The `value`
+ * and `disabled` keys are required in this case.
+ *
+ * ```ts
+ * const control = new FormControl({ value: 'n/a', disabled: true });
+ * console.log(control.value);     // 'n/a'
+ * console.log(control.status);    // 'DISABLED'
  * ```
  *
- * ### The type argument, and optional controls
+ * The following example initializes the control with a synchronous validator.
  *
- * `FormGroup` accepts one generic argument, which is an object containing its inner controls.
- * This type will usually be inferred automatically, but you can always specify it explicitly if you
- * wish.
+ * ```ts
+ * const control = new FormControl('', Validators.required);
+ * console.log(control.value);      // ''
+ * console.log(control.status);     // 'INVALID'
+ * ```
  *
- * If you have controls that are optional (i.e. they can be removed, you can use the `?` in the
- * type):
+ * The following example initializes the control using an options object.
  *
  * ```ts
- * const form = new FormGroup<{
- *   first: FormControl<string|null>,
- *   middle?: FormControl<string|null>, // Middle name is optional.
- *   last: FormControl<string|null>,
- * }>({
- *   first: new FormControl('Nancy'),
- *   last: new FormControl('Drew'),
+ * const control = new FormControl('', {
+ *    validators: Validators.required,
+ *    asyncValidators: myAsyncValidator
  * });
  * ```
  *
- * ### Create a form group with a group-level validator
+ * ### The single type argument
  *
- * You include group-level validators as the second arg, or group-level async
- * validators as the third arg. These come in handy when you want to perform validation
- * that considers the value of more than one child control.
+ * `FormControl` accepts a generic argument, which describes the type of its value.
+ * In most cases, this argument will be inferred.
+ *
+ * If you are initializing the control to `null`, or you otherwise wish to provide a
+ * wider type, you may specify the argument explicitly:
  *
  * ```ts
- * const form = new FormGroup({
- *   password: new FormControl('', Validators.minLength(2)),
- *   passwordConfirm: new FormControl('', Validators.minLength(2)),
- * }, passwordMatchValidator);
+ * let fc = new FormControl<string|null>(null);
+ * fc.setValue('foo');
+ * ```
  *
+ * You might notice that `null` is always added to the type of the control.
+ * This is because the control will become `null` if you call `reset`. You can change
+ * this behavior by setting `{nonNullable: true}`.
  *
- * function passwordMatchValidator(g: FormGroup) {
- *    return g.get('password').value === g.get('passwordConfirm').value
- *       ? null : {'mismatch': true};
- * }
+ * ### Configure the control to update on a blur event
+ *
+ * Set the `updateOn` option to `'blur'` to update on the blur `event`.
+ *
+ * ```ts
+ * const control = new FormControl('', { updateOn: 'blur' });
  * ```
  *
- * Like `FormControl` instances, you choose to pass in
- * validators and async validators as part of an options object.
+ * ### Configure the control to update on a submit event
+ *
+ * Set the `updateOn` option to `'submit'` to update on a submit `event`.
  *
  * ```ts
- * const form = new FormGroup({
- *   password: new FormControl('')
- *   passwordConfirm: new FormControl('')
- * }, { validators: passwordMatchValidator, asyncValidators: otherValidator });
+ * const control = new FormControl('', { updateOn: 'submit' });
  * ```
  *
- * ### Set the updateOn property for all controls in a form group
+ * ### Reset the control back to a specific value
  *
- * The options object is used to set a default value for each child
- * control's `updateOn` property. If you set `updateOn` to `'blur'` at the
- * group level, all child controls default to 'blur', unless the child
- * has explicitly specified a different `updateOn` value.
+ * You reset to a specific form state by passing through a standalone
+ * value or a form state object that contains both a value and a disabled state
+ * (these are the only two properties that cannot be calculated).
  *
  * ```ts
- * const c = new FormGroup({
- *   one: new FormControl()
- * }, { updateOn: 'blur' });
+ * const control = new FormControl('Nancy');
+ *
+ * console.log(control.value); // 'Nancy'
+ *
+ * control.reset('Drew');
+ *
+ * console.log(control.value); // 'Drew'
  * ```
  *
- * ### Using a FormGroup with optional controls
+ * ### Reset the control to its initial value
  *
- * It is possible to have optional controls in a FormGroup. An optional control can be removed later
- * using `removeControl`, and can be omitted when calling `reset`. Optional controls must be
- * declared optional in the group's type.
+ * If you wish to always reset the control to its initial value (instead of null),
+ * you can pass the `nonNullable` option:
  *
  * ```ts
- * const c = new FormGroup<{one?: FormControl<string>}>({
- *   one: new FormControl('')
- * });
+ * const control = new FormControl('Nancy', {nonNullable: true});
+ *
+ * console.log(control.value); // 'Nancy'
+ *
+ * control.reset();
+ *
+ * console.log(control.value); // 'Nancy'
  * ```
  *
- * Notice that `c.value.one` has type `string|null|undefined`. This is because calling `c.reset({})`
- * without providing the optional key `one` will cause it to become `null`.
+ * ### Reset the control back to an initial value and disabled
  *
- * @publicApi
+ * ```ts
+ * const control = new FormControl('Nancy');
+ *
+ * console.log(control.value); // 'Nancy'
+ * console.log(control.status); // 'VALID'
+ *
+ * control.reset({ value: 'Drew', disabled: true });
+ *
+ * console.log(control.value); // 'Drew'
+ * console.log(control.status); // 'DISABLED'
+ * ```
  */
-declare class FormGroup<TControl extends {
-    [K in keyof TControl]: AbstractControl<any>;
-} = any> extends AbstractControl<ɵTypedOrUntyped<TControl, ɵFormGroupValue<TControl>, any>, ɵTypedOrUntyped<TControl, ɵFormGroupRawValue<TControl>, any>> {
-    /**
-     * Creates a new `FormGroup` instance.
-     *
-     * @param controls A collection of child controls. The key for each child is the name
-     * under which it is registered.
-     *
-     * @param validatorOrOpts A synchronous validator function, or an array of
-     * such functions, or an `AbstractControlOptions` object that contains validation functions
-     * and a validation trigger.
-     *
-     * @param asyncValidator A single async validator or array of async validator functions
-     *
-     */
-    constructor(controls: TControl, validatorOrOpts?: ValidatorFn | ValidatorFn[] | AbstractControlOptions | null, asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null);
-    controls: ɵTypedOrUntyped<TControl, TControl, {
-        [key: string]: AbstractControl<any>;
-    }>;
-    /**
-     * Registers a control with the group's list of controls. In a strongly-typed group, the control
-     * must be in the group's type (possibly as an optional key).
-     *
-     * This method does not update the value or validity of the control.
-     * Use {@link FormGroup#addControl addControl} instead.
-     *
-     * @param name The control name to register in the collection
-     * @param control Provides the control for the given name
-     */
-    registerControl<K extends string & keyof TControl>(name: K, control: TControl[K]): TControl[K];
-    registerControl(this: FormGroup<{
-        [key: string]: AbstractControl<any>;
-    }>, name: string, control: AbstractControl<any>): AbstractControl<any>;
-    /**
-     * Add a control to this group. In a strongly-typed group, the control must be in the group's type
-     * (possibly as an optional key).
-     *
-     * If a control with a given name already exists, it would *not* be replaced with a new one.
-     * If you want to replace an existing control, use the {@link FormGroup#setControl setControl}
-     * method instead. This method also updates the value and validity of the control.
-     *
-     * @param name The control name to add to the collection
-     * @param control Provides the control for the given name
-     * @param options Specifies whether this FormGroup instance should emit events after a new
-     *     control is added.
-     * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
-     * `valueChanges` observables emit events with the latest status and value when the control is
-     * added. When false, no events are emitted.
-     */
-    addControl(this: FormGroup<{
-        [key: string]: AbstractControl<any>;
-    }>, name: string, control: AbstractControl, options?: {
-        emitEvent?: boolean;
-    }): void;
-    addControl<K extends string & keyof TControl>(name: K, control: Required<TControl>[K], options?: {
-        emitEvent?: boolean;
-    }): void;
-    removeControl(this: FormGroup<{
-        [key: string]: AbstractControl<any>;
-    }>, name: string, options?: {
-        emitEvent?: boolean;
-    }): void;
-    removeControl<S extends string>(name: ɵOptionalKeys<TControl> & S, options?: {
-        emitEvent?: boolean;
-    }): void;
-    /**
-     * Replace an existing control. In a strongly-typed group, the control must be in the group's type
-     * (possibly as an optional key).
-     *
-     * If a control with a given name does not exist in this `FormGroup`, it will be added.
-     *
-     * @param name The control name to replace in the collection
-     * @param control Provides the control for the given name
-     * @param options Specifies whether this FormGroup instance should emit events after an
-     *     existing control is replaced.
-     * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
-     * `valueChanges` observables emit events with the latest status and value when the control is
-     * replaced with a new one. When false, no events are emitted.
-     */
-    setControl<K extends string & keyof TControl>(name: K, control: TControl[K], options?: {
-        emitEvent?: boolean;
-    }): void;
-    setControl(this: FormGroup<{
-        [key: string]: AbstractControl<any>;
-    }>, name: string, control: AbstractControl, options?: {
-        emitEvent?: boolean;
-    }): void;
+interface FormControl<TValue = any> extends AbstractControl<TValue> {
     /**
-     * Check whether there is an enabled control with the given name in the group.
-     *
-     * Reports false for disabled controls. If you'd like to check for existence in the group
-     * only, use {@link AbstractControl#get get} instead.
-     *
-     * @param controlName The control name to check for existence in the collection
-     *
-     * @returns false for disabled controls, true otherwise.
+     * The default value of this FormControl, used whenever the control is reset without an explicit
+     * value. See {@link FormControlOptions#nonNullable} for more information on configuring
+     * a default value.
      */
-    contains<K extends string>(controlName: K): boolean;
-    contains(this: FormGroup<{
-        [key: string]: AbstractControl<any>;
-    }>, controlName: string): boolean;
+    readonly defaultValue: TValue;
     /**
-     * Sets the value of the `FormGroup`. It accepts an object that matches
-     * the structure of the group, with control names as keys.
-     *
-     * @usageNotes
-     * ### Set the complete value for the form group
-     *
-     * ```ts
-     * const form = new FormGroup({
-     *   first: new FormControl(),
-     *   last: new FormControl()
-     * });
-     *
-     * console.log(form.value);   // {first: null, last: null}
-     *
-     * form.setValue({first: 'Nancy', last: 'Drew'});
-     * console.log(form.value);   // {first: 'Nancy', last: 'Drew'}
-     * ```
-     *
-     * @throws When strict checks fail, such as setting the value of a control
-     * that doesn't exist or if you exclude a value of a control that does exist.
+     * Sets a new value for the form control.
      *
-     * @param value The new value for the control that matches the structure of the group.
+     * @param value The new value for the control.
      * @param options Configuration options that determine how the control propagates changes
-     * and emits events after the value changes.
+     * and emits events when the value changes.
      * The configuration options are passed to the {@link AbstractControl#updateValueAndValidity
      * updateValueAndValidity} method.
      *
@@ -1632,293 +1589,693 @@ declare class FormGroup<TControl extends {
      * `valueChanges`
      * observables emit events with the latest status and value when the control value is updated.
      * When false, no events are emitted.
+     * * `emitModelToViewChange`: When true or not supplied  (the default), each change triggers an
+     * `onChange` event to
+     * update the view.
+     * * `emitViewToModelChange`: When true or not supplied (the default), each change triggers an
+     * `ngModelChange`
+     * event to update the model.
+     *
      */
-    setValue(value: ɵFormGroupRawValue<TControl>, options?: {
+    setValue(value: TValue, options?: {
         onlySelf?: boolean;
         emitEvent?: boolean;
+        emitModelToViewChange?: boolean;
+        emitViewToModelChange?: boolean;
     }): void;
     /**
-     * Patches the value of the `FormGroup`. It accepts an object with control
-     * names as keys, and does its best to match the values to the correct controls
-     * in the group.
-     *
-     * It accepts both super-sets and sub-sets of the group without throwing an error.
-     *
-     * @usageNotes
-     * ### Patch the value for a form group
-     *
-     * ```ts
-     * const form = new FormGroup({
-     *    first: new FormControl(),
-     *    last: new FormControl()
-     * });
-     * console.log(form.value);   // {first: null, last: null}
+     * Patches the value of a control.
      *
-     * form.patchValue({first: 'Nancy'});
-     * console.log(form.value);   // {first: 'Nancy', last: null}
-     * ```
+     * This function is functionally the same as {@link FormControl#setValue setValue} at this level.
+     * It exists for symmetry with {@link FormGroup#patchValue patchValue} on `FormGroups` and
+     * `FormArrays`, where it does behave differently.
      *
-     * @param value The object that matches the structure of the group.
-     * @param options Configuration options that determine how the control propagates changes and
-     * emits events after the value is patched.
-     * * `onlySelf`: When true, each change only affects this control and not its parent. Default is
-     * true.
-     * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
-     * `valueChanges` observables emit events with the latest status and value when the control value
-     * is updated. When false, no events are emitted. The configuration options are passed to
-     * the {@link AbstractControl#updateValueAndValidity updateValueAndValidity} method.
+     * @see {@link FormControl#setValue} for options
      */
-    patchValue(value: ɵFormGroupValue<TControl>, options?: {
+    patchValue(value: TValue, options?: {
         onlySelf?: boolean;
         emitEvent?: boolean;
+        emitModelToViewChange?: boolean;
+        emitViewToModelChange?: boolean;
     }): void;
     /**
-     * Resets the `FormGroup`, marks all descendants `pristine` and `untouched` and sets
-     * the value of all descendants to their default values, or null if no defaults were provided.
+     * Resets the form control, marking it `pristine` and `untouched`, and resetting
+     * the value. The new value will be the provided value (if passed), `null`, or the initial value
+     * if `nonNullable` was set in the constructor via {@link FormControlOptions}.
      *
-     * You reset to a specific form state by passing in a map of states
-     * that matches the structure of your form, with control names as keys. The state
-     * is a standalone value or a form state object with both a value and a disabled
-     * status.
+     * ```ts
+     * // By default, the control will reset to null.
+     * const dog = new FormControl('spot');
+     * dog.reset(); // dog.value is null
      *
-     * @param value Resets the control with an initial value,
+     * // If this flag is set, the control will instead reset to the initial value.
+     * const cat = new FormControl('tabby', {nonNullable: true});
+     * cat.reset(); // cat.value is "tabby"
+     *
+     * // A value passed to reset always takes precedence.
+     * const fish = new FormControl('finn', {nonNullable: true});
+     * fish.reset('bubble'); // fish.value is "bubble"
+     * ```
+     *
+     * @param formState Resets the control with an initial value,
      * or an object that defines the initial value and disabled state.
      *
      * @param options Configuration options that determine how the control propagates changes
-     * and emits events when the group is reset.
+     * and emits events after the value changes.
+     *
      * * `onlySelf`: When true, each change only affects this control, and not its parent. Default is
      * false.
      * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
      * `valueChanges`
      * observables emit events with the latest status and value when the control is reset.
      * When false, no events are emitted.
-     * The configuration options are passed to the {@link AbstractControl#updateValueAndValidity
-     * updateValueAndValidity} method.
-     *
-     * @usageNotes
-     *
-     * ### Reset the form group values
-     *
-     * ```ts
-     * const form = new FormGroup({
-     *   first: new FormControl('first name'),
-     *   last: new FormControl('last name')
-     * });
-     *
-     * console.log(form.value);  // {first: 'first name', last: 'last name'}
-     *
-     * form.reset({ first: 'name', last: 'last name' });
-     *
-     * console.log(form.value);  // {first: 'name', last: 'last name'}
-     * ```
-     *
-     * ### Reset the form group values and disabled status
-     *
-     * ```ts
-     * const form = new FormGroup({
-     *   first: new FormControl('first name'),
-     *   last: new FormControl('last name')
-     * });
-     *
-     * form.reset({
-     *   first: {value: 'name', disabled: true},
-     *   last: 'last'
-     * });
      *
-     * console.log(form.value);  // {last: 'last'}
-     * console.log(form.get('first').status);  // 'DISABLED'
-     * ```
      */
-    reset(value?: ɵTypedOrUntyped<TControl, ɵFormGroupValue<TControl>, any>, options?: {
+    reset(formState?: TValue | FormControlState<TValue>, options?: {
         onlySelf?: boolean;
         emitEvent?: boolean;
     }): void;
     /**
-     * The aggregate value of the `FormGroup`, including any disabled controls.
-     *
-     * Retrieves all values regardless of disabled status.
+     * For a simple FormControl, the raw value is equivalent to the value.
      */
-    getRawValue(): ɵTypedOrUntyped<TControl, ɵFormGroupRawValue<TControl>, any>;
+    getRawValue(): TValue;
+    /**
+     * Register a listener for change events.
+     *
+     * @param fn The method that is called when the value changes
+     */
+    registerOnChange(fn: Function): void;
+    /**
+     * Register a listener for disabled events.
+     *
+     * @param fn The method that is called when the disabled status changes.
+     */
+    registerOnDisabledChange(fn: (isDisabled: boolean) => void): void;
 }
-interface UntypedFormGroupCtor {
-    new (controls: {
-        [key: string]: AbstractControl;
-    }, validatorOrOpts?: ValidatorFn | ValidatorFn[] | AbstractControlOptions | null, asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null): UntypedFormGroup;
+declare const FormControl: ɵFormControlCtor;
+interface UntypedFormControlCtor {
+    new (): UntypedFormControl;
+    new (formState?: any, validatorOrOpts?: ValidatorFn | ValidatorFn[] | FormControlOptions | null, asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null): UntypedFormControl;
     /**
      * The presence of an explicit `prototype` property provides backwards-compatibility for apps that
      * manually inspect the prototype chain.
      */
-    prototype: FormGroup<any>;
+    prototype: FormControl<any>;
 }
 /**
- * UntypedFormGroup is a non-strongly-typed version of `FormGroup`.
+ * UntypedFormControl is a non-strongly-typed version of `FormControl`.
  */
-type UntypedFormGroup = FormGroup<any>;
-declare const UntypedFormGroup: UntypedFormGroupCtor;
+type UntypedFormControl = FormControl<any>;
+declare const UntypedFormControl: UntypedFormControlCtor;
 /**
  * @description
- * Asserts that the given control is an instance of `FormGroup`
+ * Asserts that the given control is an instance of `FormControl`
  *
  * @publicApi
  */
-declare const isFormGroup: (control: unknown) => control is FormGroup;
+declare const isFormControl: (control: unknown) => control is FormControl;
+
 /**
- * Tracks the value and validity state of a collection of `FormControl` instances, each of which has
- * the same value type.
+ * FormGroupValue extracts the type of `.value` from a FormGroup's inner object type. The untyped
+ * case falls back to {[key: string]: any}.
  *
- * `FormRecord` is very similar to {@link FormGroup}, except it can be used with a dynamic keys,
- * with controls added and removed as needed.
+ * Angular uses this type internally to support Typed Forms; do not use it directly.
  *
- * `FormRecord` accepts one generic argument, which describes the type of the controls it contains.
+ * For internal use only.
+ */
+type ɵFormGroupArgumentValue<T extends {
+    [K in keyof T]?: AbstractControl<any>;
+}> = ɵTypedOrUntyped<T, Partial<{
+    [K in keyof T]: ɵValue<T[K]> | FormControlState<ɵValue<T[K]>>;
+}>, {
+    [key: string]: any;
+}>;
+type ɵFormGroupValue<T extends {
+    [K in keyof T]?: AbstractControl<any>;
+}> = ɵTypedOrUntyped<T, Partial<{
+    [K in keyof T]: ɵValue<T[K]>;
+}>, {
+    [key: string]: any;
+}>;
+/**
+ * FormGroupRawValue extracts the type of `.getRawValue()` from a FormGroup's inner object type. The
+ * untyped case falls back to {[key: string]: any}.
+ *
+ * Angular uses this type internally to support Typed Forms; do not use it directly.
+ *
+ * For internal use only.
+ */
+type ɵFormGroupRawValue<T extends {
+    [K in keyof T]?: AbstractControl<any>;
+}> = ɵTypedOrUntyped<T, {
+    [K in keyof T]: ɵRawValue<T[K]>;
+}, {
+    [key: string]: any;
+}>;
+/**
+ * OptionalKeys returns the union of all optional keys in the object.
+ *
+ * Angular uses this type internally to support Typed Forms; do not use it directly.
+ */
+type ɵOptionalKeys<T> = {
+    [K in keyof T]-?: undefined extends T[K] ? K : never;
+}[keyof T];
+/**
+ * Tracks the value and validity state of a group of `FormControl` instances.
+ *
+ * A `FormGroup` aggregates the values of each child `FormControl` into one object,
+ * with each control name as the key.  It calculates its status by reducing the status values
+ * of its children. For example, if one of the controls in a group is invalid, the entire
+ * group becomes invalid.
+ *
+ * `FormGroup` is one of the four fundamental building blocks used to define forms in Angular,
+ * along with `FormControl`, `FormArray`, and `FormRecord`.
+ *
+ * When instantiating a `FormGroup`, pass in a collection of child controls as the first
+ * argument. The key for each child registers the name for the control.
+ *
+ * `FormGroup` is intended for use cases where the keys are known ahead of time.
+ * If you need to dynamically add and remove controls, use {@link FormRecord} instead.
+ *
+ * `FormGroup` accepts an optional type parameter `TControl`, which is an object type with inner
+ * control types as values.
  *
  * @usageNotes
  *
+ * ### Create a form group with 2 controls
+ *
  * ```ts
- * let numbers = new FormRecord({bill: new FormControl('415-123-456')});
- * numbers.addControl('bob', new FormControl('415-234-567'));
- * numbers.removeControl('bill');
+ * const form = new FormGroup({
+ *   first: new FormControl('Nancy', Validators.minLength(2)),
+ *   last: new FormControl('Drew'),
+ * });
+ *
+ * console.log(form.value);   // {first: 'Nancy', last; 'Drew'}
+ * console.log(form.status);  // 'VALID'
+ * ```
+ *
+ * ### The type argument, and optional controls
+ *
+ * `FormGroup` accepts one generic argument, which is an object containing its inner controls.
+ * This type will usually be inferred automatically, but you can always specify it explicitly if you
+ * wish.
+ *
+ * If you have controls that are optional (i.e. they can be removed, you can use the `?` in the
+ * type):
+ *
+ * ```ts
+ * const form = new FormGroup<{
+ *   first: FormControl<string|null>,
+ *   middle?: FormControl<string|null>, // Middle name is optional.
+ *   last: FormControl<string|null>,
+ * }>({
+ *   first: new FormControl('Nancy'),
+ *   last: new FormControl('Drew'),
+ * });
+ * ```
+ *
+ * ### Create a form group with a group-level validator
+ *
+ * You include group-level validators as the second arg, or group-level async
+ * validators as the third arg. These come in handy when you want to perform validation
+ * that considers the value of more than one child control.
+ *
+ * ```ts
+ * const form = new FormGroup({
+ *   password: new FormControl('', Validators.minLength(2)),
+ *   passwordConfirm: new FormControl('', Validators.minLength(2)),
+ * }, passwordMatchValidator);
+ *
+ *
+ * function passwordMatchValidator(g: FormGroup) {
+ *    return g.get('password').value === g.get('passwordConfirm').value
+ *       ? null : {'mismatch': true};
+ * }
+ * ```
+ *
+ * Like `FormControl` instances, you choose to pass in
+ * validators and async validators as part of an options object.
+ *
+ * ```ts
+ * const form = new FormGroup({
+ *   password: new FormControl('')
+ *   passwordConfirm: new FormControl('')
+ * }, { validators: passwordMatchValidator, asyncValidators: otherValidator });
+ * ```
+ *
+ * ### Set the updateOn property for all controls in a form group
+ *
+ * The options object is used to set a default value for each child
+ * control's `updateOn` property. If you set `updateOn` to `'blur'` at the
+ * group level, all child controls default to 'blur', unless the child
+ * has explicitly specified a different `updateOn` value.
+ *
+ * ```ts
+ * const c = new FormGroup({
+ *   one: new FormControl()
+ * }, { updateOn: 'blur' });
+ * ```
+ *
+ * ### Using a FormGroup with optional controls
+ *
+ * It is possible to have optional controls in a FormGroup. An optional control can be removed later
+ * using `removeControl`, and can be omitted when calling `reset`. Optional controls must be
+ * declared optional in the group's type.
+ *
+ * ```ts
+ * const c = new FormGroup<{one?: FormControl<string>}>({
+ *   one: new FormControl('')
+ * });
  * ```
  *
+ * Notice that `c.value.one` has type `string|null|undefined`. This is because calling `c.reset({})`
+ * without providing the optional key `one` will cause it to become `null`.
+ *
  * @publicApi
  */
-declare class FormRecord<TControl extends AbstractControl = AbstractControl> extends FormGroup<{
-    [key: string]: TControl;
-}> {
-}
-interface FormRecord<TControl> {
+declare class FormGroup<TControl extends {
+    [K in keyof TControl]: AbstractControl<any>;
+} = any> extends AbstractControl<ɵTypedOrUntyped<TControl, ɵFormGroupValue<TControl>, any>, ɵTypedOrUntyped<TControl, ɵFormGroupRawValue<TControl>, any>, ɵTypedOrUntyped<TControl, ɵFormGroupArgumentValue<TControl>, any>> {
     /**
-     * Registers a control with the records's list of controls.
+     * Creates a new `FormGroup` instance.
+     *
+     * @param controls A collection of child controls. The key for each child is the name
+     * under which it is registered.
+     *
+     * @param validatorOrOpts A synchronous validator function, or an array of
+     * such functions, or an `AbstractControlOptions` object that contains validation functions
+     * and a validation trigger.
+     *
+     * @param asyncValidator A single async validator or array of async validator functions
      *
-     * See `FormGroup#registerControl` for additional information.
      */
-    registerControl(name: string, control: TControl): TControl;
+    constructor(controls: TControl, validatorOrOpts?: ValidatorFn | ValidatorFn[] | AbstractControlOptions | null, asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null);
+    controls: ɵTypedOrUntyped<TControl, TControl, {
+        [key: string]: AbstractControl<any>;
+    }>;
     /**
-     * Add a control to this group.
+     * Registers a control with the group's list of controls. In a strongly-typed group, the control
+     * must be in the group's type (possibly as an optional key).
      *
-     * See `FormGroup#addControl` for additional information.
+     * This method does not update the value or validity of the control.
+     * Use {@link FormGroup#addControl addControl} instead.
+     *
+     * @param name The control name to register in the collection
+     * @param control Provides the control for the given name
      */
-    addControl(name: string, control: TControl, options?: {
-        emitEvent?: boolean;
-    }): void;
+    registerControl<K extends string & keyof TControl>(name: K, control: TControl[K]): TControl[K];
+    registerControl(this: FormGroup<{
+        [key: string]: AbstractControl<any>;
+    }>, name: string, control: AbstractControl<any>): AbstractControl<any>;
     /**
-     * Remove a control from this group.
+     * Add a control to this group. In a strongly-typed group, the control must be in the group's type
+     * (possibly as an optional key).
      *
-     * See `FormGroup#removeControl` for additional information.
+     * If a control with a given name already exists, it would *not* be replaced with a new one.
+     * If you want to replace an existing control, use the {@link FormGroup#setControl setControl}
+     * method instead. This method also updates the value and validity of the control.
+     *
+     * @param name The control name to add to the collection
+     * @param control Provides the control for the given name
+     * @param options Specifies whether this FormGroup instance should emit events after a new
+     *     control is added.
+     * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
+     * `valueChanges` observables emit events with the latest status and value when the control is
+     * added. When false, no events are emitted.
      */
-    removeControl(name: string, options?: {
+    addControl(this: FormGroup<{
+        [key: string]: AbstractControl<any>;
+    }>, name: string, control: AbstractControl, options?: {
         emitEvent?: boolean;
     }): void;
-    /**
-     * Replace an existing control.
-     *
-     * See `FormGroup#setControl` for additional information.
-     */
-    setControl(name: string, control: TControl, options?: {
+    addControl<K extends string & keyof TControl>(name: K, control: Required<TControl>[K], options?: {
         emitEvent?: boolean;
     }): void;
-    /**
-     * Check whether there is an enabled control with the given name in the group.
-     *
-     * See `FormGroup#contains` for additional information.
+    removeControl(this: FormGroup<{
+        [key: string]: AbstractControl<any>;
+    }>, name: string, options?: {
+        emitEvent?: boolean;
+    }): void;
+    removeControl<S extends string>(name: ɵOptionalKeys<TControl> & S, options?: {
+        emitEvent?: boolean;
+    }): void;
+    /**
+     * Replace an existing control. In a strongly-typed group, the control must be in the group's type
+     * (possibly as an optional key).
+     *
+     * If a control with a given name does not exist in this `FormGroup`, it will be added.
+     *
+     * @param name The control name to replace in the collection
+     * @param control Provides the control for the given name
+     * @param options Specifies whether this FormGroup instance should emit events after an
+     *     existing control is replaced.
+     * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
+     * `valueChanges` observables emit events with the latest status and value when the control is
+     * replaced with a new one. When false, no events are emitted.
      */
-    contains(controlName: string): boolean;
+    setControl<K extends string & keyof TControl>(name: K, control: TControl[K], options?: {
+        emitEvent?: boolean;
+    }): void;
+    setControl(this: FormGroup<{
+        [key: string]: AbstractControl<any>;
+    }>, name: string, control: AbstractControl, options?: {
+        emitEvent?: boolean;
+    }): void;
     /**
-     * Sets the value of the `FormRecord`. It accepts an object that matches
+     * Check whether there is an enabled control with the given name in the group.
+     *
+     * Reports false for disabled controls. If you'd like to check for existence in the group
+     * only, use {@link AbstractControl#get get} instead.
+     *
+     * @param controlName The control name to check for existence in the collection
+     *
+     * @returns false for disabled controls, true otherwise.
+     */
+    contains<K extends string>(controlName: K): boolean;
+    contains(this: FormGroup<{
+        [key: string]: AbstractControl<any>;
+    }>, controlName: string): boolean;
+    /**
+     * Sets the value of the `FormGroup`. It accepts an object that matches
      * the structure of the group, with control names as keys.
      *
-     * See `FormGroup#setValue` for additional information.
+     * @usageNotes
+     * ### Set the complete value for the form group
+     *
+     * ```ts
+     * const form = new FormGroup({
+     *   first: new FormControl(),
+     *   last: new FormControl()
+     * });
+     *
+     * console.log(form.value);   // {first: null, last: null}
+     *
+     * form.setValue({first: 'Nancy', last: 'Drew'});
+     * console.log(form.value);   // {first: 'Nancy', last: 'Drew'}
+     * ```
+     *
+     * @throws When strict checks fail, such as setting the value of a control
+     * that doesn't exist or if you exclude a value of a control that does exist.
+     *
+     * @param value The new value for the control that matches the structure of the group.
+     * @param options Configuration options that determine how the control propagates changes
+     * and emits events after the value changes.
+     * The configuration options are passed to the {@link AbstractControl#updateValueAndValidity
+     * updateValueAndValidity} method.
+     *
+     * * `onlySelf`: When true, each change only affects this control, and not its parent. Default is
+     * false.
+     * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
+     * `valueChanges`
+     * observables emit events with the latest status and value when the control value is updated.
+     * When false, no events are emitted.
      */
-    setValue(value: {
-        [key: string]: ɵRawValue<TControl>;
-    }, options?: {
+    setValue(value: ɵFormGroupRawValue<TControl>, options?: {
         onlySelf?: boolean;
         emitEvent?: boolean;
     }): void;
     /**
-     * Patches the value of the `FormRecord`. It accepts an object with control
+     * Patches the value of the `FormGroup`. It accepts an object with control
      * names as keys, and does its best to match the values to the correct controls
      * in the group.
      *
-     * See `FormGroup#patchValue` for additional information.
+     * It accepts both super-sets and sub-sets of the group without throwing an error.
+     *
+     * @usageNotes
+     * ### Patch the value for a form group
+     *
+     * ```ts
+     * const form = new FormGroup({
+     *    first: new FormControl(),
+     *    last: new FormControl()
+     * });
+     * console.log(form.value);   // {first: null, last: null}
+     *
+     * form.patchValue({first: 'Nancy'});
+     * console.log(form.value);   // {first: 'Nancy', last: null}
+     * ```
+     *
+     * @param value The object that matches the structure of the group.
+     * @param options Configuration options that determine how the control propagates changes and
+     * emits events after the value is patched.
+     * * `onlySelf`: When true, each change only affects this control and not its parent. Default is
+     * true.
+     * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
+     * `valueChanges` observables emit events with the latest status and value when the control value
+     * is updated. When false, no events are emitted. The configuration options are passed to
+     * the {@link AbstractControl#updateValueAndValidity updateValueAndValidity} method.
      */
-    patchValue(value: {
-        [key: string]: ɵValue<TControl>;
-    }, options?: {
+    patchValue(value: ɵFormGroupValue<TControl>, options?: {
         onlySelf?: boolean;
         emitEvent?: boolean;
     }): void;
     /**
-     * Resets the `FormRecord`, marks all descendants `pristine` and `untouched` and sets
-     * the value of all descendants to null.
+     * Resets the `FormGroup`, marks all descendants `pristine` and `untouched` and sets
+     * the value of all descendants to their default values, or null if no defaults were provided.
      *
-     * See `FormGroup#reset` for additional information.
+     * You reset to a specific form state by passing in a map of states
+     * that matches the structure of your form, with control names as keys. The state
+     * is a standalone value or a form state object with both a value and a disabled
+     * status.
+     *
+     * @param value Resets the control with an initial value,
+     * or an object that defines the initial value and disabled state.
+     *
+     * @param options Configuration options that determine how the control propagates changes
+     * and emits events when the group is reset.
+     * * `onlySelf`: When true, each change only affects this control, and not its parent. Default is
+     * false.
+     * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
+     * `valueChanges`
+     * observables emit events with the latest status and value when the control is reset.
+     * When false, no events are emitted.
+     * The configuration options are passed to the {@link AbstractControl#updateValueAndValidity
+     * updateValueAndValidity} method.
+     *
+     * @usageNotes
+     *
+     * ### Reset the form group values
+     *
+     * ```ts
+     * const form = new FormGroup({
+     *   first: new FormControl('first name'),
+     *   last: new FormControl('last name')
+     * });
+     *
+     * console.log(form.value);  // {first: 'first name', last: 'last name'}
+     *
+     * form.reset({ first: 'name', last: 'last name' });
+     *
+     * console.log(form.value);  // {first: 'name', last: 'last name'}
+     * ```
+     *
+     * ### Reset the form group values and disabled status
+     *
+     * ```ts
+     * const form = new FormGroup({
+     *   first: new FormControl('first name'),
+     *   last: new FormControl('last name')
+     * });
+     *
+     * form.reset({
+     *   first: {value: 'name', disabled: true},
+     *   last: 'last'
+     * });
+     *
+     * console.log(form.value);  // {last: 'last'}
+     * console.log(form.get('first').status);  // 'DISABLED'
+     * ```
      */
-    reset(value?: {
-        [key: string]: ɵValue<TControl>;
-    }, options?: {
+    reset(value?: ɵTypedOrUntyped<TControl, ɵFormGroupArgumentValue<TControl>, any>, options?: {
         onlySelf?: boolean;
         emitEvent?: boolean;
     }): void;
     /**
-     * The aggregate value of the `FormRecord`, including any disabled controls.
+     * The aggregate value of the `FormGroup`, including any disabled controls.
      *
-     * See `FormGroup#getRawValue` for additional information.
+     * Retrieves all values regardless of disabled status.
      */
-    getRawValue(): {
-        [key: string]: ɵRawValue<TControl>;
-    };
+    getRawValue(): ɵTypedOrUntyped<TControl, ɵFormGroupRawValue<TControl>, any>;
+}
+interface UntypedFormGroupCtor {
+    new (controls: {
+        [key: string]: AbstractControl;
+    }, validatorOrOpts?: ValidatorFn | ValidatorFn[] | AbstractControlOptions | null, asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null): UntypedFormGroup;
+    /**
+     * The presence of an explicit `prototype` property provides backwards-compatibility for apps that
+     * manually inspect the prototype chain.
+     */
+    prototype: FormGroup<any>;
 }
+/**
+ * UntypedFormGroup is a non-strongly-typed version of `FormGroup`.
+ */
+type UntypedFormGroup = FormGroup<any>;
+declare const UntypedFormGroup: UntypedFormGroupCtor;
 /**
  * @description
- * Asserts that the given control is an instance of `FormRecord`
+ * Asserts that the given control is an instance of `FormGroup`
  *
  * @publicApi
  */
-declare const isFormRecord: (control: unknown) => control is FormRecord;
-
+declare const isFormGroup: (control: unknown) => control is FormGroup;
 /**
- * A form can have several different statuses. Each
- * possible status is returned as a string literal.
+ * Tracks the value and validity state of a collection of `FormControl` instances, each of which has
+ * the same value type.
  *
- * * **VALID**: Reports that a control is valid, meaning that no errors exist in the input
- * value.
- * * **INVALID**: Reports that a control is invalid, meaning that an error exists in the input
- * value.
- * * **PENDING**: Reports that a control is pending, meaning that async validation is
- * occurring and errors are not yet available for the input value.
- * * **DISABLED**: Reports that a control is
- * disabled, meaning that the control is exempt from ancestor calculations of validity or value.
+ * `FormRecord` is very similar to {@link FormGroup}, except it can be used with a dynamic keys,
+ * with controls added and removed as needed.
  *
- * @publicApi
- */
-type FormControlStatus = 'VALID' | 'INVALID' | 'PENDING' | 'DISABLED';
-/**
- * Base class for every event sent by `AbstractControl.events()`
+ * `FormRecord` accepts one generic argument, which describes the type of the controls it contains.
+ *
+ * @usageNotes
+ *
+ * ```ts
+ * let numbers = new FormRecord({bill: new FormControl('415-123-456')});
+ * numbers.addControl('bob', new FormControl('415-234-567'));
+ * numbers.removeControl('bill');
+ * ```
  *
  * @publicApi
  */
-declare abstract class ControlEvent<T = any> {
+declare class FormRecord<TControl extends AbstractControl = AbstractControl> extends FormGroup<{
+    [key: string]: TControl;
+}> {
+}
+interface FormRecord<TControl> {
     /**
-     * Form control from which this event is originated.
+     * Registers a control with the records's list of controls.
      *
-     * Note: the type of the control can't be infered from T as the event can be emitted by any of child controls
+     * See `FormGroup#registerControl` for additional information.
      */
-    abstract readonly source: AbstractControl<unknown>;
-}
-/**
- * Event fired when the value of a control changes.
- *
- * @publicApi
- */
-declare class ValueChangeEvent<T> extends ControlEvent<T> {
-    readonly value: T;
-    readonly source: AbstractControl;
-    constructor(value: T, source: AbstractControl);
-}
-/**
- * Event fired when the control's pristine state changes (pristine <=> dirty).
- *
- * @publicApi */
+    registerControl(name: string, control: TControl): TControl;
+    /**
+     * Add a control to this group.
+     *
+     * See `FormGroup#addControl` for additional information.
+     */
+    addControl(name: string, control: TControl, options?: {
+        emitEvent?: boolean;
+    }): void;
+    /**
+     * Remove a control from this group.
+     *
+     * See `FormGroup#removeControl` for additional information.
+     */
+    removeControl(name: string, options?: {
+        emitEvent?: boolean;
+    }): void;
+    /**
+     * Replace an existing control.
+     *
+     * See `FormGroup#setControl` for additional information.
+     */
+    setControl(name: string, control: TControl, options?: {
+        emitEvent?: boolean;
+    }): void;
+    /**
+     * Check whether there is an enabled control with the given name in the group.
+     *
+     * See `FormGroup#contains` for additional information.
+     */
+    contains(controlName: string): boolean;
+    /**
+     * Sets the value of the `FormRecord`. It accepts an object that matches
+     * the structure of the group, with control names as keys.
+     *
+     * See `FormGroup#setValue` for additional information.
+     */
+    setValue(value: {
+        [key: string]: ɵRawValue<TControl>;
+    }, options?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    /**
+     * Patches the value of the `FormRecord`. It accepts an object with control
+     * names as keys, and does its best to match the values to the correct controls
+     * in the group.
+     *
+     * See `FormGroup#patchValue` for additional information.
+     */
+    patchValue(value: {
+        [key: string]: ɵValue<TControl>;
+    }, options?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    /**
+     * Resets the `FormRecord`, marks all descendants `pristine` and `untouched` and sets
+     * the value of all descendants to null.
+     *
+     * See `FormGroup#reset` for additional information.
+     */
+    reset(value?: {
+        [key: string]: ɵValue<TControl> | FormControlState<ɵValue<TControl>>;
+    }, options?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    /**
+     * The aggregate value of the `FormRecord`, including any disabled controls.
+     *
+     * See `FormGroup#getRawValue` for additional information.
+     */
+    getRawValue(): {
+        [key: string]: ɵRawValue<TControl>;
+    };
+}
+/**
+ * @description
+ * Asserts that the given control is an instance of `FormRecord`
+ *
+ * @publicApi
+ */
+declare const isFormRecord: (control: unknown) => control is FormRecord;
+
+/**
+ * A form can have several different statuses. Each
+ * possible status is returned as a string literal.
+ *
+ * * **VALID**: Reports that a control is valid, meaning that no errors exist in the input
+ * value.
+ * * **INVALID**: Reports that a control is invalid, meaning that an error exists in the input
+ * value.
+ * * **PENDING**: Reports that a control is pending, meaning that async validation is
+ * occurring and errors are not yet available for the input value.
+ * * **DISABLED**: Reports that a control is
+ * disabled, meaning that the control is exempt from ancestor calculations of validity or value.
+ *
+ * @publicApi
+ */
+type FormControlStatus = 'VALID' | 'INVALID' | 'PENDING' | 'DISABLED';
+/**
+ * Base class for every event sent by `AbstractControl.events()`
+ *
+ * @publicApi
+ */
+declare abstract class ControlEvent<T = any> {
+    /**
+     * Form control from which this event is originated.
+     *
+     * Note: the type of the control can't be infered from T as the event can be emitted by any of child controls
+     */
+    abstract readonly source: AbstractControl<unknown>;
+}
+/**
+ * Event fired when the value of a control changes.
+ *
+ * @publicApi
+ */
+declare class ValueChangeEvent<T> extends ControlEvent<T> {
+    readonly value: T;
+    readonly source: AbstractControl;
+    constructor(value: T, source: AbstractControl);
+}
+/**
+ * Event fired when the control's pristine state changes (pristine <=> dirty).
+ *
+ * @publicApi */
 declare class PristineChangeEvent extends ControlEvent {
     readonly pristine: boolean;
     readonly source: AbstractControl;
@@ -2122,7 +2479,7 @@ type ɵGetProperty<T, K> = K extends string ? ɵGetProperty<T, ɵCoerceStrArrToN
  *
  * @publicApi
  */
-declare abstract class AbstractControl<TValue = any, TRawValue extends TValue = TValue> {
+declare abstract class AbstractControl<TValue = any, TRawValue extends TValue = TValue, TValueWithOptionalControlStates = any> {
     private _parent;
     private _asyncValidationSubscription;
     /**
@@ -2634,7 +2991,7 @@ declare abstract class AbstractControl<TValue = any, TRawValue extends TValue =
     /**
      * Resets the control. Abstract method (implemented in sub-classes).
      */
-    abstract reset(value?: TValue, options?: Object): void;
+    abstract reset(value?: TValueWithOptionalControlStates, options?: Object): void;
     /**
      * The raw value of this control. For most control implementations, the raw value will include
      * disabled children.
@@ -3111,356 +3468,6 @@ declare class RadioControlValueAccessor extends BuiltInControlValueAccessor impl
     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>;
 }
 
-/**
- * FormControlState is a boxed form value. It is an object with a `value` key and a `disabled` key.
- *
- * @publicApi
- */
-interface FormControlState<T> {
-    value: T;
-    disabled: boolean;
-}
-/**
- * Interface for options provided to a `FormControl`.
- *
- * This interface extends all options from {@link AbstractControlOptions}, plus some options
- * unique to `FormControl`.
- *
- * @publicApi
- */
-interface FormControlOptions extends AbstractControlOptions {
-    /**
-     * @description
-     * Whether to use the initial value used to construct the `FormControl` as its default value
-     * as well. If this option is false or not provided, the default value of a FormControl is `null`.
-     * When a FormControl is reset without an explicit value, its value reverts to
-     * its default value.
-     */
-    nonNullable?: boolean;
-    /**
-     * @deprecated Use `nonNullable` instead.
-     */
-    initialValueIsDefault?: boolean;
-}
-/**
- * Various available constructors for `FormControl`.
- * Do not use this interface directly. Instead, use `FormControl`:
- * ```ts
- * const fc = new FormControl('foo');
- * ```
- * This symbol is prefixed with ɵ to make plain that it is an internal symbol.
- */
-interface ɵFormControlCtor {
-    /**
-     * Construct a FormControl with no initial value or validators.
-     */
-    new (): FormControl<any>;
-    /**
-     * Creates a new `FormControl` instance.
-     *
-     * @param value Initializes the control with an initial value,
-     * or an object that defines the initial value and disabled state.
-     *
-     * @param opts A `FormControlOptions` object that contains validation functions and a
-     * validation trigger. `nonNullable` have to be `true`
-     */
-    new <T = any>(value: FormControlState<T> | T, opts: FormControlOptions & {
-        nonNullable: true;
-    }): FormControl<T>;
-    /**
-     * @deprecated Use `nonNullable` instead.
-     */
-    new <T = any>(value: FormControlState<T> | T, opts: FormControlOptions & {
-        initialValueIsDefault: true;
-    }): FormControl<T>;
-    /**
-     * @deprecated When passing an `options` argument, the `asyncValidator` argument has no effect.
-     */
-    new <T = any>(value: FormControlState<T> | T, opts: FormControlOptions, asyncValidator: AsyncValidatorFn | AsyncValidatorFn[]): FormControl<T | null>;
-    /**
-     * Creates a new `FormControl` instance.
-     *
-     * @param value Initializes the control with an initial value,
-     * or an object that defines the initial value and disabled state.
-     *
-     * @param validatorOrOpts A synchronous validator function, or an array of
-     * such functions, or a `FormControlOptions` object that contains validation functions
-     * and a validation trigger.
-     *
-     * @param asyncValidator A single async validator or array of async validator functions
-     */
-    new <T = any>(value: FormControlState<T> | T, validatorOrOpts?: ValidatorFn | ValidatorFn[] | FormControlOptions | null, asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null): FormControl<T | null>;
-    /**
-     * The presence of an explicit `prototype` property provides backwards-compatibility for apps that
-     * manually inspect the prototype chain.
-     */
-    prototype: FormControl<any>;
-}
-/**
- * Tracks the value and validation status of an individual form control.
- *
- * This is one of the four fundamental building blocks of Angular forms, along with
- * `FormGroup`, `FormArray` and `FormRecord`. It extends the `AbstractControl` class that
- * implements most of the base functionality for accessing the value, validation status,
- * user interactions and events.
- *
- * `FormControl` takes a single generic argument, which describes the type of its value. This
- * argument always implicitly includes `null` because the control can be reset. To change this
- * behavior, set `nonNullable` or see the usage notes below.
- *
- * See [usage examples below](#usage-notes).
- *
- * @see {@link AbstractControl}
- * @see [Reactive Forms Guide](guide/forms/reactive-forms)
- * @see [Usage Notes](#usage-notes)
- *
- * @publicApi
- *
- * @overriddenImplementation ɵFormControlCtor
- *
- * @usageNotes
- *
- * ### Initializing Form Controls
- *
- * Instantiate a `FormControl`, with an initial value.
- *
- * ```ts
- * const control = new FormControl('some value');
- * console.log(control.value);     // 'some value'
- * ```
- *
- * The following example initializes the control with a form state object. The `value`
- * and `disabled` keys are required in this case.
- *
- * ```ts
- * const control = new FormControl({ value: 'n/a', disabled: true });
- * console.log(control.value);     // 'n/a'
- * console.log(control.status);    // 'DISABLED'
- * ```
- *
- * The following example initializes the control with a synchronous validator.
- *
- * ```ts
- * const control = new FormControl('', Validators.required);
- * console.log(control.value);      // ''
- * console.log(control.status);     // 'INVALID'
- * ```
- *
- * The following example initializes the control using an options object.
- *
- * ```ts
- * const control = new FormControl('', {
- *    validators: Validators.required,
- *    asyncValidators: myAsyncValidator
- * });
- * ```
- *
- * ### The single type argument
- *
- * `FormControl` accepts a generic argument, which describes the type of its value.
- * In most cases, this argument will be inferred.
- *
- * If you are initializing the control to `null`, or you otherwise wish to provide a
- * wider type, you may specify the argument explicitly:
- *
- * ```ts
- * let fc = new FormControl<string|null>(null);
- * fc.setValue('foo');
- * ```
- *
- * You might notice that `null` is always added to the type of the control.
- * This is because the control will become `null` if you call `reset`. You can change
- * this behavior by setting `{nonNullable: true}`.
- *
- * ### Configure the control to update on a blur event
- *
- * Set the `updateOn` option to `'blur'` to update on the blur `event`.
- *
- * ```ts
- * const control = new FormControl('', { updateOn: 'blur' });
- * ```
- *
- * ### Configure the control to update on a submit event
- *
- * Set the `updateOn` option to `'submit'` to update on a submit `event`.
- *
- * ```ts
- * const control = new FormControl('', { updateOn: 'submit' });
- * ```
- *
- * ### Reset the control back to a specific value
- *
- * You reset to a specific form state by passing through a standalone
- * value or a form state object that contains both a value and a disabled state
- * (these are the only two properties that cannot be calculated).
- *
- * ```ts
- * const control = new FormControl('Nancy');
- *
- * console.log(control.value); // 'Nancy'
- *
- * control.reset('Drew');
- *
- * console.log(control.value); // 'Drew'
- * ```
- *
- * ### Reset the control to its initial value
- *
- * If you wish to always reset the control to its initial value (instead of null),
- * you can pass the `nonNullable` option:
- *
- * ```ts
- * const control = new FormControl('Nancy', {nonNullable: true});
- *
- * console.log(control.value); // 'Nancy'
- *
- * control.reset();
- *
- * console.log(control.value); // 'Nancy'
- * ```
- *
- * ### Reset the control back to an initial value and disabled
- *
- * ```ts
- * const control = new FormControl('Nancy');
- *
- * console.log(control.value); // 'Nancy'
- * console.log(control.status); // 'VALID'
- *
- * control.reset({ value: 'Drew', disabled: true });
- *
- * console.log(control.value); // 'Drew'
- * console.log(control.status); // 'DISABLED'
- * ```
- */
-interface FormControl<TValue = any> extends AbstractControl<TValue> {
-    /**
-     * The default value of this FormControl, used whenever the control is reset without an explicit
-     * value. See {@link FormControlOptions#nonNullable} for more information on configuring
-     * a default value.
-     */
-    readonly defaultValue: TValue;
-    /**
-     * Sets a new value for the form control.
-     *
-     * @param value The new value for the control.
-     * @param options Configuration options that determine how the control propagates changes
-     * and emits events when the value changes.
-     * The configuration options are passed to the {@link AbstractControl#updateValueAndValidity
-     * updateValueAndValidity} method.
-     *
-     * * `onlySelf`: When true, each change only affects this control, and not its parent. Default is
-     * false.
-     * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
-     * `valueChanges`
-     * observables emit events with the latest status and value when the control value is updated.
-     * When false, no events are emitted.
-     * * `emitModelToViewChange`: When true or not supplied  (the default), each change triggers an
-     * `onChange` event to
-     * update the view.
-     * * `emitViewToModelChange`: When true or not supplied (the default), each change triggers an
-     * `ngModelChange`
-     * event to update the model.
-     *
-     */
-    setValue(value: TValue, options?: {
-        onlySelf?: boolean;
-        emitEvent?: boolean;
-        emitModelToViewChange?: boolean;
-        emitViewToModelChange?: boolean;
-    }): void;
-    /**
-     * Patches the value of a control.
-     *
-     * This function is functionally the same as {@link FormControl#setValue setValue} at this level.
-     * It exists for symmetry with {@link FormGroup#patchValue patchValue} on `FormGroups` and
-     * `FormArrays`, where it does behave differently.
-     *
-     * @see {@link FormControl#setValue} for options
-     */
-    patchValue(value: TValue, options?: {
-        onlySelf?: boolean;
-        emitEvent?: boolean;
-        emitModelToViewChange?: boolean;
-        emitViewToModelChange?: boolean;
-    }): void;
-    /**
-     * Resets the form control, marking it `pristine` and `untouched`, and resetting
-     * the value. The new value will be the provided value (if passed), `null`, or the initial value
-     * if `nonNullable` was set in the constructor via {@link FormControlOptions}.
-     *
-     * ```ts
-     * // By default, the control will reset to null.
-     * const dog = new FormControl('spot');
-     * dog.reset(); // dog.value is null
-     *
-     * // If this flag is set, the control will instead reset to the initial value.
-     * const cat = new FormControl('tabby', {nonNullable: true});
-     * cat.reset(); // cat.value is "tabby"
-     *
-     * // A value passed to reset always takes precedence.
-     * const fish = new FormControl('finn', {nonNullable: true});
-     * fish.reset('bubble'); // fish.value is "bubble"
-     * ```
-     *
-     * @param formState Resets the control with an initial value,
-     * or an object that defines the initial value and disabled state.
-     *
-     * @param options Configuration options that determine how the control propagates changes
-     * and emits events after the value changes.
-     *
-     * * `onlySelf`: When true, each change only affects this control, and not its parent. Default is
-     * false.
-     * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
-     * `valueChanges`
-     * observables emit events with the latest status and value when the control is reset.
-     * When false, no events are emitted.
-     *
-     */
-    reset(formState?: TValue | FormControlState<TValue>, options?: {
-        onlySelf?: boolean;
-        emitEvent?: boolean;
-    }): void;
-    /**
-     * For a simple FormControl, the raw value is equivalent to the value.
-     */
-    getRawValue(): TValue;
-    /**
-     * Register a listener for change events.
-     *
-     * @param fn The method that is called when the value changes
-     */
-    registerOnChange(fn: Function): void;
-    /**
-     * Register a listener for disabled events.
-     *
-     * @param fn The method that is called when the disabled status changes.
-     */
-    registerOnDisabledChange(fn: (isDisabled: boolean) => void): void;
-}
-declare const FormControl: ɵFormControlCtor;
-interface UntypedFormControlCtor {
-    new (): UntypedFormControl;
-    new (formState?: any, validatorOrOpts?: ValidatorFn | ValidatorFn[] | FormControlOptions | null, asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null): UntypedFormControl;
-    /**
-     * The presence of an explicit `prototype` property provides backwards-compatibility for apps that
-     * manually inspect the prototype chain.
-     */
-    prototype: FormControl<any>;
-}
-/**
- * UntypedFormControl is a non-strongly-typed version of `FormControl`.
- */
-type UntypedFormControl = FormControl<any>;
-declare const UntypedFormControl: UntypedFormControlCtor;
-/**
- * @description
- * Asserts that the given control is an instance of `FormControl`
- *
- * @publicApi
- */
-declare const isFormControl: (control: unknown) => control is FormControl;
-
 /**
  * @description
  * A base class for code shared between the `NgModelGroup` and `FormGroupName` directives.