@angular/upgrade 20.0.0-next.0 → 20.0.0-next.2

package/static/index.d.ts

@@ -1,117 +1,13 @@
 /**
- * @license Angular v20.0.0-next.0
- * (c) 2010-2024 Google LLC. https://angular.io/
+ * @license Angular v20.0.0-next.2
+ * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */
 
-
-import { DoCheck } from '@angular/core';
-import { ElementRef } from '@angular/core';
+import { a as IInjectorService, c as IAugmentedJQuery, d as IDirective, e as IController, f as IScope, g as ILinkFn, S as SingleOrListOrMap, h as INgModelController } from '../angular1.d-DnOc0Rx9.js';
+export { V as VERSION, i as getAngularJSGlobal, j as getAngularLib, s as setAngularJSGlobal, k as setAngularLib, l as ɵangular1 } from '../angular1.d-DnOc0Rx9.js';
 import * as i0 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';
-
-declare const $$TESTABILITY = "$$testability";
-
-
-declare const $COMPILE = "$compile";
-
-declare const $CONTROLLER = "$controller";
-
-declare const $DELEGATE = "$delegate";
-
-declare const $EXCEPTION_HANDLER = "$exceptionHandler";
-
-declare const $HTTP_BACKEND = "$httpBackend";
-
-declare const $INJECTOR = "$injector";
-
-declare const $INTERVAL = "$interval";
-
-declare const $PARSE = "$parse";
-
-declare const $PROVIDE = "$provide";
-
-declare const $ROOT_ELEMENT = "$rootElement";
-
-declare const $ROOT_SCOPE = "$rootScope";
-
-declare const $SCOPE = "$scope";
-
-declare const $TEMPLATE_CACHE = "$templateCache";
-
-declare const $TEMPLATE_REQUEST = "$templateRequest";
-
-declare let angular: {
-    bootstrap: (e: Element, modules: (string | IInjectable)[], config?: IAngularBootstrapConfig) => IInjectorService;
-    module: (prefix: string, dependencies?: string[]) => IModule;
-    element: {
-        (e: string | Element | Document | IAugmentedJQuery): IAugmentedJQuery;
-        cleanData: (nodes: Node[] | NodeList) => void;
-    };
-    injector: (modules: Array<string | IInjectable>, strictDi?: boolean) => IInjectorService;
-    version: {
-        major: number;
-    };
-    resumeBootstrap: () => void;
-    getTestability: (e: Element) => ITestabilityService;
-};
-
-declare const bootstrap: typeof angular.bootstrap;
-
-/**
- * Clean the jqLite/jQuery data on the element and all its descendants.
- * Equivalent to how jqLite/jQuery invoke `cleanData()` on an Element when removed:
- *   https://github.com/angular/angular.js/blob/2e72ea13fa98bebf6ed4b5e3c45eaf5f990ed16f/src/jqLite.js#L349-L355
- *   https://github.com/jquery/jquery/blob/6984d1747623dbc5e87fd6c261a5b6b1628c107c/src/manipulation.js#L182
- *
- * NOTE:
- * `cleanData()` will also invoke the AngularJS `$destroy` DOM event on the element:
- *   https://github.com/angular/angular.js/blob/2e72ea13fa98bebf6ed4b5e3c45eaf5f990ed16f/src/Angular.js#L1932-L1945
- *
- * @param node The DOM node whose data needs to be cleaned.
- */
-declare function cleanData(node: Node): void;
-
-declare const COMPILER_KEY = "$$angularCompiler";
-
-declare function controllerKey(name: string): string;
-
-declare class Deferred<R> {
-    promise: Promise<R>;
-    resolve: (value: R | PromiseLike<R>) => void;
-    reject: (error?: any) => void;
-    constructor();
-}
-
-/**
- * Destroy an AngularJS app given the app `$injector`.
- *
- * NOTE: Destroying an app is not officially supported by AngularJS, but try to do our best by
- *       destroying `$rootScope` and clean the jqLite/jQuery data on `$rootElement` and all
- *       descendants.
- *
- * @param $injector The `$injector` of the AngularJS app to destroy.
- */
-declare function destroyApp($injector: IInjectorService): void;
-
-declare function directiveNormalize(name: string): string;
-
-declare type DirectiveRequireProperty = SingleOrListOrMap<string>;
-
-declare type DirectiveTranscludeProperty = boolean | 'element' | {
-    [key: string]: string;
-};
+import { Type, StaticProvider, NgModuleRef, NgModuleFactory, OnInit, OnChanges, DoCheck, OnDestroy, ElementRef, Injector, SimpleChanges, NgZone, PlatformRef } from '@angular/core';
 
 /**
  * @description
@@ -151,10 +47,9 @@ declare type DirectiveTranscludeProperty = boolean | 'element' | {
  *   <br />
  *   (This option is only necessary when using `downgradeModule()` to downgrade more than one
  *   Angular module.)
- * - `propagateDigest?: boolean`: Whether to perform {@link ChangeDetectorRef#detectChanges} on the
- * component on every
- *   [$digest](https://docs.angularjs.org/api/ng/type/$rootScope.Scope#$digest). If set to `false`,
- *   change detection will still be performed when any of the component's inputs changes.
+ * - `propagateDigest?: boolean`: Whether to perform {@link /api/core/ChangeDetectorRef#detectChanges detectChanges} on the
+ * component on every {@link https://docs.angularjs.org/api/ng/type/$rootScope.Scope#$digest $digest}.
+ *   If set to `false`, change detection will still be performed when any of the component's inputs changes.
  *   (Default: true)
  *
  * @returns a factory function that can be used to register the component in an
@@ -162,7 +57,7 @@ declare type DirectiveTranscludeProperty = boolean | 'element' | {
  *
  * @publicApi
  */
