@angular/core 8.0.0 → 8.1.0-beta.0

package/core.d.ts

@@ -1,5 +1,5 @@
 /**
- * @license Angular v8.0.0
+ * @license Angular v8.1.0-beta.0
  * (c) 2010-2019 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -1142,7 +1142,6 @@ export declare abstract class ComponentRef<C> {
  */
 declare type ComponentTemplate<T> = {
     <U extends T>(rf: ɵRenderFlags, ctx: T | U): void;
-    ngPrivateData?: never;
 };
 
 /**
@@ -1356,7 +1355,7 @@ declare interface CreateComponentOptions {
      * Typically, the features in this list are features that cannot be added to the
      * other features list in the component definition because they rely on other factors.
      *
-     * Example: `RootLifecycleHooks` is a function that adds lifecycle hook capabilities
+     * Example: `LifecycleHooksFeature` is a function that adds lifecycle hook capabilities
      * to root components in a tree-shakable way. It cannot be added to the component
      * features list because there's no way of knowing when the component will be used as
      * a root component.
@@ -2608,7 +2607,7 @@ declare type HostFeature = (<T>(component: T, componentDef: ɵComponentDef<T>) =
  * the styling is applied).
  *
  * This queue is used when any `hostStyling` instructions are executed from the `hostBindings`
- * function. Template-level styling functions (e.g. `elementStylingMap` and `elementClassProp`)
+ * function. Template-level styling functions (e.g. `styleMap` and `classProp`)
  * do not make use of this queue (they are applied to the styling context immediately).
  *
  * Due to the nature of how components/directives are evaluated, directives (both parent and
@@ -2642,7 +2641,7 @@ declare type HostFeature = (<T>(component: T, componentDef: ɵComponentDef<T>) =
  * inside of `renderStyling`).
  *
  * Right now each directive's hostBindings function, as well the template function, both
- * call `elementStylingApply()` and `hostStylingApply()`. The fact that this is called
+ * call `stylingApply()` and `hostStylingApply()`. The fact that this is called
  * multiple times for the same element (b/c of change detection) causes some issues. To avoid
  * having styling code be rendered on an element multiple times, the `HostInstructionsQueue`
  * reserves a slot for a reference pointing to the very last directive that was registered and
@@ -3807,14 +3806,6 @@ declare interface LContainer extends Array<any> {
     [T_HOST]: TNode;
     /** The comment element that serves as an anchor for this LContainer. */
     readonly [NATIVE]: RComment;
