build: update API goldens to reflect new tool (#42688)

Updates the TS API guardian goldens with their equivalents
based on the new shared dev-infra tool.

PR Close #42688

goldens/public-api/animations/animations.d.ts

@@ -1,216 +0,0 @@
-export declare function animate(timings: string | number, styles?: AnimationStyleMetadata | AnimationKeyframesSequenceMetadata | null): AnimationAnimateMetadata;
-
-export declare function animateChild(options?: AnimateChildOptions | null): AnimationAnimateChildMetadata;
-
-export declare interface AnimateChildOptions extends AnimationOptions {
-    duration?: number | string;
-}
-
-export declare type AnimateTimings = {
-    duration: number;
-    delay: number;
-    easing: string | null;
-};
-
-export declare function animation(steps: AnimationMetadata | AnimationMetadata[], options?: AnimationOptions | null): AnimationReferenceMetadata;
-
-export declare interface AnimationAnimateChildMetadata extends AnimationMetadata {
-    options: AnimationOptions | null;
-}
-
-export declare interface AnimationAnimateMetadata extends AnimationMetadata {
-    styles: AnimationStyleMetadata | AnimationKeyframesSequenceMetadata | null;
-    timings: string | number | AnimateTimings;
-}
-
-export declare interface AnimationAnimateRefMetadata extends AnimationMetadata {
-    animation: AnimationReferenceMetadata;
-    options: AnimationOptions | null;
-}
-
-export declare abstract class AnimationBuilder {
-    abstract build(animation: AnimationMetadata | AnimationMetadata[]): AnimationFactory;
-}
-
-export declare interface AnimationEvent {
-    disabled: boolean;
-    element: any;
-    fromState: string;
-    phaseName: string;
-    toState: string;
-    totalTime: number;
-    triggerName: string;
-}
-
-export declare abstract class AnimationFactory {
-    abstract create(element: any, options?: AnimationOptions): AnimationPlayer;
-}
-
-export declare interface AnimationGroupMetadata extends AnimationMetadata {
-    options: AnimationOptions | null;
-    steps: AnimationMetadata[];
-}
-
-export declare interface AnimationKeyframesSequenceMetadata extends AnimationMetadata {
-    steps: AnimationStyleMetadata[];
-}
-
-export declare interface AnimationMetadata {
-    type: AnimationMetadataType;
-}
-
-export declare const enum AnimationMetadataType {
-    State = 0,
-    Transition = 1,
-    Sequence = 2,
-    Group = 3,
-    Animate = 4,
-    Keyframes = 5,
-    Style = 6,
-    Trigger = 7,
-    Reference = 8,
-    AnimateChild = 9,
-    AnimateRef = 10,
-    Query = 11,
-    Stagger = 12
-}
-
-export declare interface AnimationOptions {
-    delay?: number | string;
-    params?: {
-        [name: string]: any;
-    };
-}
-
-export declare interface AnimationPlayer {
-    beforeDestroy?: () => any;
-    parentPlayer: AnimationPlayer | null;
-    readonly totalTime: number;
-    destroy(): void;
-    finish(): void;
-    getPosition(): number;
-    hasStarted(): boolean;
-    init(): void;
-    onDestroy(fn: () => void): void;
-    onDone(fn: () => void): void;
-    onStart(fn: () => void): void;
-    pause(): void;
-    play(): void;
-    reset(): void;
-    restart(): void;
-    setPosition(position: any /** TODO #9100 */): void;
-}
-
-export declare interface AnimationQueryMetadata extends AnimationMetadata {
-    animation: AnimationMetadata | AnimationMetadata[];
-    options: AnimationQueryOptions | null;
-    selector: string;
-}
-
-export declare interface AnimationQueryOptions extends AnimationOptions {
-    limit?: number;
-    optional?: boolean;
-}
-
-export declare interface AnimationReferenceMetadata extends AnimationMetadata {
-    animation: AnimationMetadata | AnimationMetadata[];
-    options: AnimationOptions | null;
-}
-
-export declare interface AnimationSequenceMetadata extends AnimationMetadata {
-    options: AnimationOptions | null;
-    steps: AnimationMetadata[];
-}
-
-export declare interface AnimationStaggerMetadata extends AnimationMetadata {
-    animation: AnimationMetadata | AnimationMetadata[];
-    timings: string | number;
-}
-
-export declare interface AnimationStateMetadata extends AnimationMetadata {
-    name: string;
-    options?: {
-        params: {
-            [name: string]: any;
-        };
-    };
-    styles: AnimationStyleMetadata;
-}
-
-export declare interface AnimationStyleMetadata extends AnimationMetadata {
-    offset: number | null;
-    styles: '*' | {
-        [key: string]: string | number;
-    } | Array<{
-        [key: string]: string | number;
-    } | '*'>;
-}
-
-export declare interface AnimationTransitionMetadata extends AnimationMetadata {
-    animation: AnimationMetadata | AnimationMetadata[];
-    expr: string | ((fromState: string, toState: string, element?: any, params?: {
-        [key: string]: any;
-    }) => boolean);
-    options: AnimationOptions | null;
-}
-
-export declare interface AnimationTriggerMetadata extends AnimationMetadata {
-    definitions: AnimationMetadata[];
-    name: string;
-    options: {
-        params?: {
-            [name: string]: any;
-        };
-    } | null;
-}
-
-export declare const AUTO_STYLE = "*";
-
-export declare function group(steps: AnimationMetadata[], options?: AnimationOptions | null): AnimationGroupMetadata;
-
-export declare function keyframes(steps: AnimationStyleMetadata[]): AnimationKeyframesSequenceMetadata;
-
-export declare class NoopAnimationPlayer implements AnimationPlayer {
-    parentPlayer: AnimationPlayer | null;
-    readonly totalTime: number;
-    constructor(duration?: number, delay?: number);
-    destroy(): void;
-    finish(): void;
-    getPosition(): number;
-    hasStarted(): boolean;
-    init(): void;
-    onDestroy(fn: () => void): void;
-    onDone(fn: () => void): void;
-    onStart(fn: () => void): void;
-    pause(): void;
-    play(): void;
-    reset(): void;
-    restart(): void;
-    setPosition(position: number): void;
-}
-
-export declare function query(selector: string, animation: AnimationMetadata | AnimationMetadata[], options?: AnimationQueryOptions | null): AnimationQueryMetadata;
-
-export declare function sequence(steps: AnimationMetadata[], options?: AnimationOptions | null): AnimationSequenceMetadata;
-
-export declare function stagger(timings: string | number, animation: AnimationMetadata | AnimationMetadata[]): AnimationStaggerMetadata;
-
-export declare function state(name: string, styles: AnimationStyleMetadata, options?: {
-    params: {
-        [name: string]: any;
-    };
-}): AnimationStateMetadata;
-
-export declare function style(tokens: '*' | {
-    [key: string]: string | number;
-} | Array<'*' | {
-    [key: string]: string | number;
-}>): AnimationStyleMetadata;
-
-export declare function transition(stateChangeExpr: string | ((fromState: string, toState: string, element?: any, params?: {
-    [key: string]: any;
-}) => boolean), steps: AnimationMetadata | AnimationMetadata[], options?: AnimationOptions | null): AnimationTransitionMetadata;
-
-export declare function trigger(name: string, definitions: AnimationMetadata[]): AnimationTriggerMetadata;
-
-export declare function useAnimation(animation: AnimationReferenceMetadata, options?: AnimationOptions | null): AnimationAnimateRefMetadata;

goldens/public-api/animations/animations.md

@@ -0,0 +1,282 @@
+## API Report File for "@angular/animations"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+// @public
+export function animate(timings: string | number, styles?: AnimationStyleMetadata | AnimationKeyframesSequenceMetadata | null): AnimationAnimateMetadata;
+
+// @public
+export function animateChild(options?: AnimateChildOptions | null): AnimationAnimateChildMetadata;
+
+// @public
+export interface AnimateChildOptions extends AnimationOptions {
+    // (undocumented)
+    duration?: number | string;
+}
+
+// @public
+export type AnimateTimings = {
+    duration: number;
+    delay: number;
+    easing: string | null;
+};
+
+// @public
+export function animation(steps: AnimationMetadata | AnimationMetadata[], options?: AnimationOptions | null): AnimationReferenceMetadata;
+
+// @public
+export interface AnimationAnimateChildMetadata extends AnimationMetadata {
+    options: AnimationOptions | null;
+}
+
+// @public
+export interface AnimationAnimateMetadata extends AnimationMetadata {
+    styles: AnimationStyleMetadata | AnimationKeyframesSequenceMetadata | null;
+    timings: string | number | AnimateTimings;
+}
+
+// @public
+export interface AnimationAnimateRefMetadata extends AnimationMetadata {
+    animation: AnimationReferenceMetadata;
+    options: AnimationOptions | null;
+}
+
+// @public
+export abstract class AnimationBuilder {
+    abstract build(animation: AnimationMetadata | AnimationMetadata[]): AnimationFactory;
+}
+
+// @public
+export interface AnimationEvent {
+    disabled: boolean;
+    element: any;
+    fromState: string;
+    phaseName: string;
+    toState: string;
+    totalTime: number;
+    triggerName: string;
+}
+
+// @public
+export abstract class AnimationFactory {
+    abstract create(element: any, options?: AnimationOptions): AnimationPlayer;
+}
+
+// @public
+export interface AnimationGroupMetadata extends AnimationMetadata {
+    options: AnimationOptions | null;
+    steps: AnimationMetadata[];
+}
+
+// @public
+export interface AnimationKeyframesSequenceMetadata extends AnimationMetadata {
+    steps: AnimationStyleMetadata[];
+}
+
+// @public
+export interface AnimationMetadata {
+    // (undocumented)
+    type: AnimationMetadataType;
+}
+
+// @public
+export const enum AnimationMetadataType {
+    Animate = 4,
+    AnimateChild = 9,
+    AnimateRef = 10,
+    Group = 3,
+    Keyframes = 5,
+    Query = 11,
+    Reference = 8,
+    Sequence = 2,
+    Stagger = 12,
+    State = 0,
+    Style = 6,
+    Transition = 1,
+    Trigger = 7
+}
+
+// @public
+export interface AnimationOptions {
+    delay?: number | string;
+    params?: {
+        [name: string]: any;
+    };
+}
+
+// @public
+export interface AnimationPlayer {
+    beforeDestroy?: () => any;
+    destroy(): void;
+    finish(): void;
+    getPosition(): number;
+    hasStarted(): boolean;
+    init(): void;
+    onDestroy(fn: () => void): void;
+    onDone(fn: () => void): void;
+    onStart(fn: () => void): void;
+    parentPlayer: AnimationPlayer | null;
+    pause(): void;
+    play(): void;
+    reset(): void;
+    restart(): void;
+    setPosition(position: any /** TODO #9100 */): void;
+    readonly totalTime: number;
+}
+
+// @public
+export interface AnimationQueryMetadata extends AnimationMetadata {
+    animation: AnimationMetadata | AnimationMetadata[];
+    options: AnimationQueryOptions | null;
+    selector: string;
+}
+
+// @public
+export interface AnimationQueryOptions extends AnimationOptions {
+    limit?: number;
+    optional?: boolean;
+}
+
+// @public
+export interface AnimationReferenceMetadata extends AnimationMetadata {
+    animation: AnimationMetadata | AnimationMetadata[];
+    options: AnimationOptions | null;
+}
+
+// @public
+export interface AnimationSequenceMetadata extends AnimationMetadata {
+    options: AnimationOptions | null;
+    steps: AnimationMetadata[];
+}
+
+// @public
+export interface AnimationStaggerMetadata extends AnimationMetadata {
+    animation: AnimationMetadata | AnimationMetadata[];
+    timings: string | number;
+}
+
+// @public
+export interface AnimationStateMetadata extends AnimationMetadata {
+    name: string;
+    options?: {
+        params: {
+            [name: string]: any;
+        };
+    };
+    styles: AnimationStyleMetadata;
+}
+
+// @public
+export interface AnimationStyleMetadata extends AnimationMetadata {
+    offset: number | null;
+    styles: '*' | {
+        [key: string]: string | number;
+    } | Array<{
+        [key: string]: string | number;
+    } | '*'>;
+}
+
+// @public
+export interface AnimationTransitionMetadata extends AnimationMetadata {
+    animation: AnimationMetadata | AnimationMetadata[];
+    expr: string | ((fromState: string, toState: string, element?: any, params?: {
+        [key: string]: any;
+    }) => boolean);
+    options: AnimationOptions | null;
+}
+
+// @public
+export interface AnimationTriggerMetadata extends AnimationMetadata {
+    definitions: AnimationMetadata[];
+    name: string;
+    options: {
+        params?: {
+            [name: string]: any;
+        };
+    } | null;
+}
+
+// @public
+export const AUTO_STYLE = "*";
+
+// @public
+export function group(steps: AnimationMetadata[], options?: AnimationOptions | null): AnimationGroupMetadata;
+
+// @public
+export function keyframes(steps: AnimationStyleMetadata[]): AnimationKeyframesSequenceMetadata;
+
+// @public
+export class NoopAnimationPlayer implements AnimationPlayer {
+    constructor(duration?: number, delay?: number);
+    // (undocumented)
+    destroy(): void;
+    // (undocumented)
+    finish(): void;
+    // (undocumented)
+    getPosition(): number;
+    // (undocumented)
+    hasStarted(): boolean;
+    // (undocumented)
+    init(): void;
+    // (undocumented)
+    onDestroy(fn: () => void): void;
+    // (undocumented)
+    onDone(fn: () => void): void;
+    // (undocumented)
+    onStart(fn: () => void): void;
+    // (undocumented)
+    parentPlayer: AnimationPlayer | null;
+    // (undocumented)
+    pause(): void;
+    // (undocumented)
+    play(): void;
+    // (undocumented)
+    reset(): void;
+    // (undocumented)
+    restart(): void;
+    // (undocumented)
+    setPosition(position: number): void;
+    // (undocumented)
+    readonly totalTime: number;
+}
+
+// @public
+export function query(selector: string, animation: AnimationMetadata | AnimationMetadata[], options?: AnimationQueryOptions | null): AnimationQueryMetadata;
+
+// @public
+export function sequence(steps: AnimationMetadata[], options?: AnimationOptions | null): AnimationSequenceMetadata;
+
+// @public
+export function stagger(timings: string | number, animation: AnimationMetadata | AnimationMetadata[]): AnimationStaggerMetadata;
+
+// @public
+export function state(name: string, styles: AnimationStyleMetadata, options?: {
+    params: {
+        [name: string]: any;
+    };
+}): AnimationStateMetadata;
+
+// @public
+export function style(tokens: '*' | {
+    [key: string]: string | number;
+} | Array<'*' | {
+    [key: string]: string | number;
+}>): AnimationStyleMetadata;
+
+// @public
+export function transition(stateChangeExpr: string | ((fromState: string, toState: string, element?: any, params?: {
+    [key: string]: any;
+}) => boolean), steps: AnimationMetadata | AnimationMetadata[], options?: AnimationOptions | null): AnimationTransitionMetadata;
+
+// @public
+export function trigger(name: string, definitions: AnimationMetadata[]): AnimationTriggerMetadata;
+
+// @public
+export function useAnimation(animation: AnimationReferenceMetadata, options?: AnimationOptions | null): AnimationAnimateRefMetadata;
+
+
+// (No @packageDocumentation comment for this package)
+
+```

goldens/public-api/animations/browser/browser.md

@@ -1,11 +1,30 @@
-export declare abstract class AnimationDriver {
+## API Report File for "@angular/animations_browser"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+// @public (undocumented)
+export abstract class AnimationDriver {
+    // (undocumented)
     abstract animate(element: any, keyframes: {
         [key: string]: string | number;
     }[], duration: number, delay: number, easing?: string | null, previousPlayers?: any[], scrubberAccessRequested?: boolean): any;
+    // (undocumented)
     abstract computeStyle(element: any, prop: string, defaultValue?: string): string;
+    // (undocumented)
     abstract containsElement(elm1: any, elm2: any): boolean;
+    // (undocumented)
     abstract matchesElement(element: any, selector: string): boolean;
-    abstract query(element: any, selector: string, multi: boolean): any[];
+    // (undocumented)
-    abstract validateStyleProperty(prop: string): boolean;
     static NOOP: AnimationDriver;
+    // (undocumented)
+    abstract query(element: any, selector: string, multi: boolean): any[];
+    // (undocumented)
+    abstract validateStyleProperty(prop: string): boolean;
 }
+
+
+// (No @packageDocumentation comment for this package)
+
+```

goldens/public-api/animations/browser/testing/testing.md

@@ -1,35 +1,74 @@
-export declare class MockAnimationDriver implements AnimationDriver {
+## API Report File for "@angular/animations_browser_testing"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import { AnimationDriver } from '@angular/animations/browser';
+import { AnimationPlayer } from '@angular/animations';
+import { NoopAnimationPlayer } from '@angular/animations';
+import { ɵStyleData } from '@angular/animations';
+
+// @public (undocumented)
+export class MockAnimationDriver implements AnimationDriver {
+    // (undocumented)
     animate(element: any, keyframes: {
         [key: string]: string | number;
     }[], duration: number, delay: number, easing: string, previousPlayers?: any[]): MockAnimationPlayer;
+    // (undocumented)
     computeStyle(element: any, prop: string, defaultValue?: string): string;
+    // (undocumented)
     containsElement(elm1: any, elm2: any): boolean;
-    matchesElement(element: any, selector: string): boolean;
+    // (undocumented)
-    query(element: any, selector: string, multi: boolean): any[];
-    validateStyleProperty(prop: string): boolean;
     static log: AnimationPlayer[];
+    // (undocumented)
+    matchesElement(element: any, selector: string): boolean;
+    // (undocumented)
+    query(element: any, selector: string, multi: boolean): any[];
+    // (undocumented)
+    validateStyleProperty(prop: string): boolean;
 }
 
-export declare class MockAnimationPlayer extends NoopAnimationPlayer {
+// @public (undocumented)
-    currentSnapshot: ɵStyleData;
+export class MockAnimationPlayer extends NoopAnimationPlayer {
-    delay: number;
-    duration: number;
-    easing: string;
-    element: any;
-    keyframes: {
-        [key: string]: string | number;
-    }[];
-    previousPlayers: any[];
-    previousStyles: {
-        [key: string]: string | number;
-    };
     constructor(element: any, keyframes: {
         [key: string]: string | number;
     }[], duration: number, delay: number, easing: string, previousPlayers: any[]);
+    // (undocumented)
     beforeDestroy(): void;
+    // (undocumented)
+    currentSnapshot: ɵStyleData;
+    // (undocumented)
+    delay: number;
+    // (undocumented)
     destroy(): void;
+    // (undocumented)
+    duration: number;
+    // (undocumented)
+    easing: string;
+    // (undocumented)
+    element: any;
+    // (undocumented)
     finish(): void;
+    // (undocumented)
     hasStarted(): boolean;
+    // (undocumented)
+    keyframes: {
+        [key: string]: string | number;
+    }[];
+    // (undocumented)
     play(): void;
+    // (undocumented)
+    previousPlayers: any[];
+    // (undocumented)
+    previousStyles: {
+        [key: string]: string | number;
+    };
+    // (undocumented)
     reset(): void;
 }
+
+
+// (No @packageDocumentation comment for this package)
+
+```

goldens/public-api/common/common.md

@@ -1,157 +1,268 @@
-export declare const APP_BASE_HREF: InjectionToken<string>;
+## API Report File for "@angular/common"
 
-export declare class AsyncPipe implements OnDestroy, PipeTransform {
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import { ChangeDetectorRef } from '@angular/core';
+import { DoCheck } from '@angular/core';
+import { ElementRef } from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { Injector } from '@angular/core';
+import { IterableDiffers } from '@angular/core';
+import { KeyValueDiffers } from '@angular/core';
+import { NgIterable } from '@angular/core';
+import { NgModuleFactory } from '@angular/core';
+import { Observable } from 'rxjs';
+import { OnChanges } from '@angular/core';
+import { OnDestroy } from '@angular/core';
+import { PipeTransform } from '@angular/core';
+import { Renderer2 } from '@angular/core';
+import { SimpleChanges } from '@angular/core';
+import { Subscribable } from 'rxjs';
+import { SubscriptionLike } from 'rxjs';
+import { TemplateRef } from '@angular/core';
+import { TrackByFunction } from '@angular/core';
+import { Type } from '@angular/core';
+import { Version } from '@angular/core';
+import { ViewContainerRef } from '@angular/core';
+
+// @public
+export const APP_BASE_HREF: InjectionToken<string>;
+
+// @public
+export class AsyncPipe implements OnDestroy, PipeTransform {
     constructor(_ref: ChangeDetectorRef);
+    // (undocumented)
     ngOnDestroy(): void;
+    // (undocumented)
     transform<T>(obj: Observable<T> | Subscribable<T> | Promise<T>): T | null;
+    // (undocumented)
     transform<T>(obj: null | undefined): null;
+    // (undocumented)
     transform<T>(obj: Observable<T> | Subscribable<T> | Promise<T> | null | undefined): T | null;
+    }
+
+// @public
+export class CommonModule {
 }
 
-export declare class CommonModule {
+// @public
-}
+export class CurrencyPipe implements PipeTransform {
-
-export declare class CurrencyPipe implements PipeTransform {
     constructor(_locale: string, _defaultCurrencyCode?: string);
+    // (undocumented)
     transform(value: number | string, currencyCode?: string, display?: 'code' | 'symbol' | 'symbol-narrow' | string | boolean, digitsInfo?: string, locale?: string): string | null;
+    // (undocumented)
     transform(value: null | undefined, currencyCode?: string, display?: 'code' | 'symbol' | 'symbol-narrow' | string | boolean, digitsInfo?: string, locale?: string): null;
+    // (undocumented)
     transform(value: number | string | null | undefined, currencyCode?: string, display?: 'code' | 'symbol' | 'symbol-narrow' | string | boolean, digitsInfo?: string, locale?: string): string | null;
 }
 
-export declare class DatePipe implements PipeTransform {
+// @public
+export class DatePipe implements PipeTransform {
     constructor(locale: string);
+    // (undocumented)
     transform(value: Date | string | number, format?: string, timezone?: string, locale?: string): string | null;
+    // (undocumented)
     transform(value: null | undefined, format?: string, timezone?: string, locale?: string): null;
+    // (undocumented)
     transform(value: Date | string | number | null | undefined, format?: string, timezone?: string, locale?: string): string | null;
 }
 
-export declare class DecimalPipe implements PipeTransform {
+// @public
+export class DecimalPipe implements PipeTransform {
     constructor(_locale: string);
+    // (undocumented)
     transform(value: number | string, digitsInfo?: string, locale?: string): string | null;
+    // (undocumented)
     transform(value: null | undefined, digitsInfo?: string, locale?: string): null;
+    // (undocumented)
     transform(value: number | string | null | undefined, digitsInfo?: string, locale?: string): string | null;
 }
 
-export declare const DOCUMENT: InjectionToken<Document>;
+// @public
+export const DOCUMENT: InjectionToken<Document>;
 
-export declare function formatCurrency(value: number, locale: string, currency: string, currencyCode?: string, digitsInfo?: string): string;
+// @public
+export function formatCurrency(value: number, locale: string, currency: string, currencyCode?: string, digitsInfo?: string): string;
 
-export declare function formatDate(value: string | number | Date, format: string, locale: string, timezone?: string): string;
+// @public
+export function formatDate(value: string | number | Date, format: string, locale: string, timezone?: string): string;
 
-export declare function formatNumber(value: number, locale: string, digitsInfo?: string): string;
+// @public
+export function formatNumber(value: number, locale: string, digitsInfo?: string): string;
 
-export declare function formatPercent(value: number, locale: string, digitsInfo?: string): string;
+// @public
+export function formatPercent(value: number, locale: string, digitsInfo?: string): string;
 
-export declare enum FormatWidth {
+// @public
-    Short = 0,
+export enum FormatWidth {
-    Medium = 1,
+    Full = 3,
     Long = 2,
-    Full = 3
+    Medium = 1,
+    Short = 0
 }
 
-export declare enum FormStyle {
+// @public
+export enum FormStyle {
+    // (undocumented)
     Format = 0,
+    // (undocumented)
     Standalone = 1
 }
 
-export declare function getCurrencySymbol(code: string, format: 'wide' | 'narrow', locale?: string): string;
+// @public
+export function getCurrencySymbol(code: string, format: 'wide' | 'narrow', locale?: string): string;
 
-export declare function getLocaleCurrencyCode(locale: string): string | null;
+// @public
+export function getLocaleCurrencyCode(locale: string): string | null;
 
-export declare function getLocaleCurrencyName(locale: string): string | null;
+// @public
+export function getLocaleCurrencyName(locale: string): string | null;
 
-export declare function getLocaleCurrencySymbol(locale: string): string | null;
+// @public
+export function getLocaleCurrencySymbol(locale: string): string | null;
 
-export declare function getLocaleDateFormat(locale: string, width: FormatWidth): string;
+// @public
+export function getLocaleDateFormat(locale: string, width: FormatWidth): string;
 
-export declare function getLocaleDateTimeFormat(locale: string, width: FormatWidth): string;
+// @public
+export function getLocaleDateTimeFormat(locale: string, width: FormatWidth): string;
 
-export declare function getLocaleDayNames(locale: string, formStyle: FormStyle, width: TranslationWidth): ReadonlyArray<string>;
+// @public
+export function getLocaleDayNames(locale: string, formStyle: FormStyle, width: TranslationWidth): ReadonlyArray<string>;
 
-export declare function getLocaleDayPeriods(locale: string, formStyle: FormStyle, width: TranslationWidth): Readonly<[string, string]>;
+// @public
+export function getLocaleDayPeriods(locale: string, formStyle: FormStyle, width: TranslationWidth): Readonly<[string, string]>;
 
-export declare function getLocaleDirection(locale: string): 'ltr' | 'rtl';
+// @public
+export function getLocaleDirection(locale: string): 'ltr' | 'rtl';
 
-export declare function getLocaleEraNames(locale: string, width: TranslationWidth): Readonly<[string, string]>;
+// @public
+export function getLocaleEraNames(locale: string, width: TranslationWidth): Readonly<[string, string]>;
 
-export declare function getLocaleExtraDayPeriodRules(locale: string): (Time | [Time, Time])[];
+// @public
+export function getLocaleExtraDayPeriodRules(locale: string): (Time | [Time, Time])[];
 
-export declare function getLocaleExtraDayPeriods(locale: string, formStyle: FormStyle, width: TranslationWidth): string[];
+// @public
+export function getLocaleExtraDayPeriods(locale: string, formStyle: FormStyle, width: TranslationWidth): string[];
 
-export declare function getLocaleFirstDayOfWeek(locale: string): WeekDay;
+// @public
+export function getLocaleFirstDayOfWeek(locale: string): WeekDay;
 
-export declare function getLocaleId(locale: string): string;
+// @public
+export function getLocaleId(locale: string): string;
 
-export declare function getLocaleMonthNames(locale: string, formStyle: FormStyle, width: TranslationWidth): ReadonlyArray<string>;
+// @public
+export function getLocaleMonthNames(locale: string, formStyle: FormStyle, width: TranslationWidth): ReadonlyArray<string>;
 
-export declare function getLocaleNumberFormat(locale: string, type: NumberFormatStyle): string;
+// @public
+export function getLocaleNumberFormat(locale: string, type: NumberFormatStyle): string;
 
-export declare function getLocaleNumberSymbol(locale: string, symbol: NumberSymbol): string;
+// @public
+export function getLocaleNumberSymbol(locale: string, symbol: NumberSymbol): string;
 
-export declare const getLocalePluralCase: (locale: string) => ((value: number) => Plural);
+// @public
+export const getLocalePluralCase: (locale: string) => ((value: number) => Plural);
 
-export declare function getLocaleTimeFormat(locale: string, width: FormatWidth): string;
+// @public
+export function getLocaleTimeFormat(locale: string, width: FormatWidth): string;
 
-export declare function getLocaleWeekEndRange(locale: string): [WeekDay, WeekDay];
+// @public
+export function getLocaleWeekEndRange(locale: string): [WeekDay, WeekDay];
 
-export declare function getNumberOfCurrencyDigits(code: string): number;
+// @public
+export function getNumberOfCurrencyDigits(code: string): number;
 
-export declare class HashLocationStrategy extends LocationStrategy implements OnDestroy {
+// @public
+export class HashLocationStrategy extends LocationStrategy implements OnDestroy {
     constructor(_platformLocation: PlatformLocation, _baseHref?: string);
+    // (undocumented)
     back(): void;
+    // (undocumented)
     forward(): void;
+    // (undocumented)
     getBaseHref(): string;
+    // (undocumented)
     historyGo(relativePosition?: number): void;
+    // (undocumented)
     ngOnDestroy(): void;
+    // (undocumented)
     onPopState(fn: LocationChangeListener): void;
+    // (undocumented)
     path(includeHash?: boolean): string;
+    // (undocumented)
     prepareExternalUrl(internal: string): string;
+    // (undocumented)
     pushState(state: any, title: string, path: string, queryParams: string): void;
+    // (undocumented)
     replaceState(state: any, title: string, path: string, queryParams: string): void;
 }
 
-export declare class I18nPluralPipe implements PipeTransform {
+// @public
+export class I18nPluralPipe implements PipeTransform {
     constructor(_localization: NgLocalization);
+    // (undocumented)
     transform(value: number | null | undefined, pluralMap: {
         [count: string]: string;
     }, locale?: string): string;
 }
 
-export declare class I18nSelectPipe implements PipeTransform {
+// @public
+export class I18nSelectPipe implements PipeTransform {
+    // (undocumented)
     transform(value: string | null | undefined, mapping: {
         [key: string]: string;
     }): string;
 }
 
-export declare function isPlatformBrowser(platformId: Object): boolean;
+// @public
+export function isPlatformBrowser(platformId: Object): boolean;
 
-export declare function isPlatformServer(platformId: Object): boolean;
+// @public
+export function isPlatformServer(platformId: Object): boolean;
 
-export declare function isPlatformWorkerApp(platformId: Object): boolean;
+// @public
+export function isPlatformWorkerApp(platformId: Object): boolean;
 
-export declare function isPlatformWorkerUi(platformId: Object): boolean;
+// @public
+export function isPlatformWorkerUi(platformId: Object): boolean;
 
-export declare class JsonPipe implements PipeTransform {
+// @public
+export class JsonPipe implements PipeTransform {
+    // (undocumented)
     transform(value: any): string;
 }
 
-export declare interface KeyValue<K, V> {
+// @public
+export interface KeyValue<K, V> {
+    // (undocumented)
     key: K;
+    // (undocumented)
     value: V;
 }
 
-export declare class KeyValuePipe implements PipeTransform {
+// @public
+export class KeyValuePipe implements PipeTransform {
     constructor(differs: KeyValueDiffers);
+    // (undocumented)
     transform<K, V>(input: ReadonlyMap<K, V>, compareFn?: (a: KeyValue<K, V>, b: KeyValue<K, V>) => number): Array<KeyValue<K, V>>;
+    // (undocumented)
     transform<K extends number, V>(input: Record<K, V>, compareFn?: (a: KeyValue<string, V>, b: KeyValue<string, V>) => number): Array<KeyValue<string, V>>;
+    // (undocumented)
     transform<K extends string, V>(input: Record<K, V> | ReadonlyMap<K, V>, compareFn?: (a: KeyValue<K, V>, b: KeyValue<K, V>) => number): Array<KeyValue<K, V>>;
+    // (undocumented)
     transform(input: null | undefined, compareFn?: (a: KeyValue<unknown, unknown>, b: KeyValue<unknown, unknown>) => number): null;
+    // (undocumented)
     transform<K, V>(input: ReadonlyMap<K, V> | null | undefined, compareFn?: (a: KeyValue<K, V>, b: KeyValue<K, V>) => number): Array<KeyValue<K, V>> | null;
+    // (undocumented)
     transform<K extends number, V>(input: Record<K, V> | null | undefined, compareFn?: (a: KeyValue<string, V>, b: KeyValue<string, V>) => number): Array<KeyValue<string, V>> | null;
+    // (undocumented)
     transform<K extends string, V>(input: Record<K, V> | ReadonlyMap<K, V> | null | undefined, compareFn?: (a: KeyValue<K, V>, b: KeyValue<K, V>) => number): Array<KeyValue<K, V>> | null;
 }
 
-export declare class Location {
+// @public
+export class Location {
     constructor(platformStrategy: LocationStrategy, platformLocation: PlatformLocation);
     back(): void;
     forward(): void;
@@ -159,286 +270,434 @@ export declare class Location {
     go(path: string, query?: string, state?: any): void;
     historyGo(relativePosition?: number): void;
     isCurrentPathEqualTo(path: string, query?: string): boolean;
+    static joinWithSlash: (start: string, end: string) => string;
     normalize(url: string): string;
+    static normalizeQueryParams: (params: string) => string;
     onUrlChange(fn: (url: string, state: unknown) => void): void;
     path(includeHash?: boolean): string;
     prepareExternalUrl(url: string): string;
     replaceState(path: string, query?: string, state?: any): void;
-    subscribe(onNext: (value: PopStateEvent) => void, onThrow?: ((exception: any) => void) | null, onReturn?: (() => void) | null): SubscriptionLike;
-    static joinWithSlash: (start: string, end: string) => string;
-    static normalizeQueryParams: (params: string) => string;
     static stripTrailingSlash: (url: string) => string;
+    subscribe(onNext: (value: PopStateEvent) => void, onThrow?: ((exception: any) => void) | null, onReturn?: (() => void) | null): SubscriptionLike;
 }
 
-export declare const LOCATION_INITIALIZED: InjectionToken<Promise<any>>;
+// @public
+export const LOCATION_INITIALIZED: InjectionToken<Promise<any>>;
 
-export declare interface LocationChangeEvent {
+// @public
+export interface LocationChangeEvent {
+    // (undocumented)
     state: any;
+    // (undocumented)
     type: string;
 }
 
-export declare interface LocationChangeListener {
+// @public (undocumented)
+export interface LocationChangeListener {
+    // (undocumented)
     (event: LocationChangeEvent): any;
 }
 
-export declare abstract class LocationStrategy {
+// @public
+export abstract class LocationStrategy {
+    // (undocumented)
     abstract back(): void;
+    // (undocumented)
     abstract forward(): void;
+    // (undocumented)
     abstract getBaseHref(): string;
+    // (undocumented)
     historyGo?(relativePosition: number): void;
+    // (undocumented)
     abstract onPopState(fn: LocationChangeListener): void;
+    // (undocumented)
     abstract path(includeHash?: boolean): string;
+    // (undocumented)
     abstract prepareExternalUrl(internal: string): string;
+    // (undocumented)
     abstract pushState(state: any, title: string, url: string, queryParams: string): void;
+    // (undocumented)
     abstract replaceState(state: any, title: string, url: string, queryParams: string): void;
 }
 
-export declare class LowerCasePipe implements PipeTransform {
+// @public
+export class LowerCasePipe implements PipeTransform {
+    // (undocumented)
     transform(value: string): string;
+    // (undocumented)
     transform(value: null | undefined): null;
+    // (undocumented)
     transform(value: string | null | undefined): string | null;
 }
 
-export declare class NgClass implements DoCheck {
+// @public
+export class NgClass implements DoCheck {
+    constructor(_iterableDiffers: IterableDiffers, _keyValueDiffers: KeyValueDiffers, _ngEl: ElementRef, _renderer: Renderer2);
+    // (undocumented)
     set klass(value: string);
+    // (undocumented)
     set ngClass(value: string | string[] | Set<string> | {
         [klass: string]: any;
     });
-    constructor(_iterableDiffers: IterableDiffers, _keyValueDiffers: KeyValueDiffers, _ngEl: ElementRef, _renderer: Renderer2);
+    // (undocumented)
     ngDoCheck(): void;
-}
+    }
 
-export declare class NgComponentOutlet implements OnChanges, OnDestroy {
+// @public
-    ngComponentOutlet: Type<any>;
+export class NgComponentOutlet implements OnChanges, OnDestroy {
-    ngComponentOutletContent: any[][];
-    ngComponentOutletInjector: Injector;
-    ngComponentOutletNgModuleFactory: NgModuleFactory<any>;
     constructor(_viewContainerRef: ViewContainerRef);
+    // (undocumented)
+    ngComponentOutlet: Type<any>;
+    // (undocumented)
+    ngComponentOutletContent: any[][];
+    // (undocumented)
+    ngComponentOutletInjector: Injector;
+    // (undocumented)
+    ngComponentOutletNgModuleFactory: NgModuleFactory<any>;
+    // (undocumented)
     ngOnChanges(changes: SimpleChanges): void;
+    // (undocumented)
     ngOnDestroy(): void;
-}
+    }
 
-export declare class NgForOf<T, U extends NgIterable<T> = NgIterable<T>> implements DoCheck {
+// @public
+export class NgForOf<T, U extends NgIterable<T> = NgIterable<T>> implements DoCheck {
+    constructor(_viewContainer: ViewContainerRef, _template: TemplateRef<NgForOfContext<T, U>>, _differs: IterableDiffers);
+    ngDoCheck(): void;
     set ngForOf(ngForOf: U & NgIterable<T> | undefined | null);
     set ngForTemplate(value: TemplateRef<NgForOfContext<T, U>>);
     set ngForTrackBy(fn: TrackByFunction<T>);
+    // (undocumented)
     get ngForTrackBy(): TrackByFunction<T>;
-    constructor(_viewContainer: ViewContainerRef, _template: TemplateRef<NgForOfContext<T, U>>, _differs: IterableDiffers);
-    ngDoCheck(): void;
     static ngTemplateContextGuard<T, U extends NgIterable<T>>(dir: NgForOf<T, U>, ctx: any): ctx is NgForOfContext<T, U>;
-}
+    }
 
-export declare class NgForOfContext<T, U extends NgIterable<T> = NgIterable<T>> {
+// @public (undocumented)
+export class NgForOfContext<T, U extends NgIterable<T> = NgIterable<T>> {
+    // (undocumented)
     $implicit: T;
-    count: number;
-    get even(): boolean;
-    get first(): boolean;
-    index: number;
-    get last(): boolean;
-    ngForOf: U;
-    get odd(): boolean;
     constructor($implicit: T, ngForOf: U, index: number, count: number);
+    // (undocumented)
+    count: number;
+    // (undocumented)
+    get even(): boolean;
+    // (undocumented)
+    get first(): boolean;
+    // (undocumented)
+    index: number;
+    // (undocumented)
+    get last(): boolean;
+    // (undocumented)
+    ngForOf: U;
+    // (undocumented)
+    get odd(): boolean;
 }
 
-export declare class NgIf<T = unknown> {
+// @public
+export class NgIf<T = unknown> {
+    constructor(_viewContainer: ViewContainerRef, templateRef: TemplateRef<NgIfContext<T>>);
     set ngIf(condition: T);
     set ngIfElse(templateRef: TemplateRef<NgIfContext<T>> | null);
     set ngIfThen(templateRef: TemplateRef<NgIfContext<T>> | null);
-    constructor(_viewContainer: ViewContainerRef, templateRef: TemplateRef<NgIfContext<T>>);
-    static ngTemplateGuard_ngIf: 'binding';
     static ngTemplateContextGuard<T>(dir: NgIf<T>, ctx: any): ctx is NgIfContext<Exclude<T, false | 0 | '' | null | undefined>>;
-}
+    static ngTemplateGuard_ngIf: 'binding';
+    }
 
-export declare class NgIfContext<T = unknown> {
+// @public (undocumented)
+export class NgIfContext<T = unknown> {
+    // (undocumented)
     $implicit: T;
+    // (undocumented)
     ngIf: T;
 }
 
-export declare class NgLocaleLocalization extends NgLocalization {
+// @public
-    protected locale: string;
+export class NgLocaleLocalization extends NgLocalization {
     constructor(locale: string);
+    // (undocumented)
     getPluralCategory(value: any, locale?: string): string;
+    // (undocumented)
+    protected locale: string;
 }
 
-export declare abstract class NgLocalization {
+// @public (undocumented)
+export abstract class NgLocalization {
+    // (undocumented)
     abstract getPluralCategory(value: any, locale?: string): string;
 }
 
-export declare class NgPlural {
+// @public
-    set ngPlural(value: number);
+export class NgPlural {
     constructor(_localization: NgLocalization);
+    // (undocumented)
     addCase(value: string, switchView: SwitchView): void;
-}
+    // (undocumented)
+    set ngPlural(value: number);
+    }
 
-export declare class NgPluralCase {
+// @public
-    value: string;
+export class NgPluralCase {
     constructor(value: string, template: TemplateRef<Object>, viewContainer: ViewContainerRef, ngPlural: NgPlural);
+    // (undocumented)
+    value: string;
 }
 
-export declare class NgStyle implements DoCheck {
+// @public
+export class NgStyle implements DoCheck {
+    constructor(_ngEl: ElementRef, _differs: KeyValueDiffers, _renderer: Renderer2);
+    // (undocumented)
+    ngDoCheck(): void;
+    // (undocumented)
     set ngStyle(values: {
         [klass: string]: any;
     } | null);
-    constructor(_ngEl: ElementRef, _differs: KeyValueDiffers, _renderer: Renderer2);
+    }
-    ngDoCheck(): void;
-}
 
-export declare class NgSwitch {
+// @public
+export class NgSwitch {
+    // (undocumented)
     set ngSwitch(newValue: any);
-}
+    }
 
-export declare class NgSwitchCase implements DoCheck {
+// @public
-    ngSwitchCase: any;
+export class NgSwitchCase implements DoCheck {
     constructor(viewContainer: ViewContainerRef, templateRef: TemplateRef<Object>, ngSwitch: NgSwitch);
     ngDoCheck(): void;
-}
+    ngSwitchCase: any;
+    }
 
-export declare class NgSwitchDefault {
+// @public
+export class NgSwitchDefault {
     constructor(viewContainer: ViewContainerRef, templateRef: TemplateRef<Object>, ngSwitch: NgSwitch);
 }
 
-export declare class NgTemplateOutlet implements OnChanges {
+// @public
+export class NgTemplateOutlet implements OnChanges {
+    constructor(_viewContainerRef: ViewContainerRef);
+    // (undocumented)
+    ngOnChanges(changes: SimpleChanges): void;
     ngTemplateOutlet: TemplateRef<any> | null;
     ngTemplateOutletContext: Object | null;
-    constructor(_viewContainerRef: ViewContainerRef);
+    }
-    ngOnChanges(changes: SimpleChanges): void;
-}
 
-export declare enum NumberFormatStyle {
+// @public
-    Decimal = 0,
+export enum NumberFormatStyle {
-    Percent = 1,
+    // (undocumented)
     Currency = 2,
+    // (undocumented)
+    Decimal = 0,
+    // (undocumented)
+    Percent = 1,
+    // (undocumented)
     Scientific = 3
 }
 
-export declare enum NumberSymbol {
+// @public
-    Decimal = 0,
+export enum NumberSymbol {
-    Group = 1,
-    List = 2,
-    PercentSign = 3,
-    PlusSign = 4,
-    MinusSign = 5,
-    Exponential = 6,
-    SuperscriptingExponent = 7,
-    PerMille = 8,
-    Infinity = 9,
-    NaN = 10,
-    TimeSeparator = 11,
     CurrencyDecimal = 12,
-    CurrencyGroup = 13
+    CurrencyGroup = 13,
+    Decimal = 0,
+    Exponential = 6,
+    Group = 1,
+    Infinity = 9,
+    List = 2,
+    MinusSign = 5,
+    NaN = 10,
+    PercentSign = 3,
+    PerMille = 8,
+    PlusSign = 4,
+    SuperscriptingExponent = 7,
+    TimeSeparator = 11
 }
 
-export declare class PathLocationStrategy extends LocationStrategy implements OnDestroy {
+// @public
+export class PathLocationStrategy extends LocationStrategy implements OnDestroy {
     constructor(_platformLocation: PlatformLocation, href?: string);
+    // (undocumented)
     back(): void;
+    // (undocumented)
     forward(): void;
+    // (undocumented)
     getBaseHref(): string;
+    // (undocumented)
     historyGo(relativePosition?: number): void;
+    // (undocumented)
     ngOnDestroy(): void;
+    // (undocumented)
     onPopState(fn: LocationChangeListener): void;
+    // (undocumented)
     path(includeHash?: boolean): string;
+    // (undocumented)
     prepareExternalUrl(internal: string): string;
+    // (undocumented)
     pushState(state: any, title: string, url: string, queryParams: string): void;
+    // (undocumented)
     replaceState(state: any, title: string, url: string, queryParams: string): void;
 }
 
-export declare class PercentPipe implements PipeTransform {
+// @public
+export class PercentPipe implements PipeTransform {
     constructor(_locale: string);
+    // (undocumented)
     transform(value: number | string, digitsInfo?: string, locale?: string): string | null;
+    // (undocumented)
     transform(value: null | undefined, digitsInfo?: string, locale?: string): null;
+    // (undocumented)
     transform(value: number | string | null | undefined, digitsInfo?: string, locale?: string): string | null;
 }
 
-export declare abstract class PlatformLocation {
+// @public
-    abstract get hash(): string;
+export abstract class PlatformLocation {
-    abstract get hostname(): string;
+    // (undocumented)
-    abstract get href(): string;
-    abstract get pathname(): string;
-    abstract get port(): string;
-    abstract get protocol(): string;
-    abstract get search(): string;
     abstract back(): void;
+    // (undocumented)
     abstract forward(): void;
+    // (undocumented)
     abstract getBaseHrefFromDOM(): string;
+    // (undocumented)
     abstract getState(): unknown;
+    // (undocumented)
+    abstract get hash(): string;
+    // (undocumented)
     historyGo?(relativePosition: number): void;
+    // (undocumented)
+    abstract get hostname(): string;
+    // (undocumented)
+    abstract get href(): string;
     abstract onHashChange(fn: LocationChangeListener): VoidFunction;
     abstract onPopState(fn: LocationChangeListener): VoidFunction;
+    // (undocumented)
+    abstract get pathname(): string;
+    // (undocumented)
+    abstract get port(): string;
+    // (undocumented)
+    abstract get protocol(): string;
+    // (undocumented)
     abstract pushState(state: any, title: string, url: string): void;
+    // (undocumented)
     abstract replaceState(state: any, title: string, url: string): void;
+    // (undocumented)
+    abstract get search(): string;
 }
 
-export declare enum Plural {
+// @public
-    Zero = 0,
+export enum Plural {
-    One = 1,
+    // (undocumented)
-    Two = 2,
     Few = 3,
+    // (undocumented)
     Many = 4,
-    Other = 5
+    // (undocumented)
+    One = 1,
+    // (undocumented)
+    Other = 5,
+    // (undocumented)
+    Two = 2,
+    // (undocumented)
+    Zero = 0
 }
 
-export declare interface PopStateEvent {
+// @public (undocumented)
+export interface PopStateEvent {
+    // (undocumented)
     pop?: boolean;
+    // (undocumented)
     state?: any;
+    // (undocumented)
     type?: string;
+    // (undocumented)
     url?: string;
 }
 
-export declare function registerLocaleData(data: any, localeId?: string | any, extraData?: any): void;
+// @public
+export function registerLocaleData(data: any, localeId?: string | any, extraData?: any): void;
 
-export declare class SlicePipe implements PipeTransform {
+// @public
+export class SlicePipe implements PipeTransform {
+    // (undocumented)
     transform<T>(value: ReadonlyArray<T>, start: number, end?: number): Array<T>;
+    // (undocumented)
     transform(value: null | undefined, start: number, end?: number): null;
+    // (undocumented)
     transform<T>(value: ReadonlyArray<T> | null | undefined, start: number, end?: number): Array<T> | null;
+    // (undocumented)
     transform(value: string, start: number, end?: number): string;
+    // (undocumented)
     transform(value: string | null | undefined, start: number, end?: number): string | null;
 }
 
-export declare type Time = {
+// @public
+export type Time = {
     hours: number;
     minutes: number;
 };
 
-export declare class TitleCasePipe implements PipeTransform {
+// @public
+export class TitleCasePipe implements PipeTransform {
+    // (undocumented)
     transform(value: string): string;
+    // (undocumented)
     transform(value: null | undefined): null;
+    // (undocumented)
     transform(value: string | null | undefined): string | null;
 }
 
-export declare enum TranslationWidth {
+// @public
-    Narrow = 0,
+export enum TranslationWidth {
     Abbreviated = 1,
-    Wide = 2,
+    Narrow = 0,
-    Short = 3
+    Short = 3,
+    Wide = 2
 }
 
-export declare class UpperCasePipe implements PipeTransform {
+// @public
+export class UpperCasePipe implements PipeTransform {
+    // (undocumented)
     transform(value: string): string;
+    // (undocumented)
     transform(value: null | undefined): null;
+    // (undocumented)
     transform(value: string | null | undefined): string | null;
 }
 
-export declare const VERSION: Version;
+// @public (undocumented)
+export const VERSION: Version;
 
-export declare abstract class ViewportScroller {
+// @public
+export abstract class ViewportScroller {
     abstract getScrollPosition(): [number, number];
     abstract scrollToAnchor(anchor: string): void;
     abstract scrollToPosition(position: [number, number]): void;
     abstract setHistoryScrollRestoration(scrollRestoration: 'auto' | 'manual'): void;
     abstract setOffset(offset: [number, number] | (() => [number, number])): void;
+    // (undocumented)
     static ɵprov: unknown;
 }
 
-export declare enum WeekDay {
+// @public
-    Sunday = 0,
+export enum WeekDay {
-    Monday = 1,
+    // (undocumented)
-    Tuesday = 2,
-    Wednesday = 3,
-    Thursday = 4,
     Friday = 5,
-    Saturday = 6
+    // (undocumented)
+    Monday = 1,
+    // (undocumented)
+    Saturday = 6,
+    // (undocumented)
+    Sunday = 0,
+    // (undocumented)
+    Thursday = 4,
+    // (undocumented)
+    Tuesday = 2,
+    // (undocumented)
+    Wednesday = 3
 }
 
-export declare abstract class XhrFactory {
+// @public
+export abstract class XhrFactory {
+    // (undocumented)
     abstract build(): XMLHttpRequest;
 }
+
+
+// (No @packageDocumentation comment for this package)
+
+```

goldens/public-api/common/http/http.md

@@ -1,10 +1,25 @@
-export declare const HTTP_INTERCEPTORS: InjectionToken<HttpInterceptor[]>;
+## API Report File for "@angular/common_http"
 
-export declare abstract class HttpBackend implements HttpHandler {
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import { InjectionToken } from '@angular/core';
+import { ModuleWithProviders } from '@angular/core';
+import { Observable } from 'rxjs';
+import { XhrFactory as XhrFactory_2 } from '@angular/common';
+
+// @public
+export const HTTP_INTERCEPTORS: InjectionToken<HttpInterceptor[]>;
+
+// @public
+export abstract class HttpBackend implements HttpHandler {
+    // (undocumented)
     abstract handle(req: HttpRequest<any>): Observable<HttpEvent<any>>;
 }
 
-export declare class HttpClient {
+// @public
+export class HttpClient {
     constructor(handler: HttpHandler);
     delete(url: string, options: {
         headers?: HttpHeaders | {
@@ -1615,13 +1630,16 @@ export declare class HttpClient {
     }): Observable<any>;
 }
 
-export declare class HttpClientJsonpModule {
+// @public
+export class HttpClientJsonpModule {
 }
 
-export declare class HttpClientModule {
+// @public
+export class HttpClientModule {
 }
 
-export declare class HttpClientXsrfModule {
+// @public
+export class HttpClientXsrfModule {
     static disable(): ModuleWithProviders<HttpClientXsrfModule>;
     static withOptions(options?: {
         cookieName?: string;
@@ -1629,28 +1647,31 @@ export declare class HttpClientXsrfModule {
     }): ModuleWithProviders<HttpClientXsrfModule>;
 }
 
-export declare class HttpContext {
+// @public
+export class HttpContext {
     delete(token: HttpContextToken<unknown>): HttpContext;
     get<T>(token: HttpContextToken<T>): T;
+    // (undocumented)
     keys(): IterableIterator<HttpContextToken<unknown>>;
     set<T>(token: HttpContextToken<T>, value: T): HttpContext;
 }
 
-export declare class HttpContextToken<T> {
+// @public
-    readonly defaultValue: () => T;
+export class HttpContextToken<T> {
     constructor(defaultValue: () => T);
+    // (undocumented)
+    readonly defaultValue: () => T;
 }
 
-export declare interface HttpDownloadProgressEvent extends HttpProgressEvent {
+// @public
+export interface HttpDownloadProgressEvent extends HttpProgressEvent {
     partialText?: string;
+    // (undocumented)
     type: HttpEventType.DownloadProgress;
 }
 
-export declare class HttpErrorResponse extends HttpResponseBase implements Error {
+// @public
-    readonly error: any | null;
+export class HttpErrorResponse extends HttpResponseBase implements Error {
-    readonly message: string;
-    readonly name = "HttpErrorResponse";
-    readonly ok = false;
     constructor(init: {
         error?: any;
         headers?: HttpHeaders;
@@ -1658,25 +1679,36 @@ export declare class HttpErrorResponse extends HttpResponseBase implements Error
         statusText?: string;
         url?: string;
     });
+    // (undocumented)
+    readonly error: any | null;
+    // (undocumented)
+    readonly message: string;
+    // (undocumented)
+    readonly name = "HttpErrorResponse";
+    readonly ok = false;
 }
 
-export declare type HttpEvent<T> = HttpSentEvent | HttpHeaderResponse | HttpResponse<T> | HttpProgressEvent | HttpUserEvent<T>;
+// @public
+export type HttpEvent<T> = HttpSentEvent | HttpHeaderResponse | HttpResponse<T> | HttpProgressEvent | HttpUserEvent<T>;
 
-export declare enum HttpEventType {
+// @public
-    Sent = 0,
+export enum HttpEventType {
-    UploadProgress = 1,
-    ResponseHeader = 2,
     DownloadProgress = 3,
     Response = 4,
+    ResponseHeader = 2,
+    Sent = 0,
+    UploadProgress = 1,
     User = 5
 }
 
-export declare abstract class HttpHandler {
+// @public
+export abstract class HttpHandler {
+    // (undocumented)
     abstract handle(req: HttpRequest<any>): Observable<HttpEvent<any>>;
 }
 
-export declare class HttpHeaderResponse extends HttpResponseBase {
+// @public
-    readonly type: HttpEventType.ResponseHeader;
+export class HttpHeaderResponse extends HttpResponseBase {
     constructor(init?: {
         headers?: HttpHeaders;
         status?: number;
@@ -1689,9 +1721,12 @@ export declare class HttpHeaderResponse extends HttpResponseBase {
         statusText?: string;
         url?: string;
     }): HttpHeaderResponse;
+    // (undocumented)
+    readonly type: HttpEventType.ResponseHeader;
 }
 
-export declare class HttpHeaders {
+// @public
+export class HttpHeaders {
     constructor(headers?: string | {
         [name: string]: string | string[];
     });
@@ -1704,18 +1739,25 @@ export declare class HttpHeaders {
     set(name: string, value: string | string[]): HttpHeaders;
 }
 
-export declare interface HttpInterceptor {
+// @public
+export interface HttpInterceptor {
     intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
 }
 
-export declare interface HttpParameterCodec {
+// @public
+export interface HttpParameterCodec {
+    // (undocumented)
     decodeKey(key: string): string;
+    // (undocumented)
     decodeValue(value: string): string;
+    // (undocumented)
     encodeKey(key: string): string;
+    // (undocumented)
     encodeValue(value: string): string;
 }
 
-export declare class HttpParams {
+// @public
+export class HttpParams {
     constructor(options?: HttpParamsOptions);
     append(param: string, value: string | number | boolean): HttpParams;
     appendAll(params: {
@@ -1728,9 +1770,10 @@ export declare class HttpParams {
     keys(): string[];
     set(param: string, value: string | number | boolean): HttpParams;
     toString(): string;
-}
+    }
 
-export declare interface HttpParamsOptions {
+// @public
+export interface HttpParamsOptions {
     encoder?: HttpParameterCodec;
     fromObject?: {
         [param: string]: string | number | boolean | ReadonlyArray<string | number | boolean>;
@@ -1738,23 +1781,15 @@ export declare interface HttpParamsOptions {
     fromString?: string;
 }
 
-export declare interface HttpProgressEvent {
+// @public
+export interface HttpProgressEvent {
     loaded: number;
     total?: number;
     type: HttpEventType.DownloadProgress | HttpEventType.UploadProgress;
 }
 
-export declare class HttpRequest<T> {
+// @public
-    readonly body: T | null;
+export class HttpRequest<T> {
-    readonly context: HttpContext;
-    readonly headers: HttpHeaders;
-    readonly method: string;
-    readonly params: HttpParams;
-    readonly reportProgress: boolean;
-    readonly responseType: 'arraybuffer' | 'blob' | 'json' | 'text';
-    readonly url: string;
-    readonly urlWithParams: string;
-    readonly withCredentials: boolean;
     constructor(method: 'DELETE' | 'GET' | 'HEAD' | 'JSONP' | 'OPTIONS', url: string, init?: {
         headers?: HttpHeaders;
         context?: HttpContext;
@@ -1779,7 +1814,10 @@ export declare class HttpRequest<T> {
         responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';
         withCredentials?: boolean;
     });
+    readonly body: T | null;
+    // (undocumented)
     clone(): HttpRequest<T>;
+    // (undocumented)
     clone(update: {
         headers?: HttpHeaders;
         context?: HttpContext;
@@ -1797,6 +1835,7 @@ export declare class HttpRequest<T> {
             [param: string]: string;
         };
     }): HttpRequest<T>;
+    // (undocumented)
     clone<V>(update: {
         headers?: HttpHeaders;
         context?: HttpContext;
@@ -1814,13 +1853,22 @@ export declare class HttpRequest<T> {
             [param: string]: string;
         };
     }): HttpRequest<V>;
+    readonly context: HttpContext;
     detectContentTypeHeader(): string | null;
+    readonly headers: HttpHeaders;
+    readonly method: string;
+    readonly params: HttpParams;
+    readonly reportProgress: boolean;
+    readonly responseType: 'arraybuffer' | 'blob' | 'json' | 'text';
     serializeBody(): ArrayBuffer | Blob | FormData | string | null;
+    // (undocumented)
+    readonly url: string;
+    readonly urlWithParams: string;
+    readonly withCredentials: boolean;
 }
 
-export declare class HttpResponse<T> extends HttpResponseBase {
+// @public
-    readonly body: T | null;
+export class HttpResponse<T> extends HttpResponseBase {
-    readonly type: HttpEventType.Response;
     constructor(init?: {
         body?: T | null;
         headers?: HttpHeaders;
@@ -1828,13 +1876,17 @@ export declare class HttpResponse<T> extends HttpResponseBase {
         statusText?: string;
         url?: string;
     });
+    readonly body: T | null;
+    // (undocumented)
     clone(): HttpResponse<T>;
+    // (undocumented)
     clone(update: {
         headers?: HttpHeaders;
         status?: number;
         statusText?: string;
         url?: string;
     }): HttpResponse<T>;
+    // (undocumented)
     clone<V>(update: {
         body?: V | null;
         headers?: HttpHeaders;
@@ -1842,126 +1894,212 @@ export declare class HttpResponse<T> extends HttpResponseBase {
         statusText?: string;
         url?: string;
     }): HttpResponse<V>;
+    // (undocumented)
+    readonly type: HttpEventType.Response;
 }
 
-export declare abstract class HttpResponseBase {
+// @public
-    readonly headers: HttpHeaders;
+export abstract class HttpResponseBase {
-    readonly ok: boolean;
-    readonly status: number;
-    readonly statusText: string;
-    readonly type: HttpEventType.Response | HttpEventType.ResponseHeader;
-    readonly url: string | null;
     constructor(init: {
         headers?: HttpHeaders;
         status?: number;
         statusText?: string;
         url?: string;
     }, defaultStatus?: number, defaultStatusText?: string);
+    readonly headers: HttpHeaders;
+    readonly ok: boolean;
+    readonly status: number;
+    readonly statusText: string;
+    readonly type: HttpEventType.Response | HttpEventType.ResponseHeader;
+    readonly url: string | null;
 }
 
-export declare interface HttpSentEvent {
+// @public
+export interface HttpSentEvent {
+    // (undocumented)
     type: HttpEventType.Sent;
 }
 
-export declare const enum HttpStatusCode {
+// @public
-    Continue = 100,
+export const enum HttpStatusCode {
-    SwitchingProtocols = 101,
+    // (undocumented)
-    Processing = 102,
-    EarlyHints = 103,
-    Ok = 200,
-    Created = 201,
     Accepted = 202,
-    NonAuthoritativeInformation = 203,
+    // (undocumented)
-    NoContent = 204,
-    ResetContent = 205,
-    PartialContent = 206,
-    MultiStatus = 207,
     AlreadyReported = 208,
-    ImUsed = 226,
+    // (undocumented)
-    MultipleChoices = 300,
-    MovedPermanently = 301,
-    Found = 302,
-    SeeOther = 303,
-    NotModified = 304,
-    UseProxy = 305,
-    Unused = 306,
-    TemporaryRedirect = 307,
-    PermanentRedirect = 308,
-    BadRequest = 400,
-    Unauthorized = 401,
-    PaymentRequired = 402,
-    Forbidden = 403,
-    NotFound = 404,
-    MethodNotAllowed = 405,
-    NotAcceptable = 406,
-    ProxyAuthenticationRequired = 407,
-    RequestTimeout = 408,
-    Conflict = 409,
-    Gone = 410,
-    LengthRequired = 411,
-    PreconditionFailed = 412,
-    PayloadTooLarge = 413,
-    UriTooLong = 414,
-    UnsupportedMediaType = 415,
-    RangeNotSatisfiable = 416,
-    ExpectationFailed = 417,
-    ImATeapot = 418,
-    MisdirectedRequest = 421,
-    UnprocessableEntity = 422,
-    Locked = 423,
-    FailedDependency = 424,
-    TooEarly = 425,
-    UpgradeRequired = 426,
-    PreconditionRequired = 428,
-    TooManyRequests = 429,
-    RequestHeaderFieldsTooLarge = 431,
-    UnavailableForLegalReasons = 451,
-    InternalServerError = 500,
-    NotImplemented = 501,
     BadGateway = 502,
-    ServiceUnavailable = 503,
+    // (undocumented)
+    BadRequest = 400,
+    // (undocumented)
+    Conflict = 409,
+    // (undocumented)
+    Continue = 100,
+    // (undocumented)
+    Created = 201,
+    // (undocumented)
+    EarlyHints = 103,
+    // (undocumented)
+    ExpectationFailed = 417,
+    // (undocumented)
+    FailedDependency = 424,
+    // (undocumented)
+    Forbidden = 403,
+    // (undocumented)
+    Found = 302,
+    // (undocumented)
     GatewayTimeout = 504,
+    // (undocumented)
+    Gone = 410,
+    // (undocumented)
     HttpVersionNotSupported = 505,
-    VariantAlsoNegotiates = 506,
+    // (undocumented)
+    ImATeapot = 418,
+    // (undocumented)
+    ImUsed = 226,
+    // (undocumented)
     InsufficientStorage = 507,
+    // (undocumented)
+    InternalServerError = 500,
+    // (undocumented)
+    LengthRequired = 411,
+    // (undocumented)
+    Locked = 423,
+    // (undocumented)
     LoopDetected = 508,
+    // (undocumented)
+    MethodNotAllowed = 405,
+    // (undocumented)
+    MisdirectedRequest = 421,
+    // (undocumented)
+    MovedPermanently = 301,
+    // (undocumented)
+    MultipleChoices = 300,
+    // (undocumented)
+    MultiStatus = 207,
+    // (undocumented)
+    NetworkAuthenticationRequired = 511,
+    // (undocumented)
+    NoContent = 204,
+    // (undocumented)
+    NonAuthoritativeInformation = 203,
+    // (undocumented)
+    NotAcceptable = 406,
+    // (undocumented)
     NotExtended = 510,
-    NetworkAuthenticationRequired = 511
+    // (undocumented)
+    NotFound = 404,
+    // (undocumented)
+    NotImplemented = 501,
+    // (undocumented)
+    NotModified = 304,
+    // (undocumented)
+    Ok = 200,
+    // (undocumented)
+    PartialContent = 206,
+    // (undocumented)
+    PayloadTooLarge = 413,
+    // (undocumented)
+    PaymentRequired = 402,
+    // (undocumented)
+    PermanentRedirect = 308,
+    // (undocumented)
+    PreconditionFailed = 412,
+    // (undocumented)
+    PreconditionRequired = 428,
+    // (undocumented)
+    Processing = 102,
+    // (undocumented)
+    ProxyAuthenticationRequired = 407,
+    // (undocumented)
+    RangeNotSatisfiable = 416,
+    // (undocumented)
+    RequestHeaderFieldsTooLarge = 431,
+    // (undocumented)
+    RequestTimeout = 408,
+    // (undocumented)
+    ResetContent = 205,
+    // (undocumented)
+    SeeOther = 303,
+    // (undocumented)
+    ServiceUnavailable = 503,
+    // (undocumented)
+    SwitchingProtocols = 101,
+    // (undocumented)
+    TemporaryRedirect = 307,
+    // (undocumented)
+    TooEarly = 425,
+    // (undocumented)
+    TooManyRequests = 429,
+    // (undocumented)
+    Unauthorized = 401,
+    // (undocumented)
+    UnavailableForLegalReasons = 451,
+    // (undocumented)
+    UnprocessableEntity = 422,
+    // (undocumented)
+    UnsupportedMediaType = 415,
+    // (undocumented)
+    Unused = 306,
+    // (undocumented)
+    UpgradeRequired = 426,
+    // (undocumented)
+    UriTooLong = 414,
+    // (undocumented)
+    UseProxy = 305,
+    // (undocumented)
+    VariantAlsoNegotiates = 506
 }
 
-export declare interface HttpUploadProgressEvent extends HttpProgressEvent {
+// @public
+export interface HttpUploadProgressEvent extends HttpProgressEvent {
+    // (undocumented)
     type: HttpEventType.UploadProgress;
 }
 
-export declare class HttpUrlEncodingCodec implements HttpParameterCodec {
+// @public
+export class HttpUrlEncodingCodec implements HttpParameterCodec {
     decodeKey(key: string): string;
     decodeValue(value: string): string;
     encodeKey(key: string): string;
     encodeValue(value: string): string;
 }
 
-export declare interface HttpUserEvent<T> {
+// @public
+export interface HttpUserEvent<T> {
+    // (undocumented)
     type: HttpEventType.User;
 }
 
-export declare class HttpXhrBackend implements HttpBackend {
+// @public
+export class HttpXhrBackend implements HttpBackend {
     constructor(xhrFactory: XhrFactory_2);
     handle(req: HttpRequest<any>): Observable<HttpEvent<any>>;
-}
+    }
 
-export declare abstract class HttpXsrfTokenExtractor {
+// @public
+export abstract class HttpXsrfTokenExtractor {
     abstract getToken(): string | null;
 }
 
-export declare class JsonpClientBackend implements HttpBackend {
+// @public
+export class JsonpClientBackend implements HttpBackend {
     constructor(callbackMap: ɵangular_packages_common_http_http_b, document: any);
     handle(req: HttpRequest<never>): Observable<HttpEvent<any>>;
-}
+    }
 
-export declare class JsonpInterceptor {
+// @public
+export class JsonpInterceptor {
     constructor(jsonp: JsonpClientBackend);
     intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
-}
+    }
 
-/** @deprecated */
+// @public @deprecated
-export declare type XhrFactory = XhrFactory_2;
+export type XhrFactory = XhrFactory_2;
+
+// @public @deprecated
+export const XhrFactory: typeof XhrFactory_2;
+
+
+// (No @packageDocumentation comment for this package)
+
+```

goldens/public-api/common/http/testing/testing.md

@@ -1,7 +1,20 @@
-export declare class HttpClientTestingModule {
+## API Report File for "@angular/common_http_testing"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import { HttpEvent } from '@angular/common/http';
+import { HttpHeaders } from '@angular/common/http';
+import { HttpRequest } from '@angular/common/http';
+import { Observer } from 'rxjs';
+
+// @public
+export class HttpClientTestingModule {
 }
 
-export declare abstract class HttpTestingController {
+// @public
+export abstract class HttpTestingController {
     abstract expectNone(url: string, description?: string): void;
     abstract expectNone(params: RequestMatch, description?: string): void;
     abstract expectNone(matchFn: ((req: HttpRequest<any>) => boolean), description?: string): void;
@@ -16,15 +29,18 @@ export declare abstract class HttpTestingController {
     }): void;
 }
 
-export declare interface RequestMatch {
+// @public
+export interface RequestMatch {
+    // (undocumented)
     method?: string;
+    // (undocumented)
     url?: string;
 }
 
-export declare class TestRequest {
+// @public
-    get cancelled(): boolean;
+export class TestRequest {
-    request: HttpRequest<any>;
     constructor(request: HttpRequest<any>, observer: Observer<HttpEvent<any>>);
+    get cancelled(): boolean;
     error(error: ErrorEvent, opts?: {
         headers?: HttpHeaders | {
             [name: string]: string | string[];
@@ -40,4 +56,11 @@ export declare class TestRequest {
         status?: number;
         statusText?: string;
     }): void;
+    // (undocumented)
+    request: HttpRequest<any>;
 }
+
+
+// (No @packageDocumentation comment for this package)
+
+```

goldens/public-api/common/testing/testing.md

@@ -1,66 +1,140 @@
-export declare const MOCK_PLATFORM_LOCATION_CONFIG: InjectionToken<MockPlatformLocationConfig>;
+## API Report File for "@angular/common_testing"
 
-export declare class MockLocationStrategy extends LocationStrategy {
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
-    internalBaseHref: string;
+
-    internalPath: string;
+```ts
-    internalTitle: string;
+
-    urlChanges: string[];
+import { InjectionToken } from '@angular/core';
+import { Location } from '@angular/common';
+import { LocationChangeListener } from '@angular/common';
+import { LocationStrategy } from '@angular/common';
+import { PlatformLocation } from '@angular/common';
+import { SubscriptionLike } from 'rxjs';
+
+// @public
+export const MOCK_PLATFORM_LOCATION_CONFIG: InjectionToken<MockPlatformLocationConfig>;
+
+// @public
+export class MockLocationStrategy extends LocationStrategy {
     constructor();
+    // (undocumented)
     back(): void;
+    // (undocumented)
     forward(): void;
+    // (undocumented)
     getBaseHref(): string;
+    // (undocumented)
     getState(): unknown;
+    // (undocumented)
+    internalBaseHref: string;
+    // (undocumented)
+    internalPath: string;
+    // (undocumented)
+    internalTitle: string;
+    // (undocumented)
     onPopState(fn: (value: any) => void): void;
+    // (undocumented)
     path(includeHash?: boolean): string;
+    // (undocumented)
     prepareExternalUrl(internal: string): string;
+    // (undocumented)
     pushState(ctx: any, title: string, path: string, query: string): void;
+    // (undocumented)
     replaceState(ctx: any, title: string, path: string, query: string): void;
+    // (undocumented)
     simulatePopState(url: string): void;
+    // (undocumented)
+    urlChanges: string[];
 }
 
-export declare class MockPlatformLocation implements PlatformLocation {
+// @public
-    get hash(): string;
+export class MockPlatformLocation implements PlatformLocation {
-    get hostname(): string;
-    get href(): string;
-    get pathname(): string;
-    get port(): string;
-    get protocol(): string;
-    get search(): string;
-    get state(): unknown;
-    get url(): string;
     constructor(config?: MockPlatformLocationConfig);
+    // (undocumented)
     back(): void;
+    // (undocumented)
     forward(): void;
+    // (undocumented)
     getBaseHrefFromDOM(): string;
+    // (undocumented)
     getState(): unknown;
+    // (undocumented)
+    get hash(): string;
+    // (undocumented)
     historyGo(relativePosition?: number): void;
+    // (undocumented)
+    get hostname(): string;
+    // (undocumented)
+    get href(): string;
+    // (undocumented)
     onHashChange(fn: LocationChangeListener): VoidFunction;
+    // (undocumented)
     onPopState(fn: LocationChangeListener): VoidFunction;
+    // (undocumented)
+    get pathname(): string;
+    // (undocumented)
+    get port(): string;
+    // (undocumented)
+    get protocol(): string;
+    // (undocumented)
     pushState(state: any, title: string, newUrl: string): void;
+    // (undocumented)
     replaceState(state: any, title: string, newUrl: string): void;
-}
+    // (undocumented)
+    get search(): string;
+    // (undocumented)
+    get state(): unknown;
+    // (undocumented)
+    get url(): string;
+    }
 
-export declare interface MockPlatformLocationConfig {
+// @public
+export interface MockPlatformLocationConfig {
+    // (undocumented)
     appBaseHref?: string;
+    // (undocumented)
     startUrl?: string;
 }
 
-export declare class SpyLocation implements Location {
+// @public
-    urlChanges: string[];
+export class SpyLocation implements Location {
+    // (undocumented)
     back(): void;
+    // (undocumented)
     forward(): void;
+    // (undocumented)
     getState(): unknown;
+    // (undocumented)
     go(path: string, query?: string, state?: any): void;
+    // (undocumented)
     historyGo(relativePosition?: number): void;
+    // (undocumented)
     isCurrentPathEqualTo(path: string, query?: string): boolean;
+    // (undocumented)
     normalize(url: string): string;
+    // (undocumented)
     onUrlChange(fn: (url: string, state: unknown) => void): void;
+    // (undocumented)
     path(): string;
+    // (undocumented)
     prepareExternalUrl(url: string): string;
+    // (undocumented)
     replaceState(path: string, query?: string, state?: any): void;
+    // (undocumented)
     setBaseHref(url: string): void;
+    // (undocumented)
     setInitialPath(url: string): void;
+    // (undocumented)
     simulateHashChange(pathname: string): void;
+    // (undocumented)
     simulateUrlPop(pathname: string): void;
+    // (undocumented)
     subscribe(onNext: (value: any) => void, onThrow?: ((error: any) => void) | null, onReturn?: (() => void) | null): SubscriptionLike;
+    // (undocumented)
+    urlChanges: string[];
 }
+
+
+// (No @packageDocumentation comment for this package)
+
+```

goldens/public-api/common/upgrade/upgrade.md

@@ -1,13 +1,29 @@
-export declare class $locationShim {
+## API Report File for "@angular/common_upgrade"
-    constructor($injector: any, location: Location, platformLocation: PlatformLocation, urlCodec: UrlCodec, locationStrategy: LocationStrategy);
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import { InjectionToken } from '@angular/core';
+import { Location } from '@angular/common';
+import { LocationStrategy } from '@angular/common';
+import { ModuleWithProviders } from '@angular/core';
+import { PlatformLocation } from '@angular/common';
+import { UpgradeModule } from '@angular/upgrade/static';
+
+// @public
+export class $locationShim {
     $$parse(url: string): void;
     $$parseLinkUrl(url: string, relHref?: string | null): boolean;
+    constructor($injector: any, location: Location, platformLocation: PlatformLocation, urlCodec: UrlCodec, locationStrategy: LocationStrategy);
     absUrl(): string;
     hash(): string;
+    // (undocumented)
     hash(hash: string | number | null): this;
     host(): string;
     onChange(fn: (url: string, state: unknown, oldUrl: string, oldState: unknown) => void, err?: (e: Error) => void): void;
     path(): string;
+    // (undocumented)
     path(path: string | number | null): this;
     port(): number | null;
     protocol(): string;
@@ -15,41 +31,57 @@ export declare class $locationShim {
     search(): {
         [key: string]: unknown;
     };
+    // (undocumented)
     search(search: string | number | {
         [key: string]: unknown;
     }): this;
+    // (undocumented)
     search(search: string | number | {
         [key: string]: unknown;
     }, paramValue: null | undefined | string | number | boolean | string[]): this;
     state(): unknown;
+    // (undocumented)
     state(state: unknown): this;
     url(): string;
+    // (undocumented)
     url(url: string): this;
-}
+    }
 
-export declare class $locationShimProvider {
+// @public
-    constructor(ngUpgrade: UpgradeModule, location: Location, platformLocation: PlatformLocation, urlCodec: UrlCodec, locationStrategy: LocationStrategy);
+export class $locationShimProvider {
     $get(): $locationShim;
+    constructor(ngUpgrade: UpgradeModule, location: Location, platformLocation: PlatformLocation, urlCodec: UrlCodec, locationStrategy: LocationStrategy);
     hashPrefix(prefix?: string): void;
     html5Mode(mode?: any): void;
-}
+    }
 
-export declare class AngularJSUrlCodec implements UrlCodec {
+// @public
+export class AngularJSUrlCodec implements UrlCodec {
+    // (undocumented)
     areEqual(valA: string, valB: string): boolean;
+    // (undocumented)
     decodeHash(hash: string): string;
+    // (undocumented)
     decodePath(path: string, html5Mode?: boolean): string;
+    // (undocumented)
     decodeSearch(search: string): {
         [k: string]: unknown;
     };
+    // (undocumented)
     encodeHash(hash: string): string;
+    // (undocumented)
     encodePath(path: string): string;
+    // (undocumented)
     encodeSearch(search: string | {
         [k: string]: unknown;
     }): string;
+    // (undocumented)
     normalize(href: string): string;
+    // (undocumented)
     normalize(path: string, search: {
         [k: string]: unknown;
     }, hash: string, baseUrl?: string): string;
+    // (undocumented)
     parse(url: string, base?: string): {
         href: string;
         protocol: string;
@@ -62,9 +94,11 @@ export declare class AngularJSUrlCodec implements UrlCodec {
     };
 }
 
-export declare const LOCATION_UPGRADE_CONFIGURATION: InjectionToken<LocationUpgradeConfig>;
+// @public
+export const LOCATION_UPGRADE_CONFIGURATION: InjectionToken<LocationUpgradeConfig>;
 
-export declare interface LocationUpgradeConfig {
+// @public
+export interface LocationUpgradeConfig {
     appBaseHref?: string;
     hashPrefix?: string;
     serverBaseHref?: string;
@@ -72,11 +106,14 @@ export declare interface LocationUpgradeConfig {
     useHash?: boolean;
 }
 
-export declare class LocationUpgradeModule {
+// @public
+export class LocationUpgradeModule {
+    // (undocumented)
     static config(config?: LocationUpgradeConfig): ModuleWithProviders<LocationUpgradeModule>;
 }
 
-export declare abstract class UrlCodec {
+// @public
+export abstract class UrlCodec {
     abstract areEqual(valA: string, valB: string): boolean;
     abstract decodeHash(hash: string): string;
     abstract decodePath(path: string): string;
@@ -103,3 +140,8 @@ export declare abstract class UrlCodec {
         pathname: string;
     };
 }
+
+
+// (No @packageDocumentation comment for this package)
+
+```

goldens/public-api/compiler-cli/compiler_options.md

@@ -1,8 +1,16 @@
+## API Report File for "angular-srcs"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+// @public
 export interface BazelAndG3Options {
     annotateForClosureCompiler?: boolean;
     generateDeepReexports?: boolean;
 }
 
+// @public
 export interface I18nOptions {
     enableI18nLegacyMessageIdFormat?: boolean;
     i18nInLocale?: string;
@@ -13,6 +21,7 @@ export interface I18nOptions {
     i18nUseExternalIds?: boolean;
 }
 
+// @public
 export interface LegacyNgcOptions {
     allowEmptyCodegenFiles?: boolean;
     flatModuleId?: string;
@@ -22,17 +31,20 @@ export interface LegacyNgcOptions {
     strictInjectionParameters?: boolean;
 }
 
+// @public
 export interface MiscOptions {
     compileNonExportedClasses?: boolean;
     disableTypeScriptVersionCheck?: boolean;
 }
 
+// @public
 export interface NgcCompatibilityOptions {
     enableIvy?: boolean | 'ngtsc';
     generateNgFactoryShims?: boolean;
     generateNgSummaryShims?: boolean;
 }
 
+// @public
 export interface StrictTemplateOptions {
     strictAttributeTypes?: boolean;
     strictContextGenerics?: boolean;
@@ -47,6 +59,12 @@ export interface StrictTemplateOptions {
     strictTemplates?: boolean;
 }
 
+// @public
 export interface TargetOptions {
     compilationMode?: 'full' | 'partial';
 }
+
+
+// (No @packageDocumentation comment for this package)
+
+```

goldens/public-api/compiler-cli/error_code.md

@@ -1,45 +1,72 @@
-export declare enum ErrorCode {
+## API Report File for "angular-srcs"
-    DECORATOR_ARG_NOT_LITERAL = 1001,
+
-    DECORATOR_ARITY_WRONG = 1002,
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
-    DECORATOR_NOT_CALLED = 1003,
+
-    DECORATOR_ON_ANONYMOUS_CLASS = 1004,
+```ts
-    DECORATOR_UNEXPECTED = 1005,
+
-    DECORATOR_COLLISION = 1006,
+// @public (undocumented)
-    VALUE_HAS_WRONG_TYPE = 1010,
+export enum ErrorCode {
-    VALUE_NOT_LITERAL = 1011,
-    COMPONENT_MISSING_TEMPLATE = 2001,
-    PIPE_MISSING_NAME = 2002,
-    PARAM_MISSING_TOKEN = 2003,
-    DIRECTIVE_MISSING_SELECTOR = 2004,
-    UNDECORATED_PROVIDER = 2005,
-    DIRECTIVE_INHERITS_UNDECORATED_CTOR = 2006,
-    UNDECORATED_CLASS_USING_ANGULAR_FEATURES = 2007,
-    COMPONENT_RESOURCE_NOT_FOUND = 2008,
     COMPONENT_INVALID_SHADOW_DOM_SELECTOR = 2009,
-    SYMBOL_NOT_EXPORTED = 3001,
+    // (undocumented)
-    SYMBOL_EXPORTED_UNDER_DIFFERENT_NAME = 3002,
+    COMPONENT_MISSING_TEMPLATE = 2001,
-    IMPORT_CYCLE_DETECTED = 3003,
+    COMPONENT_RESOURCE_NOT_FOUND = 2008,
+    // (undocumented)
     CONFIG_FLAT_MODULE_NO_INDEX = 4001,
+    // (undocumented)
     CONFIG_STRICT_TEMPLATES_IMPLIES_FULL_TEMPLATE_TYPECHECK = 4002,
+    // (undocumented)
+    DECORATOR_ARG_NOT_LITERAL = 1001,
+    // (undocumented)
+    DECORATOR_ARITY_WRONG = 1002,
+    DECORATOR_COLLISION = 1006,
+    // (undocumented)
+    DECORATOR_NOT_CALLED = 1003,
+    // (undocumented)
+    DECORATOR_ON_ANONYMOUS_CLASS = 1004,
+    // (undocumented)
+    DECORATOR_UNEXPECTED = 1005,
+    DIRECTIVE_INHERITS_UNDECORATED_CTOR = 2006,
+    // (undocumented)
+    DIRECTIVE_MISSING_SELECTOR = 2004,
+    DUPLICATE_VARIABLE_DECLARATION = 8006,
     HOST_BINDING_PARSE_ERROR = 5001,
-    TEMPLATE_PARSE_ERROR = 5002,
+    IMPORT_CYCLE_DETECTED = 3003,
+    INJECTABLE_DUPLICATE_PROV = 9001,
+    INLINE_TCB_REQUIRED = 8900,
+    INLINE_TYPE_CTOR_REQUIRED = 8901,
+    MISSING_PIPE = 8004,
+    MISSING_REFERENCE_TARGET = 8003,
+    NGMODULE_DECLARATION_NOT_UNIQUE = 6007,
     NGMODULE_INVALID_DECLARATION = 6001,
-    NGMODULE_INVALID_IMPORT = 6002,
     NGMODULE_INVALID_EXPORT = 6003,
+    NGMODULE_INVALID_IMPORT = 6002,
     NGMODULE_INVALID_REEXPORT = 6004,
     NGMODULE_MODULE_WITH_PROVIDERS_MISSING_GENERIC = 6005,
     NGMODULE_REEXPORT_NAME_COLLISION = 6006,
-    NGMODULE_DECLARATION_NOT_UNIQUE = 6007,
     NGMODULE_VE_DEPENDENCY_ON_IVY_LIB = 6999,
-    SCHEMA_INVALID_ELEMENT = 8001,
+    // (undocumented)
+    PARAM_MISSING_TOKEN = 2003,
+    // (undocumented)
+    PIPE_MISSING_NAME = 2002,
     SCHEMA_INVALID_ATTRIBUTE = 8002,
-    MISSING_REFERENCE_TARGET = 8003,
+    SCHEMA_INVALID_ELEMENT = 8001,
-    MISSING_PIPE = 8004,
-    WRITE_TO_READ_ONLY_VARIABLE = 8005,
-    DUPLICATE_VARIABLE_DECLARATION = 8006,
-    INLINE_TCB_REQUIRED = 8900,
-    INLINE_TYPE_CTOR_REQUIRED = 8901,
-    INJECTABLE_DUPLICATE_PROV = 9001,
     SUGGEST_STRICT_TEMPLATES = 10001,
-    SUGGEST_SUBOPTIMAL_TYPE_INFERENCE = 10002
+    SUGGEST_SUBOPTIMAL_TYPE_INFERENCE = 10002,
+    // (undocumented)
+    SYMBOL_EXPORTED_UNDER_DIFFERENT_NAME = 3002,
+    // (undocumented)
+    SYMBOL_NOT_EXPORTED = 3001,
+    TEMPLATE_PARSE_ERROR = 5002,
+    UNDECORATED_CLASS_USING_ANGULAR_FEATURES = 2007,
+    UNDECORATED_PROVIDER = 2005,
+    // (undocumented)
+    VALUE_HAS_WRONG_TYPE = 1010,
+    // (undocumented)
+    VALUE_NOT_LITERAL = 1011,
+    WRITE_TO_READ_ONLY_VARIABLE = 8005
 }
+
+
+// (No @packageDocumentation comment for this package)
+
+```

goldens/public-api/core/global_utils.d.ts

@@ -1,37 +0,0 @@
-export declare function applyChanges(component: {}): void;
-
-export interface ComponentDebugMetadata extends DirectiveDebugMetadata {
-    changeDetection: ChangeDetectionStrategy;
-    encapsulation: ViewEncapsulation;
-}
-
-export interface DirectiveDebugMetadata {
-    inputs: Record<string, string>;
-    outputs: Record<string, string>;
-}
-
-export declare function getComponent<T>(element: Element): T | null;
-
-export declare function getContext<T>(element: Element): T | null;
-
-export declare function getDirectiveMetadata(directiveOrComponentInstance: any): ComponentDebugMetadata | DirectiveDebugMetadata | null;
-
-export declare function getDirectives(node: Node): {}[];
-
-export declare function getHostElement(componentOrDirective: {}): Element;
-
-export declare function getInjector(elementOrDir: Element | {}): Injector;
-
-export declare function getListeners(element: Element): Listener[];
-
-export declare function getOwningComponent<T>(elementOrDir: Element | {}): T | null;
-
-export declare function getRootComponents(elementOrDir: Element | {}): {}[];
-
-export interface Listener {
-    callback: (value: any) => any;
-    element: Element;
-    name: string;
-    type: 'dom' | 'output';
-    useCapture: boolean;
-}

goldens/public-api/core/global_utils.md

@@ -0,0 +1,65 @@
+## API Report File for "angular-srcs"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+// @public
+export function applyChanges(component: {}): void;
+
+// @public
+export interface ComponentDebugMetadata extends DirectiveDebugMetadata {
+    // (undocumented)
+    changeDetection: ChangeDetectionStrategy;
+    // (undocumented)
+    encapsulation: ViewEncapsulation;
+}
+
+// @public
+export interface DirectiveDebugMetadata {
+    // (undocumented)
+    inputs: Record<string, string>;
+    // (undocumented)
+    outputs: Record<string, string>;
+}
+
+// @public
+export function getComponent<T>(element: Element): T | null;
+
+// @public
+export function getContext<T>(element: Element): T | null;
+
+// @public
+export function getDirectiveMetadata(directiveOrComponentInstance: any): ComponentDebugMetadata | DirectiveDebugMetadata | null;
+
+// @public
+export function getDirectives(node: Node): {}[];
+
+// @public
+export function getHostElement(componentOrDirective: {}): Element;
+
+// @public
+export function getInjector(elementOrDir: Element | {}): Injector;
+
+// @public
+export function getListeners(element: Element): Listener[];
+
+// @public
+export function getOwningComponent<T>(elementOrDir: Element | {}): T | null;
+
+// @public
+export function getRootComponents(elementOrDir: Element | {}): {}[];
+
+// @public
+export interface Listener {
+    callback: (value: any) => any;
+    element: Element;
+    name: string;
+    type: 'dom' | 'output';
+    useCapture: boolean;
+}
+
+
+// (No @packageDocumentation comment for this package)
+
+```

goldens/public-api/core/testing/testing.md

@@ -1,102 +1,164 @@
-/** @codeGenApi */
+## API Report File for "@angular/core_testing"
-export declare const __core_private_testing_placeholder__ = "";
 
-/** @deprecated */
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
-export declare function async(fn: Function): (done: any) => any;
 
-export declare class ComponentFixture<T> {
+```ts
-    changeDetectorRef: ChangeDetectorRef;
+
-    componentInstance: T;
+import { ChangeDetectorRef } from '@angular/core';
-    componentRef: ComponentRef<T>;
+import { Component } from '@angular/core';
-    debugElement: DebugElement;
+import { ComponentRef } from '@angular/core';
-    elementRef: ElementRef;
+import { DebugElement } from '@angular/core';
-    nativeElement: any;
+import { Directive } from '@angular/core';
-    ngZone: NgZone | null;
+import { ElementRef } from '@angular/core';
+import { InjectFlags } from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { NgModule } from '@angular/core';
+import { NgZone } from '@angular/core';
+import { Pipe } from '@angular/core';
+import { PlatformRef } from '@angular/core';
+import { ProviderToken } from '@angular/core';
+import { SchemaMetadata } from '@angular/core';
+import { Type } from '@angular/core';
+
+// @public
+export const __core_private_testing_placeholder__ = "";
+
+// @public @deprecated (undocumented)
+export function async(fn: Function): (done: any) => any;
+
+// @public
+export class ComponentFixture<T> {
     constructor(componentRef: ComponentRef<T>, ngZone: NgZone | null, _autoDetect: boolean);
     autoDetectChanges(autoDetect?: boolean): void;
+    changeDetectorRef: ChangeDetectorRef;
     checkNoChanges(): void;
+    componentInstance: T;
+    // (undocumented)
+    componentRef: ComponentRef<T>;
+    debugElement: DebugElement;
     destroy(): void;
     detectChanges(checkNoChanges?: boolean): void;
+    elementRef: ElementRef;
     isStable(): boolean;
+    nativeElement: any;
+    // (undocumented)
+    ngZone: NgZone | null;
     whenRenderingDone(): Promise<any>;
     whenStable(): Promise<any>;
 }
 
-export declare const ComponentFixtureAutoDetect: InjectionToken<boolean[]>;
+// @public (undocumented)
+export const ComponentFixtureAutoDetect: InjectionToken<boolean[]>;
 
-export declare const ComponentFixtureNoNgZone: InjectionToken<boolean[]>;
+// @public (undocumented)
+export const ComponentFixtureNoNgZone: InjectionToken<boolean[]>;
 
-export declare function discardPeriodicTasks(): void;
+// @public
+export function discardPeriodicTasks(): void;
 
-export declare function fakeAsync(fn: Function): (...args: any[]) => any;
+// @public
+export function fakeAsync(fn: Function): (...args: any[]) => any;
 
-export declare function flush(maxTurns?: number): number;
+// @public
+export function flush(maxTurns?: number): number;
 
-export declare function flushMicrotasks(): void;
+// @public
+export function flushMicrotasks(): void;
 
-export declare const getTestBed: () => TestBed;
+// @public
+export const getTestBed: () => TestBed;
 
-export declare function inject(tokens: any[], fn: Function): () => any;
+// @public
+export function inject(tokens: any[], fn: Function): () => any;
 
-export declare class InjectSetupWrapper {
+// @public (undocumented)
+export class InjectSetupWrapper {
     constructor(_moduleDef: () => TestModuleMetadata);
+    // (undocumented)
     inject(tokens: any[], fn: Function): () => any;
-}
+    }
 
-export declare type MetadataOverride<T> = {
+// @public
+export type MetadataOverride<T> = {
     add?: Partial<T>;
     remove?: Partial<T>;
     set?: Partial<T>;
 };
 
-export declare interface ModuleTeardownOptions {
+// @public
+export interface ModuleTeardownOptions {
     destroyAfterEach: boolean;
     rethrowErrors?: boolean;
 }
 
-export declare function resetFakeAsyncZone(): void;
+// @public
+export function resetFakeAsyncZone(): void;
 
-export declare interface TestBed {
+// @public (undocumented)
-    ngModule: Type<any> | Type<any>[];
+export interface TestBed {
-    platform: PlatformRef;
+    // (undocumented)
     compileComponents(): Promise<any>;
+    // (undocumented)
     configureCompiler(config: {
         providers?: any[];
         useJit?: boolean;
     }): void;
+    // (undocumented)
     configureTestingModule(moduleDef: TestModuleMetadata): void;
+    // (undocumented)
     createComponent<T>(component: Type<T>): ComponentFixture<T>;
+    // (undocumented)
     execute(tokens: any[], fn: Function, context?: any): any;
-    /** @deprecated */ get<T>(token: ProviderToken<T>, notFoundValue?: T, flags?: InjectFlags): any;
+    // @deprecated (undocumented)
-    /** @deprecated */ get(token: any, notFoundValue?: any): any;
+    get<T>(token: ProviderToken<T>, notFoundValue?: T, flags?: InjectFlags): any;
+    // @deprecated (undocumented)
+    get(token: any, notFoundValue?: any): any;
     initTestEnvironment(ngModule: Type<any> | Type<any>[], platform: PlatformRef, options?: TestEnvironmentOptions): void;
+    // (undocumented)
     initTestEnvironment(ngModule: Type<any> | Type<any>[], platform: PlatformRef, aotSummaries?: () => any[]): void;
+    // (undocumented)
     inject<T>(token: ProviderToken<T>, notFoundValue?: T, flags?: InjectFlags): T;
+    // (undocumented)
     inject<T>(token: ProviderToken<T>, notFoundValue: null, flags?: InjectFlags): T | null;
+    // (undocumented)
+    ngModule: Type<any> | Type<any>[];
+    // (undocumented)
     overrideComponent(component: Type<any>, override: MetadataOverride<Component>): void;
+    // (undocumented)
     overrideDirective(directive: Type<any>, override: MetadataOverride<Directive>): void;
+    // (undocumented)
     overrideModule(ngModule: Type<any>, override: MetadataOverride<NgModule>): void;
+    // (undocumented)
     overridePipe(pipe: Type<any>, override: MetadataOverride<Pipe>): void;
     overrideProvider(token: any, provider: {
         useFactory: Function;
         deps: any[];
     }): void;
+    // (undocumented)
     overrideProvider(token: any, provider: {
         useValue: any;
     }): void;
+    // (undocumented)
     overrideProvider(token: any, provider: {
         useFactory?: Function;
         useValue?: any;
         deps?: any[];
     }): void;
+    // (undocumented)
     overrideTemplateUsingTestingModule(component: Type<any>, template: string): void;
+    // (undocumented)
+    platform: PlatformRef;
     resetTestEnvironment(): void;
+    // (undocumented)
     resetTestingModule(): void;
 }
 
-export declare const TestBed: TestBedStatic;
+// @public
+export const TestBed: TestBedStatic;
 
-export declare interface TestBedStatic {
+// @public
+export interface TestBedStatic {
+    // (undocumented)
     new (...args: any[]): TestBed;
     compileComponents(): Promise<any>;
     configureCompiler(config: {
@@ -104,48 +166,70 @@ export declare interface TestBedStatic {
         useJit?: boolean;
     }): TestBedStatic;
     configureTestingModule(moduleDef: TestModuleMetadata): TestBedStatic;
+    // (undocumented)
     createComponent<T>(component: Type<T>): ComponentFixture<T>;
-    /** @deprecated */ get<T>(token: ProviderToken<T>, notFoundValue?: T, flags?: InjectFlags): any;
+    // @deprecated (undocumented)
-    /** @deprecated */ get(token: any, notFoundValue?: any): any;
+    get<T>(token: ProviderToken<T>, notFoundValue?: T, flags?: InjectFlags): any;
+    // @deprecated (undocumented)
+    get(token: any, notFoundValue?: any): any;
+    // (undocumented)
     initTestEnvironment(ngModule: Type<any> | Type<any>[], platform: PlatformRef, options?: {
         teardown?: ModuleTeardownOptions;
     }): TestBed;
+    // (undocumented)
     initTestEnvironment(ngModule: Type<any> | Type<any>[], platform: PlatformRef, aotSummaries?: () => any[]): TestBed;
+    // (undocumented)
     inject<T>(token: ProviderToken<T>, notFoundValue?: T, flags?: InjectFlags): T;
+    // (undocumented)
     inject<T>(token: ProviderToken<T>, notFoundValue: null, flags?: InjectFlags): T | null;
+    // (undocumented)
     overrideComponent(component: Type<any>, override: MetadataOverride<Component>): TestBedStatic;
+    // (undocumented)
     overrideDirective(directive: Type<any>, override: MetadataOverride<Directive>): TestBedStatic;
+    // (undocumented)
     overrideModule(ngModule: Type<any>, override: MetadataOverride<NgModule>): TestBedStatic;
+    // (undocumented)
     overridePipe(pipe: Type<any>, override: MetadataOverride<Pipe>): TestBedStatic;
     overrideProvider(token: any, provider: {
         useFactory: Function;
         deps: any[];
     }): TestBedStatic;
+    // (undocumented)
     overrideProvider(token: any, provider: {
         useValue: any;
     }): TestBedStatic;
+    // (undocumented)
     overrideProvider(token: any, provider: {
         useFactory?: Function;
         useValue?: any;
         deps?: any[];
     }): TestBedStatic;
+    // (undocumented)
     overrideTemplate(component: Type<any>, template: string): TestBedStatic;
     overrideTemplateUsingTestingModule(component: Type<any>, template: string): TestBedStatic;
     resetTestEnvironment(): void;
+    // (undocumented)
     resetTestingModule(): TestBedStatic;
 }
 
-export declare class TestComponentRenderer {
+// @public
+export class TestComponentRenderer {
+    // (undocumented)
     insertRootElement(rootElementId: string): void;
+    // (undocumented)
     removeAllRootElements?(): void;
 }
 
-export declare interface TestEnvironmentOptions {
+// @public (undocumented)
+export interface TestEnvironmentOptions {
+    // (undocumented)
     aotSummaries?: () => any[];
+    // (undocumented)
     teardown?: ModuleTeardownOptions;
 }
 
-export declare type TestModuleMetadata = {
+// @public (undocumented)
+export type TestModuleMetadata = {
     providers?: any[];
     declarations?: any[];
     imports?: any[];
@@ -154,11 +238,21 @@ export declare type TestModuleMetadata = {
     teardown?: ModuleTeardownOptions;
 };
 
-export declare function tick(millis?: number, tickOptions?: {
+// @public
+export function tick(millis?: number, tickOptions?: {
     processNewMacroTasksSynchronously: boolean;
 }): void;
 
-export declare function waitForAsync(fn: Function): (done: any) => any;
+// @public
+export function waitForAsync(fn: Function): (done: any) => any;
 
-export declare function withModule(moduleDef: TestModuleMetadata): InjectSetupWrapper;
+// @public (undocumented)
-export declare function withModule(moduleDef: TestModuleMetadata, fn: Function): () => any;
+export function withModule(moduleDef: TestModuleMetadata): InjectSetupWrapper;
+
+// @public (undocumented)
+export function withModule(moduleDef: TestModuleMetadata, fn: Function): () => any;
+
+
+// (No @packageDocumentation comment for this package)
+
+```

goldens/public-api/elements/elements.d.ts

@@ -1,42 +0,0 @@
-export declare function createCustomElement<P>(component: Type<any>, config: NgElementConfig): NgElementConstructor<P>;
-
-export declare abstract class NgElement extends HTMLElement {
-    protected ngElementEventsSubscription: Subscription | null;
-    protected abstract ngElementStrategy: NgElementStrategy;
-    abstract attributeChangedCallback(attrName: string, oldValue: string | null, newValue: string, namespace?: string): void;
-    abstract connectedCallback(): void;
-    abstract disconnectedCallback(): void;
-}
-
-export declare interface NgElementConfig {
-    injector: Injector;
-    strategyFactory?: NgElementStrategyFactory;
-}
-
-export declare interface NgElementConstructor<P> {
-    readonly observedAttributes: string[];
-    new (injector?: Injector): NgElement & WithProperties<P>;
-}
-
-export declare interface NgElementStrategy {
-    events: Observable<NgElementStrategyEvent>;
-    connect(element: HTMLElement): void;
-    disconnect(): void;
-    getInputValue(propName: string): any;
-    setInputValue(propName: string, value: string): void;
-}
-
-export declare interface NgElementStrategyEvent {
-    name: string;
-    value: any;
-}
-
-export declare interface NgElementStrategyFactory {
-    create(injector: Injector): NgElementStrategy;
-}
-
-export declare const VERSION: Version;
-
-export declare type WithProperties<P> = {
-    [property in keyof P]: P[property];
-};

goldens/public-api/elements/elements.md

@@ -0,0 +1,75 @@
+## API Report File for "@angular/elements"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import { Injector } from '@angular/core';
+import { Observable } from 'rxjs';
+import { Subscription } from 'rxjs';
+import { Type } from '@angular/core';
+import { Version } from '@angular/core';
+
+// @public
+export function createCustomElement<P>(component: Type<any>, config: NgElementConfig): NgElementConstructor<P>;
+
+// @public
+export abstract class NgElement extends HTMLElement {
+    abstract attributeChangedCallback(attrName: string, oldValue: string | null, newValue: string, namespace?: string): void;
+    abstract connectedCallback(): void;
+    abstract disconnectedCallback(): void;
+    protected ngElementEventsSubscription: Subscription | null;
+    protected abstract ngElementStrategy: NgElementStrategy;
+}
+
+// @public
+export interface NgElementConfig {
+    injector: Injector;
+    strategyFactory?: NgElementStrategyFactory;
+}
+
+// @public
+export interface NgElementConstructor<P> {
+    new (injector?: Injector): NgElement & WithProperties<P>;
+    readonly observedAttributes: string[];
+}
+
+// @public
+export interface NgElementStrategy {
+    // (undocumented)
+    connect(element: HTMLElement): void;
+    // (undocumented)
+    disconnect(): void;
+    // (undocumented)
+    events: Observable<NgElementStrategyEvent>;
+    // (undocumented)
+    getInputValue(propName: string): any;
+    // (undocumented)
+    setInputValue(propName: string, value: string): void;
+}
+
+// @public
+export interface NgElementStrategyEvent {
+    // (undocumented)
+    name: string;
+    // (undocumented)
+    value: any;
+}
+
+// @public
+export interface NgElementStrategyFactory {
+    create(injector: Injector): NgElementStrategy;
+}
+
+// @public (undocumented)
+export const VERSION: Version;
+
+// @public
+export type WithProperties<P> = {
+    [property in keyof P]: P[property];
+};
+
+
+// (No @packageDocumentation comment for this package)
+
+```

goldens/public-api/forms/forms.md

@@ -1,39 +1,46 @@
-export declare abstract class AbstractControl {
+## API Report File for "@angular/forms"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import { AfterViewInit } from '@angular/core';
+import { ElementRef } from '@angular/core';
+import { EventEmitter } from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { Injector } from '@angular/core';
+import { ModuleWithProviders } from '@angular/core';
+import { Observable } from 'rxjs';
+import { OnChanges } from '@angular/core';
+import { OnDestroy } from '@angular/core';
+import { OnInit } from '@angular/core';
+import { Renderer2 } from '@angular/core';
+import { SimpleChanges } from '@angular/core';
+import { Version } from '@angular/core';
+
+// @public
+export abstract class AbstractControl {
+    constructor(validators: ValidatorFn | ValidatorFn[] | null, asyncValidators: AsyncValidatorFn | AsyncValidatorFn[] | null);
     get asyncValidator(): AsyncValidatorFn | null;
     set asyncValidator(asyncValidatorFn: AsyncValidatorFn | null);
-    get dirty(): boolean;
-    get disabled(): boolean;
-    get enabled(): boolean;
-    readonly errors: ValidationErrors | null;
-    get invalid(): boolean;
-    get parent(): FormGroup | FormArray | null;
-    get pending(): boolean;
-    readonly pristine: boolean;
-    get root(): AbstractControl;
-    readonly status: string;
-    readonly statusChanges: Observable<any>;
-    readonly touched: boolean;
-    get untouched(): boolean;
-    get updateOn(): FormHooks;
-    get valid(): boolean;
-    get validator(): ValidatorFn | null;
-    set validator(validatorFn: ValidatorFn | null);
-    readonly value: any;
-    readonly valueChanges: Observable<any>;
-    constructor(validators: ValidatorFn | ValidatorFn[] | null, asyncValidators: AsyncValidatorFn | AsyncValidatorFn[] | null);
     clearAsyncValidators(): void;
     clearValidators(): void;
+    get dirty(): boolean;
     disable(opts?: {
         onlySelf?: boolean;
         emitEvent?: boolean;
     }): void;
+    get disabled(): boolean;
     enable(opts?: {
         onlySelf?: boolean;
         emitEvent?: boolean;
     }): void;
+    get enabled(): boolean;
+    readonly errors: ValidationErrors | null;
     get(path: Array<string | number> | string): AbstractControl | null;
     getError(errorCode: string, path?: Array<string | number> | string): any;
     hasError(errorCode: string, path?: Array<string | number> | string): boolean;
+    get invalid(): boolean;
     markAllAsTouched(): void;
     markAsDirty(opts?: {
         onlySelf?: boolean;
@@ -51,32 +58,51 @@ export declare abstract class AbstractControl {
     markAsUntouched(opts?: {
         onlySelf?: boolean;
     }): void;
+    get parent(): FormGroup | FormArray | null;
     abstract patchValue(value: any, options?: Object): void;
+    get pending(): boolean;
+    readonly pristine: boolean;
     abstract reset(value?: any, options?: Object): void;
+    get root(): AbstractControl;
     setAsyncValidators(newValidator: AsyncValidatorFn | AsyncValidatorFn[] | null): void;
     setErrors(errors: ValidationErrors | null, opts?: {
         emitEvent?: boolean;
     }): void;
+    // (undocumented)
     setParent(parent: FormGroup | FormArray): void;
     setValidators(newValidator: ValidatorFn | ValidatorFn[] | null): void;
     abstract setValue(value: any, options?: Object): void;
+    readonly status: string;
+    readonly statusChanges: Observable<any>;
+    readonly touched: boolean;
+    get untouched(): boolean;
+    get updateOn(): FormHooks;
     updateValueAndValidity(opts?: {
         onlySelf?: boolean;
         emitEvent?: boolean;
     }): void;
+    get valid(): boolean;
+    get validator(): ValidatorFn | null;
+    set validator(validatorFn: ValidatorFn | null);
+    readonly value: any;
+    readonly valueChanges: Observable<any>;
 }
 
-export declare abstract class AbstractControlDirective {
+// @public
+export abstract class AbstractControlDirective {
     get asyncValidator(): AsyncValidatorFn | null;
     abstract get control(): AbstractControl | null;
     get dirty(): boolean | null;
     get disabled(): boolean | null;
     get enabled(): boolean | null;
     get errors(): ValidationErrors | null;
+    getError(errorCode: string, path?: Array<string | number> | string): any;
+    hasError(errorCode: string, path?: Array<string | number> | string): boolean;
     get invalid(): boolean | null;
     get path(): string[] | null;
     get pending(): boolean | null;
     get pristine(): boolean | null;
+    reset(value?: any): void;
     get status(): string | null;
     get statusChanges(): Observable<any> | null;
     get touched(): boolean | null;
@@ -85,68 +111,80 @@ export declare abstract class AbstractControlDirective {
     get validator(): ValidatorFn | null;
     get value(): any;
     get valueChanges(): Observable<any> | null;
-    getError(errorCode: string, path?: Array<string | number> | string): any;
-    hasError(errorCode: string, path?: Array<string | number> | string): boolean;
-    reset(value?: any): void;
 }
 
-export declare interface AbstractControlOptions {
+// @public
+export interface AbstractControlOptions {
     asyncValidators?: AsyncValidatorFn | AsyncValidatorFn[] | null;
     updateOn?: 'change' | 'blur' | 'submit';
     validators?: ValidatorFn | ValidatorFn[] | null;
 }
 
-export declare class AbstractFormGroupDirective extends ControlContainer implements OnInit, OnDestroy {
+// @public
+export class AbstractFormGroupDirective extends ControlContainer implements OnInit, OnDestroy {
     get control(): FormGroup;
     get formDirective(): Form | null;
-    get path(): string[];
+    // (undocumented)
     ngOnDestroy(): void;
+    // (undocumented)
     ngOnInit(): void;
+    get path(): string[];
 }
 
-export declare interface AsyncValidator extends Validator {
+// @public
+export interface AsyncValidator extends Validator {
     validate(control: AbstractControl): Promise<ValidationErrors | null> | Observable<ValidationErrors | null>;
 }
 
-export declare interface AsyncValidatorFn {
+// @public
+export interface AsyncValidatorFn {
+    // (undocumented)
     (control: AbstractControl): Promise<ValidationErrors | null> | Observable<ValidationErrors | null>;
 }
 
-export declare class CheckboxControlValueAccessor extends ɵangular_packages_forms_forms_g implements ControlValueAccessor {
+// @public
+export class CheckboxControlValueAccessor extends ɵangular_packages_forms_forms_g implements ControlValueAccessor {
     writeValue(value: any): void;
 }
 
-export declare class CheckboxRequiredValidator extends RequiredValidator {
+// @public
+export class CheckboxRequiredValidator extends RequiredValidator {
     validate(control: AbstractControl): ValidationErrors | null;
 }
 
-export declare const COMPOSITION_BUFFER_MODE: InjectionToken<boolean>;
+// @public
+export const COMPOSITION_BUFFER_MODE: InjectionToken<boolean>;
 
-export declare abstract class ControlContainer extends AbstractControlDirective {
+// @public
+export abstract class ControlContainer extends AbstractControlDirective {
     get formDirective(): Form | null;
     name: string | number | null;
     get path(): string[] | null;
 }
 
-export declare interface ControlValueAccessor {
+// @public
+export interface ControlValueAccessor {
     registerOnChange(fn: any): void;
     registerOnTouched(fn: any): void;
     setDisabledState?(isDisabled: boolean): void;
     writeValue(obj: any): void;
 }
 
-export declare class DefaultValueAccessor extends ɵangular_packages_forms_forms_f implements ControlValueAccessor {
+// @public
+export class DefaultValueAccessor extends ɵangular_packages_forms_forms_f implements ControlValueAccessor {
     constructor(renderer: Renderer2, elementRef: ElementRef, _compositionMode: boolean);
     writeValue(value: any): void;
 }
 
-export declare class EmailValidator implements Validator {
+// @public
+export class EmailValidator implements Validator {
     set email(value: boolean | string);
     registerOnValidatorChange(fn: () => void): void;
     validate(control: AbstractControl): ValidationErrors | null;
 }
 
-export declare interface Form {
+// @public
+export interface Form {
     addControl(dir: NgControl): void;
     addFormGroup(dir: AbstractFormGroupDirective): void;
     getControl(dir: NgControl): FormControl;
@@ -156,18 +194,20 @@ export declare interface Form {
     updateModel(dir: NgControl, value: any): void;
 }
 
-export declare class FormArray extends AbstractControl {
+// @public
-    controls: AbstractControl[];
+export class FormArray extends AbstractControl {
-    get length(): number;
     constructor(controls: AbstractControl[], validatorOrOpts?: ValidatorFn | ValidatorFn[] | AbstractControlOptions | null, asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null);
     at(index: number): AbstractControl;
     clear(options?: {
         emitEvent?: boolean;
     }): void;
+    // (undocumented)
+    controls: AbstractControl[];
     getRawValue(): any[];
     insert(index: number, control: AbstractControl, options?: {
         emitEvent?: boolean;
     }): void;
+    get length(): number;
     patchValue(value: any[], options?: {
         onlySelf?: boolean;
         emitEvent?: boolean;
@@ -191,30 +231,34 @@ export declare class FormArray extends AbstractControl {
     }): void;
 }
 
-export declare class FormArrayName extends ControlContainer implements OnInit, OnDestroy {
+// @public
+export class FormArrayName extends ControlContainer implements OnInit, OnDestroy {
+    constructor(parent: ControlContainer, validators: (Validator | ValidatorFn)[], asyncValidators: (AsyncValidator | AsyncValidatorFn)[]);
     get control(): FormArray;
     get formDirective(): FormGroupDirective | null;
     name: string | number | null;
-    get path(): string[];
-    constructor(parent: ControlContainer, validators: (Validator | ValidatorFn)[], asyncValidators: (AsyncValidator | AsyncValidatorFn)[]);
     ngOnDestroy(): void;
     ngOnInit(): void;
+    get path(): string[];
 }
 
-export declare class FormBuilder {
+// @public
+export class FormBuilder {
     array(controlsConfig: any[], validatorOrOpts?: ValidatorFn | ValidatorFn[] | AbstractControlOptions | null, asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null): FormArray;
     control(formState: any, validatorOrOpts?: ValidatorFn | ValidatorFn[] | AbstractControlOptions | null, asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null): FormControl;
     group(controlsConfig: {
         [key: string]: any;
     }, options?: AbstractControlOptions | null): FormGroup;
-    /** @deprecated */ group(controlsConfig: {
+    // @deprecated
+    group(controlsConfig: {
         [key: string]: any;
     }, options: {
         [key: string]: any;
     }): FormGroup;
 }
 
-export declare class FormControl extends AbstractControl {
+// @public
+export class FormControl extends AbstractControl {
     constructor(formState?: any, validatorOrOpts?: ValidatorFn | ValidatorFn[] | AbstractControlOptions | null, asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null);
     patchValue(value: any, options?: {
         onlySelf?: boolean;
@@ -236,38 +280,46 @@ export declare class FormControl extends AbstractControl {
     }): void;
 }
 
-export declare class FormControlDirective extends NgControl implements OnChanges, OnDestroy {
+// @public
+export class FormControlDirective extends NgControl implements OnChanges, OnDestroy {
+    constructor(validators: (Validator | ValidatorFn)[], asyncValidators: (AsyncValidator | AsyncValidatorFn)[], valueAccessors: ControlValueAccessor[], _ngModelWarningConfig: string | null);
     get control(): FormControl;
     form: FormControl;
     set isDisabled(isDisabled: boolean);
-    /** @deprecated */ model: any;
+    // @deprecated (undocumented)
-    get path(): string[];
+    model: any;
-    /** @deprecated */ update: EventEmitter<any>;
+    // (undocumented)
-    viewModel: any;
-    constructor(validators: (Validator | ValidatorFn)[], asyncValidators: (AsyncValidator | AsyncValidatorFn)[], valueAccessors: ControlValueAccessor[], _ngModelWarningConfig: string | null);
     ngOnChanges(changes: SimpleChanges): void;
+    // (undocumented)
     ngOnDestroy(): void;
+    get path(): string[];
+    // @deprecated (undocumented)
+    update: EventEmitter<any>;
+    viewModel: any;
     viewToModelUpdate(newValue: any): void;
 }
 
-export declare class FormControlName extends NgControl implements OnChanges, OnDestroy {
+// @public
+export class FormControlName extends NgControl implements OnChanges, OnDestroy {
+    constructor(parent: ControlContainer, validators: (Validator | ValidatorFn)[], asyncValidators: (AsyncValidator | AsyncValidatorFn)[], valueAccessors: ControlValueAccessor[], _ngModelWarningConfig: string | null);
     readonly control: FormControl;
     get formDirective(): any;
     set isDisabled(isDisabled: boolean);
-    /** @deprecated */ model: any;
+    // @deprecated (undocumented)
+    model: any;
     name: string | number | null;
-    get path(): string[];
+    // (undocumented)
-    /** @deprecated */ update: EventEmitter<any>;
-    constructor(parent: ControlContainer, validators: (Validator | ValidatorFn)[], asyncValidators: (AsyncValidator | AsyncValidatorFn)[], valueAccessors: ControlValueAccessor[], _ngModelWarningConfig: string | null);
     ngOnChanges(changes: SimpleChanges): void;
+    // (undocumented)
     ngOnDestroy(): void;
+    get path(): string[];
+    // @deprecated (undocumented)
+    update: EventEmitter<any>;
     viewToModelUpdate(newValue: any): void;
 }
 
-export declare class FormGroup extends AbstractControl {
+// @public
-    controls: {
+export class FormGroup extends AbstractControl {
-        [key: string]: AbstractControl;
-    };
     constructor(controls: {
         [key: string]: AbstractControl;
     }, validatorOrOpts?: ValidatorFn | ValidatorFn[] | AbstractControlOptions | null, asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null);
@@ -275,6 +327,10 @@ export declare class FormGroup extends AbstractControl {
         emitEvent?: boolean;
     }): void;
     contains(controlName: string): boolean;
+    // (undocumented)
+    controls: {
+        [key: string]: AbstractControl;
+    };
     getRawValue(): any;
     patchValue(value: {
         [key: string]: any;
@@ -301,120 +357,148 @@ export declare class FormGroup extends AbstractControl {
     }): void;
 }
 
-export declare class FormGroupDirective extends ControlContainer implements Form, OnChanges, OnDestroy {
+// @public
-    get control(): FormGroup;
+export class FormGroupDirective extends ControlContainer implements Form, OnChanges, OnDestroy {
-    directives: FormControlName[];
-    form: FormGroup;
-    get formDirective(): Form;
-    ngSubmit: EventEmitter<any>;
-    get path(): string[];
-    readonly submitted: boolean;
     constructor(validators: (Validator | ValidatorFn)[], asyncValidators: (AsyncValidator | AsyncValidatorFn)[]);
     addControl(dir: FormControlName): FormControl;
     addFormArray(dir: FormArrayName): void;
     addFormGroup(dir: FormGroupName): void;
+    get control(): FormGroup;
+    directives: FormControlName[];
+    form: FormGroup;
+    get formDirective(): Form;
     getControl(dir: FormControlName): FormControl;
     getFormArray(dir: FormArrayName): FormArray;
     getFormGroup(dir: FormGroupName): FormGroup;
+    // (undocumented)
     ngOnChanges(changes: SimpleChanges): void;
+    // (undocumented)
     ngOnDestroy(): void;
+    ngSubmit: EventEmitter<any>;
     onReset(): void;
     onSubmit($event: Event): boolean;
+    get path(): string[];
     removeControl(dir: FormControlName): void;
     removeFormArray(dir: FormArrayName): void;
     removeFormGroup(dir: FormGroupName): void;
     resetForm(value?: any): void;
+    readonly submitted: boolean;
     updateModel(dir: FormControlName, value: any): void;
-}
+    }
 
-export declare class FormGroupName extends AbstractFormGroupDirective implements OnInit, OnDestroy {
+// @public
-    name: string | number | null;
+export class FormGroupName extends AbstractFormGroupDirective implements OnInit, OnDestroy {
     constructor(parent: ControlContainer, validators: (Validator | ValidatorFn)[], asyncValidators: (AsyncValidator | AsyncValidatorFn)[]);
+    name: string | number | null;
 }
 
-export declare class FormsModule {
+// @public
+export class FormsModule {
 }
 
-export declare class MaxLengthValidator implements Validator, OnChanges {
+// @public
+export class MaxLengthValidator implements Validator, OnChanges {
     maxlength: string | number;
+    // (undocumented)
     ngOnChanges(changes: SimpleChanges): void;
     registerOnValidatorChange(fn: () => void): void;
     validate(control: AbstractControl): ValidationErrors | null;
-}
+    }
 
-export declare class MaxValidator extends AbstractValidatorDirective implements OnChanges {
+// @public
+export class MaxValidator extends AbstractValidatorDirective implements OnChanges {
     max: string | number;
     ngOnChanges(changes: SimpleChanges): void;
 }
 
-export declare class MinLengthValidator implements Validator, OnChanges {
+// @public
+export class MinLengthValidator implements Validator, OnChanges {
     minlength: string | number;
+    // (undocumented)
     ngOnChanges(changes: SimpleChanges): void;
     registerOnValidatorChange(fn: () => void): void;
     validate(control: AbstractControl): ValidationErrors | null;
-}
+    }
 
-export declare class MinValidator extends AbstractValidatorDirective implements OnChanges {
+// @public
+export class MinValidator extends AbstractValidatorDirective implements OnChanges {
     min: string | number;
     ngOnChanges(changes: SimpleChanges): void;
 }
 
-export declare const NG_ASYNC_VALIDATORS: InjectionToken<(Function | Validator)[]>;
+// @public
+export const NG_ASYNC_VALIDATORS: InjectionToken<(Function | Validator)[]>;
 
-export declare const NG_VALIDATORS: InjectionToken<(Function | Validator)[]>;
+// @public
+export const NG_VALIDATORS: InjectionToken<(Function | Validator)[]>;
 
-export declare const NG_VALUE_ACCESSOR: InjectionToken<readonly ControlValueAccessor[]>;
+// @public
+export const NG_VALUE_ACCESSOR: InjectionToken<readonly ControlValueAccessor[]>;
 
-export declare abstract class NgControl extends AbstractControlDirective {
+// @public
+export abstract class NgControl extends AbstractControlDirective {
     name: string | number | null;
     valueAccessor: ControlValueAccessor | null;
     abstract viewToModelUpdate(newValue: any): void;
 }
 
-export declare class NgControlStatus extends ɵangular_packages_forms_forms_i {
+// @public
+export class NgControlStatus extends ɵangular_packages_forms_forms_i {
     constructor(cd: NgControl);
 }
 
-export declare class NgControlStatusGroup extends ɵangular_packages_forms_forms_i {
+// @public
+export class NgControlStatusGroup extends ɵangular_packages_forms_forms_i {
     constructor(cd: ControlContainer);
 }
 
-export declare class NgForm extends ControlContainer implements Form, AfterViewInit {
+// @public
+export class NgForm extends ControlContainer implements Form, AfterViewInit {
+    constructor(validators: (Validator | ValidatorFn)[], asyncValidators: (AsyncValidator | AsyncValidatorFn)[]);
+    addControl(dir: NgModel): void;
+    addFormGroup(dir: NgModelGroup): void;
     get control(): FormGroup;
     get controls(): {
         [key: string]: AbstractControl;
     };
     form: FormGroup;
     get formDirective(): Form;
+    getControl(dir: NgModel): FormControl;
+    getFormGroup(dir: NgModelGroup): FormGroup;
+    // (undocumented)
+    ngAfterViewInit(): void;
     ngSubmit: EventEmitter<any>;
+    onReset(): void;
+    onSubmit($event: Event): boolean;
     options: {
         updateOn?: FormHooks;
     };
     get path(): string[];
-    readonly submitted: boolean;
-    constructor(validators: (Validator | ValidatorFn)[], asyncValidators: (AsyncValidator | AsyncValidatorFn)[]);
-    addControl(dir: NgModel): void;
-    addFormGroup(dir: NgModelGroup): void;
-    getControl(dir: NgModel): FormControl;
-    getFormGroup(dir: NgModelGroup): FormGroup;
-    ngAfterViewInit(): void;
-    onReset(): void;
-    onSubmit($event: Event): boolean;
     removeControl(dir: NgModel): void;
     removeFormGroup(dir: NgModelGroup): void;
     resetForm(value?: any): void;
     setValue(value: {
         [key: string]: any;
     }): void;
+    readonly submitted: boolean;
     updateModel(dir: NgControl, value: any): void;
 }
 
-export declare class NgModel extends NgControl implements OnChanges, OnDestroy {
+// @public
+export class NgModel extends NgControl implements OnChanges, OnDestroy {
+    constructor(parent: ControlContainer, validators: (Validator | ValidatorFn)[], asyncValidators: (AsyncValidator | AsyncValidatorFn)[], valueAccessors: ControlValueAccessor[]);
+    // (undocumented)
     readonly control: FormControl;
     get formDirective(): any;
     isDisabled: boolean;
     model: any;
     name: string;
+    // (undocumented)
+    static ngAcceptInputType_isDisabled: boolean | string;
+    // (undocumented)
+    ngOnChanges(changes: SimpleChanges): void;
+    // (undocumented)
+    ngOnDestroy(): void;
     options: {
         name?: string;
         standalone?: boolean;
@@ -423,97 +507,115 @@ export declare class NgModel extends NgControl implements OnChanges, OnDestroy {
     get path(): string[];
     update: EventEmitter<any>;
     viewModel: any;
-    constructor(parent: ControlContainer, validators: (Validator | ValidatorFn)[], asyncValidators: (AsyncValidator | AsyncValidatorFn)[], valueAccessors: ControlValueAccessor[]);
-    ngOnChanges(changes: SimpleChanges): void;
-    ngOnDestroy(): void;
     viewToModelUpdate(newValue: any): void;
-    static ngAcceptInputType_isDisabled: boolean | string;
 }
 
-export declare class NgModelGroup extends AbstractFormGroupDirective implements OnInit, OnDestroy {
+// @public
-    name: string;
+export class NgModelGroup extends AbstractFormGroupDirective implements OnInit, OnDestroy {
     constructor(parent: ControlContainer, validators: (Validator | ValidatorFn)[], asyncValidators: (AsyncValidator | AsyncValidatorFn)[]);
+    name: string;
 }
 
-export declare class NgSelectOption implements OnDestroy {
+// @public
+export class NgSelectOption implements OnDestroy {
+    constructor(_element: ElementRef, _renderer: Renderer2, _select: SelectControlValueAccessor);
     id: string;
+    // (undocumented)
+    ngOnDestroy(): void;
     set ngValue(value: any);
     set value(value: any);
-    constructor(_element: ElementRef, _renderer: Renderer2, _select: SelectControlValueAccessor);
-    ngOnDestroy(): void;
 }
 
-export declare class NumberValueAccessor extends ɵangular_packages_forms_forms_g implements ControlValueAccessor {
+// @public
+export class NumberValueAccessor extends ɵangular_packages_forms_forms_g implements ControlValueAccessor {
     registerOnChange(fn: (_: number | null) => void): void;
     writeValue(value: number): void;
 }
 
-export declare class PatternValidator implements Validator, OnChanges {
+// @public
-    pattern: string | RegExp;
+export class PatternValidator implements Validator, OnChanges {
+    // (undocumented)
     ngOnChanges(changes: SimpleChanges): void;
+    pattern: string | RegExp;
     registerOnValidatorChange(fn: () => void): void;
     validate(control: AbstractControl): ValidationErrors | null;
-}
+    }
 
-export declare class RadioControlValueAccessor extends ɵangular_packages_forms_forms_g implements ControlValueAccessor, OnDestroy, OnInit {
+// @public
-    formControlName: string;
+export class RadioControlValueAccessor extends ɵangular_packages_forms_forms_g implements ControlValueAccessor, OnDestroy, OnInit {
-    name: string;
-    onChange: () => void;
-    value: any;
     constructor(renderer: Renderer2, elementRef: ElementRef, _registry: ɵangular_packages_forms_forms_r, _injector: Injector);
     fireUncheck(value: any): void;
+    formControlName: string;
+    name: string;
+    // (undocumented)
     ngOnDestroy(): void;
+    // (undocumented)
     ngOnInit(): void;
+    onChange: () => void;
     registerOnChange(fn: (_: any) => {}): void;
+    value: any;
     writeValue(value: any): void;
 }
 
-export declare class RangeValueAccessor extends ɵangular_packages_forms_forms_g implements ControlValueAccessor {
+// @public
+export class RangeValueAccessor extends ɵangular_packages_forms_forms_g implements ControlValueAccessor {
     registerOnChange(fn: (_: number | null) => void): void;
     writeValue(value: any): void;
 }
 
-export declare class ReactiveFormsModule {
+// @public
-    static withConfig(opts: { warnOnNgModelWithFormControl: 'never' | 'once' | 'always';
+export class ReactiveFormsModule {
+    static withConfig(opts: {
+        warnOnNgModelWithFormControl: 'never' | 'once' | 'always';
     }): ModuleWithProviders<ReactiveFormsModule>;
 }
 
-export declare class RequiredValidator implements Validator {
+// @public
+export class RequiredValidator implements Validator {
+    registerOnValidatorChange(fn: () => void): void;
     get required(): boolean | string;
     set required(value: boolean | string);
-    registerOnValidatorChange(fn: () => void): void;
     validate(control: AbstractControl): ValidationErrors | null;
 }
 
-export declare class SelectControlValueAccessor extends ɵangular_packages_forms_forms_g implements ControlValueAccessor {
+// @public
+export class SelectControlValueAccessor extends ɵangular_packages_forms_forms_g implements ControlValueAccessor {
     set compareWith(fn: (o1: any, o2: any) => boolean);
-    value: any;
     registerOnChange(fn: (value: any) => any): void;
+    // (undocumented)
+    value: any;
     writeValue(value: any): void;
 }
 
-export declare class SelectMultipleControlValueAccessor extends ɵangular_packages_forms_forms_g implements ControlValueAccessor {
+// @public
+export class SelectMultipleControlValueAccessor extends ɵangular_packages_forms_forms_g implements ControlValueAccessor {
     set compareWith(fn: (o1: any, o2: any) => boolean);
-    value: any;
     registerOnChange(fn: (value: any) => any): void;
+    value: any;
     writeValue(value: any): void;
 }
 
-export declare type ValidationErrors = {
+// @public
+export type ValidationErrors = {
     [key: string]: any;
 };
 
-export declare interface Validator {
+// @public
+export interface Validator {
     registerOnValidatorChange?(fn: () => void): void;
     validate(control: AbstractControl): ValidationErrors | null;
 }
 
-export declare interface ValidatorFn {
+// @public
+export interface ValidatorFn {
+    // (undocumented)
     (control: AbstractControl): ValidationErrors | null;
 }
 
-export declare class Validators {
+// @public
+export class Validators {
     static compose(validators: null): null;
+    // (undocumented)
     static compose(validators: (ValidatorFn | null | undefined)[]): ValidatorFn | null;
     static composeAsync(validators: (AsyncValidatorFn | null)[]): AsyncValidatorFn | null;
     static email(control: AbstractControl): ValidationErrors | null;
@@ -527,4 +629,10 @@ export declare class Validators {
     static requiredTrue(control: AbstractControl): ValidationErrors | null;
 }
 
-export declare const VERSION: Version;
+// @public (undocumented)
+export const VERSION: Version;
+
+
+// (No @packageDocumentation comment for this package)
+
+```

goldens/public-api/localize/index.d.ts

@@ -1,3 +0,0 @@
-export declare function clearTranslations(): void;
-
-export declare function loadTranslations(translations: Record<MessageId, TargetMessage>): void;

goldens/public-api/localize/index.md

@@ -0,0 +1,16 @@
+## API Report File for "@angular/localize"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+// @public
+export function clearTranslations(): void;
+
+// @public
+export function loadTranslations(translations: Record<MessageId, TargetMessage>): void;
+
+
+// (No @packageDocumentation comment for this package)
+
+```

goldens/public-api/localize/init/index.md

@@ -0,0 +1,27 @@
+## API Report File for "@angular/localize_init"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+// @public
+export const $localize: LocalizeFn;
+
+// @public (undocumented)
+export interface LocalizeFn {
+    // (undocumented)
+    (messageParts: TemplateStringsArray, ...expressions: readonly any[]): string;
+    locale?: string;
+    translate?: TranslateFn;
+}
+
+// @public (undocumented)
+export interface TranslateFn {
+    // (undocumented)
+    (messageParts: TemplateStringsArray, expressions: readonly any[]): [TemplateStringsArray, readonly any[]];
+}
+
+
+// (No @packageDocumentation comment for this package)
+
+```

goldens/public-api/platform-browser-dynamic/platform-browser-dynamic.d.ts

@@ -1,9 +0,0 @@
-export declare class JitCompilerFactory implements CompilerFactory {
-    createCompiler(options?: CompilerOptions[]): Compiler;
-}
-
-export declare const platformBrowserDynamic: (extraProviders?: StaticProvider[] | undefined) => PlatformRef;
-
-export declare const RESOURCE_CACHE_PROVIDER: Provider[];
-
-export declare const VERSION: Version;

goldens/public-api/platform-browser-dynamic/platform-browser-dynamic.md

@@ -0,0 +1,33 @@
+## API Report File for "@angular/platform-browser-dynamic"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import { Compiler } from '@angular/core';
+import { CompilerFactory } from '@angular/core';
+import { CompilerOptions } from '@angular/core';
+import { PlatformRef } from '@angular/core';
+import { Provider } from '@angular/core';
+import { StaticProvider } from '@angular/core';
+import { Version } from '@angular/core';
+
+// @public (undocumented)
+export class JitCompilerFactory implements CompilerFactory {
+    // (undocumented)
+    createCompiler(options?: CompilerOptions[]): Compiler;
+    }
+
+// @public (undocumented)
+export const platformBrowserDynamic: (extraProviders?: StaticProvider[] | undefined) => PlatformRef;
+
+// @public (undocumented)
+export const RESOURCE_CACHE_PROVIDER: Provider[];
+
+// @public (undocumented)
+export const VERSION: Version;
+
+
+// (No @packageDocumentation comment for this package)
+
+```

goldens/public-api/platform-browser-dynamic/testing/testing.d.ts

@@ -1,4 +0,0 @@
-export declare class BrowserDynamicTestingModule {
-}
-
-export declare const platformBrowserDynamicTesting: (extraProviders?: StaticProvider[] | undefined) => PlatformRef;

goldens/public-api/platform-browser-dynamic/testing/testing.md

@@ -0,0 +1,20 @@
+## API Report File for "@angular/platform-browser-dynamic_testing"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import { PlatformRef } from '@angular/core';
+import { StaticProvider } from '@angular/core';
+
+// @public
+export class BrowserDynamicTestingModule {
+}
+
+// @public (undocumented)
+export const platformBrowserDynamicTesting: (extraProviders?: StaticProvider[] | undefined) => PlatformRef;
+
+
+// (No @packageDocumentation comment for this package)
+
+```

goldens/public-api/platform-browser/animations/animations.d.ts

@@ -1,12 +0,0 @@
-export declare const ANIMATION_MODULE_TYPE: InjectionToken<"NoopAnimations" | "BrowserAnimations">;
-
-export declare class BrowserAnimationsModule {
-    static withConfig(config: BrowserAnimationsModuleConfig): ModuleWithProviders<BrowserAnimationsModule>;
-}
-
-export declare interface BrowserAnimationsModuleConfig {
-    disableAnimations?: boolean;
-}
-
-export declare class NoopAnimationsModule {
-}

goldens/public-api/platform-browser/animations/animations.md

@@ -0,0 +1,30 @@
+## API Report File for "@angular/platform-browser_animations"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import { InjectionToken } from '@angular/core';
+import { ModuleWithProviders } from '@angular/core';
+
+// @public (undocumented)
+export const ANIMATION_MODULE_TYPE: InjectionToken<"NoopAnimations" | "BrowserAnimations">;
+
+// @public
+export class BrowserAnimationsModule {
+    static withConfig(config: BrowserAnimationsModuleConfig): ModuleWithProviders<BrowserAnimationsModule>;
+}
+
+// @public
+export interface BrowserAnimationsModuleConfig {
+    disableAnimations?: boolean;
+}
+
+// @public
+export class NoopAnimationsModule {
+}
+
+
+// (No @packageDocumentation comment for this package)
+
+```

goldens/public-api/platform-browser/platform-browser.md

@@ -1,22 +1,47 @@
-export declare class BrowserModule {
+## API Report File for "@angular/platform-browser"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import { ComponentRef } from '@angular/core';
+import { DebugElement } from '@angular/core';
+import { DebugNode } from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { ModuleWithProviders } from '@angular/core';
+import { NgZone } from '@angular/core';
+import { PlatformRef } from '@angular/core';
+import { Predicate } from '@angular/core';
+import { Sanitizer } from '@angular/core';
+import { SecurityContext } from '@angular/core';
+import { StaticProvider } from '@angular/core';
+import { Type } from '@angular/core';
+import { Version } from '@angular/core';
+
+// @public
+export class BrowserModule {
     constructor(parentModule: BrowserModule | null);
     static withServerTransition(params: {
         appId: string;
     }): ModuleWithProviders<BrowserModule>;
 }
 
-export declare class BrowserTransferStateModule {
+// @public
+export class BrowserTransferStateModule {
 }
 
-export declare class By {
+// @public
+export class By {
     static all(): Predicate<DebugNode>;
     static css(selector: string): Predicate<DebugElement>;
     static directive(type: Type<any>): Predicate<DebugNode>;
 }
 
-export declare function disableDebugTools(): void;
+// @public
+export function disableDebugTools(): void;
 
-export declare abstract class DomSanitizer implements Sanitizer {
+// @public
+export abstract class DomSanitizer implements Sanitizer {
     abstract bypassSecurityTrustHtml(value: string): SafeHtml;
     abstract bypassSecurityTrustResourceUrl(value: string): SafeResourceUrl;
     abstract bypassSecurityTrustScript(value: string): SafeScript;
@@ -25,22 +50,30 @@ export declare abstract class DomSanitizer implements Sanitizer {
     abstract sanitize(context: SecurityContext, value: SafeValue | string | null): string | null;
 }
 
-export declare function enableDebugTools<T>(ref: ComponentRef<T>): ComponentRef<T>;
+// @public
+export function enableDebugTools<T>(ref: ComponentRef<T>): ComponentRef<T>;
 
-export declare const EVENT_MANAGER_PLUGINS: InjectionToken<ɵangular_packages_platform_browser_platform_browser_g[]>;
+// @public
+export const EVENT_MANAGER_PLUGINS: InjectionToken<ɵangular_packages_platform_browser_platform_browser_g[]>;
 
-export declare class EventManager {
+// @public
+export class EventManager {
     constructor(plugins: ɵangular_packages_platform_browser_platform_browser_g[], _zone: NgZone);
     addEventListener(element: HTMLElement, eventName: string, handler: Function): Function;
-    /** @deprecated */ addGlobalEventListener(target: string, eventName: string, handler: Function): Function;
+    // @deprecated
+    addGlobalEventListener(target: string, eventName: string, handler: Function): Function;
     getZone(): NgZone;
-}
+    }
 
-export declare const HAMMER_GESTURE_CONFIG: InjectionToken<HammerGestureConfig>;
+// @public
+export const HAMMER_GESTURE_CONFIG: InjectionToken<HammerGestureConfig>;
 
-export declare const HAMMER_LOADER: InjectionToken<HammerLoader>;
+// @public
+export const HAMMER_LOADER: InjectionToken<HammerLoader>;
 
-export declare class HammerGestureConfig {
+// @public
+export class HammerGestureConfig {
+    buildHammer(element: HTMLElement): HammerInstance;
     events: string[];
     options?: {
         cssProps?: any;
@@ -55,17 +88,20 @@ export declare class HammerGestureConfig {
     overrides: {
         [key: string]: Object;
     };
-    buildHammer(element: HTMLElement): HammerInstance;
 }
 
-export declare type HammerLoader = () => Promise<void>;
+// @public
+export type HammerLoader = () => Promise<void>;
 
-export declare class HammerModule {
+// @public
+export class HammerModule {
 }
 
-export declare function makeStateKey<T = void>(key: string): StateKey<T>;
+// @public
+export function makeStateKey<T = void>(key: string): StateKey<T>;
 
-export declare class Meta {
+// @public
+export class Meta {
     constructor(_doc: any);
     addTag(tag: MetaDefinition, forceCreation?: boolean): HTMLMetaElement | null;
     addTags(tags: MetaDefinition[], forceCreation?: boolean): HTMLMetaElement[];
@@ -76,7 +112,8 @@ export declare class Meta {
     updateTag(tag: MetaDefinition, selector?: string): HTMLMetaElement | null;
 }
 
-export declare type MetaDefinition = {
+// @public
+export type MetaDefinition = {
     charset?: string;
     content?: string;
     httpEquiv?: string;
@@ -90,37 +127,47 @@ export declare type MetaDefinition = {
     [prop: string]: string;
 };
 
-export declare const platformBrowser: (extraProviders?: StaticProvider[]) => PlatformRef;
+// @public
+export const platformBrowser: (extraProviders?: StaticProvider[]) => PlatformRef;
 
-export declare interface SafeHtml extends SafeValue {
+// @public
+export interface SafeHtml extends SafeValue {
 }
 
-export declare interface SafeResourceUrl extends SafeValue {
+// @public
+export interface SafeResourceUrl extends SafeValue {
 }
 
-export declare interface SafeScript extends SafeValue {
+// @public
+export interface SafeScript extends SafeValue {
 }
 
-export declare interface SafeStyle extends SafeValue {
+// @public
+export interface SafeStyle extends SafeValue {
 }
 
-export declare interface SafeUrl extends SafeValue {
+// @public
+export interface SafeUrl extends SafeValue {
 }
 
-export declare interface SafeValue {
+// @public
+export interface SafeValue {
 }
 
-export declare type StateKey<T> = string & {
+// @public
+export type StateKey<T> = string & {
     __not_a_string: never;
 };
 
-export declare class Title {
+// @public
+export class Title {
     constructor(_doc: any);
     getTitle(): string;
     setTitle(newTitle: string): void;
 }
 
-export declare class TransferState {
+// @public
+export class TransferState {
     get<T>(key: StateKey<T>, defaultValue: T): T;
     hasKey<T>(key: StateKey<T>): boolean;
     onSerialize<T>(key: StateKey<T>, callback: () => T): void;
@@ -129,4 +176,10 @@ export declare class TransferState {
     toJson(): string;
 }
 
-export declare const VERSION: Version;
+// @public (undocumented)
+export const VERSION: Version;
+
+
+// (No @packageDocumentation comment for this package)
+
+```

goldens/public-api/platform-browser/testing/testing.d.ts

@@ -1,4 +0,0 @@
-export declare class BrowserTestingModule {
-}
-
-export declare const platformBrowserTesting: (extraProviders?: StaticProvider[] | undefined) => PlatformRef;

goldens/public-api/platform-browser/testing/testing.md

@@ -0,0 +1,20 @@
+## API Report File for "@angular/platform-browser_testing"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import { PlatformRef } from '@angular/core';
+import { StaticProvider } from '@angular/core';
+
+// @public
+export class BrowserTestingModule {
+}
+
+// @public
+export const platformBrowserTesting: (extraProviders?: StaticProvider[] | undefined) => PlatformRef;
+
+
+// (No @packageDocumentation comment for this package)
+
+```

goldens/public-api/platform-server/init/init.md

@@ -0,0 +1,10 @@
+## API Report File for "@angular/platform-server_init"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+
+// (No @packageDocumentation comment for this package)
+
+```

goldens/public-api/platform-server/platform-server.d.ts

@@ -1,40 +0,0 @@
-export declare const BEFORE_APP_SERIALIZED: InjectionToken<(() => void | Promise<void>)[]>;
-
-export declare const INITIAL_CONFIG: InjectionToken<PlatformConfig>;
-
-export declare interface PlatformConfig {
-    baseUrl?: string;
-    document?: string;
-    url?: string;
-    useAbsoluteUrl?: boolean;
-}
-
-export declare const platformDynamicServer: (extraProviders?: StaticProvider[] | undefined) => PlatformRef;
-
-export declare const platformServer: (extraProviders?: StaticProvider[] | undefined) => PlatformRef;
-
-export declare class PlatformState {
-    constructor(_doc: any);
-    getDocument(): any;
-    renderToString(): string;
-}
-
-export declare function renderModule<T>(module: Type<T>, options: {
-    document?: string;
-    url?: string;
-    extraProviders?: StaticProvider[];
-}): Promise<string>;
-
-export declare function renderModuleFactory<T>(moduleFactory: NgModuleFactory<T>, options: {
-    document?: string;
-    url?: string;
-    extraProviders?: StaticProvider[];
-}): Promise<string>;
-
-export declare class ServerModule {
-}
-
-export declare class ServerTransferStateModule {
-}
-
-export declare const VERSION: Version;

goldens/public-api/platform-server/platform-server.md

@@ -0,0 +1,69 @@
+## API Report File for "@angular/platform-server"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import { InjectionToken } from '@angular/core';
+import { NgModuleFactory } from '@angular/core';
+import { PlatformRef } from '@angular/core';
+import { StaticProvider } from '@angular/core';
+import { Type } from '@angular/core';
+import { Version } from '@angular/core';
+
+// @public
+export const BEFORE_APP_SERIALIZED: InjectionToken<(() => void | Promise<void>)[]>;
+
+// @public
+export const INITIAL_CONFIG: InjectionToken<PlatformConfig>;
+
+// @public
+export interface PlatformConfig {
+    baseUrl?: string;
+    document?: string;
+    url?: string;
+    useAbsoluteUrl?: boolean;
+}
+
+// @public
+export const platformDynamicServer: (extraProviders?: StaticProvider[] | undefined) => PlatformRef;
+
+// @public (undocumented)
+export const platformServer: (extraProviders?: StaticProvider[] | undefined) => PlatformRef;
+
+// @public
+export class PlatformState {
+    constructor(_doc: any);
+    getDocument(): any;
+    renderToString(): string;
+}
+
+// @public
+export function renderModule<T>(module: Type<T>, options: {
+    document?: string;
+    url?: string;
+    extraProviders?: StaticProvider[];
+}): Promise<string>;
+
+// @public
+export function renderModuleFactory<T>(moduleFactory: NgModuleFactory<T>, options: {
+    document?: string;
+    url?: string;
+    extraProviders?: StaticProvider[];
+}): Promise<string>;
+
+// @public
+export class ServerModule {
+}
+
+// @public
+export class ServerTransferStateModule {
+}
+
+// @public (undocumented)
+export const VERSION: Version;
+
+
+// (No @packageDocumentation comment for this package)
+
+```

goldens/public-api/platform-server/testing/testing.d.ts

@@ -1,4 +0,0 @@
-export declare const platformServerTesting: (extraProviders?: StaticProvider[] | undefined) => PlatformRef;
-
-export declare class ServerTestingModule {
-}

goldens/public-api/platform-server/testing/testing.md

@@ -0,0 +1,20 @@
+## API Report File for "@angular/platform-server_testing"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import { PlatformRef } from '@angular/core';
+import { StaticProvider } from '@angular/core';
+
+// @public
+export const platformServerTesting: (extraProviders?: StaticProvider[] | undefined) => PlatformRef;
+
+// @public
+export class ServerTestingModule {
+}
+
+
+// (No @packageDocumentation comment for this package)
+
+```

goldens/public-api/platform-webworker-dynamic/platform-webworker-dynamic.d.ts

@@ -1,5 +0,0 @@
-/** @deprecated */
-export declare const platformWorkerAppDynamic: (extraProviders?: StaticProvider[] | undefined) => PlatformRef;
-
-/** @deprecated */
-export declare const VERSION: Version;

goldens/public-api/platform-webworker/platform-webworker.d.ts

@@ -1,92 +0,0 @@
-/** @deprecated */
-export declare function bootstrapWorkerUi(workerScriptUri: string, customProviders?: StaticProvider[]): Promise<PlatformRef>;
-
-/** @deprecated */
-export declare class ClientMessageBroker {
-    runOnService(args: UiArguments, returnType: Type<any> | SerializerTypes | null): Promise<any> | null;
-}
-
-/** @deprecated */
-export declare class ClientMessageBrokerFactory {
-    createMessageBroker(channel: string, runInZone?: boolean): ClientMessageBroker;
-}
-
-/** @deprecated */
-export declare class FnArg {
-    type: Type<any> | SerializerTypes;
-    value: any;
-    constructor(value: any, type?: Type<any> | SerializerTypes);
-}
-
-/** @deprecated */
-export declare abstract class MessageBus implements MessageBusSource, MessageBusSink {
-    abstract attachToZone(zone: NgZone): void;
-    abstract from(channel: string): EventEmitter<any>;
-    abstract initChannel(channel: string, runInZone?: boolean): void;
-    abstract to(channel: string): EventEmitter<any>;
-}
-
-/** @deprecated */
-export declare interface MessageBusSink {
-    attachToZone(zone: NgZone): void;
-    initChannel(channel: string, runInZone: boolean): void;
-    to(channel: string): EventEmitter<any>;
-}
-
-/** @deprecated */
-export declare interface MessageBusSource {
-    attachToZone(zone: NgZone): void;
-    from(channel: string): EventEmitter<any>;
-    initChannel(channel: string, runInZone: boolean): void;
-}
-
-/** @deprecated */
-export declare const platformWorkerApp: (extraProviders?: StaticProvider[] | undefined) => PlatformRef;
-
-/** @deprecated */
-export declare const platformWorkerUi: (extraProviders?: StaticProvider[] | undefined) => import("@angular/core").PlatformRef;
-
-/** @deprecated */
-export declare interface ReceivedMessage {
-    args: any[];
-    id: string;
-    method: string;
-    type: string;
-}
-
-/** @deprecated */
-export declare const enum SerializerTypes {
-    RENDERER_TYPE_2 = 0,
-    PRIMITIVE = 1,
-    RENDER_STORE_OBJECT = 2
-}
-
-/** @deprecated */
-export declare class ServiceMessageBroker {
-    registerMethod(methodName: string, signature: Array<Type<any> | SerializerTypes> | null, method: (..._: any[]) => Promise<any> | void, returnType?: Type<any> | SerializerTypes): void;
-}
-
-/** @deprecated */
-export declare class ServiceMessageBrokerFactory {
-    createMessageBroker(channel: string, runInZone?: boolean): ServiceMessageBroker;
-}
-
-/** @deprecated */
-export declare class UiArguments {
-    args?: FnArg[] | undefined;
-    method: string;
-    constructor(method: string, args?: FnArg[] | undefined);
-}
-
-/** @deprecated */
-export declare const VERSION: Version;
-
-/** @deprecated */
-export declare const WORKER_APP_LOCATION_PROVIDERS: StaticProvider[];
-
-/** @deprecated */
-export declare const WORKER_UI_LOCATION_PROVIDERS: StaticProvider[];
-
-/** @deprecated */
-export declare class WorkerAppModule {
-}

goldens/public-api/router/router.md

@@ -1,4 +1,36 @@
-export declare class ActivatedRoute {
+## API Report File for "@angular/router"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import { AfterContentInit } from '@angular/core';
+import { ChangeDetectorRef } from '@angular/core';
+import { Compiler } from '@angular/core';
+import { ComponentFactoryResolver } from '@angular/core';
+import { ComponentRef } from '@angular/core';
+import { ElementRef } from '@angular/core';
+import { EventEmitter } from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { Injector } from '@angular/core';
+import { Location } from '@angular/common';
+import { LocationStrategy } from '@angular/common';
+import { ModuleWithProviders } from '@angular/core';
+import { NgModuleFactory } from '@angular/core';
+import { NgModuleFactoryLoader } from '@angular/core';
+import { Observable } from 'rxjs';
+import { OnChanges } from '@angular/core';
+import { OnDestroy } from '@angular/core';
+import { OnInit } from '@angular/core';
+import { QueryList } from '@angular/core';
+import { Renderer2 } from '@angular/core';
+import { SimpleChanges } from '@angular/core';
+import { Type } from '@angular/core';
+import { Version } from '@angular/core';
+import { ViewContainerRef } from '@angular/core';
+
+// @public
+export class ActivatedRoute {
     get children(): ActivatedRoute[];
     component: Type<any> | string | null;
     data: Observable<Data>;
@@ -14,44 +46,56 @@ export declare class ActivatedRoute {
     get root(): ActivatedRoute;
     get routeConfig(): Route | null;
     snapshot: ActivatedRouteSnapshot;
-    url: Observable<UrlSegment[]>;
+    // (undocumented)
     toString(): string;
+    url: Observable<UrlSegment[]>;
 }
 
-export declare class ActivatedRouteSnapshot {
+// @public
+export class ActivatedRouteSnapshot {
     get children(): ActivatedRouteSnapshot[];
     component: Type<any> | string | null;
     data: Data;
     get firstChild(): ActivatedRouteSnapshot | null;
     fragment: string | null;
     outlet: string;
+    // (undocumented)
     get paramMap(): ParamMap;
     params: Params;
     get parent(): ActivatedRouteSnapshot | null;
     get pathFromRoot(): ActivatedRouteSnapshot[];
+    // (undocumented)
     get queryParamMap(): ParamMap;
     queryParams: Params;
     get root(): ActivatedRouteSnapshot;
     readonly routeConfig: Route | null;
+    // (undocumented)
+    toString(): string;
     url: UrlSegment[];
-    toString(): string;
 }
 
-export declare class ActivationEnd {
+// @public
-    snapshot: ActivatedRouteSnapshot;
+export class ActivationEnd {
     constructor(
     snapshot: ActivatedRouteSnapshot);
+    // (undocumented)
+    snapshot: ActivatedRouteSnapshot;
+    // (undocumented)
     toString(): string;
 }
 
-export declare class ActivationStart {
+// @public
-    snapshot: ActivatedRouteSnapshot;
+export class ActivationStart {
     constructor(
     snapshot: ActivatedRouteSnapshot);
+    // (undocumented)
+    snapshot: ActivatedRouteSnapshot;
+    // (undocumented)
     toString(): string;
 }
 
-export declare abstract class BaseRouteReuseStrategy implements RouteReuseStrategy {
+// @public
+export abstract class BaseRouteReuseStrategy implements RouteReuseStrategy {
     retrieve(route: ActivatedRouteSnapshot): DetachedRouteHandle | null;
     shouldAttach(route: ActivatedRouteSnapshot): boolean;
     shouldDetach(route: ActivatedRouteSnapshot): boolean;
@@ -59,64 +103,88 @@ export declare abstract class BaseRouteReuseStrategy implements RouteReuseStrate
     store(route: ActivatedRouteSnapshot, detachedTree: DetachedRouteHandle): void;
 }
 
-export declare interface CanActivate {
+// @public
+export interface CanActivate {
+    // (undocumented)
     canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<boolean | UrlTree> | Promise<boolean | UrlTree> | boolean | UrlTree;
 }
 
-export declare interface CanActivateChild {
+// @public
+export interface CanActivateChild {
+    // (undocumented)
     canActivateChild(childRoute: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<boolean | UrlTree> | Promise<boolean | UrlTree> | boolean | UrlTree;
 }
 
-export declare interface CanDeactivate<T> {
+// @public
+export interface CanDeactivate<T> {
+    // (undocumented)
     canDeactivate(component: T, currentRoute: ActivatedRouteSnapshot, currentState: RouterStateSnapshot, nextState?: RouterStateSnapshot): Observable<boolean | UrlTree> | Promise<boolean | UrlTree> | boolean | UrlTree;
 }
 
-export declare interface CanLoad {
+// @public
+export interface CanLoad {
+    // (undocumented)
     canLoad(route: Route, segments: UrlSegment[]): Observable<boolean | UrlTree> | Promise<boolean | UrlTree> | boolean | UrlTree;
 }
 
-export declare class ChildActivationEnd {
+// @public
-    snapshot: ActivatedRouteSnapshot;
+export class ChildActivationEnd {
     constructor(
     snapshot: ActivatedRouteSnapshot);
+    // (undocumented)
+    snapshot: ActivatedRouteSnapshot;
+    // (undocumented)
     toString(): string;
 }
 
-export declare class ChildActivationStart {
+// @public
-    snapshot: ActivatedRouteSnapshot;
+export class ChildActivationStart {
     constructor(
     snapshot: ActivatedRouteSnapshot);
+    // (undocumented)
+    snapshot: ActivatedRouteSnapshot;
+    // (undocumented)
     toString(): string;
 }
 
-export declare class ChildrenOutletContexts {
+// @public
+export class ChildrenOutletContexts {
+    // (undocumented)
     getContext(childName: string): OutletContext | null;
+    // (undocumented)
     getOrCreateContext(childName: string): OutletContext;
     onChildOutletCreated(childName: string, outlet: RouterOutletContract): void;
     onChildOutletDestroyed(childName: string): void;
     onOutletDeactivated(): Map<string, OutletContext>;
+    // (undocumented)
     onOutletReAttached(contexts: Map<string, OutletContext>): void;
 }
 
-export declare function convertToParamMap(params: Params): ParamMap;
+// @public
+export function convertToParamMap(params: Params): ParamMap;
 
-export declare type Data = {
+// @public
+export type Data = {
     [name: string]: any;
 };
 
-export declare class DefaultUrlSerializer implements UrlSerializer {
+// @public
+export class DefaultUrlSerializer implements UrlSerializer {
     parse(url: string): UrlTree;
     serialize(tree: UrlTree): string;
 }
 
-/** @deprecated */
+// @public @deprecated
-export declare type DeprecatedLoadChildren = string;
+export type DeprecatedLoadChildren = string;
 
-export declare type DetachedRouteHandle = {};
+// @public
+export type DetachedRouteHandle = {};
 
-export declare type Event = RouterEvent | RouteConfigLoadStart | RouteConfigLoadEnd | ChildActivationStart | ChildActivationEnd | ActivationStart | ActivationEnd | Scroll;
+// @public
+export type Event = RouterEvent | RouteConfigLoadStart | RouteConfigLoadEnd | ChildActivationStart | ChildActivationEnd | ActivationStart | ActivationEnd | Scroll;
 
-export declare interface ExtraOptions {
+// @public
+export interface ExtraOptions {
     anchorScrolling?: 'disabled' | 'enabled';
     enableTracing?: boolean;
     errorHandler?: ErrorHandler;
@@ -132,44 +200,58 @@ export declare interface ExtraOptions {
     useHash?: boolean;
 }
 
-export declare class GuardsCheckEnd extends RouterEvent {
+// @public
-    shouldActivate: boolean;
+export class GuardsCheckEnd extends RouterEvent {
-    state: RouterStateSnapshot;
-    urlAfterRedirects: string;
     constructor(
     id: number,
     url: string,
     urlAfterRedirects: string,
     state: RouterStateSnapshot,
     shouldActivate: boolean);
+    // (undocumented)
+    shouldActivate: boolean;
+    // (undocumented)
+    state: RouterStateSnapshot;
+    // (undocumented)
     toString(): string;
+    // (undocumented)
+    urlAfterRedirects: string;
 }
 
-export declare class GuardsCheckStart extends RouterEvent {
+// @public
-    state: RouterStateSnapshot;
+export class GuardsCheckStart extends RouterEvent {
-    urlAfterRedirects: string;
     constructor(
     id: number,
     url: string,
     urlAfterRedirects: string,
     state: RouterStateSnapshot);
+    // (undocumented)
+    state: RouterStateSnapshot;
+    // (undocumented)
     toString(): string;
+    // (undocumented)
+    urlAfterRedirects: string;
 }
 
-export declare type InitialNavigation = 'disabled' | 'enabled' | 'enabledBlocking' | 'enabledNonBlocking';
+// @public
+export type InitialNavigation = 'disabled' | 'enabled' | 'enabledBlocking' | 'enabledNonBlocking';
 
-export declare interface IsActiveMatchOptions {
+// @public
+export interface IsActiveMatchOptions {
     fragment: 'exact' | 'ignored';
     matrixParams: 'exact' | 'subset' | 'ignored';
     paths: 'exact' | 'subset';
     queryParams: 'exact' | 'subset' | 'ignored';
 }
 
-export declare type LoadChildren = LoadChildrenCallback | DeprecatedLoadChildren;
+// @public
+export type LoadChildren = LoadChildrenCallback | DeprecatedLoadChildren;
 
-export declare type LoadChildrenCallback = () => Type<any> | NgModuleFactory<any> | Observable<Type<any>> | Promise<NgModuleFactory<any> | Type<any> | any>;
+// @public
+export type LoadChildrenCallback = () => Type<any> | NgModuleFactory<any> | Observable<Type<any>> | Promise<NgModuleFactory<any> | Type<any> | any>;
 
-export declare interface Navigation {
+// @public
+export interface Navigation {
     extractedUrl: UrlTree;
     extras: NavigationExtras;
     finalUrl?: UrlTree;
@@ -179,7 +261,8 @@ export declare interface Navigation {
     trigger: 'imperative' | 'popstate' | 'hashchange';
 }
 
-export declare interface NavigationBehaviorOptions {
+// @public
+export interface NavigationBehaviorOptions {
     replaceUrl?: boolean;
     skipLocationChange?: boolean;
     state?: {
@@ -187,42 +270,48 @@ export declare interface NavigationBehaviorOptions {
     };
 }
 
-export declare class NavigationCancel extends RouterEvent {
+// @public
-    reason: string;
+export class NavigationCancel extends RouterEvent {
     constructor(
     id: number,
     url: string,
     reason: string);
+    // (undocumented)
+    reason: string;
+    // (undocumented)
     toString(): string;
 }
 
-export declare class NavigationEnd extends RouterEvent {
+// @public
-    urlAfterRedirects: string;
+export class NavigationEnd extends RouterEvent {
     constructor(
     id: number,
     url: string,
     urlAfterRedirects: string);
+    // (undocumented)
     toString(): string;
+    // (undocumented)
+    urlAfterRedirects: string;
 }
 
-export declare class NavigationError extends RouterEvent {
+// @public
-    error: any;
+export class NavigationError extends RouterEvent {
     constructor(
     id: number,
     url: string,
     error: any);
+    // (undocumented)
+    error: any;
+    // (undocumented)
     toString(): string;
 }
 
-export declare interface NavigationExtras extends UrlCreationOptions, NavigationBehaviorOptions {
+// @public
+export interface NavigationExtras extends UrlCreationOptions, NavigationBehaviorOptions {
 }
 
-export declare class NavigationStart extends RouterEvent {
+// @public
-    navigationTrigger?: 'imperative' | 'popstate' | 'hashchange';
+export class NavigationStart extends RouterEvent {
-    restoredState?: {
-        [k: string]: any;
-        navigationId: number;
-    } | null;
     constructor(
     id: number,
     url: string,
@@ -231,77 +320,112 @@ export declare class NavigationStart extends RouterEvent {
         [k: string]: any;
         navigationId: number;
     } | null);
+    navigationTrigger?: 'imperative' | 'popstate' | 'hashchange';
+    restoredState?: {
+        [k: string]: any;
+        navigationId: number;
+    } | null;
+    // (undocumented)
     toString(): string;
 }
 
-export declare class NoPreloading implements PreloadingStrategy {
+// @public
+export class NoPreloading implements PreloadingStrategy {
+    // (undocumented)
     preload(route: Route, fn: () => Observable<any>): Observable<any>;
 }
 
-export declare class OutletContext {
+// @public
+export class OutletContext {
+    // (undocumented)
     attachRef: ComponentRef<any> | null;
+    // (undocumented)
     children: ChildrenOutletContexts;
+    // (undocumented)
     outlet: RouterOutletContract | null;
+    // (undocumented)
     resolver: ComponentFactoryResolver | null;
+    // (undocumented)
     route: ActivatedRoute | null;
 }
 
-export declare interface ParamMap {
+// @public
-    readonly keys: string[];
+export interface ParamMap {
     get(name: string): string | null;
     getAll(name: string): string[];
     has(name: string): boolean;
+    readonly keys: string[];
 }
 
-export declare type Params = {
+// @public
+export type Params = {
     [key: string]: any;
 };
 
-export declare class PreloadAllModules implements PreloadingStrategy {
+// @public
+export class PreloadAllModules implements PreloadingStrategy {
+    // (undocumented)
     preload(route: Route, fn: () => Observable<any>): Observable<any>;
 }
 
-export declare abstract class PreloadingStrategy {
+// @public
+export abstract class PreloadingStrategy {
+    // (undocumented)
     abstract preload(route: Route, fn: () => Observable<any>): Observable<any>;
 }
 
-export declare const PRIMARY_OUTLET = "primary";
+// @public
+export const PRIMARY_OUTLET = "primary";
 
-export declare function provideRoutes(routes: Routes): any;
+// @public
+export function provideRoutes(routes: Routes): any;
 
-export declare type QueryParamsHandling = 'merge' | 'preserve' | '';
+// @public
+export type QueryParamsHandling = 'merge' | 'preserve' | '';
 
-export declare interface Resolve<T> {
+// @public
+export interface Resolve<T> {
+    // (undocumented)
     resolve(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<T> | Promise<T> | T;
 }
 
-export declare type ResolveData = {
+// @public
+export type ResolveData = {
     [name: string]: any;
 };
 
-export declare class ResolveEnd extends RouterEvent {
+// @public
-    state: RouterStateSnapshot;
+export class ResolveEnd extends RouterEvent {
-    urlAfterRedirects: string;
     constructor(
     id: number,
     url: string,
     urlAfterRedirects: string,
     state: RouterStateSnapshot);
+    // (undocumented)
+    state: RouterStateSnapshot;
+    // (undocumented)
     toString(): string;
+    // (undocumented)
+    urlAfterRedirects: string;
 }
 
-export declare class ResolveStart extends RouterEvent {
+// @public
-    state: RouterStateSnapshot;
+export class ResolveStart extends RouterEvent {
-    urlAfterRedirects: string;
     constructor(
     id: number,
     url: string,
     urlAfterRedirects: string,
     state: RouterStateSnapshot);
+    // (undocumented)
+    state: RouterStateSnapshot;
+    // (undocumented)
     toString(): string;
+    // (undocumented)
+    urlAfterRedirects: string;
 }
 
-export declare interface Route {
+// @public
+export interface Route {
     canActivate?: any[];
     canActivateChild?: any[];
     canDeactivate?: any[];
@@ -319,55 +443,68 @@ export declare interface Route {
     runGuardsAndResolvers?: RunGuardsAndResolvers;
 }
 
-export declare class RouteConfigLoadEnd {
+// @public
-    route: Route;
+export class RouteConfigLoadEnd {
     constructor(
     route: Route);
+    // (undocumented)
+    route: Route;
+    // (undocumented)
     toString(): string;
 }
 
-export declare class RouteConfigLoadStart {
+// @public
-    route: Route;
+export class RouteConfigLoadStart {
     constructor(
     route: Route);
+    // (undocumented)
+    route: Route;
+    // (undocumented)
     toString(): string;
 }
 
-export declare class Router {
+// @public
+export class Router {
+    constructor(rootComponentType: Type<any> | null, urlSerializer: UrlSerializer, rootContexts: ChildrenOutletContexts, location: Location, injector: Injector, loader: NgModuleFactoryLoader, compiler: Compiler, config: Routes);
+    // (undocumented)
     config: Routes;
+    createUrlTree(commands: any[], navigationExtras?: UrlCreationOptions): UrlTree;
+    dispose(): void;
     errorHandler: ErrorHandler;
     readonly events: Observable<Event>;
+    getCurrentNavigation(): Navigation | null;
+    initialNavigation(): void;
+    // @deprecated
+    isActive(url: string | UrlTree, exact: boolean): boolean;
+    isActive(url: string | UrlTree, matchOptions: IsActiveMatchOptions): boolean;
     malformedUriErrorHandler: (error: URIError, urlSerializer: UrlSerializer, url: string) => UrlTree;
+    navigate(commands: any[], extras?: NavigationExtras): Promise<boolean>;
+    navigateByUrl(url: string | UrlTree, extras?: NavigationBehaviorOptions): Promise<boolean>;
     navigated: boolean;
+    // (undocumented)
+    ngOnDestroy(): void;
     onSameUrlNavigation: 'reload' | 'ignore';
     paramsInheritanceStrategy: 'emptyOnly' | 'always';
+    parseUrl(url: string): UrlTree;
     relativeLinkResolution: 'legacy' | 'corrected';
+    resetConfig(config: Routes): void;
     routeReuseStrategy: RouteReuseStrategy;
     readonly routerState: RouterState;
+    serializeUrl(url: UrlTree): string;
+    setUpLocationChangeListener(): void;
     get url(): string;
     urlHandlingStrategy: UrlHandlingStrategy;
     urlUpdateStrategy: 'deferred' | 'eager';
-    constructor(rootComponentType: Type<any> | null, urlSerializer: UrlSerializer, rootContexts: ChildrenOutletContexts, location: Location, injector: Injector, loader: NgModuleFactoryLoader, compiler: Compiler, config: Routes);
-    createUrlTree(commands: any[], navigationExtras?: UrlCreationOptions): UrlTree;
-    dispose(): void;
-    getCurrentNavigation(): Navigation | null;
-    initialNavigation(): void;
-    /** @deprecated */ isActive(url: string | UrlTree, exact: boolean): boolean;
-    isActive(url: string | UrlTree, matchOptions: IsActiveMatchOptions): boolean;
-    navigate(commands: any[], extras?: NavigationExtras): Promise<boolean>;
-    navigateByUrl(url: string | UrlTree, extras?: NavigationBehaviorOptions): Promise<boolean>;
-    ngOnDestroy(): void;
-    parseUrl(url: string): UrlTree;
-    resetConfig(config: Routes): void;
-    serializeUrl(url: UrlTree): string;
-    setUpLocationChangeListener(): void;
 }
 
-export declare const ROUTER_CONFIGURATION: InjectionToken<ExtraOptions>;
+// @public
+export const ROUTER_CONFIGURATION: InjectionToken<ExtraOptions>;
 
-export declare const ROUTER_INITIALIZER: InjectionToken<(compRef: ComponentRef<any>) => void>;
+// @public
+export const ROUTER_INITIALIZER: InjectionToken<(compRef: ComponentRef<any>) => void>;
 
-export declare abstract class RouteReuseStrategy {
+// @public
+export abstract class RouteReuseStrategy {
     abstract retrieve(route: ActivatedRouteSnapshot): DetachedRouteHandle | null;
     abstract shouldAttach(route: ActivatedRouteSnapshot): boolean;
     abstract shouldDetach(route: ActivatedRouteSnapshot): boolean;
@@ -375,16 +512,23 @@ export declare abstract class RouteReuseStrategy {
     abstract store(route: ActivatedRouteSnapshot, handle: DetachedRouteHandle | null): void;
 }
 
-export declare class RouterEvent {
+// @public
-    id: number;
+export class RouterEvent {
-    url: string;
     constructor(
     id: number,
     url: string);
+    id: number;
+    url: string;
 }
 
-export declare class RouterLink implements OnChanges {
+// @public
+export class RouterLink implements OnChanges {
+    constructor(router: Router, route: ActivatedRoute, tabIndex: string, renderer: Renderer2, el: ElementRef);
     fragment?: string;
+    // (undocumented)
+    ngOnChanges(changes: SimpleChanges): void;
+    // (undocumented)
+    onClick(): boolean;
     preserveFragment: boolean;
     queryParams?: Params | null;
     queryParamsHandling?: QueryParamsHandling | null;
@@ -395,29 +539,44 @@ export declare class RouterLink implements OnChanges {
     state?: {
         [k: string]: any;
     };
+    // (undocumented)
     get urlTree(): UrlTree;
-    constructor(router: Router, route: ActivatedRoute, tabIndex: string, renderer: Renderer2, el: ElementRef);
-    ngOnChanges(changes: SimpleChanges): void;
-    onClick(): boolean;
 }
 
-export declare class RouterLinkActive implements OnChanges, OnDestroy, AfterContentInit {
+// @public
+export class RouterLinkActive implements OnChanges, OnDestroy, AfterContentInit {
+    constructor(router: Router, element: ElementRef, renderer: Renderer2, cdr: ChangeDetectorRef, link?: RouterLink | undefined, linkWithHref?: RouterLinkWithHref | undefined);
+    // (undocumented)
     readonly isActive: boolean;
+    // (undocumented)
     links: QueryList<RouterLink>;
+    // (undocumented)
     linksWithHrefs: QueryList<RouterLinkWithHref>;
+    // (undocumented)
+    ngAfterContentInit(): void;
+    // (undocumented)
+    ngOnChanges(changes: SimpleChanges): void;
+    // (undocumented)
+    ngOnDestroy(): void;
+    // (undocumented)
     set routerLinkActive(data: string[] | string);
     routerLinkActiveOptions: {
         exact: boolean;
     } | IsActiveMatchOptions;
-    constructor(router: Router, element: ElementRef, renderer: Renderer2, cdr: ChangeDetectorRef, link?: RouterLink | undefined, linkWithHref?: RouterLinkWithHref | undefined);
+    }
-    ngAfterContentInit(): void;
-    ngOnChanges(changes: SimpleChanges): void;
-    ngOnDestroy(): void;
-}
 
-export declare class RouterLinkWithHref implements OnChanges, OnDestroy {
+// @public
+export class RouterLinkWithHref implements OnChanges, OnDestroy {
+    constructor(router: Router, route: ActivatedRoute, locationStrategy: LocationStrategy);
     fragment?: string;
+    // (undocumented)
     href: string;
+    // (undocumented)
+    ngOnChanges(changes: SimpleChanges): any;
+    // (undocumented)
+    ngOnDestroy(): any;
+    // (undocumented)
+    onClick(button: number, ctrlKey: boolean, shiftKey: boolean, altKey: boolean, metaKey: boolean): boolean;
     preserveFragment: boolean;
     queryParams?: Params | null;
     queryParamsHandling?: QueryParamsHandling | null;
@@ -428,93 +587,125 @@ export declare class RouterLinkWithHref implements OnChanges, OnDestroy {
     state?: {
         [k: string]: any;
     };
+    // (undocumented)
     target: string;
+    // (undocumented)
     get urlTree(): UrlTree;
-    constructor(router: Router, route: ActivatedRoute, locationStrategy: LocationStrategy);
-    ngOnChanges(changes: SimpleChanges): any;
-    ngOnDestroy(): any;
-    onClick(button: number, ctrlKey: boolean, shiftKey: boolean, altKey: boolean, metaKey: boolean): boolean;
 }
 
-export declare class RouterModule {
+// @public
+export class RouterModule {
     constructor(guard: any, router: Router);
     static forChild(routes: Routes): ModuleWithProviders<RouterModule>;
     static forRoot(routes: Routes, config?: ExtraOptions): ModuleWithProviders<RouterModule>;
 }
 
-export declare class RouterOutlet implements OnDestroy, OnInit, RouterOutletContract {
+// @public
-    activateEvents: EventEmitter<any>;
+export class RouterOutlet implements OnDestroy, OnInit, RouterOutletContract {
-    get activatedRoute(): ActivatedRoute;
-    get activatedRouteData(): Data;
-    get component(): Object;
-    deactivateEvents: EventEmitter<any>;
-    get isActivated(): boolean;
     constructor(parentContexts: ChildrenOutletContexts, location: ViewContainerRef, resolver: ComponentFactoryResolver, name: string, changeDetector: ChangeDetectorRef);
+    // (undocumented)
+    get activatedRoute(): ActivatedRoute;
+    // (undocumented)
+    get activatedRouteData(): Data;
+    // (undocumented)
+    activateEvents: EventEmitter<any>;
+    // (undocumented)
     activateWith(activatedRoute: ActivatedRoute, resolver: ComponentFactoryResolver | null): void;
     attach(ref: ComponentRef<any>, activatedRoute: ActivatedRoute): void;
+    // (undocumented)
+    get component(): Object;
+    // (undocumented)
     deactivate(): void;
+    // (undocumented)
+    deactivateEvents: EventEmitter<any>;
     detach(): ComponentRef<any>;
+    // (undocumented)
+    get isActivated(): boolean;
+    // (undocumented)
     ngOnDestroy(): void;
+    // (undocumented)
     ngOnInit(): void;
-}
+    }
 
-export declare interface RouterOutletContract {
+// @public
+export interface RouterOutletContract {
     activatedRoute: ActivatedRoute | null;
     activatedRouteData: Data;
-    component: Object | null;
-    isActivated: boolean;
     activateWith(activatedRoute: ActivatedRoute, resolver: ComponentFactoryResolver | null): void;
     attach(ref: ComponentRef<unknown>, activatedRoute: ActivatedRoute): void;
+    component: Object | null;
     deactivate(): void;
     detach(): ComponentRef<unknown>;
+    isActivated: boolean;
 }
 
-export declare class RouterPreloader implements OnDestroy {
+// @public
+export class RouterPreloader implements OnDestroy {
     constructor(router: Router, moduleLoader: NgModuleFactoryLoader, compiler: Compiler, injector: Injector, preloadingStrategy: PreloadingStrategy);
+    // (undocumented)
     ngOnDestroy(): void;
+    // (undocumented)
     preload(): Observable<any>;
+    // (undocumented)
     setUpPreloading(): void;
-}
+    }
 
-export declare class RouterState extends ɵangular_packages_router_router_m<ActivatedRoute> {
+// @public
+export class RouterState extends ɵangular_packages_router_router_m<ActivatedRoute> {
     snapshot: RouterStateSnapshot;
+    // (undocumented)
     toString(): string;
 }
 
-export declare class RouterStateSnapshot extends ɵangular_packages_router_router_m<ActivatedRouteSnapshot> {
+// @public
+export class RouterStateSnapshot extends ɵangular_packages_router_router_m<ActivatedRouteSnapshot> {
+    // (undocumented)
+    toString(): string;
     url: string;
-    toString(): string;
 }
 
-export declare type Routes = Route[];
+// @public
+export const ROUTES: InjectionToken<Route[][]>;
 
-export declare const ROUTES: InjectionToken<Route[][]>;
+// @public
+export type Routes = Route[];
 
-export declare class RoutesRecognized extends RouterEvent {
+// @public
-    state: RouterStateSnapshot;
+export class RoutesRecognized extends RouterEvent {
-    urlAfterRedirects: string;
     constructor(
     id: number,
     url: string,
     urlAfterRedirects: string,
     state: RouterStateSnapshot);
+    // (undocumented)
+    state: RouterStateSnapshot;
+    // (undocumented)
     toString(): string;
+    // (undocumented)
+    urlAfterRedirects: string;
 }
 
-export declare type RunGuardsAndResolvers = 'pathParamsChange' | 'pathParamsOrQueryParamsChange' | 'paramsChange' | 'paramsOrQueryParamsChange' | 'always' | ((from: ActivatedRouteSnapshot, to: ActivatedRouteSnapshot) => boolean);
+// @public
+export type RunGuardsAndResolvers = 'pathParamsChange' | 'pathParamsOrQueryParamsChange' | 'paramsChange' | 'paramsOrQueryParamsChange' | 'always' | ((from: ActivatedRouteSnapshot, to: ActivatedRouteSnapshot) => boolean);
 
-export declare class Scroll {
+// @public
-    readonly anchor: string | null;
+export class Scroll {
-    readonly position: [number, number] | null;
-    readonly routerEvent: NavigationEnd;
     constructor(
     routerEvent: NavigationEnd,
     position: [number, number] | null,
     anchor: string | null);
+    // (undocumented)
+    readonly anchor: string | null;
+    // (undocumented)
+    readonly position: [number, number] | null;
+    // (undocumented)
+    readonly routerEvent: NavigationEnd;
+    // (undocumented)
     toString(): string;
 }
 
-export declare interface UrlCreationOptions {
+// @public
+export interface UrlCreationOptions {
     fragment?: string;
     preserveFragment?: boolean;
     queryParams?: Params | null;
@@ -522,62 +713,80 @@ export declare interface UrlCreationOptions {
     relativeTo?: ActivatedRoute | null;
 }
 
-export declare abstract class UrlHandlingStrategy {
+// @public
+export abstract class UrlHandlingStrategy {
     abstract extract(url: UrlTree): UrlTree;
     abstract merge(newUrlPart: UrlTree, rawUrl: UrlTree): UrlTree;
     abstract shouldProcessUrl(url: UrlTree): boolean;
 }
 
-export declare type UrlMatcher = (segments: UrlSegment[], group: UrlSegmentGroup, route: Route) => UrlMatchResult | null;
+// @public
+export type UrlMatcher = (segments: UrlSegment[], group: UrlSegmentGroup, route: Route) => UrlMatchResult | null;
 
-export declare type UrlMatchResult = {
+// @public
+export type UrlMatchResult = {
     consumed: UrlSegment[];
     posParams?: {
         [name: string]: UrlSegment;
     };
 };
 
-export declare class UrlSegment {
+// @public
-    get parameterMap(): ParamMap;
+export class UrlSegment {
-    parameters: {
-        [name: string]: string;
-    };
-    path: string;
     constructor(
     path: string,
     parameters: {
         [name: string]: string;
     });
+    // (undocumented)
+    get parameterMap(): ParamMap;
+    parameters: {
+        [name: string]: string;
+    };
+    path: string;
+    // (undocumented)
     toString(): string;
 }
 
-export declare class UrlSegmentGroup {
+// @public
-    children: {
+export class UrlSegmentGroup {
-        [key: string]: UrlSegmentGroup;
-    };
-    get numberOfChildren(): number;
-    parent: UrlSegmentGroup | null;
-    segments: UrlSegment[];
     constructor(
     segments: UrlSegment[],
     children: {
         [key: string]: UrlSegmentGroup;
     });
+    children: {
+        [key: string]: UrlSegmentGroup;
+    };
     hasChildren(): boolean;
+    get numberOfChildren(): number;
+    parent: UrlSegmentGroup | null;
+    segments: UrlSegment[];
+    // (undocumented)
     toString(): string;
 }
 
-export declare abstract class UrlSerializer {
+// @public
+export abstract class UrlSerializer {
     abstract parse(url: string): UrlTree;
     abstract serialize(tree: UrlTree): string;
 }
 
-export declare class UrlTree {
+// @public
+export class UrlTree {
     fragment: string | null;
+    // (undocumented)
     get queryParamMap(): ParamMap;
     queryParams: Params;
     root: UrlSegmentGroup;
+    // (undocumented)
     toString(): string;
 }
 
-export declare const VERSION: Version;
+// @public (undocumented)
+export const VERSION: Version;
+
+
+// (No @packageDocumentation comment for this package)
+
+```

goldens/public-api/router/testing/testing.d.ts

@@ -1,17 +0,0 @@
-export declare class RouterTestingModule {
-    static withRoutes(routes: Routes, config?: ExtraOptions): ModuleWithProviders<RouterTestingModule>;
-}
-
-export declare function setupTestingRouter(urlSerializer: UrlSerializer, contexts: ChildrenOutletContexts, location: Location, loader: NgModuleFactoryLoader, compiler: Compiler, injector: Injector, routes: Route[][], opts?: ExtraOptions, urlHandlingStrategy?: UrlHandlingStrategy): Router;
-export declare function setupTestingRouter(urlSerializer: UrlSerializer, contexts: ChildrenOutletContexts, location: Location, loader: NgModuleFactoryLoader, compiler: Compiler, injector: Injector, routes: Route[][], urlHandlingStrategy?: UrlHandlingStrategy): Router;
-
-export declare class SpyNgModuleFactoryLoader implements NgModuleFactoryLoader {
-    set stubbedModules(modules: {
-        [path: string]: any;
-    });
-    get stubbedModules(): {
-        [path: string]: any;
-    };
-    constructor(compiler: Compiler);
-    load(path: string): Promise<NgModuleFactory<any>>;
-}

goldens/public-api/router/testing/testing.md

@@ -0,0 +1,50 @@
+## API Report File for "@angular/router_testing"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import { ChildrenOutletContexts } from '@angular/router';
+import { Compiler } from '@angular/core';
+import { ExtraOptions } from '@angular/router';
+import { Injector } from '@angular/core';
+import { Location } from '@angular/common';
+import { ModuleWithProviders } from '@angular/core';
+import { NgModuleFactory } from '@angular/core';
+import { NgModuleFactoryLoader } from '@angular/core';
+import { Route } from '@angular/router';
+import { Router } from '@angular/router';
+import { Routes } from '@angular/router';
+import { UrlHandlingStrategy } from '@angular/router';
+import { UrlSerializer } from '@angular/router';
+
+// @public
+export class RouterTestingModule {
+    // (undocumented)
+    static withRoutes(routes: Routes, config?: ExtraOptions): ModuleWithProviders<RouterTestingModule>;
+}
+
+// @public
+export function setupTestingRouter(urlSerializer: UrlSerializer, contexts: ChildrenOutletContexts, location: Location, loader: NgModuleFactoryLoader, compiler: Compiler, injector: Injector, routes: Route[][], opts?: ExtraOptions, urlHandlingStrategy?: UrlHandlingStrategy): Router;
+
+// @public @deprecated
+export function setupTestingRouter(urlSerializer: UrlSerializer, contexts: ChildrenOutletContexts, location: Location, loader: NgModuleFactoryLoader, compiler: Compiler, injector: Injector, routes: Route[][], urlHandlingStrategy?: UrlHandlingStrategy): Router;
+
+// @public
+export class SpyNgModuleFactoryLoader implements NgModuleFactoryLoader {
+    constructor(compiler: Compiler);
+    // (undocumented)
+    load(path: string): Promise<NgModuleFactory<any>>;
+    set stubbedModules(modules: {
+        [path: string]: any;
+    });
+    // (undocumented)
+    get stubbedModules(): {
+        [path: string]: any;
+    };
+    }
+
+
+// (No @packageDocumentation comment for this package)
+
+```

goldens/public-api/router/upgrade/upgrade.d.ts

@@ -1,8 +0,0 @@
-export declare const RouterUpgradeInitializer: {
-    provide: InjectionToken<((compRef: ComponentRef<any>) => void)[]>;
-    multi: boolean;
-    useFactory: (ngUpgrade: UpgradeModule) => () => void;
-    deps: (typeof UpgradeModule)[];
-};
-
-export declare function setUpLocationSync(ngUpgrade: UpgradeModule, urlType?: 'path' | 'hash'): void;

goldens/public-api/router/upgrade/upgrade.md

@@ -0,0 +1,25 @@
+## API Report File for "@angular/router_upgrade"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import { ComponentRef } from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { UpgradeModule } from '@angular/upgrade/static';
+
+// @public
+export const RouterUpgradeInitializer: {
+    provide: InjectionToken<((compRef: ComponentRef<any>) => void)[]>;
+    multi: boolean;
+    useFactory: (ngUpgrade: UpgradeModule) => () => void;
+    deps: (typeof UpgradeModule)[];
+};
+
+// @public
+export function setUpLocationSync(ngUpgrade: UpgradeModule, urlType?: 'path' | 'hash'): void;
+
+
+// (No @packageDocumentation comment for this package)
+
+```

goldens/public-api/service-worker/config/config.md

@@ -1,49 +1,89 @@
-export declare interface AssetGroup {
+## API Report File for "@angular/service-worker_config"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+// @public
+export interface AssetGroup {
+    // (undocumented)
     cacheQueryOptions?: Pick<CacheQueryOptions, 'ignoreSearch'>;
+    // (undocumented)
     installMode?: 'prefetch' | 'lazy';
+    // (undocumented)
     name: string;
+    // (undocumented)
     resources: {
         files?: Glob[];
         urls?: Glob[];
     };
+    // (undocumented)
     updateMode?: 'prefetch' | 'lazy';
 }
 
-export declare interface Config {
+// @public
+export interface Config {
+    // (undocumented)
     appData?: {};
+    // (undocumented)
     assetGroups?: AssetGroup[];
+    // (undocumented)
     dataGroups?: DataGroup[];
+    // (undocumented)
     index: string;
+    // (undocumented)
     navigationRequestStrategy?: 'freshness' | 'performance';
+    // (undocumented)
     navigationUrls?: string[];
 }
 
-export declare interface DataGroup {
+// @public
+export interface DataGroup {
+    // (undocumented)
     cacheConfig: {
         maxSize: number;
         maxAge: Duration;
         timeout?: Duration;
         strategy?: 'freshness' | 'performance';
     };
+    // (undocumented)
     cacheQueryOptions?: Pick<CacheQueryOptions, 'ignoreSearch'>;
+    // (undocumented)
     name: string;
+    // (undocumented)
     urls: Glob[];
+    // (undocumented)
     version?: number;
 }
 
-export declare type Duration = string;
+// @public (undocumented)
+export type Duration = string;
 
-export declare interface Filesystem {
+// @public
+export interface Filesystem {
+    // (undocumented)
     hash(file: string): Promise<string>;
+    // (undocumented)
     list(dir: string): Promise<string[]>;
+    // (undocumented)
     read(file: string): Promise<string>;
+    // (undocumented)
     write(file: string, contents: string): Promise<void>;
 }
 
-export declare class Generator {
+// @public
-    readonly fs: Filesystem;
+export class Generator {
     constructor(fs: Filesystem, baseHref: string);
+    // (undocumented)
+    readonly fs: Filesystem;
+    // (undocumented)
     process(config: Config): Promise<Object>;
-}
+    }
 
-export declare type Glob = string;
+// @public (undocumented)
+export type Glob = string;
+
+
+// (No @packageDocumentation comment for this package)
+
+```

goldens/public-api/service-worker/service-worker.md

@@ -1,8 +1,20 @@
-export declare class ServiceWorkerModule {
+## API Report File for "@angular/service-worker"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import { ModuleWithProviders } from '@angular/core';
+import { Observable } from 'rxjs';
+
+// @public (undocumented)
+export class ServiceWorkerModule {
     static register(script: string, opts?: SwRegistrationOptions): ModuleWithProviders<ServiceWorkerModule>;
 }
 
-export declare class SwPush {
+// @public
+export class SwPush {
+    constructor(sw: ɵangular_packages_service_worker_service_worker_a);
     get isEnabled(): boolean;
     readonly messages: Observable<object>;
     readonly notificationClicks: Observable<{
@@ -11,55 +23,74 @@ export declare class SwPush {
             title: string;
         };
     }>;
-    readonly subscription: Observable<PushSubscription | null>;
-    constructor(sw: ɵangular_packages_service_worker_service_worker_a);
     requestSubscription(options: {
         serverPublicKey: string;
     }): Promise<PushSubscription>;
+    readonly subscription: Observable<PushSubscription | null>;
     unsubscribe(): Promise<void>;
 }
 
-export declare abstract class SwRegistrationOptions {
+// @public
+export abstract class SwRegistrationOptions {
     enabled?: boolean;
     registrationStrategy?: string | (() => Observable<unknown>);
     scope?: string;
 }
 
-export declare class SwUpdate {
+// @public
+export class SwUpdate {
+    constructor(sw: ɵangular_packages_service_worker_service_worker_a);
     readonly activated: Observable<UpdateActivatedEvent>;
+    // (undocumented)
+    activateUpdate(): Promise<void>;
     readonly available: Observable<UpdateAvailableEvent>;
+    // (undocumented)
+    checkForUpdate(): Promise<void>;
     get isEnabled(): boolean;
     readonly unrecoverable: Observable<UnrecoverableStateEvent>;
-    constructor(sw: ɵangular_packages_service_worker_service_worker_a);
-    activateUpdate(): Promise<void>;
-    checkForUpdate(): Promise<void>;
 }
 
-export declare interface UnrecoverableStateEvent {
+// @public
+export interface UnrecoverableStateEvent {
+    // (undocumented)
     reason: string;
+    // (undocumented)
     type: 'UNRECOVERABLE_STATE';
 }
 
-export declare interface UpdateActivatedEvent {
+// @public
+export interface UpdateActivatedEvent {
+    // (undocumented)
     current: {
         hash: string;
         appData?: Object;
     };
+    // (undocumented)
     previous?: {
         hash: string;
         appData?: Object;
     };
+    // (undocumented)
     type: 'UPDATE_ACTIVATED';
 }
 
-export declare interface UpdateAvailableEvent {
+// @public
+export interface UpdateAvailableEvent {
+    // (undocumented)
     available: {
         hash: string;
         appData?: Object;
     };
+    // (undocumented)
     current: {
         hash: string;
         appData?: Object;
     };
+    // (undocumented)
     type: 'UPDATE_AVAILABLE';
 }
+
+
+// (No @packageDocumentation comment for this package)
+
+```

goldens/public-api/upgrade/static/static.d.ts

@@ -1,43 +0,0 @@
-export declare function downgradeComponent(info: {
-    component: Type<any>;
-    downgradedModule?: string;
-    propagateDigest?: boolean;
-    /** @deprecated */ inputs?: string[];
-    /** @deprecated */ outputs?: string[];
-    /** @deprecated */ selectors?: string[];
-}): any;
-
-export declare function downgradeInjectable(token: any, downgradedModule?: string): Function;
-
-export declare function downgradeModule<T>(moduleFactoryOrBootstrapFn: NgModuleFactory<T> | ((extraProviders: StaticProvider[]) => Promise<NgModuleRef<T>>)): string;
-
-export declare function getAngularJSGlobal(): any;
-
-/** @deprecated */
-export declare function getAngularLib(): any;
-
-export declare function setAngularJSGlobal(ng: any): void;
-
-/** @deprecated */
-export declare function setAngularLib(ng: any): void;
-
-export declare class UpgradeComponent implements OnInit, OnChanges, DoCheck, OnDestroy {
-    constructor(name: string, elementRef: ElementRef, injector: Injector);
-    ngDoCheck(): void;
-    ngOnChanges(changes: SimpleChanges): void;
-    ngOnDestroy(): void;
-    ngOnInit(): void;
-}
-
-export declare class UpgradeModule {
-    $injector: any;
-    injector: Injector;
-    ngZone: NgZone;
-    constructor(
-    injector: Injector,
-    ngZone: NgZone,
-    platformRef: PlatformRef);
-    bootstrap(element: Element, modules?: string[], config?: any): void;
-}
-
-export declare const VERSION: Version;

goldens/public-api/upgrade/static/static.md

@@ -0,0 +1,81 @@
+## API Report File for "@angular/upgrade_static"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import { DoCheck } from '@angular/core';
+import { ElementRef } from '@angular/core';
+import { Injector } from '@angular/core';
+import { NgModuleFactory } from '@angular/core';
+import { NgModuleRef } from '@angular/core';
+import { NgZone } from '@angular/core';
+import { OnChanges } from '@angular/core';
+import { OnDestroy } from '@angular/core';
+import { OnInit } from '@angular/core';
+import { PlatformRef } from '@angular/core';
+import { SimpleChanges } from '@angular/core';
+import { StaticProvider } from '@angular/core';
+import { Type } from '@angular/core';
+import { Version } from '@angular/core';
+
+// @public
+export function downgradeComponent(info: {
+    component: Type<any>;
+    downgradedModule?: string;
+    propagateDigest?: boolean;
+    inputs?: string[];
+    outputs?: string[];
+    selectors?: string[];
+}): any;
+
+// @public
+export function downgradeInjectable(token: any, downgradedModule?: string): Function;
+
+// @public
+export function downgradeModule<T>(moduleFactoryOrBootstrapFn: NgModuleFactory<T> | ((extraProviders: StaticProvider[]) => Promise<NgModuleRef<T>>)): string;
+
+// @public
+export function getAngularJSGlobal(): any;
+
+// @public @deprecated (undocumented)
+export function getAngularLib(): any;
+
+// @public
+export function setAngularJSGlobal(ng: any): void;
+
+// @public @deprecated (undocumented)
+export function setAngularLib(ng: any): void;
+
+// @public
+export class UpgradeComponent implements OnInit, OnChanges, DoCheck, OnDestroy {
+    constructor(name: string, elementRef: ElementRef, injector: Injector);
+    // (undocumented)
+    ngDoCheck(): void;
+    // (undocumented)
+    ngOnChanges(changes: SimpleChanges): void;
+    // (undocumented)
+    ngOnDestroy(): void;
+    // (undocumented)
+    ngOnInit(): void;
+    }
+
+// @public
+export class UpgradeModule {
+    $injector: any;
+    constructor(
+    injector: Injector,
+    ngZone: NgZone,
+    platformRef: PlatformRef);
+    bootstrap(element: Element, modules?: string[], config?: any): void;
+    injector: Injector;
+    ngZone: NgZone;
+    }
+
+// @public (undocumented)
+export const VERSION: Version;
+
+
+// (No @packageDocumentation comment for this package)
+
+```

goldens/public-api/upgrade/static/testing/testing.d.ts

@@ -1,3 +0,0 @@
-export declare function createAngularJSTestingModule(angularModules: any[]): string;
-
-export declare function createAngularTestingModule(angularJSModules: string[], strictDi?: boolean): Type<any>;

goldens/public-api/upgrade/static/testing/testing.md

@@ -0,0 +1,18 @@
+## API Report File for "@angular/upgrade_static_testing"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import { Type } from '@angular/core';
+
+// @public
+export function createAngularJSTestingModule(angularModules: any[]): string;
+
+// @public
+export function createAngularTestingModule(angularJSModules: string[], strictDi?: boolean): Type<any>;
+
+
+// (No @packageDocumentation comment for this package)
+
+```

goldens/public-api/upgrade/upgrade.md

@@ -1,5 +1,17 @@
-/** @deprecated */
+## API Report File for "@angular/upgrade"
-export declare class UpgradeAdapter {
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import { CompilerOptions } from '@angular/core';
+import { Injector } from '@angular/core';
+import { NgModuleRef } from '@angular/core';
+import { Type } from '@angular/core';
+import { Version } from '@angular/core';
+
+// @public @deprecated
+export class UpgradeAdapter {
     constructor(ng2AppModule: Type<any>, compilerOptions?: CompilerOptions | undefined);
     bootstrap(element: Element, modules?: any[], config?: IAngularBootstrapConfig): UpgradeAdapterRef;
     downgradeNg2Component(component: Type<any>): Function;
@@ -11,14 +23,24 @@ export declare class UpgradeAdapter {
     }): void;
 }
 
-/** @deprecated */
+// @public @deprecated
-export declare class UpgradeAdapterRef {
+export class UpgradeAdapterRef {
-    ng1Injector: IInjectorService;
-    ng1RootScope: IRootScopeService;
-    ng2Injector: Injector;
-    ng2ModuleRef: NgModuleRef<any>;
     dispose(): void;
+    // (undocumented)
+    ng1Injector: IInjectorService;
+    // (undocumented)
+    ng1RootScope: IRootScopeService;
+    // (undocumented)
+    ng2Injector: Injector;
+    // (undocumented)
+    ng2ModuleRef: NgModuleRef<any>;
     ready(fn: (upgradeAdapterRef: UpgradeAdapterRef) => void): void;
 }
 
-export declare const VERSION: Version;
+// @public (undocumented)
+export const VERSION: Version;
+
+
+// (No @packageDocumentation comment for this package)
+
+```

packages/core/BUILD.bazel

@@ -70,6 +70,14 @@ api_golden_test(
     data = [
         "//goldens:public-api",
         "//packages/core",
+        # Additional targets the entry-point indirectly resolves `.d.ts` source files from.
+        # These are transitive to `:core`, but need to be listed explicitly here as only
+        # transitive `JSModule` information is collected (missing the type definitions).
+        "//packages/core/src/compiler",
+        "//packages/core/src/di/interface",
+        "//packages/core/src/interface",
+        "//packages/core/src/reflection",
+        "//packages/core/src/util",
     ],
     entry_point = "angular/packages/core/src/render3/global_utils_api.d.ts",
     golden = "angular/goldens/public-api/core/global_utils.md",