@angular/upgrade 14.0.0-next.9 → 14.0.0-rc.2

package/{upgrade.d.ts → index.d.ts}

@@ -1,474 +1,475 @@
 /**
- * @license Angular v14.0.0-next.9
+ * @license Angular v14.0.0-rc.2
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
 
-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';
-
-declare interface IAngularBootstrapConfig {
-    strictDi?: boolean;
-}
-
-declare interface IInjectorService {
-    get(key: string): any;
-    has(key: string): boolean;
-}
-
-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;
-    [key: string]: any;
-}
-
-declare interface IScope extends IRootScopeService {
-}
-
-declare type Ng1Expression = string | Function;
-
-/**
- * Use `UpgradeAdapter` to allow AngularJS and Angular to coexist in a single application.
- *
- * The `UpgradeAdapter` allows:
- * 1. creation of Angular component from AngularJS component directive
- *    (See [UpgradeAdapter#upgradeNg1Component()])
- * 2. creation of AngularJS directive from Angular component.
- *    (See [UpgradeAdapter#downgradeNg2Component()])
- * 3. Bootstrapping of a hybrid Angular application which contains both of the frameworks
- *    coexisting in a single application.
- *
- * @usageNotes
- * ### Mental Model
- *
- * When reasoning about how a hybrid application works it is useful to have a mental model which
- * describes what is happening and explains what is happening at the lowest level.
- *
- * 1. There are two independent frameworks running in a single application, each framework treats
- *    the other as a black box.
- * 2. Each DOM element on the page is owned exactly by one framework. Whichever framework
- *    instantiated the element is the owner. Each framework only updates/interacts with its own
- *    DOM elements and ignores others.
- * 3. AngularJS directives always execute inside AngularJS framework codebase regardless of
- *    where they are instantiated.
- * 4. Angular components always execute inside Angular framework codebase regardless of
- *    where they are instantiated.
- * 5. An AngularJS component can be upgraded to an Angular component. This creates an
- *    Angular directive, which bootstraps the AngularJS component directive in that location.
- * 6. An Angular component can be downgraded to an AngularJS component directive. This creates
- *    an AngularJS directive, which bootstraps the Angular component in that location.
- * 7. Whenever an adapter component is instantiated the host element is owned by the framework
- *    doing the instantiation. The other framework then instantiates and owns the view for that
- *    component. This implies that component bindings will always follow the semantics of the
- *    instantiation framework. The syntax is always that of Angular syntax.
- * 8. AngularJS is always bootstrapped first and owns the bottom most view.
- * 9. The new application is running in Angular zone, and therefore it no longer needs calls to
- *    `$apply()`.
- *
- * ### Example
- *
- * ```
- * const adapter = new UpgradeAdapter(forwardRef(() => MyNg2Module), myCompilerOptions);
- * const module = angular.module('myExample', []);
- * module.directive('ng2Comp', adapter.downgradeNg2Component(Ng2Component));
- *
- * module.directive('ng1Hello', function() {
- *   return {
- *      scope: { title: '=' },
- *      template: 'ng1[Hello {{title}}!](<span ng-transclude></span>)'
- *   };
- * });
- *
- *
- * @Component({
- *   selector: 'ng2-comp',
- *   inputs: ['name'],
- *   template: 'ng2[<ng1-hello [title]="name">transclude</ng1-hello>](<ng-content></ng-content>)',
- *   directives:
- * })
- * class Ng2Component {
- * }
- *
- * @NgModule({
- *   declarations: [Ng2Component, adapter.upgradeNg1Component('ng1Hello')],
- *   imports: [BrowserModule]
- * })
- * class MyNg2Module {}
- *
- *
- * document.body.innerHTML = '<ng2-comp name="World">project</ng2-comp>';
- *
- * adapter.bootstrap(document.body, ['myExample']).ready(function() {
- *   expect(document.body.textContent).toEqual(
- *       "ng2[ng1[Hello World!](transclude)](project)");
- * });
- *
- * ```
- *
- * @deprecated Deprecated since v5. Use `upgrade/static` instead, which also supports
- * [Ahead-of-Time compilation](guide/aot-compiler).
- * @publicApi
- */
-export declare class UpgradeAdapter {
-    private ng2AppModule;
-    private compilerOptions?;
-    private idPrefix;
-    private downgradedComponents;
-    private upgradedProviders;
-    private ngZone;
-    private ng1Module;
-    private moduleRef;
-    private ng2BootstrapDeferred;
-    constructor(ng2AppModule: Type<any>, compilerOptions?: CompilerOptions | undefined);
-    /**
-     * Allows Angular Component to be used from AngularJS.
-     *
-     * Use `downgradeNg2Component` to create an AngularJS Directive Definition Factory from
-     * Angular Component. The adapter will bootstrap Angular component from within the
-     * AngularJS template.
-     *
-     * @usageNotes
-     * ### Mental Model
-     *
-     * 1. The component is instantiated by being listed in AngularJS template. This means that the
-     *    host element is controlled by AngularJS, but the component's view will be controlled by
-     *    Angular.
-     * 2. Even thought the component is instantiated in AngularJS, it will be using Angular
-     *    syntax. This has to be done, this way because we must follow Angular components do not
-     *    declare how the attributes should be interpreted.
-     * 3. `ng-model` is controlled by AngularJS and communicates with the downgraded Angular component
-     *    by way of the `ControlValueAccessor` interface from @angular/forms. Only components that
-     *    implement this interface are eligible.
-     *
-     * ### Supported Features
-     *
-     * - Bindings:
-     *   - Attribute: `<comp name="World">`
-     *   - Interpolation:  `<comp greeting="Hello {{name}}!">`
-     *   - Expression:  `<comp [name]="username">`
-     *   - Event:  `<comp (close)="doSomething()">`
-     *   - ng-model: `<comp ng-model="name">`
-     * - Content projection: yes
-     *
-     * ### Example
-     *
-     * ```
-     * const adapter = new UpgradeAdapter(forwardRef(() => MyNg2Module));
-     * const module = angular.module('myExample', []);
-     * module.directive('greet', adapter.downgradeNg2Component(Greeter));
-     *
-     * @Component({
-     *   selector: 'greet',
-     *   template: '{{salutation}} {{name}}! - <ng-content></ng-content>'
-     * })
-     * class Greeter {
-     *   @Input() salutation: string;
-     *   @Input() name: string;
-     * }
-     *
-     * @NgModule({
-     *   declarations: [Greeter],
-     *   imports: [BrowserModule]
-     * })
-     * class MyNg2Module {}
-     *
-     * document.body.innerHTML =
-     *   'ng1 template: <greet salutation="Hello" [name]="world">text</greet>';
-     *
-     * adapter.bootstrap(document.body, ['myExample']).ready(function() {
-     *   expect(document.body.textContent).toEqual("ng1 template: Hello world! - text");
-     * });
-     * ```
-     */
-    downgradeNg2Component(component: Type<any>): Function;
-    /**
-     * Allows AngularJS Component to be used from Angular.
-     *
-     * Use `upgradeNg1Component` to create an Angular component from AngularJS Component
-     * directive. The adapter will bootstrap AngularJS component from within the Angular
-     * template.
-     *
-     * @usageNotes
-     * ### Mental Model
-     *
-     * 1. The component is instantiated by being listed in Angular template. This means that the
-     *    host element is controlled by Angular, but the component's view will be controlled by
-     *    AngularJS.
-     *
-     * ### Supported Features
-     *
-     * - Bindings:
-     *   - Attribute: `<comp name="World">`
-     *   - Interpolation:  `<comp greeting="Hello {{name}}!">`
-     *   - Expression:  `<comp [name]="username">`
-     *   - Event:  `<comp (close)="doSomething()">`
-     * - Transclusion: yes
-     * - Only some of the features of
-     *   [Directive Definition Object](https://docs.angularjs.org/api/ng/service/$compile) are
-     *   supported:
-     *   - `compile`: not supported because the host element is owned by Angular, which does
-     *     not allow modifying DOM structure during compilation.
-     *   - `controller`: supported. (NOTE: injection of `$attrs` and `$transclude` is not supported.)
-     *   - `controllerAs`: supported.
-     *   - `bindToController`: supported.
-     *   - `link`: supported. (NOTE: only pre-link function is supported.)
-     *   - `name`: supported.
-     *   - `priority`: ignored.
-     *   - `replace`: not supported.
-     *   - `require`: supported.
-     *   - `restrict`: must be set to 'E'.
-     *   - `scope`: supported.
-     *   - `template`: supported.
-     *   - `templateUrl`: supported.
-     *   - `terminal`: ignored.
-     *   - `transclude`: supported.
-     *
-     *
-     * ### Example
-     *
-     * ```
-     * const adapter = new UpgradeAdapter(forwardRef(() => MyNg2Module));
-     * const module = angular.module('myExample', []);
-     *
-     * module.directive('greet', function() {
-     *   return {
-     *     scope: {salutation: '=', name: '=' },
-     *     template: '{{salutation}} {{name}}! - <span ng-transclude></span>'
-     *   };
-     * });
-     *
-     * module.directive('ng2', adapter.downgradeNg2Component(Ng2Component));
-     *
-     * @Component({
-     *   selector: 'ng2',
-     *   template: 'ng2 template: <greet salutation="Hello" [name]="world">text</greet>'
-     * })
-     * class Ng2Component {
-     * }
-     *
-     * @NgModule({
-     *   declarations: [Ng2Component, adapter.upgradeNg1Component('greet')],
-     *   imports: [BrowserModule]
-     * })
-     * class MyNg2Module {}
-     *
-     * document.body.innerHTML = '<ng2></ng2>';
-     *
-     * adapter.bootstrap(document.body, ['myExample']).ready(function() {
-     *   expect(document.body.textContent).toEqual("ng2 template: Hello world! - text");
-     * });
-     * ```
-     */
-    upgradeNg1Component(name: string): Type<any>;
-    /**
-     * Registers the adapter's AngularJS upgrade module for unit testing in AngularJS.
-     * Use this instead of `angular.mock.module()` to load the upgrade module into
-     * the AngularJS testing injector.
-     *
-     * @usageNotes
-     * ### Example
-     *
-     * ```
-     * const upgradeAdapter = new UpgradeAdapter(MyNg2Module);
-     *
-     * // configure the adapter with upgrade/downgrade components and services
-     * upgradeAdapter.downgradeNg2Component(MyComponent);
-     *
-     * let upgradeAdapterRef: UpgradeAdapterRef;
-     * let $compile, $rootScope;
-     *
-     * // We must register the adapter before any calls to `inject()`
-     * beforeEach(() => {
-     *   upgradeAdapterRef = upgradeAdapter.registerForNg1Tests(['heroApp']);
-     * });
-     *
-     * beforeEach(inject((_$compile_, _$rootScope_) => {
-     *   $compile = _$compile_;
-     *   $rootScope = _$rootScope_;
-     * }));
-     *
-     * it("says hello", (done) => {
-     *   upgradeAdapterRef.ready(() => {
-     *     const element = $compile("<my-component></my-component>")($rootScope);
-     *     $rootScope.$apply();
-     *     expect(element.html()).toContain("Hello World");
-     *     done();
-     *   })
-     * });
-     *
-     * ```
-     *
-     * @param modules any AngularJS modules that the upgrade module should depend upon
-     * @returns an `UpgradeAdapterRef`, which lets you register a `ready()` callback to
-     * run assertions once the Angular components are ready to test through AngularJS.
-     */
-    registerForNg1Tests(modules?: string[]): UpgradeAdapterRef;
-    /**
-     * Bootstrap a hybrid AngularJS / Angular application.
-     *
-     * This `bootstrap` method is a direct replacement (takes same arguments) for AngularJS
-     * [`bootstrap`](https://docs.angularjs.org/api/ng/function/angular.bootstrap) method. Unlike
-     * AngularJS, this bootstrap is asynchronous.
-     *
-     * @usageNotes
-     * ### Example
-     *
-     * ```
-     * const adapter = new UpgradeAdapter(MyNg2Module);
-     * const module = angular.module('myExample', []);
-     * module.directive('ng2', adapter.downgradeNg2Component(Ng2));
-     *
-     * module.directive('ng1', function() {
-     *   return {
-     *      scope: { title: '=' },
-     *      template: 'ng1[Hello {{title}}!](<span ng-transclude></span>)'
-     *   };
-     * });
-     *
-     *
-     * @Component({
-     *   selector: 'ng2',
-     *   inputs: ['name'],
-     *   template: 'ng2[<ng1 [title]="name">transclude</ng1>](<ng-content></ng-content>)'
-     * })
-     * class Ng2 {
-     * }
-     *
-     * @NgModule({
-     *   declarations: [Ng2, adapter.upgradeNg1Component('ng1')],
-     *   imports: [BrowserModule]
-     * })
-     * class MyNg2Module {}
-     *
-     * document.body.innerHTML = '<ng2 name="World">project</ng2>';
-     *
-     * adapter.bootstrap(document.body, ['myExample']).ready(function() {
-     *   expect(document.body.textContent).toEqual(
-     *       "ng2[ng1[Hello World!](transclude)](project)");
-     * });
-     * ```
-     */
-    bootstrap(element: Element, modules?: any[], config?: IAngularBootstrapConfig): UpgradeAdapterRef;
-    /**
-     * Allows AngularJS service to be accessible from Angular.
-     *
-     * @usageNotes
-     * ### Example
-     *
-     * ```
-     * class Login { ... }
-     * class Server { ... }
-     *
-     * @Injectable()
-     * class Example {
-     *   constructor(@Inject('server') server, login: Login) {
-     *     ...
-     *   }
-     * }
-     *
-     * const module = angular.module('myExample', []);
-     * module.service('server', Server);
-     * module.service('login', Login);
-     *
-     * const adapter = new UpgradeAdapter(MyNg2Module);
-     * adapter.upgradeNg1Provider('server');
-     * adapter.upgradeNg1Provider('login', {asToken: Login});
-     *
-     * adapter.bootstrap(document.body, ['myExample']).ready((ref) => {
-     *   const example: Example = ref.ng2Injector.get(Example);
-     * });
-     *
-     * ```
-     */
-    upgradeNg1Provider(name: string, options?: {
-        asToken: any;
-    }): void;
-    /**
-     * Allows Angular service to be accessible from AngularJS.
-     *
-     * @usageNotes
-     * ### Example
-     *
-     * ```
-     * class Example {
-     * }
-     *
-     * const adapter = new UpgradeAdapter(MyNg2Module);
-     *
-     * const module = angular.module('myExample', []);
-     * module.factory('example', adapter.downgradeNg2Provider(Example));
-     *
-     * adapter.bootstrap(document.body, ['myExample']).ready((ref) => {
-     *   const example: Example = ref.ng1Injector.get('example');
-     * });
-     *
-     * ```
-     */
-    downgradeNg2Provider(token: any): Function;
-    /**
-     * Declare the AngularJS upgrade module for this adapter without bootstrapping the whole
-     * hybrid application.
-     *
-     * This method is automatically called by `bootstrap()` and `registerForNg1Tests()`.
-     *
-     * @param modules The AngularJS modules that this upgrade module should depend upon.
-     * @returns The AngularJS upgrade module that is declared by this method
-     *
-     * @usageNotes
-     * ### Example
-     *
-     * ```
-     * const upgradeAdapter = new UpgradeAdapter(MyNg2Module);
-     * upgradeAdapter.declareNg1Module(['heroApp']);
-     * ```
-     */
-    private declareNg1Module;
-}
-
-/**
- * Use `UpgradeAdapterRef` to control a hybrid AngularJS / Angular application.
- *
- * @deprecated Deprecated since v5. Use `upgrade/static` instead, which also supports
- * [Ahead-of-Time compilation](guide/aot-compiler).
- * @publicApi
- */
-export declare class UpgradeAdapterRef {
-    ng1RootScope: IRootScopeService;
-    ng1Injector: IInjectorService;
-    ng2ModuleRef: NgModuleRef<any>;
-    ng2Injector: Injector;
-    /**
-     * Register a callback function which is notified upon successful hybrid AngularJS / Angular
-     * application has been bootstrapped.
-     *
-     * The `ready` callback function is invoked inside the Angular zone, therefore it does not
-     * require a call to `$apply()`.
-     */
-    ready(fn: (upgradeAdapterRef: UpgradeAdapterRef) => void): void;
-    /**
-     * Dispose of running hybrid AngularJS / Angular application.
-     */
-    dispose(): void;
-}
-
-/**
- * @publicApi
- */
-export declare const VERSION: Version;
-
-export { }
+
+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';
+
+declare interface IAngularBootstrapConfig {
+    strictDi?: boolean;
+}
+
+declare interface IInjectorService {
+    get(key: string): any;
+    has(key: string): boolean;
+}
+
+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;
+    [key: string]: any;
+}
+
+declare interface IScope extends IRootScopeService {
+}
+
+declare type Ng1Expression = string | Function;
+
+/**
+ * Use `UpgradeAdapter` to allow AngularJS and Angular to coexist in a single application.
+ *
+ * The `UpgradeAdapter` allows:
+ * 1. creation of Angular component from AngularJS component directive
+ *    (See [UpgradeAdapter#upgradeNg1Component()])
+ * 2. creation of AngularJS directive from Angular component.
+ *    (See [UpgradeAdapter#downgradeNg2Component()])
+ * 3. Bootstrapping of a hybrid Angular application which contains both of the frameworks
+ *    coexisting in a single application.
+ *
+ * @usageNotes
+ * ### Mental Model
+ *
+ * When reasoning about how a hybrid application works it is useful to have a mental model which
+ * describes what is happening and explains what is happening at the lowest level.
+ *
+ * 1. There are two independent frameworks running in a single application, each framework treats
+ *    the other as a black box.
+ * 2. Each DOM element on the page is owned exactly by one framework. Whichever framework
+ *    instantiated the element is the owner. Each framework only updates/interacts with its own
+ *    DOM elements and ignores others.
+ * 3. AngularJS directives always execute inside AngularJS framework codebase regardless of
+ *    where they are instantiated.
+ * 4. Angular components always execute inside Angular framework codebase regardless of
+ *    where they are instantiated.
+ * 5. An AngularJS component can be upgraded to an Angular component. This creates an
+ *    Angular directive, which bootstraps the AngularJS component directive in that location.
+ * 6. An Angular component can be downgraded to an AngularJS component directive. This creates
+ *    an AngularJS directive, which bootstraps the Angular component in that location.
+ * 7. Whenever an adapter component is instantiated the host element is owned by the framework
+ *    doing the instantiation. The other framework then instantiates and owns the view for that
+ *    component. This implies that component bindings will always follow the semantics of the
+ *    instantiation framework. The syntax is always that of Angular syntax.
+ * 8. AngularJS is always bootstrapped first and owns the bottom most view.
+ * 9. The new application is running in Angular zone, and therefore it no longer needs calls to
+ *    `$apply()`.
+ *
+ * ### Example
+ *
+ * ```
+ * const adapter = new UpgradeAdapter(forwardRef(() => MyNg2Module), myCompilerOptions);
+ * const module = angular.module('myExample', []);
+ * module.directive('ng2Comp', adapter.downgradeNg2Component(Ng2Component));
+ *
+ * module.directive('ng1Hello', function() {
+ *   return {
+ *      scope: { title: '=' },
+ *      template: 'ng1[Hello {{title}}!](<span ng-transclude></span>)'
+ *   };
+ * });
+ *
+ *
+ * @Component({
+ *   selector: 'ng2-comp',
+ *   inputs: ['name'],
+ *   template: 'ng2[<ng1-hello [title]="name">transclude</ng1-hello>](<ng-content></ng-content>)',
+ *   directives:
+ * })
+ * class Ng2Component {
+ * }
+ *
+ * @NgModule({
+ *   declarations: [Ng2Component, adapter.upgradeNg1Component('ng1Hello')],
+ *   imports: [BrowserModule]
+ * })
+ * class MyNg2Module {}
+ *
+ *
+ * document.body.innerHTML = '<ng2-comp name="World">project</ng2-comp>';
+ *
+ * adapter.bootstrap(document.body, ['myExample']).ready(function() {
+ *   expect(document.body.textContent).toEqual(
+ *       "ng2[ng1[Hello World!](transclude)](project)");
+ * });
+ *
+ * ```
+ *
+ * @deprecated Deprecated since v5. Use `upgrade/static` instead, which also supports
+ * [Ahead-of-Time compilation](guide/aot-compiler).
+ * @publicApi
+ */
+export declare class UpgradeAdapter {
+    private ng2AppModule;
+    private compilerOptions?;
+    private idPrefix;
+    private downgradedComponents;
+    private upgradedProviders;
+    private ngZone;
+    private ng1Module;
+    private moduleRef;
+    private ng2BootstrapDeferred;
+    constructor(ng2AppModule: Type<any>, compilerOptions?: CompilerOptions | undefined);
+    /**
+     * Allows Angular Component to be used from AngularJS.
+     *
+     * Use `downgradeNg2Component` to create an AngularJS Directive Definition Factory from
+     * Angular Component. The adapter will bootstrap Angular component from within the
+     * AngularJS template.
+     *
+     * @usageNotes
+     * ### Mental Model
+     *
+     * 1. The component is instantiated by being listed in AngularJS template. This means that the
+     *    host element is controlled by AngularJS, but the component's view will be controlled by
+     *    Angular.
+     * 2. Even thought the component is instantiated in AngularJS, it will be using Angular
+     *    syntax. This has to be done, this way because we must follow Angular components do not
+     *    declare how the attributes should be interpreted.
+     * 3. `ng-model` is controlled by AngularJS and communicates with the downgraded Angular component
+     *    by way of the `ControlValueAccessor` interface from @angular/forms. Only components that
+     *    implement this interface are eligible.
+     *
+     * ### Supported Features
+     *
+     * - Bindings:
+     *   - Attribute: `<comp name="World">`
+     *   - Interpolation:  `<comp greeting="Hello {{name}}!">`
+     *   - Expression:  `<comp [name]="username">`
+     *   - Event:  `<comp (close)="doSomething()">`
+     *   - ng-model: `<comp ng-model="name">`
+     * - Content projection: yes
+     *
+     * ### Example
+     *
+     * ```
+     * const adapter = new UpgradeAdapter(forwardRef(() => MyNg2Module));
+     * const module = angular.module('myExample', []);
+     * module.directive('greet', adapter.downgradeNg2Component(Greeter));
+     *
+     * @Component({
+     *   selector: 'greet',
+     *   template: '{{salutation}} {{name}}! - <ng-content></ng-content>'
+     * })
+     * class Greeter {
+     *   @Input() salutation: string;
+     *   @Input() name: string;
+     * }
+     *
+     * @NgModule({
+     *   declarations: [Greeter],
+     *   imports: [BrowserModule]
+     * })
+     * class MyNg2Module {}
+     *
+     * document.body.innerHTML =
+     *   'ng1 template: <greet salutation="Hello" [name]="world">text</greet>';
+     *
+     * adapter.bootstrap(document.body, ['myExample']).ready(function() {
+     *   expect(document.body.textContent).toEqual("ng1 template: Hello world! - text");
+     * });
+     * ```
+     */
+    downgradeNg2Component(component: Type<any>): Function;
+    /**
+     * Allows AngularJS Component to be used from Angular.
+     *
+     * Use `upgradeNg1Component` to create an Angular component from AngularJS Component
+     * directive. The adapter will bootstrap AngularJS component from within the Angular
+     * template.
+     *
+     * @usageNotes
+     * ### Mental Model
+     *
+     * 1. The component is instantiated by being listed in Angular template. This means that the
+     *    host element is controlled by Angular, but the component's view will be controlled by
+     *    AngularJS.
+     *
+     * ### Supported Features
+     *
+     * - Bindings:
+     *   - Attribute: `<comp name="World">`
+     *   - Interpolation:  `<comp greeting="Hello {{name}}!">`
+     *   - Expression:  `<comp [name]="username">`
+     *   - Event:  `<comp (close)="doSomething()">`
+     * - Transclusion: yes
+     * - Only some of the features of
+     *   [Directive Definition Object](https://docs.angularjs.org/api/ng/service/$compile) are
+     *   supported:
+     *   - `compile`: not supported because the host element is owned by Angular, which does
+     *     not allow modifying DOM structure during compilation.
+     *   - `controller`: supported. (NOTE: injection of `$attrs` and `$transclude` is not supported.)
+     *   - `controllerAs`: supported.
+     *   - `bindToController`: supported.
+     *   - `link`: supported. (NOTE: only pre-link function is supported.)
+     *   - `name`: supported.
+     *   - `priority`: ignored.
+     *   - `replace`: not supported.
+     *   - `require`: supported.
+     *   - `restrict`: must be set to 'E'.
+     *   - `scope`: supported.
+     *   - `template`: supported.
+     *   - `templateUrl`: supported.
+     *   - `terminal`: ignored.
+     *   - `transclude`: supported.
+     *
+     *
+     * ### Example
+     *
+     * ```
+     * const adapter = new UpgradeAdapter(forwardRef(() => MyNg2Module));
+     * const module = angular.module('myExample', []);
+     *
+     * module.directive('greet', function() {
+     *   return {
+     *     scope: {salutation: '=', name: '=' },
+     *     template: '{{salutation}} {{name}}! - <span ng-transclude></span>'
+     *   };
+     * });
+     *
+     * module.directive('ng2', adapter.downgradeNg2Component(Ng2Component));
+     *
+     * @Component({
+     *   selector: 'ng2',
+     *   template: 'ng2 template: <greet salutation="Hello" [name]="world">text</greet>'
+     * })
+     * class Ng2Component {
+     * }
+     *
+     * @NgModule({
+     *   declarations: [Ng2Component, adapter.upgradeNg1Component('greet')],
+     *   imports: [BrowserModule]
+     * })
+     * class MyNg2Module {}
+     *
+     * document.body.innerHTML = '<ng2></ng2>';
+     *
+     * adapter.bootstrap(document.body, ['myExample']).ready(function() {
+     *   expect(document.body.textContent).toEqual("ng2 template: Hello world! - text");
+     * });
+     * ```
+     */
+    upgradeNg1Component(name: string): Type<any>;
+    /**
+     * Registers the adapter's AngularJS upgrade module for unit testing in AngularJS.
+     * Use this instead of `angular.mock.module()` to load the upgrade module into
+     * the AngularJS testing injector.
+     *
+     * @usageNotes
+     * ### Example
+     *
+     * ```
+     * const upgradeAdapter = new UpgradeAdapter(MyNg2Module);
+     *
+     * // configure the adapter with upgrade/downgrade components and services
+     * upgradeAdapter.downgradeNg2Component(MyComponent);
+     *
+     * let upgradeAdapterRef: UpgradeAdapterRef;
+     * let $compile, $rootScope;
+     *
+     * // We must register the adapter before any calls to `inject()`
+     * beforeEach(() => {
+     *   upgradeAdapterRef = upgradeAdapter.registerForNg1Tests(['heroApp']);
+     * });
+     *
+     * beforeEach(inject((_$compile_, _$rootScope_) => {
+     *   $compile = _$compile_;
+     *   $rootScope = _$rootScope_;
+     * }));
+     *
+     * it("says hello", (done) => {
+     *   upgradeAdapterRef.ready(() => {
+     *     const element = $compile("<my-component></my-component>")($rootScope);
+     *     $rootScope.$apply();
+     *     expect(element.html()).toContain("Hello World");
+     *     done();
+     *   })
+     * });
+     *
+     * ```
+     *
+     * @param modules any AngularJS modules that the upgrade module should depend upon
+     * @returns an `UpgradeAdapterRef`, which lets you register a `ready()` callback to
+     * run assertions once the Angular components are ready to test through AngularJS.
+     */
+    registerForNg1Tests(modules?: string[]): UpgradeAdapterRef;
+    /**
+     * Bootstrap a hybrid AngularJS / Angular application.
+     *
+     * This `bootstrap` method is a direct replacement (takes same arguments) for AngularJS
+     * [`bootstrap`](https://docs.angularjs.org/api/ng/function/angular.bootstrap) method. Unlike
+     * AngularJS, this bootstrap is asynchronous.
+     *
+     * @usageNotes
+     * ### Example
+     *
+     * ```
+     * const adapter = new UpgradeAdapter(MyNg2Module);
+     * const module = angular.module('myExample', []);
+     * module.directive('ng2', adapter.downgradeNg2Component(Ng2));
+     *
+     * module.directive('ng1', function() {
+     *   return {
+     *      scope: { title: '=' },
+     *      template: 'ng1[Hello {{title}}!](<span ng-transclude></span>)'
+     *   };
+     * });
+     *
+     *
+     * @Component({
+     *   selector: 'ng2',
+     *   inputs: ['name'],
+     *   template: 'ng2[<ng1 [title]="name">transclude</ng1>](<ng-content></ng-content>)'
+     * })
+     * class Ng2 {
+     * }
+     *
+     * @NgModule({
+     *   declarations: [Ng2, adapter.upgradeNg1Component('ng1')],
+     *   imports: [BrowserModule]
+     * })
+     * class MyNg2Module {}
+     *
+     * document.body.innerHTML = '<ng2 name="World">project</ng2>';
+     *
+     * adapter.bootstrap(document.body, ['myExample']).ready(function() {
+     *   expect(document.body.textContent).toEqual(
+     *       "ng2[ng1[Hello World!](transclude)](project)");
+     * });
+     * ```
+     */
+    bootstrap(element: Element, modules?: any[], config?: IAngularBootstrapConfig): UpgradeAdapterRef;
+    /**
+     * Allows AngularJS service to be accessible from Angular.
+     *
+     * @usageNotes
+     * ### Example
+     *
+     * ```
+     * class Login { ... }
+     * class Server { ... }
+     *
+     * @Injectable()
+     * class Example {
+     *   constructor(@Inject('server') server, login: Login) {
+     *     ...
+     *   }
+     * }
+     *
+     * const module = angular.module('myExample', []);
+     * module.service('server', Server);
+     * module.service('login', Login);
+     *
+     * const adapter = new UpgradeAdapter(MyNg2Module);
+     * adapter.upgradeNg1Provider('server');
+     * adapter.upgradeNg1Provider('login', {asToken: Login});
+     *
+     * adapter.bootstrap(document.body, ['myExample']).ready((ref) => {
+     *   const example: Example = ref.ng2Injector.get(Example);
+     * });
+     *
+     * ```
+     */
+    upgradeNg1Provider(name: string, options?: {
+        asToken: any;
+    }): void;
+    /**
+     * Allows Angular service to be accessible from AngularJS.
+     *
+     * @usageNotes
+     * ### Example
+     *
+     * ```
+     * class Example {
+     * }
+     *
+     * const adapter = new UpgradeAdapter(MyNg2Module);
+     *
+     * const module = angular.module('myExample', []);
+     * module.factory('example', adapter.downgradeNg2Provider(Example));
+     *
+     * adapter.bootstrap(document.body, ['myExample']).ready((ref) => {
+     *   const example: Example = ref.ng1Injector.get('example');
+     * });
+     *
+     * ```
+     */
+    downgradeNg2Provider(token: any): Function;
+    /**
+     * Declare the AngularJS upgrade module for this adapter without bootstrapping the whole
+     * hybrid application.
+     *
+     * This method is automatically called by `bootstrap()` and `registerForNg1Tests()`.
+     *
+     * @param modules The AngularJS modules that this upgrade module should depend upon.
+     * @returns The AngularJS upgrade module that is declared by this method
+     *
+     * @usageNotes
+     * ### Example
+     *
+     * ```
+     * const upgradeAdapter = new UpgradeAdapter(MyNg2Module);
+     * upgradeAdapter.declareNg1Module(['heroApp']);
+     * ```
+     */
+    private declareNg1Module;
+}
+
+/**
+ * Use `UpgradeAdapterRef` to control a hybrid AngularJS / Angular application.
+ *
+ * @deprecated Deprecated since v5. Use `upgrade/static` instead, which also supports
+ * [Ahead-of-Time compilation](guide/aot-compiler).
+ * @publicApi
+ */
+export declare class UpgradeAdapterRef {
+    ng1RootScope: IRootScopeService;
+    ng1Injector: IInjectorService;
+    ng2ModuleRef: NgModuleRef<any>;
+    ng2Injector: Injector;
+    /**
+     * Register a callback function which is notified upon successful hybrid AngularJS / Angular
+     * application has been bootstrapped.
+     *
+     * The `ready` callback function is invoked inside the Angular zone, therefore it does not
+     * require a call to `$apply()`.
+     */
+    ready(fn: (upgradeAdapterRef: UpgradeAdapterRef) => void): void;
+    /**
+     * Dispose of running hybrid AngularJS / Angular application.
+     */
+    dispose(): void;
+}
+
+/**
+ * @publicApi
+ */
+export declare const VERSION: Version;
+
+export { }