export interface AfterContentChecked { ngAfterContentChecked(): void;}export interface AfterContentInit { ngAfterContentInit(): void;}export interface AfterViewChecked { ngAfterViewChecked(): void;}export interface AfterViewInit { ngAfterViewInit(): void;}/** @experimental */export declare const ANALYZE_FOR_ENTRY_COMPONENTS: InjectionToken ;/** @experimental */export declare const APP_BOOTSTRAP_LISTENER: InjectionToken<((compRef: ComponentRef ) => void)[]>;/** @experimental */export declare const APP_ID: InjectionToken ;/** @experimental */export declare const APP_INITIALIZER: InjectionToken<(() => void)[]>;/** @experimental */export declare class ApplicationInitStatus { readonly done: boolean; readonly donePromise: Promise ; constructor(appInits: (() => any)[]);}/** @experimental */export declare class ApplicationModule { constructor(appRef: ApplicationRef);}export declare class ApplicationRef { readonly componentTypes: Type []; readonly components: ComponentRef []; readonly isStable: Observable ; readonly viewCount: number; attachView(viewRef: ViewRef): void; bootstrap (componentOrFactory: ComponentFactory | Type , rootSelectorOrNode?: string | any): ComponentRef ; detachView(viewRef: ViewRef): void; tick(): void;}/** @experimental */export declare function asNativeElements(debugEls: DebugElement[]): any;/** @experimental */export declare function assertPlatform(requiredToken: any): PlatformRef;export declare const Attribute: AttributeDecorator;export declare enum ChangeDetectionStrategy { OnPush = 0, Default = 1,}export declare abstract class ChangeDetectorRef { abstract checkNoChanges(): void; abstract detach(): void; abstract detectChanges(): void; abstract markForCheck(): void; abstract reattach(): void;}export interface ClassProvider extends ClassSansProvider { multi?: boolean; provide: any;}/** @deprecated */export interface CollectionChangeRecord extends IterableChangeRecord {}export declare class Compiler { clearCache(): void; clearCacheFor(type: Type ): void; compileModuleAndAllComponentsAsync (moduleType: Type ): Promise >; compileModuleAndAllComponentsSync (moduleType: Type ): ModuleWithComponentFactories ; compileModuleAsync (moduleType: Type ): Promise >; compileModuleSync (moduleType: Type ): NgModuleFactory ;}/** @experimental */export declare const COMPILER_OPTIONS: InjectionToken ;/** @experimental */export declare abstract class CompilerFactory { abstract createCompiler(options?: CompilerOptions[]): Compiler;}/** @experimental */export declare type CompilerOptions = { useJit?: boolean; defaultEncapsulation?: ViewEncapsulation; providers?: StaticProvider[]; missingTranslation?: MissingTranslationStrategy; preserveWhitespaces?: boolean;};export declare const Component: ComponentDecorator;export interface ComponentDecorator { (obj: Component): TypeDecorator; new (obj: Component): Component;}export declare abstract class ComponentFactory { readonly abstract componentType: Type ; readonly abstract inputs: { propName: string; templateName: string; }[]; readonly abstract ngContentSelectors: string[]; readonly abstract outputs: { propName: string; templateName: string; }[]; readonly abstract selector: string; abstract create(injector: Injector, projectableNodes?: any[][], rootSelectorOrNode?: string | any, ngModule?: NgModuleRef ): ComponentRef ;}export declare abstract class ComponentFactoryResolver { abstract resolveComponentFactory (component: Type ): ComponentFactory ; static NULL: ComponentFactoryResolver;}export declare abstract class ComponentRef { readonly abstract changeDetectorRef: ChangeDetectorRef; readonly abstract componentType: Type ; readonly abstract hostView: ViewRef; readonly abstract injector: Injector; readonly abstract instance: C; readonly abstract location: ElementRef; abstract destroy(): void; abstract onDestroy(callback: Function): void;}export declare const ContentChild: ContentChildDecorator;export interface ContentChildDecorator { (selector: Type | Function | string, opts?: { read?: any; }): any; new (selector: Type | Function | string, opts?: { read?: any; }): ContentChild;}export declare const ContentChildren: ContentChildrenDecorator;export interface ContentChildrenDecorator { (selector: Type | Function | string, opts?: { descendants?: boolean; read?: any; }): any; new (selector: Type | Function | string, opts?: { descendants?: boolean; read?: any; }): Query;}/** @experimental */export declare function createInjector(defType: any, parent?: Injector | null): Injector;/** @experimental */export declare function createPlatform(injector: Injector): PlatformRef;/** @experimental */export declare function createPlatformFactory(parentPlatformFactory: ((extraProviders?: StaticProvider[]) => PlatformRef) | null, name: string, providers?: StaticProvider[]): (extraProviders?: StaticProvider[]) => PlatformRef;export declare const CUSTOM_ELEMENTS_SCHEMA: SchemaMetadata;/** @experimental */export declare class DebugElement extends DebugNode { attributes: { [key: string]: string | null; }; childNodes: DebugNode[]; readonly children: DebugElement[]; classes: { [key: string]: boolean; }; name: string; nativeElement: any; properties: { [key: string]: any; }; styles: { [key: string]: string | null; }; constructor(nativeNode: any, parent: any, _debugContext: DebugContext); addChild(child: DebugNode): void; insertBefore(refChild: DebugNode, newChild: DebugNode): void; insertChildrenAfter(child: DebugNode, newChildren: DebugNode[]): void; query(predicate: Predicate ): DebugElement; queryAll(predicate: Predicate ): DebugElement[]; queryAllNodes(predicate: Predicate ): DebugNode[]; removeChild(child: DebugNode): void; triggerEventHandler(eventName: string, eventObj: any): void;}/** @experimental */export declare class DebugNode { readonly componentInstance: any; readonly context: any; readonly injector: Injector; listeners: EventListener[]; nativeNode: any; parent: DebugElement | null; readonly providerTokens: any[]; readonly references: { [key: string]: any; }; constructor(nativeNode: any, parent: DebugNode | null, _debugContext: DebugContext);}/** @deprecated */export declare class DefaultIterableDiffer implements IterableDiffer , IterableChanges { readonly collection: V[] | Iterable | null; readonly isDirty: boolean; readonly length: number; constructor(trackByFn?: TrackByFunction ); check(collection: NgIterable ): boolean; diff(collection: NgIterable ): DefaultIterableDiffer | null; forEachAddedItem(fn: (record: IterableChangeRecord_ ) => void): void; forEachIdentityChange(fn: (record: IterableChangeRecord_ ) => void): void; forEachItem(fn: (record: IterableChangeRecord_ ) => void): void; forEachMovedItem(fn: (record: IterableChangeRecord_ ) => void): void; forEachOperation(fn: (item: IterableChangeRecord , previousIndex: number | null, currentIndex: number | null) => void): void; forEachPreviousItem(fn: (record: IterableChangeRecord_ ) => void): void; forEachRemovedItem(fn: (record: IterableChangeRecord_ ) => void): void; onDestroy(): void;}/** @experimental */export declare function defineInjectable (opts: { providedIn?: Type | 'root' | 'any' | null; factory: () => T;}): never;/** @experimental */export declare function defineInjector(options: { factory: () => any; providers?: any[]; imports?: any[];}): never;/** @experimental */export declare function destroyPlatform(): void;export declare const Directive: DirectiveDecorator;export interface DirectiveDecorator { (obj: Directive): TypeDecorator; new (obj: Directive): Directive;}export interface DoCheck { ngDoCheck(): void;}export declare class ElementRef { nativeElement: T; constructor(nativeElement: T);}/** @experimental */export declare abstract class EmbeddedViewRef extends ViewRef { readonly abstract context: C; readonly abstract rootNodes: any[];}export declare function enableProdMode(): void;export declare class ErrorHandler { handleError(error: any): void;}export declare class EventEmitter extends Subject { __isAsync: boolean; constructor(isAsync?: boolean); emit(value?: T): void; subscribe(generatorOrNext?: any, error?: any, complete?: any): any;}export interface ExistingProvider extends ExistingSansProvider { multi?: boolean; provide: any;}export interface FactoryProvider extends FactorySansProvider { multi?: boolean; provide: any;}/** @experimental */export declare function forwardRef(forwardRefFn: ForwardRefFn): Type ;/** @experimental */export interface ForwardRefFn { (): any;}/** @experimental */export declare function getDebugNode(nativeNode: any): DebugNode | null;/** @experimental */export declare function getModuleFactory(id: string): NgModuleFactory ;/** @experimental */export declare function getPlatform(): PlatformRef | null;/** @experimental */export interface GetTestability { addToWindow(registry: TestabilityRegistry): void; findTestabilityInTree(registry: TestabilityRegistry, elem: any, findInAncestors: boolean): Testability | null;}export declare const Host: HostDecorator;export declare const HostBinding: HostBindingDecorator;export interface HostDecorator { (): any; new (): Host;}export declare const HostListener: HostListenerDecorator;/** @experimental */export declare function inject (token: Type | InjectionToken ): T;export declare function inject (token: Type | InjectionToken , flags?: InjectFlags): T | null;export declare const Inject: InjectDecorator;export declare const Injectable: InjectableDecorator;export interface InjectableDecorator { (): any; (options?: { providedIn: Type | 'root' | null; } & InjectableProvider): any; new (): Injectable; new (options?: { providedIn: Type | 'root' | null; } & InjectableProvider): Injectable;}/** @experimental */export declare type InjectableProvider = ValueSansProvider | ExistingSansProvider | StaticClassSansProvider | ConstructorSansProvider | FactorySansProvider | ClassSansProvider;/** @experimental */export interface InjectableType extends Type { ngInjectableDef: never;}export interface InjectDecorator { (token: any): any; new (token: any): Inject;}export declare const enum InjectFlags { Default = 0, Host = 1, Self = 2, SkipSelf = 4, Optional = 8,}export declare class InjectionToken { protected _desc: string; readonly ngInjectableDef: never | undefined; constructor(_desc: string, options?: { providedIn?: Type | 'root' | null; factory: () => T; }); toString(): string;}export declare abstract class Injector { abstract get (token: Type | InjectionToken , notFoundValue?: T, flags?: InjectFlags): T; /** @deprecated */ abstract get(token: any, notFoundValue?: any): any; static NULL: Injector; static THROW_IF_NOT_FOUND: Object; static ngInjectableDef: never; /** @deprecated */ static create(providers: StaticProvider[], parent?: Injector): Injector; static create(options: { providers: StaticProvider[]; parent?: Injector; name?: string; }): Injector;}/** @experimental */export declare const INJECTOR: InjectionToken ;/** @experimental */export interface InjectorType extends Type { ngInjectorDef: never;}export declare const Input: InputDecorator;/** @experimental */export declare function isDevMode(): boolean;export interface IterableChangeRecord { readonly currentIndex: number | null; readonly item: V; readonly previousIndex: number | null; readonly trackById: any;}export interface IterableChanges { forEachAddedItem(fn: (record: IterableChangeRecord ) => void): void; forEachIdentityChange(fn: (record: IterableChangeRecord ) => void): void; forEachItem(fn: (record: IterableChangeRecord ) => void): void; forEachMovedItem(fn: (record: IterableChangeRecord ) => void): void; forEachOperation(fn: (record: IterableChangeRecord , previousIndex: number | null, currentIndex: number | null) => void): void; forEachPreviousItem(fn: (record: IterableChangeRecord ) => void): void; forEachRemovedItem(fn: (record: IterableChangeRecord ) => void): void;}export interface IterableDiffer { diff(object: NgIterable ): IterableChanges | null;}export interface IterableDifferFactory { create (trackByFn?: TrackByFunction ): IterableDiffer ; supports(objects: any): boolean;}export declare class IterableDiffers { /** @deprecated */ factories: IterableDifferFactory[]; constructor(factories: IterableDifferFactory[]); find(iterable: any): IterableDifferFactory; static ngInjectableDef: never; static create(factories: IterableDifferFactory[], parent?: IterableDiffers): IterableDiffers; static extend(factories: IterableDifferFactory[]): StaticProvider;}export interface KeyValueChangeRecord { readonly currentValue: V | null; readonly key: K; readonly previousValue: V | null;}export interface KeyValueChanges { forEachAddedItem(fn: (r: KeyValueChangeRecord ) => void): void; forEachChangedItem(fn: (r: KeyValueChangeRecord ) => void): void; forEachItem(fn: (r: KeyValueChangeRecord ) => void): void; forEachPreviousItem(fn: (r: KeyValueChangeRecord ) => void): void; forEachRemovedItem(fn: (r: KeyValueChangeRecord ) => void): void;}export interface KeyValueDiffer { diff(object: Map ): KeyValueChanges ; diff(object: { [key: string]: V; }): KeyValueChanges ;}export interface KeyValueDifferFactory { create (): KeyValueDiffer ; supports(objects: any): boolean;}export declare class KeyValueDiffers { /** @deprecated */ factories: KeyValueDifferFactory[]; constructor(factories: KeyValueDifferFactory[]); find(kv: any): KeyValueDifferFactory; static create (factories: KeyValueDifferFactory[], parent?: KeyValueDiffers): KeyValueDiffers; static extend(factories: KeyValueDifferFactory[]): StaticProvider;}/** @experimental */export declare const LOCALE_ID: InjectionToken ;/** @experimental */export declare enum MissingTranslationStrategy { Error = 0, Warning = 1, Ignore = 2,}/** @experimental */export declare class ModuleWithComponentFactories { componentFactories: ComponentFactory []; ngModuleFactory: NgModuleFactory ; constructor(ngModuleFactory: NgModuleFactory , componentFactories: ComponentFactory []);}export interface ModuleWithProviders { ngModule: Type ; providers?: Provider[];}export declare type NgIterable = Array | Iterable ;export declare const NgModule: NgModuleDecorator;/** @experimental */export declare abstract class NgModuleFactory { readonly abstract moduleType: Type ; abstract create(parentInjector: Injector | null): NgModuleRef ;}export declare abstract class NgModuleFactoryLoader { abstract load(path: string): Promise >;}export declare abstract class NgModuleRef { readonly abstract componentFactoryResolver: ComponentFactoryResolver; readonly abstract injector: Injector; readonly abstract instance: T; abstract destroy(): void; abstract onDestroy(callback: () => void): void;}/** @experimental */export declare class NgProbeToken { name: string; token: any; constructor(name: string, token: any);}/** @experimental */export declare class NgZone { readonly hasPendingMacrotasks: boolean; readonly hasPendingMicrotasks: boolean; readonly isStable: boolean; readonly onError: EventEmitter ; readonly onMicrotaskEmpty: EventEmitter ; readonly onStable: EventEmitter ; readonly onUnstable: EventEmitter ; constructor({enableLongStackTrace}: { enableLongStackTrace?: boolean; }); run (fn: (...args: any[]) => T, applyThis?: any, applyArgs?: any[]): T; runGuarded (fn: (...args: any[]) => T, applyThis?: any, applyArgs?: any[]): T; runOutsideAngular (fn: (...args: any[]) => T): T; runTask (fn: (...args: any[]) => T, applyThis?: any, applyArgs?: any[], name?: string): T; static assertInAngularZone(): void; static assertNotInAngularZone(): void; static isInAngularZone(): boolean;}/** @experimental */export declare const NO_ERRORS_SCHEMA: SchemaMetadata;export interface OnChanges { ngOnChanges(changes: SimpleChanges): void;}export interface OnDestroy { ngOnDestroy(): void;}export interface OnInit { ngOnInit(): void;}export declare const Optional: OptionalDecorator;export interface OptionalDecorator { (): any; new (): Optional;}export declare const Output: OutputDecorator;/** @experimental */export declare const PACKAGE_ROOT_URL: InjectionToken ;export declare const Pipe: PipeDecorator;export interface PipeTransform { transform(value: any, ...args: any[]): any;}/** @experimental */export declare const PLATFORM_ID: InjectionToken