diff --git a/packages/compiler-cli/test/compliance/r3_view_compiler_styling_spec.ts b/packages/compiler-cli/test/compliance/r3_view_compiler_styling_spec.ts
index 250cb6bf56..29691ad60f 100644
--- a/packages/compiler-cli/test/compliance/r3_view_compiler_styling_spec.ts
+++ b/packages/compiler-cli/test/compliance/r3_view_compiler_styling_spec.ts
@@ -547,7 +547,7 @@ describe('compiler compliance: styling', () => {
                   $r3$.ɵɵstyleProp(0, $ctx$.myWidth);
                   $r3$.ɵɵstyleProp(1, $ctx$.myHeight);
                   $r3$.ɵɵstylingApply();
-                  $r3$.ɵɵelementAttribute(0, "style", $r3$.ɵɵbind("border-width: 10px"), $r3$.ɵɵsanitizeStyle);
+                  $r3$.ɵɵattribute("style", "border-width: 10px", $r3$.ɵɵsanitizeStyle);
                 }
               },
               encapsulation: 2
@@ -772,7 +772,7 @@ describe('compiler compliance: styling', () => {
                   $r3$.ɵɵclassProp(0, $ctx$.yesToApple);
                   $r3$.ɵɵclassProp(1, $ctx$.yesToOrange);
                   $r3$.ɵɵstylingApply();
-                  $r3$.ɵɵelementAttribute(0, "class", $r3$.ɵɵbind("banana"));
+                  $r3$.ɵɵattribute("class", "banana");
                 }
               },
               encapsulation: 2
@@ -822,8 +822,8 @@ describe('compiler compliance: styling', () => {
                 }
                 if (rf & 2) {
                   $r3$.ɵɵselect(0);
-                  $r3$.ɵɵelementAttribute(0, "class", $r3$.ɵɵbind("round"));
-                  $r3$.ɵɵelementAttribute(0, "style", $r3$.ɵɵbind("height:100px"), $r3$.ɵɵsanitizeStyle);
+                  $r3$.ɵɵattribute("class", "round");
+                  $r3$.ɵɵattribute("style", "height:100px", $r3$.ɵɵsanitizeStyle);
                 }
               },
               encapsulation: 2