-    /**
-  *A list of the container's currently active child views. Views will be inserted
-  *here as they are added and spliced from here when they are removed. We need
-  *to keep a record of current views so we know which views are already in the DOM
-  *(and don't need to be re-added) and so we can remove views from the DOM when they
-  *are no longer required.
-  */
-    [VIEWS]: ɵangular_packages_core_core_bm[];
 }
 
 /**
@@ -3908,6 +3899,36 @@ declare interface LQueries {
     track<T>(queryList: QueryList<T>, predicate: Type<any> | string[], descend?: boolean, read?: Type<T>): void;
 }
 
+/**
+ * Array-based representation of a key/value array.
+ *
+ * The format of the array is "property", "value", "property2",
+ * "value2", etc...
+ *
+ * The first value in the array is reserved to store the instance
+ * of the key/value array that was used to populate the property/
+ * value entries that take place in the remainder of the array.
+ */
+declare interface LStylingMap extends Array<{} | string | number | null> {
+    [LStylingMapIndex.RawValuePosition]: {} | string | null;
+}
+
+/**
+ * An index of position and offset points for any data stored within a `LStylingMap` instance.
+ */
+declare const enum LStylingMapIndex {
+    /** The location of the raw key/value map instance used last to populate the array entries */
+    RawValuePosition = 0,
+    /** Where the values start in the array */
+    ValuesStartPosition = 1,
+    /** The size of each property/value entry */
+    TupleSize = 2,
+    /** The offset for the property entry in the tuple */
+    PropOffset = 0,
+    /** The offset for the value entry in the tuple */
+    ValueOffset = 1
+}
+
 /** Flags associated with an LView (saved in LView[FLAGS]) */
 declare const enum LViewFlags {
     /** The state of the init phase on the first 2 bits */
@@ -5380,6 +5401,7 @@ declare class R3Injector {
      */
     destroy(): void;
     get<T>(token: Type<T> | InjectionToken<T>, notFoundValue?: any, flags?: InjectFlags): T;
+    toString(): string;
     private assertNotDestroyed;
     /**
      * Add an `InjectorType` or `InjectorDefTypeWithProviders` and all of its transitive providers
@@ -6496,11 +6518,31 @@ export declare type StaticProvider = ValueProvider | ExistingProvider | StaticCl
  * If a value is provided then the sanitized version of that will be returned.
  */
 declare interface StyleSanitizeFn {
-    /** This mode is designed to instruct whether the property will be used for sanitization
-     * at a later point */
-    (prop: string): boolean;
-    /** This mode is designed to sanitize the provided value */
-    (prop: string, value: string): string;
+    (prop: string, value: string | null, mode?: StyleSanitizeMode): any;
+}
+
+/**
+ * A series of flags to instruct a style sanitizer to either validate
+ * or sanitize a value.
+ *
+ * Because sanitization is dependent on the style property (i.e. style
+ * sanitization for `width` is much different than for `background-image`)
+ * the sanitization function (e.g. `StyleSanitizerFn`) needs to check a
+ * property value first before it actually sanitizes any values.
+ *
+ * This enum exist to allow a style sanitization function to either only
+ * do validation (check the property to see whether a value will be
+ * sanitized or not) or to sanitize the value (or both).
+ *
+ * @publicApi
+ */
+declare const enum StyleSanitizeMode {
+    /** Just check to see if the property is required to be sanitized or not */
+    ValidateProperty = 1,
+    /** Skip checking the property; just sanitize the value */
+    SanitizeOnly = 2,
+    /** Check the property and (if true) then sanitize the value */
+    ValidateAndSanitize = 3
 }
 
 /**
@@ -6542,7 +6584,7 @@ declare interface StyleSanitizeFn {
  * Once the styling context is created then single and multi properties can be stored within it.
  * For this to happen, the following function needs to be called:
  *
- * `elementStyling` (called with style properties, class properties and a sanitizer + a directive
+ * `styling` (called with style properties, class properties and a sanitizer + a directive
  * instance).
  *
  * When this instruction is called it will populate the styling context with the provided style
@@ -6613,8 +6655,8 @@ declare interface StyleSanitizeFn {
  * values are and how they work.
  *
  * Each time a binding property is updated (whether it be through a single
- * property instruction like `elementStyleProp`, `elementClassProp` or
- * `elementStylingMap`) then the values in the context will be updated as
+ * property instruction like `styleProp`, `classProp`,
+ * `styleMap` or `classMap`) then the values in the context will be updated as
  * well.
  *
  * If for example `[style.width]` updates to `555px` then its value will be reflected
@@ -6633,9 +6675,9 @@ declare interface StyleSanitizeFn {
  *
  * Despite the context being updated, nothing has been rendered on screen (not styles or
  * classes have been set on the element). To kick off rendering for an element the following
- * function needs to be run `elementStylingApply`.
+ * function needs to be run `stylingApply`.
  *
- * `elementStylingApply` will run through the context and find each dirty value and render them onto
+ * `stylingApply` will run through the context and find each dirty value and render them onto
  * the element. Once complete, all styles/classes will be set to clean. Because of this, the render
  * function will now know not to rerun itself again if called again unless new style/class values
  * have changed.
@@ -6649,11 +6691,12 @@ declare interface StyleSanitizeFn {
  * Each of the following instructions supports accepting a directive instance as an input parameter:
  *
  * - `elementHostAttrs`
- * - `elementStyling`
- * - `elementStyleProp`
- * - `elementClassProp`
- * - `elementStylingMap`
- * - `elementStylingApply`
+ * - `styling`
+ * - `styleProp`
+ * - `classProp`
+ * - `styleMap`
+ * - `classMap`
+ * - `stylingApply`
  *
  * Each time a directive value is passed in, it will be converted into an index by examining the
  * directive registry (which lives in the context configuration area). The index is then used
@@ -6747,7 +6790,7 @@ declare interface StyleSanitizeFn {
  *
  * ## Rendering
  * The rendering mechanism (when the styling data is applied on screen) occurs via the
- * `elementStylingApply` function and is designed to run after **all** styling functions have been
+ * `stylingApply` function and is designed to run after **all** styling functions have been
  * evaluated. The rendering algorithm will loop over the context and only apply the styles that are
  * flagged as dirty (either because they are new, updated or have been removed via multi or
  * single bindings).
@@ -6779,17 +6822,17 @@ declare interface StylingContext extends Array<{
     [StylingIndex.InitialClassValuesPosition]: InitialStylingValues;
     /**
      * A numeric value representing the class index offset value. Whenever a single class is
-     * applied (using `elementClassProp`) it should have an styling index value that doesn't
+     * applied (using `classProp`) it should have an styling index value that doesn't
      * need to take into account any style values that exist in the context.
      */
     [StylingIndex.SinglePropOffsetPositions]: SinglePropOffsetValues;
     /**
-     * The last class value that was interpreted by elementStylingMap. This is cached
+     * The last class value that was interpreted by `styleMap`. This is cached
      * So that the algorithm can exit early incase the value has not changed.
      */
     [StylingIndex.CachedMultiClasses]: any | MapBasedOffsetValues;
     /**
-     * The last style value that was interpreted by elementStylingMap. This is cached
+     * The last style value that was interpreted by `classMap`. This is cached
      * So that the algorithm can exit early incase the value has not changed.
      */
     [StylingIndex.CachedMultiStyles]: any | MapBasedOffsetValues;
@@ -6797,12 +6840,12 @@ declare interface StylingContext extends Array<{
      * A queue of all hostStyling instructions.
      *
      * This array (queue) is populated only when host-level styling instructions
-     * (e.g. `hostStylingMap` and `hostClassProp`) are used to apply style and
+     * (e.g. `hostStyleMap` and `hostClassProp`) are used to apply style and
      * class values via host bindings to the host element. Despite these being
      * standard angular instructions, they are not designed to immediately apply
      * their values to the styling context when executed. What happens instead is
      * a queue is constructed and each instruction is populated into the queue.
-     * Then, once the style/class values are set to flush (via `elementStylingApply` or
+     * Then, once the style/class values are set to flush (via `stylingApply` or
      * `hostStylingApply`), the queue is flushed and the values are rendered onto
      * the host element.
      */
@@ -7409,6 +7452,8 @@ declare interface TNode {
      * with functions each time the creation block is called.
      */
     onElementCreationFns: Function[] | null;
+    newStyles: TStylingContext | null;
+    newClasses: TStylingContext | null;
 }
 
 /**
@@ -7612,6 +7657,313 @@ declare interface TrustedUrlString extends TrustedString {
  */
 declare type TsickleIssue1009 = any;
 
+/**
+ * A series of flags used to configure the config value present within a
+ * `TStylingContext` value.
+ */
+declare const enum TStylingConfigFlags {
+    /**
+     * The initial state of the styling context config
+     */
+    Initial = 0,
+    /**
+     * A flag which marks the context as being locked.
+     *
+     * The styling context is constructed across an element template
+     * function as well as any associated hostBindings functions. When
+     * this occurs, the context itself is open to mutation and only once
+     * it has been flushed once then it will be locked for good (no extra
+     * bindings can be added to it).
+     */
+    Locked = 1
+}
+
+/**
+ * --------
+ *
+ * This file contains the core interfaces for styling in Angular.
+ *
+ * To learn more about the algorithm see `TStylingContext`.
+ *
+ * --------
+ */
+/**
+ * A static-level representation of all style or class bindings/values
+ * associated with a `TNode`.
+ *
+ * The `TStylingContext` unites all template styling bindings (i.e.
+ * `[class]` and `[style]` bindings) as well as all host-level
+ * styling bindings (for components and directives) together into
+ * a single manifest. It is used each time there are one or more
+ * styling bindings present for an element.
+ *
+ * The styling context is stored on a `TNode` on and there are
+ * two instances of it: one for classes and another for styles.
+ *
+ * ```typescript
+ * tNode.styles = [ ... a context only for styles ... ];
+ * tNode.classes = [ ... a context only for classes ... ];
+ * ```
+ *
+ * Due to the fact the the `TStylingContext` is stored on a `TNode`
+ * this means that all data within the context is static. Instead of
+ * storing actual styling binding values, the lView binding index values
+ * are stored within the context. (static nature means it is more compact.)
+
+ *
+ * ```typescript
+ * // <div [class.active]="c"  // lView binding index = 20
+ * //      [style.width]="x"   // lView binding index = 21
+ * //      [style.height]="y"> // lView binding index = 22
+ * tNode.stylesContext = [
+ *   0, // the context config value
+ *
+ *   0b001, // guard mask for width
+ *   2, // total entries for width
+ *   'width', // the property name
+ *   21, // the binding location for the "x" binding in the lView
+ *   null,
+ *
+ *   0b010, // guard mask for height
+ *   2, // total entries for height
+ *   'height', // the property name
+ *   22, // the binding location for the "y" binding in the lView
+ *   null,
+ * ];
+ *
+ * tNode.classesContext = [
+ *   0, // the context config value
+ *
+ *   0b001, // guard mask for active
+ *   2, // total entries for active
+ *   'active', // the property name
+ *   20, // the binding location for the "c" binding in the lView
+ *   null,
+ * ];
+ * ```
+ *
+ * Entry value present in an entry (called a tuple) within the
+ * styling context is as follows:
+ *
+ * ```typescript
+ * context = [
+ *   CONFIG, // the styling context config value
+ *   //...
+ *   guardMask,
+ *   totalEntries,
+ *   propName,
+ *   bindingIndices...,
+ *   defaultValue
+ * ];
+ * ```
+ *
+ * Below is a breakdown of each value:
+ *
+ * - **guardMask**:
+ *   A numeric value where each bit represents a binding index
+ *   location. Each binding index location is assigned based on
+ *   a local counter value that increments each time an instruction
+ *   is called:
+ *
+ * ```
+ * <div [style.width]="x"   // binding index = 21 (counter index = 0)
+ *      [style.height]="y"> // binding index = 22 (counter index = 1)
+ * ```
+ *
+ *   In the example code above, if the `width` value where to change
+ *   then the first bit in the local bit mask value would be flipped
+ *   (and the second bit for when `height`).
+ *
+ *   If and when there are more than 32 binding sources in the context
+ *   (more than 32 `[style/class]` bindings) then the bit masking will
+ *   overflow and we are left with a situation where a `-1` value will
+ *   represent the bit mask. Due to the way that JavaScript handles
+ *   negative values, when the bit mask is `-1` then all bits within
+ *   that value will be automatically flipped (this is a quick and
+ *   efficient way to flip all bits on the mask when a special kind
+ *   of caching scenario occurs or when there are more than 32 bindings).
+ *
+ * - **totalEntries**:
+ *   Each property present in the contains various binding sources of
+ *   where the styling data could come from. This includes template
+ *   level bindings, directive/component host bindings as well as the
+ *   default value (or static value) all writing to the same property.
+ *   This value depicts how many binding source entries exist for the
+ *   property.
+ *
+ *   The reason why the totalEntries value is needed is because the
+ *   styling context is dynamic in size and it's not possible
+ *   for the flushing or update algorithms to know when and where
+ *   a property starts and ends without it.
+ *
+ * - **propName**:
+ *   The CSS property name or class name (e.g `width` or `active`).
+ *
+ * - **bindingIndices...**:
+ *   A series of numeric binding values that reflect where in the
+ *   lView to find the style/class values associated with the property.
+ *   Each value is in order in terms of priority (templates are first,
+ *   then directives and then components). When the context is flushed
+ *   and the style/class values are applied to the element (this happens
+ *   inside of the `stylingApply` instruction) then the flushing code
+ *   will keep checking each binding index against the associated lView
+ *   to find the first style/class value that is non-null.
+ *
+ * - **defaultValue**:
+ *   This is the default that will always be applied to the element if
+ *   and when all other binding sources return a result that is null.
+ *   Usually this value is null but it can also be a static value that
+ *   is intercepted when the tNode is first constructured (e.g.
+ *   `<div style="width:200px">` has a default value of `200px` for
+ *   the `width` property).
+ *
+ * Each time a new binding is encountered it is registered into the
+ * context. The context then is continually updated until the first
+ * styling apply call has been called (this is triggered by the
+ * `stylingApply()` instruction for the active element).
+ *
+ * # How Styles/Classes are Rendered
+ * Each time a styling instruction (e.g. `[class.name]`, `[style.prop]`,
+ * etc...) is executed, the associated `lView` for the view is updated
+ * at the current binding location. Also, when this happens, a local
+ * counter value is incremented. If the binding value has changed then
+ * a local `bitMask` variable is updated with the specific bit based
+ * on the counter value.
+ *
+ * Below is a lightweight example of what happens when a single style
+ * property is updated (i.e. `<div [style.prop]="val">`):
+ *
+ * ```typescript
+ * function updateStyleProp(prop: string, value: string) {
+ *   const lView = getLView();
+ *   const bindingIndex = BINDING_INDEX++;
+ *   const indexForStyle = localStylesCounter++;
+ *   if (lView[bindingIndex] !== value) {
+ *     lView[bindingIndex] = value;
+ *     localBitMaskForStyles |= 1 << indexForStyle;
+ *   }
+ * }
+ * ```
+ *
+ * ## The Apply Algorithm
+ * As explained above, each time a binding updates its value, the resulting
+ * value is stored in the `lView` array. These styling values have yet to
+ * be flushed to the element.
+ *
+ * Once all the styling instructions have been evaluated, then the styling
+ * context(s) are flushed to the element. When this happens, the context will
+ * be iterated over (property by property) and each binding source will be
+ * examined and the first non-null value will be applied to the element.
+ *
+ * Let's say that we the following template code:
+ *
+ * ```html
+ * <div [style.width]="w1" dir-that-set-width="w2"></div>
+ * ```
+ *
+ * There are two styling bindings in the code above and they both write
+ * to the `width` property. When styling is flushed on the element, the
+ * algorithm will try and figure out which one of these values to write
+ * to the element.
+ *
+ * In order to figure out which value to apply, the following
+ * binding prioritization is adhered to:
+ *
+ *   1. First template-level styling bindings are applied (if present).
+ *      This includes things like `[style.width]` and `[class.active]`.
+ *
+ *   2. Second are styling-level host bindings present in directives.
+ *      (if there are sub/super directives present then the sub directives
+ *      are applied first).
+ *
+ *   3. Third are styling-level host bindings present in components.
+ *      (if there are sub/super components present then the sub directives
+ *      are applied first).
+ *
+ * This means that in the code above the styling binding present in the
+ * template is applied first and, only if its falsy, then the directive
+ * styling binding for width will be applied.
+ *
+ * ### What about map-based styling bindings?
+ * Map-based styling bindings are activated when there are one or more
+ * `[style]` and/or `[class]` bindings present on an element. When this
+ * code is activated, the apply algorithm will iterate over each map
+ * entry and apply each styling value to the element with the same
+ * prioritization rules as above.
+ *
+ * For the algorithm to apply styling values efficiently, the
+ * styling map entries must be applied in sync (property by property)
+ * with prop-based bindings. (The map-based algorithm is described
+ * more inside of the `render3/styling_next/map_based_bindings.ts` file.)
+ *
+ * ## Sanitization
+ * Sanitization is used to prevent invalid style values from being applied to
+ * the element.
+ *
+ * It is enabled in two cases:
+ *
+ *   1. The `styleSanitizer(sanitizerFn)` instruction was called (just before any other
+ *      styling instructions are run).
+ *
+ *   2. The component/directive `LView` instance has a sanitizer object attached to it
+ *      (this happens when `renderComponent` is executed with a `sanitizer` value or
+ *      if the ngModule contains a sanitizer provider attached to it).
+ *
+ * If and when sanitization is active then all property/value entries will be evaluated
+ * through the active sanitizer before they are applied to the element (or the styling
+ * debug handler).
+ *
+ * If a `Sanitizer` object is used (via the `LView[SANITIZER]` value) then that object
+ * will be used for every property.
+ *
+ * If a `StyleSanitizerFn` function is used (via the `styleSanitizer`) then it will be
+ * called in two ways:
+ *
+ *   1. property validation mode: this will be called early to mark whether a property
+ *      should be sanitized or not at during the flushing stage.
+ *
+ *   2. value sanitization mode: this will be called during the flushing stage and will
+ *      run the sanitizer function against the value before applying it to the element.
+ *
+ * If sanitization returns an empty value then that empty value will be applied
+ * to the element.
+ */
+declare interface TStylingContext extends Array<number | string | number | boolean | null | LStylingMap> {
+    /** Configuration data for the context */
+    [TStylingContextIndex.ConfigPosition]: TStylingConfigFlags;
+    /** Temporary value used to track directive index entries until
+       the old styling code is fully removed. The reason why this
+       is required is to figure out which directive is last and,
+       when encountered, trigger a styling flush to happen */
+    [TStylingContextIndex.MaxDirectiveIndexPosition]: number;
+    /** The bit guard value for all map-based bindings on an element */
+    [TStylingContextIndex.MapBindingsBitGuardPosition]: number;
+    /** The total amount of map-based bindings present on an element */
+    [TStylingContextIndex.MapBindingsValuesCountPosition]: number;
+    /** The prop value for map-based bindings (there actually isn't a
+     * value at all, but this is just used in the context to avoid
+     * having any special code to update the binding information for
+     * map-based entries). */
+    [TStylingContextIndex.MapBindingsPropPosition]: string;
+}
+
+/**
+ * An index of position and offset values used to natigate the `TStylingContext`.
+ */
+declare const enum TStylingContextIndex {
+    ConfigPosition = 0,
+    MaxDirectiveIndexPosition = 1,
+    MapBindingsPosition = 2,
+    MapBindingsBitGuardPosition = 2,
+    MapBindingsValuesCountPosition = 3,
+    MapBindingsPropPosition = 4,
+    MapBindingsBindingsStartPosition = 5,
+    ConfigAndGuardOffset = 0,
+    ValuesCountOffset = 1,
+    PropOffset = 2,
+    BindingsStartOffset = 3
+}
+
 /** Static data for a text node */
 declare interface TTextNode extends TNode {
     /** Index in the data[] array */
@@ -7633,7 +7985,7 @@ declare const TVIEW = 1;
  * The static data for an LView (shared between all templates of a
  * given type).
  *
- * Stored on the template function as ngPrivateData.
+ * Stored on the `ComponentDef.tView`.
  */
 declare interface TView {
     /**
@@ -8535,8 +8887,6 @@ declare class ViewRef_2<T> implements EmbeddedViewRef<T>, InternalViewRef, viewE
     private _lookUpContext;
 }
 
-declare const VIEWS = 8;
-
 /**
  * Bitmask of states
  */
@@ -8714,13 +9064,13 @@ export declare const ɵALLOW_MULTIPLE_PLATFORMS: InjectionToken<boolean>;
 
 export declare function ɵand(flags: ɵNodeFlags, matchedQueriesDsl: null | [string | number, ɵQueryValueType][], ngContentIndex: null | number, childCount: number, handleEvent?: null | ElementHandleEventFn, templateFactory?: ViewDefinitionFactory): NodeDef;
 
-export declare class ɵangular_packages_core_core_a implements Injector {
-    get(token: any, notFoundValue?: any): any;
-}
+export declare function ɵangular_packages_core_core_a<T>(token: Type<T> | InjectionToken<T>): T;
 
-export declare function ɵangular_packages_core_core_b<T>(token: Type<T> | InjectionToken<T>): T;
+export declare function ɵangular_packages_core_core_a<T>(token: Type<T> | InjectionToken<T>, flags?: InjectFlags): T | null;
 
-export declare function ɵangular_packages_core_core_b<T>(token: Type<T> | InjectionToken<T>, flags?: InjectFlags): T | null;
+export declare class ɵangular_packages_core_core_b implements Injector {
+    get(token: any, notFoundValue?: any): any;
+}
 
 export declare abstract class ɵangular_packages_core_core_ba {
     abstract readonly view: ViewData;
@@ -9305,7 +9655,22 @@ export declare const enum ɵAttributeMarker {
      * ['attr', 'value', AttributeMarker.ProjectAs, ['', 'title', '']]
      * ```
      */
-    ProjectAs = 5
+    ProjectAs = 5,
+    /**
+     * Signals that the following attribute will be translated by runtime i18n
+     *
+     * For example, given the following HTML:
+     *
+     * ```
+     * <div moo="car" foo="value" i18n-foo [bar]="binding" i18n-bar>
+     * ```
+     *
+     * the generated code is:
+     *
+     * ```
+     * var _c1 = ['moo', 'car', AttributeMarker.I18n, 'foo', 'bar'];
+     */
+    I18n = 6
 }
 
 export declare const enum ɵBindingFlags {
@@ -9480,8 +9845,11 @@ export declare function ɵcompileNgModule(moduleType: Type<any>, ngModule?: NgMo
 
 /**
  * Compiles and adds the `ngModuleDef` and `ngInjectorDef` properties to the module class.
+ *
+ * It's possible to compile a module via this API which will allow duplicate declarations in its
+ * root.
  */
-export declare function ɵcompileNgModuleDefs(moduleType: ɵNgModuleType, ngModule: NgModule): void;
+export declare function ɵcompileNgModuleDefs(moduleType: ɵNgModuleType, ngModule: NgModule, allowDuplicateDeclarationsInRoot?: boolean): void;
 
 export declare function ɵcompileNgModuleFactory__POST_R3__<M>(injector: Injector, options: CompilerOptions, moduleType: Type<M>): Promise<NgModuleFactory<M>>;
 
@@ -9579,6 +9947,11 @@ export declare interface ɵComponentDef<T> extends ɵDirectiveDef<T> {
      * The set of schemas that declare elements to be allowed in the component's template.
      */
     schemas: SchemaMetadata[] | null;
+    /**
+     * Ivy runtime uses this place to store the computed tView for the component. This gets filled on
+     * the first run of component.
+     */
+    tView: TView | null;
     /**
      * Used to store the result of `noSideEffects` function so that it is not removed by closure
      * compiler. The property should never be read.
@@ -9626,6 +9999,13 @@ export declare function ɵcrt(values: {
  */
 export declare type ɵCssSelectorList = CssSelector[];
 
+/**
+ * The locale id that the application is currently using (for translations and ICU expressions).
+ * This is the ivy version of `LOCALE_ID` that was defined as an injection token for the view engine
+ * but is now defined as a global value.
+ */
+export declare const ɵDEFAULT_LOCALE_ID = "en-US";
+
 export declare const ɵdefaultIterableDiffers: IterableDiffers;
 
 export declare const ɵdefaultKeyValueDiffers: KeyValueDiffers;
@@ -9695,10 +10075,6 @@ export declare interface ɵDirectiveDef<T> extends ɵɵBaseDef<T> {
      * Factory function used to create a new directive instance.
      */
     factory: FactoryFn<T>;
-    /**
-     * Refreshes host bindings on the associated directive.
-     */
-    hostBindings: HostBindingsFunction<T> | null;
     onChanges: (() => void) | null;
     onInit: (() => void) | null;
     doCheck: (() => void) | null;
@@ -9741,6 +10117,15 @@ export declare const ɵEMPTY_MAP: {
     [key: string]: any;
 };
 
+/**
+ * Finds the locale data for a given locale.
+ *
+ * @param locale The locale code.
+ * @returns The locale data.
+ * @see [Internationalization (i18n) Guide](https://angular.io/guide/i18n)
+ */
+export declare function ɵfindLocaleData(locale: string): any;
+
 /**
  * Loops over queued module definitions, if a given module definition has all of its
  * declarations resolved, it dequeues that module definition and sets the scope on
@@ -9778,9 +10163,10 @@ export declare function ɵgetDirectives(target: {}): Array<{}>;
 export declare function ɵgetHostElement<T>(directive: T): Element;
 
 /**
- * Read the `ngInjectableDef` type in a way which is immune to accidentally reading inherited value.
+ * Read the `ngInjectableDef` for `type` in a way which is immune to accidentally reading inherited
+ * value.
  *
- * @param type type which may have `ngInjectableDef`
+ * @param type A type which may have its own (non-inherited) `ngInjectableDef`.
  */
 export declare function ɵgetInjectableDef<T>(type: any): ɵɵInjectableDef<T> | null;
 
@@ -9805,6 +10191,17 @@ export declare function ɵgetInjectableDef<T>(type: any): ɵɵInjectableDef<T> |
  */
 export declare function ɵgetLContext(target: any): ɵLContext | null;
 
+
+/**
+ * Retrieves the plural function used by ICU expressions to determine the plural case to use
+ * for a given locale.
+ * @param locale A locale code for the locale format rules to use.
+ * @returns The plural function for the locale.
+ * @see `NgPlural`
+ * @see [Internationalization (i18n) Guide](https://angular.io/guide/i18n)
+ */
+export declare function ɵgetLocalePluralCase(locale: string): (value: number) => number;
+
 export declare function ɵgetModuleFactory__POST_R3__(id: string): NgModuleFactory<any>;
 
 /**
@@ -9833,6 +10230,8 @@ export declare function ɵi18nConfigureLocalize(options?: I18nLocalizeOptions):
 
 export declare function ɵinitServicesIfNeeded(): void;
 
+export declare function ɵINJECTOR_IMPL__POST_R3__(providers: StaticProvider[], parent: Injector | undefined, name: string): Injector;
+
 export declare function ɵinlineInterpolate(valueCount: number, c0: string, a1: any, c1: string, a2?: any, c2?: string, a3?: any, c3?: string, a4?: any, c4?: string, a5?: any, c5?: string, a6?: any, c6?: string, a7?: any, c7?: string, a8?: any, c8?: string, a9?: any, c9?: string): string;
 
 export declare function ɵinterpolate(valueCount: number, constAndInterp: string[]): string;
@@ -9917,6 +10316,39 @@ export declare interface ɵLContext {
  */
 export declare function ɵLifecycleHooksFeature(component: any, def: ɵComponentDef<any>): void;
 
+/**
+ * This const is used to store the locale data registered with `registerLocaleData`
+ */
+export declare const ɵLOCALE_DATA: {
+    [localeId: string]: any;
+};
+
+/**
+ * Index of each type of locale data from the locale data array
+ */
+export declare enum ɵLocaleDataIndex {
+    LocaleId = 0,
+    DayPeriodsFormat = 1,
+    DayPeriodsStandalone = 2,
+    DaysFormat = 3,
+    DaysStandalone = 4,
+    MonthsFormat = 5,
+    MonthsStandalone = 6,
+    Eras = 7,
+    FirstDayOfWeek = 8,
+    WeekendRange = 9,
+    DateFormat = 10,
+    TimeFormat = 11,
+    DateTimeFormat = 12,
+    NumberSymbols = 13,
+    NumberFormats = 14,
+    CurrencySymbol = 15,
+    CurrencyName = 16,
+    Currencies = 17,
+    PluralCase = 18,
+    ExtraData = 19
+}
+
 
 export declare function ɵlooseIdentical(a: any, b: any): boolean;
 
@@ -10009,6 +10441,8 @@ export declare interface ɵNgModuleDef<T> {
     transitiveCompileScopes: ɵNgModuleTransitiveScopes | null;
     /** The set of schemas that declare elements to be allowed in the NgModule. */
     schemas: SchemaMetadata[] | null;
+    /** Unique ID for the module with which it should be registered.  */
+    id: string | null;
 }
 
 export declare class ɵNgModuleFactory<T> extends NgModuleFactory<T> {
@@ -10303,7 +10737,7 @@ export declare class ɵReflectionCapabilities implements PlatformReflectionCapab
  */
 export declare function ɵregisterModuleFactory(id: string, factory: NgModuleFactory<any>): void;
 
-export declare function ɵregisterNgModuleType(id: string, ngModuleType: ɵNgModuleType): void;
+export declare function ɵregisterNgModuleType(ngModuleType: ɵNgModuleType): void;
 
 /**
  * Render3 implementation of {@link viewEngine_ComponentFactory}.
@@ -10463,6 +10897,15 @@ export declare function ɵsetClassMetadata(type: Type<any>, decorators: any[] |
 
 export declare function ɵsetCurrentInjector(injector: Injector | null | undefined): Injector | undefined | null;
 
+/**
+ * Sets the locale id that will be used for translations and ICU expressions.
+ * This is the ivy version of `LOCALE_ID` that was defined as an injection token for the view engine
+ * but is now defined as a global value.
+ *
+ * @param localeId
+ */
+export declare function ɵsetLocaleId(localeId: string): void;
+
 
 export declare type ɵSetterFn = (obj: any, value: any) => void;
 
@@ -10571,129 +11014,490 @@ export declare function ɵwhenRendered(component: any): Promise<null>;
 export declare function ɵɵallocHostVars(count: number): void;
 
 /**
- * Runtime information for classes that are inherited by components or directives
- * that aren't defined as components or directives.
+ * Updates the value of or removes a bound attribute on an Element.
  *
- * This is an internal data structure used by the renderer to determine what inputs
- * and outputs should be inherited.
+ * Used in the case of `[attr.title]="value"`
  *
- * See: {@link defineBase}
+ * @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 declare interface ɵɵBaseDef<T> {
-    /**
-     * A dictionary mapping the inputs' minified property names to their public API names, which
-     * are their aliases if any, or their original unminified property names
-     * (as in `@Input('alias') propertyName: any;`).
-     */
-    readonly inputs: {
-        [P in keyof T]: string;
-    };
-    /**
-     * @deprecated This is only here because `NgOnChanges` incorrectly uses declared name instead of
-     * public or minified name.
-     */
-    readonly declaredInputs: {
-        [P in keyof T]: string;
-    };
-    /**
-     * A dictionary mapping the outputs' minified property names to their public API names, which
-     * are their aliases if any, or their original unminified property names
-     * (as in `@Output('alias') propertyName: any;`).
-     */
-    readonly outputs: {
-        [P in keyof T]: string;
-    };
-    /**
-     * Function to create and refresh content queries associated with a given directive.
-     */
-    contentQueries: ContentQueriesFunction<T> | null;
-    /**
-     * Query-related instructions for a directive. Note that while directives don't have a
-     * view and as such view queries won't necessarily do anything, there might be
-     * components that extend the directive.
-     */
-    viewQuery: ViewQueriesFunction<T> | null;
-}
+export declare function ɵɵattribute(name: string, value: any, sanitizer?: SanitizerFn | null, namespace?: string): void;
 
 /**
- * Creates a single value binding.
  *
- * @param value Value to diff
+ * Update an interpolated attribute on an element with single bound value surrounded by text.
  *
+ * Used when the value passed to a property has 1 interpolated value in it:
+ *
+ * ```html
+ * <div attr.title="prefix{{v0}}suffix"></div>
+ * ```
+ *
+ * Its compiled representation is::
+ *
+ * ```ts
+ * ɵɵattributeInterpolate1('title', 'prefix', v0, 'suffix');
+ * ```
+ *
+ * @param attrName The name of the attribute to update
+ * @param prefix Static value used for concatenation only.
+ * @param v0 Value checked for change.
+ * @param suffix Static value used for concatenation only.
+ * @param sanitizer An optional sanitizer function
+ * @returns itself, so that it may be chained.
  * @codeGenApi
  */
-export declare function ɵɵbind<T>(value: T): T | ɵNO_CHANGE;
-
-/**
- * @codeGenApi
- */
-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 ɵɵattributeInterpolate1(attrName: string, prefix: string, v0: any, suffix: string, sanitizer?: SanitizerFn, namespace?: string): TsickleIssue1009;
 
 /**
-* Registers a synthetic host listener (e.g. `(@foo.start)`) on a component.
-*
-* This instruction is for compatibility purposes and is designed to ensure that a
-* synthetic host listener (e.g. `@HostListener('@foo.start')`) properly gets rendered
-* in the component's renderer. Normally all host listeners are evaluated with the
-* parent component's renderer, but, in the case of animation @triggers, they need
-* to be evaluated with the sub component's renderer (because that's where the
-* animation triggers are defined).
-*
-* Do not use this instruction as a replacement for `listener`. This instruction
-* only exists to ensure compatibility with the ViewEngine's host binding behavior.
-*
-* @param eventName Name of the event
-* @param listenerFn The function to be called when event emits
-* @param useCapture Whether or not to use capture in event listener
-* @param eventTargetResolver Function that returns global target information in case this listener
-* should be attached to a global object like window, document or body
  *
- * @codeGenApi
-*/
-export declare function ɵɵcomponentHostSyntheticListener<T>(eventName: string, listenerFn: (e?: any) => any, useCapture?: boolean, eventTargetResolver?: GlobalTargetResolver): void;
-
-/**
- * Updates a synthetic host binding (e.g. `[@foo]`) on a component.
+ * Update an interpolated attribute on an element with 2 bound values surrounded by text.
  *
- * This instruction is for compatibility purposes and is designed to ensure that a
- * synthetic host binding (e.g. `@HostBinding('@foo')`) properly gets rendered in
- * the component's renderer. Normally all host bindings are evaluated with the parent
- * component's renderer, but, in the case of animation @triggers, they need to be
- * evaluated with the sub component's renderer (because that's where the animation
- * triggers are defined).
+ * Used when the value passed to a property has 2 interpolated values in it:
  *
- * Do not use this instruction as a replacement for `elementProperty`. This instruction
- * only exists to ensure compatibility with the ViewEngine's host binding behavior.
+ * ```html
+ * <div attr.title="prefix{{v0}}-{{v1}}suffix"></div>
+ * ```
  *
- * @param index The index of the element to update in the data array
- * @param propName Name of property. Because it is going to DOM, this is not subject to
- *        renaming as part of minification.
- * @param value New value to write.
- * @param sanitizer An optional function used to sanitize the value.
- * @param nativeOnly Whether or not we should only set native properties and skip input check
- * (this is necessary for host property bindings)
+ * Its compiled representation is::
+ *
+ * ```ts
+ * ɵɵattributeInterpolate2('title', 'prefix', v0, '-', v1, 'suffix');
+ * ```
  *
+ * @param attrName The name of the attribute to update
+ * @param prefix Static value used for concatenation only.
+ * @param v0 Value checked for change.
+ * @param i0 Static value used for concatenation only.
+ * @param v1 Value checked for change.
+ * @param suffix Static value used for concatenation only.
+ * @param sanitizer An optional sanitizer function
+ * @returns itself, so that it may be chained.
  * @codeGenApi
  */
-export declare function ɵɵcomponentHostSyntheticProperty<T>(index: number, propName: string, value: T | ɵNO_CHANGE, sanitizer?: SanitizerFn | null, nativeOnly?: boolean): void;
+export declare function ɵɵattributeInterpolate2(attrName: string, prefix: string, v0: any, i0: string, v1: any, suffix: string, sanitizer?: SanitizerFn, namespace?: string): TsickleIssue1009;
 
 /**
- * Creates an LContainer for inline views, e.g.
  *
- * % if (showing) {
- *   <div></div>
- * % }
+ * Update an interpolated attribute on an element with 3 bound values surrounded by text.
  *
- * @param index The index of the container in the data array
+ * Used when the value passed to a property has 3 interpolated values in it:
  *
- * @codeGenApi
- */
+ * ```html
+ * <div attr.title="prefix{{v0}}-{{v1}}-{{v2}}suffix"></div>
+ * ```
+ *
+ * Its compiled representation is::
+ *
+ * ```ts
+ * ɵɵattributeInterpolate3(
+ * 'title', 'prefix', v0, '-', v1, '-', v2, 'suffix');
+ * ```
+ *
+ * @param attrName The name of the attribute to update
+ * @param prefix Static value used for concatenation only.
+ * @param v0 Value checked for change.
+ * @param i0 Static value used for concatenation only.
+ * @param v1 Value checked for change.
+ * @param i1 Static value used for concatenation only.
+ * @param v2 Value checked for change.
+ * @param suffix Static value used for concatenation only.
+ * @param sanitizer An optional sanitizer function
+ * @returns itself, so that it may be chained.
+ * @codeGenApi
+ */
+export declare function ɵɵattributeInterpolate3(attrName: string, prefix: string, v0: any, i0: string, v1: any, i1: string, v2: any, suffix: string, sanitizer?: SanitizerFn, namespace?: string): TsickleIssue1009;
+
+/**
+ *
+ * Update an interpolated attribute on an element with 4 bound values surrounded by text.
+ *
+ * Used when the value passed to a property has 4 interpolated values in it:
+ *
+ * ```html
+ * <div attr.title="prefix{{v0}}-{{v1}}-{{v2}}-{{v3}}suffix"></div>
+ * ```
+ *
+ * Its compiled representation is::
+ *
+ * ```ts
+ * ɵɵattributeInterpolate4(
+ * 'title', 'prefix', v0, '-', v1, '-', v2, '-', v3, 'suffix');
+ * ```
+ *
+ * @param attrName The name of the attribute to update
+ * @param prefix Static value used for concatenation only.
+ * @param v0 Value checked for change.
+ * @param i0 Static value used for concatenation only.
+ * @param v1 Value checked for change.
+ * @param i1 Static value used for concatenation only.
+ * @param v2 Value checked for change.
+ * @param i2 Static value used for concatenation only.
+ * @param v3 Value checked for change.
+ * @param suffix Static value used for concatenation only.
+ * @param sanitizer An optional sanitizer function
+ * @returns itself, so that it may be chained.
+ * @codeGenApi
+ */
+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): TsickleIssue1009;
+
+/**
+ *
+ * Update an interpolated attribute on an element with 5 bound values surrounded by text.
+ *
+ * Used when the value passed to a property has 5 interpolated values in it:
+ *
+ * ```html
+ * <div attr.title="prefix{{v0}}-{{v1}}-{{v2}}-{{v3}}-{{v4}}suffix"></div>
+ * ```
+ *
+ * Its compiled representation is::
+ *
+ * ```ts
+ * ɵɵattributeInterpolate5(
+ * 'title', 'prefix', v0, '-', v1, '-', v2, '-', v3, '-', v4, 'suffix');
+ * ```
+ *
+ * @param attrName The name of the attribute to update
+ * @param prefix Static value used for concatenation only.
+ * @param v0 Value checked for change.
+ * @param i0 Static value used for concatenation only.
+ * @param v1 Value checked for change.
+ * @param i1 Static value used for concatenation only.
+ * @param v2 Value checked for change.
+ * @param i2 Static value used for concatenation only.
+ * @param v3 Value checked for change.
+ * @param i3 Static value used for concatenation only.
+ * @param v4 Value checked for change.
+ * @param suffix Static value used for concatenation only.
+ * @param sanitizer An optional sanitizer function
+ * @returns itself, so that it may be chained.
+ * @codeGenApi
+ */
+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): TsickleIssue1009;
+
+/**
+ *
+ * Update an interpolated attribute on an element with 6 bound values surrounded by text.
+ *
+ * Used when the value passed to a property has 6 interpolated values in it:
+ *
+ * ```html
+ * <div attr.title="prefix{{v0}}-{{v1}}-{{v2}}-{{v3}}-{{v4}}-{{v5}}suffix"></div>
+ * ```
+ *
+ * Its compiled representation is::
+ *
+ * ```ts
+ * ɵɵattributeInterpolate6(
+ *    'title', 'prefix', v0, '-', v1, '-', v2, '-', v3, '-', v4, '-', v5, 'suffix');
+ * ```
+ *
+ * @param attrName The name of the attribute to update
+ * @param prefix Static value used for concatenation only.
+ * @param v0 Value checked for change.
+ * @param i0 Static value used for concatenation only.
+ * @param v1 Value checked for change.
+ * @param i1 Static value used for concatenation only.
+ * @param v2 Value checked for change.
+ * @param i2 Static value used for concatenation only.
+ * @param v3 Value checked for change.
+ * @param i3 Static value used for concatenation only.
+ * @param v4 Value checked for change.
+ * @param i4 Static value used for concatenation only.
+ * @param v5 Value checked for change.
+ * @param suffix Static value used for concatenation only.
+ * @param sanitizer An optional sanitizer function
+ * @returns itself, so that it may be chained.
+ * @codeGenApi
+ */
+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): TsickleIssue1009;
+
+/**
+ *
+ * Update an interpolated attribute on an element with 7 bound values surrounded by text.
+ *
+ * Used when the value passed to a property has 7 interpolated values in it:
+ *
+ * ```html
+ * <div attr.title="prefix{{v0}}-{{v1}}-{{v2}}-{{v3}}-{{v4}}-{{v5}}-{{v6}}suffix"></div>
+ * ```
+ *
+ * Its compiled representation is::
+ *
+ * ```ts
+ * ɵɵattributeInterpolate7(
+ *    'title', 'prefix', v0, '-', v1, '-', v2, '-', v3, '-', v4, '-', v5, '-', v6, 'suffix');
+ * ```
+ *
+ * @param attrName The name of the attribute to update
+ * @param prefix Static value used for concatenation only.
+ * @param v0 Value checked for change.
+ * @param i0 Static value used for concatenation only.
+ * @param v1 Value checked for change.
+ * @param i1 Static value used for concatenation only.
+ * @param v2 Value checked for change.
+ * @param i2 Static value used for concatenation only.
+ * @param v3 Value checked for change.
+ * @param i3 Static value used for concatenation only.
+ * @param v4 Value checked for change.
+ * @param i4 Static value used for concatenation only.
+ * @param v5 Value checked for change.
+ * @param i5 Static value used for concatenation only.
+ * @param v6 Value checked for change.
+ * @param suffix Static value used for concatenation only.
+ * @param sanitizer An optional sanitizer function
+ * @returns itself, so that it may be chained.
+ * @codeGenApi
+ */
+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): TsickleIssue1009;
+
+/**
+ *
+ * Update an interpolated attribute on an element with 8 bound values surrounded by text.
+ *
+ * Used when the value passed to a property has 8 interpolated values in it:
+ *
+ * ```html
+ * <div attr.title="prefix{{v0}}-{{v1}}-{{v2}}-{{v3}}-{{v4}}-{{v5}}-{{v6}}-{{v7}}suffix"></div>
+ * ```
+ *
+ * Its compiled representation is::
+ *
+ * ```ts
+ * ɵɵattributeInterpolate8(
+ *  'title', 'prefix', v0, '-', v1, '-', v2, '-', v3, '-', v4, '-', v5, '-', v6, '-', v7, 'suffix');
+ * ```
+ *
+ * @param attrName The name of the attribute to update
+ * @param prefix Static value used for concatenation only.
+ * @param v0 Value checked for change.
+ * @param i0 Static value used for concatenation only.
+ * @param v1 Value checked for change.
+ * @param i1 Static value used for concatenation only.
+ * @param v2 Value checked for change.
+ * @param i2 Static value used for concatenation only.
+ * @param v3 Value checked for change.
+ * @param i3 Static value used for concatenation only.
+ * @param v4 Value checked for change.
+ * @param i4 Static value used for concatenation only.
+ * @param v5 Value checked for change.
+ * @param i5 Static value used for concatenation only.
+ * @param v6 Value checked for change.
+ * @param i6 Static value used for concatenation only.
+ * @param v7 Value checked for change.
+ * @param suffix Static value used for concatenation only.
+ * @param sanitizer An optional sanitizer function
+ * @returns itself, so that it may be chained.
+ * @codeGenApi
+ */
+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): TsickleIssue1009;
+
+/**
+ * Update an interpolated attribute on an element with 8 or more bound values surrounded by text.
+ *
+ * Used when the number of interpolated values exceeds 7.
+ *
+ * ```html
+ * <div
+ *  title="prefix{{v0}}-{{v1}}-{{v2}}-{{v3}}-{{v4}}-{{v5}}-{{v6}}-{{v7}}-{{v8}}-{{v9}}suffix"></div>
+ * ```
+ *
+ * Its compiled representation is::
+ *
+ * ```ts
+ * ɵɵattributeInterpolateV(
+ *  'title', ['prefix', v0, '-', v1, '-', v2, '-', v3, '-', v4, '-', v5, '-', v6, '-', v7, '-', v9,
+ *  'suffix']);
+ * ```
+ *
+ * @param attrName The name of the attribute to update.
+ * @param values The a collection of values and the strings in-between those values, beginning with
+ * a string prefix and ending with a string suffix.
+ * (e.g. `['prefix', value0, '-', value1, '-', value2, ..., value99, 'suffix']`)
+ * @param sanitizer An optional sanitizer function
+ * @returns itself, so that it may be chained.
+ * @codeGenApi
+ */
+export declare function ɵɵattributeInterpolateV(attrName: string, values: any[], sanitizer?: SanitizerFn, namespace?: string): TsickleIssue1009;
+
+/**
+ * Runtime information for classes that are inherited by components or directives
+ * that aren't defined as components or directives.
+ *
+ * This is an internal data structure used by the renderer to determine what inputs
+ * and outputs should be inherited.
+ *
+ * See: {@link defineBase}
+ *
+ * @codeGenApi
+ */
+export declare interface ɵɵBaseDef<T> {
+    /**
+     * A dictionary mapping the inputs' minified property names to their public API names, which
+     * are their aliases if any, or their original unminified property names
+     * (as in `@Input('alias') propertyName: any;`).
+     */
+    readonly inputs: {
+        [P in keyof T]: string;
+    };
+    /**
+     * @deprecated This is only here because `NgOnChanges` incorrectly uses declared name instead of
+     * public or minified name.
+     */
+    readonly declaredInputs: {
+        [P in keyof T]: string;
+    };
+    /**
+     * A dictionary mapping the outputs' minified property names to their public API names, which
+     * are their aliases if any, or their original unminified property names
+     * (as in `@Output('alias') propertyName: any;`).
+     */
+    readonly outputs: {
+        [P in keyof T]: string;
+    };
+    /**
+     * Function to create and refresh content queries associated with a given directive.
+     */
+    contentQueries: ContentQueriesFunction<T> | null;
+    /**
+     * Query-related instructions for a directive. Note that while directives don't have a
+     * view and as such view queries won't necessarily do anything, there might be
+     * components that extend the directive.
+     */
+    viewQuery: ViewQueriesFunction<T> | null;
+    /**
+     * Refreshes host bindings on the associated directive.
+     */
+    hostBindings: HostBindingsFunction<T> | null;
+}
+
+/**
+ * Creates a single value binding.
+ *
+ * @param value Value to diff
+ *
+ * @codeGenApi
+ */
+export declare function ɵɵbind<T>(value: T): T | ɵNO_CHANGE;
+
+/**
+ * Update class bindings using an object literal or class-string on an element.
+ *
+ * This instruction is meant to apply styling via the `[class]="exp"` template bindings.
+ * When classes are applied to the element they will then be updated with
+ * respect to any styles/classes set via `classProp`. If any
+ * classes are set to falsy then they will be removed from the element.
+ *
+ * Note that the styling instruction will not be applied until `stylingApply` is called.
+ * Note that this will the provided classMap value to the host element if this function is called
+ * within a host binding.
+ *
+ * @param classes A key/value map or string of CSS classes that will be added to the
+ *        given element. Any missing classes (that have already been applied to the element
+ *        beforehand) will be removed (unset) from the element's list of CSS classes.
+ *
+ * @codeGenApi
+ */
+export declare function ɵɵclassMap(classes: {
+    [styleName: string]: any;
+} | ɵNO_CHANGE | string | null): void;
+
+/**
+ * Update a class binding on an element with the provided value.
+ *
+ * This instruction is meant to handle the `[class.foo]="exp"` case and,
+ * therefore, the class binding itself must already be allocated using
+ * `styling` within the creation block.
+ *
+ * @param classIndex Index of class to toggle. This index value refers to the
+ *        index of the class in the class bindings array that was passed into
+ *        `styling` (which is meant to be called before this
+ *        function is).
+ * @param value A true/false value which will turn the class on or off.
+ * @param forceOverride Whether or not this value will be applied regardless
+ *        of where it is being set within the styling priority structure.
+ *
+ * Note that this will apply the provided class value to the host element if this function
+ * is called within a host binding.
+ *
+ * @codeGenApi
+ */
+export declare function ɵɵclassProp(classIndex: number, value: boolean | ɵPlayerFactory, forceOverride?: boolean): void;
+
+/**
+ * @codeGenApi
+ */
+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>;
+
+/**
+* Registers a synthetic host listener (e.g. `(@foo.start)`) on a component.
+*
+* This instruction is for compatibility purposes and is designed to ensure that a
+* synthetic host listener (e.g. `@HostListener('@foo.start')`) properly gets rendered
+* in the component's renderer. Normally all host listeners are evaluated with the
+* parent component's renderer, but, in the case of animation @triggers, they need
+* to be evaluated with the sub component's renderer (because that's where the
+* animation triggers are defined).
+*
+* Do not use this instruction as a replacement for `listener`. This instruction
+* only exists to ensure compatibility with the ViewEngine's host binding behavior.
+*
+* @param eventName Name of the event
+* @param listenerFn The function to be called when event emits
+* @param useCapture Whether or not to use capture in event listener
+* @param eventTargetResolver Function that returns global target information in case this listener
+* should be attached to a global object like window, document or body
+ *
+ * @codeGenApi
+*/
+export declare function ɵɵcomponentHostSyntheticListener<T>(eventName: string, listenerFn: (e?: any) => any, useCapture?: boolean, eventTargetResolver?: GlobalTargetResolver): void;
+
+/**
+ * Updates a synthetic host binding (e.g. `[@foo]`) on a component.
+ *
+ * This instruction is for compatibility purposes and is designed to ensure that a
+ * synthetic host binding (e.g. `@HostBinding('@foo')`) properly gets rendered in
+ * the component's renderer. Normally all host bindings are evaluated with the parent
+ * component's renderer, but, in the case of animation @triggers, they need to be
+ * evaluated with the sub component's renderer (because that's where the animation
+ * triggers are defined).
+ *
+ * Do not use this instruction as a replacement for `elementProperty`. This instruction
+ * only exists to ensure compatibility with the ViewEngine's host binding behavior.
+ *
+ * @param index The index of the element to update in the data array
+ * @param propName Name of property. Because it is going to DOM, this is not subject to
+ *        renaming as part of minification.
+ * @param value New value to write.
+ * @param sanitizer An optional function used to sanitize the value.
+ * @param nativeOnly Whether or not we should only set native properties and skip input check
+ * (this is necessary for host property bindings)
+ *
+ * @codeGenApi
+ */
+export declare function ɵɵcomponentHostSyntheticProperty<T>(index: number, propName: string, value: T | ɵNO_CHANGE, sanitizer?: SanitizerFn | null, nativeOnly?: boolean): void;
+
+/**
+ * Creates an LContainer for inline views, e.g.
+ *
+ * % if (showing) {
+ *   <div></div>
+ * % }
+ *
+ * @param index The index of the container in the data array
+ *
+ * @codeGenApi
+ */
 export declare function ɵɵcontainer(index: number): void;
 
 /**
@@ -10821,6 +11625,10 @@ export declare function ɵɵdefineBase<T>(baseDefinition: {
      * set of instructions to be inserted into the template function.
      */
     viewQuery?: ViewQueriesFunction<T> | null;
+    /**
+     * Function executed by the parent template to allow children to apply host bindings.
+     */
+    hostBindings?: HostBindingsFunction<T>;
 }): ɵɵBaseDef<T>;
 
 /**
@@ -11203,6 +12011,8 @@ export declare function ɵɵdefineNgModule<T>(def: {
     exports?: Type<any>[] | (() => Type<any>[]);
     /** The set of schemas that declare elements to be allowed in the NgModule. */
     schemas?: SchemaMetadata[] | null;
+    /** Unique ID for the module that is used with `getModuleFactory`. */
+    id?: string | null;
 }): never;
 
 /**
@@ -11304,9 +12114,9 @@ export declare function ɵɵdisableBindings(): void;
 export declare function ɵɵelement(index: number, name: string, attrs?: TAttributes | null, localRefs?: string[] | null): void;
 
 /**
- * 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 index The index of the element in the data array
  * @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.
@@ -11317,26 +12127,6 @@ export declare function ɵɵelement(index: number, name: string, attrs?: TAttrib
  */
 export declare function ɵɵelementAttribute(index: number, name: string, value: any, sanitizer?: SanitizerFn | null, namespace?: string): void;
 
-/**
- * Update a class binding on an element with the provided value.
- *
- * This instruction is meant to handle the `[class.foo]="exp"` case and,
- * therefore, the class binding itself must already be allocated using
- * `elementStyling` within the creation block.
- *
- * @param index Index of the element's with which styling is associated.
- * @param classIndex Index of class to toggle. This index value refers to the
- *        index of the class in the class bindings array that was passed into
- *        `elementStyling` (which is meant to be called before this
- *        function is).
- * @param value A true/false value which will turn the class on or off.
- * @param forceOverride Whether or not this value will be applied regardless
- *        of where it is being set within the styling priority structure.
- *
- * @codeGenApi
- */
-export declare function ɵɵelementClassProp(index: number, classIndex: number, value: boolean | ɵPlayerFactory, forceOverride?: boolean): void;
-
 /**
  * Mark the end of the <ng-container>.
  *
@@ -11398,253 +12188,52 @@ export declare function ɵɵelementEnd(): void;
  * the entries. The marker values themselves are set via entries found in the
  * [AttributeMarker] enum.
  *
- * NOTE: This instruction is meant to used from `hostBindings` function only.
- *
- * @param directive A directive instance the styling is associated with.
- * @param attrs An array of static values (attributes, classes and styles) with the correct marker
- * values.
- *
- * @codeGenApi
- */
-export declare function ɵɵelementHostAttrs(attrs: TAttributes): void;
-
-/**
- * Update a class host binding for a directive's/component's host element within
- * the host bindings function.
- *
- * This instruction is meant to handle the `@HostBinding('class.foo')` case and,
- * therefore, the class binding itself must already be allocated using
- * `elementHostStyling` within the creation block.
- *
- * @param classIndex Index of class to toggle. This index value refers to the
- *        index of the class in the class bindings array that was passed into
- *        `elementHostStlying` (which is meant to be called before this
- *        function is).
- * @param value A true/false value which will turn the class on or off.
- * @param forceOverride Whether or not this value will be applied regardless
- *        of where it is being set within the stylings priority structure.
- *
- * @codeGenApi
- */
-export declare function ɵɵelementHostClassProp(classIndex: number, value: boolean | ɵPlayerFactory, forceOverride?: boolean): void;
-
-/**
- * Update a host style binding value on the host element within a component/directive.
- *
- * If the style value is falsy then it will be removed from the host element
- * (or assigned a different value depending if there are any styles placed
- * on the same element with `elementHostStylingMap` or any static styles that
- * are present from when the element was patched with `elementHostStyling`).
- *
- * Note that the styling applied to the host element once
- * `elementHostStylingApply` is called.
- *
- * @param styleIndex Index of style to update. This index value refers to the
- *        index of the style in the style bindings array that was passed into
- *        `elementHostStyling`.
- * @param value New value to write (falsy to remove). The value may or may not
- *        be applied to the element depending on the template/component/directive
- *        prioritization (see `interfaces/styling.ts`)
- * @param suffix Optional suffix. Used with scalar values to add unit such as `px`.
- *        Note that when a suffix is provided then the underlying sanitizer will
- *        be ignored.
- * @param forceOverride Whether or not to update the styling value immediately
- *        (despite the other bindings possibly having priority)
- *
- * @codeGenApi
- */
-export declare function ɵɵelementHostStyleProp(styleIndex: number, value: string | number | String | ɵPlayerFactory | null, suffix?: string | null, forceOverride?: boolean): void;
-
-/**
- * Allocates style and class binding properties on the host element during creation mode
- * within the host bindings function of a directive or component.
- *
- * This instruction is meant to be called during creation mode to register all
- * dynamic style and class host bindings on the host element of a directive or
- * component. Note that this is only used for binding values (see `elementHostAttrs`
- * to learn how to assign static styling values to the host element).
- *
- * @param classBindingNames An array containing bindable class names.
- *        The `elementHostClassProp` instruction refers to the class name by index in
- *        this array (i.e. `['foo', 'bar']` means `foo=0` and `bar=1`).
- * @param styleBindingNames An array containing bindable style properties.
- *        The `elementHostStyleProp` instruction refers to the class name by index in
- *        this array (i.e. `['width', 'height']` means `width=0` and `height=1`).
- * @param styleSanitizer An optional sanitizer function that will be used to sanitize any CSS
- *        style values that are applied to the element (during rendering).
- *        Note that the sanitizer instance itself is tied to the provided `directive` and
- *        will not be used if the same property is assigned in another directive or
- *        on the element directly.
- *
- * @codeGenApi
- */
-export declare function ɵɵelementHostStyling(classBindingNames?: string[] | null, styleBindingNames?: string[] | null, styleSanitizer?: StyleSanitizeFn | null): void;
-
-/**
- * Apply all style and class host binding values to the element.
- *
- * This instruction is meant to be run after `elementHostStylingMap`,
- * `elementHostStyleProp` or `elementHostClassProp` instructions have
- * been run and will only apply styling to the host element if any
- * styling bindings have been updated.
- *
- * @codeGenApi
- */
-export declare function ɵɵelementHostStylingApply(): void;
-
-/**
- * Update style and/or class host bindings using object literals on an element within the host
- * bindings function for a directive/component.
- *
- * This instruction is meant to apply styling via the `@HostBinding('style')` and
- * `@HostBinding('class')` bindings for a component's or directive's host element.
- * When styles/classes are applied to the host element they will then be updated
- * with respect to any styles/classes set with `elementHostStyleProp` or
- * `elementHostClassProp`. If any styles or classes are set to falsy then they
- * will be removed from the element.
- *
- * Note that the styling instruction will not be applied until
- * `elementHostStylingApply` is called.
- *
- * @param classes A key/value map or string of CSS classes that will be added to the
- *        given element. Any missing classes (that have already been applied to the element
- *        beforehand) will be removed (unset) from the element's list of CSS classes.
- * @param styles A key/value style map of the styles that will be applied to the given element.
- *        Any missing styles (that have already been applied to the element beforehand) will be
- *        removed (unset) from the element's styling.
- *
- * @codeGenApi
- */
-export declare function ɵɵelementHostStylingMap(classes: {
-    [key: string]: any;
-} | string | ɵNO_CHANGE | null, styles?: {
-    [styleName: string]: any;
-} | ɵNO_CHANGE | null): void;
-
-/**
-* **TODO: Remove this function after `property` is in use**
-* Update a property on an element.
-*
-* If the property name also exists as an input property on one of the element's directives,
-* the component property will be set instead of the element property. This check must
-* be conducted at runtime so child components that add new @Inputs don't have to be re-compiled.
-*
-* @param index The index of the element to update in the data array
-* @param propName Name of property. Because it is going to DOM, this is not subject to
-*        renaming as part of minification.
-* @param value New value to write.
-* @param sanitizer An optional function used to sanitize the value.
-* @param nativeOnly Whether or not we should only set native properties and skip input check
-* (this is necessary for host property bindings)
- *
- * @codeGenApi
-*/
-export declare function ɵɵelementProperty<T>(index: number, propName: string, value: T | ɵNO_CHANGE, sanitizer?: SanitizerFn | null, nativeOnly?: boolean): void;
-
-/**
- * Create DOM element. The instruction must later be followed by `elementEnd()` call.
- *
- * @param index Index of the element in the LView array
- * @param name Name of the DOM Node
- * @param attrs Statically bound set of attributes, classes, and styles to be written into the DOM
- *              element on creation. Use [AttributeMarker] to denote the meaning of this array.
- * @param localRefs A set of local reference bindings on the element.
- *
- * Attributes and localRefs are passed as an array of strings where elements with an even index
- * hold an attribute name and elements with an odd index hold an attribute value, ex.:
- * ['id', 'warning5', 'class', 'alert']
- *
- * @codeGenApi
- */
-export declare function ɵɵelementStart(index: number, name: string, attrs?: TAttributes | null, localRefs?: string[] | null): void;
-
-/**
- * Update a style binding on an element with the provided value.
- *
- * If the style value is falsy then it will be removed from the element
- * (or assigned a different value depending if there are any styles placed
- * on the element with `elementStylingMap` or any static styles that are
- * present from when the element was created with `elementStyling`).
- *
- * Note that the styling element is updated as part of `elementStylingApply`.
- *
- * @param index Index of the element's with which styling is associated.
- * @param styleIndex Index of style to update. This index value refers to the
- *        index of the style in the style bindings array that was passed into
- *        `elementStyling`.
- * @param value New value to write (falsy to remove). Note that if a directive also
- *        attempts to write to the same binding value (via `elementHostStyleProp`)
- *        then it will only be able to do so if the binding value assigned via
- *        `elementStyleProp` is falsy (or doesn't exist at all).
- * @param suffix Optional suffix. Used with scalar values to add unit such as `px`.
- *        Note that when a suffix is provided then the underlying sanitizer will
- *        be ignored.
- * @param forceOverride Whether or not to update the styling value immediately
- *        (despite the other bindings possibly having priority)
- *
- * @codeGenApi
- */
-export declare function ɵɵelementStyleProp(index: number, styleIndex: number, value: string | number | String | ɵPlayerFactory | null, suffix?: string | null, forceOverride?: boolean): void;
-
-/**
- * Allocates style and class binding properties on the element during creation mode.
- *
- * This instruction is meant to be called during creation mode to register all
- * dynamic style and class bindings on the element. Note that this is only used
- * for binding values (see `elementStart` to learn how to assign static styling
- * values to an element).
+ * NOTE: This instruction is meant to used from `hostBindings` function only.
  *
- * @param classBindingNames An array containing bindable class names.
- *        The `elementClassProp` instruction refers to the class name by index in
- *        this array (i.e. `['foo', 'bar']` means `foo=0` and `bar=1`).
- * @param styleBindingNames An array containing bindable style properties.
- *        The `elementStyleProp` instruction refers to the class name by index in
- *        this array (i.e. `['width', 'height']` means `width=0` and `height=1`).
- * @param styleSanitizer An optional sanitizer function that will be used to sanitize any CSS
- *        style values that are applied to the element (during rendering).
+ * @param directive A directive instance the styling is associated with.
+ * @param attrs An array of static values (attributes, classes and styles) with the correct marker
+ * values.
  *
  * @codeGenApi
  */
-export declare function ɵɵelementStyling(classBindingNames?: string[] | null, styleBindingNames?: string[] | null, styleSanitizer?: StyleSanitizeFn | null): void;
+export declare function ɵɵelementHostAttrs(attrs: TAttributes): void;
 
 /**
- * Apply all style and class binding values to the element.
- *
- * This instruction is meant to be run after `elementStylingMap`, `elementStyleProp`
- * or `elementClassProp` instructions have been run and will only apply styling to
- * the element if any styling bindings have been updated.
- *
- * @param index Index of the element's with which styling is associated.
+* **TODO: Remove this function after `property` is in use**
+* Update a property on an element.
+*
+* If the property name also exists as an input property on one of the element's directives,
+* the component property will be set instead of the element property. This check must
+* be conducted at runtime so child components that add new @Inputs don't have to be re-compiled.
+*
+* @param index The index of the element to update in the data array
+* @param propName Name of property. Because it is going to DOM, this is not subject to
+*        renaming as part of minification.
+* @param value New value to write.
+* @param sanitizer An optional function used to sanitize the value.
+* @param nativeOnly Whether or not we should only set native properties and skip input check
+* (this is necessary for host property bindings)
  *
  * @codeGenApi
- */
-export declare function ɵɵelementStylingApply(index: number): void;
+*/
+export declare function ɵɵelementProperty<T>(index: number, propName: string, value: T | ɵNO_CHANGE, sanitizer?: SanitizerFn | null, nativeOnly?: boolean): void;
 
 /**
- * Update style and/or class bindings using object literals on an element.
- *
- * This instruction is meant to apply styling via the `[style]="exp"` and `[class]="exp"` template
- * bindings. When styles/classes are applied to the element they will then be updated with
- * respect to any styles/classes set with `elementStyleProp` or `elementClassProp`. If any
- * styles or classes are set to falsy then they will be removed from the element.
+ * Create DOM element. The instruction must later be followed by `elementEnd()` call.
  *
- * Note that the styling instruction will not be applied until `elementStylingApply` is called.
+ * @param index Index of the element in the LView array
+ * @param name Name of the DOM Node
+ * @param attrs Statically bound set of attributes, classes, and styles to be written into the DOM
+ *              element on creation. Use [AttributeMarker] to denote the meaning of this array.
+ * @param localRefs A set of local reference bindings on the element.
  *
- * @param index Index of the element's with which styling is associated.
- * @param classes A key/value map or string of CSS classes that will be added to the
- *        given element. Any missing classes (that have already been applied to the element
- *        beforehand) will be removed (unset) from the element's list of CSS classes.
- * @param styles A key/value style map of the styles that will be applied to the given element.
- *        Any missing styles (that have already been applied to the element beforehand) will be
- *        removed (unset) from the element's styling.
+ * Attributes and localRefs are passed as an array of strings where elements with an even index
+ * hold an attribute name and elements with an odd index hold an attribute value, ex.:
+ * ['id', 'warning5', 'class', 'alert']
  *
  * @codeGenApi
  */
-export declare function ɵɵelementStylingMap(index: number, classes: {
-    [key: string]: any;
-} | string | ɵNO_CHANGE | null, styles?: {
-    [styleName: string]: any;
-} | ɵNO_CHANGE | null): void;
+export declare function ɵɵelementStart(index: number, name: string, attrs?: TAttributes | null, localRefs?: string[] | null): void;
 
 /**
  * Marks the end of an embedded view.
@@ -11778,7 +12367,7 @@ export declare function ɵɵi18nExp<T>(expression: T | ɵNO_CHANGE): void;
  * running outside of Closure Compiler. This method will not be needed once runtime translation
  * service support is introduced.
  *
- * @publicApi
+ * @codeGenApi
  * @deprecated this method is temporary & should not be used as it will be removed soon
  */
 export declare function ɵɵi18nLocalize(input: string, placeholders?: {
@@ -13072,6 +13661,91 @@ export declare function ɵɵstaticContentQuery<T>(directiveIndex: number, predic
  */
 export declare function ɵɵstaticViewQuery<T>(predicate: Type<any> | string[], descend: boolean, read: any): void;
 
+/**
+ * Update style bindings using an object literal on an element.
+ *
+ * This instruction is meant to apply styling via the `[style]="exp"` template bindings.
+ * When styles are applied to the element they will then be updated with respect to
+ * any styles/classes set via `styleProp`. If any styles are set to falsy
+ * then they will be removed from the element.
+ *
+ * Note that the styling instruction will not be applied until `stylingApply` is called.
+ *
+ * @param styles A key/value style map of the styles that will be applied to the given element.
+ *        Any missing styles (that have already been applied to the element beforehand) will be
+ *        removed (unset) from the element's styling.
+ *
+ * Note that this will apply the provided styleMap value to the host element if this function
+ * is called within a host binding.
+ *
+ * @codeGenApi
+ */
+export declare function ɵɵstyleMap(styles: {
+    [styleName: string]: any;
+} | ɵNO_CHANGE | null): void;
+
+/**
+ * Update a style binding on an element with the provided value.
+ *
+ * If the style value is falsy then it will be removed from the element
+ * (or assigned a different value depending if there are any styles placed
+ * on the element with `styleMap` or any static styles that are
+ * present from when the element was created with `styling`).
+ *
+ * Note that the styling element is updated as part of `stylingApply`.
+ *
+ * @param styleIndex Index of style to update. This index value refers to the
+ *        index of the style in the style bindings array that was passed into
+ *        `styling`.
+ * @param value New value to write (falsy to remove).
+ * @param suffix Optional suffix. Used with scalar values to add unit such as `px`.
+ *        Note that when a suffix is provided then the underlying sanitizer will
+ *        be ignored.
+ * @param forceOverride Whether or not to update the styling value immediately
+ *        (despite the other bindings possibly having priority)
+ *
+ * Note that this will apply the provided style value to the host element if this function is called
+ * within a host binding.
+ *
+ * @codeGenApi
+ */
+export declare function ɵɵstyleProp(styleIndex: number, value: string | number | String | ɵPlayerFactory | null, suffix?: string | null, forceOverride?: boolean): void;
+
+/**
+ * Allocates style and class binding properties on the element during creation mode.
+ *
+ * This instruction is meant to be called during creation mode to register all
+ * dynamic style and class bindings on the element. Note that this is only used
+ * for binding values (see `elementStart` to learn how to assign static styling
+ * values to an element).
+ *
+ * @param classBindingNames An array containing bindable class names.
+ *        The `classProp` instruction refers to the class name by index in
+ *        this array (i.e. `['foo', 'bar']` means `foo=0` and `bar=1`).
+ * @param styleBindingNames An array containing bindable style properties.
+ *        The `styleProp` instruction refers to the class name by index in
+ *        this array (i.e. `['width', 'height']` means `width=0` and `height=1`).
+ * @param styleSanitizer An optional sanitizer function that will be used to sanitize any CSS
+ *        style values that are applied to the element (during rendering).
+ *
+ * Note that this will allocate the provided style/class bindings to the host element if
+ * this function is called within a host binding.
+ *
+ * @codeGenApi
+ */
+export declare function ɵɵstyling(classBindingNames?: string[] | null, styleBindingNames?: string[] | null, styleSanitizer?: StyleSanitizeFn | null): void;
+
+/**
+ * Apply all style and class binding values to the element.
+ *
+ * This instruction is meant to be run after `styleMap`, `classMap`,
+ * `styleProp` or `classProp` instructions have been run and will
+ * only apply styling to the element if any styling bindings have been updated.
+ *
+ * @codeGenApi
+ */
+export declare function ɵɵstylingApply(): void;
+
 /**
  * Creates an LContainer for an ng-template (dynamically-inserted view), e.g.
  *
@@ -13122,6 +13796,230 @@ export declare function ɵɵtext(index: number, value?: any): void;
  */
 export declare function ɵɵtextBinding<T>(index: number, value: T | ɵNO_CHANGE): void;
 
+/**
+ *
+ * Update text content with a lone bound value
+ *
+ * Used when a text node has 1 interpolated value in it, an no additional text
+ * surrounds that interpolated value:
+ *
+ * ```html
+ * <div>{{v0}}</div>
+ * ```
+ *
+ * Its compiled representation is:
+ *
+ * ```ts
+ * ɵɵtextInterpolate(v0);
+ * ```
+ * @returns itself, so that it may be chained.
+ * @see textInterpolateV
+ * @codeGenApi
+ */
+export declare function ɵɵtextInterpolate(v0: any): TsickleIssue1009;
+
+/**
+ *
+ * Update text content with single bound value surrounded by other text.
+ *
+ * Used when a text node has 1 interpolated value in it:
+ *
+ * ```html
+ * <div>prefix{{v0}}suffix</div>
+ * ```
+ *
+ * Its compiled representation is:
+ *
+ * ```ts
+ * ɵɵtextInterpolate1('prefix', v0, 'suffix');
+ * ```
+ * @returns itself, so that it may be chained.
+ * @see textInterpolateV
+ * @codeGenApi
+ */
+export declare function ɵɵtextInterpolate1(prefix: string, v0: any, suffix: string): TsickleIssue1009;
+
+/**
+ *
+ * Update text content with 2 bound values surrounded by other text.
+ *
+ * Used when a text node has 2 interpolated values in it:
+ *
+ * ```html
+ * <div>prefix{{v0}}-{{v1}}suffix</div>
+ * ```
+ *
+ * Its compiled representation is:
+ *
+ * ```ts
+ * ɵɵtextInterpolate2('prefix', v0, '-', v1, 'suffix');
+ * ```
+ * @returns itself, so that it may be chained.
+ * @see textInterpolateV
+ * @codeGenApi
+ */
+export declare function ɵɵtextInterpolate2(prefix: string, v0: any, i0: string, v1: any, suffix: string): TsickleIssue1009;
+
+/**
+ *
+ * Update text content with 3 bound values surrounded by other text.
+ *
+ * Used when a text node has 3 interpolated values in it:
+ *
+ * ```html
+ * <div>prefix{{v0}}-{{v1}}-{{v2}}suffix</div>
+ * ```
+ *
+ * Its compiled representation is:
+ *
+ * ```ts
+ * ɵɵtextInterpolate3(
+ * 'prefix', v0, '-', v1, '-', v2, 'suffix');
+ * ```
+ * @returns itself, so that it may be chained.
+ * @see textInterpolateV
+ * @codeGenApi
+ */
+export declare function ɵɵtextInterpolate3(prefix: string, v0: any, i0: string, v1: any, i1: string, v2: any, suffix: string): TsickleIssue1009;
+
+/**
+ *
+ * Update text content with 4 bound values surrounded by other text.
+ *
+ * Used when a text node has 4 interpolated values in it:
+ *
+ * ```html
+ * <div>prefix{{v0}}-{{v1}}-{{v2}}-{{v3}}suffix</div>
+ * ```
+ *
+ * Its compiled representation is:
+ *
+ * ```ts
+ * ɵɵtextInterpolate4(
+ * 'prefix', v0, '-', v1, '-', v2, '-', v3, 'suffix');
+ * ```
+ * @returns itself, so that it may be chained.
+ * @see ɵɵtextInterpolateV
+ * @codeGenApi
+ */
+export declare function ɵɵtextInterpolate4(prefix: string, v0: any, i0: string, v1: any, i1: string, v2: any, i2: string, v3: any, suffix: string): TsickleIssue1009;
+
+/**
+ *
+ * Update text content with 5 bound values surrounded by other text.
+ *
+ * Used when a text node has 5 interpolated values in it:
+ *
+ * ```html
+ * <div>prefix{{v0}}-{{v1}}-{{v2}}-{{v3}}-{{v4}}suffix</div>
+ * ```
+ *
+ * Its compiled representation is:
+ *
+ * ```ts
+ * ɵɵtextInterpolate5(
+ * 'prefix', v0, '-', v1, '-', v2, '-', v3, '-', v4, 'suffix');
+ * ```
+ * @returns itself, so that it may be chained.
+ * @see textInterpolateV
+ * @codeGenApi
+ */
+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): TsickleIssue1009;
+
+/**
+ *
+ * Update text content with 6 bound values surrounded by other text.
+ *
+ * Used when a text node has 6 interpolated values in it:
+ *
+ * ```html
+ * <div>prefix{{v0}}-{{v1}}-{{v2}}-{{v3}}-{{v4}}-{{v5}}suffix</div>
+ * ```
+ *
+ * Its compiled representation is:
+ *
+ * ```ts
+ * ɵɵtextInterpolate6(
+ *    'prefix', v0, '-', v1, '-', v2, '-', v3, '-', v4, '-', v5, 'suffix');
+ * ```
+ *
+ * @param i4 Static value used for concatenation only.
+ * @param v5 Value checked for change. @returns itself, so that it may be chained.
+ * @see textInterpolateV
+ * @codeGenApi
+ */
+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): TsickleIssue1009;
+
+/**
+ *
+ * Update text content with 7 bound values surrounded by other text.
+ *
+ * Used when a text node has 7 interpolated values in it:
+ *
+ * ```html
+ * <div>prefix{{v0}}-{{v1}}-{{v2}}-{{v3}}-{{v4}}-{{v5}}-{{v6}}suffix</div>
+ * ```
+ *
+ * Its compiled representation is:
+ *
+ * ```ts
+ * ɵɵtextInterpolate7(
+ *    'prefix', v0, '-', v1, '-', v2, '-', v3, '-', v4, '-', v5, '-', v6, 'suffix');
+ * ```
+ * @returns itself, so that it may be chained.
+ * @see textInterpolateV
+ * @codeGenApi
+ */
+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): TsickleIssue1009;
+
+/**
+ *
+ * Update text content with 8 bound values surrounded by other text.
+ *
+ * Used when a text node has 8 interpolated values in it:
+ *
+ * ```html
+ * <div>prefix{{v0}}-{{v1}}-{{v2}}-{{v3}}-{{v4}}-{{v5}}-{{v6}}-{{v7}}suffix</div>
+ * ```
+ *
+ * Its compiled representation is:
+ *
+ * ```ts
+ * ɵɵtextInterpolate8(
+ *  'prefix', v0, '-', v1, '-', v2, '-', v3, '-', v4, '-', v5, '-', v6, '-', v7, 'suffix');
+ * ```
+ * @returns itself, so that it may be chained.
+ * @see textInterpolateV
+ * @codeGenApi
+ */
+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): TsickleIssue1009;
+
+/**
+ * Update text content with 9 or more bound values other surrounded by text.
+ *
+ * Used when the number of interpolated values exceeds 8.
+ *
+ * ```html
+ * <div>prefix{{v0}}-{{v1}}-{{v2}}-{{v3}}-{{v4}}-{{v5}}-{{v6}}-{{v7}}-{{v8}}-{{v9}}suffix</div>
+ * ```
+ *
+ * Its compiled representation is:
+ *
+ * ```ts
+ * ɵɵtextInterpolateV(
+ *  ['prefix', v0, '-', v1, '-', v2, '-', v3, '-', v4, '-', v5, '-', v6, '-', v7, '-', v9,
+ *  'suffix']);
+ * ```
+ *.
+ * @param values The a collection of values and the strings in between those values, beginning with
+ * a string prefix and ending with a string suffix.
+ * (e.g. `['prefix', value0, '-', value1, '-', value2, ..., value99, 'suffix']`)
+ *
+ * @returns itself, so that it may be chained.
+ * @codeGenApi
+ */
+export declare function ɵɵtextInterpolateV(values: any[]): TsickleIssue1009;
+
 /**
  * Creates new QueryList, stores the reference in LView and returns QueryList.
  *