static-injector 2.0.0 → 2.1.1

package/import/typings/di/forward_ref.d.ts

@@ -5,7 +5,7 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-import { Type } from "../interface/type";
+import { Type } from '../interface/type';
 /**
  * An interface that a function passed into {@link forwardRef} has to implement.
  *

package/import/typings/di/injectable.d.ts

@@ -5,15 +5,15 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-import { ValueSansProvider, ExistingSansProvider, StaticClassSansProvider, ConstructorSansProvider, FactorySansProvider, ClassSansProvider } from './interface/provider';
 import { Type } from '../interface/type';
 import { TypeDecorator } from '../util/decorators';
+import { ClassSansProvider, ConstructorSansProvider, ExistingSansProvider, FactorySansProvider, StaticClassSansProvider, ValueSansProvider } from './interface/provider';
 /**
  * Injectable providers used in `@Injectable` decorator.
  *
  * @publicApi
  */
-export declare type InjectableProvider = ValueSansProvider | ExistingSansProvider | StaticClassSansProvider | ConstructorSansProvider | FactorySansProvider | ClassSansProvider;
+export type InjectableProvider = ValueSansProvider | ExistingSansProvider | StaticClassSansProvider | ConstructorSansProvider | FactorySansProvider | ClassSansProvider;
 /**
  * Type of the Injectable decorator / constructor function.
  *
@@ -57,7 +57,8 @@ export interface Injectable {
     /**
      * Determines which injectors will provide the injectable.
      *
-     * - `Type<any>` - associates the injectable with an `@NgModule` or other `InjectorType`,
+     * - `Type<any>` - associates the injectable with an `@NgModule` or other `InjectorType`. This
+     * option is DEPRECATED.
      * - 'null' : Equivalent to `undefined`. The injectable is not provided in any scope automatically
      * and must be added to a `providers` array of an [@NgModule](api/core/NgModule#providers),
      * [@Component](api/core/Directive#providers) or [@Directive](api/core/Directive#providers).
@@ -68,7 +69,7 @@ export interface Injectable {
      * - 'platform' : A special singleton platform injector shared by all
      * applications on the page.
      * - 'any' : Provides a unique instance in each lazy loaded module while all eagerly loaded
-     * modules share one instance.
+     * modules share one instance. This option is DEPRECATED.
      *
      */
     providedIn?: Type<any> | 'root' | 'platform' | 'any' | null;

package/import/typings/di/injection_token.d.ts

@@ -14,11 +14,11 @@ import { Type } from '../interface/type';
  * parameterized type.
  *
  * `InjectionToken` is parameterized on `T` which is the type of object which will be returned by
- * the `Injector`. This provides additional level of type safety.
+ * the `Injector`. This provides an additional level of type safety.
  *
  * ```
  * interface MyInterface {...}
- * var myInterface = injector.get(new InjectionToken<MyInterface>('SomeToken'));
+ * const myInterface = injector.get(new InjectionToken<MyInterface>('SomeToken'));
  * // myInterface is inferred to be MyInterface.
  * ```
  *
@@ -26,14 +26,18 @@ import { Type } from '../interface/type';
  * (possibly by creating) a default value of the parameterized type `T`. This sets up the
  * `InjectionToken` using this factory as a provider as if it was defined explicitly in the
  * application's root injector. If the factory function, which takes zero arguments, needs to inject
- * dependencies, it can do so using the `inject` function. See below for an example.
+ * dependencies, it can do so using the `inject` function.
+ * As you can see in the Tree-shakable InjectionToken example below.
  *
  * Additionally, if a `factory` is specified you can also specify the `providedIn` option, which
- * overrides the above behavior and marks the token as belonging to a particular `@NgModule`. As
- * mentioned above, `'root'` is the default value for `providedIn`.
+ * overrides the above behavior and marks the token as belonging to a particular `@NgModule` (note:
+ * this option is now deprecated). As mentioned above, `'root'` is the default value for
+ * `providedIn`.
+ *
+ * The `providedIn: NgModule` and `providedIn: 'any'` options are deprecated.
  *
  * @usageNotes
- * ### Basic Example
+ * ### Basic Examples
  *
  * ### Plain InjectionToken
  *