diff --git a/packages/compiler/src/render3/r3_identifiers.ts b/packages/compiler/src/render3/r3_identifiers.ts
index af400aa98c..05de920cd9 100644
--- a/packages/compiler/src/render3/r3_identifiers.ts
+++ b/packages/compiler/src/render3/r3_identifiers.ts
@@ -41,6 +41,8 @@ export class Identifiers {
 
   static elementAttribute: o.ExternalReference = {name: 'ɵɵelementAttribute', moduleName: CORE};
 
+  static attribute: o.ExternalReference = {name: 'ɵɵattribute', moduleName: CORE};
+
   static classProp: o.ExternalReference = {name: 'ɵɵclassProp', moduleName: CORE};
 
   static elementContainerStart:
diff --git a/packages/compiler/src/render3/view/template.ts b/packages/compiler/src/render3/view/template.ts
index 32d990934b..c141d350bc 100644
--- a/packages/compiler/src/render3/view/template.ts
+++ b/packages/compiler/src/render3/view/template.ts
@@ -753,6 +753,7 @@ export class TemplateDefinitionBuilder implements t.Visitor<void>, LocalResolver
 
           if (inputType === BindingType.Property) {
             if (value instanceof Interpolation) {
+              // prop="{{value}}" and friends
               this.updateInstruction(
                   elementIndex, input.sourceSpan, getPropertyInterpolationExpression(value),
                   () =>
@@ -761,23 +762,33 @@ export class TemplateDefinitionBuilder implements t.Visitor<void>, LocalResolver
                        ...params]);
 
             } else {
-              // Bound, un-interpolated properties
+              // [prop]="value"
               this.updateInstruction(elementIndex, input.sourceSpan, R3.property, () => {
                 return [
                   o.literal(attrName), this.convertPropertyBinding(implicit, value, true), ...params
                 ];
               });
             }
-          } else {
-            let instruction: any;
-
-            if (inputType === BindingType.Class) {
-              instruction = R3.classProp;
+          } else if (inputType === BindingType.Attribute) {
+            if (value instanceof Interpolation) {
+              // attr.name="{{value}}" and friends
+              this.updateInstruction(elementIndex, input.sourceSpan, R3.elementAttribute, () => {
+                return [
+                  o.literal(elementIndex), o.literal(attrName),
+                  this.convertPropertyBinding(implicit, value), ...params
+                ];
+              });
             } else {
-              instruction = R3.elementAttribute;
+              // [attr.name]="value"
+              this.updateInstruction(elementIndex, input.sourceSpan, R3.attribute, () => {
+                return [
+                  o.literal(attrName), this.convertPropertyBinding(implicit, value, true), ...params
+                ];
+              });
             }
-
-            this.updateInstruction(elementIndex, input.sourceSpan, instruction, () => {
+          } else {
+            // class prop
+            this.updateInstruction(elementIndex, input.sourceSpan, R3.classProp, () => {
               return [
                 o.literal(elementIndex), o.literal(attrName),
                 this.convertPropertyBinding(implicit, value), ...params
diff --git a/packages/core/src/core_render3_private_export.ts b/packages/core/src/core_render3_private_export.ts
index f2b48983e4..96cfb3bd9b 100644
--- a/packages/core/src/core_render3_private_export.ts
+++ b/packages/core/src/core_render3_private_export.ts
@@ -8,6 +8,7 @@
 
 // clang-format off
 export {
+  ɵɵattribute,
   ɵɵdefineBase,
   ɵɵdefineComponent,
   ɵɵdefineDirective,
diff --git a/packages/core/src/render3/index.ts b/packages/core/src/render3/index.ts
index 34c39ec47f..b0ffe6aa71 100644
--- a/packages/core/src/render3/index.ts
+++ b/packages/core/src/render3/index.ts
@@ -21,7 +21,9 @@ export {
   markDirty,
   store,
   tick,
+
   ɵɵallocHostVars,
+  ɵɵattribute,
   ɵɵbind,
   ɵɵclassMap,
   ɵɵclassProp,
diff --git a/packages/core/src/render3/instructions/all.ts b/packages/core/src/render3/instructions/all.ts
index faee257e01..22017700fd 100644
--- a/packages/core/src/render3/instructions/all.ts
+++ b/packages/core/src/render3/instructions/all.ts
@@ -26,6 +26,7 @@
  * Jira Issue = FW-1184
  */
 export * from './alloc_host_vars';
+export * from './attribute';
 export * from './change_detection';
 export * from './container';
 export * from './storage';
diff --git a/packages/core/src/render3/instructions/attribute.ts b/packages/core/src/render3/instructions/attribute.ts
new file mode 100644
index 0000000000..478a1c2e4a
--- /dev/null
+++ b/packages/core/src/render3/instructions/attribute.ts
@@ -0,0 +1,31 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import {SanitizerFn} from '../interfaces/sanitization';
+import {getSelectedIndex} from '../state';
+
+import {ΔelementAttribute} from './element';
+import {Δbind} from './property';
+
+/**
+ * Updates the value of or removes a bound attribute on an Element.
+ *
+ * Used in the case of `[attr.title]="value"`
+ *
+ * @param name name The name of the attribute.
+ * @param value value The attribute is removed when value is `null` or `undefined`.
+ *                  Otherwise the attribute value is set to the stringified value.
+ * @param sanitizer An optional function used to sanitize the value.
+ * @param namespace Optional namespace to use when setting the attribute.
+ *
+ * @codeGenApi
+ */
+export function Δattribute(
+    name: string, value: any, sanitizer?: SanitizerFn | null, namespace?: string) {
+  const index = getSelectedIndex();
+  return ΔelementAttribute(index, name, Δbind(value), sanitizer, namespace);
+}
diff --git a/packages/core/src/render3/instructions/element.ts b/packages/core/src/render3/instructions/element.ts
index b6e859fd11..a288211792 100644
--- a/packages/core/src/render3/instructions/element.ts
+++ b/packages/core/src/render3/instructions/element.ts
@@ -198,7 +198,7 @@ export function ɵɵelement(
 
 
 /**
- * Updates the value of removes an attribute on an Element.
+ * Updates the value or removes an attribute on an Element.
  *
  * @param number index The index of the element in the data array
  * @param name name The name of the attribute.
diff --git a/packages/core/src/render3/jit/environment.ts b/packages/core/src/render3/jit/environment.ts
index 7dcb88d3a5..51e5432bdb 100644
--- a/packages/core/src/render3/jit/environment.ts
+++ b/packages/core/src/render3/jit/environment.ts
@@ -20,6 +20,7 @@ import * as r3 from '../index';
  */
 export const angularCoreEnv: {[name: string]: Function} =
     (() => ({
+       'ɵɵattribute': r3.ɵɵattribute,
        'ɵɵdefineBase': r3.ɵɵdefineBase,
        'ɵɵdefineComponent': r3.ɵɵdefineComponent,
        'ɵɵdefineDirective': r3.ɵɵdefineDirective,
diff --git a/tools/public_api_guard/core/core.d.ts b/tools/public_api_guard/core/core.d.ts
index 1a3c687730..1ca6059c4b 100644
--- a/tools/public_api_guard/core/core.d.ts
+++ b/tools/public_api_guard/core/core.d.ts
@@ -1,988 +1,962 @@
-export interface AbstractType<T> extends Function {
-    prototype: T;
-}
+export interface AbstractType<T> extends Function { prototype: T; }
 
-export interface AfterContentChecked {
-    ngAfterContentChecked(): void;
-}
+export interface AfterContentChecked { ngAfterContentChecked(): void; }
 
-export interface AfterContentInit {
-    ngAfterContentInit(): void;
-}
+export interface AfterContentInit { ngAfterContentInit(): void; }
 
-export interface AfterViewChecked {
-    ngAfterViewChecked(): void;
-}
+export interface AfterViewChecked { ngAfterViewChecked(): void; }
 
-export interface AfterViewInit {
-    ngAfterViewInit(): void;
-}
+export interface AfterViewInit { ngAfterViewInit(): void; }
 
 export declare const ANALYZE_FOR_ENTRY_COMPONENTS: InjectionToken<any>;
 
-export declare const APP_BOOTSTRAP_LISTENER: InjectionToken<((compRef: ComponentRef<any>) => void)[]>;
+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)[]);
+  readonly done = false;
+  readonly donePromise: Promise<any>;
+  constructor(appInits: (() => any)[]);
 }
 
-export declare class ApplicationModule {
-    constructor(appRef: ApplicationRef);
-}
+export declare class ApplicationModule { constructor(appRef: ApplicationRef); }
 
 export declare class ApplicationRef {
-    readonly componentTypes: Type<any>[];
-    readonly components: ComponentRef<any>[];
-    readonly isStable: Observable<boolean>;
-    readonly viewCount: number;
-    attachView(viewRef: ViewRef): void;
-    bootstrap<C>(componentOrFactory: ComponentFactory<C> | Type<C>, rootSelectorOrNode?: string | any): ComponentRef<C>;
-    detachView(viewRef: ViewRef): void;
-    tick(): void;
+  readonly componentTypes: Type<any>[];
+  readonly components: ComponentRef<any>[];
+  readonly isStable: Observable<boolean>;
+  readonly 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 function assertPlatform(requiredToken: any):
+        PlatformRef;
 
-export interface Attribute {
-    attributeName?: string;
-}
+    export interface Attribute {
+      attributeName?: string;
+    }
 
 export declare const Attribute: AttributeDecorator;
 
 export interface AttributeDecorator {
-    (name: string): any;
-    new (name: string): Attribute;
+  (name: string): any;
+  new (name: string): Attribute;
 }
 
-export declare enum ChangeDetectionStrategy {
-    OnPush = 0,
-    Default = 1
-}
+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;
+  abstract checkNoChanges(): void;
+  abstract detach(): void;
+  abstract detectChanges(): void;
+  abstract markForCheck(): void;
+  abstract reattach(): void;
 }
 
 export interface ClassProvider extends ClassSansProvider {
-    multi?: boolean;
-    provide: any;
+  multi?: boolean;
+  provide: any;
 }
 
 /** @deprecated */
-export interface CollectionChangeRecord<V> extends IterableChangeRecord<V> {
-}
+export 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;
+  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;
+  abstract createCompiler(options?: CompilerOptions[]): Compiler;
 }
 
 export declare type CompilerOptions = {
-    useJit?: boolean;
-    defaultEncapsulation?: ViewEncapsulation;
-    providers?: StaticProvider[];
-    missingTranslation?: MissingTranslationStrategy;
-    preserveWhitespaces?: boolean;
+  useJit?: boolean; defaultEncapsulation?: ViewEncapsulation; providers?: StaticProvider[];
+  missingTranslation?: MissingTranslationStrategy;
+  preserveWhitespaces?: boolean;
 };
 
 export interface Component extends Directive {
-    animations?: any[];
-    changeDetection?: ChangeDetectionStrategy;
-    encapsulation?: ViewEncapsulation;
-    entryComponents?: Array<Type<any> | any[]>;
-    interpolation?: [string, string];
-    moduleId?: string;
-    preserveWhitespaces?: boolean;
-    styleUrls?: string[];
-    styles?: string[];
-    template?: string;
-    templateUrl?: string;
-    viewProviders?: Provider[];
+  animations?: any[];
+  changeDetection?: ChangeDetectionStrategy;
+  encapsulation?: ViewEncapsulation;
+  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 interface ComponentDecorator {
-    (obj: Component): TypeDecorator;
-    new (obj: Component): Component;
+  (obj: Component): TypeDecorator;
+  new (obj: Component): Component;
 }
 
 export declare abstract class ComponentFactory<C> {
-    abstract readonly componentType: Type<any>;
-    abstract readonly inputs: {
-        propName: string;
-        templateName: string;
-    }[];
-    abstract readonly ngContentSelectors: string[];
-    abstract readonly outputs: {
-        propName: string;
-        templateName: string;
-    }[];
-    abstract readonly selector: string;
-    abstract create(injector: Injector, projectableNodes?: any[][], rootSelectorOrNode?: string | any, ngModule?: NgModuleRef<any>): ComponentRef<C>;
+  abstract readonly componentType: Type<any>;
+  abstract readonly inputs: {propName: string; templateName: string;}[];
+  abstract readonly ngContentSelectors: string[];
+  abstract readonly outputs: {propName: string; templateName: string;}[];
+  abstract readonly selector: string;
+  abstract create(
+      injector: Injector, projectableNodes?: any[][], rootSelectorOrNode?: string|any,
+      ngModule?: NgModuleRef<any>): ComponentRef<C>;
 }
 
 export declare abstract class ComponentFactoryResolver {
-    abstract resolveComponentFactory<T>(component: Type<T>): ComponentFactory<T>;
-    static NULL: ComponentFactoryResolver;
+  abstract resolveComponentFactory<T>(component: Type<T>): ComponentFactory<T>;
+  static NULL: ComponentFactoryResolver;
 }
 
 export declare abstract class ComponentRef<C> {
-    abstract readonly changeDetectorRef: ChangeDetectorRef;
-    abstract readonly componentType: Type<any>;
-    abstract readonly hostView: ViewRef;
-    abstract readonly injector: Injector;
-    abstract readonly instance: C;
-    abstract readonly location: ElementRef;
-    abstract destroy(): void;
-    abstract onDestroy(callback: Function): void;
+  abstract readonly changeDetectorRef: ChangeDetectorRef;
+  abstract readonly componentType: Type<any>;
+  abstract readonly hostView: ViewRef;
+  abstract readonly injector: Injector;
+  abstract readonly instance: C;
+  abstract readonly location: ElementRef;
+  abstract destroy(): void;
+  abstract onDestroy(callback: Function): void;
 }
 
-export interface ConstructorSansProvider {
-    deps?: any[];
-}
+export interface ConstructorSansProvider { deps?: any[]; }
 
 export declare type ContentChild = Query;
 
 export interface ContentChildDecorator {
-    (selector: Type<any> | Function | string, opts?: {
-        read?: any;
-        static?: boolean;
-    }): any;
-    new (selector: Type<any> | Function | string, opts?: {
-        read?: any;
-        static?: boolean;
-    }): ContentChild;
+  (selector: Type<any>|Function|string, opts?: {read?: any; static?: boolean;}): any;
+  new (selector: Type<any>|Function|string, opts?: {read?: any; static?: boolean;}): ContentChild;
 }
 
 export declare type ContentChildren = Query;
 
 export interface ContentChildrenDecorator {
-    (selector: Type<any> | Function | string, opts?: {
-        descendants?: boolean;
-        read?: any;
-    }): any;
-    new (selector: Type<any> | Function | string, opts?: {
-        descendants?: boolean;
-        read?: any;
-    }): Query;
+  (selector: Type<any>|Function|string, opts?: {descendants?: boolean; read?: any;}): any;
+  new (selector: Type<any>|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 function createPlatformFactory(
+        parentPlatformFactory: ((extraProviders?: StaticProvider[]) => PlatformRef) | null,
+        name: string, providers?: StaticProvider[]): (extraProviders?: StaticProvider[]) =>
+        PlatformRef;
 
-export declare const CUSTOM_ELEMENTS_SCHEMA: SchemaMetadata;
+    export declare const CUSTOM_ELEMENTS_SCHEMA:
+        SchemaMetadata;
 
-export 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 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 const DebugElement: {new (...args: any[]): DebugElement;};
 
 export declare class DebugEventListener {
-    callback: Function;
-    name: string;
-    constructor(name: string, callback: Function);
+  callback: Function;
+  name: string;
+  constructor(name: string, callback: Function);
 }
 
 export 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;
-    };
+  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 DebugNode: {new (...args: any[]): DebugNode;};
 
 /** @deprecated */
 export declare class DefaultIterableDiffer<V> implements IterableDiffer<V>, IterableChanges<V> {
-    readonly collection: V[] | Iterable<V> | null;
-    readonly isDirty: boolean;
-    readonly length: number;
-    constructor(trackByFn?: TrackByFunction<V>);
-    check(collection: NgIterable<V>): boolean;
-    diff(collection: NgIterable<V>): 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;
+  readonly collection: V[]|Iterable<V>|null;
+  readonly isDirty: boolean;
+  readonly length: number;
+  constructor(trackByFn?: TrackByFunction<V>);
+  check(collection: NgIterable<V>): boolean;
+  diff(collection: NgIterable<V>): 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 function destroyPlatform():
+    void;
 
-export interface Directive {
-    exportAs?: string;
-    host?: {
-        [key: string]: string;
-    };
-    inputs?: string[];
-    jit?: true;
-    outputs?: string[];
-    providers?: Provider[];
-    queries?: {
-        [key: string]: any;
-    };
-    selector?: string;
-}
+    export 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 interface DirectiveDecorator {
-    (obj: Directive): TypeDecorator;
-    new (obj: Directive): Directive;
+  (obj: Directive): TypeDecorator;
+  new (obj: Directive): Directive;
 }
 
-export interface DoBootstrap {
-    ngDoBootstrap(appRef: ApplicationRef): void;
-}
+export interface DoBootstrap { ngDoBootstrap(appRef: ApplicationRef): void; }
 
-export interface DoCheck {
-    ngDoCheck(): void;
-}
+export interface DoCheck { ngDoCheck(): void; }
 
 export declare class ElementRef<T = any> {
-    nativeElement: T;
-    constructor(nativeElement: T);
+  nativeElement: T;
+  constructor(nativeElement: T);
 }
 
 export declare abstract class EmbeddedViewRef<C> extends ViewRef {
-    abstract readonly context: C;
-    abstract readonly rootNodes: any[];
+  abstract readonly context: C;
+  abstract readonly rootNodes: any[];
 }
 
-export declare function enableProdMode(): void;
+export declare function enableProdMode():
+    void;
 
-export declare class ErrorHandler {
-    handleError(error: any): void;
-}
+    export declare class ErrorHandler {
+      handleError(error: any): void;
+    }
 
 export declare class EventEmitter<T> extends Subject<T> {
-    __isAsync: boolean;
-    constructor(isAsync?: boolean);
-    emit(value?: T): void;
-    subscribe(generatorOrNext?: any, error?: any, complete?: any): Subscription;
+  __isAsync: boolean;
+  constructor(isAsync?: boolean);
+  emit(value?: T): void;
+  subscribe(generatorOrNext?: any, error?: any, complete?: any): Subscription;
 }
 
 export interface ExistingProvider extends ExistingSansProvider {
-    multi?: boolean;
-    provide: any;
+  multi?: boolean;
+  provide: any;
 }
 
 export interface FactoryProvider extends FactorySansProvider {
-    multi?: boolean;
-    provide: any;
+  multi?: boolean;
+  provide: any;
 }
 
-export declare function forwardRef(forwardRefFn: ForwardRefFn): Type<any>;
+export declare function forwardRef(forwardRefFn: ForwardRefFn):
+    Type<any>;
 
-export interface ForwardRefFn {
-    (): any;
-}
+    export 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 function getPlatform():
+    PlatformRef|null;
 
-export interface GetTestability {
-    addToWindow(registry: TestabilityRegistry): void;
-    findTestabilityInTree(registry: TestabilityRegistry, elem: any, findInAncestors: boolean): Testability | null;
-}
+    export interface GetTestability {
+      addToWindow(registry: TestabilityRegistry): void;
+      findTestabilityInTree(
+          registry: TestabilityRegistry, elem: any, findInAncestors: boolean): Testability|null;
+    }
 
-export interface Host {
-}
+export interface Host {}
 
 export declare const Host: HostDecorator;
 
-export interface HostBinding {
-    hostPropertyName?: string;
-}
+export interface HostBinding { hostPropertyName?: string; }
 
 export declare const HostBinding: HostBindingDecorator;
 
 export interface HostBindingDecorator {
-    (hostPropertyName?: string): any;
-    new (hostPropertyName?: string): any;
+  (hostPropertyName?: string): any;
+  new (hostPropertyName?: string): any;
 }
 
 export interface HostDecorator {
-    (): any;
-    new (): Host;
+  (): any;
+  new (): Host;
 }
 
 export interface HostListener {
-    args?: string[];
-    eventName?: string;
+  args?: string[];
+  eventName?: string;
 }
 
 export declare const HostListener: HostListenerDecorator;
 
 export interface HostListenerDecorator {
-    (eventName: string, args?: string[]): any;
-    new (eventName: string, args?: string[]): any;
+  (eventName: string, args?: string[]): any;
+  new (eventName: string, args?: string[]): any;
 }
 
 export declare const inject: typeof ɵɵinject;
 
-export interface Inject {
-    token: any;
-}
+export interface Inject { token: any; }
 
 export declare const Inject: InjectDecorator;
 
-export interface Injectable {
-    providedIn?: Type<any> | 'root' | null;
-}
+export interface Injectable { providedIn?: Type<any>|'root'|null; }
 
 export declare const Injectable: InjectableDecorator;
 
 export interface InjectableDecorator {
-    (): TypeDecorator;
-    (options?: {
-        providedIn: Type<any> | 'root' | null;
-    } & InjectableProvider): TypeDecorator;
-    new (): Injectable;
-    new (options?: {
-        providedIn: Type<any> | 'root' | null;
-    } & InjectableProvider): Injectable;
+  (): TypeDecorator;
+  (options?: {providedIn: Type<any>| 'root' | null;}&InjectableProvider): TypeDecorator;
+  new (): Injectable;
+  new (options?: {providedIn: Type<any>| 'root' | null;}&InjectableProvider): Injectable;
 }
 
-export declare type InjectableProvider = ValueSansProvider | ExistingSansProvider | StaticClassSansProvider | ConstructorSansProvider | FactorySansProvider | ClassSansProvider;
+export declare type InjectableProvider = ValueSansProvider | ExistingSansProvider |
+    StaticClassSansProvider | ConstructorSansProvider | FactorySansProvider | ClassSansProvider;
 
-export interface InjectableType<T> extends Type<T> {
-    ngInjectableDef: never;
-}
+export interface InjectableType<T> extends Type<T> { ngInjectableDef: never; }
 
 export interface InjectDecorator {
-    (token: any): any;
-    new (token: any): Inject;
+  (token: any): any;
+  new (token: any): Inject;
 }
 
-export declare enum InjectFlags {
-    Default = 0,
-    Host = 1,
-    Self = 2,
-    SkipSelf = 4,
-    Optional = 8
-}
+export declare enum InjectFlags {Default = 0, Host = 1, Self = 2, SkipSelf = 4, Optional = 8}
 
 export declare class InjectionToken<T> {
-    protected _desc: string;
-    readonly ngInjectableDef: never | undefined;
-    constructor(_desc: string, options?: {
-        providedIn?: Type<any> | 'root' | null;
-        factory: () => T;
-    });
-    toString(): string;
+  protected _desc: string;
+  readonly ngInjectableDef: never|undefined;
+  constructor(_desc: string, options?: {providedIn?: Type<any>| 'root' | null; factory: () => T;});
+  toString(): string;
 }
 
 export declare abstract class Injector {
-    abstract get<T>(token: Type<T> | InjectionToken<T>, 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;
+  abstract get<T>(token: Type<T>|InjectionToken<T>, 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;
 }
 
 export declare const INJECTOR: InjectionToken<Injector>;
 
-export interface InjectorType<T> extends Type<T> {
-    ngInjectorDef: never;
-}
+export interface InjectorType<T> extends Type<T> { ngInjectorDef: never; }
 
-export interface Input {
-    bindingPropertyName?: string;
-}
+export interface Input { bindingPropertyName?: string; }
 
 export declare const Input: InputDecorator;
 
 export interface InputDecorator {
-    (bindingPropertyName?: string): any;
-    new (bindingPropertyName?: string): any;
+  (bindingPropertyName?: string): any;
+  new (bindingPropertyName?: string): any;
 }
 
-export declare function isDevMode(): boolean;
+export declare function isDevMode():
+    boolean;
 
-export interface IterableChangeRecord<V> {
-    readonly currentIndex: number | null;
-    readonly item: V;
-    readonly previousIndex: number | null;
-    readonly trackById: any;
-}
+    export interface IterableChangeRecord<V> {
+      readonly currentIndex: number|null;
+      readonly item: V;
+      readonly previousIndex: number|null;
+      readonly trackById: any;
+    }
 
 export 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;
+  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 interface IterableDiffer<V> {
-    diff(object: NgIterable<V>): IterableChanges<V> | null;
-}
+export interface IterableDiffer<V> { diff(object: NgIterable<V>): IterableChanges<V>|null; }
 
 export interface IterableDifferFactory {
-    create<V>(trackByFn?: TrackByFunction<V>): IterableDiffer<V>;
-    supports(objects: any): boolean;
+  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 ngInjectableDef: never;
-    static create(factories: IterableDifferFactory[], parent?: IterableDiffers): IterableDiffers;
-    static extend(factories: IterableDifferFactory[]): StaticProvider;
+  /** @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<K, V> {
-    readonly currentValue: V | null;
-    readonly key: K;
-    readonly previousValue: V | null;
+  readonly currentValue: V|null;
+  readonly key: K;
+  readonly previousValue: V|null;
 }
 
 export 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;
+  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 interface KeyValueDiffer<K, V> {
-    diff(object: Map<K, V>): KeyValueChanges<K, V> | null;
-    diff(object: {
-        [key: string]: V;
-    }): KeyValueChanges<string, V> | null;
+  diff(object: Map<K, V>): KeyValueChanges<K, V>|null;
+  diff(object: {[key: string]: V;}): KeyValueChanges<string, V>|null;
 }
 
 export interface KeyValueDifferFactory {
-    create<K, V>(): KeyValueDiffer<K, V>;
-    supports(objects: any): boolean;
+  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 ngInjectableDef: never;
-    static create<S>(factories: KeyValueDifferFactory[], parent?: KeyValueDiffers): KeyValueDiffers;
-    static extend<S>(factories: KeyValueDifferFactory[]): StaticProvider;
+  /** @deprecated */ factories: KeyValueDifferFactory[];
+  constructor(factories: KeyValueDifferFactory[]);
+  find(kv: any): KeyValueDifferFactory;
+  static ngInjectableDef: 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 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>[]);
+  componentFactories: ComponentFactory<any>[];
+  ngModuleFactory: NgModuleFactory<T>;
+  constructor(ngModuleFactory: NgModuleFactory<T>, componentFactories: ComponentFactory<any>[]);
 }
 
-export interface ModuleWithProviders<T = any /** TODO(alxhub): remove default when callers pass explicit type param */> {
-    ngModule: Type<T>;
-    providers?: Provider[];
+export interface ModuleWithProviders<
+    T = any /** TODO(alxhub): remove default when callers pass explicit type param */> {
+  ngModule: Type<T>;
+  providers?: Provider[];
 }
 
-export declare type NgIterable<T> = Array<T> | Iterable<T>;
+export declare type NgIterable<T> = Array<T>| Iterable<T>;
 
 export interface NgModule {
-    bootstrap?: Array<Type<any> | any[]>;
-    declarations?: Array<Type<any> | any[]>;
-    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[]>;
+  bootstrap?: Array<Type<any>|any[]>;
+  declarations?: Array<Type<any>|any[]>;
+  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 interface NgModuleDecorator {
-    (obj?: NgModule): TypeDecorator;
-    new (obj?: NgModule): NgModule;
+  (obj?: NgModule): TypeDecorator;
+  new (obj?: NgModule): NgModule;
 }
 
 export declare abstract class NgModuleFactory<T> {
-    abstract readonly moduleType: Type<T>;
-    abstract create(parentInjector: Injector | null): NgModuleRef<T>;
+  abstract readonly moduleType: Type<T>;
+  abstract create(parentInjector: Injector|null): NgModuleRef<T>;
 }
 
 /** @deprecated */
 export declare abstract class NgModuleFactoryLoader {
-    abstract load(path: string): Promise<NgModuleFactory<any>>;
+  abstract load(path: string): Promise<NgModuleFactory<any>>;
 }
 
 export declare abstract class NgModuleRef<T> {
-    abstract readonly componentFactoryResolver: ComponentFactoryResolver;
-    abstract readonly injector: Injector;
-    abstract readonly instance: T;
-    abstract destroy(): void;
-    abstract onDestroy(callback: () => void): void;
+  abstract readonly componentFactoryResolver: ComponentFactoryResolver;
+  abstract readonly injector: Injector;
+  abstract readonly instance: T;
+  abstract destroy(): void;
+  abstract onDestroy(callback: () => void): void;
 }
 
 export declare class NgProbeToken {
-    name: string;
-    token: any;
-    constructor(name: string, token: any);
+  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 }: {
-        enableLongStackTrace?: 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;
+  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}: {enableLongStackTrace?: 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 interface OnChanges {
-    ngOnChanges(changes: SimpleChanges): void;
-}
+export interface OnChanges { ngOnChanges(changes: SimpleChanges): void; }
 
-export interface OnDestroy {
-    ngOnDestroy(): void;
-}
+export interface OnDestroy { ngOnDestroy(): void; }
 
-export interface OnInit {
-    ngOnInit(): void;
-}
+export interface OnInit { ngOnInit(): void; }
 
-export interface Optional {
-}
+export interface Optional {}
 
 export declare const Optional: OptionalDecorator;
 
 export interface OptionalDecorator {
-    (): any;
-    new (): Optional;
+  (): any;
+  new (): Optional;
 }
 
-export interface Output {
-    bindingPropertyName?: string;
-}
+export interface Output { bindingPropertyName?: string; }
 
 export declare const Output: OutputDecorator;
 
 export interface OutputDecorator {
-    (bindingPropertyName?: string): any;
-    new (bindingPropertyName?: string): any;
+  (bindingPropertyName?: string): any;
+  new (bindingPropertyName?: string): any;
 }
 
-export declare function ɵɵallocHostVars(count: number): void;
+export declare function ɵɵallocHostVars(count: number):
+    void;
 
-export interface ɵɵBaseDef<T> {
-    contentQueries: ContentQueriesFunction<T> | null;
-    /** @deprecated */ readonly declaredInputs: {
-        [P in keyof T]: string;
-    };
-    hostBindings: HostBindingsFunction<T> | null;
-    readonly inputs: {
-        [P in keyof T]: string;
-    };
-    readonly outputs: {
-        [P in keyof T]: string;
-    };
-    viewQuery: ViewQueriesFunction<T> | null;
+    export interface ɵɵBaseDef<T> {
+      contentQueries: ContentQueriesFunction<T>|null;
+      /** @deprecated */ readonly declaredInputs: {[P in keyof T]: string;};
+      hostBindings: HostBindingsFunction<T>|null;
+      readonly inputs: {[P in keyof T]: string;};
+      readonly outputs: {[P in keyof T]: string;};
+      viewQuery: ViewQueriesFunction<T>|null;
+    }
+
+export declare function ɵɵbind<T>(value: T): T |
+    NO_CHANGE;
+
+export declare function ɵɵclassMap(
+    classes: {[styleName: string]: any;} | NO_CHANGE | string | null): void;
+
+    export declare function ɵɵclassProp(
+        classIndex: number, value: boolean | PlayerFactory, forceOverride?: boolean): void;
+
+    export declare type ɵɵComponentDefWithMeta < T, Selector extends String,
+    ExportAs extends string[], InputMap extends {
+      [key: string]: string;
+    }, OutputMap extends {
+  [key: string]: string;
 }
+, QueryFields extends string[] > = ComponentDef<T>;
 
-export declare function ɵɵbind<T>(value: T): T | NO_CHANGE;
+export declare function ɵɵcomponentHostSyntheticListener<T>(
+    eventName: string, listenerFn: (e?: any) => any, useCapture?: boolean,
+    eventTargetResolver?: GlobalTargetResolver): void;
 
-export declare function ɵɵclassMap(classes: {
-    [styleName: string]: any;
-} | NO_CHANGE | string | null): void;
-
-export declare function ɵɵclassProp(classIndex: number, value: boolean | PlayerFactory, forceOverride?: boolean): void;
-
-export declare type ɵɵComponentDefWithMeta<T, Selector extends String, ExportAs extends string[], InputMap extends {
-    [key: string]: string;
-}, OutputMap extends {
-    [key: string]: string;
-}, QueryFields extends string[]> = ComponentDef<T>;
-
-export declare function ɵɵcomponentHostSyntheticListener<T>(eventName: string, listenerFn: (e?: any) => any, useCapture?: boolean, eventTargetResolver?: GlobalTargetResolver): void;
-
-export declare function ɵɵcomponentHostSyntheticProperty<T>(index: number, propName: string, value: T | NO_CHANGE, sanitizer?: SanitizerFn | null, nativeOnly?: boolean): void;
+export declare function ɵɵcomponentHostSyntheticProperty<T>(
+    index: number, propName: string, value: T | NO_CHANGE, sanitizer?: SanitizerFn | null,
+    nativeOnly?: boolean): void;
 
 export declare function ɵɵcontainer(index: number): void;
 
-export declare function ɵɵcontainerRefreshEnd(): void;
+    export declare function ɵɵcontainerRefreshEnd(): void;
 
-export declare function ɵɵcontainerRefreshStart(index: number): void;
+    export declare function ɵɵcontainerRefreshStart(index: number): void;
 
-export declare function ɵɵcontentQuery<T>(directiveIndex: number, predicate: Type<any> | string[], descend: boolean, read: any): QueryList<T>;
+    export declare function ɵɵcontentQuery<T>(
+        directiveIndex: number, predicate: Type<any>| string[], descend: boolean, read: any):
+        QueryList<T>;
 
-export declare const ɵɵdefaultStyleSanitizer: StyleSanitizeFn;
+    export declare const ɵɵdefaultStyleSanitizer: StyleSanitizeFn;
 
-export declare function ɵɵdefineBase<T>(baseDefinition: {
-    inputs?: {
-        [P in keyof T]?: string | [string, string];
-    };
-    outputs?: {
-        [P in keyof T]?: string;
-    };
-    contentQueries?: ContentQueriesFunction<T> | null;
-    viewQuery?: ViewQueriesFunction<T> | null;
-    hostBindings?: HostBindingsFunction<T>;
-}): ɵɵBaseDef<T>;
+    export declare function ɵɵdefineBase<T>(baseDefinition: {
+      inputs?: {[P in keyof T]?: string | [string, string];};
+      outputs?: {[P in keyof T]?: string;};
+      contentQueries?: ContentQueriesFunction<T>|null;
+      viewQuery?: ViewQueriesFunction<T>|null;
+      hostBindings?: HostBindingsFunction<T>;
+    }): ɵɵBaseDef<T>;
 
 export declare function ɵɵdefineComponent<T>(componentDefinition: {
-    type: Type<T>;
-    selectors: CssSelectorList;
-    factory: FactoryFn<T>;
-    consts: number;
-    vars: number;
-    inputs?: {
-        [P in keyof T]?: string | [string, string];
-    };
-    outputs?: {
-        [P in keyof T]?: string;
-    };
-    hostBindings?: HostBindingsFunction<T>;
-    contentQueries?: ContentQueriesFunction<T>;
-    exportAs?: string[];
-    template: ComponentTemplate<T>;
-    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;
+  type: Type<T>; selectors: CssSelectorList; factory: FactoryFn<T>; consts: number; vars: number;
+  inputs?: {[P in keyof T]?: string | [string, string];};
+  outputs?: {[P in keyof T]?: string;};
+  hostBindings?: HostBindingsFunction<T>;
+  contentQueries?: ContentQueriesFunction<T>;
+  exportAs?: string[];
+  template: ComponentTemplate<T>;
+  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: (string | SelectorFlags)[][];
-    factory: FactoryFn<T>;
-    inputs?: { [P in keyof T]?: string | [string, string] | undefined; } | undefined;
-    outputs?: { [P in keyof T]?: string | undefined; } | undefined;
-    features?: DirectiveDefFeature[] | undefined;
-    hostBindings?: HostBindingsFunction<T> | undefined;
-    contentQueries?: ContentQueriesFunction<T> | undefined;
-    viewQuery?: ViewQueriesFunction<T> | null | undefined;
-    exportAs?: string[] | undefined;
+  type: Type<T>; selectors: (string | SelectorFlags)[][]; factory: FactoryFn<T>;
+  inputs?: {[P in keyof T]?: string | [string, string] | undefined;} | undefined;
+  outputs?: {[P in keyof T]?: string | undefined;} | undefined;
+  features?: DirectiveDefFeature[] | undefined;
+  hostBindings?: HostBindingsFunction<T>| undefined;
+  contentQueries?: ContentQueriesFunction<T>| undefined;
+  viewQuery?: ViewQueriesFunction<T>| null | undefined;
+  exportAs?: string[] | undefined;
 }) => never;
 
-export declare function ɵɵdefineInjectable<T>(opts: {
-    providedIn?: Type<any> | 'root' | 'any' | null;
-    factory: () => T;
-}): never;
+export declare function ɵɵdefineInjectable<T>(
+    opts: {providedIn?: Type<any>| 'root' | 'any' | null; factory: () => T;}): never;
 
-export declare function ɵɵdefineInjector(options: {
-    factory: () => any;
-    providers?: any[];
-    imports?: any[];
-}): 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 ɵɵ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>;
-    factory: FactoryFn<T>;
-    pure?: boolean;
-}): never;
+export declare function ɵɵdefinePipe<T>(
+    pipeDef: {name: string; type: Type<T>; factory: FactoryFn<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 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 ɵɵ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, attrs?: TAttributes | null, localRefs?: string[] | null): void;
+    export declare function ɵɵelement(
+        index: number, name: string, attrs?: TAttributes | null, localRefs?: string[] | null): void;
 
-export declare function ɵɵelementAttribute(index: number, name: string, value: any, sanitizer?: SanitizerFn | null, namespace?: string): void;
+    export declare function ɵɵelementAttribute(
+        index: number, name: string, value: any, sanitizer?: SanitizerFn | null,
+        namespace?: string): void;
 
-export declare function ɵɵelementContainerEnd(): void;
+    export declare function ɵɵelementContainerEnd(): void;
 
-export declare function ɵɵelementContainerStart(index: number, attrs?: TAttributes | null, localRefs?: string[] | null): void;
+    export declare function ɵɵelementContainerStart(
+        index: number, attrs?: TAttributes | null, localRefs?: string[] | null): void;
 
-export declare function ɵɵelementEnd(): void;
+    export declare function ɵɵelementEnd(): void;
 
-export declare function ɵɵelementHostAttrs(attrs: TAttributes): void;
+    export declare function ɵɵelementHostAttrs(attrs: TAttributes): void;
 
-export declare function ɵɵelementProperty<T>(index: number, propName: string, value: T | NO_CHANGE, sanitizer?: SanitizerFn | null, nativeOnly?: boolean): void;
+    export declare function ɵɵelementProperty<T>(
+        index: number, propName: string, value: T | NO_CHANGE, sanitizer?: SanitizerFn | null,
+        nativeOnly?: boolean): void;
 
-export declare function ɵɵelementStart(index: number, name: string, attrs?: TAttributes | null, localRefs?: string[] | null): void;
+    export declare function ɵɵelementStart(
+        index: number, name: string, attrs?: TAttributes | null, localRefs?: string[] | null): void;
 
-export declare function ɵɵembeddedViewEnd(): void;
+    export declare function ɵɵembeddedViewEnd(): void;
 
-export declare function ɵɵembeddedViewStart(viewBlockId: number, consts: number, vars: number): RenderFlags;
+    export declare function ɵɵembeddedViewStart(viewBlockId: number, consts: number, vars: number):
+        RenderFlags;
 
-export declare function ɵɵenableBindings(): void;
+    export declare function ɵɵenableBindings(): void;
 
-export declare function ɵɵgetCurrentView(): OpaqueViewState;
+    export declare function ɵɵgetCurrentView(): OpaqueViewState;
 
-export declare function ɵɵgetFactoryOf<T>(type: Type<any>): ((type: Type<T> | null) => T) | null;
+    export declare function ɵɵgetFactoryOf<T>(type: Type<any>): ((type: Type<T>| null) => T) | null;
 
-export declare function ɵɵgetInheritedFactory<T>(type: Type<any>): (type: Type<T>) => T;
+    export declare function ɵɵgetInheritedFactory<T>(type: Type<any>): (type: Type<T>) => T;
 
-export declare function ɵɵi18n(index: number, message: string, subTemplateIndex?: number): void;
+    export declare function ɵɵi18n(index: number, message: string, subTemplateIndex?: number): void;
 
-export declare function ɵɵi18nApply(index: number): void;
+    export declare function ɵɵi18nApply(index: number): void;
 
-export declare function ɵɵi18nAttributes(index: number, values: string[]): void;
+    export declare function ɵɵi18nAttributes(index: number, values: string[]): void;
 
-export declare function ɵɵi18nEnd(): void;
+    export declare function ɵɵi18nEnd(): void;
 
-export declare function ɵɵi18nExp<T>(expression: T | NO_CHANGE): void;
+    export declare function ɵɵi18nExp<T>(expression: T | NO_CHANGE): void;
 
-/** @deprecated */
-export declare function ɵɵi18nLocalize(input: string, placeholders?: {
-    [key: string]: string;
-}): string;
+    /** @deprecated */
+    export declare function ɵɵi18nLocalize(input: string, placeholders?: { [key: string]: string;}):
+        string;
 
-export declare function ɵɵi18nPostprocess(message: string, replacements?: {
-    [key: string]: (string | string[]);
-}): string;
+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 ɵɵi18nStart(index: number, message: string, subTemplateIndex?: number):
+        void;
 
-export declare function ɵɵInheritDefinitionFeature(definition: DirectiveDef<any> | ComponentDef<any>): 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 function ɵɵinject<T>(token: Type<T>| InjectionToken<T>):
+        T;
+    export declare function ɵɵinject<T>(token: Type<T>| InjectionToken<T>, flags?: InjectFlags): T |
+    null;
 
-export interface ɵɵInjectableDef<T> {
-    factory: () => T;
-    providedIn: InjectorType<any> | 'root' | 'any' | null;
-    value: T | undefined;
-}
+    export interface ɵɵInjectableDef<T> {
+      factory: () => T;
+      providedIn: InjectorType<any>|'root'|'any'|null;
+      value: T|undefined;
+    }
 
-export declare function ɵɵinjectAttribute(attrNameToInject: string): string | null;
+export declare function ɵɵinjectAttribute(attrNameToInject: string): string |
+    null;
 
-export interface ɵɵInjectorDef<T> {
-    factory: () => T;
-    imports: (InjectorType<any> | InjectorTypeWithProviders<any>)[];
-    providers: (Type<any> | ValueProvider | ExistingProvider | FactoryProvider | ConstructorProvider | StaticClassProvider | ClassProvider | any[])[];
-}
+    export interface ɵɵInjectorDef<T> {
+      factory: () => T;
+      imports: (InjectorType<any>| InjectorTypeWithProviders<any>)[];
+      providers:
+          (Type<any>| ValueProvider | ExistingProvider | FactoryProvider | ConstructorProvider |
+           StaticClassProvider | ClassProvider | any[])[];
+    }
 
-export declare function ɵɵinterpolation1(prefix: string, v0: any, suffix: string): string | NO_CHANGE;
+export declare function ɵɵinterpolation1(prefix: string, v0: any, suffix: string): string |
+    NO_CHANGE;
 
-export declare function ɵɵinterpolation2(prefix: string, v0: any, i0: string, v1: any, suffix: string): string | NO_CHANGE;
+    export declare function ɵɵinterpolation2(
+        prefix: string, v0: any, i0: string, v1: any, suffix: string): string |
+    NO_CHANGE;
 
-export declare function ɵɵinterpolation3(prefix: string, v0: any, i0: string, v1: any, i1: string, v2: any, suffix: string): string | NO_CHANGE;
+    export declare function ɵɵinterpolation3(
+        prefix: string, v0: any, i0: string, v1: any, i1: string, v2: any, suffix: string): string |
+    NO_CHANGE;
 
-export declare function ɵɵinterpolation4(prefix: string, v0: any, i0: string, v1: any, i1: string, v2: any, i2: string, v3: any, suffix: string): string | NO_CHANGE;
+    export declare function ɵɵinterpolation4(
+        prefix: string, v0: any, i0: string, v1: any, i1: string, v2: any, i2: string, v3: any,
+        suffix: string): string |
+    NO_CHANGE;
 
-export declare function ɵɵinterpolation5(prefix: string, v0: any, i0: string, v1: any, i1: string, v2: any, i2: string, v3: any, i3: string, v4: any, suffix: string): string | NO_CHANGE;
+    export declare function ɵɵinterpolation5(
+        prefix: string, v0: any, i0: string, v1: any, i1: string, v2: any, i2: string, v3: any,
+        i3: string, v4: any, suffix: string): string |
+    NO_CHANGE;
 
-export declare function ɵɵinterpolation6(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): string | NO_CHANGE;
+    export declare function ɵɵinterpolation6(
+        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): string |
+    NO_CHANGE;
 
-export declare function ɵɵinterpolation7(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): string | NO_CHANGE;
+    export declare function ɵɵinterpolation7(
+        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): string |
+    NO_CHANGE;
 
-export declare function ɵɵinterpolation8(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): string | NO_CHANGE;
+    export declare function ɵɵinterpolation8(
+        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): string |
+    NO_CHANGE;
 
-export declare function ɵɵinterpolationV(values: any[]): string | NO_CHANGE;
+    export declare function ɵɵinterpolationV(values: any[]): string | NO_CHANGE;
 
-export declare function ɵɵlistener(eventName: string, listenerFn: (e?: any) => any, useCapture?: boolean, eventTargetResolver?: GlobalTargetResolver): void;
+    export declare function ɵɵlistener(
+        eventName: string, listenerFn: (e?: any) => any, useCapture?: boolean,
+        eventTargetResolver?: GlobalTargetResolver): void;
 
-export declare function ɵɵload<T>(index: number): T;
+    export declare function ɵɵload<T>(index: number): T;
 
-export declare function ɵɵloadContentQuery<T>(): QueryList<T>;
+    export declare function ɵɵloadContentQuery<T>(): QueryList<T>;
 
-export declare function ɵɵloadViewQuery<T>(): T;
+    export declare function ɵɵloadViewQuery<T>(): T;
 
-export declare function ɵɵnamespaceHTML(): void;
+    export declare function ɵɵnamespaceHTML(): void;
 
-export declare function ɵɵnamespaceMathML(): void;
+    export declare function ɵɵnamespaceMathML(): void;
 
-export declare function ɵɵnamespaceSVG(): void;
+    export declare function ɵɵnamespaceSVG(): void;
 
-export declare function ɵɵnextContext<T = any>(level?: number): T;
+    export declare function ɵɵnextContext<T = any>(level?: number): T;
 
-export declare type ɵɵNgModuleDefWithMeta<T, Declarations, Imports, Exports> = NgModuleDef<T>;
+    export declare type ɵɵNgModuleDefWithMeta<T, Declarations, Imports, Exports> = NgModuleDef<T>;
 
-export declare function ɵɵNgOnChangesFeature<T>(): DirectiveDefFeature;
+    export declare function ɵɵNgOnChangesFeature<T>(): DirectiveDefFeature;
 
-export declare function ɵɵpipe(index: number, pipeName: string): any;
+    export declare function ɵɵpipe(index: number, pipeName: string): any;
 
-export declare function ɵɵpipeBind1(index: number, slotOffset: number, v1: any): 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 ɵɵ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 ɵɵ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 ɵɵ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;
+    export declare function ɵɵpipeBindV(index: number, slotOffset: number, values: any[]): any;
 
-export declare type ɵɵPipeDefWithMeta<T, Name extends string> = PipeDef<T>;
+    export declare type ɵɵPipeDefWithMeta<T, Name extends string> = PipeDef<T>;
 
-export declare function ɵɵprojection(nodeIndex: number, selectorIndex?: number, attrs?: TAttributes): void;
+    export declare function ɵɵprojection(
+        nodeIndex: number, selectorIndex?: number, attrs?: TAttributes): void;
 
-export declare function ɵɵprojectionDef(selectors?: CssSelectorList[]): void;
+    export declare function ɵɵprojectionDef(selectors?: CssSelectorList[]): void;
 
-export declare function ɵɵproperty<T>(propName: string, value: T, sanitizer?: SanitizerFn | null, nativeOnly?: boolean): TsickleIssue1009;
+    export declare function ɵɵproperty<T>(
+        propName: string, value: T, sanitizer?: SanitizerFn | null, nativeOnly?: boolean):
+        TsickleIssue1009;
 
-export declare function ɵɵpropertyInterpolate(propName: string, v0: any, sanitizer?: SanitizerFn): TsickleIssue1009;
+    export declare function ɵɵpropertyInterpolate(
+        propName: string, v0: any, sanitizer?: SanitizerFn): TsickleIssue1009;
 
-export declare function ɵɵpropertyInterpolate1(propName: string, prefix: string, v0: any, suffix: string, sanitizer?: SanitizerFn): TsickleIssue1009;
+    export declare function ɵɵpropertyInterpolate1(
+        propName: string, prefix: string, v0: any, suffix: string, sanitizer?: SanitizerFn):
+        TsickleIssue1009;
 
-export declare function ɵɵpropertyInterpolate2(propName: string, prefix: string, v0: any, i0: string, v1: any, suffix: string, sanitizer?: SanitizerFn): TsickleIssue1009;
+    export declare function ɵɵpropertyInterpolate2(
+        propName: string, prefix: string, v0: any, i0: string, v1: any, suffix: string,
+        sanitizer?: SanitizerFn): TsickleIssue1009;
 
-export declare function ɵɵpropertyInterpolate3(propName: string, prefix: string, v0: any, i0: string, v1: any, i1: string, v2: any, suffix: string, sanitizer?: SanitizerFn): TsickleIssue1009;
+    export declare function ɵɵpropertyInterpolate3(
+        propName: string, prefix: string, v0: any, i0: string, v1: any, i1: string, v2: any,
+        suffix: string, sanitizer?: SanitizerFn): TsickleIssue1009;
 
-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): TsickleIssue1009;
+    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): TsickleIssue1009;
 
-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): TsickleIssue1009;
+    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): TsickleIssue1009;
 
-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): TsickleIssue1009;
+    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): TsickleIssue1009;
 
-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): TsickleIssue1009;
+    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): TsickleIssue1009;
 
-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): TsickleIssue1009;
+    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): TsickleIssue1009;
 
-export declare function ɵɵpropertyInterpolateV(propName: string, values: any[], sanitizer?: SanitizerFn): TsickleIssue1009;
+    export declare function ɵɵpropertyInterpolateV(
+        propName: string, values: any[], sanitizer?: SanitizerFn): TsickleIssue1009;
 
-export declare function ɵɵProvidersFeature<T>(providers: Provider[], viewProviders?: Provider[]): (definition: DirectiveDef<T>) => void;
+    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 ɵɵ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 ɵɵ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 ɵɵ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 ɵɵ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 ɵɵ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 ɵɵ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 ɵɵ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 ɵɵ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 ɵɵ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 ɵɵpureFunctionV(
+        slotOffset: number, pureFn: (...v: any[]) => any, exps: any[], thisArg?: any): any;
 
-export declare function ɵɵqueryRefresh(queryList: QueryList<any>): boolean;
+    export declare function ɵɵqueryRefresh(queryList: QueryList<any>): boolean;
 
-export declare function ɵɵreference<T>(index: number): T;
+    export declare function ɵɵreference<T>(index: number): T;
 
-export declare function ɵɵresolveBody(element: RElement & {
-    ownerDocument: Document;
-}): {
-    name: string;
-    target: HTMLElement;
-};
+    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 ɵɵresolveDocument(element: RElement & { ownerDocument: Document;}):
+    {name: string; target: Document;};
 
 export declare function ɵɵresolveWindow(element: RElement & {
     ownerDocument: Document;