@angular/core 0.0.0-6 → 2.0.0-rc.2

package/esm/src/metadata.d.ts

@@ -2,14 +2,15 @@
  * This indirection is needed to free up Component, etc symbols in the public API
  * to be used by the decorator versions of these annotations.
  */
-export { QueryMetadata, ContentChildrenMetadata, ContentChildMetadata, ViewChildrenMetadata, ViewQueryMetadata, ViewChildMetadata, AttributeMetadata } from './metadata/di';
-export { ComponentMetadata, DirectiveMetadata, PipeMetadata, InputMetadata, OutputMetadata, HostBindingMetadata, HostListenerMetadata } from './metadata/directives';
-export { ViewMetadata, ViewEncapsulation } from './metadata/view';
-export { AfterContentInit, AfterContentChecked, AfterViewInit, AfterViewChecked, OnChanges, OnDestroy, OnInit, DoCheck } from './metadata/lifecycle_hooks';
-import { QueryMetadata, ContentChildrenMetadata, ViewChildrenMetadata, AttributeMetadata } from './metadata/di';
+import { ChangeDetectionStrategy } from '../src/change_detection/change_detection';
+import { AnimationEntryMetadata } from './animation/metadata';
+import { AttributeMetadata, ContentChildrenMetadata, QueryMetadata, ViewChildrenMetadata } from './metadata/di';
 import { ComponentMetadata, DirectiveMetadata } from './metadata/directives';
