@angular/core

  • Version 12.1.4
  • Published
  • 16.2 MB
  • 1 dependency
  • MIT license

Install

npm i @angular/core
yarn add @angular/core
pnpm add @angular/core

Overview

Angular - the core framework

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Variables

variable ANALYZE_FOR_ENTRY_COMPONENTS

const ANALYZE_FOR_ENTRY_COMPONENTS: InjectionToken<any>;
  • A DI token that you can use to create a virtual [provider](guide/glossary#provider) that will populate the entryComponents field of components and NgModules based on its useValue property value. All components that are referenced in the useValue value (either directly or in a nested array or map) are added to the entryComponents property.

    The following example shows how the router can populate the entryComponents field of an NgModule based on a router configuration that refers to components.

    // helper function inside the router
    function provideRoutes(routes) {
    return [
    {provide: ROUTES, useValue: routes},
    {provide: ANALYZE_FOR_ENTRY_COMPONENTS, useValue: routes, multi: true}
    ];
    }
    // user code
    let routes = [
    {path: '/root', component: RootComp},
    {path: '/teams', component: TeamsComp}
    ];
    @NgModule({
    providers: [provideRoutes(routes)]
    })
    class ModuleWithRoutes {}

    Deprecated

    Since 9.0.0. With Ivy, this property is no longer necessary.

variable APP_BOOTSTRAP_LISTENER

const APP_BOOTSTRAP_LISTENER: InjectionToken<
((compRef: ComponentRef<any>) => void)[]
>;
  • A [DI token](guide/glossary#di-token "DI token definition") that provides a set of callbacks to be called for every component that is bootstrapped.

    Each callback must take a ComponentRef instance and return nothing.

    (componentRef: ComponentRef) => void

variable APP_ID

const APP_ID: InjectionToken<string>;
  • A [DI token](guide/glossary#di-token "DI token definition") representing a unique string ID, used primarily for prefixing application attributes and CSS styles when is being used.

    BY default, the value is randomly generated and assigned to the application by Angular. To provide a custom ID value, use a DI provider <!-- TODO: provider --> to configure the root Injector that uses this token.

variable APP_INITIALIZER

const APP_INITIALIZER: InjectionToken<
readonly (() => Observable<unknown> | Promise<unknown> | void)[]
>;
  • A [DI token](guide/glossary#di-token "DI token definition") that you can use to provide one or more initialization functions.

    The provided functions are injected at application startup and executed during app initialization. If any of these functions returns a Promise or an Observable, initialization does not complete until the Promise is resolved or the Observable is completed.

    You can, for example, create a factory function that loads language data or an external configuration, and provide that function to the APP_INITIALIZER token. The function is executed during the application bootstrap process, and the needed data is available on startup.

    See Also

    • ApplicationInitStatus

      The following example illustrates how to configure a multi-provider using APP_INITIALIZER token and a function returning a promise.

      function initializeApp(): Promise<any> {
      return new Promise((resolve, reject) => {
      // Do some asynchronous stuff
      resolve();
      });
      }
      @NgModule({
      imports: [BrowserModule],
      declarations: [AppComponent],
      bootstrap: [AppComponent],
      providers: [{
      provide: APP_INITIALIZER,
      useFactory: () => initializeApp,
      multi: true
      }]
      })
      export class AppModule {}

      It's also possible to configure a multi-provider using APP_INITIALIZER token and a function returning an observable, see an example below. Note: the HttpClient in this example is used for demo purposes to illustrate how the factory function can work with other providers available through DI.

      function initializeAppFactory(httpClient: HttpClient): () => Observable<any> {
      return () => httpClient.get("https://someUrl.com/api/user")
      .pipe(
      tap(user => { ... })
      );
      }
      @NgModule({
      imports: [BrowserModule, HttpClientModule],
      declarations: [AppComponent],
      bootstrap: [AppComponent],
      providers: [{
      provide: APP_INITIALIZER,
      useFactory: initializeAppFactory,
      deps: [HttpClient],
      multi: true
      }]
      })
      export class AppModule {}

variable Attribute

const Attribute: AttributeDecorator;
  • Attribute decorator and metadata.

variable CHILD_HEAD

const CHILD_HEAD: number;

    variable CHILD_TAIL

    const CHILD_TAIL: number;

      variable CLEANUP

      const CLEANUP: number;

        variable COMPILER_OPTIONS

        const COMPILER_OPTIONS: InjectionToken<CompilerOptions[]>;
        • Token to provide CompilerOptions in the platform injector.

        variable Component

        const Component: ComponentDecorator;
        • Component decorator and metadata.

        variable ContentChild

        const ContentChild: ContentChildDecorator;
        • ContentChild decorator and metadata.

        variable ContentChildren

        const ContentChildren: ContentChildrenDecorator;
        • ContentChildren decorator and metadata.

        variable CONTEXT

        const CONTEXT: number;

          variable CUSTOM_ELEMENTS_SCHEMA

          const CUSTOM_ELEMENTS_SCHEMA: SchemaMetadata;
          • Defines a schema that allows an NgModule to contain the following: - Non-Angular elements named with dash case (-). - Element properties named with dash case (-). Dash case is the naming convention for custom elements.

          variable DebugElement

          const DebugElement: new (...args: any[]) => DebugElement;

          variable DebugNode

          const DebugNode: new (...args: any[]) => DebugNode;

          variable DECLARATION_COMPONENT_VIEW

          const DECLARATION_COMPONENT_VIEW: number;

            variable DECLARATION_LCONTAINER

            const DECLARATION_LCONTAINER: number;

              variable DECLARATION_VIEW

              const DECLARATION_VIEW: number;

                variable DEFAULT_CURRENCY_CODE

                const DEFAULT_CURRENCY_CODE: InjectionToken<string>;
                • Provide this token to set the default currency code your application uses for CurrencyPipe when there is no currency code passed into it. This is only used by CurrencyPipe and has no relation to locale currency. Defaults to USD if not configured.

                  See the [i18n guide](guide/i18n#setting-up-locale) for more information.

                  **Deprecation notice:**

                  The default currency code is currently always USD but this is deprecated from v9.

                  **In v10 the default currency code will be taken from the current locale.**

                  If you need the previous behavior then set it by creating a DEFAULT_CURRENCY_CODE provider in your application NgModule:

                  {provide: DEFAULT_CURRENCY_CODE, useValue: 'USD'}

                  ### Example

                  import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
                  import { AppModule } from './app/app.module';
                  platformBrowserDynamic().bootstrapModule(AppModule, {
                  providers: [{provide: DEFAULT_CURRENCY_CODE, useValue: 'EUR' }]
                  });

                variable defineInjectable

                const defineInjectable: <T>(opts: {
                token: unknown;
                providedIn?: Type<any> | 'root' | 'platform' | 'any';
                factory: () => T;
                }) => unknown;
                • Deprecated

                  in v8, delete after v10. This API should be used only by generated code, and that code should now use ɵɵdefineInjectable instead.

                variable Directive

                const Directive: DirectiveDecorator;
                • Type of the Directive metadata.

                variable ELEMENT_MARKER

                const ELEMENT_MARKER: ELEMENT_MARKER;
                • Marks that the next string is an element name.

                  See I18nMutateOpCodes documentation.

                variable EventEmitter

                const EventEmitter: {
                new (isAsync?: boolean): EventEmitter<any>;
                new <T>(isAsync?: boolean): EventEmitter<T>;
                readonly prototype: EventEmitter<any>;
                };

                variable FLAGS

                const FLAGS: number;

                  variable HAS_TRANSPLANTED_VIEWS

                  const HAS_TRANSPLANTED_VIEWS: number;
                  • Flag to signify that this LContainer may have transplanted views which need to be change detected. (see: LView[DECLARATION_COMPONENT_VIEW]).

                    This flag, once set, is never unset for the LContainer. This means that when unset we can skip a lot of work in refreshEmbeddedViews. But when set we still need to verify that the MOVED_VIEWS are transplanted and on-push.

                  variable Host

                  const Host: HostDecorator;
                  • Host decorator and metadata.

                  variable HOST

                  const HOST: number;

                    variable HostBinding

                    const HostBinding: HostBindingDecorator;

                    variable HostListener

                    const HostListener: HostListenerDecorator;
                    • Decorator that binds a DOM event to a host listener and supplies configuration metadata. Angular invokes the supplied handler method when the host element emits the specified event, and updates the bound element with the result.

                      If the handler method returns false, applies preventDefault on the bound element.

                      The following example declares a directive that attaches a click listener to a button and counts clicks.

                      @Directive({selector: 'button[counting]'})
                      class CountClicks {
                      numberOfClicks = 0;
                      @HostListener('click', ['$event.target'])
                      onClick(btn) {
                      console.log('button', btn, 'number of clicks:', this.numberOfClicks++);
                      }
                      }
                      @Component({
                      selector: 'app',
                      template: '<button counting>Increment</button>',
                      })
                      class App {}

                      The following example registers another DOM event handler that listens for key-press events.

                      import { HostListener, Component } from "@angular/core";
                      @Component({
                      selector: 'app',
                      template: `<h1>Hello, you have pressed keys {{counter}} number of times!</h1> Press any key to
                      increment the counter.
                      <button (click)="resetCounter()">Reset Counter</button>`
                      })
                      class AppComponent {
                      counter = 0;
                      @HostListener('window:keydown', ['$event'])
                      handleKeyDown(event: KeyboardEvent) {
                      this.counter++;
                      }
                      resetCounter() {
                      this.counter = 0;
                      }
                      }

                    variable ICU_MARKER

                    const ICU_MARKER: ICU_MARKER;
                    • Marks that the next string is comment text need for ICU.

                      See I18nMutateOpCodes documentation.

                    variable inject

                    const inject: {
                    <T>(token: ProviderToken<T>): T;
                    <T>(token: ProviderToken<T>, flags?: InjectFlags): T;
                    };
                    • 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.

                      Within such a factory function, using this function to request injection of a dependency is faster and more type-safe than providing an additional array of dependencies (as has been common with useFactory providers).

                      Parameter token

                      The injection token for the dependency to be injected.

                      Parameter flags

                      Optional flags that control how injection is executed. The flags correspond to injection strategies that can be specified with parameter decorators @Host, @Self, @SkipSef, and @Optional.

                      Returns

                      the injected value if injection is successful, null otherwise.

                      ### Example

                    variable Inject

                    const Inject: InjectDecorator;
                    • Inject decorator and metadata.

                    variable Injectable

                    const Injectable: InjectableDecorator;
                    • Injectable decorator and metadata.

                    variable INJECTOR

                    const INJECTOR: InjectionToken<Injector>;
                    • An InjectionToken that gets the current Injector for createInjector()-style injectors.

                      Requesting this token instead of Injector allows StaticInjector to be tree-shaken from a project.

                    variable INJECTOR_2

                    const INJECTOR_2: number;

                      variable Input

                      const Input: InputDecorator;

                      variable LOCALE_ID

                      const LOCALE_ID: InjectionToken<string>;
                      • Provide this token to set the locale of your application. It is used for i18n extraction, by i18n pipes (DatePipe, I18nPluralPipe, CurrencyPipe, DecimalPipe and PercentPipe) and by ICU expressions.

                        See the [i18n guide](guide/i18n#setting-up-locale) for more information.

                        ### Example

                        import { LOCALE_ID } from '@angular/core';
                        import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
                        import { AppModule } from './app/app.module';
                        platformBrowserDynamic().bootstrapModule(AppModule, {
                        providers: [{provide: LOCALE_ID, useValue: 'en-US' }]
                        });

                      variable MOVED_VIEWS

                      const MOVED_VIEWS: number;

                        variable NATIVE

                        const NATIVE: number;

                          variable NEXT

                          const NEXT: number;

                            variable NgModule

                            const NgModule: NgModuleDecorator;

                            variable NO_ERRORS_SCHEMA

                            const NO_ERRORS_SCHEMA: SchemaMetadata;
                            • Defines a schema that allows any property on any element.

                              This schema allows you to ignore the errors related to any unknown elements or properties in a template. The usage of this schema is generally discouraged because it prevents useful validation and may hide real errors in your template. Consider using the CUSTOM_ELEMENTS_SCHEMA instead.

                            variable Optional

                            const Optional: OptionalDecorator;
                            • Optional decorator and metadata.

                            variable Output

                            const Output: OutputDecorator;

                            variable ɵALLOW_MULTIPLE_PLATFORMS

                            const ɵALLOW_MULTIPLE_PLATFORMS: InjectionToken<boolean>;

                              variable ɵangular_packages_core_core_bb

                              const ɵangular_packages_core_core_bb: string;
                              • USD currency code that the application uses by default for CurrencyPipe when no DEFAULT_CURRENCY_CODE is provided.

                              variable ɵangular_packages_core_core_bf

                              const ɵangular_packages_core_core_bf: InjectionToken<(fn: () => void) => void>;
                              • A change detection scheduler token for RootContext. This token is the default value used for the default RootContext found in the ROOT_CONTEXT token.

                              variable ɵangular_packages_core_core_z

                              const ɵangular_packages_core_core_z: StaticProvider[];
                              • A built-in [dependency injection token](guide/glossary#di-token) that is used to configure the root injector for bootstrapping.

                              variable ɵAPP_ID_RANDOM_PROVIDER

                              const ɵAPP_ID_RANDOM_PROVIDER: {
                              provide: InjectionToken<string>;
                              useFactory: typeof ɵangular_packages_core_core_g;
                              deps: any[];
                              };
                              • Providers that generate a random APP_ID_TOKEN.

                              variable ɵDEFAULT_LOCALE_ID

                              const ɵDEFAULT_LOCALE_ID: string;
                              • The locale id that the application is using by default (for translations and ICU expressions).

                              variable ɵdefaultIterableDiffers

                              const ɵdefaultIterableDiffers: IterableDiffers;

                                variable ɵdefaultKeyValueDiffers

                                const ɵdefaultKeyValueDiffers: KeyValueDiffers;

                                  variable ɵEMPTY_ARRAY

                                  const ɵEMPTY_ARRAY: any[];

                                    variable ɵEMPTY_MAP

                                    const ɵEMPTY_MAP: { [key: string]: any };

                                      variable ɵglobal

                                      const ɵglobal: any;

                                        variable ɵINJECTOR_SCOPE

                                        const ɵINJECTOR_SCOPE: InjectionToken<'root' | 'platform'>;
                                        • 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 they are provided in the root scope.

                                        variable ɵivyEnabled

                                        const ɵivyEnabled: boolean;

                                          variable ɵNG_COMP_DEF

                                          const ɵNG_COMP_DEF: string;

                                            variable ɵNG_DIR_DEF

                                            const ɵNG_DIR_DEF: string;

                                              variable ɵNG_ELEMENT_ID

                                              const ɵNG_ELEMENT_ID: string;
                                              • If a directive is diPublic, bloomAdd sets a property on the type with this constant as the key and the directive's unique ID as the value. This allows us to map directives to their bloom filter bit for DI.

                                              variable ɵNG_INJ_DEF

                                              const ɵNG_INJ_DEF: string;

                                                variable ɵNG_MOD_DEF

                                                const ɵNG_MOD_DEF: string;

                                                  variable ɵNG_PIPE_DEF

                                                  const ɵNG_PIPE_DEF: string;

                                                    variable ɵNG_PROV_DEF

                                                    const ɵNG_PROV_DEF: string;

                                                      variable ɵNO_CHANGE

                                                      const ɵNO_CHANGE: ɵNO_CHANGE;
                                                      • A special value which designates that a value has not changed.

                                                      variable ɵNOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR

                                                      const ɵNOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR: {};

                                                        variable ɵSWITCH_CHANGE_DETECTOR_REF_FACTORY__POST_R3__

                                                        const ɵSWITCH_CHANGE_DETECTOR_REF_FACTORY__POST_R3__: (
                                                        flags: InjectFlags
                                                        ) => ChangeDetectorRef;

                                                          variable ɵSWITCH_COMPILE_COMPONENT__POST_R3__

                                                          const ɵSWITCH_COMPILE_COMPONENT__POST_R3__: (
                                                          type: Type<any>,
                                                          metadata: Component
                                                          ) => void;

                                                            variable ɵSWITCH_COMPILE_DIRECTIVE__POST_R3__

                                                            const ɵSWITCH_COMPILE_DIRECTIVE__POST_R3__: (
                                                            type: Type<any>,
                                                            directive: Directive
                                                            ) => void;

                                                              variable ɵSWITCH_COMPILE_INJECTABLE__POST_R3__

                                                              const ɵSWITCH_COMPILE_INJECTABLE__POST_R3__: (
                                                              type: Type<any>,
                                                              meta?: Injectable
                                                              ) => void;

                                                                variable ɵSWITCH_COMPILE_NGMODULE__POST_R3__

                                                                const ɵSWITCH_COMPILE_NGMODULE__POST_R3__: (
                                                                moduleType: Type<any>,
                                                                ngModule?: NgModule
                                                                ) => void;

                                                                  variable ɵSWITCH_COMPILE_PIPE__POST_R3__

                                                                  const ɵSWITCH_COMPILE_PIPE__POST_R3__: (type: Type<any>, meta: Pipe) => void;

                                                                    variable ɵSWITCH_ELEMENT_REF_FACTORY__POST_R3__

                                                                    const ɵSWITCH_ELEMENT_REF_FACTORY__POST_R3__: () => ElementRef<any>;

                                                                      variable ɵSWITCH_IVY_ENABLED__POST_R3__

                                                                      const ɵSWITCH_IVY_ENABLED__POST_R3__: boolean;

                                                                        variable ɵSWITCH_RENDERER2_FACTORY__POST_R3__

                                                                        const ɵSWITCH_RENDERER2_FACTORY__POST_R3__: () => Renderer2;

                                                                          variable ɵSWITCH_TEMPLATE_REF_FACTORY__POST_R3__

                                                                          const ɵSWITCH_TEMPLATE_REF_FACTORY__POST_R3__: <T>() => TemplateRef<T>;

                                                                            variable ɵSWITCH_VIEW_CONTAINER_REF_FACTORY__POST_R3__

                                                                            const ɵSWITCH_VIEW_CONTAINER_REF_FACTORY__POST_R3__: () => ViewContainerRef;

                                                                              variable PACKAGE_ROOT_URL

                                                                              const PACKAGE_ROOT_URL: InjectionToken<string>;
                                                                              • A [DI token](guide/glossary#di-token "DI token definition") that indicates the root directory of the application

                                                                              variable PARENT

                                                                              const PARENT: number;

                                                                                variable Pipe

                                                                                const Pipe: PipeDecorator;

                                                                                variable PLATFORM_ID

                                                                                const PLATFORM_ID: InjectionToken<Object>;
                                                                                • A token that indicates an opaque platform ID.

                                                                                variable PLATFORM_INITIALIZER

                                                                                const PLATFORM_INITIALIZER: InjectionToken<(() => void)[]>;
                                                                                • A function that is executed when a platform is initialized.

                                                                                variable PREORDER_HOOK_FLAGS

                                                                                const PREORDER_HOOK_FLAGS: number;

                                                                                  variable QUERIES

                                                                                  const QUERIES: number;

                                                                                    variable RENDERER

                                                                                    const RENDERER: number;

                                                                                      variable RENDERER_FACTORY

                                                                                      const RENDERER_FACTORY: number;

                                                                                        variable SANITIZER

                                                                                        const SANITIZER: number;

                                                                                          variable Self

                                                                                          const Self: SelfDecorator;
                                                                                          • Self decorator and metadata.

                                                                                          variable SkipSelf

                                                                                          const SkipSelf: SkipSelfDecorator;
                                                                                          • SkipSelf decorator and metadata.

                                                                                          variable T_HOST

                                                                                          const T_HOST: number;

                                                                                            variable TRANSLATIONS

                                                                                            const TRANSLATIONS: InjectionToken<string>;
                                                                                            • Use this token at bootstrap to provide the content of your translation file (xtb, xlf or xlf2) when you want to translate your application in another language.

                                                                                              See the [i18n guide](guide/i18n#merge) for more information.

                                                                                              ### Example

                                                                                              import { TRANSLATIONS } from '@angular/core';
                                                                                              import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
                                                                                              import { AppModule } from './app/app.module';
                                                                                              // content of your translation file
                                                                                              const translations = '....';
                                                                                              platformBrowserDynamic().bootstrapModule(AppModule, {
                                                                                              providers: [{provide: TRANSLATIONS, useValue: translations }]
                                                                                              });

                                                                                            variable TRANSLATIONS_FORMAT

                                                                                            const TRANSLATIONS_FORMAT: InjectionToken<string>;
                                                                                            • Provide this token at bootstrap to set the format of your TRANSLATIONS: xtb, xlf or xlf2.

                                                                                              See the [i18n guide](guide/i18n#merge) for more information.

                                                                                              ### Example

                                                                                              import { TRANSLATIONS_FORMAT } from '@angular/core';
                                                                                              import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
                                                                                              import { AppModule } from './app/app.module';
                                                                                              platformBrowserDynamic().bootstrapModule(AppModule, {
                                                                                              providers: [{provide: TRANSLATIONS_FORMAT, useValue: 'xlf' }]
                                                                                              });

                                                                                            variable TRANSPLANTED_VIEWS_TO_REFRESH

                                                                                            const TRANSPLANTED_VIEWS_TO_REFRESH: number;

                                                                                              variable TVIEW

                                                                                              const TVIEW: number;

                                                                                                variable Type

                                                                                                const Type: FunctionConstructor;
                                                                                                • 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.

                                                                                                variable TYPE

                                                                                                const TYPE: number;
                                                                                                • Special location which allows easy identification of type. If we have an array which was retrieved from the LView and that array has true at TYPE location, we know it is LContainer.

                                                                                                variable VERSION

                                                                                                const VERSION: Version;

                                                                                                variable VIEW_REFS

                                                                                                const VIEW_REFS: number;

                                                                                                  variable ViewChild

                                                                                                  const ViewChild: ViewChildDecorator;
                                                                                                  • ViewChild decorator and metadata.

                                                                                                  variable ViewChildren

                                                                                                  const ViewChildren: ViewChildrenDecorator;
                                                                                                  • ViewChildren decorator and metadata.

                                                                                                  Functions

                                                                                                  function asNativeElements

                                                                                                  asNativeElements: (debugEls: DebugElement[]) => any;

                                                                                                  function assertPlatform

                                                                                                  assertPlatform: (requiredToken: any) => PlatformRef;
                                                                                                  • Checks that there is currently a platform that contains the given token as a provider.

                                                                                                  function compileInjectable

                                                                                                  compileInjectable: (type: Type<any>, meta?: Injectable) => void;
                                                                                                  • Compile an Angular injectable according to its Injectable metadata, and patch the resulting injectable def (ɵprov) onto the injectable type.

                                                                                                  function createPlatform

                                                                                                  createPlatform: (injector: Injector) => PlatformRef;
                                                                                                  • Creates a platform. Platforms must be created on launch using this function.

                                                                                                  function createPlatformFactory

                                                                                                  createPlatformFactory: (
                                                                                                  parentPlatformFactory: (extraProviders?: StaticProvider[]) => PlatformRef,
                                                                                                  name: string,
                                                                                                  providers?: StaticProvider[]
                                                                                                  ) => (extraProviders?: StaticProvider[]) => PlatformRef;
                                                                                                  • Creates a factory for a platform. Can be used to provide or override Providers specific to your application's runtime needs, such as PLATFORM_INITIALIZER and PLATFORM_ID.

                                                                                                    Parameter parentPlatformFactory

                                                                                                    Another platform factory to modify. Allows you to compose factories to build up configurations that might be required by different libraries or parts of the application.

                                                                                                    Parameter name

                                                                                                    Identifies the new platform factory.

                                                                                                    Parameter providers

                                                                                                    A set of dependency providers for platforms created with the new factory.

                                                                                                  function destroyPlatform

                                                                                                  destroyPlatform: () => void;
                                                                                                  • Destroys the current Angular platform and all Angular applications on the page. Destroys all modules and listeners registered with the platform.

                                                                                                  function enableProdMode

                                                                                                  enableProdMode: () => void;
                                                                                                  • Disable Angular's development mode, which turns off assertions and other checks within the framework.

                                                                                                    One important assertion this disables verifies that a change detection pass does not result in additional changes to any bindings (also known as unidirectional data flow).

                                                                                                  function forwardRef

                                                                                                  forwardRef: (forwardRefFn: ForwardRefFn) => Type<any>;
                                                                                                  • Allows to refer to references which are not yet defined.

                                                                                                    For instance, forwardRef is used when the token which we need to refer to for the purposes of DI is declared, but not yet defined. It is also used when the token which we use when creating a query is not yet defined.

                                                                                                    ### Example

                                                                                                  function getDebugNode

                                                                                                  getDebugNode: (nativeNode: any) => DebugNode | null;

                                                                                                  function getModuleFactory

                                                                                                  getModuleFactory: (id: string) => NgModuleFactory<any>;
                                                                                                  • Returns the NgModuleFactory with the given id, if it exists and has been loaded. Factories for modules that do not specify an id cannot be retrieved. Throws if the module cannot be found.

                                                                                                  function getPlatform

                                                                                                  getPlatform: () => PlatformRef | null;
                                                                                                  • Returns the current platform.

                                                                                                  function isDevMode

                                                                                                  isDevMode: () => boolean;
                                                                                                  • Returns whether Angular is in development mode. After called once, the value is locked and won't change any more.

                                                                                                    By default, this is true, unless a user calls enableProdMode before calling this.

                                                                                                  function ɵ_sanitizeHtml

                                                                                                  ɵ_sanitizeHtml: (
                                                                                                  defaultDoc: any,
                                                                                                  unsafeHtmlInput: string
                                                                                                  ) => TrustedHTML | string;
                                                                                                  • Sanitizes the given unsafe, untrusted HTML fragment, and returns HTML text that is safe to add to the DOM in a browser environment.

                                                                                                  function ɵ_sanitizeUrl

                                                                                                  ɵ_sanitizeUrl: (url: string) => string;

                                                                                                    function ɵallowSanitizationBypassAndThrow

                                                                                                    ɵallowSanitizationBypassAndThrow: {
                                                                                                    (value: any, type: ɵBypassType.Html): value is ɵSafeHtml;
                                                                                                    (value: any, type: ɵBypassType.ResourceUrl): value is ɵSafeResourceUrl;
                                                                                                    (value: any, type: ɵBypassType.Script): value is ɵSafeScript;
                                                                                                    (value: any, type: ɵBypassType.Style): value is ɵSafeStyle;
                                                                                                    (value: any, type: ɵBypassType.Url): value is ɵSafeUrl;
                                                                                                    (value: any, type: ɵBypassType): boolean;
                                                                                                    };

                                                                                                      function ɵand

                                                                                                      ɵand: (
                                                                                                      flags: ɵNodeFlags,
                                                                                                      matchedQueriesDsl: null | [string | number, ɵQueryValueType][],
                                                                                                      ngContentIndex: null | number,
                                                                                                      childCount: number,
                                                                                                      handleEvent?: null | ElementHandleEventFn,
                                                                                                      templateFactory?: ViewDefinitionFactory
                                                                                                      ) => NodeDef;

                                                                                                        function ɵangular_packages_core_core_a

                                                                                                        ɵangular_packages_core_core_a: (fn: any) => fn is () => any;
                                                                                                        • Checks whether a function is wrapped by a forwardRef.

                                                                                                        function ɵangular_packages_core_core_b

                                                                                                        ɵangular_packages_core_core_b: {
                                                                                                        <T>(token: ProviderToken<T>): T;
                                                                                                        <T>(token: ProviderToken<T>, flags?: InjectFlags): T;
                                                                                                        };

                                                                                                          function ɵangular_packages_core_core_ba

                                                                                                          ɵangular_packages_core_core_ba: (ngZone: NgZone) => (fn: () => void) => void;
                                                                                                          • Schedule work at next available slot.

                                                                                                            In Ivy this is just requestAnimationFrame. For compatibility reasons when bootstrapped using platformRef.bootstrap we need to use NgZone.onStable as the scheduling mechanism. This overrides the scheduling mechanism in Ivy to NgZone.onStable.

                                                                                                            Parameter ngZone

                                                                                                            NgZone to use for scheduling.

                                                                                                          function ɵangular_packages_core_core_bc

                                                                                                          ɵangular_packages_core_core_bc: (
                                                                                                          checkIndex: number,
                                                                                                          flags: ɵNodeFlags,
                                                                                                          matchedQueriesDsl: [string | number, ɵQueryValueType][] | null,
                                                                                                          childCount: number,
                                                                                                          token: any,
                                                                                                          value: any,
                                                                                                          deps: ([ɵDepFlags, any] | any)[],
                                                                                                          bindings?: BindingDef[],
                                                                                                          outputs?: OutputDef[]
                                                                                                          ) => NodeDef;

                                                                                                            function ɵangular_packages_core_core_be

                                                                                                            ɵangular_packages_core_core_be: <T>(
                                                                                                            definition: ɵDirectiveDef<T>
                                                                                                            ) => typeof rememberChangeHistoryAndInvokeOnChangesHook;

                                                                                                              function ɵangular_packages_core_core_bg

                                                                                                              ɵangular_packages_core_core_bg: (
                                                                                                              tNode: TNode,
                                                                                                              attrNameToInject: string
                                                                                                              ) => string | null;
                                                                                                              • Inject static attribute value into directive constructor.

                                                                                                                This method is used with factory functions which are generated as part of defineDirective or defineComponent. The method retrieves the static value of an attribute. (Dynamic attributes are not supported since they are not resolved at the time of injection and can change over time.)

                                                                                                                # Example Given:

                                                                                                                @Component(...)
                                                                                                                class MyComponent {
                                                                                                                constructor(@Attribute('title') title: string) { ... }
                                                                                                                }

                                                                                                                When instantiated with

                                                                                                                <my-component title="Hello"></my-component>

                                                                                                                Then factory method generated is:

                                                                                                                MyComponent.ɵcmp = defineComponent({
                                                                                                                factory: () => new MyComponent(injectAttribute('title'))
                                                                                                                ...
                                                                                                                })

                                                                                                              function ɵangular_packages_core_core_bh

                                                                                                              ɵangular_packages_core_core_bh: () => ɵangular_packages_core_core_ca;
                                                                                                              • Return the current LView.

                                                                                                              function ɵangular_packages_core_core_bi

                                                                                                              ɵangular_packages_core_core_bi: () => number;

                                                                                                                function ɵangular_packages_core_core_bj

                                                                                                                ɵangular_packages_core_core_bj: <T = any>(level: number) => T;

                                                                                                                  function ɵangular_packages_core_core_bl

                                                                                                                  ɵangular_packages_core_core_bl: (
                                                                                                                  lView: ɵangular_packages_core_core_ca,
                                                                                                                  bindingRoot: number,
                                                                                                                  slotOffset: number,
                                                                                                                  pureFn: (v: any) => any,
                                                                                                                  exp: any,
                                                                                                                  thisArg?: any
                                                                                                                  ) => any;
                                                                                                                  • If the value of the provided exp has changed, calls the pure function to return an updated value. Or if the value has not changed, returns cached value.

                                                                                                                    Parameter lView

                                                                                                                    LView in which the function is being executed.

                                                                                                                    Parameter bindingRoot

                                                                                                                    Binding root index.

                                                                                                                    Parameter slotOffset

                                                                                                                    the offset from binding root to the reserved slot

                                                                                                                    Parameter pureFn

                                                                                                                    Function that returns an updated value

                                                                                                                    Parameter exp

                                                                                                                    Updated expression value

                                                                                                                    Parameter thisArg

                                                                                                                    Optional calling context of pureFn

                                                                                                                    Returns

                                                                                                                    Updated or cached value

                                                                                                                  function ɵangular_packages_core_core_bm

                                                                                                                  ɵangular_packages_core_core_bm: (
                                                                                                                  lView: ɵangular_packages_core_core_ca,
                                                                                                                  bindingRoot: number,
                                                                                                                  slotOffset: number,
                                                                                                                  pureFn: (v1: any, v2: any) => any,
                                                                                                                  exp1: any,
                                                                                                                  exp2: any,
                                                                                                                  thisArg?: any
                                                                                                                  ) => any;
                                                                                                                  • If the value of any provided exp has changed, calls the pure function to return an updated value. Or if no values have changed, returns cached value.

                                                                                                                    Parameter lView

                                                                                                                    LView in which the function is being executed.

                                                                                                                    Parameter bindingRoot

                                                                                                                    Binding root index.

                                                                                                                    Parameter slotOffset

                                                                                                                    the offset from binding root to the reserved slot

                                                                                                                    Parameter pureFn

                                                                                                                    Parameter exp1

                                                                                                                    Parameter exp2

                                                                                                                    Parameter thisArg

                                                                                                                    Optional calling context of pureFn

                                                                                                                    Returns

                                                                                                                    Updated or cached value

                                                                                                                  function ɵangular_packages_core_core_bn

                                                                                                                  ɵangular_packages_core_core_bn: (
                                                                                                                  lView: ɵangular_packages_core_core_ca,
                                                                                                                  bindingRoot: number,
                                                                                                                  slotOffset: number,
                                                                                                                  pureFn: (v1: any, v2: any, v3: any) => any,
                                                                                                                  exp1: any,
                                                                                                                  exp2: any,
                                                                                                                  exp3: any,
                                                                                                                  thisArg?: any
                                                                                                                  ) => any;
                                                                                                                  • If the value of any provided exp has changed, calls the pure function to return an updated value. Or if no values have changed, returns cached value.

                                                                                                                    Parameter lView

                                                                                                                    LView in which the function is being executed.

                                                                                                                    Parameter bindingRoot

                                                                                                                    Binding root index.

                                                                                                                    Parameter slotOffset

                                                                                                                    the offset from binding root to the reserved slot

                                                                                                                    Parameter pureFn

                                                                                                                    Parameter exp1

                                                                                                                    Parameter exp2

                                                                                                                    Parameter exp3

                                                                                                                    Parameter thisArg

                                                                                                                    Optional calling context of pureFn

                                                                                                                    Returns

                                                                                                                    Updated or cached value

                                                                                                                  function ɵangular_packages_core_core_bo

                                                                                                                  ɵangular_packages_core_core_bo: (
                                                                                                                  lView: ɵangular_packages_core_core_ca,
                                                                                                                  bindingRoot: number,
                                                                                                                  slotOffset: number,
                                                                                                                  pureFn: (v1: any, v2: any, v3: any, v4: any) => any,
                                                                                                                  exp1: any,
                                                                                                                  exp2: any,
                                                                                                                  exp3: any,
                                                                                                                  exp4: any,
                                                                                                                  thisArg?: any
                                                                                                                  ) => any;
                                                                                                                  • If the value of any provided exp has changed, calls the pure function to return an updated value. Or if no values have changed, returns cached value.

                                                                                                                    Parameter lView

                                                                                                                    LView in which the function is being executed.

                                                                                                                    Parameter bindingRoot

                                                                                                                    Binding root index.

                                                                                                                    Parameter slotOffset

                                                                                                                    the offset from binding root to the reserved slot

                                                                                                                    Parameter pureFn

                                                                                                                    Parameter exp1

                                                                                                                    Parameter exp2

                                                                                                                    Parameter exp3

                                                                                                                    Parameter exp4

                                                                                                                    Parameter thisArg

                                                                                                                    Optional calling context of pureFn

                                                                                                                    Returns

                                                                                                                    Updated or cached value

                                                                                                                  function ɵangular_packages_core_core_bp

                                                                                                                  ɵangular_packages_core_core_bp: (
                                                                                                                  lView: ɵangular_packages_core_core_ca,
                                                                                                                  bindingRoot: number,
                                                                                                                  slotOffset: number,
                                                                                                                  pureFn: (...v: any[]) => any,
                                                                                                                  exps: any[],
                                                                                                                  thisArg?: any
                                                                                                                  ) => any;
                                                                                                                  • pureFunction instruction that can support any number of bindings.

                                                                                                                    If the value of any provided exp has changed, calls the pure function to return an updated value. Or if no values have changed, returns cached value.

                                                                                                                    Parameter lView

                                                                                                                    LView in which the function is being executed.

                                                                                                                    Parameter bindingRoot

                                                                                                                    Binding root index.

                                                                                                                    Parameter slotOffset

                                                                                                                    the offset from binding root to the reserved slot

                                                                                                                    Parameter pureFn

                                                                                                                    A pure function that takes binding values and builds an object or array containing those values.

                                                                                                                    Parameter exps

                                                                                                                    An array of binding values

                                                                                                                    Parameter thisArg

                                                                                                                    Optional calling context of pureFn

                                                                                                                    Returns

                                                                                                                    Updated or cached value

                                                                                                                  function ɵangular_packages_core_core_bq

                                                                                                                  ɵangular_packages_core_core_bq: (
                                                                                                                  tag: string,
                                                                                                                  prop: string
                                                                                                                  ) => typeof ɵɵsanitizeResourceUrl;
                                                                                                                  • Detects which sanitizer to use for URL property, based on tag name and prop name.

                                                                                                                    The rules are based on the RESOURCE_URL context config from packages/compiler/src/schema/dom_security_schema.ts. If tag and prop names don't match Resource URL schema, use URL sanitizer.

                                                                                                                  function ɵangular_packages_core_core_br

                                                                                                                  ɵangular_packages_core_core_br: (
                                                                                                                  name: string,
                                                                                                                  props?: (...args: any[]) => any,
                                                                                                                  parentClass?: any,
                                                                                                                  additionalProcessing?: (target: any, name: string, ...args: any[]) => void
                                                                                                                  ) => any;

                                                                                                                    function ɵangular_packages_core_core_bs

                                                                                                                    ɵangular_packages_core_core_bs: (
                                                                                                                    name: string,
                                                                                                                    props?: (...args: any[]) => any,
                                                                                                                    parentClass?: any
                                                                                                                    ) => any;

                                                                                                                      function ɵangular_packages_core_core_bv

                                                                                                                      ɵangular_packages_core_core_bv: <T>(objWithPropertyToExtract: T) => string;

                                                                                                                        function ɵangular_packages_core_core_bx

                                                                                                                        ɵangular_packages_core_core_bx: () => <T>(
                                                                                                                        token: ProviderToken<T>,
                                                                                                                        flags?: InjectFlags | undefined
                                                                                                                        ) => T;

                                                                                                                          function ɵangular_packages_core_core_bz

                                                                                                                          ɵangular_packages_core_core_bz: (
                                                                                                                          tNode: TNode,
                                                                                                                          lView: ɵangular_packages_core_core_ca
                                                                                                                          ) => RNode;
                                                                                                                          • Retrieve an RNode for a given TNode and LView.

                                                                                                                            This function guarantees in dev mode to retrieve a non-null RNode.

                                                                                                                            Parameter tNode

                                                                                                                            Parameter lView

                                                                                                                          function ɵangular_packages_core_core_c

                                                                                                                          ɵangular_packages_core_core_c: (
                                                                                                                          decorator: any,
                                                                                                                          flag: ɵangular_packages_core_core_bu | ɵangular_packages_core_core_bt
                                                                                                                          ) => any;
                                                                                                                          • Attaches a given InjectFlag to a given decorator using monkey-patching. Since DI decorators can be used in providers deps array (when provider is configured using useFactory) without initialization (e.g. Host) and as an instance (e.g. new Host()), we attach the flag to make it available both as a static property and as a field on decorator instance.

                                                                                                                            Parameter decorator

                                                                                                                            Provided DI decorator.

                                                                                                                            Parameter flag

                                                                                                                            InjectFlag that should be applied.

                                                                                                                          function ɵangular_packages_core_core_cb

                                                                                                                          ɵangular_packages_core_core_cb: (
                                                                                                                          viewOrComponent: ɵangular_packages_core_core_ca | {}
                                                                                                                          ) => RootContext;
                                                                                                                          • Returns the RootContext instance that is associated with the application where the target is situated. It does this by walking the parent views until it gets to the root view, then getting the context off of that.

                                                                                                                            Parameter viewOrComponent

                                                                                                                            the LView or component to get the root context for.

                                                                                                                          function ɵangular_packages_core_core_cc

                                                                                                                          ɵangular_packages_core_core_cc: (
                                                                                                                          message: string,
                                                                                                                          replacements?: { [key: string]: string | string[] }
                                                                                                                          ) => string;
                                                                                                                          • Handles message string post-processing for internationalization.

                                                                                                                            Handles message string post-processing by transforming it from intermediate format (that might contain some markers that we need to replace) to the final form, consumable by i18nStart instruction. Post processing steps include:

                                                                                                                            1. Resolve all multi-value cases (like [�*1:1��#2:1�|�#4:1�|�5�]) 2. Replace all ICU vars (like "VAR_PLURAL") 3. Replace all placeholders used inside ICUs in a form of {PLACEHOLDER} 4. Replace all ICU references with corresponding values (like �ICU_EXP_ICU_1�) in case multiple ICUs have the same placeholder name

                                                                                                                            Parameter message

                                                                                                                            Raw translation string for post processing

                                                                                                                            Parameter replacements

                                                                                                                            Set of replacements that should be applied

                                                                                                                            Returns

                                                                                                                            Transformed string that can be consumed by i18nStart instruction

                                                                                                                          function ɵangular_packages_core_core_f

                                                                                                                          ɵangular_packages_core_core_f: (
                                                                                                                          providers: Provider[]
                                                                                                                          ) => ResolvedReflectiveProvider[];
                                                                                                                          • Resolve a list of Providers.

                                                                                                                          function ɵangular_packages_core_core_g

                                                                                                                          ɵangular_packages_core_core_g: () => string;

                                                                                                                            function ɵangular_packages_core_core_h

                                                                                                                            ɵangular_packages_core_core_h: () => Renderer2;
                                                                                                                            • Injects a Renderer2 for the current component.

                                                                                                                            function ɵangular_packages_core_core_i

                                                                                                                            ɵangular_packages_core_core_i: () => ElementRef;
                                                                                                                            • Creates an ElementRef from the most recent node.

                                                                                                                              Returns

                                                                                                                              The ElementRef instance to use

                                                                                                                            function ɵangular_packages_core_core_j

                                                                                                                            ɵangular_packages_core_core_j: (
                                                                                                                            tNode: TNode,
                                                                                                                            lView: ɵangular_packages_core_core_ca
                                                                                                                            ) => ElementRef;
                                                                                                                            • Creates an ElementRef given a node.

                                                                                                                              Parameter tNode

                                                                                                                              The node for which you'd like an ElementRef

                                                                                                                              Parameter lView

                                                                                                                              The view to which the node belongs

                                                                                                                              Returns

                                                                                                                              The ElementRef instance to use

                                                                                                                            function ɵangular_packages_core_core_k

                                                                                                                            ɵangular_packages_core_core_k: (id: string) => NgModuleFactory<any>;

                                                                                                                              function ɵangular_packages_core_core_l

                                                                                                                              ɵangular_packages_core_core_l: <T>() => TemplateRef<T> | null;
                                                                                                                              • Creates a TemplateRef given a node.

                                                                                                                                Returns

                                                                                                                                The TemplateRef instance to use

                                                                                                                              function ɵangular_packages_core_core_m

                                                                                                                              ɵangular_packages_core_core_m: <T>(
                                                                                                                              hostTNode: TNode,
                                                                                                                              hostLView: ɵangular_packages_core_core_ca
                                                                                                                              ) => TemplateRef<T> | null;
                                                                                                                              • Creates a TemplateRef and stores it on the injector.

                                                                                                                                Parameter hostTNode

                                                                                                                                The node on which a TemplateRef is requested

                                                                                                                                Parameter hostLView

                                                                                                                                The LView to which the node belongs

                                                                                                                                Returns

                                                                                                                                The TemplateRef instance or null if we can't create a TemplateRef on a given node type

                                                                                                                              function ɵangular_packages_core_core_n

                                                                                                                              ɵangular_packages_core_core_n: () => ViewContainerRef;
                                                                                                                              • Creates a ViewContainerRef and stores it on the injector. Or, if the ViewContainerRef already exists, retrieves the existing ViewContainerRef.

                                                                                                                                Returns

                                                                                                                                The ViewContainerRef instance to use

                                                                                                                              function ɵangular_packages_core_core_q

                                                                                                                              ɵangular_packages_core_core_q: (nativeNode: any) => DebugNode | null;

                                                                                                                                function ɵangular_packages_core_core_r

                                                                                                                                ɵangular_packages_core_core_r: (flags: InjectFlags) => ChangeDetectorRef;
                                                                                                                                • Returns a ChangeDetectorRef (a.k.a. a ViewRef)

                                                                                                                                function ɵangular_packages_core_core_u

                                                                                                                                ɵangular_packages_core_core_u: () => IterableDiffers;

                                                                                                                                  function ɵangular_packages_core_core_v

                                                                                                                                  ɵangular_packages_core_core_v: () => KeyValueDiffers;

                                                                                                                                    function ɵangular_packages_core_core_w

                                                                                                                                    ɵangular_packages_core_core_w: () => IterableDiffers;

                                                                                                                                      function ɵangular_packages_core_core_x

                                                                                                                                      ɵangular_packages_core_core_x: () => KeyValueDiffers;

                                                                                                                                        function ɵangular_packages_core_core_y

                                                                                                                                        ɵangular_packages_core_core_y: (locale?: string) => string;

                                                                                                                                          function ɵbypassSanitizationTrustHtml

                                                                                                                                          ɵbypassSanitizationTrustHtml: (trustedHtml: string) => ɵSafeHtml;
                                                                                                                                          • Mark html string as trusted.

                                                                                                                                            This function wraps the trusted string in String and brands it in a way which makes it recognizable to htmlSanitizer to be trusted implicitly.

                                                                                                                                            Parameter trustedHtml

                                                                                                                                            html string which needs to be implicitly trusted.

                                                                                                                                            Returns

                                                                                                                                            a html which has been branded to be implicitly trusted.

                                                                                                                                          function ɵbypassSanitizationTrustResourceUrl

                                                                                                                                          ɵbypassSanitizationTrustResourceUrl: (
                                                                                                                                          trustedResourceUrl: string
                                                                                                                                          ) => ɵSafeResourceUrl;
                                                                                                                                          • Mark url string as trusted.

                                                                                                                                            This function wraps the trusted string in String and brands it in a way which makes it recognizable to resourceUrlSanitizer to be trusted implicitly.

                                                                                                                                            Parameter trustedResourceUrl

                                                                                                                                            url string which needs to be implicitly trusted.

                                                                                                                                            Returns

                                                                                                                                            a url which has been branded to be implicitly trusted.

                                                                                                                                          function ɵbypassSanitizationTrustScript

                                                                                                                                          ɵbypassSanitizationTrustScript: (trustedScript: string) => ɵSafeScript;
                                                                                                                                          • Mark script string as trusted.

                                                                                                                                            This function wraps the trusted string in String and brands it in a way which makes it recognizable to scriptSanitizer to be trusted implicitly.

                                                                                                                                            Parameter trustedScript

                                                                                                                                            script string which needs to be implicitly trusted.

                                                                                                                                            Returns

                                                                                                                                            a script which has been branded to be implicitly trusted.

                                                                                                                                          function ɵbypassSanitizationTrustStyle

                                                                                                                                          ɵbypassSanitizationTrustStyle: (trustedStyle: string) => ɵSafeStyle;
                                                                                                                                          • Mark style string as trusted.

                                                                                                                                            This function wraps the trusted string in String and brands it in a way which makes it recognizable to styleSanitizer to be trusted implicitly.

                                                                                                                                            Parameter trustedStyle

                                                                                                                                            style string which needs to be implicitly trusted.

                                                                                                                                            Returns

                                                                                                                                            a style hich has been branded to be implicitly trusted.

                                                                                                                                          function ɵbypassSanitizationTrustUrl

                                                                                                                                          ɵbypassSanitizationTrustUrl: (trustedUrl: string) => ɵSafeUrl;
                                                                                                                                          • Mark url string as trusted.

                                                                                                                                            This function wraps the trusted string in String and brands it in a way which makes it recognizable to urlSanitizer to be trusted implicitly.

                                                                                                                                            Parameter trustedUrl

                                                                                                                                            url string which needs to be implicitly trusted.

                                                                                                                                            Returns

                                                                                                                                            a url which has been branded to be implicitly trusted.

                                                                                                                                          function ɵccf

                                                                                                                                          ɵccf: (
                                                                                                                                          selector: string,
                                                                                                                                          componentType: Type<any>,
                                                                                                                                          viewDefFactory: ViewDefinitionFactory,
                                                                                                                                          inputs: { [propName: string]: string },
                                                                                                                                          outputs: { [propName: string]: string },
                                                                                                                                          ngContentSelectors: string[]
                                                                                                                                          ) => ComponentFactory<any>;

                                                                                                                                            function ɵclearOverrides

                                                                                                                                            ɵclearOverrides: () => void;

                                                                                                                                              function ɵclearResolutionOfComponentResourcesQueue

                                                                                                                                              ɵclearResolutionOfComponentResourcesQueue: () => Map<Type<any>, Component>;

                                                                                                                                                function ɵcmf

                                                                                                                                                ɵcmf: (
                                                                                                                                                ngModuleType: Type<any>,
                                                                                                                                                bootstrapComponents: Type<any>[],
                                                                                                                                                defFactory: NgModuleDefinitionFactory
                                                                                                                                                ) => NgModuleFactory<any>;

                                                                                                                                                  function ɵcompileComponent

                                                                                                                                                  ɵcompileComponent: (type: Type<any>, metadata: Component) => void;
                                                                                                                                                  • Compile an Angular component according to its decorator metadata, and patch the resulting component def (ɵcmp) onto the component type.

                                                                                                                                                    Compilation may be asynchronous (due to the need to resolve URLs for the component template or other resources, for example). In the event that compilation is not immediate, compileComponent will enqueue resource resolution into a global queue and will fail to return the ɵcmp until the global queue has been resolved with a call to resolveComponentResources.

                                                                                                                                                  function ɵcompileDirective

                                                                                                                                                  ɵcompileDirective: (type: Type<any>, directive: Directive | null) => void;
                                                                                                                                                  • Compile an Angular directive according to its decorator metadata, and patch the resulting directive def onto the component type.

                                                                                                                                                    In the event that compilation is not immediate, compileDirective will return a Promise which will resolve when compilation completes and the directive becomes usable.

                                                                                                                                                  function ɵcompileNgModule

                                                                                                                                                  ɵcompileNgModule: (moduleType: Type<any>, ngModule?: NgModule) => void;
                                                                                                                                                  • Compiles a module in JIT mode.

                                                                                                                                                    This function automatically gets called when a class has a @NgModule decorator.

                                                                                                                                                  function ɵcompileNgModuleDefs

                                                                                                                                                  ɵcompileNgModuleDefs: (
                                                                                                                                                  moduleType: ɵNgModuleType,
                                                                                                                                                  ngModule: NgModule,
                                                                                                                                                  allowDuplicateDeclarationsInRoot?: boolean
                                                                                                                                                  ) => void;
                                                                                                                                                  • Compiles and adds the ɵmod, ɵfac and ɵinj properties to the module class.

                                                                                                                                                    It's possible to compile a module via this API which will allow duplicate declarations in its root.

                                                                                                                                                  function ɵcompileNgModuleFactory__POST_R3__

                                                                                                                                                  ɵcompileNgModuleFactory__POST_R3__: <M>(
                                                                                                                                                  injector: Injector,
                                                                                                                                                  options: CompilerOptions,
                                                                                                                                                  moduleType: Type<M>
                                                                                                                                                  ) => Promise<NgModuleFactory<M>>;

                                                                                                                                                    function ɵcompilePipe

                                                                                                                                                    ɵcompilePipe: (type: Type<any>, meta: Pipe) => void;

                                                                                                                                                      function ɵCompiler_compileModuleAndAllComponentsAsync__POST_R3__

                                                                                                                                                      ɵCompiler_compileModuleAndAllComponentsAsync__POST_R3__: <T>(
                                                                                                                                                      moduleType: Type<T>
                                                                                                                                                      ) => Promise<ModuleWithComponentFactories<T>>;

                                                                                                                                                        function ɵCompiler_compileModuleAndAllComponentsSync__POST_R3__

                                                                                                                                                        ɵCompiler_compileModuleAndAllComponentsSync__POST_R3__: <T>(
                                                                                                                                                        moduleType: Type<T>
                                                                                                                                                        ) => ModuleWithComponentFactories<T>;

                                                                                                                                                          function ɵCompiler_compileModuleAsync__POST_R3__

                                                                                                                                                          ɵCompiler_compileModuleAsync__POST_R3__: <T>(
                                                                                                                                                          moduleType: Type<T>
                                                                                                                                                          ) => Promise<NgModuleFactory<T>>;

                                                                                                                                                            function ɵCompiler_compileModuleSync__POST_R3__

                                                                                                                                                            ɵCompiler_compileModuleSync__POST_R3__: <T>(
                                                                                                                                                            moduleType: Type<T>
                                                                                                                                                            ) => NgModuleFactory<T>;

                                                                                                                                                              function ɵCREATE_ATTRIBUTE_DECORATOR__POST_R3__

                                                                                                                                                              ɵCREATE_ATTRIBUTE_DECORATOR__POST_R3__: () => AttributeDecorator;

                                                                                                                                                                function ɵcreateInjector

                                                                                                                                                                ɵcreateInjector: (
                                                                                                                                                                defType: any,
                                                                                                                                                                parent?: Injector | null,
                                                                                                                                                                additionalProviders?: StaticProvider[] | null,
                                                                                                                                                                name?: string
                                                                                                                                                                ) => Injector;
                                                                                                                                                                • Create a new Injector which is configured using a defType of InjectorType<any>s.

                                                                                                                                                                function ɵcrt

                                                                                                                                                                ɵcrt: (values: {
                                                                                                                                                                styles: (string | any[])[];
                                                                                                                                                                encapsulation: ViewEncapsulation;
                                                                                                                                                                data: { [kind: string]: any[] };
                                                                                                                                                                }) => RendererType2;

                                                                                                                                                                  function ɵdetectChanges

                                                                                                                                                                  ɵdetectChanges: (component: {}) => void;
                                                                                                                                                                  • Synchronously perform change detection on a component (and possibly its sub-components).

                                                                                                                                                                    This function triggers change detection in a synchronous way on a component.

                                                                                                                                                                    Parameter component

                                                                                                                                                                    The component which the change detection should be performed on.

                                                                                                                                                                  function ɵdevModeEqual

                                                                                                                                                                  ɵdevModeEqual: (a: any, b: any) => boolean;

                                                                                                                                                                    function ɵdid

                                                                                                                                                                    ɵdid: (
                                                                                                                                                                    checkIndex: number,
                                                                                                                                                                    flags: ɵNodeFlags,
                                                                                                                                                                    matchedQueries: null | [string | number, ɵQueryValueType][],
                                                                                                                                                                    childCount: number,
                                                                                                                                                                    ctor: any,
                                                                                                                                                                    deps: ([ɵDepFlags, any] | any)[],
                                                                                                                                                                    props?: { [name: string]: [number, string] },
                                                                                                                                                                    outputs?: { [name: string]: string }
                                                                                                                                                                    ) => NodeDef;

                                                                                                                                                                      function ɵeld

                                                                                                                                                                      ɵeld: (
                                                                                                                                                                      checkIndex: number,
                                                                                                                                                                      flags: ɵNodeFlags,
                                                                                                                                                                      matchedQueriesDsl: null | [string | number, ɵQueryValueType][],
                                                                                                                                                                      ngContentIndex: null | number,
                                                                                                                                                                      childCount: number,
                                                                                                                                                                      namespaceAndName: string | null,
                                                                                                                                                                      fixedAttrs?: null | [string, string][],
                                                                                                                                                                      bindings?: null | [ɵBindingFlags, string, string | SecurityContext | null][],
                                                                                                                                                                      outputs?: null | [string, string][],
                                                                                                                                                                      handleEvent?: null | ElementHandleEventFn,
                                                                                                                                                                      componentView?: null | ViewDefinitionFactory,
                                                                                                                                                                      componentRendererType?: RendererType2 | null
                                                                                                                                                                      ) => NodeDef;

                                                                                                                                                                        function ɵfindLocaleData

                                                                                                                                                                        ɵfindLocaleData: (locale: string) => any;
                                                                                                                                                                        • Finds the locale data for a given locale.

                                                                                                                                                                          Parameter locale

                                                                                                                                                                          The locale code.

                                                                                                                                                                          Returns

                                                                                                                                                                          The locale data.

                                                                                                                                                                          See Also

                                                                                                                                                                          • [Internationalization (i18n) Guide](https://angular.io/guide/i18n)

                                                                                                                                                                        function ɵflushModuleScopingQueueAsMuchAsPossible

                                                                                                                                                                        ɵflushModuleScopingQueueAsMuchAsPossible: () => void;
                                                                                                                                                                        • Loops over queued module definitions, if a given module definition has all of its declarations resolved, it dequeues that module definition and sets the scope on its declarations.

                                                                                                                                                                        function ɵgetComponentViewDefinitionFactory

                                                                                                                                                                        ɵgetComponentViewDefinitionFactory: (
                                                                                                                                                                        componentFactory: ComponentFactory<any>
                                                                                                                                                                        ) => ViewDefinitionFactory;

                                                                                                                                                                          function ɵgetDebugNode__POST_R3__

                                                                                                                                                                          ɵgetDebugNode__POST_R3__: {
                                                                                                                                                                          (nativeNode: Element): DebugElement__POST_R3__;
                                                                                                                                                                          (nativeNode: Node): DebugNode__POST_R3__;
                                                                                                                                                                          (nativeNode: null): null;
                                                                                                                                                                          };

                                                                                                                                                                            function ɵgetDebugNodeR2

                                                                                                                                                                            ɵgetDebugNodeR2: (nativeNode: any) => DebugNode | null;

                                                                                                                                                                              function ɵgetDirectives

                                                                                                                                                                              ɵgetDirectives: (node: Node) => {}[];
                                                                                                                                                                              • Retrieves directive instances associated with a given DOM node. Does not include component instances.

                                                                                                                                                                                Given the following DOM structure:

                                                                                                                                                                                <app-root>
                                                                                                                                                                                <button my-button></button>
                                                                                                                                                                                <my-comp></my-comp>
                                                                                                                                                                                </app-root>

                                                                                                                                                                                Calling getDirectives on <button> will return an array with an instance of the MyButton directive that is associated with the DOM node.

                                                                                                                                                                                Calling getDirectives on <my-comp> will return an empty array.

                                                                                                                                                                                Parameter node

                                                                                                                                                                                DOM node for which to get the directives.

                                                                                                                                                                                Returns

                                                                                                                                                                                Array of directives associated with the node.

                                                                                                                                                                                ng

                                                                                                                                                                              function ɵgetHostElement

                                                                                                                                                                              ɵgetHostElement: (componentOrDirective: {}) => Element;
                                                                                                                                                                              • Retrieves the host element of a component or directive instance. The host element is the DOM element that matched the selector of the directive.

                                                                                                                                                                                Parameter componentOrDirective

                                                                                                                                                                                Component or directive instance for which the host element should be retrieved.

                                                                                                                                                                                Returns

                                                                                                                                                                                Host element of the target.

                                                                                                                                                                                ng

                                                                                                                                                                              function ɵgetInjectableDef

                                                                                                                                                                              ɵgetInjectableDef: <T>(type: any) => ɵɵInjectableDeclaration<T> | null;
                                                                                                                                                                              • Read the injectable def (ɵprov) for type in a way which is immune to accidentally reading inherited value.

                                                                                                                                                                                Parameter type

                                                                                                                                                                                A type which may have its own (non-inherited) ɵprov.

                                                                                                                                                                              function ɵgetLContext

                                                                                                                                                                              ɵgetLContext: (target: any) => ɵLContext | null;
                                                                                                                                                                              • Returns the matching LContext data for a given DOM node, directive or component instance.

                                                                                                                                                                                This function will examine the provided DOM element, component, or directive instance's monkey-patched property to derive the LContext data. Once called then the monkey-patched value will be that of the newly created LContext.

                                                                                                                                                                                If the monkey-patched value is the LView instance then the context value for that target will be created and the monkey-patch reference will be updated. Therefore when this function is called it may mutate the provided element's, component's or any of the associated directive's monkey-patch values.

                                                                                                                                                                                If the monkey-patch value is not detected then the code will walk up the DOM until an element is found which contains a monkey-patch reference. When that occurs then the provided element will be updated with a new context (which is then returned). If the monkey-patch value is not detected for a component/directive instance then it will throw an error (all components and directives should be automatically monkey-patched by ivy).

                                                                                                                                                                                Parameter target

                                                                                                                                                                                Component, Directive or DOM Node.

                                                                                                                                                                              function ɵgetLocaleCurrencyCode

                                                                                                                                                                              ɵgetLocaleCurrencyCode: (locale: string) => string | null;
                                                                                                                                                                              • Retrieves the default currency code for the given locale.

                                                                                                                                                                                The default is defined as the first currency which is still in use.

                                                                                                                                                                                Parameter locale

                                                                                                                                                                                The code of the locale whose currency code we want.

                                                                                                                                                                                Returns

                                                                                                                                                                                The code of the default currency for the given locale.

                                                                                                                                                                              function ɵgetLocalePluralCase

                                                                                                                                                                              ɵgetLocalePluralCase: (locale: string) => (value: number) => number;
                                                                                                                                                                              • Retrieves the plural function used by ICU expressions to determine the plural case to use for a given locale.

                                                                                                                                                                                Parameter locale

                                                                                                                                                                                A locale code for the locale format rules to use.

                                                                                                                                                                                Returns

                                                                                                                                                                                The plural function for the locale.

                                                                                                                                                                                See Also

                                                                                                                                                                                • NgPlural

                                                                                                                                                                                • [Internationalization (i18n) Guide](https://angular.io/guide/i18n)

                                                                                                                                                                              function ɵgetModuleFactory__POST_R3__

                                                                                                                                                                              ɵgetModuleFactory__POST_R3__: (id: string) => NgModuleFactory<any>;

                                                                                                                                                                                function ɵgetSanitizationBypassType

                                                                                                                                                                                ɵgetSanitizationBypassType: (value: any) => ɵBypassType | null;

                                                                                                                                                                                  function ɵinitServicesIfNeeded

                                                                                                                                                                                  ɵinitServicesIfNeeded: () => void;

                                                                                                                                                                                    function ɵINJECTOR_IMPL__POST_R3__

                                                                                                                                                                                    ɵINJECTOR_IMPL__POST_R3__: (
                                                                                                                                                                                    providers: StaticProvider[],
                                                                                                                                                                                    parent: Injector | undefined,
                                                                                                                                                                                    name: string
                                                                                                                                                                                    ) => Injector;

                                                                                                                                                                                      function ɵinlineInterpolate

                                                                                                                                                                                      ɵinlineInterpolate: (
                                                                                                                                                                                      valueCount: number,
                                                                                                                                                                                      c0: string,
                                                                                                                                                                                      a1: any,
                                                                                                                                                                                      c1: string,
                                                                                                                                                                                      a2?: any,
                                                                                                                                                                                      c2?: string,
                                                                                                                                                                                      a3?: any,
                                                                                                                                                                                      c3?: string,
                                                                                                                                                                                      a4?: any,
                                                                                                                                                                                      c4?: string,
                                                                                                                                                                                      a5?: any,
                                                                                                                                                                                      c5?: string,
                                                                                                                                                                                      a6?: any,
                                                                                                                                                                                      c6?: string,
                                                                                                                                                                                      a7?: any,
                                                                                                                                                                                      c7?: string,
                                                                                                                                                                                      a8?: any,
                                                                                                                                                                                      c8?: string,
                                                                                                                                                                                      a9?: any,
                                                                                                                                                                                      c9?: string
                                                                                                                                                                                      ) => string;

                                                                                                                                                                                        function ɵinterpolate

                                                                                                                                                                                        ɵinterpolate: (valueCount: number, constAndInterp: string[]) => string;

                                                                                                                                                                                          function ɵisBoundToModule__POST_R3__

                                                                                                                                                                                          ɵisBoundToModule__POST_R3__: <C>(cf: ComponentFactory<C>) => boolean;

                                                                                                                                                                                            function ɵisDefaultChangeDetectionStrategy

                                                                                                                                                                                            ɵisDefaultChangeDetectionStrategy: (
                                                                                                                                                                                            changeDetectionStrategy: ChangeDetectionStrategy
                                                                                                                                                                                            ) => boolean;
                                                                                                                                                                                            • Reports whether a given strategy is currently the default for change detection.

                                                                                                                                                                                              Parameter changeDetectionStrategy

                                                                                                                                                                                              The strategy to check.

                                                                                                                                                                                              Returns

                                                                                                                                                                                              True if the given strategy is the current default, false otherwise.

                                                                                                                                                                                              See Also

                                                                                                                                                                                              • ChangeDetectorStatus

                                                                                                                                                                                              • ChangeDetectorRef

                                                                                                                                                                                            function ɵisListLikeIterable

                                                                                                                                                                                            ɵisListLikeIterable: (obj: any) => boolean;

                                                                                                                                                                                              function ɵisObservable

                                                                                                                                                                                              ɵisObservable: (obj: any | Observable<any>) => obj is any;
                                                                                                                                                                                              • Determine if the argument is an Observable

                                                                                                                                                                                                Strictly this tests that the obj is Subscribable, since Observable types need additional methods, such as lift(). But it is adequate for our needs since within the Angular framework code we only ever need to use the subscribe() method, and RxJS has mechanisms to wrap Subscribable objects into Observable as needed.

                                                                                                                                                                                              function ɵisPromise

                                                                                                                                                                                              ɵisPromise: <T = any>(obj: any) => obj is Promise<T>;
                                                                                                                                                                                              • Determine if the argument is shaped like a Promise

                                                                                                                                                                                              function ɵisSubscribable

                                                                                                                                                                                              ɵisSubscribable: (obj: any | Subscribable<any>) => obj is any;
                                                                                                                                                                                              • Determine if the argument is a Subscribable

                                                                                                                                                                                              function ɵLifecycleHooksFeature

                                                                                                                                                                                              ɵLifecycleHooksFeature: (component: any, def: ɵComponentDef<any>) => void;
                                                                                                                                                                                              • Used to enable lifecycle hooks on the root component.

                                                                                                                                                                                                Include this feature when calling renderComponent if the root component you are rendering has lifecycle hooks defined. Otherwise, the hooks won't be called properly.

                                                                                                                                                                                                Example:

                                                                                                                                                                                                renderComponent(AppComponent, {hostFeatures: [LifecycleHooksFeature]});

                                                                                                                                                                                              function ɵmakeDecorator

                                                                                                                                                                                              ɵmakeDecorator: <T>(
                                                                                                                                                                                              name: string,
                                                                                                                                                                                              props?: (...args: any[]) => any,
                                                                                                                                                                                              parentClass?: any,
                                                                                                                                                                                              additionalProcessing?: (type: Type<T>) => void,
                                                                                                                                                                                              typeFn?: (type: Type<T>, ...args: any[]) => void
                                                                                                                                                                                              ) => {
                                                                                                                                                                                              (...args: any[]): any;
                                                                                                                                                                                              (...args: any[]): (cls: any) => any;
                                                                                                                                                                                              new (...args: any[]): any;
                                                                                                                                                                                              };
                                                                                                                                                                                              • {globalThis}

                                                                                                                                                                                              function ɵmarkDirty

                                                                                                                                                                                              ɵmarkDirty: (component: {}) => void;
                                                                                                                                                                                              • Marks the component as dirty (needing change detection). Marking a component dirty will schedule a change detection on it at some point in the future.

                                                                                                                                                                                                Marking an already dirty component as dirty won't do anything. Only one outstanding change detection can be scheduled per component tree.

                                                                                                                                                                                                Parameter component

                                                                                                                                                                                                Component to mark as dirty.

                                                                                                                                                                                              function ɵmod

                                                                                                                                                                                              ɵmod: (providers: NgModuleProviderDef[]) => NgModuleDefinition;

                                                                                                                                                                                                function ɵmpd

                                                                                                                                                                                                ɵmpd: (
                                                                                                                                                                                                flags: ɵNodeFlags,
                                                                                                                                                                                                token: any,
                                                                                                                                                                                                value: any,
                                                                                                                                                                                                deps: ([ɵDepFlags, any] | any)[]
                                                                                                                                                                                                ) => NgModuleProviderDef;

                                                                                                                                                                                                  function ɵncd

                                                                                                                                                                                                  ɵncd: (ngContentIndex: null | number, index: number) => NodeDef;

                                                                                                                                                                                                    function ɵnoSideEffects

                                                                                                                                                                                                    ɵnoSideEffects: <T>(fn: () => T) => T;
                                                                                                                                                                                                    • Convince closure compiler that the wrapped function has no side-effects.

                                                                                                                                                                                                      Closure compiler always assumes that toString has no side-effects. We use this quirk to allow us to execute a function but have closure compiler mark the call as no-side-effects. It is important that the return value for the noSideEffects function be assigned to something which is retained otherwise the call to noSideEffects will be removed by closure compiler.

                                                                                                                                                                                                    function ɵnov

                                                                                                                                                                                                    ɵnov: (view: ViewData, index: number) => any;

                                                                                                                                                                                                      function ɵoverrideComponentView

                                                                                                                                                                                                      ɵoverrideComponentView: (
                                                                                                                                                                                                      comp: Type<any>,
                                                                                                                                                                                                      componentFactory: ComponentFactory<any>
                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                        function ɵoverrideProvider

                                                                                                                                                                                                        ɵoverrideProvider: (override: ProviderOverride) => void;

                                                                                                                                                                                                          function ɵɵadvance

                                                                                                                                                                                                          ɵɵadvance: (delta: number) => void;
                                                                                                                                                                                                          • Advances to an element for later binding instructions.

                                                                                                                                                                                                            Used in conjunction with instructions like property to act on elements with specified indices, for example those created with element or elementStart.

                                                                                                                                                                                                            (rf: RenderFlags, ctx: any) => {
                                                                                                                                                                                                            if (rf & 1) {
                                                                                                                                                                                                            text(0, 'Hello');
                                                                                                                                                                                                            text(1, 'Goodbye')
                                                                                                                                                                                                            element(2, 'div');
                                                                                                                                                                                                            }
                                                                                                                                                                                                            if (rf & 2) {
                                                                                                                                                                                                            advance(2); // Advance twice to the <div>.
                                                                                                                                                                                                            property('title', 'test');
                                                                                                                                                                                                            }
                                                                                                                                                                                                            }

                                                                                                                                                                                                            Parameter delta

                                                                                                                                                                                                            Number of elements to advance forwards by.

                                                                                                                                                                                                          function ɵɵattribute

                                                                                                                                                                                                          ɵɵattribute: (
                                                                                                                                                                                                          name: string,
                                                                                                                                                                                                          value: any,
                                                                                                                                                                                                          sanitizer?: SanitizerFn | null,
                                                                                                                                                                                                          namespace?: string
                                                                                                                                                                                                          ) => typeof ɵɵattribute;
                                                                                                                                                                                                          • Updates the value of or removes a bound attribute on an Element.

                                                                                                                                                                                                            Used in the case of [attr.title]="value"

                                                                                                                                                                                                            Parameter name

                                                                                                                                                                                                            name The name of the attribute.

                                                                                                                                                                                                            Parameter value

                                                                                                                                                                                                            value The attribute is removed when value is null or undefined. Otherwise the attribute value is set to the stringified value.

                                                                                                                                                                                                            Parameter sanitizer

                                                                                                                                                                                                            An optional function used to sanitize the value.

                                                                                                                                                                                                            Parameter namespace

                                                                                                                                                                                                            Optional namespace to use when setting the attribute.

                                                                                                                                                                                                          function ɵɵattributeInterpolate1

                                                                                                                                                                                                          ɵɵattributeInterpolate1: (
                                                                                                                                                                                                          attrName: string,
                                                                                                                                                                                                          prefix: string,
                                                                                                                                                                                                          v0: any,
                                                                                                                                                                                                          suffix: string,
                                                                                                                                                                                                          sanitizer?: SanitizerFn,
                                                                                                                                                                                                          namespace?: string
                                                                                                                                                                                                          ) => typeof ɵɵattributeInterpolate1;
                                                                                                                                                                                                          • Update an interpolated attribute on an element with single bound value surrounded by text.

                                                                                                                                                                                                            Used when the value passed to a property has 1 interpolated value in it:

                                                                                                                                                                                                            <div attr.title="prefix{{v0}}suffix"></div>

                                                                                                                                                                                                            Its compiled representation is::

                                                                                                                                                                                                            ɵɵattributeInterpolate1('title', 'prefix', v0, 'suffix');

                                                                                                                                                                                                            Parameter attrName

                                                                                                                                                                                                            The name of the attribute to update

                                                                                                                                                                                                            Parameter prefix

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v0

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter suffix

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter sanitizer

                                                                                                                                                                                                            An optional sanitizer function

                                                                                                                                                                                                            Returns

                                                                                                                                                                                                            itself, so that it may be chained.

                                                                                                                                                                                                          function ɵɵattributeInterpolate2

                                                                                                                                                                                                          ɵɵattributeInterpolate2: (
                                                                                                                                                                                                          attrName: string,
                                                                                                                                                                                                          prefix: string,
                                                                                                                                                                                                          v0: any,
                                                                                                                                                                                                          i0: string,
                                                                                                                                                                                                          v1: any,
                                                                                                                                                                                                          suffix: string,
                                                                                                                                                                                                          sanitizer?: SanitizerFn,
                                                                                                                                                                                                          namespace?: string
                                                                                                                                                                                                          ) => typeof ɵɵattributeInterpolate2;
                                                                                                                                                                                                          • Update an interpolated attribute on an element with 2 bound values surrounded by text.

                                                                                                                                                                                                            Used when the value passed to a property has 2 interpolated values in it:

                                                                                                                                                                                                            <div attr.title="prefix{{v0}}-{{v1}}suffix"></div>

                                                                                                                                                                                                            Its compiled representation is::

                                                                                                                                                                                                            ɵɵattributeInterpolate2('title', 'prefix', v0, '-', v1, 'suffix');

                                                                                                                                                                                                            Parameter attrName

                                                                                                                                                                                                            The name of the attribute to update

                                                                                                                                                                                                            Parameter prefix

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v0

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i0

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v1

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter suffix

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter sanitizer

                                                                                                                                                                                                            An optional sanitizer function

                                                                                                                                                                                                            Returns

                                                                                                                                                                                                            itself, so that it may be chained.

                                                                                                                                                                                                          function ɵɵattributeInterpolate3

                                                                                                                                                                                                          ɵɵattributeInterpolate3: (
                                                                                                                                                                                                          attrName: string,
                                                                                                                                                                                                          prefix: string,
                                                                                                                                                                                                          v0: any,
                                                                                                                                                                                                          i0: string,
                                                                                                                                                                                                          v1: any,
                                                                                                                                                                                                          i1: string,
                                                                                                                                                                                                          v2: any,
                                                                                                                                                                                                          suffix: string,
                                                                                                                                                                                                          sanitizer?: SanitizerFn,
                                                                                                                                                                                                          namespace?: string
                                                                                                                                                                                                          ) => typeof ɵɵattributeInterpolate3;
                                                                                                                                                                                                          • Update an interpolated attribute on an element with 3 bound values surrounded by text.

                                                                                                                                                                                                            Used when the value passed to a property has 3 interpolated values in it:

                                                                                                                                                                                                            <div attr.title="prefix{{v0}}-{{v1}}-{{v2}}suffix"></div>

                                                                                                                                                                                                            Its compiled representation is::

                                                                                                                                                                                                            ɵɵattributeInterpolate3(
                                                                                                                                                                                                            'title', 'prefix', v0, '-', v1, '-', v2, 'suffix');

                                                                                                                                                                                                            Parameter attrName

                                                                                                                                                                                                            The name of the attribute to update

                                                                                                                                                                                                            Parameter prefix

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v0

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i0

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v1

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i1

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v2

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter suffix

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter sanitizer

                                                                                                                                                                                                            An optional sanitizer function

                                                                                                                                                                                                            Returns

                                                                                                                                                                                                            itself, so that it may be chained.

                                                                                                                                                                                                          function ɵɵattributeInterpolate4

                                                                                                                                                                                                          ɵɵattributeInterpolate4: (
                                                                                                                                                                                                          attrName: string,
                                                                                                                                                                                                          prefix: string,
                                                                                                                                                                                                          v0: any,
                                                                                                                                                                                                          i0: string,
                                                                                                                                                                                                          v1: any,
                                                                                                                                                                                                          i1: string,
                                                                                                                                                                                                          v2: any,
                                                                                                                                                                                                          i2: string,
                                                                                                                                                                                                          v3: any,
                                                                                                                                                                                                          suffix: string,
                                                                                                                                                                                                          sanitizer?: SanitizerFn,
                                                                                                                                                                                                          namespace?: string
                                                                                                                                                                                                          ) => typeof ɵɵattributeInterpolate4;
                                                                                                                                                                                                          • Update an interpolated attribute on an element with 4 bound values surrounded by text.

                                                                                                                                                                                                            Used when the value passed to a property has 4 interpolated values in it:

                                                                                                                                                                                                            <div attr.title="prefix{{v0}}-{{v1}}-{{v2}}-{{v3}}suffix"></div>

                                                                                                                                                                                                            Its compiled representation is::

                                                                                                                                                                                                            ɵɵattributeInterpolate4(
                                                                                                                                                                                                            'title', 'prefix', v0, '-', v1, '-', v2, '-', v3, 'suffix');

                                                                                                                                                                                                            Parameter attrName

                                                                                                                                                                                                            The name of the attribute to update

                                                                                                                                                                                                            Parameter prefix

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v0

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i0

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v1

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i1

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v2

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i2

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v3

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter suffix

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter sanitizer

                                                                                                                                                                                                            An optional sanitizer function

                                                                                                                                                                                                            Returns

                                                                                                                                                                                                            itself, so that it may be chained.

                                                                                                                                                                                                          function ɵɵattributeInterpolate5

                                                                                                                                                                                                          ɵɵattributeInterpolate5: (
                                                                                                                                                                                                          attrName: string,
                                                                                                                                                                                                          prefix: string,
                                                                                                                                                                                                          v0: any,
                                                                                                                                                                                                          i0: string,
                                                                                                                                                                                                          v1: any,
                                                                                                                                                                                                          i1: string,
                                                                                                                                                                                                          v2: any,
                                                                                                                                                                                                          i2: string,
                                                                                                                                                                                                          v3: any,
                                                                                                                                                                                                          i3: string,
                                                                                                                                                                                                          v4: any,
                                                                                                                                                                                                          suffix: string,
                                                                                                                                                                                                          sanitizer?: SanitizerFn,
                                                                                                                                                                                                          namespace?: string
                                                                                                                                                                                                          ) => typeof ɵɵattributeInterpolate5;
                                                                                                                                                                                                          • Update an interpolated attribute on an element with 5 bound values surrounded by text.

                                                                                                                                                                                                            Used when the value passed to a property has 5 interpolated values in it:

                                                                                                                                                                                                            <div attr.title="prefix{{v0}}-{{v1}}-{{v2}}-{{v3}}-{{v4}}suffix"></div>

                                                                                                                                                                                                            Its compiled representation is::

                                                                                                                                                                                                            ɵɵattributeInterpolate5(
                                                                                                                                                                                                            'title', 'prefix', v0, '-', v1, '-', v2, '-', v3, '-', v4, 'suffix');

                                                                                                                                                                                                            Parameter attrName

                                                                                                                                                                                                            The name of the attribute to update

                                                                                                                                                                                                            Parameter prefix

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v0

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i0

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v1

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i1

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v2

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i2

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v3

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i3

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v4

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter suffix

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter sanitizer

                                                                                                                                                                                                            An optional sanitizer function

                                                                                                                                                                                                            Returns

                                                                                                                                                                                                            itself, so that it may be chained.

                                                                                                                                                                                                          function ɵɵattributeInterpolate6

                                                                                                                                                                                                          ɵɵattributeInterpolate6: (
                                                                                                                                                                                                          attrName: string,
                                                                                                                                                                                                          prefix: string,
                                                                                                                                                                                                          v0: any,
                                                                                                                                                                                                          i0: string,
                                                                                                                                                                                                          v1: any,
                                                                                                                                                                                                          i1: string,
                                                                                                                                                                                                          v2: any,
                                                                                                                                                                                                          i2: string,
                                                                                                                                                                                                          v3: any,
                                                                                                                                                                                                          i3: string,
                                                                                                                                                                                                          v4: any,
                                                                                                                                                                                                          i4: string,
                                                                                                                                                                                                          v5: any,
                                                                                                                                                                                                          suffix: string,
                                                                                                                                                                                                          sanitizer?: SanitizerFn,
                                                                                                                                                                                                          namespace?: string
                                                                                                                                                                                                          ) => typeof ɵɵattributeInterpolate6;
                                                                                                                                                                                                          • Update an interpolated attribute on an element with 6 bound values surrounded by text.

                                                                                                                                                                                                            Used when the value passed to a property has 6 interpolated values in it:

                                                                                                                                                                                                            <div attr.title="prefix{{v0}}-{{v1}}-{{v2}}-{{v3}}-{{v4}}-{{v5}}suffix"></div>

                                                                                                                                                                                                            Its compiled representation is::

                                                                                                                                                                                                            ɵɵattributeInterpolate6(
                                                                                                                                                                                                            'title', 'prefix', v0, '-', v1, '-', v2, '-', v3, '-', v4, '-', v5, 'suffix');

                                                                                                                                                                                                            Parameter attrName

                                                                                                                                                                                                            The name of the attribute to update

                                                                                                                                                                                                            Parameter prefix

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v0

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i0

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v1

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i1

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v2

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i2

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v3

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i3

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v4

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i4

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v5

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter suffix

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter sanitizer

                                                                                                                                                                                                            An optional sanitizer function

                                                                                                                                                                                                            Returns

                                                                                                                                                                                                            itself, so that it may be chained.

                                                                                                                                                                                                          function ɵɵattributeInterpolate7

                                                                                                                                                                                                          ɵɵattributeInterpolate7: (
                                                                                                                                                                                                          attrName: string,
                                                                                                                                                                                                          prefix: string,
                                                                                                                                                                                                          v0: any,
                                                                                                                                                                                                          i0: string,
                                                                                                                                                                                                          v1: any,
                                                                                                                                                                                                          i1: string,
                                                                                                                                                                                                          v2: any,
                                                                                                                                                                                                          i2: string,
                                                                                                                                                                                                          v3: any,
                                                                                                                                                                                                          i3: string,
                                                                                                                                                                                                          v4: any,
                                                                                                                                                                                                          i4: string,
                                                                                                                                                                                                          v5: any,
                                                                                                                                                                                                          i5: string,
                                                                                                                                                                                                          v6: any,
                                                                                                                                                                                                          suffix: string,
                                                                                                                                                                                                          sanitizer?: SanitizerFn,
                                                                                                                                                                                                          namespace?: string
                                                                                                                                                                                                          ) => typeof ɵɵattributeInterpolate7;
                                                                                                                                                                                                          • Update an interpolated attribute on an element with 7 bound values surrounded by text.

                                                                                                                                                                                                            Used when the value passed to a property has 7 interpolated values in it:

                                                                                                                                                                                                            <div attr.title="prefix{{v0}}-{{v1}}-{{v2}}-{{v3}}-{{v4}}-{{v5}}-{{v6}}suffix"></div>

                                                                                                                                                                                                            Its compiled representation is::

                                                                                                                                                                                                            ɵɵattributeInterpolate7(
                                                                                                                                                                                                            'title', 'prefix', v0, '-', v1, '-', v2, '-', v3, '-', v4, '-', v5, '-', v6, 'suffix');

                                                                                                                                                                                                            Parameter attrName

                                                                                                                                                                                                            The name of the attribute to update

                                                                                                                                                                                                            Parameter prefix

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v0

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i0

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v1

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i1

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v2

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i2

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v3

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i3

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v4

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i4

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v5

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i5

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v6

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter suffix

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter sanitizer

                                                                                                                                                                                                            An optional sanitizer function

                                                                                                                                                                                                            Returns

                                                                                                                                                                                                            itself, so that it may be chained.

                                                                                                                                                                                                          function ɵɵattributeInterpolate8

                                                                                                                                                                                                          ɵɵattributeInterpolate8: (
                                                                                                                                                                                                          attrName: string,
                                                                                                                                                                                                          prefix: string,
                                                                                                                                                                                                          v0: any,
                                                                                                                                                                                                          i0: string,
                                                                                                                                                                                                          v1: any,
                                                                                                                                                                                                          i1: string,
                                                                                                                                                                                                          v2: any,
                                                                                                                                                                                                          i2: string,
                                                                                                                                                                                                          v3: any,
                                                                                                                                                                                                          i3: string,
                                                                                                                                                                                                          v4: any,
                                                                                                                                                                                                          i4: string,
                                                                                                                                                                                                          v5: any,
                                                                                                                                                                                                          i5: string,
                                                                                                                                                                                                          v6: any,
                                                                                                                                                                                                          i6: string,
                                                                                                                                                                                                          v7: any,
                                                                                                                                                                                                          suffix: string,
                                                                                                                                                                                                          sanitizer?: SanitizerFn,
                                                                                                                                                                                                          namespace?: string
                                                                                                                                                                                                          ) => typeof ɵɵattributeInterpolate8;
                                                                                                                                                                                                          • Update an interpolated attribute on an element with 8 bound values surrounded by text.

                                                                                                                                                                                                            Used when the value passed to a property has 8 interpolated values in it:

                                                                                                                                                                                                            <div attr.title="prefix{{v0}}-{{v1}}-{{v2}}-{{v3}}-{{v4}}-{{v5}}-{{v6}}-{{v7}}suffix"></div>

                                                                                                                                                                                                            Its compiled representation is::

                                                                                                                                                                                                            ɵɵattributeInterpolate8(
                                                                                                                                                                                                            'title', 'prefix', v0, '-', v1, '-', v2, '-', v3, '-', v4, '-', v5, '-', v6, '-', v7, 'suffix');

                                                                                                                                                                                                            Parameter attrName

                                                                                                                                                                                                            The name of the attribute to update

                                                                                                                                                                                                            Parameter prefix

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v0

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i0

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v1

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i1

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v2

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i2

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v3

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i3

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v4

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i4

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v5

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i5

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v6

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i6

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v7

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter suffix

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter sanitizer

                                                                                                                                                                                                            An optional sanitizer function

                                                                                                                                                                                                            Returns

                                                                                                                                                                                                            itself, so that it may be chained.

                                                                                                                                                                                                          function ɵɵattributeInterpolateV

                                                                                                                                                                                                          ɵɵattributeInterpolateV: (
                                                                                                                                                                                                          attrName: string,
                                                                                                                                                                                                          values: any[],
                                                                                                                                                                                                          sanitizer?: SanitizerFn,
                                                                                                                                                                                                          namespace?: string
                                                                                                                                                                                                          ) => typeof ɵɵattributeInterpolateV;
                                                                                                                                                                                                          • Update an interpolated attribute on an element with 9 or more bound values surrounded by text.

                                                                                                                                                                                                            Used when the number of interpolated values exceeds 8.

                                                                                                                                                                                                            <div
                                                                                                                                                                                                            title="prefix{{v0}}-{{v1}}-{{v2}}-{{v3}}-{{v4}}-{{v5}}-{{v6}}-{{v7}}-{{v8}}-{{v9}}suffix"></div>

                                                                                                                                                                                                            Its compiled representation is::

                                                                                                                                                                                                            ɵɵattributeInterpolateV(
                                                                                                                                                                                                            'title', ['prefix', v0, '-', v1, '-', v2, '-', v3, '-', v4, '-', v5, '-', v6, '-', v7, '-', v9,
                                                                                                                                                                                                            'suffix']);

                                                                                                                                                                                                            Parameter attrName

                                                                                                                                                                                                            The name of the attribute to update.

                                                                                                                                                                                                            Parameter values

                                                                                                                                                                                                            The collection of values and the strings in-between those values, beginning with a string prefix and ending with a string suffix. (e.g. ['prefix', value0, '-', value1, '-', value2, ..., value99, 'suffix'])

                                                                                                                                                                                                            Parameter sanitizer

                                                                                                                                                                                                            An optional sanitizer function

                                                                                                                                                                                                            Returns

                                                                                                                                                                                                            itself, so that it may be chained.

                                                                                                                                                                                                          function ɵɵclassMap

                                                                                                                                                                                                          ɵɵclassMap: (classes: string | { [className: string]: boolean }) => void;
                                                                                                                                                                                                          • Update class bindings using an object literal or class-string on an element.

                                                                                                                                                                                                            This instruction is meant to apply styling via the [class]="exp" template bindings. When classes are applied to the element they will then be updated with respect to any styles/classes set via classProp. If any classes are set to falsy then they will be removed from the element.

                                                                                                                                                                                                            Note that the styling instruction will not be applied until stylingApply is called. Note that this will the provided classMap value to the host element if this function is called within a host binding.

                                                                                                                                                                                                            Parameter classes

                                                                                                                                                                                                            A key/value map or string of CSS classes that will be added to the given element. Any missing classes (that have already been applied to the element beforehand) will be removed (unset) from the element's list of CSS classes.

                                                                                                                                                                                                          function ɵɵclassMapInterpolate1

                                                                                                                                                                                                          ɵɵclassMapInterpolate1: (prefix: string, v0: any, suffix: string) => void;
                                                                                                                                                                                                          • Update an interpolated class on an element with single bound value surrounded by text.

                                                                                                                                                                                                            Used when the value passed to a property has 1 interpolated value in it:

                                                                                                                                                                                                            <div class="prefix{{v0}}suffix"></div>

                                                                                                                                                                                                            Its compiled representation is:

                                                                                                                                                                                                            ɵɵclassMapInterpolate1('prefix', v0, 'suffix');

                                                                                                                                                                                                            Parameter prefix

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v0

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter suffix

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                          function ɵɵclassMapInterpolate2

                                                                                                                                                                                                          ɵɵclassMapInterpolate2: (
                                                                                                                                                                                                          prefix: string,
                                                                                                                                                                                                          v0: any,
                                                                                                                                                                                                          i0: string,
                                                                                                                                                                                                          v1: any,
                                                                                                                                                                                                          suffix: string
                                                                                                                                                                                                          ) => void;
                                                                                                                                                                                                          • Update an interpolated class on an element with 2 bound values surrounded by text.

                                                                                                                                                                                                            Used when the value passed to a property has 2 interpolated values in it:

                                                                                                                                                                                                            <div class="prefix{{v0}}-{{v1}}suffix"></div>

                                                                                                                                                                                                            Its compiled representation is:

                                                                                                                                                                                                            ɵɵclassMapInterpolate2('prefix', v0, '-', v1, 'suffix');

                                                                                                                                                                                                            Parameter prefix

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v0

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i0

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v1

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter suffix

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                          function ɵɵclassMapInterpolate3

                                                                                                                                                                                                          ɵɵclassMapInterpolate3: (
                                                                                                                                                                                                          prefix: string,
                                                                                                                                                                                                          v0: any,
                                                                                                                                                                                                          i0: string,
                                                                                                                                                                                                          v1: any,
                                                                                                                                                                                                          i1: string,
                                                                                                                                                                                                          v2: any,
                                                                                                                                                                                                          suffix: string
                                                                                                                                                                                                          ) => void;
                                                                                                                                                                                                          • Update an interpolated class on an element with 3 bound values surrounded by text.

                                                                                                                                                                                                            Used when the value passed to a property has 3 interpolated values in it:

                                                                                                                                                                                                            <div class="prefix{{v0}}-{{v1}}-{{v2}}suffix"></div>

                                                                                                                                                                                                            Its compiled representation is:

                                                                                                                                                                                                            ɵɵclassMapInterpolate3(
                                                                                                                                                                                                            'prefix', v0, '-', v1, '-', v2, 'suffix');

                                                                                                                                                                                                            Parameter prefix

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v0

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i0

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v1

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i1

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v2

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter suffix

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                          function ɵɵclassMapInterpolate4

                                                                                                                                                                                                          ɵɵclassMapInterpolate4: (
                                                                                                                                                                                                          prefix: string,
                                                                                                                                                                                                          v0: any,
                                                                                                                                                                                                          i0: string,
                                                                                                                                                                                                          v1: any,
                                                                                                                                                                                                          i1: string,
                                                                                                                                                                                                          v2: any,
                                                                                                                                                                                                          i2: string,
                                                                                                                                                                                                          v3: any,
                                                                                                                                                                                                          suffix: string
                                                                                                                                                                                                          ) => void;
                                                                                                                                                                                                          • Update an interpolated class on an element with 4 bound values surrounded by text.

                                                                                                                                                                                                            Used when the value passed to a property has 4 interpolated values in it:

                                                                                                                                                                                                            <div class="prefix{{v0}}-{{v1}}-{{v2}}-{{v3}}suffix"></div>

                                                                                                                                                                                                            Its compiled representation is:

                                                                                                                                                                                                            ɵɵclassMapInterpolate4(
                                                                                                                                                                                                            'prefix', v0, '-', v1, '-', v2, '-', v3, 'suffix');

                                                                                                                                                                                                            Parameter prefix

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v0

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i0

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v1

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i1

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v2

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i2

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v3

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter suffix

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                          function ɵɵclassMapInterpolate5

                                                                                                                                                                                                          ɵɵclassMapInterpolate5: (
                                                                                                                                                                                                          prefix: string,
                                                                                                                                                                                                          v0: any,
                                                                                                                                                                                                          i0: string,
                                                                                                                                                                                                          v1: any,
                                                                                                                                                                                                          i1: string,
                                                                                                                                                                                                          v2: any,
                                                                                                                                                                                                          i2: string,
                                                                                                                                                                                                          v3: any,
                                                                                                                                                                                                          i3: string,
                                                                                                                                                                                                          v4: any,
                                                                                                                                                                                                          suffix: string
                                                                                                                                                                                                          ) => void;
                                                                                                                                                                                                          • Update an interpolated class on an element with 5 bound values surrounded by text.

                                                                                                                                                                                                            Used when the value passed to a property has 5 interpolated values in it:

                                                                                                                                                                                                            <div class="prefix{{v0}}-{{v1}}-{{v2}}-{{v3}}-{{v4}}suffix"></div>

                                                                                                                                                                                                            Its compiled representation is:

                                                                                                                                                                                                            ɵɵclassMapInterpolate5(
                                                                                                                                                                                                            'prefix', v0, '-', v1, '-', v2, '-', v3, '-', v4, 'suffix');

                                                                                                                                                                                                            Parameter prefix

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v0

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i0

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v1

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i1

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v2

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i2

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v3

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i3

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v4

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter suffix

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                          function ɵɵclassMapInterpolate6

                                                                                                                                                                                                          ɵɵclassMapInterpolate6: (
                                                                                                                                                                                                          prefix: string,
                                                                                                                                                                                                          v0: any,
                                                                                                                                                                                                          i0: string,
                                                                                                                                                                                                          v1: any,
                                                                                                                                                                                                          i1: string,
                                                                                                                                                                                                          v2: any,
                                                                                                                                                                                                          i2: string,
                                                                                                                                                                                                          v3: any,
                                                                                                                                                                                                          i3: string,
                                                                                                                                                                                                          v4: any,
                                                                                                                                                                                                          i4: string,
                                                                                                                                                                                                          v5: any,
                                                                                                                                                                                                          suffix: string
                                                                                                                                                                                                          ) => void;
                                                                                                                                                                                                          • Update an interpolated class on an element with 6 bound values surrounded by text.

                                                                                                                                                                                                            Used when the value passed to a property has 6 interpolated values in it:

                                                                                                                                                                                                            <div class="prefix{{v0}}-{{v1}}-{{v2}}-{{v3}}-{{v4}}-{{v5}}suffix"></div>

                                                                                                                                                                                                            Its compiled representation is:

                                                                                                                                                                                                            ɵɵclassMapInterpolate6(
                                                                                                                                                                                                            'prefix', v0, '-', v1, '-', v2, '-', v3, '-', v4, '-', v5, 'suffix');

                                                                                                                                                                                                            Parameter prefix

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v0

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i0

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v1

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i1

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v2

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i2

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v3

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i3

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v4

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i4

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v5

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter suffix

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                          function ɵɵclassMapInterpolate7

                                                                                                                                                                                                          ɵɵclassMapInterpolate7: (
                                                                                                                                                                                                          prefix: string,
                                                                                                                                                                                                          v0: any,
                                                                                                                                                                                                          i0: string,
                                                                                                                                                                                                          v1: any,
                                                                                                                                                                                                          i1: string,
                                                                                                                                                                                                          v2: any,
                                                                                                                                                                                                          i2: string,
                                                                                                                                                                                                          v3: any,
                                                                                                                                                                                                          i3: string,
                                                                                                                                                                                                          v4: any,
                                                                                                                                                                                                          i4: string,
                                                                                                                                                                                                          v5: any,
                                                                                                                                                                                                          i5: string,
                                                                                                                                                                                                          v6: any,
                                                                                                                                                                                                          suffix: string
                                                                                                                                                                                                          ) => void;
                                                                                                                                                                                                          • Update an interpolated class on an element with 7 bound values surrounded by text.

                                                                                                                                                                                                            Used when the value passed to a property has 7 interpolated values in it:

                                                                                                                                                                                                            <div class="prefix{{v0}}-{{v1}}-{{v2}}-{{v3}}-{{v4}}-{{v5}}-{{v6}}suffix"></div>

                                                                                                                                                                                                            Its compiled representation is:

                                                                                                                                                                                                            ɵɵclassMapInterpolate7(
                                                                                                                                                                                                            'prefix', v0, '-', v1, '-', v2, '-', v3, '-', v4, '-', v5, '-', v6, 'suffix');

                                                                                                                                                                                                            Parameter prefix

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v0

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i0

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v1

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i1

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v2

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i2

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v3

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i3

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v4

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i4

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v5

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i5

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v6

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter suffix

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                          function ɵɵclassMapInterpolate8

                                                                                                                                                                                                          ɵɵclassMapInterpolate8: (
                                                                                                                                                                                                          prefix: string,
                                                                                                                                                                                                          v0: any,
                                                                                                                                                                                                          i0: string,
                                                                                                                                                                                                          v1: any,
                                                                                                                                                                                                          i1: string,
                                                                                                                                                                                                          v2: any,
                                                                                                                                                                                                          i2: string,
                                                                                                                                                                                                          v3: any,
                                                                                                                                                                                                          i3: string,
                                                                                                                                                                                                          v4: any,
                                                                                                                                                                                                          i4: string,
                                                                                                                                                                                                          v5: any,
                                                                                                                                                                                                          i5: string,
                                                                                                                                                                                                          v6: any,
                                                                                                                                                                                                          i6: string,
                                                                                                                                                                                                          v7: any,
                                                                                                                                                                                                          suffix: string
                                                                                                                                                                                                          ) => void;
                                                                                                                                                                                                          • Update an interpolated class on an element with 8 bound values surrounded by text.

                                                                                                                                                                                                            Used when the value passed to a property has 8 interpolated values in it:

                                                                                                                                                                                                            <div class="prefix{{v0}}-{{v1}}-{{v2}}-{{v3}}-{{v4}}-{{v5}}-{{v6}}-{{v7}}suffix"></div>

                                                                                                                                                                                                            Its compiled representation is:

                                                                                                                                                                                                            ɵɵclassMapInterpolate8(
                                                                                                                                                                                                            'prefix', v0, '-', v1, '-', v2, '-', v3, '-', v4, '-', v5, '-', v6, '-', v7, 'suffix');

                                                                                                                                                                                                            Parameter prefix

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v0

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i0

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v1

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i1

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v2

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i2

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v3

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i3

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v4

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i4

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v5

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i5

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v6

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter i6

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                            Parameter v7

                                                                                                                                                                                                            Value checked for change.

                                                                                                                                                                                                            Parameter suffix

                                                                                                                                                                                                            Static value used for concatenation only.

                                                                                                                                                                                                          function ɵɵclassMapInterpolateV

                                                                                                                                                                                                          ɵɵclassMapInterpolateV: (values: any[]) => void;
                                                                                                                                                                                                          • Update an interpolated class on an element with 9 or more bound values surrounded by text.

                                                                                                                                                                                                            Used when the number of interpolated values exceeds 8.

                                                                                                                                                                                                            <div
                                                                                                                                                                                                            class="prefix{{v0}}-{{v1}}-{{v2}}-{{v3}}-{{v4}}-{{v5}}-{{v6}}-{{v7}}-{{v8}}-{{v9}}suffix"></div>

                                                                                                                                                                                                            Its compiled representation is:

                                                                                                                                                                                                            ɵɵclassMapInterpolateV(
                                                                                                                                                                                                            ['prefix', v0, '-', v1, '-', v2, '-', v3, '-', v4, '-', v5, '-', v6, '-', v7, '-', v9,
                                                                                                                                                                                                            'suffix']);

                                                                                                                                                                                                            .

                                                                                                                                                                                                            Parameter values

                                                                                                                                                                                                            The collection of values and the strings in-between those values, beginning with a string prefix and ending with a string suffix. (e.g. ['prefix', value0, '-', value1, '-', value2, ..., value99, 'suffix'])

                                                                                                                                                                                                          function ɵɵclassProp

                                                                                                                                                                                                          ɵɵclassProp: (
                                                                                                                                                                                                          className: string,
                                                                                                                                                                                                          value: boolean | undefined | null
                                                                                                                                                                                                          ) => typeof ɵɵclassProp;
                                                                                                                                                                                                          • Update a class binding on an element with the provided value.

                                                                                                                                                                                                            This instruction is meant to handle the [class.foo]="exp" case and, therefore, the class binding itself must already be allocated using styling within the creation block.

                                                                                                                                                                                                            Parameter prop

                                                                                                                                                                                                            A valid CSS class (only one).

                                                                                                                                                                                                            Parameter value

                                                                                                                                                                                                            A true/false value which will turn the class on or off.

                                                                                                                                                                                                            Note that this will apply the provided class value to the host element if this function is called within a host binding function.

                                                                                                                                                                                                          function ɵɵcontentQuery

                                                                                                                                                                                                          ɵɵcontentQuery: <T>(
                                                                                                                                                                                                          directiveIndex: number,
                                                                                                                                                                                                          predicate: ProviderToken<unknown> | string[],
                                                                                                                                                                                                          flags: QueryFlags,
                                                                                                                                                                                                          read?: any
                                                                                                                                                                                                          ) => void;
                                                                                                                                                                                                          • Registers a QueryList, associated with a content query, for later refresh (part of a view refresh).

                                                                                                                                                                                                            Parameter directiveIndex

                                                                                                                                                                                                            Current directive index

                                                                                                                                                                                                            Parameter predicate

                                                                                                                                                                                                            The type for which the query will search

                                                                                                                                                                                                            Parameter flags

                                                                                                                                                                                                            Flags associated with the query

                                                                                                                                                                                                            Parameter read

                                                                                                                                                                                                            What to save in the query

                                                                                                                                                                                                            Returns

                                                                                                                                                                                                            QueryList

                                                                                                                                                                                                          function ɵɵCopyDefinitionFeature

                                                                                                                                                                                                          ɵɵCopyDefinitionFeature: (
                                                                                                                                                                                                          definition: ɵDirectiveDef<any> | ɵComponentDef<any>
                                                                                                                                                                                                          ) => void;
                                                                                                                                                                                                          • Copies the fields not handled by the ɵɵInheritDefinitionFeature from the supertype of a definition.

                                                                                                                                                                                                            This exists primarily to support ngcc migration of an existing View Engine pattern, where an entire decorator is inherited from a parent to a child class. When ngcc detects this case, it generates a skeleton definition on the child class, and applies this feature.

                                                                                                                                                                                                            The ɵɵCopyDefinitionFeature then copies any needed fields from the parent class' definition, including things like the component template function.

                                                                                                                                                                                                            Parameter definition

                                                                                                                                                                                                            The definition of a child class which inherits from a parent class with its own definition.

                                                                                                                                                                                                          function ɵɵdefineComponent

                                                                                                                                                                                                          ɵɵdefineComponent: <T>(componentDefinition: {
                                                                                                                                                                                                          type: Type<T>;
                                                                                                                                                                                                          selectors?: ɵCssSelectorList;
                                                                                                                                                                                                          decls: number;
                                                                                                                                                                                                          vars: number;
                                                                                                                                                                                                          inputs?: { [P in keyof T]?: string | [string, string] };
                                                                                                                                                                                                          outputs?: { [P in keyof T]?: string };
                                                                                                                                                                                                          hostBindings?: HostBindingsFunction<T>;
                                                                                                                                                                                                          hostVars?: number;
                                                                                                                                                                                                          hostAttrs?: TAttributes;
                                                                                                                                                                                                          contentQueries?: ContentQueriesFunction<T>;
                                                                                                                                                                                                          exportAs?: string[];
                                                                                                                                                                                                          template: ComponentTemplate<T>;
                                                                                                                                                                                                          consts?: TConstantsOrFactory;
                                                                                                                                                                                                          ngContentSelectors?: string[];
                                                                                                                                                                                                          viewQuery?: ViewQueriesFunction<T> | null;
                                                                                                                                                                                                          features?: ComponentDefFeature[];
                                                                                                                                                                                                          encapsulation?: ViewEncapsulation;
                                                                                                                                                                                                          data?: { [kind: string]: any };
                                                                                                                                                                                                          styles?: string[];
                                                                                                                                                                                                          changeDetection?: ChangeDetectionStrategy;
                                                                                                                                                                                                          directives?: DirectiveTypesOrFactory | null;
                                                                                                                                                                                                          pipes?: PipeTypesOrFactory | null;
                                                                                                                                                                                                          schemas?: SchemaMetadata[] | null;
                                                                                                                                                                                                          }) => unknown;
                                                                                                                                                                                                          • Create a component definition object.

                                                                                                                                                                                                            # Example

                                                                                                                                                                                                            class MyDirective {
                                                                                                                                                                                                            // Generated by Angular Template Compiler
                                                                                                                                                                                                            // [Symbol] syntax will not be supported by TypeScript until v2.7
                                                                                                                                                                                                            static ɵcmp = defineComponent({
                                                                                                                                                                                                            ...
                                                                                                                                                                                                            });
                                                                                                                                                                                                            }

                                                                                                                                                                                                          function ɵɵdefineDirective

                                                                                                                                                                                                          ɵɵdefineDirective: <T>(directiveDefinition: {
                                                                                                                                                                                                          type: Type<T>;
                                                                                                                                                                                                          selectors?: ɵCssSelectorList | undefined;
                                                                                                                                                                                                          inputs?: { [P in keyof T]?: string | [string, string] };
                                                                                                                                                                                                          outputs?: { [P_1 in keyof T]?: string };
                                                                                                                                                                                                          features?: DirectiveDefFeature[] | undefined;
                                                                                                                                                                                                          hostBindings?: HostBindingsFunction<T>;
                                                                                                                                                                                                          hostVars?: number | undefined;
                                                                                                                                                                                                          hostAttrs?: TAttributes | undefined;
                                                                                                                                                                                                          contentQueries?: ContentQueriesFunction<T>;
                                                                                                                                                                                                          viewQuery?: ViewQueriesFunction<T>;
                                                                                                                                                                                                          exportAs?: string[] | undefined;
                                                                                                                                                                                                          }) => never;
                                                                                                                                                                                                          • Create a directive definition object.

                                                                                                                                                                                                            # Example

                                                                                                                                                                                                            class MyDirective {
                                                                                                                                                                                                            // Generated by Angular Template Compiler
                                                                                                                                                                                                            // [Symbol] syntax will not be supported by TypeScript until v2.7
                                                                                                                                                                                                            static ɵdir = ɵɵdefineDirective({
                                                                                                                                                                                                            ...
                                                                                                                                                                                                            });
                                                                                                                                                                                                            }

                                                                                                                                                                                                          function ɵɵdefineInjectable

                                                                                                                                                                                                          ɵɵdefineInjectable: <T>(opts: {
                                                                                                                                                                                                          token: unknown;
                                                                                                                                                                                                          providedIn?: Type<any> | 'root' | 'platform' | 'any' | null;
                                                                                                                                                                                                          factory: () => T;
                                                                                                                                                                                                          }) => unknown;
                                                                                                                                                                                                          • Construct an injectable definition which defines how a token will be constructed by the DI system, and in which injectors (if any) it will be available.

                                                                                                                                                                                                            This should be assigned to a static ɵprov field on a type, which will then be an InjectableType.

                                                                                                                                                                                                            Options: * providedIn determines which injectors will include the injectable, by either associating it with an @NgModule or other InjectorType, or by specifying that this injectable should be provided in the 'root' injector, which will be the application-level injector in most apps. * factory gives the zero argument function which will create an instance of the injectable. The factory can call inject to access the Injector and request injection of dependencies.

                                                                                                                                                                                                            This instruction has been emitted by ViewEngine for some time and is deployed to npm.

                                                                                                                                                                                                          function ɵɵdefineInjector

                                                                                                                                                                                                          ɵɵdefineInjector: (options: { providers?: any[]; imports?: any[] }) => unknown;
                                                                                                                                                                                                          • Construct an InjectorDef which configures an injector.

                                                                                                                                                                                                            This should be assigned to a static injector def (ɵinj) field on a type, which will then be an InjectorType.

                                                                                                                                                                                                            Options:

                                                                                                                                                                                                            * providers: an optional array of providers to add to the injector. Each provider must either have a factory or point to a type which has a ɵprov static property (the type must be an InjectableType). * imports: an optional array of imports of other InjectorTypes or InjectorTypeWithModules whose providers will also be added to the injector. Locally provided types will override providers from imports.

                                                                                                                                                                                                          function ɵɵdefineNgModule

                                                                                                                                                                                                          ɵɵdefineNgModule: <T>(def: {
                                                                                                                                                                                                          type: T;
                                                                                                                                                                                                          bootstrap?: Type<any>[] | (() => Type<any>[]);
                                                                                                                                                                                                          declarations?: Type<any>[] | (() => Type<any>[]);
                                                                                                                                                                                                          imports?: Type<any>[] | (() => Type<any>[]);
                                                                                                                                                                                                          exports?: Type<any>[] | (() => Type<any>[]);
                                                                                                                                                                                                          schemas?: SchemaMetadata[] | null;
                                                                                                                                                                                                          id?: string | null;
                                                                                                                                                                                                          }) => unknown;

                                                                                                                                                                                                          function ɵɵdefinePipe

                                                                                                                                                                                                          ɵɵdefinePipe: <T>(pipeDef: {
                                                                                                                                                                                                          name: string;
                                                                                                                                                                                                          type: Type<T>;
                                                                                                                                                                                                          pure?: boolean;
                                                                                                                                                                                                          }) => unknown;
                                                                                                                                                                                                          • Create a pipe definition object.

                                                                                                                                                                                                            # Example

                                                                                                                                                                                                            class MyPipe implements PipeTransform {
                                                                                                                                                                                                            // Generated by Angular Template Compiler
                                                                                                                                                                                                            static ɵpipe = definePipe({
                                                                                                                                                                                                            ...
                                                                                                                                                                                                            });
                                                                                                                                                                                                            }

                                                                                                                                                                                                            Parameter pipeDef

                                                                                                                                                                                                            Pipe definition generated by the compiler

                                                                                                                                                                                                          function ɵɵdirectiveInject

                                                                                                                                                                                                          ɵɵdirectiveInject: {
                                                                                                                                                                                                          <T>(token: ProviderToken<T>): T;
                                                                                                                                                                                                          <T>(token: ProviderToken<T>, flags: InjectFlags): T;
                                                                                                                                                                                                          };
                                                                                                                                                                                                          • Returns the value associated to the given token from the injectors.

                                                                                                                                                                                                            directiveInject is intended to be used for directive, component and pipe factories. All other injection use inject which does not walk the node injector tree.

                                                                                                                                                                                                            Usage example (in factory function):

                                                                                                                                                                                                            class SomeDirective {
                                                                                                                                                                                                            constructor(directive: DirectiveA) {}
                                                                                                                                                                                                            static ɵdir = ɵɵdefineDirective({
                                                                                                                                                                                                            type: SomeDirective,
                                                                                                                                                                                                            factory: () => new SomeDirective(ɵɵdirectiveInject(DirectiveA))
                                                                                                                                                                                                            });
                                                                                                                                                                                                            }

                                                                                                                                                                                                            Parameter token

                                                                                                                                                                                                            the type or token to inject

                                                                                                                                                                                                            Parameter flags

                                                                                                                                                                                                            Injection flags

                                                                                                                                                                                                            Returns

                                                                                                                                                                                                            the value from the injector or null when not found

                                                                                                                                                                                                          function ɵɵdisableBindings

                                                                                                                                                                                                          ɵɵdisableBindings: () => void;
                                                                                                                                                                                                          • Disables directive matching on element.

                                                                                                                                                                                                            * Example:

                                                                                                                                                                                                            <my-comp my-directive>
                                                                                                                                                                                                            Should match component / directive.
                                                                                                                                                                                                            </my-comp>
                                                                                                                                                                                                            <div ngNonBindable>
                                                                                                                                                                                                            <!-- ɵɵdisableBindings() -->
                                                                                                                                                                                                            <my-comp my-directive>
                                                                                                                                                                                                            Should not match component / directive because we are in ngNonBindable.
                                                                                                                                                                                                            </my-comp>
                                                                                                                                                                                                            <!-- ɵɵenableBindings() -->
                                                                                                                                                                                                            </div>

                                                                                                                                                                                                          function ɵɵelement

                                                                                                                                                                                                          ɵɵelement: (
                                                                                                                                                                                                          index: number,
                                                                                                                                                                                                          name: string,
                                                                                                                                                                                                          attrsIndex?: number | null,
                                                                                                                                                                                                          localRefsIndex?: number
                                                                                                                                                                                                          ) => void;
                                                                                                                                                                                                          • Creates an empty element using elementStart and elementEnd

                                                                                                                                                                                                            Parameter index

                                                                                                                                                                                                            Index of the element in the data array

                                                                                                                                                                                                            Parameter name

                                                                                                                                                                                                            Name of the DOM Node

                                                                                                                                                                                                            Parameter attrsIndex

                                                                                                                                                                                                            Index of the element's attributes in the consts array.

                                                                                                                                                                                                            Parameter localRefsIndex

                                                                                                                                                                                                            Index of the element's local references in the consts array.

                                                                                                                                                                                                          function ɵɵelementContainer

                                                                                                                                                                                                          ɵɵelementContainer: (
                                                                                                                                                                                                          index: number,
                                                                                                                                                                                                          attrsIndex?: number | null,
                                                                                                                                                                                                          localRefsIndex?: number
                                                                                                                                                                                                          ) => void;
                                                                                                                                                                                                          • Creates an empty logical container using elementContainerStart and elementContainerEnd

                                                                                                                                                                                                            Parameter index

                                                                                                                                                                                                            Index of the element in the LView array

                                                                                                                                                                                                            Parameter attrsIndex

                                                                                                                                                                                                            Index of the container attributes in the consts array.

                                                                                                                                                                                                            Parameter localRefsIndex

                                                                                                                                                                                                            Index of the container's local references in the consts array.

                                                                                                                                                                                                          function ɵɵelementContainerEnd

                                                                                                                                                                                                          ɵɵelementContainerEnd: () => void;
                                                                                                                                                                                                          • Mark the end of the .

                                                                                                                                                                                                          function ɵɵelementContainerStart

                                                                                                                                                                                                          ɵɵelementContainerStart: (
                                                                                                                                                                                                          index: number,
                                                                                                                                                                                                          attrsIndex?: number | null,
                                                                                                                                                                                                          localRefsIndex?: number
                                                                                                                                                                                                          ) => void;
                                                                                                                                                                                                          • Creates a logical container for other nodes () backed by a comment node in the DOM. The instruction must later be followed by elementContainerEnd() call.

                                                                                                                                                                                                            Parameter index

                                                                                                                                                                                                            Index of the element in the LView array

                                                                                                                                                                                                            Parameter attrsIndex

                                                                                                                                                                                                            Index of the container attributes in the consts array.

                                                                                                                                                                                                            Parameter localRefsIndex

                                                                                                                                                                                                            Index of the container's local references in the consts array.

                                                                                                                                                                                                            Even if this instruction accepts a set of attributes no actual attribute values are propagated to the DOM (as a comment node can't have attributes). Attributes are here only for directive matching purposes and setting initial inputs of directives.

                                                                                                                                                                                                          function ɵɵelementEnd

                                                                                                                                                                                                          ɵɵelementEnd: () => void;
                                                                                                                                                                                                          • Mark the end of the element.

                                                                                                                                                                                                          function ɵɵelementStart

                                                                                                                                                                                                          ɵɵelementStart: (
                                                                                                                                                                                                          index: number,
                                                                                                                                                                                                          name: string,
                                                                                                                                                                                                          attrsIndex?: number | null,
                                                                                                                                                                                                          localRefsIndex?: number
                                                                                                                                                                                                          ) => void;
                                                                                                                                                                                                          • Create DOM element. The instruction must later be followed by elementEnd() call.

                                                                                                                                                                                                            Parameter index

                                                                                                                                                                                                            Index of the element in the LView array

                                                                                                                                                                                                            Parameter name

                                                                                                                                                                                                            Name of the DOM Node

                                                                                                                                                                                                            Parameter attrsIndex

                                                                                                                                                                                                            Index of the element's attributes in the consts array.

                                                                                                                                                                                                            Parameter localRefsIndex

                                                                                                                                                                                                            Index of the element's local references in the consts array.

                                                                                                                                                                                                            Attributes and localRefs are passed as an array of strings where elements with an even index hold an attribute name and elements with an odd index hold an attribute value, ex.: ['id', 'warning5', 'class', 'alert']

                                                                                                                                                                                                          function ɵɵenableBindings

                                                                                                                                                                                                          ɵɵenableBindings: () => void;
                                                                                                                                                                                                          • Enables directive matching on elements.

                                                                                                                                                                                                            * Example:

                                                                                                                                                                                                            <my-comp my-directive>
                                                                                                                                                                                                            Should match component / directive.
                                                                                                                                                                                                            </my-comp>
                                                                                                                                                                                                            <div ngNonBindable>
                                                                                                                                                                                                            <!-- ɵɵdisableBindings() -->
                                                                                                                                                                                                            <my-comp my-directive>
                                                                                                                                                                                                            Should not match component / directive because we are in ngNonBindable.
                                                                                                                                                                                                            </my-comp>
                                                                                                                                                                                                            <!-- ɵɵenableBindings() -->
                                                                                                                                                                                                            </div>

                                                                                                                                                                                                          function ɵɵgetCurrentView

                                                                                                                                                                                                          ɵɵgetCurrentView: () => OpaqueViewState;
                                                                                                                                                                                                          • Returns the current OpaqueViewState instance.

                                                                                                                                                                                                            Used in conjunction with the restoreView() instruction to save a snapshot of the current view and restore it when listeners are invoked. This allows walking the declaration view tree in listeners to get vars from parent views.

                                                                                                                                                                                                          function ɵɵgetInheritedFactory

                                                                                                                                                                                                          ɵɵgetInheritedFactory: <T>(type: Type<any>) => (type: Type<T>) => T;

                                                                                                                                                                                                          function ɵɵhostProperty

                                                                                                                                                                                                          ɵɵhostProperty: <T>(
                                                                                                                                                                                                          propName: string,
                                                                                                                                                                                                          value: T,
                                                                                                                                                                                                          sanitizer?: SanitizerFn | null
                                                                                                                                                                                                          ) => typeof ɵɵhostProperty;
                                                                                                                                                                                                          • Update a property on a host element. Only applies to native node properties, not inputs.

                                                                                                                                                                                                            Operates on the element selected by index via the select instruction.

                                                                                                                                                                                                            Parameter propName

                                                                                                                                                                                                            Name of property. Because it is going to DOM, this is not subject to renaming as part of minification.

                                                                                                                                                                                                            Parameter value

                                                                                                                                                                                                            New value to write.

                                                                                                                                                                                                            Parameter sanitizer

                                                                                                                                                                                                            An optional function used to sanitize the value.

                                                                                                                                                                                                            Returns

                                                                                                                                                                                                            This function returns itself so that it may be chained (e.g. property('name', ctx.name)('title', ctx.title))

                                                                                                                                                                                                          function ɵɵi18n

                                                                                                                                                                                                          ɵɵi18n: (index: number, messageIndex: number, subTemplateIndex?: number) => void;
                                                                                                                                                                                                          • Use this instruction to create a translation block that doesn't contain any placeholder. It calls both i18nStart and i18nEnd in one instruction.

                                                                                                                                                                                                            The translation message is the value which is locale specific. The translation string may contain placeholders which associate inner elements and sub-templates within the translation.

                                                                                                                                                                                                            The translation message placeholders are: - �{index}(:{block})�: *Binding Placeholder*: Marks a location where an expression will be interpolated into. The placeholder index points to the expression binding index. An optional block that matches the sub-template in which it was declared. - �#{index}(:{block})�/�/#{index}(:{block})�: *Element Placeholder*: Marks the beginning and end of DOM element that were embedded in the original translation block. The placeholder index points to the element index in the template instructions set. An optional block that matches the sub-template in which it was declared. - �*{index}:{block}�/�/*{index}:{block}�: *Sub-template Placeholder*: Sub-templates must be split up and translated separately in each angular template function. The index points to the template instruction index. A block that matches the sub-template in which it was declared.

                                                                                                                                                                                                            Parameter index

                                                                                                                                                                                                            A unique index of the translation in the static block.

                                                                                                                                                                                                            Parameter messageIndex

                                                                                                                                                                                                            An index of the translation message from the def.consts array.

                                                                                                                                                                                                            Parameter subTemplateIndex

                                                                                                                                                                                                            Optional sub-template index in the message.

                                                                                                                                                                                                          function ɵɵi18nApply

                                                                                                                                                                                                          ɵɵi18nApply: (index: number) => void;
                                                                                                                                                                                                          • Updates a translation block or an i18n attribute when the bindings have changed.

                                                                                                                                                                                                            Parameter index

                                                                                                                                                                                                            Index of either i18nStart (translation block) or i18nAttributes (i18n attribute) on which it should update the content.

                                                                                                                                                                                                          function ɵɵi18nAttributes

                                                                                                                                                                                                          ɵɵi18nAttributes: (index: number, attrsIndex: number) => void;
                                                                                                                                                                                                          • Marks a list of attributes as translatable.

                                                                                                                                                                                                            Parameter index

                                                                                                                                                                                                            A unique index in the static block

                                                                                                                                                                                                            Parameter values

                                                                                                                                                                                                          function ɵɵi18nEnd