97dc85ba5e
Currently Angular internally already handles `InjectionToken` as predicates for queries. This commit exposes this as public API as developers already relied on this functionality but currently use workarounds to satisfy the type constraints (e.g. `as any`). We intend to make this public as it's low-effort to support, and it's a significant key part for the use of light-weight tokens as described in the upcoming guide: https://github.com/angular/angular/pull/36144. In concrete, applications might use injection tokens over classes for both optional DI and queries, because otherwise such references cause classes to be always retained. This was also an issue in View Engine, but now with Ivy, this pattern became worse, as factories are directly attached to retained classes (ultimately ending up in the production bundle, while being unused). More details in the light-weight token guide and in: https://github.com/angular/angular-cli/issues/16866. Closes #21152. Related to #36144. PR Close #37506
1446 lines
55 KiB
TypeScript
1446 lines
55 KiB
TypeScript
export declare interface AbstractType<T> extends Function {
|
|
prototype: T;
|
|
}
|
|
|
|
export declare interface AfterContentChecked {
|
|
ngAfterContentChecked(): void;
|
|
}
|
|
|
|
export declare interface AfterContentInit {
|
|
ngAfterContentInit(): void;
|
|
}
|
|
|
|
export declare interface AfterViewChecked {
|
|
ngAfterViewChecked(): void;
|
|
}
|
|
|
|
export declare interface AfterViewInit {
|
|
ngAfterViewInit(): void;
|
|
}
|
|
|
|
/** @deprecated */
|
|
export declare const ANALYZE_FOR_ENTRY_COMPONENTS: InjectionToken<any>;
|
|
|
|
export declare const APP_BOOTSTRAP_LISTENER: InjectionToken<((compRef: ComponentRef<any>) => void)[]>;
|
|
|
|
export declare const APP_ID: InjectionToken<string>;
|
|
|
|
export declare const APP_INITIALIZER: InjectionToken<(() => void)[]>;
|
|
|
|
export declare class ApplicationInitStatus {
|
|
readonly done = false;
|
|
readonly donePromise: Promise<any>;
|
|
constructor(appInits: (() => any)[]);
|
|
}
|
|
|
|
export declare class ApplicationModule {
|
|
constructor(appRef: ApplicationRef);
|
|
}
|
|
|
|
export declare class ApplicationRef {
|
|
readonly componentTypes: Type<any>[];
|
|
readonly components: ComponentRef<any>[];
|
|
readonly isStable: Observable<boolean>;
|
|
get viewCount(): number;
|
|
attachView(viewRef: ViewRef): void;
|
|
bootstrap<C>(componentOrFactory: ComponentFactory<C> | Type<C>, rootSelectorOrNode?: string | any): ComponentRef<C>;
|
|
detachView(viewRef: ViewRef): void;
|
|
tick(): void;
|
|
}
|
|
|
|
export declare function asNativeElements(debugEls: DebugElement[]): any;
|
|
|
|
export declare function assertPlatform(requiredToken: any): PlatformRef;
|
|
|
|
export declare interface Attribute {
|
|
attributeName?: string;
|
|
}
|
|
|
|
export declare const Attribute: AttributeDecorator;
|
|
|
|
export declare interface AttributeDecorator {
|
|
(name: string): any;
|
|
new (name: string): Attribute;
|
|
}
|
|
|
|
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 declare interface ClassProvider extends ClassSansProvider {
|
|
multi?: boolean;
|
|
provide: any;
|
|
}
|
|
|
|
export declare interface ClassSansProvider {
|
|
useClass: Type<any>;
|
|
}
|
|
|
|
/** @deprecated */
|
|
export declare interface CollectionChangeRecord<V> extends IterableChangeRecord<V> {
|
|
}
|
|
|
|
export declare class Compiler {
|
|
compileModuleAndAllComponentsAsync: <T>(moduleType: Type<T>) => Promise<ModuleWithComponentFactories<T>>;
|
|
compileModuleAndAllComponentsSync: <T>(moduleType: Type<T>) => ModuleWithComponentFactories<T>;
|
|
compileModuleAsync: <T>(moduleType: Type<T>) => Promise<NgModuleFactory<T>>;
|
|
compileModuleSync: <T>(moduleType: Type<T>) => NgModuleFactory<T>;
|
|
clearCache(): void;
|
|
clearCacheFor(type: Type<any>): void;
|
|
getModuleId(moduleType: Type<any>): string | undefined;
|
|
}
|
|
|
|
export declare const COMPILER_OPTIONS: InjectionToken<CompilerOptions[]>;
|
|
|
|
export declare abstract class CompilerFactory {
|
|
abstract createCompiler(options?: CompilerOptions[]): Compiler;
|
|
}
|
|
|
|
export declare type CompilerOptions = {
|
|
useJit?: boolean;
|
|
defaultEncapsulation?: ViewEncapsulation;
|
|
providers?: StaticProvider[];
|
|
missingTranslation?: MissingTranslationStrategy;
|
|
preserveWhitespaces?: boolean;
|
|
};
|
|
|
|
export declare interface Component extends Directive {
|
|
animations?: any[];
|
|
changeDetection?: ChangeDetectionStrategy;
|
|
encapsulation?: ViewEncapsulation;
|
|
/** @deprecated */ entryComponents?: Array<Type<any> | any[]>;
|
|
interpolation?: [string, string];
|
|
moduleId?: string;
|
|
preserveWhitespaces?: boolean;
|
|
styleUrls?: string[];
|
|
styles?: string[];
|
|
template?: string;
|
|
templateUrl?: string;
|
|
viewProviders?: Provider[];
|
|
}
|
|
|
|
export declare const Component: ComponentDecorator;
|
|
|
|
export declare interface ComponentDecorator {
|
|
(obj: Component): TypeDecorator;
|
|
new (obj: Component): Component;
|
|
}
|
|
|
|
export declare abstract class ComponentFactoryResolver {
|
|
abstract resolveComponentFactory<T>(component: Type<T>): ComponentFactory<T>;
|
|
static NULL: ComponentFactoryResolver;
|
|
}
|
|
|
|
export declare abstract class ComponentRef<C> {
|
|
abstract get changeDetectorRef(): ChangeDetectorRef;
|
|
abstract get componentType(): Type<any>;
|
|
abstract get hostView(): ViewRef;
|
|
abstract get injector(): Injector;
|
|
abstract get instance(): C;
|
|
abstract get location(): ElementRef;
|
|
abstract destroy(): void;
|
|
abstract onDestroy(callback: Function): void;
|
|
}
|
|
|
|
export declare interface ConstructorProvider extends ConstructorSansProvider {
|
|
multi?: boolean;
|
|
provide: Type<any>;
|
|
}
|
|
|
|
export declare interface ConstructorSansProvider {
|
|
deps?: any[];
|
|
}
|
|
|
|
export declare type ContentChild = Query;
|
|
|
|
export declare interface ContentChildDecorator {
|
|
(selector: Type<any> | InjectionToken<unknown> | Function | string, opts?: {
|
|
read?: any;
|
|
static?: boolean;
|
|
}): any;
|
|
new (selector: Type<any> | InjectionToken<unknown> | Function | string, opts?: {
|
|
read?: any;
|
|
static?: boolean;
|
|
}): ContentChild;
|
|
}
|
|
|
|
export declare type ContentChildren = Query;
|
|
|
|
export declare interface ContentChildrenDecorator {
|
|
(selector: Type<any> | InjectionToken<unknown> | Function | string, opts?: {
|
|
descendants?: boolean;
|
|
read?: any;
|
|
}): any;
|
|
new (selector: Type<any> | InjectionToken<unknown> | Function | string, opts?: {
|
|
descendants?: boolean;
|
|
read?: any;
|
|
}): Query;
|
|
}
|
|
|
|
export declare function createPlatform(injector: Injector): PlatformRef;
|
|
|
|
export declare function createPlatformFactory(parentPlatformFactory: ((extraProviders?: StaticProvider[]) => PlatformRef) | null, name: string, providers?: StaticProvider[]): (extraProviders?: StaticProvider[]) => PlatformRef;
|
|
|
|
export declare const CUSTOM_ELEMENTS_SCHEMA: SchemaMetadata;
|
|
|
|
export declare interface DebugElement extends DebugNode {
|
|
readonly attributes: {
|
|
[key: string]: string | null;
|
|
};
|
|
readonly childNodes: DebugNode[];
|
|
readonly children: DebugElement[];
|
|
readonly classes: {
|
|
[key: string]: boolean;
|
|
};
|
|
readonly name: string;
|
|
readonly nativeElement: any;
|
|
readonly properties: {
|
|
[key: string]: any;
|
|
};
|
|
readonly styles: {
|
|
[key: string]: string | null;
|
|
};
|
|
query(predicate: Predicate<DebugElement>): DebugElement;
|
|
queryAll(predicate: Predicate<DebugElement>): DebugElement[];
|
|
queryAllNodes(predicate: Predicate<DebugNode>): DebugNode[];
|
|
triggerEventHandler(eventName: string, eventObj: any): void;
|
|
}
|
|
|
|
export declare const DebugElement: {
|
|
new (...args: any[]): DebugElement;
|
|
};
|
|
|
|
export declare class DebugEventListener {
|
|
callback: Function;
|
|
name: string;
|
|
constructor(name: string, callback: Function);
|
|
}
|
|
|
|
export declare interface DebugNode {
|
|
readonly componentInstance: any;
|
|
readonly context: any;
|
|
readonly injector: Injector;
|
|
readonly listeners: DebugEventListener[];
|
|
readonly nativeNode: any;
|
|
readonly parent: DebugElement | null;
|
|
readonly providerTokens: any[];
|
|
readonly references: {
|
|
[key: string]: any;
|
|
};
|
|
}
|
|
|
|
export declare const DebugNode: {
|
|
new (...args: any[]): DebugNode;
|
|
};
|
|
|
|
export declare const DEFAULT_CURRENCY_CODE: InjectionToken<string>;
|
|
|
|
/** @deprecated */
|
|
export declare class DefaultIterableDiffer<V> implements IterableDiffer<V>, IterableChanges<V> {
|
|
readonly collection: V[] | Iterable<V> | null;
|
|
get isDirty(): boolean;
|
|
readonly length: number;
|
|
constructor(trackByFn?: TrackByFunction<V>);
|
|
check(collection: NgIterable<V>): boolean;
|
|
diff(collection: NgIterable<V> | null | undefined): DefaultIterableDiffer<V> | null;
|
|
forEachAddedItem(fn: (record: IterableChangeRecord_<V>) => void): void;
|
|
forEachIdentityChange(fn: (record: IterableChangeRecord_<V>) => void): void;
|
|
forEachItem(fn: (record: IterableChangeRecord_<V>) => void): void;
|
|
forEachMovedItem(fn: (record: IterableChangeRecord_<V>) => void): void;
|
|
forEachOperation(fn: (item: IterableChangeRecord<V>, previousIndex: number | null, currentIndex: number | null) => void): void;
|
|
forEachPreviousItem(fn: (record: IterableChangeRecord_<V>) => void): void;
|
|
forEachRemovedItem(fn: (record: IterableChangeRecord_<V>) => void): void;
|
|
onDestroy(): void;
|
|
}
|
|
|
|
/** @deprecated */
|
|
export declare const defineInjectable: typeof ɵɵdefineInjectable;
|
|
|
|
export declare function destroyPlatform(): void;
|
|
|
|
export declare interface Directive {
|
|
exportAs?: string;
|
|
host?: {
|
|
[key: string]: string;
|
|
};
|
|
inputs?: string[];
|
|
jit?: true;
|
|
outputs?: string[];
|
|
providers?: Provider[];
|
|
queries?: {
|
|
[key: string]: any;
|
|
};
|
|
selector?: string;
|
|
}
|
|
|
|
export declare const Directive: DirectiveDecorator;
|
|
|
|
export declare interface DirectiveDecorator {
|
|
(obj?: Directive): TypeDecorator;
|
|
new (obj?: Directive): Directive;
|
|
}
|
|
|
|
export declare interface DoBootstrap {
|
|
ngDoBootstrap(appRef: ApplicationRef): void;
|
|
}
|
|
|
|
export declare interface DoCheck {
|
|
ngDoCheck(): void;
|
|
}
|
|
|
|
export declare class ElementRef<T = any> {
|
|
nativeElement: T;
|
|
constructor(nativeElement: T);
|
|
}
|
|
|
|
export declare abstract class EmbeddedViewRef<C> extends ViewRef {
|
|
abstract get context(): C;
|
|
abstract get rootNodes(): any[];
|
|
}
|
|
|
|
export declare function enableProdMode(): void;
|
|
|
|
export declare class ErrorHandler {
|
|
handleError(error: any): void;
|
|
}
|
|
|
|
export declare interface EventEmitter<T> extends Subject<T> {
|
|
new (isAsync?: boolean): EventEmitter<T>;
|
|
emit(value?: T): void;
|
|
subscribe(generatorOrNext?: any, error?: any, complete?: any): Subscription;
|
|
}
|
|
|
|
export declare const EventEmitter: {
|
|
new (isAsync?: boolean): EventEmitter<any>;
|
|
new <T>(isAsync?: boolean): EventEmitter<T>;
|
|
readonly prototype: EventEmitter<any>;
|
|
};
|
|
|
|
export declare interface ExistingProvider extends ExistingSansProvider {
|
|
multi?: boolean;
|
|
provide: any;
|
|
}
|
|
|
|
export declare interface ExistingSansProvider {
|
|
useExisting: any;
|
|
}
|
|
|
|
export declare interface FactoryProvider extends FactorySansProvider {
|
|
multi?: boolean;
|
|
provide: any;
|
|
}
|
|
|
|
export declare interface FactorySansProvider {
|
|
deps?: any[];
|
|
useFactory: Function;
|
|
}
|
|
|
|
export declare function forwardRef(forwardRefFn: ForwardRefFn): Type<any>;
|
|
|
|
export declare interface ForwardRefFn {
|
|
(): any;
|
|
}
|
|
|
|
export declare const getDebugNode: (nativeNode: any) => DebugNode | null;
|
|
|
|
export declare const getModuleFactory: (id: string) => NgModuleFactory<any>;
|
|
|
|
export declare function getPlatform(): PlatformRef | null;
|
|
|
|
export declare interface GetTestability {
|
|
addToWindow(registry: TestabilityRegistry): void;
|
|
findTestabilityInTree(registry: TestabilityRegistry, elem: any, findInAncestors: boolean): Testability | null;
|
|
}
|
|
|
|
export declare interface Host {
|
|
}
|
|
|
|
export declare const Host: HostDecorator;
|
|
|
|
export declare interface HostBinding {
|
|
hostPropertyName?: string;
|
|
}
|
|
|
|
export declare const HostBinding: HostBindingDecorator;
|
|
|
|
export declare interface HostBindingDecorator {
|
|
(hostPropertyName?: string): any;
|
|
new (hostPropertyName?: string): any;
|
|
}
|
|
|
|
export declare interface HostDecorator {
|
|
(): any;
|
|
new (): Host;
|
|
}
|
|
|
|
export declare interface HostListener {
|
|
args?: string[];
|
|
eventName?: string;
|
|
}
|
|
|
|
export declare const HostListener: HostListenerDecorator;
|
|
|
|
export declare interface HostListenerDecorator {
|
|
(eventName: string, args?: string[]): any;
|
|
new (eventName: string, args?: string[]): any;
|
|
}
|
|
|
|
export declare const inject: typeof ɵɵinject;
|
|
|
|
export declare interface Inject {
|
|
token: any;
|
|
}
|
|
|
|
export declare const Inject: InjectDecorator;
|
|
|
|
export declare interface Injectable {
|
|
providedIn?: Type<any> | 'root' | 'platform' | 'any' | null;
|
|
}
|
|
|
|
export declare const Injectable: InjectableDecorator;
|
|
|
|
export declare interface InjectableDecorator {
|
|
(): TypeDecorator;
|
|
(options?: {
|
|
providedIn: Type<any> | 'root' | 'platform' | 'any' | null;
|
|
} & InjectableProvider): TypeDecorator;
|
|
new (): Injectable;
|
|
new (options?: {
|
|
providedIn: Type<any> | 'root' | 'platform' | 'any' | null;
|
|
} & InjectableProvider): Injectable;
|
|
}
|
|
|
|
export declare type InjectableProvider = ValueSansProvider | ExistingSansProvider | StaticClassSansProvider | ConstructorSansProvider | FactorySansProvider | ClassSansProvider;
|
|
|
|
export declare interface InjectableType<T> extends Type<T> {
|
|
ɵprov: never;
|
|
}
|
|
|
|
export declare interface InjectDecorator {
|
|
(token: any): any;
|
|
new (token: any): Inject;
|
|
}
|
|
|
|
export declare enum InjectFlags {
|
|
Default = 0,
|
|
Host = 1,
|
|
Self = 2,
|
|
SkipSelf = 4,
|
|
Optional = 8
|
|
}
|
|
|
|
export declare class InjectionToken<T> {
|
|
protected _desc: string;
|
|
readonly ɵprov: never | undefined;
|
|
constructor(_desc: string, options?: {
|
|
providedIn?: Type<any> | 'root' | 'platform' | 'any' | null;
|
|
factory: () => T;
|
|
});
|
|
toString(): string;
|
|
}
|
|
|
|
export declare abstract class Injector {
|
|
abstract get<T>(token: Type<T> | InjectionToken<T> | AbstractType<T>, notFoundValue?: T, flags?: InjectFlags): T;
|
|
/** @deprecated */ abstract get(token: any, notFoundValue?: any): any;
|
|
static NULL: Injector;
|
|
static THROW_IF_NOT_FOUND: {};
|
|
static ɵprov: never;
|
|
/** @deprecated */ static create(providers: StaticProvider[], parent?: Injector): Injector;
|
|
static create(options: {
|
|
providers: StaticProvider[];
|
|
parent?: Injector;
|
|
name?: string;
|
|
}): Injector;
|
|
}
|
|
|
|
export declare const INJECTOR: InjectionToken<Injector>;
|
|
|
|
export declare interface InjectorType<T> extends Type<T> {
|
|
ɵinj: never;
|
|
}
|
|
|
|
export declare interface Input {
|
|
bindingPropertyName?: string;
|
|
}
|
|
|
|
export declare const Input: InputDecorator;
|
|
|
|
export declare interface InputDecorator {
|
|
(bindingPropertyName?: string): any;
|
|
new (bindingPropertyName?: string): any;
|
|
}
|
|
|
|
export declare function isDevMode(): boolean;
|
|
|
|
export declare interface IterableChangeRecord<V> {
|
|
readonly currentIndex: number | null;
|
|
readonly item: V;
|
|
readonly previousIndex: number | null;
|
|
readonly trackById: any;
|
|
}
|
|
|
|
export declare interface IterableChanges<V> {
|
|
forEachAddedItem(fn: (record: IterableChangeRecord<V>) => void): void;
|
|
forEachIdentityChange(fn: (record: IterableChangeRecord<V>) => void): void;
|
|
forEachItem(fn: (record: IterableChangeRecord<V>) => void): void;
|
|
forEachMovedItem(fn: (record: IterableChangeRecord<V>) => void): void;
|
|
forEachOperation(fn: (record: IterableChangeRecord<V>, previousIndex: number | null, currentIndex: number | null) => void): void;
|
|
forEachPreviousItem(fn: (record: IterableChangeRecord<V>) => void): void;
|
|
forEachRemovedItem(fn: (record: IterableChangeRecord<V>) => void): void;
|
|
}
|
|
|
|
export declare interface IterableDiffer<V> {
|
|
diff(object: NgIterable<V> | undefined | null): IterableChanges<V> | null;
|
|
}
|
|
|
|
export declare interface IterableDifferFactory {
|
|
create<V>(trackByFn?: TrackByFunction<V>): IterableDiffer<V>;
|
|
supports(objects: any): boolean;
|
|
}
|
|
|
|
export declare class IterableDiffers {
|
|
/** @deprecated */ factories: IterableDifferFactory[];
|
|
constructor(factories: IterableDifferFactory[]);
|
|
find(iterable: any): IterableDifferFactory;
|
|
static ɵprov: never;
|
|
static create(factories: IterableDifferFactory[], parent?: IterableDiffers): IterableDiffers;
|
|
static extend(factories: IterableDifferFactory[]): StaticProvider;
|
|
}
|
|
|
|
export declare interface KeyValueChangeRecord<K, V> {
|
|
readonly currentValue: V | null;
|
|
readonly key: K;
|
|
readonly previousValue: V | null;
|
|
}
|
|
|
|
export declare interface KeyValueChanges<K, V> {
|
|
forEachAddedItem(fn: (r: KeyValueChangeRecord<K, V>) => void): void;
|
|
forEachChangedItem(fn: (r: KeyValueChangeRecord<K, V>) => void): void;
|
|
forEachItem(fn: (r: KeyValueChangeRecord<K, V>) => void): void;
|
|
forEachPreviousItem(fn: (r: KeyValueChangeRecord<K, V>) => void): void;
|
|
forEachRemovedItem(fn: (r: KeyValueChangeRecord<K, V>) => void): void;
|
|
}
|
|
|
|
export declare interface KeyValueDiffer<K, V> {
|
|
diff(object: Map<K, V>): KeyValueChanges<K, V> | null;
|
|
diff(object: {
|
|
[key: string]: V;
|
|
}): KeyValueChanges<string, V> | null;
|
|
}
|
|
|
|
export declare interface KeyValueDifferFactory {
|
|
create<K, V>(): KeyValueDiffer<K, V>;
|
|
supports(objects: any): boolean;
|
|
}
|
|
|
|
export declare class KeyValueDiffers {
|
|
/** @deprecated */ factories: KeyValueDifferFactory[];
|
|
constructor(factories: KeyValueDifferFactory[]);
|
|
find(kv: any): KeyValueDifferFactory;
|
|
static ɵprov: never;
|
|
static create<S>(factories: KeyValueDifferFactory[], parent?: KeyValueDiffers): KeyValueDiffers;
|
|
static extend<S>(factories: KeyValueDifferFactory[]): StaticProvider;
|
|
}
|
|
|
|
export declare const LOCALE_ID: InjectionToken<string>;
|
|
|
|
export declare enum MissingTranslationStrategy {
|
|
Error = 0,
|
|
Warning = 1,
|
|
Ignore = 2
|
|
}
|
|
|
|
export declare class ModuleWithComponentFactories<T> {
|
|
componentFactories: ComponentFactory<any>[];
|
|
ngModuleFactory: NgModuleFactory<T>;
|
|
constructor(ngModuleFactory: NgModuleFactory<T>, componentFactories: ComponentFactory<any>[]);
|
|
}
|
|
|
|
export declare interface ModuleWithProviders<T> {
|
|
ngModule: Type<T>;
|
|
providers?: Provider[];
|
|
}
|
|
|
|
export declare type NgIterable<T> = Array<T> | Iterable<T>;
|
|
|
|
export declare interface NgModule {
|
|
bootstrap?: Array<Type<any> | any[]>;
|
|
declarations?: Array<Type<any> | any[]>;
|
|
/** @deprecated */ entryComponents?: Array<Type<any> | any[]>;
|
|
exports?: Array<Type<any> | any[]>;
|
|
id?: string;
|
|
imports?: Array<Type<any> | ModuleWithProviders<{}> | any[]>;
|
|
jit?: true;
|
|
providers?: Provider[];
|
|
schemas?: Array<SchemaMetadata | any[]>;
|
|
}
|
|
|
|
export declare const NgModule: NgModuleDecorator;
|
|
|
|
export declare interface NgModuleDecorator {
|
|
(obj?: NgModule): TypeDecorator;
|
|
new (obj?: NgModule): NgModule;
|
|
}
|
|
|
|
export declare abstract class NgModuleFactory<T> {
|
|
abstract get moduleType(): Type<T>;
|
|
abstract create(parentInjector: Injector | null): NgModuleRef<T>;
|
|
}
|
|
|
|
/** @deprecated */
|
|
export declare abstract class NgModuleFactoryLoader {
|
|
abstract load(path: string): Promise<NgModuleFactory<any>>;
|
|
}
|
|
|
|
export declare abstract class NgModuleRef<T> {
|
|
abstract get componentFactoryResolver(): ComponentFactoryResolver;
|
|
abstract get injector(): Injector;
|
|
abstract get instance(): T;
|
|
abstract destroy(): void;
|
|
abstract onDestroy(callback: () => void): void;
|
|
}
|
|
|
|
export declare class NgProbeToken {
|
|
name: string;
|
|
token: any;
|
|
constructor(name: string, token: any);
|
|
}
|
|
|
|
export declare class NgZone {
|
|
readonly hasPendingMacrotasks: boolean;
|
|
readonly hasPendingMicrotasks: boolean;
|
|
readonly isStable: boolean;
|
|
readonly onError: EventEmitter<any>;
|
|
readonly onMicrotaskEmpty: EventEmitter<any>;
|
|
readonly onStable: EventEmitter<any>;
|
|
readonly onUnstable: EventEmitter<any>;
|
|
constructor({ enableLongStackTrace, shouldCoalesceEventChangeDetection }: {
|
|
enableLongStackTrace?: boolean | undefined;
|
|
shouldCoalesceEventChangeDetection?: boolean | undefined;
|
|
});
|
|
run<T>(fn: (...args: any[]) => T, applyThis?: any, applyArgs?: any[]): T;
|
|
runGuarded<T>(fn: (...args: any[]) => T, applyThis?: any, applyArgs?: any[]): T;
|
|
runOutsideAngular<T>(fn: (...args: any[]) => T): T;
|
|
runTask<T>(fn: (...args: any[]) => T, applyThis?: any, applyArgs?: any[], name?: string): T;
|
|
static assertInAngularZone(): void;
|
|
static assertNotInAngularZone(): void;
|
|
static isInAngularZone(): boolean;
|
|
}
|
|
|
|
export declare const NO_ERRORS_SCHEMA: SchemaMetadata;
|
|
|
|
export declare interface OnChanges {
|
|
ngOnChanges(changes: SimpleChanges): void;
|
|
}
|
|
|
|
export declare interface OnDestroy {
|
|
ngOnDestroy(): void;
|
|
}
|
|
|
|
export declare interface OnInit {
|
|
ngOnInit(): void;
|
|
}
|
|
|
|
export declare interface Optional {
|
|
}
|
|
|
|
export declare const Optional: OptionalDecorator;
|
|
|
|
export declare interface OptionalDecorator {
|
|
(): any;
|
|
new (): Optional;
|
|
}
|
|
|
|
export declare interface Output {
|
|
bindingPropertyName?: string;
|
|
}
|
|
|
|
export declare const Output: OutputDecorator;
|
|
|
|
export declare interface OutputDecorator {
|
|
(bindingPropertyName?: string): any;
|
|
new (bindingPropertyName?: string): any;
|
|
}
|
|
|
|
export declare function ɵɵadvance(delta: number): void;
|
|
|
|
export declare function ɵɵattribute(name: string, value: any, sanitizer?: SanitizerFn | null, namespace?: string): typeof ɵɵattribute;
|
|
|
|
export declare function ɵɵattributeInterpolate1(attrName: string, prefix: string, v0: any, suffix: string, sanitizer?: SanitizerFn, namespace?: string): typeof ɵɵattributeInterpolate1;
|
|
|
|
export declare function ɵɵattributeInterpolate2(attrName: string, prefix: string, v0: any, i0: string, v1: any, suffix: string, sanitizer?: SanitizerFn, namespace?: string): typeof ɵɵattributeInterpolate2;
|
|
|
|
export declare function ɵɵattributeInterpolate3(attrName: string, prefix: string, v0: any, i0: string, v1: any, i1: string, v2: any, suffix: string, sanitizer?: SanitizerFn, namespace?: string): typeof ɵɵattributeInterpolate3;
|
|
|
|
export declare function ɵɵ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;
|
|
|
|
export declare function ɵɵ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;
|
|
|
|
export declare function ɵɵ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;
|
|
|
|
export declare function ɵɵ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;
|
|
|
|
export declare function ɵɵ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;
|
|
|
|
export declare function ɵɵattributeInterpolateV(attrName: string, values: any[], sanitizer?: SanitizerFn, namespace?: string): typeof ɵɵattributeInterpolateV;
|
|
|
|
export declare function ɵɵclassMap(classes: {
|
|
[className: string]: boolean | undefined | null;
|
|
} | string | undefined | null): void;
|
|
|
|
export declare function ɵɵclassMapInterpolate1(prefix: string, v0: any, suffix: string): void;
|
|
|
|
export declare function ɵɵclassMapInterpolate2(prefix: string, v0: any, i0: string, v1: any, suffix: string): void;
|
|
|
|
export declare function ɵɵclassMapInterpolate3(prefix: string, v0: any, i0: string, v1: any, i1: string, v2: any, suffix: string): void;
|
|
|
|
export declare function ɵɵclassMapInterpolate4(prefix: string, v0: any, i0: string, v1: any, i1: string, v2: any, i2: string, v3: any, suffix: string): void;
|
|
|
|
export declare function ɵɵclassMapInterpolate5(prefix: string, v0: any, i0: string, v1: any, i1: string, v2: any, i2: string, v3: any, i3: string, v4: any, suffix: string): void;
|
|
|
|
export declare function ɵɵ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;
|
|
|
|
export declare function ɵɵ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;
|
|
|
|
export declare function ɵɵ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;
|
|
|
|
export declare function ɵɵclassMapInterpolateV(values: any[]): void;
|
|
|
|
export declare function ɵɵclassProp(className: string, value: boolean | undefined | null): typeof ɵɵclassProp;
|
|
|
|
export declare type ɵɵComponentDefWithMeta<T, Selector extends String, ExportAs extends string[], InputMap extends {
|
|
[key: string]: string;
|
|
}, OutputMap extends {
|
|
[key: string]: string;
|
|
}, QueryFields extends string[], NgContentSelectors extends string[]> = ɵComponentDef<T>;
|
|
|
|
export declare function ɵɵcomponentHostSyntheticListener(eventName: string, listenerFn: (e?: any) => any, useCapture?: boolean, eventTargetResolver?: GlobalTargetResolver): typeof ɵɵcomponentHostSyntheticListener;
|
|
|
|
export declare function ɵɵcontentQuery<T>(directiveIndex: number, predicate: Type<any> | InjectionToken<unknown> | string[], descend: boolean, read?: any): void;
|
|
|
|
export declare function ɵɵCopyDefinitionFeature(definition: ɵDirectiveDef<any> | ɵComponentDef<any>): void;
|
|
|
|
export declare function ɵɵ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?: TConstants;
|
|
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;
|
|
}): never;
|
|
|
|
export declare const ɵɵdefineDirective: <T>(directiveDefinition: {
|
|
type: Type<T>;
|
|
selectors?: ɵCssSelectorList | undefined;
|
|
inputs?: { [P in keyof T]?: string | [string, string] | undefined; } | undefined;
|
|
outputs?: { [P_1 in keyof T]?: string | undefined; } | undefined;
|
|
features?: DirectiveDefFeature[] | undefined;
|
|
hostBindings?: HostBindingsFunction<T> | undefined;
|
|
hostVars?: number | undefined;
|
|
hostAttrs?: TAttributes | undefined;
|
|
contentQueries?: ContentQueriesFunction<T> | undefined;
|
|
viewQuery?: ViewQueriesFunction<T> | null | undefined;
|
|
exportAs?: string[] | undefined;
|
|
}) => never;
|
|
|
|
export declare function ɵɵdefineInjectable<T>(opts: {
|
|
token: unknown;
|
|
providedIn?: Type<any> | 'root' | 'platform' | 'any' | null;
|
|
factory: () => T;
|
|
}): never;
|
|
|
|
export declare function ɵɵdefineInjector(options: {
|
|
factory: () => any;
|
|
providers?: any[];
|
|
imports?: any[];
|
|
}): never;
|
|
|
|
export declare function ɵɵ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;
|
|
}): never;
|
|
|
|
export declare function ɵɵdefinePipe<T>(pipeDef: {
|
|
name: string;
|
|
type: Type<T>;
|
|
pure?: boolean;
|
|
}): never;
|
|
|
|
export declare type ɵɵDirectiveDefWithMeta<T, Selector extends string, ExportAs extends string[], InputMap extends {
|
|
[key: string]: string;
|
|
}, OutputMap extends {
|
|
[key: string]: string;
|
|
}, QueryFields extends string[]> = ɵDirectiveDef<T>;
|
|
|
|
export declare function ɵɵdirectiveInject<T>(token: Type<T> | InjectionToken<T>): T;
|
|
export declare function ɵɵdirectiveInject<T>(token: Type<T> | InjectionToken<T>, flags: InjectFlags): T;
|
|
|
|
export declare function ɵɵdisableBindings(): void;
|
|
|
|
export declare function ɵɵelement(index: number, name: string, attrsIndex?: number | null, localRefsIndex?: number): void;
|
|
|
|
export declare function ɵɵelementContainer(index: number, attrsIndex?: number | null, localRefsIndex?: number): void;
|
|
|
|
export declare function ɵɵelementContainerEnd(): void;
|
|
|
|
export declare function ɵɵelementContainerStart(index: number, attrsIndex?: number | null, localRefsIndex?: number): void;
|
|
|
|
export declare function ɵɵelementEnd(): void;
|
|
|
|
export declare function ɵɵelementStart(index: number, name: string, attrsIndex?: number | null, localRefsIndex?: number): void;
|
|
|
|
export declare function ɵɵenableBindings(): void;
|
|
|
|
export declare type ɵɵFactoryDef<T, CtorDependencies extends CtorDependency[]> = () => T;
|
|
|
|
export declare function ɵɵgetCurrentView(): OpaqueViewState;
|
|
|
|
export declare function ɵɵgetFactoryOf<T>(type: Type<any>): FactoryFn<T> | null;
|
|
|
|
export declare function ɵɵgetInheritedFactory<T>(type: Type<any>): (type: Type<T>) => T;
|
|
|
|
export declare function ɵɵhostProperty<T>(propName: string, value: T, sanitizer?: SanitizerFn | null): typeof ɵɵhostProperty;
|
|
|
|
export declare function ɵɵi18n(index: number, message: string, subTemplateIndex?: number): void;
|
|
|
|
export declare function ɵɵi18nApply(index: number): void;
|
|
|
|
export declare function ɵɵi18nAttributes(index: number, values: string[]): void;
|
|
|
|
export declare function ɵɵi18nEnd(): void;
|
|
|
|
export declare function ɵɵi18nExp<T>(value: T): typeof ɵɵi18nExp;
|
|
|
|
export declare function ɵɵi18nPostprocess(message: string, replacements?: {
|
|
[key: string]: (string | string[]);
|
|
}): string;
|
|
|
|
export declare function ɵɵi18nStart(index: number, message: string, subTemplateIndex?: number): void;
|
|
|
|
export declare function ɵɵInheritDefinitionFeature(definition: ɵDirectiveDef<any> | ɵComponentDef<any>): void;
|
|
|
|
export declare function ɵɵinject<T>(token: Type<T> | InjectionToken<T>): T;
|
|
export declare function ɵɵinject<T>(token: Type<T> | InjectionToken<T>, flags?: InjectFlags): T | null;
|
|
|
|
export declare interface ɵɵInjectableDef<T> {
|
|
factory: (t?: Type<any>) => T;
|
|
providedIn: InjectorType<any> | 'root' | 'platform' | 'any' | null;
|
|
token: unknown;
|
|
value: T | undefined;
|
|
}
|
|
|
|
export declare function ɵɵinjectAttribute(attrNameToInject: string): string | null;
|
|
|
|
export declare interface ɵɵInjectorDef<T> {
|
|
factory: () => T;
|
|
imports: (InjectorType<any> | InjectorTypeWithProviders<any>)[];
|
|
providers: (Type<any> | ValueProvider | ExistingProvider | FactoryProvider | ConstructorProvider | StaticClassProvider | ClassProvider | any[])[];
|
|
}
|
|
|
|
export declare function ɵɵinjectPipeChangeDetectorRef(flags?: InjectFlags): ChangeDetectorRef | null;
|
|
|
|
export declare function ɵɵinvalidFactory(): never;
|
|
|
|
export declare function ɵɵinvalidFactoryDep(index: number): never;
|
|
|
|
export declare function ɵɵlistener(eventName: string, listenerFn: (e?: any) => any, useCapture?: boolean, eventTargetResolver?: GlobalTargetResolver): typeof ɵɵlistener;
|
|
|
|
export declare function ɵɵloadQuery<T>(): QueryList<T>;
|
|
|
|
export declare function ɵɵnamespaceHTML(): void;
|
|
|
|
export declare function ɵɵnamespaceMathML(): void;
|
|
|
|
export declare function ɵɵnamespaceSVG(): void;
|
|
|
|
export declare function ɵɵnextContext<T = any>(level?: number): T;
|
|
|
|
export declare type ɵɵNgModuleDefWithMeta<T, Declarations, Imports, Exports> = ɵNgModuleDef<T>;
|
|
|
|
export declare function ɵɵNgOnChangesFeature<T>(definition: ɵDirectiveDef<T>): void;
|
|
|
|
export declare function ɵɵpipe(index: number, pipeName: string): any;
|
|
|
|
export declare function ɵɵpipeBind1(index: number, slotOffset: number, v1: any): any;
|
|
|
|
export declare function ɵɵpipeBind2(index: number, slotOffset: number, v1: any, v2: any): any;
|
|
|
|
export declare function ɵɵpipeBind3(index: number, slotOffset: number, v1: any, v2: any, v3: any): any;
|
|
|
|
export declare function ɵɵpipeBind4(index: number, slotOffset: number, v1: any, v2: any, v3: any, v4: any): any;
|
|
|
|
export declare function ɵɵpipeBindV(index: number, slotOffset: number, values: [any, ...any[]]): any;
|
|
|
|
export declare type ɵɵPipeDefWithMeta<T, Name extends string> = ɵPipeDef<T>;
|
|
|
|
export declare function ɵɵprojection(nodeIndex: number, selectorIndex?: number, attrs?: TAttributes): void;
|
|
|
|
export declare function ɵɵprojectionDef(projectionSlots?: ProjectionSlots): void;
|
|
|
|
export declare function ɵɵproperty<T>(propName: string, value: T, sanitizer?: SanitizerFn | null): typeof ɵɵproperty;
|
|
|
|
export declare function ɵɵpropertyInterpolate(propName: string, v0: any, sanitizer?: SanitizerFn): typeof ɵɵpropertyInterpolate;
|
|
|
|
export declare function ɵɵpropertyInterpolate1(propName: string, prefix: string, v0: any, suffix: string, sanitizer?: SanitizerFn): typeof ɵɵpropertyInterpolate1;
|
|
|
|
export declare function ɵɵpropertyInterpolate2(propName: string, prefix: string, v0: any, i0: string, v1: any, suffix: string, sanitizer?: SanitizerFn): typeof ɵɵpropertyInterpolate2;
|
|
|
|
export declare function ɵɵpropertyInterpolate3(propName: string, prefix: string, v0: any, i0: string, v1: any, i1: string, v2: any, suffix: string, sanitizer?: SanitizerFn): typeof ɵɵpropertyInterpolate3;
|
|
|
|
export declare function ɵɵpropertyInterpolate4(propName: string, prefix: string, v0: any, i0: string, v1: any, i1: string, v2: any, i2: string, v3: any, suffix: string, sanitizer?: SanitizerFn): typeof ɵɵpropertyInterpolate4;
|
|
|
|
export declare function ɵɵpropertyInterpolate5(propName: 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): typeof ɵɵpropertyInterpolate5;
|
|
|
|
export declare function ɵɵpropertyInterpolate6(propName: 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): typeof ɵɵpropertyInterpolate6;
|
|
|
|
export declare function ɵɵpropertyInterpolate7(propName: 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): typeof ɵɵpropertyInterpolate7;
|
|
|
|
export declare function ɵɵpropertyInterpolate8(propName: 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): typeof ɵɵpropertyInterpolate8;
|
|
|
|
export declare function ɵɵpropertyInterpolateV(propName: string, values: any[], sanitizer?: SanitizerFn): typeof ɵɵpropertyInterpolateV;
|
|
|
|
export declare function ɵɵProvidersFeature<T>(providers: Provider[], viewProviders?: Provider[]): (definition: ɵDirectiveDef<T>) => void;
|
|
|
|
export declare function ɵɵpureFunction0<T>(slotOffset: number, pureFn: () => T, thisArg?: any): T;
|
|
|
|
export declare function ɵɵpureFunction1(slotOffset: number, pureFn: (v: any) => any, exp: any, thisArg?: any): any;
|
|
|
|
export declare function ɵɵpureFunction2(slotOffset: number, pureFn: (v1: any, v2: any) => any, exp1: any, exp2: any, thisArg?: any): any;
|
|
|
|
export declare function ɵɵpureFunction3(slotOffset: number, pureFn: (v1: any, v2: any, v3: any) => any, exp1: any, exp2: any, exp3: any, thisArg?: any): any;
|
|
|
|
export declare function ɵɵpureFunction4(slotOffset: number, pureFn: (v1: any, v2: any, v3: any, v4: any) => any, exp1: any, exp2: any, exp3: any, exp4: any, thisArg?: any): any;
|
|
|
|
export declare function ɵɵpureFunction5(slotOffset: number, pureFn: (v1: any, v2: any, v3: any, v4: any, v5: any) => any, exp1: any, exp2: any, exp3: any, exp4: any, exp5: any, thisArg?: any): any;
|
|
|
|
export declare function ɵɵpureFunction6(slotOffset: number, pureFn: (v1: any, v2: any, v3: any, v4: any, v5: any, v6: any) => any, exp1: any, exp2: any, exp3: any, exp4: any, exp5: any, exp6: any, thisArg?: any): any;
|
|
|
|
export declare function ɵɵpureFunction7(slotOffset: number, pureFn: (v1: any, v2: any, v3: any, v4: any, v5: any, v6: any, v7: any) => any, exp1: any, exp2: any, exp3: any, exp4: any, exp5: any, exp6: any, exp7: any, thisArg?: any): any;
|
|
|
|
export declare function ɵɵpureFunction8(slotOffset: number, pureFn: (v1: any, v2: any, v3: any, v4: any, v5: any, v6: any, v7: any, v8: any) => any, exp1: any, exp2: any, exp3: any, exp4: any, exp5: any, exp6: any, exp7: any, exp8: any, thisArg?: any): any;
|
|
|
|
export declare function ɵɵpureFunctionV(slotOffset: number, pureFn: (...v: any[]) => any, exps: any[], thisArg?: any): any;
|
|
|
|
export declare function ɵɵqueryRefresh(queryList: QueryList<any>): boolean;
|
|
|
|
export declare function ɵɵreference<T>(index: number): T;
|
|
|
|
export declare function ɵɵresolveBody(element: RElement & {
|
|
ownerDocument: Document;
|
|
}): {
|
|
name: string;
|
|
target: HTMLElement;
|
|
};
|
|
|
|
export declare function ɵɵresolveDocument(element: RElement & {
|
|
ownerDocument: Document;
|
|
}): {
|
|
name: string;
|
|
target: Document;
|
|
};
|
|
|
|
export declare function ɵɵresolveWindow(element: RElement & {
|
|
ownerDocument: Document;
|
|
}): {
|
|
name: string;
|
|
target: (Window & typeof globalThis) | null;
|
|
};
|
|
|
|
export declare function ɵɵrestoreView(viewToRestore: OpaqueViewState): void;
|
|
|
|
export declare function ɵɵsanitizeHtml(unsafeHtml: any): string;
|
|
|
|
export declare function ɵɵsanitizeResourceUrl(unsafeResourceUrl: any): string;
|
|
|
|
export declare function ɵɵsanitizeScript(unsafeScript: any): string;
|
|
|
|
export declare function ɵɵsanitizeStyle(unsafeStyle: any): string;
|
|
|
|
export declare function ɵɵsanitizeUrl(unsafeUrl: any): string;
|
|
|
|
export declare function ɵɵsanitizeUrlOrResourceUrl(unsafeUrl: any, tag: string, prop: string): any;
|
|
|
|
/** @deprecated */
|
|
export declare function ɵɵselect(index: number): void;
|
|
|
|
export declare function ɵɵsetComponentScope(type: ɵComponentType<any>, directives: Type<any>[], pipes: Type<any>[]): void;
|
|
|
|
export declare function ɵɵsetNgModuleScope(type: any, scope: {
|
|
declarations?: Type<any>[] | (() => Type<any>[]);
|
|
imports?: Type<any>[] | (() => Type<any>[]);
|
|
exports?: Type<any>[] | (() => Type<any>[]);
|
|
}): void;
|
|
|
|
export declare function ɵɵstaticContentQuery<T>(directiveIndex: number, predicate: Type<any> | InjectionToken<unknown> | string[], descend: boolean, read?: any): void;
|
|
|
|
export declare function ɵɵstaticViewQuery<T>(predicate: Type<any> | InjectionToken<unknown> | string[], descend: boolean, read?: any): void;
|
|
|
|
export declare function ɵɵstyleMap(styles: {
|
|
[styleName: string]: any;
|
|
} | string | undefined | null): void;
|
|
|
|
export declare function ɵɵstyleMapInterpolate1(prefix: string, v0: any, suffix: string): void;
|
|
|
|
export declare function ɵɵstyleMapInterpolate2(prefix: string, v0: any, i0: string, v1: any, suffix: string): void;
|
|
|
|
export declare function ɵɵstyleMapInterpolate3(prefix: string, v0: any, i0: string, v1: any, i1: string, v2: any, suffix: string): void;
|
|
|
|
export declare function ɵɵstyleMapInterpolate4(prefix: string, v0: any, i0: string, v1: any, i1: string, v2: any, i2: string, v3: any, suffix: string): void;
|
|
|
|
export declare function ɵɵstyleMapInterpolate5(prefix: string, v0: any, i0: string, v1: any, i1: string, v2: any, i2: string, v3: any, i3: string, v4: any, suffix: string): void;
|
|
|
|
export declare function ɵɵstyleMapInterpolate6(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;
|
|
|
|
export declare function ɵɵstyleMapInterpolate7(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;
|
|
|
|
export declare function ɵɵstyleMapInterpolate8(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;
|
|
|
|
export declare function ɵɵstyleMapInterpolateV(values: any[]): void;
|
|
|
|
export declare function ɵɵstyleProp(prop: string, value: string | number | ɵSafeValue | undefined | null, suffix?: string | null): typeof ɵɵstyleProp;
|
|
|
|
export declare function ɵɵstylePropInterpolate1(prop: string, prefix: string, v0: any, suffix: string, valueSuffix?: string | null): typeof ɵɵstylePropInterpolate1;
|
|
|
|
export declare function ɵɵstylePropInterpolate2(prop: string, prefix: string, v0: any, i0: string, v1: any, suffix: string, valueSuffix?: string | null): typeof ɵɵstylePropInterpolate2;
|
|
|
|
export declare function ɵɵstylePropInterpolate3(prop: string, prefix: string, v0: any, i0: string, v1: any, i1: string, v2: any, suffix: string, valueSuffix?: string | null): typeof ɵɵstylePropInterpolate3;
|
|
|
|
export declare function ɵɵstylePropInterpolate4(prop: string, prefix: string, v0: any, i0: string, v1: any, i1: string, v2: any, i2: string, v3: any, suffix: string, valueSuffix?: string | null): typeof ɵɵstylePropInterpolate4;
|
|
|
|
export declare function ɵɵstylePropInterpolate5(prop: string, prefix: string, v0: any, i0: string, v1: any, i1: string, v2: any, i2: string, v3: any, i3: string, v4: any, suffix: string, valueSuffix?: string | null): typeof ɵɵstylePropInterpolate5;
|
|
|
|
export declare function ɵɵstylePropInterpolate6(prop: 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, valueSuffix?: string | null): typeof ɵɵstylePropInterpolate6;
|
|
|
|
export declare function ɵɵstylePropInterpolate7(prop: 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, valueSuffix?: string | null): typeof ɵɵstylePropInterpolate7;
|
|
|
|
export declare function ɵɵstylePropInterpolate8(prop: 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, valueSuffix?: string | null): typeof ɵɵstylePropInterpolate8;
|
|
|
|
export declare function ɵɵstylePropInterpolateV(prop: string, values: any[], valueSuffix?: string | null): typeof ɵɵstylePropInterpolateV;
|
|
|
|
export declare function ɵɵtemplate(index: number, templateFn: ComponentTemplate<any> | null, decls: number, vars: number, tagName?: string | null, attrsIndex?: number | null, localRefsIndex?: number | null, localRefExtractor?: LocalRefExtractor): void;
|
|
|
|
export declare function ɵɵtemplateRefExtractor(tNode: TNode, currentView: ɵangular_packages_core_core_bo): TemplateRef<unknown> | null;
|
|
|
|
export declare function ɵɵtext(index: number, value?: string): void;
|
|
|
|
export declare function ɵɵtextInterpolate(v0: any): typeof ɵɵtextInterpolate;
|
|
|
|
export declare function ɵɵtextInterpolate1(prefix: string, v0: any, suffix: string): typeof ɵɵtextInterpolate1;
|
|
|
|
export declare function ɵɵtextInterpolate2(prefix: string, v0: any, i0: string, v1: any, suffix: string): typeof ɵɵtextInterpolate2;
|
|
|
|
export declare function ɵɵtextInterpolate3(prefix: string, v0: any, i0: string, v1: any, i1: string, v2: any, suffix: string): typeof ɵɵtextInterpolate3;
|
|
|
|
export declare function ɵɵtextInterpolate4(prefix: string, v0: any, i0: string, v1: any, i1: string, v2: any, i2: string, v3: any, suffix: string): typeof ɵɵtextInterpolate4;
|
|
|
|
export declare function ɵɵtextInterpolate5(prefix: string, v0: any, i0: string, v1: any, i1: string, v2: any, i2: string, v3: any, i3: string, v4: any, suffix: string): typeof ɵɵtextInterpolate5;
|
|
|
|
export declare function ɵɵtextInterpolate6(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): typeof ɵɵtextInterpolate6;
|
|
|
|
export declare function ɵɵtextInterpolate7(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): typeof ɵɵtextInterpolate7;
|
|
|
|
export declare function ɵɵtextInterpolate8(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): typeof ɵɵtextInterpolate8;
|
|
|
|
export declare function ɵɵtextInterpolateV(values: any[]): typeof ɵɵtextInterpolateV;
|
|
|
|
export declare function ɵɵupdateSyntheticHostBinding<T>(propName: string, value: T | ɵNO_CHANGE, sanitizer?: SanitizerFn | null): typeof ɵɵupdateSyntheticHostBinding;
|
|
|
|
export declare function ɵɵviewQuery<T>(predicate: Type<any> | InjectionToken<unknown> | string[], descend: boolean, read?: any): void;
|
|
|
|
export declare const PACKAGE_ROOT_URL: InjectionToken<string>;
|
|
|
|
export declare interface Pipe {
|
|
name: string;
|
|
pure?: boolean;
|
|
}
|
|
|
|
export declare const Pipe: PipeDecorator;
|
|
|
|
export declare interface PipeDecorator {
|
|
(obj: Pipe): TypeDecorator;
|
|
new (obj: Pipe): Pipe;
|
|
}
|
|
|
|
export declare interface PipeTransform {
|
|
transform(value: any, ...args: any[]): any;
|
|
}
|
|
|
|
export declare const PLATFORM_ID: InjectionToken<Object>;
|
|
|
|
export declare const PLATFORM_INITIALIZER: InjectionToken<(() => void)[]>;
|
|
|
|
export declare const platformCore: (extraProviders?: StaticProvider[] | undefined) => PlatformRef;
|
|
|
|
export declare class PlatformRef {
|
|
get destroyed(): boolean;
|
|
get injector(): Injector;
|
|
bootstrapModule<M>(moduleType: Type<M>, compilerOptions?: (CompilerOptions & BootstrapOptions) | Array<CompilerOptions & BootstrapOptions>): Promise<NgModuleRef<M>>;
|
|
bootstrapModuleFactory<M>(moduleFactory: NgModuleFactory<M>, options?: BootstrapOptions): Promise<NgModuleRef<M>>;
|
|
destroy(): void;
|
|
onDestroy(callback: () => void): void;
|
|
}
|
|
|
|
export declare interface Predicate<T> {
|
|
(value: T): boolean;
|
|
}
|
|
|
|
export declare type Provider = TypeProvider | ValueProvider | ClassProvider | ConstructorProvider | ExistingProvider | FactoryProvider | any[];
|
|
|
|
export declare interface Query {
|
|
descendants: boolean;
|
|
first: boolean;
|
|
isViewQuery: boolean;
|
|
read: any;
|
|
selector: any;
|
|
static?: boolean;
|
|
}
|
|
|
|
export declare abstract class Query {
|
|
}
|
|
|
|
export declare class QueryList<T> implements Iterable<T> {
|
|
[Symbol.iterator]: () => Iterator<T>;
|
|
readonly changes: Observable<any>;
|
|
readonly dirty = true;
|
|
readonly first: T;
|
|
readonly last: T;
|
|
readonly length: number;
|
|
constructor();
|
|
destroy(): void;
|
|
filter(fn: (item: T, index: number, array: T[]) => boolean): T[];
|
|
find(fn: (item: T, index: number, array: T[]) => boolean): T | undefined;
|
|
forEach(fn: (item: T, index: number, array: T[]) => void): void;
|
|
map<U>(fn: (item: T, index: number, array: T[]) => U): U[];
|
|
notifyOnChanges(): void;
|
|
reduce<U>(fn: (prevValue: U, curValue: T, curIndex: number, array: T[]) => U, init: U): U;
|
|
reset(resultsTree: Array<T | any[]>): void;
|
|
setDirty(): void;
|
|
some(fn: (value: T, index: number, array: T[]) => boolean): boolean;
|
|
toArray(): T[];
|
|
toString(): string;
|
|
}
|
|
|
|
/** @deprecated */
|
|
export declare abstract class ReflectiveInjector implements Injector {
|
|
abstract get parent(): Injector | null;
|
|
abstract createChildFromResolved(providers: ResolvedReflectiveProvider[]): ReflectiveInjector;
|
|
abstract get(token: any, notFoundValue?: any): any;
|
|
abstract instantiateResolved(provider: ResolvedReflectiveProvider): any;
|
|
abstract resolveAndCreateChild(providers: Provider[]): ReflectiveInjector;
|
|
abstract resolveAndInstantiate(provider: Provider): any;
|
|
static fromResolvedProviders(providers: ResolvedReflectiveProvider[], parent?: Injector): ReflectiveInjector;
|
|
static resolve(providers: Provider[]): ResolvedReflectiveProvider[];
|
|
static resolveAndCreate(providers: Provider[], parent?: Injector): ReflectiveInjector;
|
|
}
|
|
|
|
/** @deprecated */
|
|
export declare class ReflectiveKey {
|
|
readonly displayName: string;
|
|
id: number;
|
|
token: Object;
|
|
constructor(token: Object, id: number);
|
|
static get numberOfKeys(): number;
|
|
static get(token: Object): ReflectiveKey;
|
|
}
|
|
|
|
export declare abstract class Renderer2 {
|
|
abstract get data(): {
|
|
[key: string]: any;
|
|
};
|
|
destroyNode: ((node: any) => void) | null;
|
|
abstract addClass(el: any, name: string): void;
|
|
abstract appendChild(parent: any, newChild: any): void;
|
|
abstract createComment(value: string): any;
|
|
abstract createElement(name: string, namespace?: string | null): any;
|
|
abstract createText(value: string): any;
|
|
abstract destroy(): void;
|
|
abstract insertBefore(parent: any, newChild: any, refChild: any): void;
|
|
abstract listen(target: 'window' | 'document' | 'body' | any, eventName: string, callback: (event: any) => boolean | void): () => void;
|
|
abstract nextSibling(node: any): any;
|
|
abstract parentNode(node: any): any;
|
|
abstract removeAttribute(el: any, name: string, namespace?: string | null): void;
|
|
abstract removeChild(parent: any, oldChild: any, isHostElement?: boolean): void;
|
|
abstract removeClass(el: any, name: string): void;
|
|
abstract removeStyle(el: any, style: string, flags?: RendererStyleFlags2): void;
|
|
abstract selectRootElement(selectorOrNode: string | any, preserveContent?: boolean): any;
|
|
abstract setAttribute(el: any, name: string, value: string, namespace?: string | null): void;
|
|
abstract setProperty(el: any, name: string, value: any): void;
|
|
abstract setStyle(el: any, style: string, value: any, flags?: RendererStyleFlags2): void;
|
|
abstract setValue(node: any, value: string): void;
|
|
}
|
|
|
|
export declare abstract class RendererFactory2 {
|
|
abstract begin?(): void;
|
|
abstract createRenderer(hostElement: any, type: RendererType2 | null): Renderer2;
|
|
abstract end?(): void;
|
|
abstract whenRenderingDone?(): Promise<any>;
|
|
}
|
|
|
|
export declare enum RendererStyleFlags2 {
|
|
Important = 1,
|
|
DashCase = 2
|
|
}
|
|
|
|
export declare interface RendererType2 {
|
|
data: {
|
|
[kind: string]: any;
|
|
};
|
|
encapsulation: ViewEncapsulation;
|
|
id: string;
|
|
styles: (string | any[])[];
|
|
}
|
|
|
|
export declare class ResolvedReflectiveFactory {
|
|
dependencies: ɵangular_packages_core_core_e[];
|
|
factory: Function;
|
|
constructor(
|
|
factory: Function,
|
|
dependencies: ɵangular_packages_core_core_e[]);
|
|
}
|
|
|
|
export declare interface ResolvedReflectiveProvider {
|
|
key: ReflectiveKey;
|
|
multiProvider: boolean;
|
|
resolvedFactories: ResolvedReflectiveFactory[];
|
|
}
|
|
|
|
export declare function resolveForwardRef<T>(type: T): T;
|
|
|
|
export declare abstract class Sanitizer {
|
|
abstract sanitize(context: SecurityContext, value: {} | string | null): string | null;
|
|
static ɵprov: never;
|
|
}
|
|
|
|
export declare interface SchemaMetadata {
|
|
name: string;
|
|
}
|
|
|
|
export declare enum SecurityContext {
|
|
NONE = 0,
|
|
HTML = 1,
|
|
STYLE = 2,
|
|
SCRIPT = 3,
|
|
URL = 4,
|
|
RESOURCE_URL = 5
|
|
}
|
|
|
|
export declare interface Self {
|
|
}
|
|
|
|
export declare const Self: SelfDecorator;
|
|
|
|
export declare interface SelfDecorator {
|
|
(): any;
|
|
new (): Self;
|
|
}
|
|
|
|
export declare function setTestabilityGetter(getter: GetTestability): void;
|
|
|
|
export declare class SimpleChange {
|
|
currentValue: any;
|
|
firstChange: boolean;
|
|
previousValue: any;
|
|
constructor(previousValue: any, currentValue: any, firstChange: boolean);
|
|
isFirstChange(): boolean;
|
|
}
|
|
|
|
export declare interface SimpleChanges {
|
|
[propName: string]: SimpleChange;
|
|
}
|
|
|
|
export declare interface SkipSelf {
|
|
}
|
|
|
|
export declare const SkipSelf: SkipSelfDecorator;
|
|
|
|
export declare interface SkipSelfDecorator {
|
|
(): any;
|
|
new (): SkipSelf;
|
|
}
|
|
|
|
export declare interface StaticClassProvider extends StaticClassSansProvider {
|
|
multi?: boolean;
|
|
provide: any;
|
|
}
|
|
|
|
export declare interface StaticClassSansProvider {
|
|
deps: any[];
|
|
useClass: Type<any>;
|
|
}
|
|
|
|
export declare type StaticProvider = ValueProvider | ExistingProvider | StaticClassProvider | ConstructorProvider | FactoryProvider | any[];
|
|
|
|
/** @deprecated */
|
|
export declare class SystemJsNgModuleLoader implements NgModuleFactoryLoader {
|
|
constructor(_compiler: Compiler, config?: SystemJsNgModuleLoaderConfig);
|
|
load(path: string): Promise<NgModuleFactory<any>>;
|
|
}
|
|
|
|
/** @deprecated */
|
|
export declare abstract class SystemJsNgModuleLoaderConfig {
|
|
factoryPathPrefix: string;
|
|
factoryPathSuffix: string;
|
|
}
|
|
|
|
export declare abstract class TemplateRef<C> {
|
|
abstract get elementRef(): ElementRef;
|
|
abstract createEmbeddedView(context: C): EmbeddedViewRef<C>;
|
|
}
|
|
|
|
export declare class Testability implements PublicTestability {
|
|
constructor(_ngZone: NgZone);
|
|
/** @deprecated */ decreasePendingRequestCount(): number;
|
|
findProviders(using: any, provider: string, exactMatch: boolean): any[];
|
|
/** @deprecated */ getPendingRequestCount(): number;
|
|
/** @deprecated */ increasePendingRequestCount(): number;
|
|
isStable(): boolean;
|
|
whenStable(doneCb: Function, timeout?: number, updateCb?: Function): void;
|
|
}
|
|
|
|
export declare class TestabilityRegistry {
|
|
constructor();
|
|
findTestabilityInTree(elem: Node, findInAncestors?: boolean): Testability | null;
|
|
getAllRootElements(): any[];
|
|
getAllTestabilities(): Testability[];
|
|
getTestability(elem: any): Testability | null;
|
|
registerApplication(token: any, testability: Testability): void;
|
|
unregisterAllApplications(): void;
|
|
unregisterApplication(token: any): void;
|
|
}
|
|
|
|
export declare interface TrackByFunction<T> {
|
|
(index: number, item: T): any;
|
|
}
|
|
|
|
export declare const TRANSLATIONS: InjectionToken<string>;
|
|
|
|
export declare const TRANSLATIONS_FORMAT: InjectionToken<string>;
|
|
|
|
export declare const Type: FunctionConstructor;
|
|
|
|
export declare interface TypeDecorator {
|
|
(target: Object, propertyKey?: string | symbol, parameterIndex?: number): void;
|
|
<T extends Type<any>>(type: T): T;
|
|
}
|
|
|
|
export declare interface TypeProvider extends Type<any> {
|
|
}
|
|
|
|
export declare interface ValueProvider extends ValueSansProvider {
|
|
multi?: boolean;
|
|
provide: any;
|
|
}
|
|
|
|
export declare interface ValueSansProvider {
|
|
useValue: any;
|
|
}
|
|
|
|
export declare class Version {
|
|
full: string;
|
|
readonly major: string;
|
|
readonly minor: string;
|
|
readonly patch: string;
|
|
constructor(full: string);
|
|
}
|
|
|
|
export declare const VERSION: Version;
|
|
|
|
export declare type ViewChild = Query;
|
|
|
|
export declare interface ViewChildDecorator {
|
|
(selector: Type<any> | InjectionToken<unknown> | Function | string, opts?: {
|
|
read?: any;
|
|
static?: boolean;
|
|
}): any;
|
|
new (selector: Type<any> | InjectionToken<unknown> | Function | string, opts?: {
|
|
read?: any;
|
|
static?: boolean;
|
|
}): ViewChild;
|
|
}
|
|
|
|
export declare type ViewChildren = Query;
|
|
|
|
export declare interface ViewChildrenDecorator {
|
|
(selector: Type<any> | InjectionToken<unknown> | Function | string, opts?: {
|
|
read?: any;
|
|
}): any;
|
|
new (selector: Type<any> | InjectionToken<unknown> | Function | string, opts?: {
|
|
read?: any;
|
|
}): ViewChildren;
|
|
}
|
|
|
|
export declare abstract class ViewContainerRef {
|
|
abstract get element(): ElementRef;
|
|
abstract get injector(): Injector;
|
|
abstract get length(): number;
|
|
/** @deprecated */ abstract get parentInjector(): Injector;
|
|
abstract clear(): void;
|
|
abstract createComponent<C>(componentFactory: ComponentFactory<C>, index?: number, injector?: Injector, projectableNodes?: any[][], ngModule?: NgModuleRef<any>): ComponentRef<C>;
|
|
abstract createEmbeddedView<C>(templateRef: TemplateRef<C>, context?: C, index?: number): EmbeddedViewRef<C>;
|
|
abstract detach(index?: number): ViewRef | null;
|
|
abstract get(index: number): ViewRef | null;
|
|
abstract indexOf(viewRef: ViewRef): number;
|
|
abstract insert(viewRef: ViewRef, index?: number): ViewRef;
|
|
abstract move(viewRef: ViewRef, currentIndex: number): ViewRef;
|
|
abstract remove(index?: number): void;
|
|
}
|
|
|
|
export declare enum ViewEncapsulation {
|
|
Emulated = 0,
|
|
Native = 1,
|
|
None = 2,
|
|
ShadowDom = 3
|
|
}
|
|
|
|
export declare abstract class ViewRef extends ChangeDetectorRef {
|
|
abstract get destroyed(): boolean;
|
|
abstract destroy(): void;
|
|
abstract onDestroy(callback: Function): any /** TODO #9100 */;
|
|
}
|
|
|
|
/** @deprecated */
|
|
export declare class WrappedValue {
|
|
/** @deprecated */ wrapped: any;
|
|
constructor(value: any);
|
|
static isWrapped(value: any): value is WrappedValue;
|
|
static unwrap(value: any): any;
|
|
static wrap(value: any): WrappedValue;
|
|
}
|