@@ -48,7 +52,15 @@ import { Type } from '../interface/type';
  */
 export declare class InjectionToken<T> {
     protected _desc: string;
+    /** @internal */
+    readonly ngMetadataName = "InjectionToken";
     readonly ɵprov: unknown;
+    /**
+     * @param _desc   Description for the token,
+     *                used only for debugging purposes,
+     *                it should but does not need to be unique
+     * @param options Options for the token's usage, as described above
+     */
     constructor(_desc: string, options?: {
         providedIn?: Type<any> | 'root' | 'platform' | 'any' | null;
         factory: () => T;
@@ -59,3 +71,6 @@ export declare class InjectionToken<T> {
     get multi(): InjectionToken<Array<T>>;
     toString(): string;
 }
+export interface InjectableDefToken<T> extends InjectionToken<T> {
+    ɵprov: unknown;
+}

package/import/typings/di/injector.d.ts

@@ -62,6 +62,22 @@ export declare abstract class Injector {
      * @throws When the `notFoundValue` is `undefined` or `Injector.THROW_IF_NOT_FOUND`.
      */
     abstract get<T>(token: ProviderToken<T>, notFoundValue?: T, options?: InjectOptions | InjectFlags): T;
+    /**
+     * Retrieves an instance from the injector based on the provided token.
+     * @returns The instance from the injector if defined, otherwise the `notFoundValue`.
+     * @throws When the `notFoundValue` is `undefined` or `Injector.THROW_IF_NOT_FOUND`.
+     * @deprecated use object-based flags (`InjectOptions`) instead.
+     */
+    abstract get<T>(token: ProviderToken<T>, notFoundValue?: T, flags?: InjectFlags): T;
+    /**
+     * @deprecated from v4.0.0 use ProviderToken<T>
+     * @suppress {duplicate}
+     */
+    abstract get(token: any, notFoundValue?: any): any;
+    /**
+     * @deprecated from v5 use the new signature Injector.create(options)
+     */
+    static create(providers: StaticProvider[], parent?: Injector): Injector;
     /**
      * Creates a new injector instance that provides one or more dependencies,
      * according to a given type or types of `StaticProvider`.

package/import/typings/di/injector_compatibility.d.ts

@@ -11,15 +11,11 @@ import { ProviderToken } from './provider_token';
 export declare const THROW_IF_NOT_FOUND: {};
 export declare const NG_TEMP_TOKEN_PATH = "ngTempTokenPath";
 export declare const SOURCE = "__source";
-export declare const USE_VALUE: string;
 export declare function setCurrentInjector(injector: Injector | null | undefined): Injector | undefined | null;
 export declare function injectInjectorOnly<T>(token: ProviderToken<T>): T;
 export declare function injectInjectorOnly<T>(token: ProviderToken<T>, flags?: InjectFlags): T | null;
 /**
- * Generated instruction: Injects a token from the currently active injector.
- *
- * Must be used in the context of a factory function such as one defined for an
- * `InjectionToken`. Throws an error if not called from such a context.
+ * Generated instruction: injects a token from the currently active injector.
  *
  * (Additional documentation moved to `inject`, as it is the public API, and an alias for this
  * instruction)
@@ -30,6 +26,16 @@ export declare function injectInjectorOnly<T>(token: ProviderToken<T>, flags?: I
  */
 export declare function ɵɵinject<T>(token: ProviderToken<T>): T;
 export declare function ɵɵinject<T>(token: ProviderToken<T>, flags?: InjectFlags): T | null;
+/**
+ * Throws an error indicating that a factory function could not be generated by the compiler for a
+ * particular class.
+ *
+ * The name of the class is not mentioned here, but will be in the generated factory function name
+ * and thus in the stack trace.
+ *
+ * @codeGenApi
+ */
+export declare function ɵɵinvalidFactoryDep(index: number): void;
 /**
  * @param token A token that represents a dependency that should be injected.
  * @returns the injected value if operation is successful, `null` otherwise.

package/import/typings/di/injector_token.d.ts

@@ -5,8 +5,8 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-import { InjectionToken } from "./injection_token";
-import { Injector } from "./injector";
+import { InjectionToken } from './injection_token';
+import { Injector } from './injector';
 /**
  * An InjectionToken that gets the current `Injector` for `createInjector()`-style injectors.
  *

package/import/typings/di/interface/defs.d.ts

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { Type } from '../../interface/type';
-import { ClassProvider, ConstructorProvider, ExistingProvider, FactoryProvider, StaticClassProvider, ValueProvider } from './provider';
+import { ClassProvider, ConstructorProvider, EnvironmentProviders, ExistingProvider, FactoryProvider, StaticClassProvider, ValueProvider } from './provider';
 /**
  * Information about how a type or `InjectionToken` interfaces with the DI system.
  *
@@ -31,7 +31,7 @@ export interface ɵɵInjectableDeclaration<T> {
      * - `null`, does not belong to any injector. Must be explicitly listed in the injector
      *   `providers`.
      */
-    providedIn: InjectorType<any> | 'root' | 'platform' | 'any' | null;
+    providedIn: InjectorType<any> | 'root' | 'platform' | 'any' | 'environment' | null;
     /**
      * The token to which this definition belongs.
      *
@@ -60,14 +60,14 @@ export interface ɵɵInjectableDeclaration<T> {
  * @codeGenApi
  */
 export interface ɵɵInjectorDef<T> {
-    providers: (Type<any> | ValueProvider | ExistingProvider | FactoryProvider | ConstructorProvider | StaticClassProvider | ClassProvider | any[])[];
+    providers: (Type<any> | ValueProvider | ExistingProvider | FactoryProvider | ConstructorProvider | StaticClassProvider | ClassProvider | EnvironmentProviders | any[])[];
     imports: (InjectorType<any> | InjectorTypeWithProviders<any>)[];
 }
 /**
  * A `Type` which has a `ɵprov: ɵɵInjectableDeclaration` static field.
  *
  * `InjectableType`s contain their own Dependency Injection metadata and are usable in an
- * `InjectorDef`-based `StaticInjector.
+ * `InjectorDef`-based `StaticInjector`.
  *
  * @publicApi
  */
@@ -100,7 +100,7 @@ export interface InjectorType<T> extends Type<T> {
  */
 export interface InjectorTypeWithProviders<T> {
     ngModule: InjectorType<T>;
-    providers?: (Type<any> | ValueProvider | ExistingProvider | FactoryProvider | ConstructorProvider | StaticClassProvider | ClassProvider | any[])[];
+    providers?: (Type<any> | ValueProvider | ExistingProvider | FactoryProvider | ConstructorProvider | StaticClassProvider | ClassProvider | EnvironmentProviders | any[])[];
 }
 /**
  * Construct an injectable definition which defines how a token will be constructed by the DI
@@ -121,7 +121,7 @@ export interface InjectorTypeWithProviders<T> {
  */
 export declare function ɵɵdefineInjectable<T>(opts: {
     token: unknown;
-    providedIn?: Type<any> | 'root' | 'platform' | 'any' | null;
+    providedIn?: Type<any> | 'root' | 'platform' | 'any' | 'environment' | null;
     factory: () => T;
 }): unknown;
 /**
@@ -152,7 +152,7 @@ export declare function ɵɵdefineInjector(options: {
  * @param type A type which may have its own (non-inherited) `ɵprov`.
  */
 export declare function getInjectableDef<T>(type: any): ɵɵInjectableDeclaration<T> | null;
-export declare const NG_PROV_DEF: string;
+export declare function isInjectable(type: any): boolean;
 /**
  * Read the injectable def (`ɵprov`) for `type` or read the `ɵprov` from one of its ancestors.
  *
@@ -162,4 +162,11 @@ export declare const NG_PROV_DEF: string;
  *     scenario if we find the `ɵprov` on an ancestor only.
  */
 export declare function getInheritedInjectableDef<T>(type: any): ɵɵInjectableDeclaration<T> | null;
-export declare const NG_INJECTABLE_DEF: string;
+/**
+ * Read the injector def type in a way which is immune to accidentally reading inherited value.
+ *
+ * @param type type which may have an injector def (`ɵinj`)
+ */
+export declare function getInjectorDef<T>(type: any): ɵɵInjectorDef<T> | null;
+export declare const NG_PROV_DEF: string;
+export declare const NG_INJ_DEF: string;

package/import/typings/di/interface/provider.d.ts

@@ -236,7 +236,7 @@ export interface FactoryProvider extends FactorySansProvider {
  *
  * @publicApi
  */
-export declare type StaticProvider = ValueProvider | ExistingProvider | StaticClassProvider | ConstructorProvider | FactoryProvider | any[];
+export type StaticProvider = ValueProvider | ExistingProvider | StaticClassProvider | ConstructorProvider | FactoryProvider | any[];
 /**
  * Configures the `Injector` to return an instance of `Type` when `Type' is used as the token.
  *
@@ -304,4 +304,64 @@ export interface ClassProvider extends ClassSansProvider {
  *
  * @publicApi
  */
-export declare type Provider = TypeProvider | ValueProvider | ClassProvider | ConstructorProvider | ExistingProvider | FactoryProvider | any[];
+export type Provider = TypeProvider | ValueProvider | ClassProvider | ConstructorProvider | ExistingProvider | FactoryProvider | any[];
+/**
+ * Encapsulated `Provider`s that are only accepted during creation of an `EnvironmentInjector` (e.g.
+ * in an `NgModule`).
+ *
+ * Using this wrapper type prevents providers which are only designed to work in
+ * application/environment injectors from being accidentally included in
+ * `@Component.providers` and ending up in a component injector.
+ *
+ * This wrapper type prevents access to the `Provider`s inside.
+ *
+ * @see `makeEnvironmentProviders`
+ * @see `importProvidersFrom`
+ *
+ * @publicApi
+ */
+export type EnvironmentProviders = {
+    ɵbrand: 'EnvironmentProviders';
+};
+export interface InternalEnvironmentProviders extends EnvironmentProviders {
+    ɵproviders: (Provider | EnvironmentProviders)[];
+    /**
+     * If present, indicates that the `EnvironmentProviders` were derived from NgModule providers.
+     *
+     * This is used to produce clearer error messages.
+     */
+    ɵfromNgModule?: true;
+}
+export declare function isEnvironmentProviders(value: Provider | EnvironmentProviders | InternalEnvironmentProviders): value is InternalEnvironmentProviders;
+/**
+ * Describes a function that is used to process provider lists (such as provider
+ * overrides).
+ */
+export type ProcessProvidersFunction = (providers: Provider[]) => Provider[];
+/**
+ * A wrapper around an NgModule that associates it with [providers](guide/glossary#provider
+ * "Definition"). Usage without a generic type is deprecated.
+ *
+ * @see [Deprecations](guide/deprecations#modulewithproviders-type-without-a-generic)
+ *
+ * @publicApi
+ */
+export interface ModuleWithProviders<T> {
+    ngModule: Type<T>;
+    providers?: Array<Provider | EnvironmentProviders>;
+}
+/**
+ * Providers that were imported from NgModules via the `importProvidersFrom` function.
+ *
+ * These providers are meant for use in an application injector (or other environment injectors) and
+ * should not be used in component injectors.
+ *
+ * This type cannot be directly implemented. It's returned from the `importProvidersFrom` function
+ * and serves to prevent the extracted NgModule providers from being used in the wrong contexts.
+ *
+ * @see `importProvidersFrom`
+ *
+ * @publicApi
+ * @deprecated replaced by `EnvironmentProviders`
+ */
+export type ImportedNgModuleProviders = EnvironmentProviders;

package/import/typings/di/null_injector.d.ts

@@ -5,7 +5,7 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-import { Injector } from "./injector";
+import { Injector } from './injector';
 export declare class NullInjector implements Injector {
     get(token: any, notFoundValue?: any): any;
 }

package/import/typings/di/provider_collection.d.ts

@@ -7,11 +7,64 @@
  */
 import { Type } from '../interface/type';
 import { InjectorTypeWithProviders } from './interface/defs';
-import { ClassProvider, ConstructorProvider, ExistingProvider, FactoryProvider, StaticClassProvider, TypeProvider, ValueProvider } from './interface/provider';
+import { ClassProvider, ConstructorProvider, EnvironmentProviders, ExistingProvider, FactoryProvider, ModuleWithProviders, Provider, StaticClassProvider, TypeProvider, ValueProvider } from './interface/provider';
+/**
+ * Wrap an array of `Provider`s into `EnvironmentProviders`, preventing them from being accidentally
+ * referenced in `@Component in a component injector.
+ */
+export declare function makeEnvironmentProviders(providers: (Provider | EnvironmentProviders)[]): EnvironmentProviders;
+/**
+ * A source of providers for the `importProvidersFrom` function.
+ *
+ * @publicApi
+ */
+export type ImportProvidersSource = Type<unknown> | ModuleWithProviders<unknown> | Array<ImportProvidersSource>;
+/**
+ * Collects providers from all NgModules and standalone components, including transitively imported
+ * ones.
+ *
+ * Providers extracted via `importProvidersFrom` are only usable in an application injector or
+ * another environment injector (such as a route injector). They should not be used in component
+ * providers.
+ *
+ * More information about standalone components can be found in [this
+ * guide](guide/standalone-components).
+ *
+ * @usageNotes
+ * The results of the `importProvidersFrom` call can be used in the `bootstrapApplication` call:
+ *
+ * ```typescript
+ * await bootstrapApplication(RootComponent, {
+ *   providers: [
+ *     importProvidersFrom(NgModuleOne, NgModuleTwo)
+ *   ]
+ * });
+ * ```
+ *
+ * You can also use the `importProvidersFrom` results in the `providers` field of a route, when a
+ * standalone component is used:
+ *
+ * ```typescript
+ * export const ROUTES: Route[] = [
+ *   {
+ *     path: 'foo',
+ *     providers: [
+ *       importProvidersFrom(NgModuleOne, NgModuleTwo)
+ *     ],
+ *     component: YourStandaloneComponent
+ *   }
+ * ];
+ * ```
+ *
+ * @returns Collected providers from the specified list of types.
+ * @publicApi
+ */
+export declare function importProvidersFrom(...sources: ImportProvidersSource[]): EnvironmentProviders;
+export declare function internalImportProvidersFrom(checkForStandaloneCmp: boolean, ...sources: ImportProvidersSource[]): Provider[];
 /**
  * Internal type for a single provider in a deep provider array.
  */
-export declare type SingleProvider = TypeProvider | ValueProvider | ClassProvider | ConstructorProvider | ExistingProvider | FactoryProvider | StaticClassProvider;
+export type SingleProvider = TypeProvider | ValueProvider | ClassProvider | ConstructorProvider | ExistingProvider | FactoryProvider | StaticClassProvider;
 /**
  * The logic visits an `InjectorType`, an `InjectorTypeWithProviders`, or a standalone
  * `ComponentType`, and all of its transitive providers and collects providers.

package/import/typings/di/provider_token.d.ts

@@ -5,8 +5,8 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-import { AbstractType, Type } from "../interface/type";
-import { InjectionToken } from "./injection_token";
+import { AbstractType, Type } from '../interface/type';
+import { InjectionToken } from './injection_token';
 /**
  * @description
  *
@@ -14,4 +14,4 @@ import { InjectionToken } from "./injection_token";
  *
  * @publicApi
  */
-export declare type ProviderToken<T> = Type<T> | AbstractType<T> | InjectionToken<T>;
+export type ProviderToken<T> = Type<T> | AbstractType<T> | InjectionToken<T>;

package/import/typings/di/r3_injector.d.ts

@@ -8,13 +8,10 @@
 import { Injector } from './injector';
 import { InjectorType } from './interface/defs';
 import { InjectFlags, InjectOptions } from './interface/injector';
-import { ClassProvider, ConstructorProvider, ExistingProvider, FactoryProvider, Provider, StaticClassProvider, TypeProvider, ValueProvider } from './interface/provider';
+import { EnvironmentProviders, Provider } from './interface/provider';
+import { SingleProvider } from './provider_collection';
 import { ProviderToken } from './provider_token';
 import { InjectorScope } from './scope';
-/**
- * Internal type for a single provider in a deep provider array.
- */
-declare type SingleProvider = TypeProvider | ValueProvider | ClassProvider | ConstructorProvider | ExistingProvider | FactoryProvider | StaticClassProvider;
 export declare function getNullInjector(): Injector;
 /**
  * An `Injector` that's part of the environment injector hierarchy, which exists outside of the
@@ -91,7 +88,7 @@ export declare class R3Injector extends EnvironmentInjector {
     get destroyed(): boolean;
     private _destroyed;
     private injectorDefTypes;
-    constructor(providers: Array<Provider>, parent: Injector, source: string | null, scopes: Set<InjectorScope>);
+    constructor(providers: Array<Provider | EnvironmentProviders>, parent: Injector, source: string | null, scopes: Set<InjectorScope>);
     /**
      * Destroy the injector and release references to every instance or provider associated with it.
      *
@@ -119,5 +116,3 @@ export declare class R3Injector extends EnvironmentInjector {
  * @param provider provider to convert to factory
  */
 export declare function providerToFactory(provider: SingleProvider, ngModuleType?: InjectorType<any>, providers?: any[]): () => any;
-export declare function isTypeProvider(value: SingleProvider): value is TypeProvider;
-export {};

package/import/typings/di/scope.d.ts

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { InjectionToken } from './injection_token';
-export declare type InjectorScope = 'root' | 'platform' | 'environment';
+export type InjectorScope = 'root' | 'platform' | 'environment';
 /**
  * An internal token whose presence in an injector indicates that the injector should treat itself
  * as a root scoped injector when processing requests for unknown tokens which may indicate

package/import/typings/error_details_base_url.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * Base URL for the error details page.
+ *
+ * Keep this constant in sync across:
+ *  - packages/compiler-cli/src/ngtsc/diagnostics/src/error_details_base_url.ts
+ *  - packages/core/src/error_details_base_url.ts
+ */
+export declare const ERROR_DETAILS_PAGE_BASE_URL = "https://angular.io/errors";
+/**
+ * URL for the XSS security documentation.
+ */
+export declare const XSS_SECURITY_URL = "https://g.co/ng/security#xss";

package/import/typings/errors.d.ts

@@ -0,0 +1,89 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * The list of error codes used in runtime code of the `core` package.
+ * Reserved error code range: 100-999.
+ *
+ * Note: the minus sign denotes the fact that a particular code has a detailed guide on
+ * angular.io. This extra annotation is needed to avoid introducing a separate set to store
+ * error codes which have guides, which might leak into runtime code.
+ *
+ * Full list of available error guides can be found at https://angular.io/errors.
+ */
+export declare const enum RuntimeErrorCode {
+    EXPRESSION_CHANGED_AFTER_CHECKED = -100,
+    RECURSIVE_APPLICATION_REF_TICK = 101,
+    CYCLIC_DI_DEPENDENCY = -200,
+    PROVIDER_NOT_FOUND = -201,
+    INVALID_FACTORY_DEPENDENCY = 202,
+    MISSING_INJECTION_CONTEXT = -203,
+    INVALID_INJECTION_TOKEN = 204,
+    INJECTOR_ALREADY_DESTROYED = 205,
+    PROVIDER_IN_WRONG_CONTEXT = 207,
+    MISSING_INJECTION_TOKEN = 208,
+    INVALID_MULTI_PROVIDER = -209,
+    MULTIPLE_COMPONENTS_MATCH = -300,
+    EXPORT_NOT_FOUND = -301,
+    PIPE_NOT_FOUND = -302,
+    UNKNOWN_BINDING = 303,
+    UNKNOWN_ELEMENT = 304,
+    TEMPLATE_STRUCTURE_ERROR = 305,
+    INVALID_EVENT_BINDING = 306,
+    HOST_DIRECTIVE_UNRESOLVABLE = 307,
+    HOST_DIRECTIVE_NOT_STANDALONE = 308,
+    DUPLICATE_DIRECTITVE = 309,
+    HOST_DIRECTIVE_COMPONENT = 310,
+    HOST_DIRECTIVE_UNDEFINED_BINDING = 311,
+    HOST_DIRECTIVE_CONFLICTING_ALIAS = 312,
+    MULTIPLE_PLATFORMS = 400,
+    PLATFORM_NOT_FOUND = 401,
+    ERROR_HANDLER_NOT_FOUND = 402,
+    BOOTSTRAP_COMPONENTS_NOT_FOUND = -403,
+    PLATFORM_ALREADY_DESTROYED = 404,
+    ASYNC_INITIALIZERS_STILL_RUNNING = 405,
+    APPLICATION_REF_ALREADY_DESTROYED = 406,
+    RENDERER_NOT_FOUND = 407,
+    INVALID_I18N_STRUCTURE = 700,
+    MISSING_LOCALE_DATA = 701,
+    IMPORT_PROVIDERS_FROM_STANDALONE = 800,
+    INVALID_DIFFER_INPUT = 900,
+    NO_SUPPORTING_DIFFER_FACTORY = 901,
+    VIEW_ALREADY_ATTACHED = 902,
+    INVALID_INHERITANCE = 903,
+    UNSAFE_VALUE_IN_RESOURCE_URL = 904,
+    UNSAFE_VALUE_IN_SCRIPT = 905,
+    MISSING_GENERATED_DEF = 906,
+    TYPE_IS_NOT_STANDALONE = 907,
+    MISSING_ZONEJS = 908,
+    UNEXPECTED_ZONE_STATE = 909,
+    UNSAFE_IFRAME_ATTRS = -910
+}
+/**
+ * Class that represents a runtime error.
+ * Formats and outputs the error message in a consistent way.
+ *
+ * Example:
+ * ```
+ *  throw new RuntimeError(
+ *    RuntimeErrorCode.INJECTOR_ALREADY_DESTROYED,
+ *    ngDevMode && 'Injector has already been destroyed.');
+ * ```
+ *
+ * Note: the `message` argument contains a descriptive error message as a string in development
+ * mode (when the `ngDevMode` is defined). In production mode (after tree-shaking pass), the
+ * `message` argument becomes `false`, thus we account for it in the typings and the runtime logic.
+ */
+export declare class RuntimeError<T extends number = RuntimeErrorCode> extends Error {
+    code: T;
+    constructor(code: T, message: null | false | string);
+}
+/**
+ * Called to format a runtime error.
+ * See additional info on the `message` argument type in the `RuntimeError` class description.
+ */
+export declare function formatRuntimeError<T extends number = RuntimeErrorCode>(code: T, message: null | false | string): string;

package/import/typings/interface/type.d.ts

@@ -5,6 +5,18 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
+/**
+ * @description
+ *
+ * Represents a type that a Component or other object is instances of.
+ *
+ * An example of a `Type` is `MyCustomComponent` class, which in JavaScript is represented by
+ * the `MyCustomComponent` constructor function.
+ *
+ * @publicApi
+ */
+export declare const Type: FunctionConstructor;
+export declare function isType(v: any): v is Type<any>;
 /**
  * @description
  *
@@ -19,3 +31,36 @@ export interface AbstractType<T> extends Function {
 export interface Type<T> extends Function {
     new (...args: any[]): T;
 }
+export type Mutable<T extends {
+    [x: string]: any;
+}, K extends string> = {
+    [P in K]: T[P];
+};
+/**
+ * Returns a writable type version of type.
+ *
+ * USAGE:
+ * Given:
+ * ```
+ * interface Person {readonly name: string}
+ * ```
+ *
+ * We would like to get a read/write version of `Person`.
+ * ```
+ * const WritablePerson = Writable<Person>;
+ * ```
+ *
+ * The result is that you can do:
+ *
+ * ```
+ * const readonlyPerson: Person = {name: 'Marry'};
+ * readonlyPerson.name = 'John'; // TypeError
+ * (readonlyPerson as WritablePerson).name = 'John'; // OK
+ *
+ * // Error: Correctly detects that `Person` did not have `age` property.
+ * (readonlyPerson as WritablePerson).age = 30;
+ * ```
+ */
+export type Writable<T> = {
+    -readonly [K in keyof T]: T[K];
+};

package/import/typings/render3/definition_factory.d.ts

@@ -9,7 +9,7 @@ import { Type } from '../interface/type';
 /**
  * Definition of what a factory function should look like.
  */
-export declare type FactoryFn<T> = {
+export type FactoryFn<T> = {
     /**
      * Subclasses without an explicit constructor call through to the factory of their base
      * definition, providing it with their own constructor to instantiate.

package/import/typings/render3/errors_di.d.ts

@@ -1,2 +1,9 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
 /** Throws an error when a token is not found in DI. */
 export declare function throwProviderNotFoundError(token: any, injectorName?: string): never;

package/import/typings/render3/instructions/di.d.ts

@@ -1,10 +1,3 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
 /**
  * Throws an error indicating that a factory function could not be generated by the compiler for a
  * particular class.