-import { ViewMetadata, ViewEncapsulation } from './metadata/view';
-import { ChangeDetectionStrategy } from './change_detection/change_detection';
+import { ViewEncapsulation, ViewMetadata } from './metadata/view';
+export { AttributeMetadata, ContentChildMetadata, ContentChildrenMetadata, QueryMetadata, ViewChildMetadata, ViewChildrenMetadata, ViewQueryMetadata } from './metadata/di';
+export { ComponentMetadata, DirectiveMetadata, HostBindingMetadata, HostListenerMetadata, InputMetadata, OutputMetadata, PipeMetadata } from './metadata/directives';
+export { AfterContentChecked, AfterContentInit, AfterViewChecked, AfterViewInit, DoCheck, OnChanges, OnDestroy, OnInit } from './metadata/lifecycle_hooks';
+export { ViewEncapsulation, ViewMetadata } from './metadata/view';
 import { TypeDecorator } from './util/decorators';
 import { Type } from '../src/facade/lang';
 /**
@@ -36,6 +37,7 @@ export interface ComponentDecorator extends TypeDecorator {
         renderer?: string;
         styles?: string[];
         styleUrls?: string[];
+        animations?: AnimationEntryMetadata[];
     }): ViewDecorator;
 }
 /**
@@ -55,6 +57,7 @@ export interface ViewDecorator extends TypeDecorator {
         renderer?: string;
         styles?: string[];
         styleUrls?: string[];
+        animations?: AnimationEntryMetadata[];
     }): ViewDecorator;
 }
 /**
@@ -98,7 +101,6 @@ export interface DirectiveMetadataFactory {
         host?: {
             [key: string]: string;
         };
-        bindings?: any[];
         providers?: any[];
         exportAs?: string;
         queries?: {
@@ -114,7 +116,6 @@ export interface DirectiveMetadataFactory {
         host?: {
             [key: string]: string;
         };
-        bindings?: any[];
         providers?: any[];
         exportAs?: string;
         queries?: {
@@ -163,20 +164,19 @@ export interface ComponentMetadataFactory {
         host?: {
             [key: string]: string;
         };
-        bindings?: any[];
         providers?: any[];
         exportAs?: string;
         moduleId?: string;
         queries?: {
             [key: string]: any;
         };
-        viewBindings?: any[];
         viewProviders?: any[];
         changeDetection?: ChangeDetectionStrategy;
         templateUrl?: string;
         template?: string;
         styleUrls?: string[];
         styles?: string[];
+        animations?: AnimationEntryMetadata[];
         directives?: Array<Type | any[]>;
         pipes?: Array<Type | any[]>;
         encapsulation?: ViewEncapsulation;
@@ -190,20 +190,19 @@ export interface ComponentMetadataFactory {
         host?: {
             [key: string]: string;
         };
-        bindings?: any[];
         providers?: any[];
         exportAs?: string;
         moduleId?: string;
         queries?: {
             [key: string]: any;
         };
-        viewBindings?: any[];
         viewProviders?: any[];
         changeDetection?: ChangeDetectionStrategy;
         templateUrl?: string;
         template?: string;
         styleUrls?: string[];
         styles?: string[];
+        animations?: AnimationEntryMetadata[];
         directives?: Array<Type | any[]>;
         pipes?: Array<Type | any[]>;
         encapsulation?: ViewEncapsulation;
@@ -260,6 +259,7 @@ export interface ViewMetadataFactory {
         encapsulation?: ViewEncapsulation;
         styles?: string[];
         styleUrls?: string[];
+        animations?: AnimationEntryMetadata[];
     }): ViewDecorator;
     new (obj: {
         templateUrl?: string;
@@ -269,6 +269,7 @@ export interface ViewMetadataFactory {
         encapsulation?: ViewEncapsulation;
         styles?: string[];
         styleUrls?: string[];
+        animations?: AnimationEntryMetadata[];
     }): ViewMetadata;
 }
 /**
@@ -351,6 +352,7 @@ export interface AttributeMetadataFactory {
  *   [new ng.Query(SomeType)]
  * ]
  * ```
+ * @deprecated
  */
 export interface QueryMetadataFactory {
     (selector: Type | string, {descendants, read}?: {
@@ -364,6 +366,7 @@ export interface QueryMetadataFactory {
 }
 /**
  * Factory for {@link ContentChildren}.
+ * @stable
  */
 export interface ContentChildrenMetadataFactory {
     (selector: Type | string, {descendants, read}?: {
@@ -377,6 +380,7 @@ export interface ContentChildrenMetadataFactory {
 }
 /**
  * Factory for {@link ContentChild}.
+ * @stable
  */
 export interface ContentChildMetadataFactory {
     (selector: Type | string, {read}?: {
@@ -388,6 +392,7 @@ export interface ContentChildMetadataFactory {
 }
 /**
  * Factory for {@link ViewChildren}.
+ * @stable
  */
 export interface ViewChildrenMetadataFactory {
     (selector: Type | string, {read}?: {
@@ -399,6 +404,7 @@ export interface ViewChildrenMetadataFactory {
 }
 /**
  * Factory for {@link ViewChild}.
+ * @stable
  */
 export interface ViewChildMetadataFactory {
     (selector: Type | string, {read}?: {
@@ -414,6 +420,7 @@ export interface ViewChildMetadataFactory {
  * ### Example
  *
  * {@example core/ts/metadata/metadata.ts region='pipe'}
+ * @stable
  */
 export interface PipeMetadataFactory {
     (obj: {
@@ -429,6 +436,7 @@ export interface PipeMetadataFactory {
  * {@link InputMetadata} factory for creating decorators.
  *
  * See {@link InputMetadata}.
+ * @stable
  */
 export interface InputMetadataFactory {
     (bindingPropertyName?: string): any;
@@ -438,6 +446,7 @@ export interface InputMetadataFactory {
  * {@link OutputMetadata} factory for creating decorators.
  *
  * See {@link OutputMetadata}.
+ * @stable
  */
 export interface OutputMetadataFactory {
     (bindingPropertyName?: string): any;
@@ -445,6 +454,7 @@ export interface OutputMetadataFactory {
 }
 /**
  * {@link HostBindingMetadata} factory function.
+ * @stable
  */
 export interface HostBindingMetadataFactory {
     (hostPropertyName?: string): any;
@@ -452,6 +462,7 @@ export interface HostBindingMetadataFactory {
 }
 /**
  * {@link HostListenerMetadata} factory function.
+ * @stable
  */
 export interface HostListenerMetadataFactory {
     (eventName: string, args?: string[]): any;
@@ -479,6 +490,7 @@ export interface HostListenerMetadataFactory {
  * ### Example
  *
  * {@example core/ts/metadata/metadata.ts region='component'}
+ * @stable
  */
 export declare var Component: ComponentMetadataFactory;
 /**
@@ -858,6 +870,7 @@ export declare var Component: ComponentMetadataFactory;
  * Note also that although the `<li></li>` template still exists inside the `<template></template>`,
  * the instantiated
  * view occurs on the second `<li></li>` which is a sibling to the `<template>` element.
+ * @stable
  */
 export declare var Directive: DirectiveMetadataFactory;
 /**
@@ -876,6 +889,7 @@ export declare var Directive: DirectiveMetadataFactory;
  * A decorator can inject string literal `text` like so:
  *
  * {@example core/ts/metadata/metadata.ts region='attributeMetadata'}
+ * @stable
  */
 export declare var Attribute: AttributeMetadataFactory;
 /**
@@ -984,6 +998,7 @@ export declare var Attribute: AttributeMetadataFactory;
  *
  * The injected object is an unmodifiable live list.
  * See {@link QueryList} for more details.
+ * @deprecated
  */
 export declare var Query: QueryMetadataFactory;
 /**
@@ -1005,6 +1020,7 @@ export declare var Query: QueryMetadataFactory;
  *   }
  * }
  * ```
+ * @stable
  */
 export declare var ContentChildren: ContentChildrenMetadataFactory;
 /**
@@ -1020,12 +1036,22 @@ export declare var ContentChildren: ContentChildrenMetadataFactory;
  * })
  * class SomeDir {
  *   @ContentChild(ChildDirective) contentChild;
+ *   @ContentChild('container_ref') containerChild
  *
  *   ngAfterContentInit() {
  *     // contentChild is set
+ *     // containerChild is set
  *   }
  * }
  * ```
+ *
+ * ```html
+ * <container #container_ref>
+ *   <item>a</item>
+ *   <item>b</item>
+ * </container>
+ * ```
+ * @stable
  */
 export declare var ContentChild: ContentChildMetadataFactory;
 /**
@@ -1106,6 +1132,7 @@ export declare var ContentChild: ContentChildMetadataFactory;
  * ```
  *
  * See also: [ViewChildrenMetadata]
+ * @stable
  */
 export declare var ViewChildren: ViewChildrenMetadataFactory;
 /**
@@ -1177,6 +1204,7 @@ export declare var ViewChildren: ViewChildrenMetadataFactory;
  * }
  * ```
  * See also: [ViewChildMetadata]
+ * @stable
  */
 export declare var ViewChild: ViewChildMetadataFactory;
 /**
@@ -1213,6 +1241,7 @@ export declare var ViewChild: ViewChildMetadataFactory;
  *
  * The injected object is an iterable and observable live list.
  * See {@link QueryList} for more details.
+ * @deprecated
  */
 export declare var ViewQuery: QueryMetadataFactory;
 /**
@@ -1221,6 +1250,7 @@ export declare var ViewQuery: QueryMetadataFactory;
  * ### Example
  *
  * {@example core/ts/metadata/metadata.ts region='pipe'}
+ * @stable
  */
 export declare var Pipe: PipeMetadataFactory;
 /**
@@ -1263,6 +1293,7 @@ export declare var Pipe: PipeMetadataFactory;
  *
  * bootstrap(App);
  * ```
+ * @stable
  */
 export declare var Input: InputMetadataFactory;
 /**
@@ -1305,6 +1336,7 @@ export declare var Input: InputMetadataFactory;
  * }
  * bootstrap(App);
  * ```
+ * @stable
  */
 export declare var Output: OutputMetadataFactory;
 /**
@@ -1326,8 +1358,8 @@ export declare var Output: OutputMetadataFactory;
  * @Directive({selector: '[ngModel]'})
  * class NgModelStatus {
  *   constructor(public control:NgModel) {}
- *   @HostBinding('[class.valid]') get valid { return this.control.valid; }
- *   @HostBinding('[class.invalid]') get invalid { return this.control.invalid; }
+ *   @HostBinding('class.valid') get valid() { return this.control.valid; }
+ *   @HostBinding('class.invalid') get invalid() { return this.control.invalid; }
  * }
  *
  * @Component({
@@ -1341,6 +1373,7 @@ export declare var Output: OutputMetadataFactory;
  *
  * bootstrap(App);
  * ```
+ * @stable
  */
 export declare var HostBinding: HostBindingMetadataFactory;
 /**
@@ -1376,5 +1409,6 @@ export declare var HostBinding: HostBindingMetadataFactory;
  *
  * bootstrap(App);
  * ```
+ * @stable
  */
 export declare var HostListener: HostListenerMetadataFactory;

package/esm/src/metadata.js

@@ -1,13 +1,14 @@
 /**
-* This indirection is needed to free up Component, etc symbols in the public API
-* to be used by the decorator versions of these annotations.
-*/
-export { QueryMetadata, ContentChildrenMetadata, ContentChildMetadata, ViewChildrenMetadata, ViewQueryMetadata, ViewChildMetadata, AttributeMetadata } from './metadata/di';
-export { ComponentMetadata, DirectiveMetadata, PipeMetadata, InputMetadata, OutputMetadata, HostBindingMetadata, HostListenerMetadata } from './metadata/directives';
-export { ViewMetadata, ViewEncapsulation } from './metadata/view';
-import { QueryMetadata, ContentChildrenMetadata, ContentChildMetadata, ViewChildrenMetadata, ViewChildMetadata, ViewQueryMetadata, AttributeMetadata } from './metadata/di';
-import { ComponentMetadata, DirectiveMetadata, PipeMetadata, InputMetadata, OutputMetadata, HostBindingMetadata, HostListenerMetadata } from './metadata/directives';
+ * This indirection is needed to free up Component, etc symbols in the public API
+ * to be used by the decorator versions of these annotations.
+ */
+import { AttributeMetadata, ContentChildMetadata, ContentChildrenMetadata, QueryMetadata, ViewChildMetadata, ViewChildrenMetadata, ViewQueryMetadata } from './metadata/di';
+import { ComponentMetadata, DirectiveMetadata, HostBindingMetadata, HostListenerMetadata, InputMetadata, OutputMetadata, PipeMetadata } from './metadata/directives';
 import { ViewMetadata } from './metadata/view';
+export { AttributeMetadata, ContentChildMetadata, ContentChildrenMetadata, QueryMetadata, ViewChildMetadata, ViewChildrenMetadata, ViewQueryMetadata } from './metadata/di';
+export { ComponentMetadata, DirectiveMetadata, HostBindingMetadata, HostListenerMetadata, InputMetadata, OutputMetadata, PipeMetadata } from './metadata/directives';
+export { AfterContentChecked, AfterContentInit, AfterViewChecked, AfterViewInit, DoCheck, OnChanges, OnDestroy, OnInit } from './metadata/lifecycle_hooks';
+export { ViewEncapsulation, ViewMetadata } from './metadata/view';
 import { makeDecorator, makeParamDecorator, makePropDecorator } from './util/decorators';
 // TODO(alexeagle): remove the duplication of this doc. It is copied from ComponentMetadata.
 /**
@@ -32,6 +33,7 @@ import { makeDecorator, makeParamDecorator, makePropDecorator } from './util/dec
  * ### Example
  *
  * {@example core/ts/metadata/metadata.ts region='component'}
+ * @stable
  */
 export var Component = makeDecorator(ComponentMetadata, (fn) => fn.View = View);
 // TODO(alexeagle): remove the duplication of this doc. It is copied from DirectiveMetadata.
@@ -412,6 +414,7 @@ export var Component = makeDecorator(ComponentMetadata, (fn) => fn.View = View);
  * Note also that although the `<li></li>` template still exists inside the `<template></template>`,
  * the instantiated
  * view occurs on the second `<li></li>` which is a sibling to the `<template>` element.
+ * @stable
  */
 export var Directive = makeDecorator(DirectiveMetadata);
 // TODO(alexeagle): remove the duplication of this doc. It is copied from ViewMetadata.
@@ -443,6 +446,7 @@ export var Directive = makeDecorator(DirectiveMetadata);
  *   }
  * }
  * ```
+ * @deprecated
  */
 var View = makeDecorator(ViewMetadata, (fn) => fn.View = View);
 /**
@@ -461,6 +465,7 @@ var View = makeDecorator(ViewMetadata, (fn) => fn.View = View);
  * A decorator can inject string literal `text` like so:
  *
  * {@example core/ts/metadata/metadata.ts region='attributeMetadata'}
+ * @stable
  */
 export var Attribute = makeParamDecorator(AttributeMetadata);
 // TODO(alexeagle): remove the duplication of this doc. It is copied from QueryMetadata.
@@ -570,6 +575,7 @@ export var Attribute = makeParamDecorator(AttributeMetadata);
  *
  * The injected object is an unmodifiable live list.
  * See {@link QueryList} for more details.
+ * @deprecated
  */
 export var Query = makeParamDecorator(QueryMetadata);
 // TODO(alexeagle): remove the duplication of this doc. It is copied from ContentChildrenMetadata.
@@ -592,6 +598,7 @@ export var Query = makeParamDecorator(QueryMetadata);
  *   }
  * }
  * ```
+ * @stable
  */
 export var ContentChildren = makePropDecorator(ContentChildrenMetadata);
 // TODO(alexeagle): remove the duplication of this doc. It is copied from ContentChildMetadata.
@@ -608,12 +615,22 @@ export var ContentChildren = makePropDecorator(ContentChildrenMetadata);
  * })
  * class SomeDir {
  *   @ContentChild(ChildDirective) contentChild;
+ *   @ContentChild('container_ref') containerChild
  *
  *   ngAfterContentInit() {
  *     // contentChild is set
+ *     // containerChild is set
  *   }
  * }
  * ```
+ *
+ * ```html
+ * <container #container_ref>
+ *   <item>a</item>
+ *   <item>b</item>
+ * </container>
+ * ```
+ * @stable
  */
 export var ContentChild = makePropDecorator(ContentChildMetadata);
 // TODO(alexeagle): remove the duplication of this doc. It is copied from ViewChildrenMetadata.
@@ -695,6 +712,7 @@ export var ContentChild = makePropDecorator(ContentChildMetadata);
  * ```
  *
  * See also: [ViewChildrenMetadata]
+ * @stable
  */
 export var ViewChildren = makePropDecorator(ViewChildrenMetadata);
 // TODO(alexeagle): remove the duplication of this doc. It is copied from ViewChildMetadata.
@@ -767,6 +785,7 @@ export var ViewChildren = makePropDecorator(ViewChildrenMetadata);
  * }
  * ```
  * See also: [ViewChildMetadata]
+ * @stable
  */
 export var ViewChild = makePropDecorator(ViewChildMetadata);
 // TODO(alexeagle): remove the duplication of this doc. It is copied from ViewQueryMetadata.
@@ -804,6 +823,7 @@ export var ViewChild = makePropDecorator(ViewChildMetadata);
  *
  * The injected object is an iterable and observable live list.
  * See {@link QueryList} for more details.
+ * @deprecated
  */
 export var ViewQuery = makeParamDecorator(ViewQueryMetadata);
 // TODO(alexeagle): remove the duplication of this doc. It is copied from PipeMetadata.
@@ -813,6 +833,7 @@ export var ViewQuery = makeParamDecorator(ViewQueryMetadata);
  * ### Example
  *
  * {@example core/ts/metadata/metadata.ts region='pipe'}
+ * @stable
  */
 export var Pipe = makeDecorator(PipeMetadata);
 // TODO(alexeagle): remove the duplication of this doc. It is copied from InputMetadata.
@@ -856,6 +877,7 @@ export var Pipe = makeDecorator(PipeMetadata);
  *
  * bootstrap(App);
  * ```
+ * @stable
  */
 export var Input = makePropDecorator(InputMetadata);
 // TODO(alexeagle): remove the duplication of this doc. It is copied from OutputMetadata.
@@ -899,6 +921,7 @@ export var Input = makePropDecorator(InputMetadata);
  * }
  * bootstrap(App);
  * ```
+ * @stable
  */
 export var Output = makePropDecorator(OutputMetadata);
 // TODO(alexeagle): remove the duplication of this doc. It is copied from HostBindingMetadata.
@@ -921,8 +944,8 @@ export var Output = makePropDecorator(OutputMetadata);
  * @Directive({selector: '[ngModel]'})
  * class NgModelStatus {
  *   constructor(public control:NgModel) {}
- *   @HostBinding('[class.valid]') get valid { return this.control.valid; }
- *   @HostBinding('[class.invalid]') get invalid { return this.control.invalid; }
+ *   @HostBinding('class.valid') get valid() { return this.control.valid; }
+ *   @HostBinding('class.invalid') get invalid() { return this.control.invalid; }
  * }
  *
  * @Component({
@@ -936,6 +959,7 @@ export var Output = makePropDecorator(OutputMetadata);
  *
  * bootstrap(App);
  * ```
+ * @stable
  */
 export var HostBinding = makePropDecorator(HostBindingMetadata);
 // TODO(alexeagle): remove the duplication of this doc. It is copied from HostListenerMetadata.
@@ -972,6 +996,7 @@ export var HostBinding = makePropDecorator(HostBindingMetadata);
  *
  * bootstrap(App);
  * ```
+ * @stable
  */
 export var HostListener = makePropDecorator(HostListenerMetadata);
 //# sourceMappingURL=metadata.js.map

package/esm/src/metadata.js.map

@@ -1 +1 @@
-{"version":3,"file":"metadata.js","sourceRoot":"/Users/iminar/Dev/angular/modules/@angular/core/","sources":["src/metadata.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"metadata.js","sourceRoot":"","sources":["../../../../../modules/@angular/core/src/metadata.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * This indirection is needed to free up Component, etc symbols in the public API\n * to be used by the decorator versions of these annotations.\n */\n\nimport {ChangeDetectionStrategy} from '../src/change_detection/change_detection';\n\nimport {AnimationEntryMetadata} from './animation/metadata';\nimport {AttributeMetadata, ContentChildMetadata, ContentChildrenMetadata, QueryMetadata, ViewChildMetadata, ViewChildrenMetadata, ViewQueryMetadata} from './metadata/di';\nimport {ComponentMetadata, DirectiveMetadata, HostBindingMetadata, HostListenerMetadata, InputMetadata, OutputMetadata, PipeMetadata} from './metadata/directives';\nimport {ViewEncapsulation, ViewMetadata} from './metadata/view';\n\nexport {AttributeMetadata, ContentChildMetadata, ContentChildrenMetadata, QueryMetadata, ViewChildMetadata, ViewChildrenMetadata, ViewQueryMetadata} from './metadata/di';\nexport {ComponentMetadata, DirectiveMetadata, HostBindingMetadata, HostListenerMetadata, InputMetadata, OutputMetadata, PipeMetadata} from './metadata/directives';\nexport {AfterContentChecked, AfterContentInit, AfterViewChecked, AfterViewInit, DoCheck, OnChanges, OnDestroy, OnInit} from './metadata/lifecycle_hooks';\nexport {ViewEncapsulation, ViewMetadata} from './metadata/view';\n\nimport {makeDecorator, makeParamDecorator, makePropDecorator, TypeDecorator,} from './util/decorators';\nimport {Type} from '../src/facade/lang';\n\n/**\n * Interface for the {@link DirectiveMetadata} decorator function.\n *\n * See {@link DirectiveFactory}.\n */\nexport interface DirectiveDecorator extends TypeDecorator {}\n\n/**\n * Interface for the {@link ComponentMetadata} decorator function.\n *\n * See {@link ComponentFactory}.\n */\nexport interface ComponentDecorator extends TypeDecorator {\n  /**\n   * Chain {@link ViewMetadata} annotation.\n   */\n  View(obj: {\n    templateUrl?: string,\n    template?: string,\n    directives?: Array<Type|any[]>,\n    pipes?: Array<Type|any[]>,\n    renderer?: string,\n    styles?: string[],\n    styleUrls?: string[],\n    animations?: AnimationEntryMetadata[]\n  }): ViewDecorator;\n}\n\n/**\n * Interface for the {@link ViewMetadata} decorator function.\n *\n * See {@link ViewFactory}.\n */\nexport interface ViewDecorator extends TypeDecorator {\n  /**\n   * Chain {@link ViewMetadata} annotation.\n   */\n  View(obj: {\n    templateUrl?: string,\n    template?: string,\n    directives?: Array<Type|any[]>,\n    pipes?: Array<Type|any[]>,\n    renderer?: string,\n    styles?: string[],\n    styleUrls?: string[],\n    animations?: AnimationEntryMetadata[]\n  }): ViewDecorator;\n}\n\n/**\n * {@link DirectiveMetadata} factory for creating annotations, decorators or DSL.\n *\n * ### Example as TypeScript Decorator\n *\n * {@example core/ts/metadata/metadata.ts region='directive'}\n *\n * ### Example as ES5 DSL\n *\n * ```\n * var MyDirective = ng\n *   .Directive({...})\n *   .Class({\n *     constructor: function() {\n *       ...\n *     }\n *   })\n * ```\n *\n * ### Example as ES5 annotation\n *\n * ```\n * var MyDirective = function() {\n *   ...\n * };\n *\n * MyDirective.annotations = [\n *   new ng.Directive({...})\n * ]\n * ```\n */\nexport interface DirectiveMetadataFactory {\n  (obj: {\n    selector?: string,\n    inputs?: string[],\n    outputs?: string[],\n    properties?: string[],\n    events?: string[],\n    host?: {[key: string]: string},\n    providers?: any[],\n    exportAs?: string,\n    queries?: {[key: string]: any}\n  }): DirectiveDecorator;\n  new (obj: {\n    selector?: string,\n    inputs?: string[],\n    outputs?: string[],\n    properties?: string[],\n    events?: string[],\n    host?: {[key: string]: string},\n    providers?: any[],\n    exportAs?: string,\n    queries?: {[key: string]: any}\n  }): DirectiveMetadata;\n}\n\n/**\n * {@link ComponentMetadata} factory for creating annotations, decorators or DSL.\n *\n * ### Example as TypeScript Decorator\n *\n * {@example core/ts/metadata/metadata.ts region='component'}\n *\n * ### Example as ES5 DSL\n *\n * ```\n * var MyComponent = ng\n *   .Component({...})\n *   .Class({\n *     constructor: function() {\n *       ...\n *     }\n *   })\n * ```\n *\n * ### Example as ES5 annotation\n *\n * ```\n * var MyComponent = function() {\n *   ...\n * };\n *\n * MyComponent.annotations = [\n *   new ng.Component({...})\n * ]\n * ```\n */\nexport interface ComponentMetadataFactory {\n  (obj: {\n    selector?: string,\n    inputs?: string[],\n    outputs?: string[],\n    properties?: string[],\n    events?: string[],\n    host?: {[key: string]: string},\n    providers?: any[],\n    exportAs?: string,\n    moduleId?: string,\n    queries?: {[key: string]: any},\n    viewProviders?: any[],\n    changeDetection?: ChangeDetectionStrategy,\n    templateUrl?: string,\n    template?: string,\n    styleUrls?: string[],\n    styles?: string[],\n    animations?: AnimationEntryMetadata[],\n    directives?: Array<Type|any[]>,\n    pipes?: Array<Type|any[]>,\n    encapsulation?: ViewEncapsulation\n  }): ComponentDecorator;\n  new (obj: {\n    selector?: string,\n    inputs?: string[],\n    outputs?: string[],\n    properties?: string[],\n    events?: string[],\n    host?: {[key: string]: string},\n    providers?: any[],\n    exportAs?: string,\n    moduleId?: string,\n    queries?: {[key: string]: any},\n    viewProviders?: any[],\n    changeDetection?: ChangeDetectionStrategy,\n    templateUrl?: string,\n    template?: string,\n    styleUrls?: string[],\n    styles?: string[],\n    animations?: AnimationEntryMetadata[],\n    directives?: Array<Type|any[]>,\n    pipes?: Array<Type|any[]>,\n    encapsulation?: ViewEncapsulation\n  }): ComponentMetadata;\n}\n\n/**\n * {@link ViewMetadata} factory for creating annotations, decorators or DSL.\n *\n * ### Example as TypeScript Decorator\n *\n * ```\n * import {Component, View} from '@angular/core';\n *\n * @Component({...})\n * class MyComponent {\n *   constructor() {\n *     ...\n *   }\n * }\n * ```\n *\n * ### Example as ES5 DSL\n *\n * ```\n * var MyComponent = ng\n *   .Component({...})\n *   .View({...})\n *   .Class({\n *     constructor: function() {\n *       ...\n *     }\n *   })\n * ```\n *\n * ### Example as ES5 annotation\n *\n * ```\n * var MyComponent = function() {\n *   ...\n * };\n *\n * MyComponent.annotations = [\n *   new ng.Component({...}),\n *   new ng.View({...})\n * ]\n * ```\n */\nexport interface ViewMetadataFactory {\n  (obj: {\n    templateUrl?: string,\n    template?: string,\n    directives?: Array<Type|any[]>,\n    pipes?: Array<Type|any[]>,\n    encapsulation?: ViewEncapsulation,\n    styles?: string[],\n    styleUrls?: string[],\n    animations?: AnimationEntryMetadata[]\n  }): ViewDecorator;\n  new (obj: {\n    templateUrl?: string,\n    template?: string,\n    directives?: Array<Type|any[]>,\n    pipes?: Array<Type|any[]>,\n    encapsulation?: ViewEncapsulation,\n    styles?: string[],\n    styleUrls?: string[],\n    animations?: AnimationEntryMetadata[]\n  }): ViewMetadata;\n}\n\n/**\n * {@link AttributeMetadata} factory for creating annotations, decorators or DSL.\n *\n * ### Example as TypeScript Decorator\n *\n * {@example core/ts/metadata/metadata.ts region='attributeFactory'}\n *\n * ### Example as ES5 DSL\n *\n * ```\n * var MyComponent = ng\n *   .Component({...})\n *   .Class({\n *     constructor: [new ng.Attribute('title'), function(title) {\n *       ...\n *     }]\n *   })\n * ```\n *\n * ### Example as ES5 annotation\n *\n * ```\n * var MyComponent = function(title) {\n *   ...\n * };\n *\n * MyComponent.annotations = [\n *   new ng.Component({...})\n * ]\n * MyComponent.parameters = [\n *   [new ng.Attribute('title')]\n * ]\n * ```\n */\nexport interface AttributeMetadataFactory {\n  (name: string): TypeDecorator;\n  new (name: string): AttributeMetadata;\n}\n\n/**\n * {@link QueryMetadata} factory for creating annotations, decorators or DSL.\n *\n * ### Example as TypeScript Decorator\n *\n * ```\n * import {Query, QueryList, Component} from '@angular/core';\n *\n * @Component({...})\n * class MyComponent {\n *   constructor(@Query(SomeType) queryList: QueryList<SomeType>) {\n *     ...\n *   }\n * }\n * ```\n *\n * ### Example as ES5 DSL\n *\n * ```\n * var MyComponent = ng\n *   .Component({...})\n *   .Class({\n *     constructor: [new ng.Query(SomeType), function(queryList) {\n *       ...\n *     }]\n *   })\n * ```\n *\n * ### Example as ES5 annotation\n *\n * ```\n * var MyComponent = function(queryList) {\n *   ...\n * };\n *\n * MyComponent.annotations = [\n *   new ng.Component({...})\n * ]\n * MyComponent.parameters = [\n *   [new ng.Query(SomeType)]\n * ]\n * ```\n * @deprecated\n */\nexport interface QueryMetadataFactory {\n  (selector: Type|string,\n   {descendants, read}?: {descendants?: boolean, read?: any}): ParameterDecorator;\n  new (selector: Type|string, {descendants, read}?: {descendants?: boolean, read?: any}):\n      QueryMetadata;\n}\n\n/**\n * Factory for {@link ContentChildren}.\n * @stable\n */\nexport interface ContentChildrenMetadataFactory {\n  (selector: Type|string, {descendants, read}?: {descendants?: boolean, read?: any}): any;\n  new (selector: Type|string, {descendants, read}?: {descendants?: boolean, read?: any}):\n      ContentChildrenMetadata;\n}\n\n/**\n * Factory for {@link ContentChild}.\n * @stable\n */\nexport interface ContentChildMetadataFactory {\n  (selector: Type|string, {read}?: {read?: any}): any;\n  new (selector: Type|string, {read}?: {read?: any}): ContentChildMetadataFactory;\n}\n\n/**\n * Factory for {@link ViewChildren}.\n * @stable\n */\nexport interface ViewChildrenMetadataFactory {\n  (selector: Type|string, {read}?: {read?: any}): any;\n  new (selector: Type|string, {read}?: {read?: any}): ViewChildrenMetadata;\n}\n\n/**\n * Factory for {@link ViewChild}.\n * @stable\n */\nexport interface ViewChildMetadataFactory {\n  (selector: Type|string, {read}?: {read?: any}): any;\n  new (selector: Type|string, {read}?: {read?: any}): ViewChildMetadataFactory;\n}\n\n\n/**\n * {@link PipeMetadata} factory for creating decorators.\n *\n * ### Example\n *\n * {@example core/ts/metadata/metadata.ts region='pipe'}\n * @stable\n */\nexport interface PipeMetadataFactory {\n  (obj: {name: string, pure?: boolean}): any;\n  new (obj: {name: string, pure?: boolean}): any;\n}\n\n/**\n * {@link InputMetadata} factory for creating decorators.\n *\n * See {@link InputMetadata}.\n * @stable\n */\nexport interface InputMetadataFactory {\n  (bindingPropertyName?: string): any;\n  new (bindingPropertyName?: string): any;\n}\n\n/**\n * {@link OutputMetadata} factory for creating decorators.\n *\n * See {@link OutputMetadata}.\n * @stable\n */\nexport interface OutputMetadataFactory {\n  (bindingPropertyName?: string): any;\n  new (bindingPropertyName?: string): any;\n}\n\n/**\n * {@link HostBindingMetadata} factory function.\n * @stable\n */\nexport interface HostBindingMetadataFactory {\n  (hostPropertyName?: string): any;\n  new (hostPropertyName?: string): any;\n}\n\n/**\n * {@link HostListenerMetadata} factory function.\n * @stable\n */\nexport interface HostListenerMetadataFactory {\n  (eventName: string, args?: string[]): any;\n  new (eventName: string, args?: string[]): any;\n}\n\n// TODO(alexeagle): remove the duplication of this doc. It is copied from ComponentMetadata.\n/**\n * Declare reusable UI building blocks for an application.\n *\n * Each Angular component requires a single `@Component` annotation. The `@Component`\n * annotation specifies when a component is instantiated, and which properties and hostListeners it\n * binds to.\n *\n * When a component is instantiated, Angular\n * - creates a shadow DOM for the component.\n * - loads the selected template into the shadow DOM.\n * - creates all the injectable objects configured with `providers` and `viewProviders`.\n *\n * All template expressions and statements are then evaluated against the component instance.\n *\n * ## Lifecycle hooks\n *\n * When the component class implements some {@link ../../guide/lifecycle-hooks.html} the callbacks\n * are called by the change detection at defined points in time during the life of the component.\n *\n * ### Example\n *\n * {@example core/ts/metadata/metadata.ts region='component'}\n * @stable\n */\nexport var Component: ComponentMetadataFactory =\n    <ComponentMetadataFactory>makeDecorator(ComponentMetadata, (fn: any) => fn.View = View);\n\n// TODO(alexeagle): remove the duplication of this doc. It is copied from DirectiveMetadata.\n/**\n * Directives allow you to attach behavior to elements in the DOM.\n *\n * {@link DirectiveMetadata}s with an embedded view are called {@link ComponentMetadata}s.\n *\n * A directive consists of a single directive annotation and a controller class. When the\n * directive's `selector` matches\n * elements in the DOM, the following steps occur:\n *\n * 1. For each directive, the `ElementInjector` attempts to resolve the directive's constructor\n * arguments.\n * 2. Angular instantiates directives for each matched element using `ElementInjector` in a\n * depth-first order,\n *    as declared in the HTML.\n *\n * ## Understanding How Injection Works\n *\n * There are three stages of injection resolution.\n * - *Pre-existing Injectors*:\n *   - The terminal {@link Injector} cannot resolve dependencies. It either throws an error or, if\n * the dependency was\n *     specified as `@Optional`, returns `null`.\n *   - The platform injector resolves browser singleton resources, such as: cookies, title,\n * location, and others.\n * - *Component Injectors*: Each component instance has its own {@link Injector}, and they follow\n * the same parent-child hierarchy\n *     as the component instances in the DOM.\n * - *Element Injectors*: Each component instance has a Shadow DOM. Within the Shadow DOM each\n * element has an `ElementInjector`\n *     which follow the same parent-child hierarchy as the DOM elements themselves.\n *\n * When a template is instantiated, it also must instantiate the corresponding directives in a\n * depth-first order. The\n * current `ElementInjector` resolves the constructor dependencies for each directive.\n *\n * Angular then resolves dependencies as follows, according to the order in which they appear in the\n * {@link ViewMetadata}:\n *\n * 1. Dependencies on the current element\n * 2. Dependencies on element injectors and their parents until it encounters a Shadow DOM boundary\n * 3. Dependencies on component injectors and their parents until it encounters the root component\n * 4. Dependencies on pre-existing injectors\n *\n *\n * The `ElementInjector` can inject other directives, element-specific special objects, or it can\n * delegate to the parent\n * injector.\n *\n * To inject other directives, declare the constructor parameter as:\n * - `directive:DirectiveType`: a directive on the current element only\n * - `@Host() directive:DirectiveType`: any directive that matches the type between the current\n * element and the\n *    Shadow DOM root.\n * - `@Query(DirectiveType) query:QueryList<DirectiveType>`: A live collection of direct child\n * directives.\n * - `@QueryDescendants(DirectiveType) query:QueryList<DirectiveType>`: A live collection of any\n * child directives.\n *\n * To inject element-specific special objects, declare the constructor parameter as:\n * - `element: ElementRef` to obtain a reference to logical element in the view.\n * - `viewContainer: ViewContainerRef` to control child template instantiation, for\n * {@link DirectiveMetadata} directives only\n * - `bindingPropagation: BindingPropagation` to control change detection in a more granular way.\n *\n * ### Example\n *\n * The following example demonstrates how dependency injection resolves constructor arguments in\n * practice.\n *\n *\n * Assume this HTML template:\n *\n * ```\n * <div dependency=\"1\">\n *   <div dependency=\"2\">\n *     <div dependency=\"3\" my-directive>\n *       <div dependency=\"4\">\n *         <div dependency=\"5\"></div>\n *       </div>\n *       <div dependency=\"6\"></div>\n *     </div>\n *   </div>\n * </div>\n * ```\n *\n * With the following `dependency` decorator and `SomeService` injectable class.\n *\n * ```\n * @Injectable()\n * class SomeService {\n * }\n *\n * @Directive({\n *   selector: '[dependency]',\n *   inputs: [\n *     'id: dependency'\n *   ]\n * })\n * class Dependency {\n *   id:string;\n * }\n * ```\n *\n * Let's step through the different ways in which `MyDirective` could be declared...\n *\n *\n * ### No injection\n *\n * Here the constructor is declared with no arguments, therefore nothing is injected into\n * `MyDirective`.\n *\n * ```\n * @Directive({ selector: '[my-directive]' })\n * class MyDirective {\n *   constructor() {\n *   }\n * }\n * ```\n *\n * This directive would be instantiated with no dependencies.\n *\n *\n * ### Component-level injection\n *\n * Directives can inject any injectable instance from the closest component injector or any of its\n * parents.\n *\n * Here, the constructor declares a parameter, `someService`, and injects the `SomeService` type\n * from the parent\n * component's injector.\n * ```\n * @Directive({ selector: '[my-directive]' })\n * class MyDirective {\n *   constructor(someService: SomeService) {\n *   }\n * }\n * ```\n *\n * This directive would be instantiated with a dependency on `SomeService`.\n *\n *\n * ### Injecting a directive from the current element\n *\n * Directives can inject other directives declared on the current element.\n *\n * ```\n * @Directive({ selector: '[my-directive]' })\n * class MyDirective {\n *   constructor(dependency: Dependency) {\n *     expect(dependency.id).toEqual(3);\n *   }\n * }\n * ```\n * This directive would be instantiated with `Dependency` declared at the same element, in this case\n * `dependency=\"3\"`.\n *\n * ### Injecting a directive from any ancestor elements\n *\n * Directives can inject other directives declared on any ancestor element (in the current Shadow\n * DOM), i.e. on the current element, the\n * parent element, or its parents.\n * ```\n * @Directive({ selector: '[my-directive]' })\n * class MyDirective {\n *   constructor(@Host() dependency: Dependency) {\n *     expect(dependency.id).toEqual(2);\n *   }\n * }\n * ```\n *\n * `@Host` checks the current element, the parent, as well as its parents recursively. If\n * `dependency=\"2\"` didn't\n * exist on the direct parent, this injection would\n * have returned\n * `dependency=\"1\"`.\n *\n *\n * ### Injecting a live collection of direct child directives\n *\n *\n * A directive can also query for other child directives. Since parent directives are instantiated\n * before child directives, a directive can't simply inject the list of child directives. Instead,\n * the directive injects a {@link QueryList}, which updates its contents as children are added,\n * removed, or moved by a directive that uses a {@link ViewContainerRef} such as a `ngFor`, an\n * `ngIf`, or an `ngSwitch`.\n *\n * ```\n * @Directive({ selector: '[my-directive]' })\n * class MyDirective {\n *   constructor(@Query(Dependency) dependencies:QueryList<Dependency>) {\n *   }\n * }\n * ```\n *\n * This directive would be instantiated with a {@link QueryList} which contains `Dependency` 4 and\n * 6. Here, `Dependency` 5 would not be included, because it is not a direct child.\n *\n * ### Injecting a live collection of descendant directives\n *\n * By passing the descendant flag to `@Query` above, we can include the children of the child\n * elements.\n *\n * ```\n * @Directive({ selector: '[my-directive]' })\n * class MyDirective {\n *   constructor(@Query(Dependency, {descendants: true}) dependencies:QueryList<Dependency>) {\n *   }\n * }\n * ```\n *\n * This directive would be instantiated with a Query which would contain `Dependency` 4, 5 and 6.\n *\n * ### Optional injection\n *\n * The normal behavior of directives is to return an error when a specified dependency cannot be\n * resolved. If you\n * would like to inject `null` on unresolved dependency instead, you can annotate that dependency\n * with `@Optional()`.\n * This explicitly permits the author of a template to treat some of the surrounding directives as\n * optional.\n *\n * ```\n * @Directive({ selector: '[my-directive]' })\n * class MyDirective {\n *   constructor(@Optional() dependency:Dependency) {\n *   }\n * }\n * ```\n *\n * This directive would be instantiated with a `Dependency` directive found on the current element.\n * If none can be\n * found, the injector supplies `null` instead of throwing an error.\n *\n * ### Example\n *\n * Here we use a decorator directive to simply define basic tool-tip behavior.\n *\n * ```\n * @Directive({\n *   selector: '[tooltip]',\n *   inputs: [\n *     'text: tooltip'\n *   ],\n *   host: {\n *     '(mouseenter)': 'onMouseEnter()',\n *     '(mouseleave)': 'onMouseLeave()'\n *   }\n * })\n * class Tooltip{\n *   text:string;\n *   overlay:Overlay; // NOT YET IMPLEMENTED\n *   overlayManager:OverlayManager; // NOT YET IMPLEMENTED\n *\n *   constructor(overlayManager:OverlayManager) {\n *     this.overlay = overlay;\n *   }\n *\n *   onMouseEnter() {\n *     // exact signature to be determined\n *     this.overlay = this.overlayManager.open(text, ...);\n *   }\n *\n *   onMouseLeave() {\n *     this.overlay.close();\n *     this.overlay = null;\n *   }\n * }\n * ```\n * In our HTML template, we can then add this behavior to a `<div>` or any other element with the\n * `tooltip` selector,\n * like so:\n *\n * ```\n * <div tooltip=\"some text here\"></div>\n * ```\n *\n * Directives can also control the instantiation, destruction, and positioning of inline template\n * elements:\n *\n * A directive uses a {@link ViewContainerRef} to instantiate, insert, move, and destroy views at\n * runtime.\n * The {@link ViewContainerRef} is created as a result of `<template>` element, and represents a\n * location in the current view\n * where these actions are performed.\n *\n * Views are always created as children of the current {@link ViewMetadata}, and as siblings of the\n * `<template>` element. Thus a\n * directive in a child view cannot inject the directive that created it.\n *\n * Since directives that create views via ViewContainers are common in Angular, and using the full\n * `<template>` element syntax is wordy, Angular\n * also supports a shorthand notation: `<li *foo=\"bar\">` and `<li template=\"foo: bar\">` are\n * equivalent.\n *\n * Thus,\n *\n * ```\n * <ul>\n *   <li *foo=\"bar\" title=\"text\"></li>\n * </ul>\n * ```\n *\n * Expands in use to:\n *\n * ```\n * <ul>\n *   <template [foo]=\"bar\">\n *     <li title=\"text\"></li>\n *   </template>\n * </ul>\n * ```\n *\n * Notice that although the shorthand places `*foo=\"bar\"` within the `<li>` element, the binding for\n * the directive\n * controller is correctly instantiated on the `<template>` element rather than the `<li>` element.\n *\n * ## Lifecycle hooks\n *\n * When the directive class implements some {@link ../../guide/lifecycle-hooks.html} the callbacks\n * are called by the change detection at defined points in time during the life of the directive.\n *\n * ### Example\n *\n * Let's suppose we want to implement the `unless` behavior, to conditionally include a template.\n *\n * Here is a simple directive that triggers on an `unless` selector:\n *\n * ```\n * @Directive({\n *   selector: '[unless]',\n *   inputs: ['unless']\n * })\n * export class Unless {\n *   viewContainer: ViewContainerRef;\n *   templateRef: TemplateRef;\n *   prevCondition: boolean;\n *\n *   constructor(viewContainer: ViewContainerRef, templateRef: TemplateRef) {\n *     this.viewContainer = viewContainer;\n *     this.templateRef = templateRef;\n *     this.prevCondition = null;\n *   }\n *\n *   set unless(newCondition) {\n *     if (newCondition && (isBlank(this.prevCondition) || !this.prevCondition)) {\n *       this.prevCondition = true;\n *       this.viewContainer.clear();\n *     } else if (!newCondition && (isBlank(this.prevCondition) || this.prevCondition)) {\n *       this.prevCondition = false;\n *       this.viewContainer.create(this.templateRef);\n *     }\n *   }\n * }\n * ```\n *\n * We can then use this `unless` selector in a template:\n * ```\n * <ul>\n *   <li *unless=\"expr\"></li>\n * </ul>\n * ```\n *\n * Once the directive instantiates the child view, the shorthand notation for the template expands\n * and the result is:\n *\n * ```\n * <ul>\n *   <template [unless]=\"exp\">\n *     <li></li>\n *   </template>\n *   <li></li>\n * </ul>\n * ```\n *\n * Note also that although the `<li></li>` template still exists inside the `<template></template>`,\n * the instantiated\n * view occurs on the second `<li></li>` which is a sibling to the `<template>` element.\n * @stable\n */\nexport var Directive: DirectiveMetadataFactory =\n    <DirectiveMetadataFactory>makeDecorator(DirectiveMetadata);\n\n// TODO(alexeagle): remove the duplication of this doc. It is copied from ViewMetadata.\n/**\n * Metadata properties available for configuring Views.\n *\n * Each Angular component requires a single `@Component` and at least one `@View` annotation. The\n * `@View` annotation specifies the HTML template to use, and lists the directives that are active\n * within the template.\n *\n * When a component is instantiated, the template is loaded into the component's shadow root, and\n * the expressions and statements in the template are evaluated against the component.\n *\n * For details on the `@Component` annotation, see {@link ComponentMetadata}.\n *\n * ### Example\n *\n * ```\n * @Component({\n *   selector: 'greet',\n *   template: 'Hello {{name}}!',\n *   directives: [GreetUser, Bold]\n * })\n * class Greet {\n *   name: string;\n *\n *   constructor() {\n *     this.name = 'World';\n *   }\n * }\n * ```\n * @deprecated\n */\nvar View: ViewMetadataFactory =\n    <ViewMetadataFactory>makeDecorator(ViewMetadata, (fn: any) => fn.View = View);\n\n/**\n * Specifies that a constant attribute value should be injected.\n *\n * The directive can inject constant string literals of host element attributes.\n *\n * ### Example\n *\n * Suppose we have an `<input>` element and want to know its `type`.\n *\n * ```html\n * <input type=\"text\">\n * ```\n *\n * A decorator can inject string literal `text` like so:\n *\n * {@example core/ts/metadata/metadata.ts region='attributeMetadata'}\n * @stable\n */\nexport var Attribute: AttributeMetadataFactory = makeParamDecorator(AttributeMetadata);\n\n// TODO(alexeagle): remove the duplication of this doc. It is copied from QueryMetadata.\n/**\n * Declares an injectable parameter to be a live list of directives or variable\n * bindings from the content children of a directive.\n *\n * ### Example ([live demo](http://plnkr.co/edit/lY9m8HLy7z06vDoUaSN2?p=preview))\n *\n * Assume that `<tabs>` component would like to get a list its children `<pane>`\n * components as shown in this example:\n *\n * ```html\n * <tabs>\n *   <pane title=\"Overview\">...</pane>\n *   <pane *ngFor=\"let o of objects\" [title]=\"o.title\">{{o.text}}</pane>\n * </tabs>\n * ```\n *\n * The preferred solution is to query for `Pane` directives using this decorator.\n *\n * ```javascript\n * @Component({\n *   selector: 'pane',\n *   inputs: ['title']\n * })\n * class Pane {\n *   title:string;\n * }\n *\n * @Component({\n *  selector: 'tabs',\n *  template: `\n *    <ul>\n *      <li *ngFor=\"let pane of panes\">{{pane.title}}</li>\n *    </ul>\n *    <ng-content></ng-content>\n *  `\n * })\n * class Tabs {\n *   panes: QueryList<Pane>;\n *   constructor(@Query(Pane) panes:QueryList<Pane>) {\n *     this.panes = panes;\n *   }\n * }\n * ```\n *\n * A query can look for variable bindings by passing in a string with desired binding symbol.\n *\n * ### Example ([live demo](http://plnkr.co/edit/sT2j25cH1dURAyBRCKx1?p=preview))\n * ```html\n * <seeker>\n *   <div #findme>...</div>\n * </seeker>\n *\n * @Component({ selector: 'seeker' })\n * class seeker {\n *   constructor(@Query('findme') elList: QueryList<ElementRef>) {...}\n * }\n * ```\n *\n * In this case the object that is injected depend on the type of the variable\n * binding. It can be an ElementRef, a directive or a component.\n *\n * Passing in a comma separated list of variable bindings will query for all of them.\n *\n * ```html\n * <seeker>\n *   <div #findMe>...</div>\n *   <div #findMeToo>...</div>\n * </seeker>\n *\n *  @Component({\n *   selector: 'seeker'\n * })\n * class Seeker {\n *   constructor(@Query('findMe, findMeToo') elList: QueryList<ElementRef>) {...}\n * }\n * ```\n *\n * Configure whether query looks for direct children or all descendants\n * of the querying element, by using the `descendants` parameter.\n * It is set to `false` by default.\n *\n * ### Example ([live demo](http://plnkr.co/edit/wtGeB977bv7qvA5FTYl9?p=preview))\n * ```html\n * <container #first>\n *   <item>a</item>\n *   <item>b</item>\n *   <container #second>\n *     <item>c</item>\n *   </container>\n * </container>\n * ```\n *\n * When querying for items, the first container will see only `a` and `b` by default,\n * but with `Query(TextDirective, {descendants: true})` it will see `c` too.\n *\n * The queried directives are kept in a depth-first pre-order with respect to their\n * positions in the DOM.\n *\n * Query does not look deep into any subcomponent views.\n *\n * Query is updated as part of the change-detection cycle. Since change detection\n * happens after construction of a directive, QueryList will always be empty when observed in the\n * constructor.\n *\n * The injected object is an unmodifiable live list.\n * See {@link QueryList} for more details.\n * @deprecated\n */\nexport var Query: QueryMetadataFactory = makeParamDecorator(QueryMetadata);\n\n// TODO(alexeagle): remove the duplication of this doc. It is copied from ContentChildrenMetadata.\n/**\n * Configures a content query.\n *\n * Content queries are set before the `ngAfterContentInit` callback is called.\n *\n * ### Example\n *\n * ```\n * @Directive({\n *   selector: 'someDir'\n * })\n * class SomeDir {\n *   @ContentChildren(ChildDirective) contentChildren: QueryList<ChildDirective>;\n *\n *   ngAfterContentInit() {\n *     // contentChildren is set\n *   }\n * }\n * ```\n * @stable\n */\nexport var ContentChildren: ContentChildrenMetadataFactory =\n    makePropDecorator(ContentChildrenMetadata);\n\n// TODO(alexeagle): remove the duplication of this doc. It is copied from ContentChildMetadata.\n/**\n * Configures a content query.\n *\n * Content queries are set before the `ngAfterContentInit` callback is called.\n *\n * ### Example\n *\n * ```\n * @Directive({\n *   selector: 'someDir'\n * })\n * class SomeDir {\n *   @ContentChild(ChildDirective) contentChild;\n *   @ContentChild('container_ref') containerChild\n *\n *   ngAfterContentInit() {\n *     // contentChild is set\n *     // containerChild is set\n *   }\n * }\n * ```\n *\n * ```html\n * <container #container_ref>\n *   <item>a</item>\n *   <item>b</item>\n * </container>\n * ```\n * @stable\n */\nexport var ContentChild: ContentChildMetadataFactory = makePropDecorator(ContentChildMetadata);\n\n// TODO(alexeagle): remove the duplication of this doc. It is copied from ViewChildrenMetadata.\n/**\n * Declares a list of child element references.\n *\n * Angular automatically updates the list when the DOM is updated.\n *\n * `ViewChildren` takes a argument to select elements.\n *\n * - If the argument is a type, directives or components with the type will be bound.\n *\n * - If the argument is a string, the string is interpreted as a list of comma-separated selectors.\n * For each selector, an element containing the matching template variable (e.g. `#child`) will be\n * bound.\n *\n * View children are set before the `ngAfterViewInit` callback is called.\n *\n * ### Example\n *\n * With type selector:\n *\n * ```\n * @Component({\n *   selector: 'child-cmp',\n *   template: '<p>child</p>'\n * })\n * class ChildCmp {\n *   doSomething() {}\n * }\n *\n * @Component({\n *   selector: 'some-cmp',\n *   template: `\n *     <child-cmp></child-cmp>\n *     <child-cmp></child-cmp>\n *     <child-cmp></child-cmp>\n *   `,\n *   directives: [ChildCmp]\n * })\n * class SomeCmp {\n *   @ViewChildren(ChildCmp) children:QueryList<ChildCmp>;\n *\n *   ngAfterViewInit() {\n *     // children are set\n *     this.children.toArray().forEach((child)=>child.doSomething());\n *   }\n * }\n * ```\n *\n * With string selector:\n *\n * ```\n * @Component({\n *   selector: 'child-cmp',\n *   template: '<p>child</p>'\n * })\n * class ChildCmp {\n *   doSomething() {}\n * }\n *\n * @Component({\n *   selector: 'some-cmp',\n *   template: `\n *     <child-cmp #child1></child-cmp>\n *     <child-cmp #child2></child-cmp>\n *     <child-cmp #child3></child-cmp>\n *   `,\n *   directives: [ChildCmp]\n * })\n * class SomeCmp {\n *   @ViewChildren('child1,child2,child3') children:QueryList<ChildCmp>;\n *\n *   ngAfterViewInit() {\n *     // children are set\n *     this.children.toArray().forEach((child)=>child.doSomething());\n *   }\n * }\n * ```\n *\n * See also: [ViewChildrenMetadata]\n * @stable\n */\nexport var ViewChildren: ViewChildrenMetadataFactory = makePropDecorator(ViewChildrenMetadata);\n\n// TODO(alexeagle): remove the duplication of this doc. It is copied from ViewChildMetadata.\n/**\n * Declares a reference to a child element.\n *\n * `ViewChildren` takes a argument to select elements.\n *\n * - If the argument is a type, a directive or a component with the type will be bound.\n *\n * - If the argument is a string, the string is interpreted as a selector. An element containing the\n * matching template variable (e.g. `#child`) will be bound.\n *\n * In either case, `@ViewChild()` assigns the first (looking from above) element if there are\n * multiple matches.\n *\n * View child is set before the `ngAfterViewInit` callback is called.\n *\n * ### Example\n *\n * With type selector:\n *\n * ```\n * @Component({\n *   selector: 'child-cmp',\n *   template: '<p>child</p>'\n * })\n * class ChildCmp {\n *   doSomething() {}\n * }\n *\n * @Component({\n *   selector: 'some-cmp',\n *   template: '<child-cmp></child-cmp>',\n *   directives: [ChildCmp]\n * })\n * class SomeCmp {\n *   @ViewChild(ChildCmp) child:ChildCmp;\n *\n *   ngAfterViewInit() {\n *     // child is set\n *     this.child.doSomething();\n *   }\n * }\n * ```\n *\n * With string selector:\n *\n * ```\n * @Component({\n *   selector: 'child-cmp',\n *   template: '<p>child</p>'\n * })\n * class ChildCmp {\n *   doSomething() {}\n * }\n *\n * @Component({\n *   selector: 'some-cmp',\n *   template: '<child-cmp #child></child-cmp>',\n *   directives: [ChildCmp]\n * })\n * class SomeCmp {\n *   @ViewChild('child') child:ChildCmp;\n *\n *   ngAfterViewInit() {\n *     // child is set\n *     this.child.doSomething();\n *   }\n * }\n * ```\n * See also: [ViewChildMetadata]\n * @stable\n */\nexport var ViewChild: ViewChildMetadataFactory = makePropDecorator(ViewChildMetadata);\n\n// TODO(alexeagle): remove the duplication of this doc. It is copied from ViewQueryMetadata.\n/**\n * Similar to {@link QueryMetadata}, but querying the component view, instead of\n * the content children.\n *\n * ### Example ([live demo](http://plnkr.co/edit/eNsFHDf7YjyM6IzKxM1j?p=preview))\n *\n * ```javascript\n * @Component({\n *   ...,\n *   template: `\n *     <item> a </item>\n *     <item> b </item>\n *     <item> c </item>\n *   `\n * })\n * class MyComponent {\n *   shown: boolean;\n *\n *   constructor(private @Query(Item) items:QueryList<Item>) {\n *     items.changes.subscribe(() => console.log(items.length));\n *   }\n * }\n * ```\n *\n * Supports the same querying parameters as {@link QueryMetadata}, except\n * `descendants`. This always queries the whole view.\n *\n * As `shown` is flipped between true and false, items will contain zero of one\n * items.\n *\n * Specifies that a {@link QueryList} should be injected.\n *\n * The injected object is an iterable and observable live list.\n * See {@link QueryList} for more details.\n * @deprecated\n */\nexport var ViewQuery: QueryMetadataFactory = makeParamDecorator(ViewQueryMetadata);\n\n// TODO(alexeagle): remove the duplication of this doc. It is copied from PipeMetadata.\n/**\n * Declare reusable pipe function.\n *\n * ### Example\n *\n * {@example core/ts/metadata/metadata.ts region='pipe'}\n * @stable\n */\nexport var Pipe: PipeMetadataFactory = <PipeMetadataFactory>makeDecorator(PipeMetadata);\n\n// TODO(alexeagle): remove the duplication of this doc. It is copied from InputMetadata.\n/**\n * Declares a data-bound input property.\n *\n * Angular automatically updates data-bound properties during change detection.\n *\n * `InputMetadata` takes an optional parameter that specifies the name\n * used when instantiating a component in the template. When not provided,\n * the name of the decorated property is used.\n *\n * ### Example\n *\n * The following example creates a component with two input properties.\n *\n * ```typescript\n * @Component({\n *   selector: 'bank-account',\n *   template: `\n *     Bank Name: {{bankName}}\n *     Account Id: {{id}}\n *   `\n * })\n * class BankAccount {\n *   @Input() bankName: string;\n *   @Input('account-id') id: string;\n *\n *   // this property is not bound, and won't be automatically updated by Angular\n *   normalizedBankName: string;\n * }\n *\n * @Component({\n *   selector: 'app',\n *   template: `\n *     <bank-account bank-name=\"RBC\" account-id=\"4747\"></bank-account>\n *   `,\n *   directives: [BankAccount]\n * })\n * class App {}\n *\n * bootstrap(App);\n * ```\n * @stable\n */\nexport var Input: InputMetadataFactory = makePropDecorator(InputMetadata);\n\n// TODO(alexeagle): remove the duplication of this doc. It is copied from OutputMetadata.\n/**\n * Declares an event-bound output property.\n *\n * When an output property emits an event, an event handler attached to that event\n * the template is invoked.\n *\n * `OutputMetadata` takes an optional parameter that specifies the name\n * used when instantiating a component in the template. When not provided,\n * the name of the decorated property is used.\n *\n * ### Example\n *\n * ```typescript\n * @Directive({\n *   selector: 'interval-dir',\n * })\n * class IntervalDir {\n *   @Output() everySecond = new EventEmitter();\n *   @Output('everyFiveSeconds') five5Secs = new EventEmitter();\n *\n *   constructor() {\n *     setInterval(() => this.everySecond.emit(\"event\"), 1000);\n *     setInterval(() => this.five5Secs.emit(\"event\"), 5000);\n *   }\n * }\n *\n * @Component({\n *   selector: 'app',\n *   template: `\n *     <interval-dir (everySecond)=\"everySecond()\" (everyFiveSeconds)=\"everyFiveSeconds()\">\n *     </interval-dir>\n *   `,\n *   directives: [IntervalDir]\n * })\n * class App {\n *   everySecond() { console.log('second'); }\n *   everyFiveSeconds() { console.log('five seconds'); }\n * }\n * bootstrap(App);\n * ```\n * @stable\n */\nexport var Output: OutputMetadataFactory = makePropDecorator(OutputMetadata);\n\n// TODO(alexeagle): remove the duplication of this doc. It is copied from HostBindingMetadata.\n/**\n * Declares a host property binding.\n *\n * Angular automatically checks host property bindings during change detection.\n * If a binding changes, it will update the host element of the directive.\n *\n * `HostBindingMetadata` takes an optional parameter that specifies the property\n * name of the host element that will be updated. When not provided,\n * the class property name is used.\n *\n * ### Example\n *\n * The following example creates a directive that sets the `valid` and `invalid` classes\n * on the DOM element that has ngModel directive on it.\n *\n * ```typescript\n * @Directive({selector: '[ngModel]'})\n * class NgModelStatus {\n *   constructor(public control:NgModel) {}\n *   @HostBinding('class.valid') get valid() { return this.control.valid; }\n *   @HostBinding('class.invalid') get invalid() { return this.control.invalid; }\n * }\n *\n * @Component({\n *   selector: 'app',\n *   template: `<input [(ngModel)]=\"prop\">`,\n *   directives: [FORM_DIRECTIVES, NgModelStatus]\n * })\n * class App {\n *   prop;\n * }\n *\n * bootstrap(App);\n * ```\n * @stable\n */\nexport var HostBinding: HostBindingMetadataFactory = makePropDecorator(HostBindingMetadata);\n\n// TODO(alexeagle): remove the duplication of this doc. It is copied from HostListenerMetadata.\n/**\n * Declares a host listener.\n *\n * Angular will invoke the decorated method when the host element emits the specified event.\n *\n * If the decorated method returns `false`, then `preventDefault` is applied on the DOM\n * event.\n *\n * ### Example\n *\n * The following example declares a directive that attaches a click listener to the button and\n * counts clicks.\n *\n * ```typescript\n * @Directive({selector: 'button[counting]'})\n * class CountClicks {\n *   numberOfClicks = 0;\n *\n *   @HostListener('click', ['$event.target'])\n *   onClick(btn) {\n *     console.log(\"button\", btn, \"number of clicks:\", this.numberOfClicks++);\n *   }\n * }\n *\n * @Component({\n *   selector: 'app',\n *   template: `<button counting>Increment</button>`,\n *   directives: [CountClicks]\n * })\n * class App {}\n *\n * bootstrap(App);\n * ```\n * @stable\n */\nexport var HostListener: HostListenerMetadataFactory = makePropDecorator(HostListenerMetadata);\n\ninterface DecoratorInvocation {\n  type: Function;\n  args?: any[];\n}\n"]}

package/esm/src/metadata.metadata.json

@@ -1 +1 @@
-{"__symbolic":"module","metadata":{"Directive":{"__symbolic":"call","expression":{"__symbolic":"reference","name":"makeDecorator","module":"./util/decorators"},"arguments":[{"__symbolic":"reference","name":"DirectiveMetadata","module":"./metadata/directives"}]},"Attribute":{"__symbolic":"call","expression":{"__symbolic":"reference","name":"makeParamDecorator","module":"./util/decorators"},"arguments":[{"__symbolic":"reference","name":"AttributeMetadata","module":"./metadata/di"}]},"Query":{"__symbolic":"call","expression":{"__symbolic":"reference","name":"makeParamDecorator","module":"./util/decorators"},"arguments":[{"__symbolic":"reference","name":"QueryMetadata","module":"./metadata/di"}]},"ContentChildren":{"__symbolic":"call","expression":{"__symbolic":"reference","name":"makePropDecorator","module":"./util/decorators"},"arguments":[{"__symbolic":"reference","name":"ContentChildrenMetadata","module":"./metadata/di"}]},"ContentChild":{"__symbolic":"call","expression":{"__symbolic":"reference","name":"makePropDecorator","module":"./util/decorators"},"arguments":[{"__symbolic":"reference","name":"ContentChildMetadata","module":"./metadata/di"}]},"ViewChildren":{"__symbolic":"call","expression":{"__symbolic":"reference","name":"makePropDecorator","module":"./util/decorators"},"arguments":[{"__symbolic":"reference","name":"ViewChildrenMetadata","module":"./metadata/di"}]},"ViewChild":{"__symbolic":"call","expression":{"__symbolic":"reference","name":"makePropDecorator","module":"./util/decorators"},"arguments":[{"__symbolic":"reference","name":"ViewChildMetadata","module":"./metadata/di"}]},"ViewQuery":{"__symbolic":"call","expression":{"__symbolic":"reference","name":"makeParamDecorator","module":"./util/decorators"},"arguments":[{"__symbolic":"reference","name":"ViewQueryMetadata","module":"./metadata/di"}]},"Pipe":{"__symbolic":"call","expression":{"__symbolic":"reference","name":"makeDecorator","module":"./util/decorators"},"arguments":[{"__symbolic":"reference","name":"PipeMetadata","module":"./metadata/directives"}]},"Input":{"__symbolic":"call","expression":{"__symbolic":"reference","name":"makePropDecorator","module":"./util/decorators"},"arguments":[{"__symbolic":"reference","name":"InputMetadata","module":"./metadata/directives"}]},"Output":{"__symbolic":"call","expression":{"__symbolic":"reference","name":"makePropDecorator","module":"./util/decorators"},"arguments":[{"__symbolic":"reference","name":"OutputMetadata","module":"./metadata/directives"}]},"HostBinding":{"__symbolic":"call","expression":{"__symbolic":"reference","name":"makePropDecorator","module":"./util/decorators"},"arguments":[{"__symbolic":"reference","name":"HostBindingMetadata","module":"./metadata/directives"}]},"HostListener":{"__symbolic":"call","expression":{"__symbolic":"reference","name":"makePropDecorator","module":"./util/decorators"},"arguments":[{"__symbolic":"reference","name":"HostListenerMetadata","module":"./metadata/directives"}]}}}
+{"__symbolic":"module","version":1,"metadata":{"Component":{"__symbolic":"error","message":"Function call not supported","line":475,"character":62},"Directive":{"__symbolic":"call","expression":{"__symbolic":"reference","module":"./util/decorators","name":"makeDecorator"},"arguments":[{"__symbolic":"reference","module":"./metadata/directives","name":"DirectiveMetadata"}]},"Attribute":{"__symbolic":"call","expression":{"__symbolic":"reference","module":"./util/decorators","name":"makeParamDecorator"},"arguments":[{"__symbolic":"reference","module":"./metadata/di","name":"AttributeMetadata"}]},"Query":{"__symbolic":"call","expression":{"__symbolic":"reference","module":"./util/decorators","name":"makeParamDecorator"},"arguments":[{"__symbolic":"reference","module":"./metadata/di","name":"QueryMetadata"}]},"ContentChildren":{"__symbolic":"call","expression":{"__symbolic":"reference","module":"./util/decorators","name":"makePropDecorator"},"arguments":[{"__symbolic":"reference","module":"./metadata/di","name":"ContentChildrenMetadata"}]},"ContentChild":{"__symbolic":"call","expression":{"__symbolic":"reference","module":"./util/decorators","name":"makePropDecorator"},"arguments":[{"__symbolic":"reference","module":"./metadata/di","name":"ContentChildMetadata"}]},"ViewChildren":{"__symbolic":"call","expression":{"__symbolic":"reference","module":"./util/decorators","name":"makePropDecorator"},"arguments":[{"__symbolic":"reference","module":"./metadata/di","name":"ViewChildrenMetadata"}]},"ViewChild":{"__symbolic":"call","expression":{"__symbolic":"reference","module":"./util/decorators","name":"makePropDecorator"},"arguments":[{"__symbolic":"reference","module":"./metadata/di","name":"ViewChildMetadata"}]},"ViewQuery":{"__symbolic":"call","expression":{"__symbolic":"reference","module":"./util/decorators","name":"makeParamDecorator"},"arguments":[{"__symbolic":"reference","module":"./metadata/di","name":"ViewQueryMetadata"}]},"Pipe":{"__symbolic":"call","expression":{"__symbolic":"reference","module":"./util/decorators","name":"makeDecorator"},"arguments":[{"__symbolic":"reference","module":"./metadata/directives","name":"PipeMetadata"}]},"Input":{"__symbolic":"call","expression":{"__symbolic":"reference","module":"./util/decorators","name":"makePropDecorator"},"arguments":[{"__symbolic":"reference","module":"./metadata/directives","name":"InputMetadata"}]},"Output":{"__symbolic":"call","expression":{"__symbolic":"reference","module":"./util/decorators","name":"makePropDecorator"},"arguments":[{"__symbolic":"reference","module":"./metadata/directives","name":"OutputMetadata"}]},"HostBinding":{"__symbolic":"call","expression":{"__symbolic":"reference","module":"./util/decorators","name":"makePropDecorator"},"arguments":[{"__symbolic":"reference","module":"./metadata/directives","name":"HostBindingMetadata"}]},"HostListener":{"__symbolic":"call","expression":{"__symbolic":"reference","module":"./util/decorators","name":"makePropDecorator"},"arguments":[{"__symbolic":"reference","module":"./metadata/directives","name":"HostListenerMetadata"}]}}}

package/esm/src/platform_common_providers.d.ts

@@ -2,5 +2,6 @@ import { Type } from '../src/facade/lang';
 import { Provider } from './di';
 /**
  * A default set of providers which should be included in any Angular platform.
+ * @experimental
  */
 export declare const PLATFORM_COMMON_PROVIDERS: Array<any | Type | Provider | any[]>;