-export declare function downgradeComponent(info: {
+declare function downgradeComponent(info: {
     component: Type<any>;
     downgradedModule?: string;
     propagateDigest?: boolean;
@@ -174,9 +69,6 @@ export declare function downgradeComponent(info: {
     selectors?: string[];
 }): any;
 
-declare const DOWNGRADED_MODULE_COUNT_KEY = "$$angularDowngradedModuleCount";
-
-
 /**
  * @description
  *
@@ -237,7 +129,7 @@ declare const DOWNGRADED_MODULE_COUNT_KEY = "$$angularDowngradedModuleCount";
  *
  * @publicApi
  */
-export declare function downgradeInjectable(token: any, downgradedModule?: string): Function;
+declare function downgradeInjectable(token: any, downgradedModule?: string): Function;
 
 /**
  * @description
@@ -344,7 +236,7 @@ export declare function downgradeInjectable(token: any, downgradedModule?: strin
  *   {@link PlatformRef#bootstrapmodulefactory `bootstrapModuleFactory()`} to bootstrap the
  *   downgraded modules, each one is considered a "root" module. As a consequence, a new instance
  *   will be created for every injectable provided in `"root"` (via
- *   {@link Injectable#providedIn `providedIn`}).
+ *   {@link /api/core/Injectable#providedIn providedIn}
  *   If this is not your intention, you can have a shared module (that will act as act as the "root"
  *   module) and create all downgraded modules using that module's injector:
  *
@@ -352,8 +244,7 @@ export declare function downgradeInjectable(token: any, downgradedModule?: strin
  *
  * @publicApi
  */
-export declare function downgradeModule<T>(moduleOrBootstrapFn: Type<T> | ((extraProviders: StaticProvider[]) => Promise<NgModuleRef<T>>)): string;
-
+declare function downgradeModule<T>(moduleOrBootstrapFn: Type<T> | ((extraProviders: StaticProvider[]) => Promise<NgModuleRef<T>>)): string;
 /**
  * @description
  *
@@ -459,7 +350,7 @@ export declare function downgradeModule<T>(moduleOrBootstrapFn: Type<T> | ((extr
  *   {@link PlatformRef#bootstrapmodulefactory `bootstrapModuleFactory()`} to bootstrap the
  *   downgraded modules, each one is considered a "root" module. As a consequence, a new instance
  *   will be created for every injectable provided in `"root"` (via
- *   {@link Injectable#providedIn `providedIn`}).
+ *   {@link /api/core/Injectable#providedIn providedIn}
  *   If this is not your intention, you can have a shared module (that will act as act as the "root"
  *   module) and create all downgraded modules using that module's injector:
  *
@@ -470,382 +361,7 @@ export declare function downgradeModule<T>(moduleOrBootstrapFn: Type<T> | ((extr
  * @deprecated Passing `NgModuleFactory` as the `downgradeModule` function argument is deprecated,
  *     please pass an NgModule class reference instead.
  */
-export declare function downgradeModule<T>(moduleOrBootstrapFn: NgModuleFactory<T>): string;
-
-declare const element: typeof angular.element;
-
-/**
- * Returns the current AngularJS global.
- *
- * @publicApi
- */
-export declare function getAngularJSGlobal(): any;
-
-/**
- * @deprecated Use `getAngularJSGlobal` instead.
- *
- * @publicApi
- */
-export declare function getAngularLib(): any;
-
-declare function getDowngradedModuleCount($injector: IInjectorService): number;
-
-declare const getTestability: typeof angular.getTestability;
-
-declare function getTypeName(type: Type<any>): string;
-
-declare function getUpgradeAppType($injector: IInjectorService): UpgradeAppType;
-
-declare const GROUP_PROJECTABLE_NODES_KEY = "$$angularGroupProjectableNodes";
-
-/**
- * Glue the AngularJS `NgModelController` (if it exists) to the component
- * (if it implements the needed subset of the `ControlValueAccessor` interface).
- */
-declare function hookupNgModel(ngModel: INgModelController, component: any): void;
-
-declare interface IAngularBootstrapConfig {
-    strictDi?: boolean;
-}
-
-declare interface IAnnotatedFunction extends Function {
-    $inject?: Function extends {
-        $inject?: string[];
-    } ? Ng1Token[] : ReadonlyArray<Ng1Token>;
-}
-
-declare interface IAttributes {
-    $observe(attr: string, fn: (v: string) => void): void;
-    [key: string]: any;
-}
-
-declare type IAugmentedJQuery = Node[] & {
-    on?: (name: string, fn: () => void) => void;
-    data?: (name: string, value?: any) => any;
-    text?: () => string;
-    inheritedData?: (name: string, value?: any) => any;
-    children?: () => IAugmentedJQuery;
-    contents?: () => IAugmentedJQuery;
-    parent?: () => IAugmentedJQuery;
-    empty?: () => void;
-    append?: (content: IAugmentedJQuery | string) => IAugmentedJQuery;
-    controller?: (name: string) => any;
-    isolateScope?: () => IScope;
-    injector?: () => IInjectorService;
-    triggerHandler?: (eventTypeOrObject: string | Event, extraParameters?: any[]) => IAugmentedJQuery;
-    remove?: () => void;
-    removeData?: () => void;
-};
-
-declare interface IBindingDestination {
-    [key: string]: any;
-    $onChanges?: (changes: SimpleChanges) => void;
-}
-
-declare interface ICacheObject {
-    put<T>(key: string, value?: T): T;
-    get(key: string): any;
-}
-
-declare interface ICloneAttachFunction {
-    (clonedElement: IAugmentedJQuery, scope: IScope): any;
-}
-
-declare interface ICompiledExpression {
-    (context: any, locals: any): any;
-    assign?: (context: any, value: any) => any;
-}
-
-declare interface ICompileService {
-    (element: Element | NodeList | Node[] | string, transclude?: Function): ILinkFn;
-}
-
-declare interface IComponent {
-    bindings?: {
-        [key: string]: string;
-    };
-    controller?: string | IInjectable;
-    controllerAs?: string;
-    require?: DirectiveRequireProperty;
-    template?: string | Function;
-    templateUrl?: string | Function;
-    transclude?: DirectiveTranscludeProperty;
-}
-
-declare type IController = string | IInjectable;
-
-declare interface IControllerInstance extends IBindingDestination {
-    $doCheck?: () => void;
-    $onDestroy?: () => void;
-    $onInit?: () => void;
-    $postLink?: () => void;
-}
-
-declare interface IControllerService {
-    (controllerConstructor: IController, locals?: any, later?: any, ident?: any): any;
-    (controllerName: string, locals?: any): any;
-}
-
-declare interface IDirective {
-    compile?: IDirectiveCompileFn;
-    controller?: IController;
-    controllerAs?: string;
-    bindToController?: boolean | {
-        [key: string]: string;
-    };
-    link?: IDirectiveLinkFn | IDirectivePrePost;
-    name?: string;
-    priority?: number;
-    replace?: boolean;
-    require?: DirectiveRequireProperty;
-    restrict?: string;
-    scope?: boolean | {
-        [key: string]: string;
-    };
-    template?: string | Function;
-    templateUrl?: string | Function;
-    templateNamespace?: string;
-    terminal?: boolean;
-    transclude?: DirectiveTranscludeProperty;
-}
-
-declare interface IDirectiveCompileFn {
-    (templateElement: IAugmentedJQuery, templateAttributes: IAttributes, transclude: ITranscludeFunction): IDirectivePrePost;
-}
-
-declare interface IDirectiveLinkFn {
-    (scope: IScope, instanceElement: IAugmentedJQuery, instanceAttributes: IAttributes, controller: any, transclude: ITranscludeFunction): void;
-}
-
-declare interface IDirectivePrePost {
-    pre?: IDirectiveLinkFn;
-    post?: IDirectiveLinkFn;
-}
-
-declare interface IHttpBackendService {
-    (method: string, url: string, post?: any, callback?: Function, headers?: any, timeout?: number, withCredentials?: boolean): void;
-}
-
-declare type IInjectable = (Ng1Token | Function)[] | IAnnotatedFunction;
-
-declare interface IInjectorService {
-    get(key: string): any;
-    has(key: string): boolean;
-}
-
-declare interface IIntervalService {
-    (func: Function, delay: number, count?: number, invokeApply?: boolean, ...args: any[]): Promise<any>;
-    cancel(promise: Promise<any>): boolean;
-}
-
-declare interface ILinkFn {
-    (scope: IScope, cloneAttachFn?: ICloneAttachFunction, options?: ILinkFnOptions): IAugmentedJQuery;
-    $$slots?: {
-        [slotName: string]: ILinkFn;
-    };
-}
-
-declare interface ILinkFnOptions {
-    parentBoundTranscludeFn?: Function;
-    transcludeControllers?: {
-        [key: string]: any;
-    };
-    futureParentElement?: Node;
-}
-
-declare interface IModule {
-    name: string;
-    requires: (string | IInjectable)[];
-    config(fn: IInjectable): IModule;
-    directive(selector: string, factory: IInjectable): IModule;
-    component(selector: string, component: IComponent): IModule;
-    controller(name: string, type: IInjectable): IModule;
-    factory(key: Ng1Token, factoryFn: IInjectable): IModule;
-    value(key: Ng1Token, value: any): IModule;
-    constant(token: Ng1Token, value: any): IModule;
-    run(a: IInjectable): IModule;
-}
-
-declare interface INgModelController {
-    $render(): void;
-    $isEmpty(value: any): boolean;
-    $setValidity(validationErrorKey: string, isValid: boolean): void;
-    $setPristine(): void;
-    $setDirty(): void;
-    $setUntouched(): void;
-    $setTouched(): void;
-    $rollbackViewValue(): void;
-    $validate(): void;
-    $commitViewValue(): void;
-    $setViewValue(value: any, trigger: string): void;
-    $viewValue: any;
-    $modelValue: any;
-    $parsers: Function[];
-    $formatters: Function[];
-    $validators: {
-        [key: string]: Function;
-    };
-    $asyncValidators: {
-        [key: string]: Function;
-    };
-    $viewChangeListeners: Function[];
-    $error: Object;
-    $pending: Object;
-    $untouched: boolean;
-    $touched: boolean;
-    $pristine: boolean;
-    $dirty: boolean;
-    $valid: boolean;
-    $invalid: boolean;
-    $name: string;
-}
-
-declare const injector: typeof angular.injector;
-
-declare const INJECTOR_KEY = "$$angularInjector";
-
-declare interface IParseService {
-    (expression: string): ICompiledExpression;
-}
-
-declare interface IProvider {
-    $get: IInjectable;
-}
-
-declare interface IProvideService {
-    provider(token: Ng1Token, provider: IProvider): IProvider;
-    factory(token: Ng1Token, factory: IInjectable): IProvider;
-    service(token: Ng1Token, type: IInjectable): IProvider;
-    value(token: Ng1Token, value: any): IProvider;
-    constant(token: Ng1Token, value: any): void;
-    decorator(token: Ng1Token, factory: IInjectable): void;
-}
-
-declare interface IRootScopeService {
-    $new(isolate?: boolean): IScope;
-    $id: string;
-    $parent: IScope;
-    $root: IScope;
-    $watch(exp: Ng1Expression, fn?: (a1?: any, a2?: any) => void): Function;
-    $on(event: string, fn?: (event?: any, ...args: any[]) => void): Function;
-    $destroy(): any;
-    $apply(exp?: Ng1Expression): any;
-    $digest(): any;
-    $evalAsync(exp: Ng1Expression, locals?: any): void;
-    $on(event: string, fn?: (event?: any, ...args: any[]) => void): Function;
-    $$childTail: IScope;
-    $$childHead: IScope;
-    $$nextSibling: IScope;
-    $$phase: any;
-    [key: string]: any;
-}
-
-declare interface IScope extends IRootScopeService {
-}
-
-declare function isFunction(value: any): value is Function;
-
-declare function isNgModuleType(value: any): value is Type<unknown>;
-
-declare interface ITemplateCacheService extends ICacheObject {
-}
-
-declare interface ITestabilityService {
-    findBindings(element: Element, expression: string, opt_exactMatch?: boolean): Element[];
-    findModels(element: Element, expression: string, opt_exactMatch?: boolean): Element[];
-    getLocation(): string;
-    setLocation(url: string): void;
-    whenStable(callback: Function): void;
-}
-
-declare interface ITranscludeFunction {
-    (scope: IScope, cloneAttachFn: ICloneAttachFunction): IAugmentedJQuery;
-    (cloneAttachFn?: ICloneAttachFunction): IAugmentedJQuery;
-}
-
-declare const LAZY_MODULE_REF = "$$angularLazyModuleRef";
-
-declare interface LazyModuleRef {
-    injector?: Injector;
-    promise?: Promise<Injector>;
-}
-
-declare const module_: typeof angular.module;
-
-declare type Ng1Expression = string | Function;
-
-
-declare type Ng1Token = string;
-
-declare const NG_ZONE_KEY = "$$angularNgZone";
-
-declare function onError(e: any): void;
-
-declare const REQUIRE_INJECTOR: string;
-
-declare const REQUIRE_NG_MODEL = "?ngModel";
-
-declare const resumeBootstrap: typeof angular.resumeBootstrap;
-
-/**
- * Resets the AngularJS global.
- *
- * Used when AngularJS is loaded lazily, and not available on `window`.
- *
- * @publicApi
- */
-export declare function setAngularJSGlobal(ng: any): void;
-
-/**
- * @deprecated Use `setAngularJSGlobal` instead.
- *
- * @publicApi
- */
-export declare function setAngularLib(ng: any): void;
-
-declare type SingleOrListOrMap<T> = T | T[] | {
-    [key: string]: T;
-};
-
-/**
- * Test two values for strict equality, accounting for the fact that `NaN !== NaN`.
- */
-declare function strictEquals(val1: any, val2: any): boolean;
-
-
-/**
- * @fileoverview
- * While Angular only uses Trusted Types internally for the time being,
- * references to Trusted Types could leak into our public API, which would force
- * anyone compiling against @angular/upgrade to provide the @types/trusted-types
- * package in their compilation unit.
- *
- * Until https://github.com/microsoft/TypeScript/issues/30024 is resolved, we
- * will keep Angular's public API surface free of references to Trusted Types.
- * For internal and semi-private APIs that need to reference Trusted Types, the
- * minimal type definitions for the Trusted Types API provided by this module
- * should be used instead. They are marked as "declare" to prevent them from
- * being renamed by compiler optimization.
- *
- * Adapted from
- * https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/trusted-types/index.d.ts
- * but restricted to the API surface used within Angular, mimicking the approach
- * in packages/core/src/util/security/trusted_type_defs.ts.
- */
-declare type TrustedHTML = string & {
-    __brand__: 'TrustedHTML';
-};
-
-declare const UPGRADE_APP_TYPE_KEY = "$$angularUpgradeAppType";
-
-declare const UPGRADE_MODULE_NAME = "$$UpgradeModule";
-
-declare const enum UpgradeAppType {
-    None = 0,
-    Dynamic = 1,
-    Static = 2,
-    Lite = 3
-}
+declare function downgradeModule<T>(moduleOrBootstrapFn: NgModuleFactory<T>): string;
 
 /**
  * @description
@@ -887,7 +403,7 @@ declare const enum UpgradeAppType {
  * @publicApi
  * @extensible
  */
-export declare class UpgradeComponent implements OnInit, OnChanges, DoCheck, OnDestroy {
+declare class UpgradeComponent implements OnInit, OnChanges, DoCheck, OnDestroy {
     private helper;
     private $element;
     private $componentScope;
@@ -925,28 +441,6 @@ export declare class UpgradeComponent implements OnInit, OnChanges, DoCheck, OnD
     static ɵdir: i0.ɵɵDirectiveDeclaration<UpgradeComponent, never, never, {}, {}, never, never, true, never>;
 }
 
-declare class UpgradeHelper {
-    private name;
-    readonly $injector: IInjectorService;
-    readonly element: Element;
-    readonly $element: IAugmentedJQuery;
-    readonly directive: IDirective;
-    private readonly $compile;
-    private readonly $controller;
-    constructor(injector: Injector, name: string, elementRef: ElementRef, directive?: IDirective);
-    static getDirective($injector: IInjectorService, name: string): IDirective;
-    static getTemplate($injector: IInjectorService, directive: IDirective, fetchRemoteTemplate?: boolean, $element?: IAugmentedJQuery): string | TrustedHTML | Promise<string | TrustedHTML>;
-    buildController(controllerType: IController, $scope: IScope): any;
-    compileTemplate(template?: string | TrustedHTML): ILinkFn;
-    onDestroy($scope: IScope, controllerInstance?: any): void;
-    prepareTransclusion(): ILinkFn | undefined;
-    resolveAndBindRequiredControllers(controllerInstance: IControllerInstance | null): SingleOrListOrMap<IControllerInstance> | null;
-    private compileHtml;
-    private extractChildNodes;
-    private getDirectiveRequire;
-    private resolveRequire;
-}
-
 /**
  * @description
  *
@@ -970,7 +464,7 @@ declare class UpgradeHelper {
  *    {@link UpgradeModule#upgrading-an-angular-1-service Upgrading an AngularJS service} below.
  * 4. Creation of an AngularJS service that wraps and exposes an Angular injectable
  *    so that it can be injected into an AngularJS context. See `downgradeInjectable`.
- * 3. Bootstrapping of a hybrid Angular application which contains both of the frameworks
+ * 5. Bootstrapping of a hybrid Angular application which contains both of the frameworks
  *    coexisting in a single application.
  *
  * @usageNotes
@@ -1036,7 +530,7 @@ declare class UpgradeHelper {
  *
  * ### Examples
  *
- * Import the `UpgradeModule` into your top level {@link NgModule Angular `NgModule`}.
+ * Import the `UpgradeModule` into your top level Angular {@link NgModule NgModule}.
  *
  * {@example upgrade/static/ts/full/module.ts region='ng2-module'}
  *
@@ -1050,7 +544,6 @@ declare class UpgradeHelper {
  *
  * {@example upgrade/static/ts/full/module.ts region='bootstrap-ng2'}
  *
- * {@a upgrading-an-angular-1-service}
  * ### Upgrading an AngularJS service
  *
  * There is no specific API for upgrading an AngularJS service. Instead you should just follow the
@@ -1072,7 +565,7 @@ declare class UpgradeHelper {
  *
  * @publicApi
  */
-export declare class UpgradeModule {
+declare class UpgradeModule {
     /** The bootstrap zone for the upgrade application */
     ngZone: NgZone;
     /**
@@ -1112,125 +605,202 @@ export declare class UpgradeModule {
     static ɵinj: i0.ɵɵInjectorDeclaration<UpgradeModule>;
 }
 
-declare function validateInjectionKey($injector: IInjectorService, downgradedModule: string, injectionKey: string, attemptedAction: string): void;
+declare const $COMPILE = "$compile";
+declare const $CONTROLLER = "$controller";
+declare const $DELEGATE = "$delegate";
+declare const $EXCEPTION_HANDLER = "$exceptionHandler";
+declare const $HTTP_BACKEND = "$httpBackend";
+declare const $INJECTOR = "$injector";
+declare const $INTERVAL = "$interval";
+declare const $PARSE = "$parse";
+declare const $PROVIDE = "$provide";
+declare const $ROOT_ELEMENT = "$rootElement";
+declare const $ROOT_SCOPE = "$rootScope";
+declare const $SCOPE = "$scope";
+declare const $TEMPLATE_CACHE = "$templateCache";
+declare const $TEMPLATE_REQUEST = "$templateRequest";
+declare const $$TESTABILITY = "$$testability";
+declare const COMPILER_KEY = "$$angularCompiler";
+declare const DOWNGRADED_MODULE_COUNT_KEY = "$$angularDowngradedModuleCount";
+declare const GROUP_PROJECTABLE_NODES_KEY = "$$angularGroupProjectableNodes";
+declare const INJECTOR_KEY = "$$angularInjector";
+declare const LAZY_MODULE_REF = "$$angularLazyModuleRef";
+declare const NG_ZONE_KEY = "$$angularNgZone";
+declare const UPGRADE_APP_TYPE_KEY = "$$angularUpgradeAppType";
+declare const REQUIRE_INJECTOR: string;
+declare const REQUIRE_NG_MODEL = "?ngModel";
+declare const UPGRADE_MODULE_NAME = "$$UpgradeModule";
+
+declare const constants_d_$$TESTABILITY: typeof $$TESTABILITY;
+declare const constants_d_$COMPILE: typeof $COMPILE;
+declare const constants_d_$CONTROLLER: typeof $CONTROLLER;
+declare const constants_d_$DELEGATE: typeof $DELEGATE;
+declare const constants_d_$EXCEPTION_HANDLER: typeof $EXCEPTION_HANDLER;
+declare const constants_d_$HTTP_BACKEND: typeof $HTTP_BACKEND;
+declare const constants_d_$INJECTOR: typeof $INJECTOR;
+declare const constants_d_$INTERVAL: typeof $INTERVAL;
+declare const constants_d_$PARSE: typeof $PARSE;
+declare const constants_d_$PROVIDE: typeof $PROVIDE;
+declare const constants_d_$ROOT_ELEMENT: typeof $ROOT_ELEMENT;
+declare const constants_d_$ROOT_SCOPE: typeof $ROOT_SCOPE;
+declare const constants_d_$SCOPE: typeof $SCOPE;
+declare const constants_d_$TEMPLATE_CACHE: typeof $TEMPLATE_CACHE;
+declare const constants_d_$TEMPLATE_REQUEST: typeof $TEMPLATE_REQUEST;
+declare const constants_d_COMPILER_KEY: typeof COMPILER_KEY;
+declare const constants_d_DOWNGRADED_MODULE_COUNT_KEY: typeof DOWNGRADED_MODULE_COUNT_KEY;
+declare const constants_d_GROUP_PROJECTABLE_NODES_KEY: typeof GROUP_PROJECTABLE_NODES_KEY;
+declare const constants_d_INJECTOR_KEY: typeof INJECTOR_KEY;
+declare const constants_d_LAZY_MODULE_REF: typeof LAZY_MODULE_REF;
+declare const constants_d_NG_ZONE_KEY: typeof NG_ZONE_KEY;
+declare const constants_d_REQUIRE_INJECTOR: typeof REQUIRE_INJECTOR;
+declare const constants_d_REQUIRE_NG_MODEL: typeof REQUIRE_NG_MODEL;
+declare const constants_d_UPGRADE_APP_TYPE_KEY: typeof UPGRADE_APP_TYPE_KEY;
+declare const constants_d_UPGRADE_MODULE_NAME: typeof UPGRADE_MODULE_NAME;
+declare namespace constants_d {
+  export { constants_d_$$TESTABILITY as $$TESTABILITY, constants_d_$COMPILE as $COMPILE, constants_d_$CONTROLLER as $CONTROLLER, constants_d_$DELEGATE as $DELEGATE, constants_d_$EXCEPTION_HANDLER as $EXCEPTION_HANDLER, constants_d_$HTTP_BACKEND as $HTTP_BACKEND, constants_d_$INJECTOR as $INJECTOR, constants_d_$INTERVAL as $INTERVAL, constants_d_$PARSE as $PARSE, constants_d_$PROVIDE as $PROVIDE, constants_d_$ROOT_ELEMENT as $ROOT_ELEMENT, constants_d_$ROOT_SCOPE as $ROOT_SCOPE, constants_d_$SCOPE as $SCOPE, constants_d_$TEMPLATE_CACHE as $TEMPLATE_CACHE, constants_d_$TEMPLATE_REQUEST as $TEMPLATE_REQUEST, constants_d_COMPILER_KEY as COMPILER_KEY, constants_d_DOWNGRADED_MODULE_COUNT_KEY as DOWNGRADED_MODULE_COUNT_KEY, constants_d_GROUP_PROJECTABLE_NODES_KEY as GROUP_PROJECTABLE_NODES_KEY, constants_d_INJECTOR_KEY as INJECTOR_KEY, constants_d_LAZY_MODULE_REF as LAZY_MODULE_REF, constants_d_NG_ZONE_KEY as NG_ZONE_KEY, constants_d_REQUIRE_INJECTOR as REQUIRE_INJECTOR, constants_d_REQUIRE_NG_MODEL as REQUIRE_NG_MODEL, constants_d_UPGRADE_APP_TYPE_KEY as UPGRADE_APP_TYPE_KEY, constants_d_UPGRADE_MODULE_NAME as UPGRADE_MODULE_NAME };
+}
 
 /**
- * @publicApi
+ * @fileoverview
+ * While Angular only uses Trusted Types internally for the time being,
+ * references to Trusted Types could leak into our public API, which would force
+ * anyone compiling against @angular/upgrade to provide the @types/trusted-types
+ * package in their compilation unit.
+ *
+ * Until https://github.com/microsoft/TypeScript/issues/30024 is resolved, we
+ * will keep Angular's public API surface free of references to Trusted Types.
+ * For internal and semi-private APIs that need to reference Trusted Types, the
+ * minimal type definitions for the Trusted Types API provided by this module
+ * should be used instead. They are marked as "declare" to prevent them from
+ * being renamed by compiler optimization.
+ *
+ * Adapted from
+ * https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/trusted-types/index.d.ts
+ * but restricted to the API surface used within Angular, mimicking the approach
+ * in packages/core/src/util/security/trusted_type_defs.ts.
  */
-export declare const VERSION: Version;
+type TrustedHTML = string & {
+    __brand__: 'TrustedHTML';
+};
 
-declare namespace ɵangular1 {
-    export {
-        setAngularLib,
-        getAngularLib,
-        setAngularJSGlobal,
-        getAngularJSGlobal,
-        Ng1Token,
-        Ng1Expression,
-        IAnnotatedFunction,
-        IInjectable,
-        SingleOrListOrMap,
-        IModule,
-        ICompileService,
-        ILinkFn,
-        ILinkFnOptions,
-        IRootScopeService,
-        IScope,
-        IAngularBootstrapConfig,
-        IDirective,
-        DirectiveRequireProperty,
-        DirectiveTranscludeProperty,
-        IDirectiveCompileFn,
-        IDirectivePrePost,
-        IDirectiveLinkFn,
-        IComponent,
-        IAttributes,
-        ITranscludeFunction,
-        ICloneAttachFunction,
-        IAugmentedJQuery,
-        IProvider,
-        IProvideService,
-        IParseService,
-        ICompiledExpression,
-        IHttpBackendService,
-        ICacheObject,
-        ITemplateCacheService,
-        IController,
-        IControllerService,
-        IInjectorService,
-        IIntervalService,
-        ITestabilityService,
-        INgModelController,
-        bootstrap,
-        module_,
-        element,
-        injector,
-        resumeBootstrap,
-        getTestability
-    }
+interface IBindingDestination {
+    [key: string]: any;
+    $onChanges?: (changes: SimpleChanges) => void;
 }
-export { ɵangular1 }
-
-declare namespace ɵconstants {
-    export {
-        $COMPILE,
-        $CONTROLLER,
-        $DELEGATE,
-        $EXCEPTION_HANDLER,
-        $HTTP_BACKEND,
-        $INJECTOR,
-        $INTERVAL,
-        $PARSE,
-        $PROVIDE,
-        $ROOT_ELEMENT,
-        $ROOT_SCOPE,
-        $SCOPE,
-        $TEMPLATE_CACHE,
-        $TEMPLATE_REQUEST,
-        $$TESTABILITY,
-        COMPILER_KEY,
-        DOWNGRADED_MODULE_COUNT_KEY,
-        GROUP_PROJECTABLE_NODES_KEY,
-        INJECTOR_KEY,
-        LAZY_MODULE_REF,
-        NG_ZONE_KEY,
-        UPGRADE_APP_TYPE_KEY,
-        REQUIRE_INJECTOR,
-        REQUIRE_NG_MODEL,
-        UPGRADE_MODULE_NAME
-    }
+interface IControllerInstance extends IBindingDestination {
+    $doCheck?: () => void;
+    $onDestroy?: () => void;
+    $onInit?: () => void;
+    $postLink?: () => void;
+}
+declare class UpgradeHelper {
+    private name;
+    readonly $injector: IInjectorService;
+    readonly element: Element;
+    readonly $element: IAugmentedJQuery;
+    readonly directive: IDirective;
+    private readonly $compile;
+    private readonly $controller;
+    constructor(injector: Injector, name: string, elementRef: ElementRef, directive?: IDirective);
+    static getDirective($injector: IInjectorService, name: string): IDirective;
+    static getTemplate($injector: IInjectorService, directive: IDirective, fetchRemoteTemplate?: boolean, $element?: IAugmentedJQuery): string | TrustedHTML | Promise<string | TrustedHTML>;
+    buildController(controllerType: IController, $scope: IScope): any;
+    compileTemplate(template?: string | TrustedHTML): ILinkFn;
+    onDestroy($scope: IScope, controllerInstance?: any): void;
+    prepareTransclusion(): ILinkFn | undefined;
+    resolveAndBindRequiredControllers(controllerInstance: IControllerInstance | null): SingleOrListOrMap<IControllerInstance> | null;
+    private compileHtml;
+    private extractChildNodes;
+    private getDirectiveRequire;
+    private resolveRequire;
 }
-export { ɵconstants }
 
-declare namespace ɵupgradeHelper {
-    export {
-        IBindingDestination,
-        IControllerInstance,
-        UpgradeHelper
-    }
+type upgrade_helper_d_IBindingDestination = IBindingDestination;
+type upgrade_helper_d_IControllerInstance = IControllerInstance;
+type upgrade_helper_d_UpgradeHelper = UpgradeHelper;
+declare const upgrade_helper_d_UpgradeHelper: typeof UpgradeHelper;
+declare namespace upgrade_helper_d {
+  export { type upgrade_helper_d_IBindingDestination as IBindingDestination, type upgrade_helper_d_IControllerInstance as IControllerInstance, upgrade_helper_d_UpgradeHelper as UpgradeHelper };
 }
-export { ɵupgradeHelper }
 
-declare namespace ɵutil {
-    export {
-        onError,
-        cleanData,
-        controllerKey,
-        destroyApp,
-        directiveNormalize,
-        getTypeName,
-        getDowngradedModuleCount,
-        getUpgradeAppType,
-        isFunction,
-        isNgModuleType,
-        validateInjectionKey,
-        hookupNgModel,
-        strictEquals,
-        Deferred,
-        LazyModuleRef,
-        UpgradeAppType
-    }
+declare function onError(e: any): void;
+/**
+ * Clean the jqLite/jQuery data on the element and all its descendants.
+ * Equivalent to how jqLite/jQuery invoke `cleanData()` on an Element when removed:
+ *   https://github.com/angular/angular.js/blob/2e72ea13fa98bebf6ed4b5e3c45eaf5f990ed16f/src/jqLite.js#L349-L355
+ *   https://github.com/jquery/jquery/blob/6984d1747623dbc5e87fd6c261a5b6b1628c107c/src/manipulation.js#L182
+ *
+ * NOTE:
+ * `cleanData()` will also invoke the AngularJS `$destroy` DOM event on the element:
+ *   https://github.com/angular/angular.js/blob/2e72ea13fa98bebf6ed4b5e3c45eaf5f990ed16f/src/Angular.js#L1932-L1945
+ *
+ * @param node The DOM node whose data needs to be cleaned.
+ */
+declare function cleanData(node: Node): void;
+declare function controllerKey(name: string): string;
+/**
+ * Destroy an AngularJS app given the app `$injector`.
+ *
+ * NOTE: Destroying an app is not officially supported by AngularJS, but try to do our best by
+ *       destroying `$rootScope` and clean the jqLite/jQuery data on `$rootElement` and all
+ *       descendants.
+ *
+ * @param $injector The `$injector` of the AngularJS app to destroy.
+ */
+declare function destroyApp($injector: IInjectorService): void;
+declare function directiveNormalize(name: string): string;
+declare function getTypeName(type: Type<any>): string;
+declare function getDowngradedModuleCount($injector: IInjectorService): number;
+declare function getUpgradeAppType($injector: IInjectorService): UpgradeAppType;
+declare function isFunction(value: any): value is Function;
+declare function isNgModuleType(value: any): value is Type<unknown>;
+declare function validateInjectionKey($injector: IInjectorService, downgradedModule: string, injectionKey: string, attemptedAction: string): void;
+declare class Deferred<R> {
+    promise: Promise<R>;
+    resolve: (value: R | PromiseLike<R>) => void;
+    reject: (error?: any) => void;
+    constructor();
 }
-export { ɵutil }
+interface LazyModuleRef {
+    injector?: Injector;
+    promise?: Promise<Injector>;
+}
+declare const enum UpgradeAppType {
+    None = 0,
+    Dynamic = 1,
+    Static = 2,
+    Lite = 3
+}
+/**
+ * Glue the AngularJS `NgModelController` (if it exists) to the component
+ * (if it implements the needed subset of the `ControlValueAccessor` interface).
+ */
+declare function hookupNgModel(ngModel: INgModelController, component: any): void;
+/**
+ * Test two values for strict equality, accounting for the fact that `NaN !== NaN`.
+ */
+declare function strictEquals(val1: any, val2: any): boolean;
 
-export { }
+type util_d_Deferred<R> = Deferred<R>;
+declare const util_d_Deferred: typeof Deferred;
+type util_d_LazyModuleRef = LazyModuleRef;
+type util_d_UpgradeAppType = UpgradeAppType;
+declare const util_d_UpgradeAppType: typeof UpgradeAppType;
+declare const util_d_cleanData: typeof cleanData;
+declare const util_d_controllerKey: typeof controllerKey;
+declare const util_d_destroyApp: typeof destroyApp;
+declare const util_d_directiveNormalize: typeof directiveNormalize;
+declare const util_d_getDowngradedModuleCount: typeof getDowngradedModuleCount;
+declare const util_d_getTypeName: typeof getTypeName;
+declare const util_d_getUpgradeAppType: typeof getUpgradeAppType;
+declare const util_d_hookupNgModel: typeof hookupNgModel;
+declare const util_d_isFunction: typeof isFunction;
+declare const util_d_isNgModuleType: typeof isNgModuleType;
+declare const util_d_onError: typeof onError;
+declare const util_d_strictEquals: typeof strictEquals;
+declare const util_d_validateInjectionKey: typeof validateInjectionKey;
+declare namespace util_d {
+  export { util_d_Deferred as Deferred, type util_d_LazyModuleRef as LazyModuleRef, util_d_UpgradeAppType as UpgradeAppType, util_d_cleanData as cleanData, util_d_controllerKey as controllerKey, util_d_destroyApp as destroyApp, util_d_directiveNormalize as directiveNormalize, util_d_getDowngradedModuleCount as getDowngradedModuleCount, util_d_getTypeName as getTypeName, util_d_getUpgradeAppType as getUpgradeAppType, util_d_hookupNgModel as hookupNgModel, util_d_isFunction as isFunction, util_d_isNgModuleType as isNgModuleType, util_d_onError as onError, util_d_strictEquals as strictEquals, util_d_validateInjectionKey as validateInjectionKey };
+}
+
+export { UpgradeComponent, UpgradeModule, downgradeComponent, downgradeInjectable, downgradeModule, constants_d as ɵconstants, upgrade_helper_d as ɵupgradeHelper, util_d as ɵutil };