` ) will ensure that this element will get the "button" role.
+ *
+ * ```typescript
+ * @Directive({
+ * selector: '[my-button]',
+ * host: {
+ * 'role': 'button'
+ * }
+ * })
+ * class MyButton {
+ * }
+ * ```
+ */
+ host: {[key: string]: string};
+
+ /**
+ * Defines the set of injectable objects that are visible to a Directive and its light DOM
+ * children.
+ *
+ * ## Simple Example
+ *
+ * Here is an example of a class that can be injected:
+ *
+ * ```
+ * class Greeter {
+ * greet(name:string) {
+ * return 'Hello ' + name + '!';
+ * }
+ * }
+ *
+ * @Directive({
+ * selector: 'greet',
+ * bindings: [
+ * Greeter
+ * ]
+ * })
+ * class HelloWorld {
+ * greeter:Greeter;
+ *
+ * constructor(greeter:Greeter) {
+ * this.greeter = greeter;
+ * }
+ * }
+ * ```
+ */
+ providers: any[];
+
+ /**
+ * @deprecated
+ */
+ bindings: any[];
+
+ /**
+ * Defines the name that can be used in the template to assign this directive to a variable.
+ *
+ * ## Simple Example
+ *
+ * ```
+ * @Directive({
+ * selector: 'child-dir',
+ * exportAs: 'child'
+ * })
+ * class ChildDir {
+ * }
+ *
+ * @Component({
+ * selector: 'main',
+ * template: `
`,
+ * directives: [ChildDir]
+ * })
+ * class MainComponent {
+ * }
+ *
+ * ```
+ */
+ exportAs: string;
+
+ /**
+ * Configures the queries that will be injected into the directive.
+ *
+ * Content queries are set before the `ngAfterContentInit` callback is called.
+ * View queries are set before the `ngAfterViewInit` callback is called.
+ *
+ * ### Example
+ *
+ * ```
+ * @Component({
+ * selector: 'someDir',
+ * queries: {
+ * contentChildren: new ContentChildren(ChildDirective),
+ * viewChildren: new ViewChildren(ChildDirective)
+ * },
+ * template: '
',
+ * directives: [ChildDirective]
+ * })
+ * class SomeDir {
+ * contentChildren: QueryList
,
+ * viewChildren: QueryList
+ *
+ * ngAfterContentInit() {
+ * // contentChildren is set
+ * }
+ *
+ * ngAfterViewInit() {
+ * // viewChildren is set
+ * }
+ * }
+ * ```
+ */
+ queries: {[key: string]: any};
+
+ }
+
+
+ /**
+ * Declare reusable pipe function.
+ *
+ * A "pure" pipe is only re-evaluated when either the input or any of the arguments change.
+ *
+ * When not specified, pipes default to being pure.
+ *
+ * ### Example
+ *
+ * {@example core/ts/metadata/metadata.ts region='pipe'}
+ */
+ class PipeMetadata extends InjectableMetadata {
+
+ constructor({name, pure}: {name: string, pure?: boolean});
+
+ name: string;
+
+ pure: boolean;
+
+ }
+
+
+ /**
+ * Declares a data-bound input property.
+ *
+ * Angular automatically updates data-bound properties during change detection.
+ *
+ * `InputMetadata` takes an optional parameter that specifies the name
+ * used when instantiating a component in the template. When not provided,
+ * the name of the decorated property is used.
+ *
+ * ### Example
+ *
+ * The following example creates a component with two input properties.
+ *
+ * ```typescript
+ * @Component({
+ * selector: 'bank-account',
+ * template: `
+ * Bank Name: {{bankName}}
+ * Account Id: {{id}}
+ * `
+ * })
+ * class BankAccount {
+ * @Input() bankName: string;
+ * @Input('account-id') id: string;
+ *
+ * // this property is not bound, and won't be automatically updated by Angular
+ * normalizedBankName: string;
+ * }
+ *
+ * @Component({
+ * selector: 'app',
+ * template: `
+ *
+ *
+ * `,
+ * directives: [IntervalDir]
+ * })
+ * class App {
+ * everySecond() { console.log('second'); }
+ * everyFiveSeconds() { console.log('five seconds'); }
+ * }
+ * bootstrap(App);
+ * ```
+ */
+ class OutputMetadata {
+
+ constructor(bindingPropertyName?: string);
+
+ bindingPropertyName: string;
+
+ }
+
+
+ /**
+ * Declares a host property binding.
+ *
+ * Angular automatically checks host property bindings during change detection.
+ * If a binding changes, it will update the host element of the directive.
+ *
+ * `HostBindingMetadata` takes an optional parameter that specifies the property
+ * name of the host element that will be updated. When not provided,
+ * the class property name is used.
+ *
+ * ### Example
+ *
+ * The following example creates a directive that sets the `valid` and `invalid` classes
+ * on the DOM element that has ngModel directive on it.
+ *
+ * ```typescript
+ * @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; }
+ * }
+ *
+ * @Component({
+ * selector: 'app',
+ * template: `Increment `,
+ * directives: [CountClicks]
+ * })
+ * class App {}
+ *
+ * bootstrap(App);
+ * ```
+ */
+ class HostListenerMetadata {
+
+ constructor(eventName: string, args?: string[]);
+
+ eventName: string;
+
+ args: string[];
+
+ }
+
+
+ /**
+ * Metadata properties available for configuring Views.
+ *
+ * Each Angular component requires a single `@Component` and at least one `@View` annotation. The
+ * `@View` annotation specifies the HTML template to use, and lists the directives that are active
+ * within the template.
+ *
+ * When a component is instantiated, the template is loaded into the component's shadow root, and
+ * the expressions and statements in the template are evaluated against the component.
+ *
+ * For details on the `@Component` annotation, see {@link ComponentMetadata}.
+ *
+ * ### Example
+ *
+ * ```
+ * @Component({
+ * selector: 'greet',
+ * template: 'Hello {{name}}!',
+ * directives: [GreetUser, Bold]
+ * })
+ * class Greet {
+ * name: string;
+ *
+ * constructor() {
+ * this.name = 'World';
+ * }
+ * }
+ * ```
+ */
+ class ViewMetadata {
+
+ constructor({templateUrl, template, directives, pipes, encapsulation, styles, styleUrls}?: {
+ templateUrl?: string,
+ template?: string,
+ directives?: Array,
+ pipes?: Array,
+ encapsulation?: ViewEncapsulation,
+ styles?: string[],
+ styleUrls?: string[],
+ });
+
+ /**
+ * Specifies a template URL for an Angular component.
+ *
+ * NOTE: Only one of `templateUrl` or `template` can be defined per View.
+ *
+ *
+ */
+ templateUrl: string;
+
+ /**
+ * Specifies an inline template for an Angular component.
+ *
+ * NOTE: Only one of `templateUrl` or `template` can be defined per View.
+ */
+ template: string;
+
+ /**
+ * Specifies stylesheet URLs for an Angular component.
+ *
+ *
+ */
+ styleUrls: string[];
+
+ /**
+ * Specifies an inline stylesheet for an Angular component.
+ */
+ styles: string[];
+
+ /**
+ * Specifies a list of directives that can be used within a template.
+ *
+ * Directives must be listed explicitly to provide proper component encapsulation.
+ *
+ * ### Example
+ *
+ * ```javascript
+ * @Component({
+ * selector: 'my-component',
+ * directives: [NgFor]
+ * template: '
+ * '
+ * })
+ * class MyComponent {
+ * }
+ * ```
+ */
+ directives: Array;
+
+ pipes: Array;
+
+ /**
+ * Specify how the template and the styles should be encapsulated.
+ * The default is {@link ViewEncapsulation#Emulated `ViewEncapsulation.Emulated`} if the view
+ * has styles,
+ * otherwise {@link ViewEncapsulation#None `ViewEncapsulation.None`}.
+ */
+ encapsulation: ViewEncapsulation;
+
+ }
+
+
+ /**
+ * Defines template and style encapsulation options available for Component's {@link View}.
+ *
+ * See {@link ViewMetadata#encapsulation}.
+ */
+ enum ViewEncapsulation {
+
+ /**
+ * Emulate `Native` scoping of styles by adding an attribute containing surrogate id to the Host
+ * Element and pre-processing the style rules provided via
+ * {@link ViewMetadata#styles} or {@link ViewMetadata#stylesUrls}, and adding the new Host Element
+ * attribute to all selectors.
+ *
+ * This is the default option.
+ */
+ Emulated,
+
+ /**
+ * Use the native encapsulation mechanism of the renderer.
+ *
+ * For the DOM this means using [Shadow DOM](https://w3c.github.io/webcomponents/spec/shadow/) and
+ * creating a ShadowRoot for Component's Host Element.
+ */
+ Native,
+
+ /**
+ * Don't provide any template or style encapsulation.
+ */
+ None
+ }
+
+
+
+ /**
+ * Interface for the {@link DirectiveMetadata} decorator function.
+ *
+ * See {@link DirectiveFactory}.
+ */
+ interface DirectiveDecorator extends TypeDecorator {
+
+ }
+
+
+ /**
+ * Interface for the {@link ComponentMetadata} decorator function.
+ *
+ * See {@link ComponentFactory}.
+ */
+ interface ComponentDecorator extends TypeDecorator {
+
+ /**
+ * Chain {@link ViewMetadata} annotation.
+ */
+ View(obj: {
+ templateUrl?: string,
+ template?: string,
+ directives?: Array,
+ pipes?: Array,
+ renderer?: string,
+ styles?: string[],
+ styleUrls?: string[],
+ }): ViewDecorator;
+
+ }
+
+
+ /**
+ * Interface for the {@link ViewMetadata} decorator function.
+ *
+ * See {@link ViewFactory}.
+ */
+ interface ViewDecorator extends TypeDecorator {
+
+ /**
+ * Chain {@link ViewMetadata} annotation.
+ */
+ View(obj: {
+ templateUrl?: string,
+ template?: string,
+ directives?: Array,
+ pipes?: Array,
+ renderer?: string,
+ styles?: string[],
+ styleUrls?: string[],
+ }): ViewDecorator;
+
+ }
+
+
+ /**
+ * {@link DirectiveMetadata} factory for creating annotations, decorators or DSL.
+ *
+ * ### Example as TypeScript Decorator
+ *
+ * {@example core/ts/metadata/metadata.ts region='directive'}
+ *
+ * ### Example as ES5 DSL
+ *
+ * ```
+ * var MyDirective = ng
+ * .Directive({...})
+ * .Class({
+ * constructor: function() {
+ * ...
+ * }
+ * })
+ * ```
+ *
+ * ### Example as ES5 annotation
+ *
+ * ```
+ * var MyDirective = function() {
+ * ...
+ * };
+ *
+ * MyDirective.annotations = [
+ * new ng.Directive({...})
+ * ]
+ * ```
+ */
+ interface DirectiveFactory {
+
+ new(obj: {
+ selector?: string,
+ inputs?: string[],
+ outputs?: string[],
+ properties?: string[],
+ events?: string[],
+ host?: {[key: string]: string},
+ bindings?: any[],
+ providers?: any[],
+ exportAs?: string,
+ queries?: {[key: string]: any}
+ }): DirectiveMetadata;
+
+ (obj: {
+ selector?: string,
+ inputs?: string[],
+ outputs?: string[],
+ properties?: string[],
+ events?: string[],
+ host?: {[key: string]: string},
+ bindings?: any[],
+ providers?: any[],
+ exportAs?: string,
+ queries?: {[key: string]: any}
+ }): DirectiveDecorator;
+
+ }
+
+
+ /**
+ * {@link ComponentMetadata} factory for creating annotations, decorators or DSL.
+ *
+ * ### Example as TypeScript Decorator
+ *
+ * {@example core/ts/metadata/metadata.ts region='component'}
+ *
+ * ### Example as ES5 DSL
+ *
+ * ```
+ * var MyComponent = ng
+ * .Component({...})
+ * .Class({
+ * constructor: function() {
+ * ...
+ * }
+ * })
+ * ```
+ *
+ * ### Example as ES5 annotation
+ *
+ * ```
+ * var MyComponent = function() {
+ * ...
+ * };
+ *
+ * MyComponent.annotations = [
+ * new ng.Component({...})
+ * ]
+ * ```
+ */
+ interface ComponentFactory {
+
+ new(obj: {
+ selector?: string,
+ inputs?: string[],
+ outputs?: string[],
+ properties?: string[],
+ events?: string[],
+ host?: {[key: string]: string},
+ /* @deprecated */
+ bindings?: any[],
+ providers?: any[],
+ exportAs?: string,
+ moduleId?: string,
+ queries?: {[key: string]: any},
+ /* @deprecated */
+ viewBindings?: any[],
+ viewProviders?: any[],
+ changeDetection?: ChangeDetectionStrategy,
+ templateUrl?: string,
+ template?: string,
+ styleUrls?: string[],
+ styles?: string[],
+ directives?: Array,
+ pipes?: Array,
+ encapsulation?: ViewEncapsulation
+ }): ComponentMetadata;
+
+ (obj: {
+ selector?: string,
+ inputs?: string[],
+ outputs?: string[],
+ properties?: string[],
+ events?: string[],
+ host?: {[key: string]: string},
+ /* @deprecated */
+ 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[],
+ directives?: Array,
+ pipes?: Array,
+ encapsulation?: ViewEncapsulation
+ }): ComponentDecorator;
+
+ }
+
+
+ /**
+ * {@link ViewMetadata} factory for creating annotations, decorators or DSL.
+ *
+ * ### Example as TypeScript Decorator
+ *
+ * ```
+ * import {Component, View} from "angular2/core";
+ *
+ * @Component({...})
+ * @View({...})
+ * class MyComponent {
+ * constructor() {
+ * ...
+ * }
+ * }
+ * ```
+ *
+ * ### Example as ES5 DSL
+ *
+ * ```
+ * var MyComponent = ng
+ * .Component({...})
+ * .View({...})
+ * .Class({
+ * constructor: function() {
+ * ...
+ * }
+ * })
+ * ```
+ *
+ * ### Example as ES5 annotation
+ *
+ * ```
+ * var MyComponent = function() {
+ * ...
+ * };
+ *
+ * MyComponent.annotations = [
+ * new ng.Component({...}),
+ * new ng.View({...})
+ * ]
+ * ```
+ */
+ interface ViewFactory {
+
+ new(obj: {
+ templateUrl?: string,
+ template?: string,
+ directives?: Array,
+ pipes?: Array,
+ encapsulation?: ViewEncapsulation,
+ styles?: string[],
+ styleUrls?: string[],
+ }): ViewMetadata;
+
+ (obj: {
+ templateUrl?: string,
+ template?: string,
+ directives?: Array,
+ pipes?: Array,
+ encapsulation?: ViewEncapsulation,
+ styles?: string[],
+ styleUrls?: string[],
+ }): ViewDecorator;
+
+ }
+
+
+ /**
+ * {@link AttributeMetadata} factory for creating annotations, decorators or DSL.
+ *
+ * ### Example as TypeScript Decorator
+ *
+ * {@example core/ts/metadata/metadata.ts region='attributeFactory'}
+ *
+ * ### Example as ES5 DSL
+ *
+ * ```
+ * var MyComponent = ng
+ * .Component({...})
+ * .Class({
+ * constructor: [new ng.Attribute('title'), function(title) {
+ * ...
+ * }]
+ * })
+ * ```
+ *
+ * ### Example as ES5 annotation
+ *
+ * ```
+ * var MyComponent = function(title) {
+ * ...
+ * };
+ *
+ * MyComponent.annotations = [
+ * new ng.Component({...})
+ * ]
+ * MyComponent.parameters = [
+ * [new ng.Attribute('title')]
+ * ]
+ * ```
+ */
+ interface AttributeFactory {
+
+ new(name: string): AttributeMetadata;
+
+ (name: string): TypeDecorator;
+
+ }
+
+
+ /**
+ * {@link QueryMetadata} factory for creating annotations, decorators or DSL.
+ *
+ * ### Example as TypeScript Decorator
+ *
+ * ```
+ * import {Query, QueryList, Component} from "angular2/core";
+ *
+ * @Component({...})
+ * class MyComponent {
+ * constructor(@Query(SomeType) queryList: QueryList) {
+ * ...
+ * }
+ * }
+ * ```
+ *
+ * ### Example as ES5 DSL
+ *
+ * ```
+ * var MyComponent = ng
+ * .Component({...})
+ * .Class({
+ * constructor: [new ng.Query(SomeType), function(queryList) {
+ * ...
+ * }]
+ * })
+ * ```
+ *
+ * ### Example as ES5 annotation
+ *
+ * ```
+ * var MyComponent = function(queryList) {
+ * ...
+ * };
+ *
+ * MyComponent.annotations = [
+ * new ng.Component({...})
+ * ]
+ * MyComponent.parameters = [
+ * [new ng.Query(SomeType)]
+ * ]
+ * ```
+ */
+ interface QueryFactory {
+
+ new(selector: Type | string, {descendants}?: {descendants?: boolean}): QueryMetadata;
+
+ (selector: Type | string, {descendants}?: {descendants?: boolean}): ParameterDecorator;
+
+ }
+
+
+ /**
+ * Factory for {@link ContentChildren}.
+ */
+ interface ContentChildrenFactory {
+
+ new(selector: Type | string, {descendants}?: {descendants?: boolean}): ContentChildrenMetadata;
+
+ (selector: Type | string, {descendants}?: {descendants?: boolean}): any;
+
+ }
+
+
+ /**
+ * Factory for {@link ContentChild}.
+ */
+ interface ContentChildFactory {
+
+ new(selector: Type | string): ContentChildFactory;
+
+ (selector: Type | string): any;
+
+ }
+
+
+ /**
+ * Factory for {@link ViewChildren}.
+ */
+ interface ViewChildrenFactory {
+
+ new(selector: Type | string): ViewChildrenMetadata;
+
+ (selector: Type | string): any;
+
+ }
+
+
+ /**
+ * Factory for {@link ViewChild}.
+ */
+ interface ViewChildFactory {
+
+ new(selector: Type | string): ViewChildFactory;
+
+ (selector: Type | string): any;
+
+ }
+
+
+ /**
+ * {@link PipeMetadata} factory for creating decorators.
+ *
+ * ### Example
+ *
+ * {@example core/ts/metadata/metadata.ts region='pipe'}
+ */
+ interface PipeFactory {
+
+ new(obj: {name: string, pure?: boolean}): any;
+
+ (obj: {name: string, pure?: boolean}): any;
+
+ }
+
+
+ /**
+ * {@link InputMetadata} factory for creating decorators.
+ *
+ * See {@link InputMetadata}.
+ */
+ interface InputFactory {
+
+ new(bindingPropertyName?: string): any;
+
+ (bindingPropertyName?: string): any;
+
+ }
+
+
+ /**
+ * {@link OutputMetadata} factory for creating decorators.
+ *
+ * See {@link OutputMetadata}.
+ */
+ interface OutputFactory {
+
+ new(bindingPropertyName?: string): any;
+
+ (bindingPropertyName?: string): any;
+
+ }
+
+
+ /**
+ * {@link HostBindingMetadata} factory function.
+ */
+ interface HostBindingFactory {
+
+ new(hostPropertyName?: string): any;
+
+ (hostPropertyName?: string): any;
+
+ }
+
+
+ /**
+ * {@link HostListenerMetadata} factory function.
+ */
+ interface HostListenerFactory {
+
+ new(eventName: string, args?: string[]): any;
+
+ (eventName: string, args?: string[]): any;
+
+ }
+
+
+ /**
+ * Declare reusable UI building blocks for an application.
+ *
+ * Each Angular component requires a single `@Component` and at least one `@View` annotation. The
+ * `@Component`
+ * annotation specifies when a component is instantiated, and which properties and hostListeners it
+ * binds to.
+ *
+ * When a component is instantiated, Angular
+ * - creates a shadow DOM for the component.
+ * - loads the selected template into the shadow DOM.
+ * - creates all the injectable objects configured with `providers` and `viewProviders`.
+ *
+ * All template expressions and statements are then evaluated against the component instance.
+ *
+ * For details on the `@View` annotation, see {@link ViewMetadata}.
+ *
+ * ## Lifecycle hooks
+ *
+ * When the component class implements some {@link angular2/lifecycle_hooks} the callbacks are
+ * called by the change detection at defined points in time during the life of the component.
+ *
+ * ### Example
+ *
+ * {@example core/ts/metadata/metadata.ts region='component'}
+ */
+ var Component: ComponentFactory;
+
+
+
+ /**
+ * Directives allow you to attach behavior to elements in the DOM.
+ *
+ * {@link DirectiveMetadata}s with an embedded view are called {@link ComponentMetadata}s.
+ *
+ * A directive consists of a single directive annotation and a controller class. When the
+ * directive's `selector` matches
+ * elements in the DOM, the following steps occur:
+ *
+ * 1. For each directive, the `ElementInjector` attempts to resolve the directive's constructor
+ * arguments.
+ * 2. Angular instantiates directives for each matched element using `ElementInjector` in a
+ * depth-first order,
+ * as declared in the HTML.
+ *
+ * ## Understanding How Injection Works
+ *
+ * There are three stages of injection resolution.
+ * - *Pre-existing Injectors*:
+ * - The terminal {@link Injector} cannot resolve dependencies. It either throws an error or, if
+ * the dependency was
+ * specified as `@Optional`, returns `null`.
+ * - The platform injector resolves browser singleton resources, such as: cookies, title,
+ * location, and others.
+ * - *Component Injectors*: Each component instance has its own {@link Injector}, and they follow
+ * the same parent-child hierarchy
+ * as the component instances in the DOM.
+ * - *Element Injectors*: Each component instance has a Shadow DOM. Within the Shadow DOM each
+ * element has an `ElementInjector`
+ * which follow the same parent-child hierarchy as the DOM elements themselves.
+ *
+ * When a template is instantiated, it also must instantiate the corresponding directives in a
+ * depth-first order. The
+ * current `ElementInjector` resolves the constructor dependencies for each directive.
+ *
+ * Angular then resolves dependencies as follows, according to the order in which they appear in the
+ * {@link ViewMetadata}:
+ *
+ * 1. Dependencies on the current element
+ * 2. Dependencies on element injectors and their parents until it encounters a Shadow DOM boundary
+ * 3. Dependencies on component injectors and their parents until it encounters the root component
+ * 4. Dependencies on pre-existing injectors
+ *
+ *
+ * The `ElementInjector` can inject other directives, element-specific special objects, or it can
+ * delegate to the parent
+ * injector.
+ *
+ * To inject other directives, declare the constructor parameter as:
+ * - `directive:DirectiveType`: a directive on the current element only
+ * - `@Host() directive:DirectiveType`: any directive that matches the type between the current
+ * element and the
+ * Shadow DOM root.
+ * - `@Query(DirectiveType) query:QueryList`: A live collection of direct child
+ * directives.
+ * - `@QueryDescendants(DirectiveType) query:QueryList`: A live collection of any
+ * child directives.
+ *
+ * To inject element-specific special objects, declare the constructor parameter as:
+ * - `element: ElementRef` to obtain a reference to logical element in the view.
+ * - `viewContainer: ViewContainerRef` to control child template instantiation, for
+ * {@link DirectiveMetadata} directives only
+ * - `bindingPropagation: BindingPropagation` to control change detection in a more granular way.
+ *
+ * ### Example
+ *
+ * The following example demonstrates how dependency injection resolves constructor arguments in
+ * practice.
+ *
+ *
+ * Assume this HTML template:
+ *
+ * ```
+ *
+ * ```
+ *
+ * With the following `dependency` decorator and `SomeService` injectable class.
+ *
+ * ```
+ * @Injectable()
+ * class SomeService {
+ * }
+ *
+ * @Directive({
+ * selector: '[dependency]',
+ * inputs: [
+ * 'id: dependency'
+ * ]
+ * })
+ * class Dependency {
+ * id:string;
+ * }
+ * ```
+ *
+ * Let's step through the different ways in which `MyDirective` could be declared...
+ *
+ *
+ * ### No injection
+ *
+ * Here the constructor is declared with no arguments, therefore nothing is injected into
+ * `MyDirective`.
+ *
+ * ```
+ * @Directive({ selector: '[my-directive]' })
+ * class MyDirective {
+ * constructor() {
+ * }
+ * }
+ * ```
+ *
+ * This directive would be instantiated with no dependencies.
+ *
+ *
+ * ### Component-level injection
+ *
+ * Directives can inject any injectable instance from the closest component injector or any of its
+ * parents.
+ *
+ * Here, the constructor declares a parameter, `someService`, and injects the `SomeService` type
+ * from the parent
+ * component's injector.
+ * ```
+ * @Directive({ selector: '[my-directive]' })
+ * class MyDirective {
+ * constructor(someService: SomeService) {
+ * }
+ * }
+ * ```
+ *
+ * This directive would be instantiated with a dependency on `SomeService`.
+ *
+ *
+ * ### Injecting a directive from the current element
+ *
+ * Directives can inject other directives declared on the current element.
+ *
+ * ```
+ * @Directive({ selector: '[my-directive]' })
+ * class MyDirective {
+ * constructor(dependency: Dependency) {
+ * expect(dependency.id).toEqual(3);
+ * }
+ * }
+ * ```
+ * This directive would be instantiated with `Dependency` declared at the same element, in this case
+ * `dependency="3"`.
+ *
+ * ### Injecting a directive from any ancestor elements
+ *
+ * Directives can inject other directives declared on any ancestor element (in the current Shadow
+ * DOM), i.e. on the current element, the
+ * parent element, or its parents.
+ * ```
+ * @Directive({ selector: '[my-directive]' })
+ * class MyDirective {
+ * constructor(@Host() dependency: Dependency) {
+ * expect(dependency.id).toEqual(2);
+ * }
+ * }
+ * ```
+ *
+ * `@Host` checks the current element, the parent, as well as its parents recursively. If
+ * `dependency="2"` didn't
+ * exist on the direct parent, this injection would
+ * have returned
+ * `dependency="1"`.
+ *
+ *
+ * ### Injecting a live collection of direct child directives
+ *
+ *
+ * A directive can also query for other child directives. Since parent directives are instantiated
+ * before child directives, a directive can't simply inject the list of child directives. Instead,
+ * the directive injects a {@link QueryList}, which updates its contents as children are added,
+ * removed, or moved by a directive that uses a {@link ViewContainerRef} such as a `ngFor`, an
+ * `ngIf`, or an `ngSwitch`.
+ *
+ * ```
+ * @Directive({ selector: '[my-directive]' })
+ * class MyDirective {
+ * constructor(@Query(Dependency) dependencies:QueryList) {
+ * }
+ * }
+ * ```
+ *
+ * This directive would be instantiated with a {@link QueryList} which contains `Dependency` 4 and
+ * 6. Here, `Dependency` 5 would not be included, because it is not a direct child.
+ *
+ * ### Injecting a live collection of descendant directives
+ *
+ * By passing the descendant flag to `@Query` above, we can include the children of the child
+ * elements.
+ *
+ * ```
+ * @Directive({ selector: '[my-directive]' })
+ * class MyDirective {
+ * constructor(@Query(Dependency, {descendants: true}) dependencies:QueryList) {
+ * }
+ * }
+ * ```
+ *
+ * This directive would be instantiated with a Query which would contain `Dependency` 4, 5 and 6.
+ *
+ * ### Optional injection
+ *
+ * The normal behavior of directives is to return an error when a specified dependency cannot be
+ * resolved. If you
+ * would like to inject `null` on unresolved dependency instead, you can annotate that dependency
+ * with `@Optional()`.
+ * This explicitly permits the author of a template to treat some of the surrounding directives as
+ * optional.
+ *
+ * ```
+ * @Directive({ selector: '[my-directive]' })
+ * class MyDirective {
+ * constructor(@Optional() dependency:Dependency) {
+ * }
+ * }
+ * ```
+ *
+ * This directive would be instantiated with a `Dependency` directive found on the current element.
+ * If none can be
+ * found, the injector supplies `null` instead of throwing an error.
+ *
+ * ### Example
+ *
+ * Here we use a decorator directive to simply define basic tool-tip behavior.
+ *
+ * ```
+ * @Directive({
+ * selector: '[tooltip]',
+ * inputs: [
+ * 'text: tooltip'
+ * ],
+ * host: {
+ * '(mouseenter)': 'onMouseEnter()',
+ * '(mouseleave)': 'onMouseLeave()'
+ * }
+ * })
+ * class Tooltip{
+ * text:string;
+ * overlay:Overlay; // NOT YET IMPLEMENTED
+ * overlayManager:OverlayManager; // NOT YET IMPLEMENTED
+ *
+ * constructor(overlayManager:OverlayManager) {
+ * this.overlay = overlay;
+ * }
+ *
+ * onMouseEnter() {
+ * // exact signature to be determined
+ * this.overlay = this.overlayManager.open(text, ...);
+ * }
+ *
+ * onMouseLeave() {
+ * this.overlay.close();
+ * this.overlay = null;
+ * }
+ * }
+ * ```
+ * In our HTML template, we can then add this behavior to a `` or any other element with the
+ * `tooltip` selector,
+ * like so:
+ *
+ * ```
+ *
+ * ```
+ *
+ * Directives can also control the instantiation, destruction, and positioning of inline template
+ * elements:
+ *
+ * A directive uses a {@link ViewContainerRef} to instantiate, insert, move, and destroy views at
+ * runtime.
+ * The {@link ViewContainerRef} is created as a result of `
` element, and represents a
+ * location in the current view
+ * where these actions are performed.
+ *
+ * Views are always created as children of the current {@link ViewMetadata}, and as siblings of the
+ * `` element. Thus a
+ * directive in a child view cannot inject the directive that created it.
+ *
+ * Since directives that create views via ViewContainers are common in Angular, and using the full
+ * `` element syntax is wordy, Angular
+ * also supports a shorthand notation: `` and ` ` are
+ * equivalent.
+ *
+ * Thus,
+ *
+ * ```
+ *
+ * ```
+ *
+ * Expands in use to:
+ *
+ * ```
+ *
+ * ```
+ *
+ * Notice that although the shorthand places `*foo="bar"` within the ` ` element, the binding for
+ * the directive
+ * controller is correctly instantiated on the `` element rather than the `` element.
+ *
+ * ## Lifecycle hooks
+ *
+ * When the directive class implements some {@link angular2/lifecycle_hooks} the callbacks are
+ * called by the change detection at defined points in time during the life of the directive.
+ *
+ * ### Example
+ *
+ * Let's suppose we want to implement the `unless` behavior, to conditionally include a template.
+ *
+ * Here is a simple directive that triggers on an `unless` selector:
+ *
+ * ```
+ * @Directive({
+ * selector: '[unless]',
+ * inputs: ['unless']
+ * })
+ * export class Unless {
+ * viewContainer: ViewContainerRef;
+ * templateRef: TemplateRef;
+ * prevCondition: boolean;
+ *
+ * constructor(viewContainer: ViewContainerRef, templateRef: TemplateRef) {
+ * this.viewContainer = viewContainer;
+ * this.templateRef = templateRef;
+ * this.prevCondition = null;
+ * }
+ *
+ * set unless(newCondition) {
+ * if (newCondition && (isBlank(this.prevCondition) || !this.prevCondition)) {
+ * this.prevCondition = true;
+ * this.viewContainer.clear();
+ * } else if (!newCondition && (isBlank(this.prevCondition) || this.prevCondition)) {
+ * this.prevCondition = false;
+ * this.viewContainer.create(this.templateRef);
+ * }
+ * }
+ * }
+ * ```
+ *
+ * We can then use this `unless` selector in a template:
+ * ```
+ *
+ * ```
+ *
+ * Once the directive instantiates the child view, the shorthand notation for the template expands
+ * and the result is:
+ *
+ * ```
+ *
+ * ```
+ *
+ * Note also that although the ` ` element.
+ */
+ var Directive: DirectiveFactory;
+
+
+
+ /**
+ * Metadata properties available for configuring Views.
+ *
+ * Each Angular component requires a single `@Component` and at least one `@View` annotation. The
+ * `@View` annotation specifies the HTML template to use, and lists the directives that are active
+ * within the template.
+ *
+ * When a component is instantiated, the template is loaded into the component's shadow root, and
+ * the expressions and statements in the template are evaluated against the component.
+ *
+ * For details on the `@Component` annotation, see {@link ComponentMetadata}.
+ *
+ * ### Example
+ *
+ * ```
+ * @Component({
+ * selector: 'greet',
+ * template: 'Hello {{name}}!',
+ * directives: [GreetUser, Bold]
+ * })
+ * class Greet {
+ * name: string;
+ *
+ * constructor() {
+ * this.name = 'World';
+ * }
+ * }
+ * ```
+ */
+ var View: ViewFactory;
+
+
+
+ /**
+ * Specifies that a constant attribute value should be injected.
+ *
+ * The directive can inject constant string literals of host element attributes.
+ *
+ * ### Example
+ *
+ * Suppose we have an `` component would like to get a list its children ``
+ * components as shown in this example:
+ *
+ * ```html
+ *
+ * ...
+ * {{o.text}}
+ *
+ * ```
+ *
+ * The preferred solution is to query for `Pane` directives using this decorator.
+ *
+ * ```javascript
+ * @Component({
+ * selector: 'pane',
+ * inputs: ['title']
+ * })
+ * class Pane {
+ * title:string;
+ * }
+ *
+ * @Component({
+ * selector: 'tabs',
+ * template: `
+ *
+ * ;
+ * constructor(@Query(Pane) panes:QueryList) {
+ * this.panes = panes;
+ * }
+ * }
+ * ```
+ *
+ * A query can look for variable bindings by passing in a string with desired binding symbol.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/sT2j25cH1dURAyBRCKx1?p=preview))
+ * ```html
+ *
+ * ...
+ *
+ *
+ * @Component({ selector: 'foo' })
+ * class seeker {
+ * constructor(@Query('findme') elList: QueryList) {...}
+ * }
+ * ```
+ *
+ * In this case the object that is injected depend on the type of the variable
+ * binding. It can be an ElementRef, a directive or a component.
+ *
+ * Passing in a comma separated list of variable bindings will query for all of them.
+ *
+ * ```html
+ *
+ * ...
+ * ...
+ *
+ *
+ * @Component({
+ * selector: 'foo'
+ * })
+ * class Seeker {
+ * constructor(@Query('findMe, findMeToo') elList: QueryList) {...}
+ * }
+ * ```
+ *
+ * Configure whether query looks for direct children or all descendants
+ * of the querying element, by using the `descendants` parameter.
+ * It is set to `false` by default.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/wtGeB977bv7qvA5FTYl9?p=preview))
+ * ```html
+ *
+ * - a
+ * - b
+ *
+ * - c
+ *
+ *
+ * ```
+ *
+ * When querying for items, the first container will see only `a` and `b` by default,
+ * but with `Query(TextDirective, {descendants: true})` it will see `c` too.
+ *
+ * The queried directives are kept in a depth-first pre-order with respect to their
+ * positions in the DOM.
+ *
+ * Query does not look deep into any subcomponent views.
+ *
+ * Query is updated as part of the change-detection cycle. Since change detection
+ * happens after construction of a directive, QueryList will always be empty when observed in the
+ * constructor.
+ *
+ * The injected object is an unmodifiable live list.
+ * See {@link QueryList} for more details.
+ */
+ var Query: QueryFactory;
+
+
+
+ /**
+ * Configures a content query.
+ *
+ * Content queries are set before the `ngAfterContentInit` callback is called.
+ *
+ * ### Example
+ *
+ * ```
+ * @Directive({
+ * selector: 'someDir'
+ * })
+ * class SomeDir {
+ * @ContentChildren(ChildDirective) contentChildren: QueryList;
+ *
+ * ngAfterContentInit() {
+ * // contentChildren is set
+ * }
+ * }
+ * ```
+ */
+ var ContentChildren: ContentChildrenFactory;
+
+
+
+ /**
+ * Configures a content query.
+ *
+ * Content queries are set before the `ngAfterContentInit` callback is called.
+ *
+ * ### Example
+ *
+ * ```
+ * @Directive({
+ * selector: 'someDir'
+ * })
+ * class SomeDir {
+ * @ContentChild(ChildDirective) contentChild;
+ *
+ * ngAfterContentInit() {
+ * // contentChild is set
+ * }
+ * }
+ * ```
+ */
+ var ContentChild: ContentChildFactory;
+
+
+
+ /**
+ * Configures a view query.
+ *
+ * View queries are set before the `ngAfterViewInit` callback is called.
+ *
+ * ### Example
+ *
+ * ```
+ * @Component({
+ * selector: 'someDir',
+ * templateUrl: 'someTemplate',
+ * directives: [ItemDirective]
+ * })
+ * class SomeDir {
+ * @ViewChildren(ItemDirective) viewChildren: QueryList;
+ *
+ * ngAfterViewInit() {
+ * // viewChildren is set
+ * }
+ * }
+ * ```
+ */
+ var ViewChildren: ViewChildrenFactory;
+
+
+
+ /**
+ * Configures a view query.
+ *
+ * View queries are set before the `ngAfterViewInit` callback is called.
+ *
+ * ### Example
+ *
+ * ```
+ * @Component({
+ * selector: 'someDir',
+ * templateUrl: 'someTemplate',
+ * directives: [ItemDirective]
+ * })
+ * class SomeDir {
+ * @ViewChild(ItemDirective) viewChild:ItemDirective;
+ *
+ * ngAfterViewInit() {
+ * // viewChild is set
+ * }
+ * }
+ * ```
+ */
+ var ViewChild: ViewChildFactory;
+
+
+
+ /**
+ * Similar to {@link QueryMetadata}, but querying the component view, instead of
+ * the content children.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/eNsFHDf7YjyM6IzKxM1j?p=preview))
+ *
+ * ```javascript
+ * @Component({...})
+ * @View({
+ * template: `
+ * - a
+ * - b
+ * - c
+ * `
+ * })
+ * class MyComponent {
+ * shown: boolean;
+ *
+ * constructor(private @Query(Item) items:QueryList- ) {
+ * items.onChange(() => console.log(items.length));
+ * }
+ * }
+ * ```
+ *
+ * Supports the same querying parameters as {@link QueryMetadata}, except
+ * `descendants`. This always queries the whole view.
+ *
+ * As `shown` is flipped between true and false, items will contain zero of one
+ * items.
+ *
+ * Specifies that a {@link QueryList} should be injected.
+ *
+ * The injected object is an iterable and observable live list.
+ * See {@link QueryList} for more details.
+ */
+ var ViewQuery: QueryFactory;
+
+
+
+ /**
+ * Declare reusable pipe function.
+ *
+ * ### Example
+ *
+ * {@example core/ts/metadata/metadata.ts region='pipe'}
+ */
+ var Pipe: PipeFactory;
+
+
+
+ /**
+ * Declares a data-bound input property.
+ *
+ * Angular automatically updates data-bound properties during change detection.
+ *
+ * `InputMetadata` takes an optional parameter that specifies the name
+ * used when instantiating a component in the template. When not provided,
+ * the name of the decorated property is used.
+ *
+ * ### Example
+ *
+ * The following example creates a component with two input properties.
+ *
+ * ```typescript
+ * @Component({
+ * selector: 'bank-account',
+ * template: `
+ * Bank Name: {{bankName}}
+ * Account Id: {{id}}
+ * `
+ * })
+ * class BankAccount {
+ * @Input() bankName: string;
+ * @Input('account-id') id: string;
+ *
+ * // this property is not bound, and won't be automatically updated by Angular
+ * normalizedBankName: string;
+ * }
+ *
+ * @Component({
+ * selector: 'app',
+ * template: `
+ *
+ *
+ * `,
+ * directives: [IntervalDir]
+ * })
+ * class App {
+ * everySecond() { console.log('second'); }
+ * everyFiveSeconds() { console.log('five seconds'); }
+ * }
+ * bootstrap(App);
+ * ```
+ */
+ var Output: OutputFactory;
+
+
+
+ /**
+ * Declares a host property binding.
+ *
+ * Angular automatically checks host property bindings during change detection.
+ * If a binding changes, it will update the host element of the directive.
+ *
+ * `HostBindingMetadata` takes an optional parameter that specifies the property
+ * name of the host element that will be updated. When not provided,
+ * the class property name is used.
+ *
+ * ### Example
+ *
+ * The following example creates a directive that sets the `valid` and `invalid` classes
+ * on the DOM element that has ngModel directive on it.
+ *
+ * ```typescript
+ * @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; }
+ * }
+ *
+ * @Component({
+ * selector: 'app',
+ * template: `Increment `,
+ * directives: [CountClicks]
+ * })
+ * class App {}
+ *
+ * bootstrap(App);
+ * ```
+ */
+ var HostListener: HostListenerFactory;
+
+
+
+ /**
+ * Provides a way for expressing ES6 classes with parameter annotations in ES5.
+ *
+ * ## Basic Example
+ *
+ * ```
+ * var Greeter = ng.Class({
+ * constructor: function(name) {
+ * this.name = name;
+ * },
+ *
+ * greet: function() {
+ * alert('Hello ' + this.name + '!');
+ * }
+ * });
+ * ```
+ *
+ * is equivalent to ES6:
+ *
+ * ```
+ * class Greeter {
+ * constructor(name) {
+ * this.name = name;
+ * }
+ *
+ * greet() {
+ * alert('Hello ' + this.name + '!');
+ * }
+ * }
+ * ```
+ *
+ * or equivalent to ES5:
+ *
+ * ```
+ * var Greeter = function (name) {
+ * this.name = name;
+ * }
+ *
+ * Greeter.prototype.greet = function () {
+ * alert('Hello ' + this.name + '!');
+ * }
+ * ```
+ *
+ * ### Example with parameter annotations
+ *
+ * ```
+ * var MyService = ng.Class({
+ * constructor: [String, [new Query(), QueryList], function(name, queryList) {
+ * ...
+ * }]
+ * });
+ * ```
+ *
+ * is equivalent to ES6:
+ *
+ * ```
+ * class MyService {
+ * constructor(name: string, @Query() queryList: QueryList) {
+ * ...
+ * }
+ * }
+ * ```
+ *
+ * ### Example with inheritance
+ *
+ * ```
+ * var Shape = ng.Class({
+ * constructor: (color) {
+ * this.color = color;
+ * }
+ * });
+ *
+ * var Square = ng.Class({
+ * extends: Shape,
+ * constructor: function(color, size) {
+ * Shape.call(this, color);
+ * this.size = size;
+ * }
+ * });
+ * ```
+ */
+ function Class(clsDef: ClassDefinition): ConcreteType;
+
+
+
+ /**
+ * Declares the interface to be used with {@link Class}.
+ */
+ interface ClassDefinition {
+
+ /**
+ * Optional argument for specifying the superclass.
+ */
+ extends?: Type;
+
+ /**
+ * Required constructor function for a class.
+ *
+ * The function may be optionally wrapped in an `Array`, in which case additional parameter
+ * annotations may be specified.
+ * The number of arguments and the number of parameter annotations must match.
+ *
+ * See {@link Class} for example of usage.
+ */
+ constructor: Function | any[];
+
+ }
+
+
+ /**
+ * An interface implemented by all Angular type decorators, which allows them to be used as ES7
+ * decorators as well as
+ * Angular DSL syntax.
+ *
+ * DSL syntax:
+ *
+ * ```
+ * var MyClass = ng
+ * .Component({...})
+ * .View({...})
+ * .Class({...});
+ * ```
+ *
+ * ES7 syntax:
+ *
+ * ```
+ * @ng.Component({...})
+ * @ng.View({...})
+ * class MyClass {...}
+ * ```
+ */
+ interface TypeDecorator {
+
+ /**
+ * Invoke as ES7 decorator.
+ */
+ (type: T): T;
+
+ /**
+ * Storage for the accumulated annotations so far used by the DSL syntax.
+ *
+ * Used by {@link Class} to annotate the generated class.
+ */
+ annotations: any[];
+
+ /**
+ * Generate a class from the definition and annotate it with {@link TypeDecorator#annotations}.
+ */
+ Class(obj: ClassDefinition): ConcreteType;
+
+ }
+
+
+ /**
+ * A parameter metadata that specifies a dependency.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/6uHYJK?p=preview))
+ *
+ * ```typescript
+ * class Engine {}
+ *
+ * @Injectable()
+ * class Car {
+ * engine;
+ * constructor(@Inject("MyEngine") engine:Engine) {
+ * this.engine = engine;
+ * }
+ * }
+ *
+ * var injector = Injector.resolveAndCreate([
+ * provide("MyEngine", {useClass: Engine}),
+ * Car
+ * ]);
+ *
+ * expect(injector.get(Car).engine instanceof Engine).toBe(true);
+ * ```
+ *
+ * When `@Inject()` is not present, {@link Injector} will use the type annotation of the parameter.
+ *
+ * ### Example
+ *
+ * ```typescript
+ * class Engine {}
+ *
+ * @Injectable()
+ * class Car {
+ * constructor(public engine: Engine) {} //same as constructor(@Inject(Engine) engine:Engine)
+ * }
+ *
+ * var injector = Injector.resolveAndCreate([Engine, Car]);
+ * expect(injector.get(Car).engine instanceof Engine).toBe(true);
+ * ```
+ */
+ class InjectMetadata {
+
+ constructor(token: any);
+
+ token: any;
+
+ toString(): string;
+
+ }
+
+
+ /**
+ * A parameter metadata that marks a dependency as optional. {@link Injector} provides `null` if
+ * the dependency is not found.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/AsryOm?p=preview))
+ *
+ * ```typescript
+ * class Engine {}
+ *
+ * @Injectable()
+ * class Car {
+ * engine;
+ * constructor(@Optional() engine:Engine) {
+ * this.engine = engine;
+ * }
+ * }
+ *
+ * var injector = Injector.resolveAndCreate([Car]);
+ * expect(injector.get(Car).engine).toBeNull();
+ * ```
+ */
+ class OptionalMetadata {
+
+ toString(): string;
+
+ }
+
+
+ /**
+ * A marker metadata that marks a class as available to {@link Injector} for creation.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/Wk4DMQ?p=preview))
+ *
+ * ```typescript
+ * @Injectable()
+ * class UsefulService {}
+ *
+ * @Injectable()
+ * class NeedsService {
+ * constructor(public service:UsefulService) {}
+ * }
+ *
+ * var injector = Injector.resolveAndCreate([NeedsService, UsefulService]);
+ * expect(injector.get(NeedsService).service instanceof UsefulService).toBe(true);
+ * ```
+ * {@link Injector} will throw {@link NoAnnotationError} when trying to instantiate a class that
+ * does not have `@Injectable` marker, as shown in the example below.
+ *
+ * ```typescript
+ * class UsefulService {}
+ *
+ * class NeedsService {
+ * constructor(public service:UsefulService) {}
+ * }
+ *
+ * var injector = Injector.resolveAndCreate([NeedsService, UsefulService]);
+ * expect(() => injector.get(NeedsService)).toThrowError();
+ * ```
+ */
+ class InjectableMetadata {
+
+ constructor();
+
+ }
+
+
+ /**
+ * Specifies that an {@link Injector} should retrieve a dependency only from itself.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/NeagAg?p=preview))
+ *
+ * ```typescript
+ * class Dependency {
+ * }
+ *
+ * @Injectable()
+ * class NeedsDependency {
+ * dependency;
+ * constructor(@Self() dependency:Dependency) {
+ * this.dependency = dependency;
+ * }
+ * }
+ *
+ * var inj = Injector.resolveAndCreate([Dependency, NeedsDependency]);
+ * var nd = inj.get(NeedsDependency);
+ *
+ * expect(nd.dependency instanceof Dependency).toBe(true);
+ *
+ * var inj = Injector.resolveAndCreate([Dependency]);
+ * var child = inj.resolveAndCreateChild([NeedsDependency]);
+ * expect(() => child.get(NeedsDependency)).toThrowError();
+ * ```
+ */
+ class SelfMetadata {
+
+ toString(): string;
+
+ }
+
+
+ /**
+ * Specifies that an injector should retrieve a dependency from any injector until reaching the
+ * closest host.
+ *
+ * In Angular, a component element is automatically declared as a host for all the injectors in
+ * its view.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/GX79pV?p=preview))
+ *
+ * In the following example `App` contains `ParentCmp`, which contains `ChildDirective`.
+ * So `ParentCmp` is the host of `ChildDirective`.
+ *
+ * `ChildDirective` depends on two services: `HostService` and `OtherService`.
+ * `HostService` is defined at `ParentCmp`, and `OtherService` is defined at `App`.
+ *
+ * ```typescript
+ * class OtherService {}
+ * class HostService {}
+ *
+ * @Directive({
+ * selector: 'child-directive'
+ * })
+ * class ChildDirective {
+ * constructor(@Optional() @Host() os:OtherService, @Optional() @Host() hs:HostService){
+ * console.log("os is null", os);
+ * console.log("hs is NOT null", hs);
+ * }
+ * }
+ *
+ * @Component({
+ * selector: 'parent-cmp',
+ * providers: [HostService],
+ * template: `
+ * Dir: ): ResolvedProvider[];
+
+ /**
+ * Resolves an array of providers and creates an injector from those providers.
+ *
+ * The passed-in providers can be an array of `Type`, {@link Provider},
+ * or a recursive array of more providers.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/ePOccA?p=preview))
+ *
+ * ```typescript
+ * @Injectable()
+ * class Engine {
+ * }
+ *
+ * @Injectable()
+ * class Car {
+ * constructor(public engine:Engine) {}
+ * }
+ *
+ * var injector = Injector.resolveAndCreate([Car, Engine]);
+ * expect(injector.get(Car) instanceof Car).toBe(true);
+ * ```
+ *
+ * This function is slower than the corresponding `fromResolvedProviders`
+ * because it needs to resolve the passed-in providers first.
+ * See {@link Injector#resolve} and {@link Injector#fromResolvedProviders}.
+ */
+ static resolveAndCreate(providers: Array): Injector;
+
+ /**
+ * Creates an injector from previously resolved providers.
+ *
+ * This API is the recommended way to construct injectors in performance-sensitive parts.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/KrSMci?p=preview))
+ *
+ * ```typescript
+ * @Injectable()
+ * class Engine {
+ * }
+ *
+ * @Injectable()
+ * class Car {
+ * constructor(public engine:Engine) {}
+ * }
+ *
+ * var providers = Injector.resolve([Car, Engine]);
+ * var injector = Injector.fromResolvedProviders(providers);
+ * expect(injector.get(Car) instanceof Car).toBe(true);
+ * ```
+ */
+ static fromResolvedProviders(providers: ResolvedProvider[]): Injector;
+
+ /**
+ * @deprecated
+ */
+ static fromResolvedBindings(providers: ResolvedProvider[]): Injector;
+
+ /**
+ * Retrieves an instance from the injector based on the provided token.
+ * Throws {@link NoProviderError} if not found.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/HeXSHg?p=preview))
+ *
+ * ```typescript
+ * var injector = Injector.resolveAndCreate([
+ * provide("validToken", {useValue: "Value"})
+ * ]);
+ * expect(injector.get("validToken")).toEqual("Value");
+ * expect(() => injector.get("invalidToken")).toThrowError();
+ * ```
+ *
+ * `Injector` returns itself when given `Injector` as a token.
+ *
+ * ```typescript
+ * var injector = Injector.resolveAndCreate([]);
+ * expect(injector.get(Injector)).toBe(injector);
+ * ```
+ */
+ get(token: any): any;
+
+ /**
+ * Retrieves an instance from the injector based on the provided token.
+ * Returns null if not found.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/tpEbEy?p=preview))
+ *
+ * ```typescript
+ * var injector = Injector.resolveAndCreate([
+ * provide("validToken", {useValue: "Value"})
+ * ]);
+ * expect(injector.getOptional("validToken")).toEqual("Value");
+ * expect(injector.getOptional("invalidToken")).toBe(null);
+ * ```
+ *
+ * `Injector` returns itself when given `Injector` as a token.
+ *
+ * ```typescript
+ * var injector = Injector.resolveAndCreate([]);
+ * expect(injector.getOptional(Injector)).toBe(injector);
+ * ```
+ */
+ getOptional(token: any): any;
+
+ /**
+ * Parent of this injector.
+ *
+ *
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/eosMGo?p=preview))
+ *
+ * ```typescript
+ * var parent = Injector.resolveAndCreate([]);
+ * var child = parent.resolveAndCreateChild([]);
+ * expect(child.parent).toBe(parent);
+ * ```
+ */
+ parent: Injector;
+
+ /**
+ * Resolves an array of providers and creates a child injector from those providers.
+ *
+ *
+ *
+ * The passed-in providers can be an array of `Type`, {@link Provider},
+ * or a recursive array of more providers.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/opB3T4?p=preview))
+ *
+ * ```typescript
+ * class ParentProvider {}
+ * class ChildProvider {}
+ *
+ * var parent = Injector.resolveAndCreate([ParentProvider]);
+ * var child = parent.resolveAndCreateChild([ChildProvider]);
+ *
+ * expect(child.get(ParentProvider) instanceof ParentProvider).toBe(true);
+ * expect(child.get(ChildProvider) instanceof ChildProvider).toBe(true);
+ * expect(child.get(ParentProvider)).toBe(parent.get(ParentProvider));
+ * ```
+ *
+ * This function is slower than the corresponding `createChildFromResolved`
+ * because it needs to resolve the passed-in providers first.
+ * See {@link Injector#resolve} and {@link Injector#createChildFromResolved}.
+ */
+ resolveAndCreateChild(providers: Array): Injector;
+
+ /**
+ * Creates a child injector from previously resolved providers.
+ *
+ *
+ *
+ * This API is the recommended way to construct injectors in performance-sensitive parts.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/VhyfjN?p=preview))
+ *
+ * ```typescript
+ * class ParentProvider {}
+ * class ChildProvider {}
+ *
+ * var parentProviders = Injector.resolve([ParentProvider]);
+ * var childProviders = Injector.resolve([ChildProvider]);
+ *
+ * var parent = Injector.fromResolvedProviders(parentProviders);
+ * var child = parent.createChildFromResolved(childProviders);
+ *
+ * expect(child.get(ParentProvider) instanceof ParentProvider).toBe(true);
+ * expect(child.get(ChildProvider) instanceof ChildProvider).toBe(true);
+ * expect(child.get(ParentProvider)).toBe(parent.get(ParentProvider));
+ * ```
+ */
+ createChildFromResolved(providers: ResolvedProvider[]): Injector;
+
+ /**
+ * Resolves a provider and instantiates an object in the context of the injector.
+ *
+ * The created object does not get cached by the injector.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/yvVXoB?p=preview))
+ *
+ * ```typescript
+ * @Injectable()
+ * class Engine {
+ * }
+ *
+ * @Injectable()
+ * class Car {
+ * constructor(public engine:Engine) {}
+ * }
+ *
+ * var injector = Injector.resolveAndCreate([Engine]);
+ *
+ * var car = injector.resolveAndInstantiate(Car);
+ * expect(car.engine).toBe(injector.get(Engine));
+ * expect(car).not.toBe(injector.resolveAndInstantiate(Car));
+ * ```
+ */
+ resolveAndInstantiate(provider: Type | Provider): any;
+
+ /**
+ * Instantiates an object using a resolved provider in the context of the injector.
+ *
+ * The created object does not get cached by the injector.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/ptCImQ?p=preview))
+ *
+ * ```typescript
+ * @Injectable()
+ * class Engine {
+ * }
+ *
+ * @Injectable()
+ * class Car {
+ * constructor(public engine:Engine) {}
+ * }
+ *
+ * var injector = Injector.resolveAndCreate([Engine]);
+ * var carProvider = Injector.resolve([Car])[0];
+ * var car = injector.instantiateResolved(carProvider);
+ * expect(car.engine).toBe(injector.get(Engine));
+ * expect(car).not.toBe(injector.instantiateResolved(carProvider));
+ * ```
+ */
+ instantiateResolved(provider: ResolvedProvider): any;
+
+ displayName: string;
+
+ toString(): string;
+
+ }
+
+
+ /**
+ * See {@link Provider} instead.
+ *
+ * @deprecated
+ */
+ class Binding extends Provider {
+
+ constructor(token: any, {toClass, toValue, toAlias, toFactory, deps, multi}: {
+ toClass?: Type,
+ toValue?: any,
+ toAlias?: any,
+ toFactory: Function, deps?: Object[], multi?: boolean
+ });
+
+ /**
+ * @deprecated
+ */
+ toClass: any;
+
+ /**
+ * @deprecated
+ */
+ toAlias: any;
+
+ /**
+ * @deprecated
+ */
+ toFactory: any;
+
+ /**
+ * @deprecated
+ */
+ toValue: any;
+
+ }
+
+
+ /**
+ * Helper class for the {@link bind} function.
+ */
+ class ProviderBuilder {
+
+ constructor(token: any);
+
+ token: any;
+
+ /**
+ * Binds a DI token to a class.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/ZpBCSYqv6e2ud5KXLdxQ?p=preview))
+ *
+ * Because `toAlias` and `toClass` are often confused, the example contains
+ * both use cases for easy comparison.
+ *
+ * ```typescript
+ * class Vehicle {}
+ *
+ * class Car extends Vehicle {}
+ *
+ * var injectorClass = Injector.resolveAndCreate([
+ * Car,
+ * provide(Vehicle, {useClass: Car})
+ * ]);
+ * var injectorAlias = Injector.resolveAndCreate([
+ * Car,
+ * provide(Vehicle, {useExisting: Car})
+ * ]);
+ *
+ * expect(injectorClass.get(Vehicle)).not.toBe(injectorClass.get(Car));
+ * expect(injectorClass.get(Vehicle) instanceof Car).toBe(true);
+ *
+ * expect(injectorAlias.get(Vehicle)).toBe(injectorAlias.get(Car));
+ * expect(injectorAlias.get(Vehicle) instanceof Car).toBe(true);
+ * ```
+ */
+ toClass(type: Type): Provider;
+
+ /**
+ * Binds a DI token to a value.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/G024PFHmDL0cJFgfZK8O?p=preview))
+ *
+ * ```typescript
+ * var injector = Injector.resolveAndCreate([
+ * provide('message', {useValue: 'Hello'})
+ * ]);
+ *
+ * expect(injector.get('message')).toEqual('Hello');
+ * ```
+ */
+ toValue(value: any): Provider;
+
+ /**
+ * Binds a DI token to an existing token.
+ *
+ * Angular will return the same instance as if the provided token was used. (This is
+ * in contrast to `useClass` where a separate instance of `useClass` will be returned.)
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/uBaoF2pN5cfc5AfZapNw?p=preview))
+ *
+ * Because `toAlias` and `toClass` are often confused, the example contains
+ * both use cases for easy comparison.
+ *
+ * ```typescript
+ * class Vehicle {}
+ *
+ * class Car extends Vehicle {}
+ *
+ * var injectorAlias = Injector.resolveAndCreate([
+ * Car,
+ * provide(Vehicle, {useExisting: Car})
+ * ]);
+ * var injectorClass = Injector.resolveAndCreate([
+ * Car,
+ * provide(Vehicle, {useClass: Car})
+ * ]);
+ *
+ * expect(injectorAlias.get(Vehicle)).toBe(injectorAlias.get(Car));
+ * expect(injectorAlias.get(Vehicle) instanceof Car).toBe(true);
+ *
+ * expect(injectorClass.get(Vehicle)).not.toBe(injectorClass.get(Car));
+ * expect(injectorClass.get(Vehicle) instanceof Car).toBe(true);
+ * ```
+ */
+ toAlias(aliasToken: /*Type*/ any): Provider;
+
+ /**
+ * Binds a DI token to a function which computes the value.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/OejNIfTT3zb1iBxaIYOb?p=preview))
+ *
+ * ```typescript
+ * var injector = Injector.resolveAndCreate([
+ * provide(Number, {useFactory: () => { return 1+2; }}),
+ * provide(String, {useFactory: (v) => { return "Value: " + v; }, deps: [Number]})
+ * ]);
+ *
+ * expect(injector.get(Number)).toEqual(3);
+ * expect(injector.get(String)).toEqual('Value: 3');
+ * ```
+ */
+ toFactory(factory: Function, dependencies?: any[]): Provider;
+
+ }
+
+
+ /**
+ * See {@link ResolvedProvider} instead.
+ *
+ * @deprecated
+ */
+ interface ResolvedBinding extends ResolvedProvider {
+
+ }
+
+
+ /**
+ * An internal resolved representation of a factory function created by resolving {@link Provider}.
+ */
+ class ResolvedFactory {
+
+ constructor(factory: Function, dependencies: Dependency[]);
+
+ /**
+ * Factory function which can return an instance of an object represented by a key.
+ */
+ factory: Function;
+
+ /**
+ * Arguments (dependencies) to the `factory` function.
+ */
+ dependencies: Dependency[];
+
+ }
+
+
+ /**
+ * `Dependency` is used by the framework to extend DI.
+ * This is internal to Angular and should not be used directly.
+ */
+ class Dependency {
+
+ constructor(key: Key, optional: boolean, lowerBoundVisibility: any, upperBoundVisibility: any, properties: any[]);
+
+ static fromKey(key: Key): Dependency;
+
+ key: Key;
+
+ optional: boolean;
+
+ lowerBoundVisibility: any;
+
+ upperBoundVisibility: any;
+
+ properties: any[];
+
+ }
+
+
+ /**
+ * Creates a {@link Provider}.
+ *
+ * To construct a {@link Provider}, bind a `token` to either a class, a value, a factory function,
+ * or
+ * to an existing `token`.
+ * See {@link ProviderBuilder} for more details.
+ *
+ * The `token` is most commonly a class or {@link angular2/di/OpaqueToken}.
+ *
+ * @deprecated
+ */
+ function bind(token: any): ProviderBuilder;
+
+
+
+ /**
+ * Describes how the {@link Injector} should instantiate a given token.
+ *
+ * See {@link provide}.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/GNAyj6K6PfYg2NBzgwZ5?p%3Dpreview&p=preview))
+ *
+ * ```javascript
+ * var injector = Injector.resolveAndCreate([
+ * new Provider("message", { useValue: 'Hello' })
+ * ]);
+ *
+ * expect(injector.get("message")).toEqual('Hello');
+ * ```
+ */
+ class Provider {
+
+ constructor(token: any, {useClass, useValue, useExisting, useFactory, deps, multi}: {
+ useClass?: Type,
+ useValue?: any,
+ useExisting?: any,
+ useFactory?: Function,
+ deps?: Object[],
+ multi?: boolean
+ });
+
+ /**
+ * Token used when retrieving this provider. Usually, it is a type {@link Type}.
+ */
+ token: any;
+
+ /**
+ * Binds a DI token to an implementation class.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/RSTG86qgmoxCyj9SWPwY?p=preview))
+ *
+ * Because `useExisting` and `useClass` are often confused, the example contains
+ * both use cases for easy comparison.
+ *
+ * ```typescript
+ * class Vehicle {}
+ *
+ * class Car extends Vehicle {}
+ *
+ * var injectorClass = Injector.resolveAndCreate([
+ * Car,
+ * new Provider(Vehicle, { useClass: Car })
+ * ]);
+ * var injectorAlias = Injector.resolveAndCreate([
+ * Car,
+ * new Provider(Vehicle, { useExisting: Car })
+ * ]);
+ *
+ * expect(injectorClass.get(Vehicle)).not.toBe(injectorClass.get(Car));
+ * expect(injectorClass.get(Vehicle) instanceof Car).toBe(true);
+ *
+ * expect(injectorAlias.get(Vehicle)).toBe(injectorAlias.get(Car));
+ * expect(injectorAlias.get(Vehicle) instanceof Car).toBe(true);
+ * ```
+ */
+ useClass: Type;
+
+ /**
+ * Binds a DI token to a value.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/UFVsMVQIDe7l4waWziES?p=preview))
+ *
+ * ```javascript
+ * var injector = Injector.resolveAndCreate([
+ * new Provider("message", { useValue: 'Hello' })
+ * ]);
+ *
+ * expect(injector.get("message")).toEqual('Hello');
+ * ```
+ */
+ useValue: any;
+
+ /**
+ * Binds a DI token to an existing token.
+ *
+ * {@link Injector} returns the same instance as if the provided token was used.
+ * This is in contrast to `useClass` where a separate instance of `useClass` is returned.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/QsatsOJJ6P8T2fMe9gr8?p=preview))
+ *
+ * Because `useExisting` and `useClass` are often confused the example contains
+ * both use cases for easy comparison.
+ *
+ * ```typescript
+ * class Vehicle {}
+ *
+ * class Car extends Vehicle {}
+ *
+ * var injectorAlias = Injector.resolveAndCreate([
+ * Car,
+ * new Provider(Vehicle, { useExisting: Car })
+ * ]);
+ * var injectorClass = Injector.resolveAndCreate([
+ * Car,
+ * new Provider(Vehicle, { useClass: Car })
+ * ]);
+ *
+ * expect(injectorAlias.get(Vehicle)).toBe(injectorAlias.get(Car));
+ * expect(injectorAlias.get(Vehicle) instanceof Car).toBe(true);
+ *
+ * expect(injectorClass.get(Vehicle)).not.toBe(injectorClass.get(Car));
+ * expect(injectorClass.get(Vehicle) instanceof Car).toBe(true);
+ * ```
+ */
+ useExisting: any;
+
+ /**
+ * Binds a DI token to a function which computes the value.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/Scoxy0pJNqKGAPZY1VVC?p=preview))
+ *
+ * ```typescript
+ * var injector = Injector.resolveAndCreate([
+ * new Provider(Number, { useFactory: () => { return 1+2; }}),
+ * new Provider(String, { useFactory: (value) => { return "Value: " + value; },
+ * deps: [Number] })
+ * ]);
+ *
+ * expect(injector.get(Number)).toEqual(3);
+ * expect(injector.get(String)).toEqual('Value: 3');
+ * ```
+ *
+ * Used in conjuction with dependencies.
+ */
+ useFactory: Function;
+
+ /**
+ * Specifies a set of dependencies
+ * (as `token`s) which should be injected into the factory function.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/Scoxy0pJNqKGAPZY1VVC?p=preview))
+ *
+ * ```typescript
+ * var injector = Injector.resolveAndCreate([
+ * new Provider(Number, { useFactory: () => { return 1+2; }}),
+ * new Provider(String, { useFactory: (value) => { return "Value: " + value; },
+ * deps: [Number] })
+ * ]);
+ *
+ * expect(injector.get(Number)).toEqual(3);
+ * expect(injector.get(String)).toEqual('Value: 3');
+ * ```
+ *
+ * Used in conjunction with `useFactory`.
+ */
+ dependencies: Object[];
+
+ /**
+ * Creates multiple providers matching the same token (a multi-provider).
+ *
+ * Multi-providers are used for creating pluggable service, where the system comes
+ * with some default providers, and the user can register additonal providers.
+ * The combination of the default providers and the additional providers will be
+ * used to drive the behavior of the system.
+ *
+ * ### Example
+ *
+ * ```typescript
+ * var injector = Injector.resolveAndCreate([
+ * new Provider("Strings", { useValue: "String1", multi: true}),
+ * new Provider("Strings", { useValue: "String2", multi: true})
+ * ]);
+ *
+ * expect(injector.get("Strings")).toEqual(["String1", "String2"]);
+ * ```
+ *
+ * Multi-providers and regular providers cannot be mixed. The following
+ * will throw an exception:
+ *
+ * ```typescript
+ * var injector = Injector.resolveAndCreate([
+ * new Provider("Strings", { useValue: "String1", multi: true }),
+ * new Provider("Strings", { useValue: "String2"})
+ * ]);
+ * ```
+ */
+ multi: boolean;
+
+ }
+
+
+ /**
+ * An internal resolved representation of a {@link Provider} used by the {@link Injector}.
+ *
+ * It is usually created automatically by `Injector.resolveAndCreate`.
+ *
+ * It can be created manually, as follows:
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/RfEnhh8kUEI0G3qsnIeT?p%3Dpreview&p=preview))
+ *
+ * ```typescript
+ * var resolvedProviders = Injector.resolve([new Provider('message', {useValue: 'Hello'})]);
+ * var injector = Injector.fromResolvedProviders(resolvedProviders);
+ *
+ * expect(injector.get('message')).toEqual('Hello');
+ * ```
+ */
+ interface ResolvedProvider {
+
+ /**
+ * A key, usually a `Type`.
+ */
+ key: Key;
+
+ /**
+ * Factory function which can return an instance of an object represented by a key.
+ */
+ resolvedFactories: ResolvedFactory[];
+
+ /**
+ * Indicates if the provider is a multi-provider or a regular provider.
+ */
+ multiProvider: boolean;
+
+ }
+
+
+ /**
+ * Creates a {@link Provider}.
+ *
+ * See {@link Provider} for more details.
+ *
+ *
+ */
+ function provide(token: any, {useClass, useValue, useExisting, useFactory, deps, multi}: {
+ useClass?: Type,
+ useValue?: any,
+ useExisting?: any,
+ useFactory?: Function,
+ deps?: Object[],
+ multi?: boolean
+ }): Provider;
+
+
+
+ /**
+ * A unique object used for retrieving items from the {@link Injector}.
+ *
+ * Keys have:
+ * - a system-wide unique `id`.
+ * - a `token`.
+ *
+ * `Key` is used internally by {@link Injector} because its system-wide unique `id` allows the
+ * injector to store created objects in a more efficient way.
+ *
+ * `Key` should not be created directly. {@link Injector} creates keys automatically when resolving
+ * providers.
+ */
+ class Key {
+
+ /**
+ * Private
+ */
+ constructor(token: Object, id: number);
+
+ /**
+ * Retrieves a `Key` for a token.
+ */
+ static get(token: Object): Key;
+
+ /**
+ * @returns the number of keys registered in the system.
+ */
+ static numberOfKeys: number;
+
+ token: Object;
+
+ id: number;
+
+ /**
+ * Returns a stringified token.
+ */
+ displayName: string;
+
+ }
+
+
+ /**
+ * Type literals is a Dart-only feature. This is here only so we can x-compile
+ * to multiple languages.
+ */
+ class TypeLiteral {
+
+ type: any;
+
+ }
+
+
+ /**
+ * Thrown when trying to retrieve a dependency by `Key` from {@link Injector}, but the
+ * {@link Injector} does not have a {@link Provider} for {@link Key}.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/vq8D3FRB9aGbnWJqtEPE?p=preview))
+ *
+ * ```typescript
+ * class A {
+ * constructor(b:B) {}
+ * }
+ *
+ * expect(() => Injector.resolveAndCreate([A])).toThrowError();
+ * ```
+ */
+ class NoProviderError extends AbstractProviderError {
+
+ constructor(injector: Injector, key: Key);
+
+ }
+
+
+ /**
+ * Base class for all errors arising from misconfigured providers.
+ */
+ class AbstractProviderError extends BaseException {
+
+ constructor(injector: Injector, key: Key, constructResolvingMessage: Function);
+
+ addKey(injector: Injector, key: Key): void;
+
+ context: any;
+
+ }
+
+
+ /**
+ * Thrown when dependencies form a cycle.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/wYQdNos0Tzql3ei1EV9j?p=info))
+ *
+ * ```typescript
+ * var injector = Injector.resolveAndCreate([
+ * provide("one", {useFactory: (two) => "two", deps: [[new Inject("two")]]}),
+ * provide("two", {useFactory: (one) => "one", deps: [[new Inject("one")]]})
+ * ]);
+ *
+ * expect(() => injector.get("one")).toThrowError();
+ * ```
+ *
+ * Retrieving `A` or `B` throws a `CyclicDependencyError` as the graph above cannot be constructed.
+ */
+ class CyclicDependencyError extends AbstractProviderError {
+
+ constructor(injector: Injector, key: Key);
+
+ }
+
+
+ /**
+ * Thrown when a constructing type returns with an Error.
+ *
+ * The `InstantiationError` class contains the original error plus the dependency graph which caused
+ * this object to be instantiated.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/7aWYdcqTQsP0eNqEdUAf?p=preview))
+ *
+ * ```typescript
+ * class A {
+ * constructor() {
+ * throw new Error('message');
+ * }
+ * }
+ *
+ * var injector = Injector.resolveAndCreate([A]);
+ *
+ * try {
+ * injector.get(A);
+ * } catch (e) {
+ * expect(e instanceof InstantiationError).toBe(true);
+ * expect(e.originalException.message).toEqual("message");
+ * expect(e.originalStack).toBeDefined();
+ * }
+ * ```
+ */
+ class InstantiationError extends WrappedException {
+
+ constructor(injector: Injector, originalException: any, originalStack: any, key: Key);
+
+ addKey(injector: Injector, key: Key): void;
+
+ wrapperMessage: string;
+
+ causeKey: Key;
+
+ context: any;
+
+ }
+
+
+ /**
+ * Thrown when an object other then {@link Provider} (or `Type`) is passed to {@link Injector}
+ * creation.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/YatCFbPAMCL0JSSQ4mvH?p=preview))
+ *
+ * ```typescript
+ * expect(() => Injector.resolveAndCreate(["not a type"])).toThrowError();
+ * ```
+ */
+ class InvalidProviderError extends BaseException {
+
+ constructor(provider: any);
+
+ }
+
+
+ /**
+ * Thrown when the class has no annotation information.
+ *
+ * Lack of annotation information prevents the {@link Injector} from determining which dependencies
+ * need to be injected into the constructor.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/rHnZtlNS7vJOPQ6pcVkm?p=preview))
+ *
+ * ```typescript
+ * class A {
+ * constructor(b) {}
+ * }
+ *
+ * expect(() => Injector.resolveAndCreate([A])).toThrowError();
+ * ```
+ *
+ * This error is also thrown when the class not marked with {@link Injectable} has parameter types.
+ *
+ * ```typescript
+ * class B {}
+ *
+ * class A {
+ * constructor(b:B) {} // no information about the parameter types of A is available at runtime.
+ * }
+ *
+ * expect(() => Injector.resolveAndCreate([A,B])).toThrowError();
+ * ```
+ */
+ class NoAnnotationError extends BaseException {
+
+ constructor(typeOrFunc: any, params: any[][]);
+
+ }
+
+
+ /**
+ * Thrown when getting an object by index.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/bRs0SX2OTQiJzqvjgl8P?p=preview))
+ *
+ * ```typescript
+ * class A {}
+ *
+ * var injector = Injector.resolveAndCreate([A]);
+ *
+ * expect(() => injector.getAt(100)).toThrowError();
+ * ```
+ */
+ class OutOfBoundsError extends BaseException {
+
+ constructor(index: any);
+
+ }
+
+
+ /**
+ * Creates a token that can be used in a DI Provider.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/Ys9ezXpj2Mnoy3Uc8KBp?p=preview))
+ *
+ * ```typescript
+ * var t = new OpaqueToken("value");
+ *
+ * var injector = Injector.resolveAndCreate([
+ * provide(t, {useValue: "providedValue"})
+ * ]);
+ *
+ * expect(injector.get(t)).toEqual("bindingValue");
+ * ```
+ *
+ * Using an `OpaqueToken` is preferable to using strings as tokens because of possible collisions
+ * caused by multiple providers using the same string as two different tokens.
+ *
+ * Using an `OpaqueToken` is preferable to using an `Object` as tokens because it provides better
+ * error messages.
+ */
+ class OpaqueToken {
+
+ constructor(_desc: string);
+
+ toString(): string;
+
+ }
+
+
+ /**
+ * Factory for creating {@link InjectMetadata}.
+ */
+ interface InjectFactory {
+
+ new(token: any): InjectMetadata;
+
+ (token: any): any;
+
+ }
+
+
+ /**
+ * Factory for creating {@link OptionalMetadata}.
+ */
+ interface OptionalFactory {
+
+ new(): OptionalMetadata;
+
+ (): any;
+
+ }
+
+
+ /**
+ * Factory for creating {@link InjectableMetadata}.
+ */
+ interface InjectableFactory {
+
+ new(): InjectableMetadata;
+
+ (): any;
+
+ }
+
+
+ /**
+ * Factory for creating {@link SelfMetadata}.
+ */
+ interface SelfFactory {
+
+ new(): SelfMetadata;
+
+ (): any;
+
+ }
+
+
+ /**
+ * Factory for creating {@link HostMetadata}.
+ */
+ interface HostFactory {
+
+ new(): HostMetadata;
+
+ (): any;
+
+ }
+
+
+ /**
+ * Factory for creating {@link SkipSelfMetadata}.
+ */
+ interface SkipSelfFactory {
+
+ new(): SkipSelfMetadata;
+
+ (): any;
+
+ }
+
+
+ /**
+ * Factory for creating {@link InjectMetadata}.
+ */
+ var Inject: InjectFactory;
+
+
+
+ /**
+ * Factory for creating {@link OptionalMetadata}.
+ */
+ var Optional: OptionalFactory;
+
+
+
+ /**
+ * Factory for creating {@link InjectableMetadata}.
+ */
+ var Injectable: InjectableFactory;
+
+
+
+ /**
+ * Factory for creating {@link SelfMetadata}.
+ */
+ var Self: SelfFactory;
+
+
+
+ /**
+ * Factory for creating {@link HostMetadata}.
+ */
+ var Host: HostFactory;
+
+
+
+ /**
+ * Factory for creating {@link SkipSelfMetadata}.
+ */
+ var SkipSelf: SkipSelfFactory;
+
+
+
+ /**
+ * Runtime representation of a type that is constructable (non-abstract).
+ */
+ interface ConcreteType extends Type {
+
+ new(...args: any[]): any;
+
+ }
+
+
+ /**
+ *
+ * Runtime representation a type that a Component or other object is instances of.
+ *
+ * An example of a `Type` is `MyCustomComponent` class, which in JavaScript is be represented by
+ * the `MyCustomComponent` constructor function.
+ */
+ interface Type extends Function {
+
+ }
+
+
+ /**
+ * Use by directives and components to emit custom Events.
+ *
+ * ### Examples
+ *
+ * In the following example, `Zippy` alternatively emits `open` and `close` events when its
+ * title gets clicked:
+ *
+ * ```
+ * @Component({
+ * selector: 'zippy',
+ * template: `
+ *
+ *
Toggle
+ *
+ *
+ *
= new EventEmitter();
+ * @Output() close: EventEmitter = new EventEmitter();
+ *
+ * toggle() {
+ * this.visible = !this.visible;
+ * if (this.visible) {
+ * this.open.emit(null);
+ * } else {
+ * this.close.emit(null);
+ * }
+ * }
+ * }
+ * ```
+ *
+ * Use Rx.Observable but provides an adapter to make it work as specified here:
+ * https://github.com/jhusain/observable-spec
+ *
+ * Once a reference implementation of the spec is available, switch to it.
+ */
+ class EventEmitter extends Subject {
+
+ /**
+ * Creates an instance of [EventEmitter], which depending on [isAsync],
+ * delivers events synchronously or asynchronously.
+ */
+ constructor(isAsync?: boolean);
+
+ emit(value: T): void;
+
+ /**
+ * @deprecated - use .emit(value) instead
+ */
+ next(value: any): void;
+
+ subscribe(generatorOrNext?: any, error?: any, complete?: any): any;
+
+ }
+
+
+ /**
+ * Wraps an exception and provides additional context or information.
+ */
+ class WrappedException extends Error {
+
+ constructor(_wrapperMessage: string, _originalException: any, _originalStack?: any, _context?: any);
+
+ wrapperMessage: string;
+
+ wrapperStack: any;
+
+ originalException: any;
+
+ originalStack: any;
+
+ context: any;
+
+ message: string;
+
+ toString(): string;
+
+ }
+
+
+ /**
+ * Provides a hook for centralized exception handling.
+ *
+ * The default implementation of `ExceptionHandler` prints error messages to the `Console`. To
+ * intercept error handling,
+ * write a custom exception handler that replaces this default as appropriate for your app.
+ *
+ * ### Example
+ *
+ * ```javascript
+ *
+ * class MyExceptionHandler implements ExceptionHandler {
+ * call(error, stackTrace = null, reason = null) {
+ * // do something with the exception
+ * }
+ * }
+ *
+ * bootstrap(MyApp, [provide(ExceptionHandler, {useClass: MyExceptionHandler})])
+ *
+ * ```
+ */
+ class ExceptionHandler {
+
+ constructor(_logger: any, _rethrowException?: boolean);
+
+ static exceptionToString(exception: any, stackTrace?: any, reason?: string): string;
+
+ call(exception: any, stackTrace?: any, reason?: string): void;
+
+ }
+
+
+ /**
+ * An injectable service for executing work inside or outside of the Angular zone.
+ *
+ * The most common use of this service is to optimize performance when starting a work consisting of
+ * one or more asynchronous tasks that don't require UI updates or error handling to be handled by
+ * Angular. Such tasks can be kicked off via {@link #runOutsideAngular} and if needed, these tasks
+ * can reenter the Angular zone via {@link #run}.
+ *
+ *
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/lY9m8HLy7z06vDoUaSN2?p=preview))
+ * ```
+ * import {Component, View, NgZone} from 'angular2/core';
+ * import {NgIf} from 'angular2/common';
+ *
+ * @Component({
+ * selector: 'ng-zone-demo'.
+ * template: `
+ * Demo: NgZone
+ *
+ * Progress: {{progress}}%
+ * Done processing {{label}} of Angular zone!
+ *
+ * Process within Angular zone
+ * Process outside of Angular zone
+ * `,
+ * directives: [NgIf]
+ * })
+ * export class NgZoneDemo {
+ * progress: number = 0;
+ * label: string;
+ *
+ * constructor(private _ngZone: NgZone) {}
+ *
+ * // Loop inside the Angular zone
+ * // so the UI DOES refresh after each setTimeout cycle
+ * processWithinAngularZone() {
+ * this.label = 'inside';
+ * this.progress = 0;
+ * this._increaseProgress(() => console.log('Inside Done!'));
+ * }
+ *
+ * // Loop outside of the Angular zone
+ * // so the UI DOES NOT refresh after each setTimeout cycle
+ * processOutsideOfAngularZone() {
+ * this.label = 'outside';
+ * this.progress = 0;
+ * this._ngZone.runOutsideAngular(() => {
+ * this._increaseProgress(() => {
+ * // reenter the Angular zone and display done
+ * this._ngZone.run(() => {console.log('Outside Done!') });
+ * }}));
+ * }
+ *
+ *
+ * _increaseProgress(doneCallback: () => void) {
+ * this.progress += 1;
+ * console.log(`Current progress: ${this.progress}%`);
+ *
+ * if (this.progress < 100) {
+ * window.setTimeout(() => this._increaseProgress(doneCallback)), 10)
+ * } else {
+ * doneCallback();
+ * }
+ * }
+ * }
+ * ```
+ */
+ class NgZone {
+
+ /**
+ * @param {bool} enableLongStackTrace whether to enable long stack trace. They should only be
+ * enabled in development mode as they significantly impact perf.
+ */
+ constructor({enableLongStackTrace}: any);
+
+ /**
+ * Sets the zone hook that is called just before a browser task that is handled by Angular
+ * executes.
+ *
+ * The hook is called once per browser task that is handled by Angular.
+ *
+ * Setting the hook overrides any previously set hook.
+ *
+ * @deprecated this API will be removed in the future. Use `onTurnStart` instead.
+ */
+ overrideOnTurnStart(onTurnStartHook: ZeroArgFunction): void;
+
+ /**
+ * Notifies subscribers just before Angular event turn starts.
+ *
+ * Emits an event once per browser task that is handled by Angular.
+ */
+ onTurnStart: /* Subject */ any;
+
+ /**
+ * Sets the zone hook that is called immediately after Angular zone is done processing the current
+ * task and any microtasks scheduled from that task.
+ *
+ * This is where we typically do change-detection.
+ *
+ * The hook is called once per browser task that is handled by Angular.
+ *
+ * Setting the hook overrides any previously set hook.
+ *
+ * @deprecated this API will be removed in the future. Use `onTurnDone` instead.
+ */
+ overrideOnTurnDone(onTurnDoneHook: ZeroArgFunction): void;
+
+ /**
+ * Notifies subscribers immediately after Angular zone is done processing
+ * the current turn and any microtasks scheduled from that turn.
+ *
+ * Used by Angular as a signal to kick off change-detection.
+ */
+ onTurnDone: any;
+
+ /**
+ * Sets the zone hook that is called immediately after the `onTurnDone` callback is called and any
+ * microstasks scheduled from within that callback are drained.
+ *
+ * `onEventDoneFn` is executed outside Angular zone, which means that we will no longer attempt to
+ * sync the UI with any model changes that occur within this callback.
+ *
+ * This hook is useful for validating application state (e.g. in a test).
+ *
+ * Setting the hook overrides any previously set hook.
+ *
+ * @deprecated this API will be removed in the future. Use `onEventDone` instead.
+ */
+ overrideOnEventDone(onEventDoneFn: ZeroArgFunction, opt_waitForAsync?: boolean): void;
+
+ /**
+ * Notifies subscribers immediately after the final `onTurnDone` callback
+ * before ending VM event.
+ *
+ * This event is useful for validating application state (e.g. in a test).
+ */
+ onEventDone: any;
+
+ /**
+ * Whether there are any outstanding microtasks.
+ */
+ hasPendingMicrotasks: boolean;
+
+ /**
+ * Whether there are any outstanding timers.
+ */
+ hasPendingTimers: boolean;
+
+ /**
+ * Whether there are any outstanding asychnronous tasks of any kind that are
+ * scheduled to run within Angular zone.
+ *
+ * Useful as a signal of UI stability. For example, when a test reaches a
+ * point when [hasPendingAsyncTasks] is `false` it might be a good time to run
+ * test expectations.
+ */
+ hasPendingAsyncTasks: boolean;
+
+ /**
+ * Sets the zone hook that is called when an error is thrown in the Angular zone.
+ *
+ * Setting the hook overrides any previously set hook.
+ *
+ * @deprecated this API will be removed in the future. Use `onError` instead.
+ */
+ overrideOnErrorHandler(errorHandler: ErrorHandlingFn): void;
+
+ onError: any;
+
+ /**
+ * Executes the `fn` function synchronously within the Angular zone and returns value returned by
+ * the function.
+ *
+ * Running functions via `run` allows you to reenter Angular zone from a task that was executed
+ * outside of the Angular zone (typically started via {@link #runOutsideAngular}).
+ *
+ * Any future tasks or microtasks scheduled from within this function will continue executing from
+ * within the Angular zone.
+ */
+ run(fn: () => any): any;
+
+ /**
+ * Executes the `fn` function synchronously in Angular's parent zone and returns value returned by
+ * the function.
+ *
+ * Running functions via `runOutsideAngular` allows you to escape Angular's zone and do work that
+ * doesn't trigger Angular change-detection or is subject to Angular's error handling.
+ *
+ * Any future tasks or microtasks scheduled from within this function will continue executing from
+ * outside of the Angular zone.
+ *
+ * Use {@link #run} to reenter the Angular zone and do work that updates the application model.
+ */
+ runOutsideAngular(fn: () => any): any;
+
+ }
+
+
+ /**
+ * Interface for a function with zero arguments.
+ */
+ interface ZeroArgFunction {
+
+ (): void;
+
+ }
+
+
+ /**
+ * Function type for an error handler, which takes an error and a stack trace.
+ */
+ interface ErrorHandlingFn {
+
+ (error: any, stackTrace: any): void;
+
+ }
+
+
+ /**
+ * Stores error information; delivered via [NgZone.onError] stream.
+ */
+ class NgZoneError {
+
+ constructor(error: any, stackTrace: any);
+
+ error: any;
+
+ stackTrace: any;
+
+ }
+
+
+ /**
+ * A dispatcher that relays all events that occur in a Render View.
+ *
+ * Use {@link Renderer#setEventDispatcher} to register a dispatcher for a particular Render View.
+ */
+ interface RenderEventDispatcher {
+
+ /**
+ * Called when Event called `eventName` was triggered on an Element with an Event Binding for this
+ * Event.
+ *
+ * `elementIndex` specifies the depth-first index of the Element in the Render View.
+ *
+ * `locals` is a map for local variable to value mapping that should be used when evaluating the
+ * Event Binding expression.
+ *
+ * Returns `false` if `preventDefault` should be called to stop the default behavior of the Event
+ * in the Rendering Context.
+ */
+ dispatchRenderEvent(elementIndex: number, eventName: string, locals: Map): boolean;
+
+ }
+
+
+ /**
+ * Injectable service that provides a low-level interface for modifying the UI.
+ *
+ * Use this service to bypass Angular's templating and make custom UI changes that can't be
+ * expressed declaratively. For example if you need to set a property or an attribute whose name is
+ * not statically known, use {@link #setElementProperty} or {@link #setElementAttribute}
+ * respectively.
+ *
+ * If you are implementing a custom renderer, you must implement this interface.
+ *
+ * The default Renderer implementation is `DomRenderer`. Also available is `WebWorkerRenderer`.
+ */
+ abstract class Renderer {
+
+ /**
+ * Registers a component template represented as arrays of {@link RenderTemplateCmd}s and styles
+ * with the Renderer.
+ *
+ * Once a template is registered it can be referenced via {@link RenderBeginComponentCmd} when
+ * {@link #createProtoView creating Render ProtoView}.
+ */
+ registerComponentTemplate(template: RenderComponentTemplate): void;
+
+ /**
+ * Creates a {@link RenderProtoViewRef} from an array of {@link RenderTemplateCmd}`s.
+ */
+ createProtoView(componentTemplateId: string, cmds: RenderTemplateCmd[]): RenderProtoViewRef;
+
+ /**
+ * Creates a Root Host View based on the provided `hostProtoViewRef`.
+ *
+ * `fragmentCount` is the number of nested {@link RenderFragmentRef}s in this View. This parameter
+ * is non-optional so that the renderer can create a result synchronously even when application
+ * runs in a different context (e.g. in a Web Worker).
+ *
+ * `hostElementSelector` is a (CSS) selector for querying the main document to find the Host
+ * Element. The newly created Root Host View should be attached to this element.
+ *
+ * Returns an instance of {@link RenderViewWithFragments}, representing the Render View.
+ */
+ createRootHostView(hostProtoViewRef: RenderProtoViewRef, fragmentCount: number, hostElementSelector: string): RenderViewWithFragments;
+
+ /**
+ * Creates a Render View based on the provided `protoViewRef`.
+ *
+ * `fragmentCount` is the number of nested {@link RenderFragmentRef}s in this View. This parameter
+ * is non-optional so that the renderer can create a result synchronously even when application
+ * runs in a different context (e.g. in a Web Worker).
+ *
+ * Returns an instance of {@link RenderViewWithFragments}, representing the Render View.
+ */
+ createView(protoViewRef: RenderProtoViewRef, fragmentCount: number): RenderViewWithFragments;
+
+ /**
+ * Destroys a Render View specified via `viewRef`.
+ *
+ * This operation should be performed only on a View that has already been dehydrated and
+ * all of its Render Fragments have been detached.
+ *
+ * Destroying a View indicates to the Renderer that this View is not going to be referenced in any
+ * future operations. If the Renderer created any renderer-specific objects for this View, these
+ * objects should now be destroyed to prevent memory leaks.
+ */
+ destroyView(viewRef: RenderViewRef): void;
+
+ /**
+ * Attaches the Nodes of a Render Fragment after the last Node of `previousFragmentRef`.
+ */
+ attachFragmentAfterFragment(previousFragmentRef: RenderFragmentRef, fragmentRef: RenderFragmentRef): void;
+
+ /**
+ * Attaches the Nodes of the Render Fragment after an Element.
+ */
+ attachFragmentAfterElement(elementRef: RenderElementRef, fragmentRef: RenderFragmentRef): void;
+
+ /**
+ * Detaches the Nodes of a Render Fragment from their parent.
+ *
+ * This operations should be called only on a View that has been already
+ * {@link #dehydrateView dehydrated}.
+ */
+ detachFragment(fragmentRef: RenderFragmentRef): void;
+
+ /**
+ * Notifies a custom Renderer to initialize a Render View.
+ *
+ * This method is called by Angular after a Render View has been created, or when a previously
+ * dehydrated Render View is about to be reused.
+ */
+ hydrateView(viewRef: RenderViewRef): void;
+
+ /**
+ * Notifies a custom Renderer that a Render View is no longer active.
+ *
+ * This method is called by Angular before a Render View will be destroyed, or when a hydrated
+ * Render View is about to be put into a pool for future reuse.
+ */
+ dehydrateView(viewRef: RenderViewRef): void;
+
+ /**
+ * Returns the underlying native element at the specified `location`, or `null` if direct access
+ * to native elements is not supported (e.g. when the application runs in a web worker).
+ *
+ *
+ *
+ *
+ * Use this api as the last resort when direct access to DOM is needed. Use templating and
+ * data-binding, or other {@link Renderer} methods instead.
+ *
+ *
+ * Relying on direct DOM access creates tight coupling between your application and rendering
+ * layers which will make it impossible to separate the two and deploy your application into a
+ * web worker.
+ *
+ *
+ * `,
+ * directives: [ParentComponent, ChildComponent]
+ * })
+ * export class App {
+ * }
+ *
+ * bootstrap(App).catch(err => console.error(err));
+ * ```
+ */
+ interface AfterContentInit {
+
+ ngAfterContentInit(): void;
+
+ }
+
+
+ /**
+ * Implement this interface to get notified after every check of your directive's content.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/tGdrytNEKQnecIPkD7NU?p=preview))
+ *
+ * ```typescript
+ * @Component({selector: 'child-cmp', template: `{{where}} child`})
+ * class ChildComponent {
+ * @Input() where: string;
+ * }
+ *
+ * @Component({selector: 'parent-cmp', template: `
+ * Toggle content child
+ * `,
+ * directives: [NgIf, ParentComponent, ChildComponent]
+ * })
+ * export class App {
+ * hasContent = true;
+ * }
+ *
+ * bootstrap(App).catch(err => console.error(err));
+ * ```
+ */
+ interface AfterContentChecked {
+
+ ngAfterContentChecked(): void;
+
+ }
+
+
+ /**
+ * Implement this interface to get notified when your component's view has been fully initialized.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/LhTKVMEM0fkJgyp4CI1W?p=preview))
+ *
+ * ```typescript
+ * @Component({selector: 'child-cmp', template: `{{where}} child`})
+ * class ChildComponent {
+ * @Input() where: string;
+ * }
+ *
+ * @Component({
+ * selector: 'parent-cmp',
+ * template: `Toggle view child
+ * myProp = {{myProp}}
`
+ * })
+ * class MyComponent implements OnChanges {
+ * @Input() myProp: any;
+ *
+ * ngOnChanges(changes: {[propName: string]: SimpleChange}) {
+ * console.log('ngOnChanges - myProp = ' + changes['myProp'].currentValue);
+ * }
+ * }
+ *
+ * @Component({
+ * selector: 'app',
+ * template: `
+ * Change MyComponent
+ * my-component
`
+ * })
+ * class MyComponent implements OnInit, OnDestroy {
+ * ngOnInit() {
+ * console.log('ngOnInit');
+ * }
+ *
+ * ngOnDestroy() {
+ * console.log('ngOnDestroy');
+ * }
+ * }
+ *
+ * @Component({
+ * selector: 'app',
+ * template: `
+ *
+ * {{hasChild ? 'Destroy' : 'Create'}} MyComponent
+ *
+ * my-component
`
+ * })
+ * class MyComponent implements OnInit, OnDestroy {
+ * ngOnInit() {
+ * console.log('ngOnInit');
+ * }
+ *
+ * ngOnDestroy() {
+ * console.log('ngOnDestroy');
+ * }
+ * }
+ *
+ * @Component({
+ * selector: 'app',
+ * template: `
+ *
+ * {{hasChild ? 'Destroy' : 'Create'}} MyComponent
+ *
+ * Changes:
+ * `,
+ * directives: [NgFor]
+ * })
+ * class CustomCheckComponent implements DoCheck {
+ * @Input() list: any[];
+ * differ: any;
+ * logs = [];
+ *
+ * constructor(differs: IterableDiffers) {
+ * this.differ = differs.find([]).create(null);
+ * }
+ *
+ * ngDoCheck() {
+ * var changes = this.differ.diff(this.list);
+ *
+ * if (changes) {
+ * changes.forEachAddedItem(r => this.logs.push('added ' + r.item));
+ * changes.forEachRemovedItem(r => this.logs.push('removed ' + r.item))
+ * }
+ * }
+ * }
+ *
+ * @Component({
+ * selector: 'app',
+ * template: `
+ * Push
+ * Pop
+ * ;
+
+ clearCache(): void;
+
+ }
+
+
+ /**
+ * Service exposing low level API for creating, moving and destroying Views.
+ *
+ * Most applications should use higher-level abstractions like {@link DynamicComponentLoader} and
+ * {@link ViewContainerRef} instead.
+ */
+ abstract class AppViewManager {
+
+ /**
+ * Returns a {@link ViewContainerRef} of the View Container at the specified location.
+ */
+ getViewContainer(location: ElementRef): ViewContainerRef;
+
+ /**
+ * Returns the {@link ElementRef} that makes up the specified Host View.
+ */
+ getHostElement(hostViewRef: HostViewRef): ElementRef;
+
+ /**
+ * Searches the Component View of the Component specified via `hostLocation` and returns the
+ * {@link ElementRef} for the Element identified via a Variable Name `variableName`.
+ *
+ * Throws an exception if the specified `hostLocation` is not a Host Element of a Component, or if
+ * variable `variableName` couldn't be found in the Component View of this Component.
+ */
+ getNamedElementInComponentView(hostLocation: ElementRef, variableName: string): ElementRef;
+
+ /**
+ * Returns the component instance for the provided Host Element.
+ */
+ getComponent(hostLocation: ElementRef): any;
+
+ /**
+ * Creates an instance of a Component and attaches it to the first element in the global View
+ * (usually DOM Document) that matches the component's selector or `overrideSelector`.
+ *
+ * This as a low-level way to bootstrap an application and upgrade an existing Element to a
+ * Host Element. Most applications should use {@link DynamicComponentLoader#loadAsRoot} instead.
+ *
+ * The Component and its View are created based on the `hostProtoViewRef` which can be obtained
+ * by compiling the component with {@link Compiler#compileInHost}.
+ *
+ * Use {@link AppViewManager#destroyRootHostView} to destroy the created Component and it's Host
+ * View.
+ *
+ * ### Example
+ *
+ * ```
+ * @ng.Component({
+ * selector: 'child-component'
+ * })
+ * @ng.View({
+ * template: 'Child'
+ * })
+ * class ChildComponent {
+ *
+ * }
+ *
+ * @ng.Component({
+ * selector: 'my-app'
+ * })
+ * @ng.View({
+ * template: `
+ * Parent (- ) {
+ * items.changes.subscribe(_ => console.log(items.length));
+ * }
+ * }
+ * ```
+ */
+ class QueryList
{
+
+ changes: Observable;
+
+ length: number;
+
+ first: T;
+
+ last: T;
+
+ /**
+ * returns a new array with the passed in function applied to each element.
+ */
+ map(fn: (item: T) => U): U[];
+
+ /**
+ * returns a filtered array.
+ */
+ filter(fn: (item: T) => boolean): T[];
+
+ /**
+ * returns a reduced value.
+ */
+ reduce(fn: (acc: U, item: T) => U, init: U): U;
+
+ /**
+ * converts QueryList into an array
+ */
+ toArray(): T[];
+
+ toString(): string;
+
+ }
+
+
+ /**
+ * Service for instantiating a Component and attaching it to a View at a specified location.
+ */
+ abstract class DynamicComponentLoader {
+
+ /**
+ * Creates an instance of a Component `type` and attaches it to the first element in the
+ * platform-specific global view that matches the component's selector.
+ *
+ * In a browser the platform-specific global view is the main DOM Document.
+ *
+ * If needed, the component's selector can be overridden via `overrideSelector`.
+ *
+ * You can optionally provide `injector` and this {@link Injector} will be used to instantiate the
+ * Component.
+ *
+ * To be notified when this Component instance is destroyed, you can also optionally provide
+ * `onDispose` callback.
+ *
+ * Returns a promise for the {@link ComponentRef} representing the newly created Component.
+ *
+ * ### Example
+ *
+ * ```
+ * @Component({
+ * selector: 'child-component',
+ * template: 'Child'
+ * })
+ * class ChildComponent {
+ * }
+ *
+ * @Component({
+ * selector: 'my-app',
+ * template: 'Parent (
+ * Parent (
+ * Child
+ * )
+ *
+ * ```
+ */
+ loadAsRoot(type: Type, overrideSelector: string, injector: Injector, onDispose?: () => void): Promise;
+
+ /**
+ * Creates an instance of a Component and attaches it to a View Container located inside of the
+ * Component View of another Component instance.
+ *
+ * The targeted Component Instance is specified via its `hostLocation` {@link ElementRef}. The
+ * location within the Component View of this Component Instance is specified via `anchorName`
+ * Template Variable Name.
+ *
+ * You can optionally provide `providers` to configure the {@link Injector} provisioned for this
+ * Component Instance.
+ *
+ * Returns a promise for the {@link ComponentRef} representing the newly created Component.
+ *
+ * ### Example
+ *
+ * ```
+ * @Component({
+ * selector: 'child-component',
+ * template: 'Child'
+ * })
+ * class ChildComponent {
+ * }
+ *
+ * @Component({
+ * selector: 'my-app',
+ * template: 'Parent (
)'
+ * })
+ * class MyApp {
+ * constructor(dcl: DynamicComponentLoader, elementRef: ElementRef) {
+ * dcl.loadIntoLocation(ChildComponent, elementRef, 'child');
+ * }
+ * }
+ *
+ * bootstrap(MyApp);
+ * ```
+ *
+ * Resulting DOM:
+ *
+ * ```
+ *
+ * Parent (
+ *
+ * Child
+ * )
+ *
+ * ```
+ */
+ loadIntoLocation(type: Type, hostLocation: ElementRef, anchorName: string, providers?: ResolvedProvider[]): Promise;
+
+ /**
+ * Creates an instance of a Component and attaches it to the View Container found at the
+ * `location` specified as {@link ElementRef}.
+ *
+ * You can optionally provide `providers` to configure the {@link Injector} provisioned for this
+ * Component Instance.
+ *
+ * Returns a promise for the {@link ComponentRef} representing the newly created Component.
+ *
+ *
+ * ### Example
+ *
+ * ```
+ * @Component({
+ * selector: 'child-component',
+ * template: 'Child'
+ * })
+ * class ChildComponent {
+ * }
+ *
+ * @Component({
+ * selector: 'my-app',
+ * template: 'Parent'
+ * })
+ * class MyApp {
+ * constructor(dcl: DynamicComponentLoader, elementRef: ElementRef) {
+ * dcl.loadNextToLocation(ChildComponent, elementRef);
+ * }
+ * }
+ *
+ * bootstrap(MyApp);
+ * ```
+ *
+ * Resulting DOM:
+ *
+ * ```
+ * Parent
+ * Child
+ * ```
+ */
+ loadNextToLocation(type: Type, location: ElementRef, providers?: ResolvedProvider[]): Promise;
+
+ }
+
+
+ /**
+ * Represents a location in a View that has an injection, change-detection and render context
+ * associated with it.
+ *
+ * An `ElementRef` is created for each element in the Template that contains a Directive, Component
+ * or data-binding.
+ *
+ * An `ElementRef` is backed by a render-specific element. In the browser, this is usually a DOM
+ * element.
+ */
+ abstract class ElementRef implements RenderElementRef {
+
+ /**
+ * The underlying native element or `null` if direct access to native elements is not supported
+ * (e.g. when the application runs in a web worker).
+ *
+ *
+ *
+ *
+ * Use this API as the last resort when direct access to DOM is needed. Use templating and
+ * data-binding provided by Angular instead. Alternatively you take a look at {@link Renderer}
+ * which provides API that can safely be used even when direct access to native elements is not
+ * supported.
+ *
+ *
+ * Relying on direct DOM access creates tight coupling between your application and rendering
+ * layers which will make it impossible to separate the two and deploy your application into a
+ * web worker.
+ *
+ *
` element (or
+ * directive prefixed with `*`) and have the `TemplateRef` for this Embedded View injected into the
+ * constructor of the directive using the `TemplateRef` Token. Alternatively you can query for the
+ * `TemplateRef` from a Component or a Directive via {@link Query}.
+ *
+ * To instantiate Embedded Views based on a Template, use
+ * {@link ViewContainerRef#createEmbeddedView}, which will create the View and attach it to the
+ * View Container.
+ */
+ abstract class TemplateRef {
+
+ /**
+ * The location in the View where the Embedded View logically belongs to.
+ *
+ * The data-binding and injection contexts of Embedded Views created from this `TemplateRef`
+ * inherit from the contexts of this location.
+ *
+ * Typically new Embedded Views are attached to the View Container of this location, but in
+ * advanced use-cases, the View can be attached to a different container while keeping the
+ * data-binding and injection context from the original location.
+ */
+ elementRef: ElementRef;
+
+ /**
+ * Allows you to check if this Embedded Template defines Local Variable with name matching `name`.
+ */
+ hasLocal(name: string): boolean;
+
+ }
+
+
+ /**
+ * Represents an Angular View.
+ *
+ *
+ * A View is a fundamental building block of the application UI. It is the smallest grouping of
+ * Elements which are created and destroyed together.
+ *
+ * Properties of elements in a View can change, but the structure (number and order) of elements in
+ * a View cannot. Changing the structure of Elements can only be done by inserting, moving or
+ * removing nested Views via a {@link ViewContainerRef}. Each View can contain many View Containers.
+ *
+ *
+ * ### Example
+ *
+ * Given this template...
+ *
+ * ```
+ * Count: {{items.length}}
+ *
+ * ```
+ *
+ * ... we have two {@link ProtoViewRef}s:
+ *
+ * Outer {@link ProtoViewRef}:
+ * ```
+ * Count: {{items.length}}
+ *
+ * ```
+ *
+ * Inner {@link ProtoViewRef}:
+ * ```
+ * {{item}}
+ * ```
+ *
+ * Notice that the original template is broken down into two separate {@link ProtoViewRef}s.
+ *
+ * The outer/inner {@link ProtoViewRef}s are then assembled into views like so:
+ *
+ * ```
+ *
+ * Count: 2
+ *
+ * first
+ * second
+ *
+ *
+ * ```
+ */
+ abstract class ViewRef implements HostViewRef {
+
+ /**
+ * Sets `value` of local variable called `variableName` in this View.
+ */
+ setLocal(variableName: string, value: any): void;
+
+ changeDetectorRef: ChangeDetectorRef;
+
+ }
+
+
+ /**
+ * Represents a View containing a single Element that is the Host Element of a {@link Component}
+ * instance.
+ *
+ * A Host View is created for every dynamically created Component that was compiled on its own (as
+ * opposed to as a part of another Component's Template) via {@link Compiler#compileInHost} or one
+ * of the higher-level APIs: {@link AppViewManager#createRootHostView},
+ * {@link AppViewManager#createHostViewInContainer}, {@link ViewContainerRef#createHostView}.
+ */
+ interface HostViewRef {
+
+ }
+
+
+ /**
+ * Represents an Angular ProtoView.
+ *
+ * A ProtoView is a prototypical {@link ViewRef View} that is the result of Template compilation and
+ * is used by Angular to efficiently create an instance of this View based on the compiled Template.
+ *
+ * Most ProtoViews are created and used internally by Angular and you don't need to know about them,
+ * except in advanced use-cases where you compile components yourself via the low-level
+ * {@link Compiler#compileInHost} API.
+ *
+ *
+ * ### Example
+ *
+ * Given this template:
+ *
+ * ```
+ * Count: {{items.length}}
+ *
+ * ```
+ *
+ * Angular desugars and compiles the template into two ProtoViews:
+ *
+ * Outer ProtoView:
+ * ```
+ * Count: {{items.length}}
+ *
+ * ```
+ *
+ * Inner ProtoView:
+ * ```
+ * {{item}}
+ * ```
+ *
+ * Notice that the original template is broken down into two separate ProtoViews.
+ */
+ abstract class ProtoViewRef {
+
+ }
+
+
+ /**
+ * Represents a container where one or more Views can be attached.
+ *
+ * The container can contain two kinds of Views. Host Views, created by instantiating a
+ * {@link Component} via {@link #createHostView}, and Embedded Views, created by instantiating an
+ * {@link TemplateRef Embedded Template} via {@link #createEmbeddedView}.
+ *
+ * The location of the View Container within the containing View is specified by the Anchor
+ * `element`. Each View Container can have only one Anchor Element and each Anchor Element can only
+ * have a single View Container.
+ *
+ * Root elements of Views attached to this container become siblings of the Anchor Element in
+ * the Rendered View.
+ *
+ * To access a `ViewContainerRef` of an Element, you can either place a {@link Directive} injected
+ * with `ViewContainerRef` on the Element, or you obtain it via
+ * {@link AppViewManager#getViewContainer}.
+ *
+ *
+ */
+ abstract class ViewContainerRef {
+
+ /**
+ * Anchor element that specifies the location of this container in the containing View.
+ *
+ */
+ element: ElementRef;
+
+ /**
+ * Destroys all Views in this container.
+ */
+ clear(): void;
+
+ /**
+ * Returns the {@link ViewRef} for the View located in this container at the specified index.
+ */
+ get(index: number): ViewRef;
+
+ /**
+ * Returns the number of Views currently attached to this container.
+ */
+ length: number;
+
+ /**
+ * Instantiates an Embedded View based on the {@link TemplateRef `templateRef`} and inserts it
+ * into this container at the specified `index`.
+ *
+ * If `index` is not specified, the new View will be inserted as the last View in the container.
+ *
+ * Returns the {@link ViewRef} for the newly created View.
+ */
+ createEmbeddedView(templateRef: TemplateRef, index?: number): ViewRef;
+
+ /**
+ * Instantiates a single {@link Component} and inserts its Host View into this container at the
+ * specified `index`.
+ *
+ * The component is instantiated using its {@link ProtoViewRef `protoView`} which can be
+ * obtained via {@link Compiler#compileInHost}.
+ *
+ * If `index` is not specified, the new View will be inserted as the last View in the container.
+ *
+ * You can optionally specify `dynamicallyCreatedProviders`, which configure the {@link Injector}
+ * that will be created for the Host View.
+ *
+ * Returns the {@link HostViewRef} of the Host View created for the newly instantiated Component.
+ */
+ createHostView(protoViewRef?: ProtoViewRef, index?: number, dynamicallyCreatedProviders?: ResolvedProvider[]): HostViewRef;
+
+ /**
+ * Inserts a View identified by a {@link ViewRef} into the container at the specified `index`.
+ *
+ * If `index` is not specified, the new View will be inserted as the last View in the container.
+ *
+ * Returns the inserted {@link ViewRef}.
+ */
+ insert(viewRef: ViewRef, index?: number): ViewRef;
+
+ /**
+ * Returns the index of the View, specified via {@link ViewRef}, within the current container or
+ * `-1` if this container doesn't contain the View.
+ */
+ indexOf(viewRef: ViewRef): number;
+
+ /**
+ * Destroys a View attached to this container at the specified `index`.
+ *
+ * If `index` is not specified, the last View in the container will be removed.
+ */
+ remove(index?: number): void;
+
+ /**
+ * Use along with {@link #insert} to move a View within the current container.
+ *
+ * If the `index` param is omitted, the last {@link ViewRef} is detached.
+ */
+ detach(index?: number): ViewRef;
+
+ }
+
+
+ /**
+ * Represents an instance of a Component created via {@link DynamicComponentLoader}.
+ *
+ * `ComponentRef` provides access to the Component Instance as well other objects related to this
+ * Component Instance and allows you to destroy the Component Instance via the {@link #dispose}
+ * method.
+ */
+ abstract class ComponentRef {
+
+ /**
+ * The injector provided {@link DynamicComponentLoader#loadAsRoot}.
+ *
+ * TODO(i): this api is useless and should be replaced by an injector retrieved from
+ * the HostElementRef, which is currently not possible.
+ */
+ injector: Injector;
+
+ /**
+ * Location of the Host Element of this Component Instance.
+ */
+ location: ElementRef;
+
+ /**
+ * The instance of the Component.
+ */
+ instance: any;
+
+ /**
+ * The user defined component type, represented via the constructor function.
+ *
+ *
+ */
+ componentType: Type;
+
+ /**
+ * The {@link ViewRef} of the Host View of this Component instance.
+ */
+ hostView: HostViewRef;
+
+ /**
+ * Destroys the component instance and all of the data structures associated with it.
+ *
+ * TODO(i): rename to destroy to be consistent with AppViewManager and ViewContainerRef
+ */
+ dispose(): void;
+
+ }
+
+
+ /**
+ * The Testability service provides testing hooks that can be accessed from
+ * the browser and by services such as Protractor. Each bootstrapped Angular
+ * application on the page will have an instance of Testability.
+ */
+ class Testability {
+
+ constructor(_ngZone: NgZone);
+
+ increasePendingRequestCount(): number;
+
+ decreasePendingRequestCount(): number;
+
+ isStable(): boolean;
+
+ whenStable(callback: Function): void;
+
+ getPendingRequestCount(): number;
+
+ isAngularEventPending(): boolean;
+
+ findBindings(using: any, provider: string, exactMatch: boolean): any[];
+
+ findProviders(using: any, provider: string, exactMatch: boolean): any[];
+
+ }
+
+
+ /**
+ * A global registry of {@link Testability} instances for specific elements.
+ */
+ class TestabilityRegistry {
+
+ constructor();
+
+ registerApplication(token: any, testability: Testability): void;
+
+ getTestability(elem: any): Testability;
+
+ getAllTestabilities(): Testability[];
+
+ findTestabilityInTree(elem: Node, findInAncestors?: boolean): Testability;
+
+ }
+
+
+ /**
+ * Adapter interface for retrieving the `Testability` service associated for a
+ * particular context.
+ */
+ interface GetTestability {
+
+ addToWindow(registry: TestabilityRegistry): void;
+
+ findTestabilityInTree(registry: TestabilityRegistry, elem: any, findInAncestors: boolean): Testability;
+
+ }
+
+
+ /**
+ * Set the {@link GetTestability} implementation used by the Angular testing framework.
+ */
+ function setTestabilityGetter(getter: GetTestability): void;
+
+
+
+ /**
+ * Describes within the change detector which strategy will be used the next time change
+ * detection is triggered.
+ */
+ enum ChangeDetectionStrategy {
+
+ /**
+ * `CheckedOnce` means that after calling detectChanges the mode of the change detector
+ * will become `Checked`.
+ */
+ CheckOnce,
+
+ /**
+ * `Checked` means that the change detector should be skipped until its mode changes to
+ * `CheckOnce`.
+ */
+ Checked,
+
+ /**
+ * `CheckAlways` means that after calling detectChanges the mode of the change detector
+ * will remain `CheckAlways`.
+ */
+ CheckAlways,
+
+ /**
+ * `Detached` means that the change detector sub tree is not a part of the main tree and
+ * should be skipped.
+ */
+ Detached,
+
+ /**
+ * `OnPush` means that the change detector's mode will be set to `CheckOnce` during hydration.
+ */
+ OnPush,
+
+ /**
+ * `Default` means that the change detector's mode will be set to `CheckAlways` during hydration.
+ */
+ Default,
+
+ /**
+ * This is an experimental feature. Works only in Dart.
+ */
+ OnPushObserve
+ }
+
+
+
+ /**
+ * An error thrown if application changes model breaking the top-down data flow.
+ *
+ * This exception is only thrown in dev mode.
+ *
+ *
+ *
+ * ### Example
+ *
+ * ```typescript
+ * @Component({
+ * selector: 'parent',
+ * template: `
+ *
+ * `,
+ * directives: [Cmp]
+ * })
+ * class App {
+ * }
+ *
+ * bootstrap(App);
+ * ```
+ */
+ markForCheck(): void;
+
+ /**
+ * Detaches the change detector from the change detector tree.
+ *
+ * The detached change detector will not be checked until it is reattached.
+ *
+ * This can also be used in combination with {@link ChangeDetectorRef#detectChanges} to implement
+ * local change
+ * detection checks.
+ *
+ *
+ *
+ *
+ * ### Example
+ *
+ * The following example defines a component with a large list of readonly data.
+ * Imagine the data changes constantly, many times per second. For performance reasons,
+ * we want to check and update the list every five seconds. We can do that by detaching
+ * the component's change detector and doing a local check every five seconds.
+ *
+ * ```typescript
+ * class DataProvider {
+ * // in a real application the returned data will be different every time
+ * get data() {
+ * return [1,2,3,4,5];
+ * }
+ * }
+ *
+ * @Component({
+ * selector: 'giant-list',
+ * template: `
+ * Data {{d}}
+ * `,
+ * directives: [NgFor]
+ * })
+ * class GiantList {
+ * constructor(private ref: ChangeDetectorRef, private dataProvider:DataProvider) {
+ * ref.detach();
+ * setInterval(() => {
+ * this.ref.detectChanges();
+ * }, 5000);
+ * }
+ * }
+ *
+ * @Component({
+ * selector: 'app',
+ * providers: [DataProvider],
+ * template: `
+ *
+ * `,
+ * directives: [GiantList]
+ * })
+ * class App {
+ * }
+ *
+ * bootstrap(App);
+ * ```
+ */
+ detach(): void;
+
+ /**
+ * Checks the change detector and its children.
+ *
+ * This can also be used in combination with {@link ChangeDetectorRef#detach} to implement local
+ * change detection
+ * checks.
+ *
+ *
+ *
+ *
+ * ### Example
+ *
+ * The following example defines a component with a large list of readonly data.
+ * Imagine, the data changes constantly, many times per second. For performance reasons,
+ * we want to check and update the list every five seconds.
+ *
+ * We can do that by detaching the component's change detector and doing a local change detection
+ * check
+ * every five seconds.
+ *
+ * See {@link ChangeDetectorRef#detach} for more information.
+ */
+ detectChanges(): void;
+
+ /**
+ * Checks the change detector and its children, and throws if any changes are detected.
+ *
+ * This is used in development mode to verify that running change detection doesn't introduce
+ * other changes.
+ */
+ checkNoChanges(): void;
+
+ /**
+ * Reattach the change detector to the change detector tree.
+ *
+ * This also marks OnPush ancestors as to be checked. This reattached change detector will be
+ * checked during the next change detection run.
+ *
+ *
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/aUhZha?p=preview))
+ *
+ * The following example creates a component displaying `live` data. The component will detach
+ * its change detector from the main change detector tree when the component's live property
+ * is set to false.
+ *
+ * ```typescript
+ * class DataProvider {
+ * data = 1;
+ *
+ * constructor() {
+ * setInterval(() => {
+ * this.data = this.data * 2;
+ * }, 500);
+ * }
+ * }
+ *
+ * @Component({
+ * selector: 'live-data',
+ * inputs: ['live'],
+ * template: `Data: {{dataProvider.data}}`
+ * })
+ * class LiveData {
+ * constructor(private ref: ChangeDetectorRef, private dataProvider:DataProvider) {}
+ *
+ * set live(value) {
+ * if (value)
+ * this.ref.reattach();
+ * else
+ * this.ref.detach();
+ * }
+ * }
+ *
+ * @Component({
+ * selector: 'app',
+ * providers: [DataProvider],
+ * template: `
+ * Live Update:
+ * `,
+ * directives: [LiveData, FORM_DIRECTIVES]
+ * })
+ * class App {
+ * live = true;
+ * }
+ *
+ * bootstrap(App);
+ * ```
+ */
+ reattach(): void;
+
+ }
+
+
+ /**
+ * Indicates that the result of a {@link PipeMetadata} transformation has changed even though the
+ * reference
+ * has not changed.
+ *
+ * The wrapped value will be unwrapped by change detection, and the unwrapped value will be stored.
+ *
+ * Example:
+ *
+ * ```
+ * if (this._latestValue === this._latestReturnedValue) {
+ * return this._latestReturnedValue;
+ * } else {
+ * this._latestReturnedValue = this._latestValue;
+ * return WrappedValue.wrap(this._latestValue); // this will force update
+ * }
+ * ```
+ */
+ class WrappedValue {
+
+ constructor(wrapped: any);
+
+ static wrap(value: any): WrappedValue;
+
+ wrapped: any;
+
+ }
+
+
+ /**
+ * Represents a basic change from a previous to a new value.
+ */
+ class SimpleChange {
+
+ constructor(previousValue: any, currentValue: any);
+
+ previousValue: any;
+
+ currentValue: any;
+
+ /**
+ * Check whether the new value is the first value assigned.
+ */
+ isFirstChange(): boolean;
+
+ }
+
+
+ /**
+ * To create a Pipe, you must implement this interface.
+ *
+ * Angular invokes the `transform` method with the value of a binding
+ * as the first argument, and any parameters as the second argument in list form.
+ *
+ * ## Syntax
+ *
+ * `value | pipeName[:arg0[:arg1...]]`
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/f5oyIked9M2cKzvZNKHV?p=preview))
+ *
+ * The `RepeatPipe` below repeats the value as many times as indicated by the first argument:
+ *
+ * ```
+ * import {Pipe, PipeTransform} from 'angular2/core';
+ *
+ * @Pipe({name: 'repeat'})
+ * export class RepeatPipe implements PipeTransform {
+ * transform(value: any, args: any[] = []) {
+ * if (args.length == 0) {
+ * throw new Error('repeat pipe requires one argument');
+ * }
+ * let times: number = args[0];
+ * return value.repeat(times);
+ * }
+ * }
+ * ```
+ *
+ * Invoking `{{ 'ok' | repeat:3 }}` in a template produces `okokok`.
+ */
+ interface PipeTransform {
+
+ transform(value: any, args: any[]): any;
+
+ }
+
+
+ /**
+ * A repository of different iterable diffing strategies used by NgFor, NgClass, and others.
+ */
+ class IterableDiffers {
+
+ constructor(factories: IterableDifferFactory[]);
+
+ static create(factories: IterableDifferFactory[], parent?: IterableDiffers): IterableDiffers;
+
+ /**
+ * Takes an array of {@link IterableDifferFactory} and returns a provider used to extend the
+ * inherited {@link IterableDiffers} instance with the provided factories and return a new
+ * {@link IterableDiffers} instance.
+ *
+ * The following example shows how to extend an existing list of factories,
+ * which will only be applied to the injector for this component and its children.
+ * This step is all that's required to make a new {@link IterableDiffer} available.
+ *
+ * ### Example
+ *
+ * ```
+ * @Component({
+ * viewProviders: [
+ * IterableDiffers.extend([new ImmutableListDiffer()])
+ * ]
+ * })
+ * ```
+ */
+ static extend(factories: IterableDifferFactory[]): Provider;
+
+ factories: IterableDifferFactory[];
+
+ find(iterable: Object): IterableDifferFactory;
+
+ }
+
+
+ /**
+ * A strategy for tracking changes over time to an iterable. Used for {@link NgFor} to
+ * respond to changes in an iterable by effecting equivalent changes in the DOM.
+ */
+ interface IterableDiffer {
+
+ diff(object: Object): any;
+
+ onDestroy(): void;
+
+ }
+
+
+ /**
+ * Provides a factory for {@link IterableDiffer}.
+ */
+ interface IterableDifferFactory {
+
+ supports(objects: Object): boolean;
+
+ create(cdRef: ChangeDetectorRef): IterableDiffer;
+
+ }
+
+
+ /**
+ * A repository of different Map diffing strategies used by NgClass, NgStyle, and others.
+ */
+ class KeyValueDiffers {
+
+ constructor(factories: KeyValueDifferFactory[]);
+
+ static create(factories: KeyValueDifferFactory[], parent?: KeyValueDiffers): KeyValueDiffers;
+
+ /**
+ * Takes an array of {@link KeyValueDifferFactory} and returns a provider used to extend the
+ * inherited {@link KeyValueDiffers} instance with the provided factories and return a new
+ * {@link KeyValueDiffers} instance.
+ *
+ * The following example shows how to extend an existing list of factories,
+ * which will only be applied to the injector for this component and its children.
+ * This step is all that's required to make a new {@link KeyValueDiffer} available.
+ *
+ * ### Example
+ *
+ * ```
+ * @Component({
+ * viewProviders: [
+ * KeyValueDiffers.extend([new ImmutableMapDiffer()])
+ * ]
+ * })
+ * ```
+ */
+ static extend(factories: KeyValueDifferFactory[]): Provider;
+
+ factories: KeyValueDifferFactory[];
+
+ find(kv: Object): KeyValueDifferFactory;
+
+ }
+
+
+ /**
+ * A differ that tracks changes made to an object over time.
+ */
+ interface KeyValueDiffer {
+
+ diff(object: Object): void;
+
+ onDestroy(): void;
+
+ }
+
+
+ /**
+ * Provides a factory for {@link KeyValueDiffer}.
+ */
+ interface KeyValueDifferFactory {
+
+ supports(objects: Object): boolean;
+
+ create(cdRef: ChangeDetectorRef): KeyValueDiffer;
+
+ }
+
+
+ /**
+ * A token that can be provided when bootstraping an application to make an array of directives
+ * available in every component of the application.
+ *
+ * ### Example
+ *
+ * ```typescript
+ * import {PLATFORM_DIRECTIVES} from 'angular2/core';
+ * import {OtherDirective} from './myDirectives';
+ *
+ * @Component({
+ * selector: 'my-component',
+ * template: `
+ *
+ * ;
+
+
+
+ /**
+ * A default set of providers which should be included in any Angular
+ * application, regardless of the platform it runs onto.
+ */
+ let APPLICATION_COMMON_PROVIDERS: Array;
+
+
+
+ /**
+ * Provides access to reflection data about symbols. Used internally by Angular
+ * to power dependency injection and compilation.
+ */
+ class Reflector {
+
+ constructor(reflectionCapabilities: PlatformReflectionCapabilities);
+
+ reflectionCapabilities: PlatformReflectionCapabilities;
+
+ isReflectionEnabled(): boolean;
+
+ /**
+ * Causes `this` reflector to track keys used to access
+ * {@link ReflectionInfo} objects.
+ */
+ trackUsage(): void;
+
+ /**
+ * Lists types for which reflection information was not requested since
+ * {@link #trackUsage} was called. This list could later be audited as
+ * potential dead code.
+ */
+ listUnusedKeys(): any[];
+
+ registerFunction(func: Function, funcInfo: ReflectionInfo): void;
+
+ registerType(type: Type, typeInfo: ReflectionInfo): void;
+
+ registerGetters(getters: {[key: string]: GetterFn}): void;
+
+ registerSetters(setters: {[key: string]: SetterFn}): void;
+
+ registerMethods(methods: {[key: string]: MethodFn}): void;
+
+ factory(type: Type): Function;
+
+ parameters(typeOrFunc: /*Type*/ any): any[];
+
+ annotations(typeOrFunc: /*Type*/ any): any[];
+
+ propMetadata(typeOrFunc: /*Type*/ any): {[key: string]: any[]};
+
+ interfaces(type: Type): any[];
+
+ getter(name: string): GetterFn;
+
+ setter(name: string): SetterFn;
+
+ method(name: string): MethodFn;
+
+ importUri(type: Type): string;
+
+ }
+
+
+ /**
+ * Reflective information about a symbol, including annotations, interfaces, and other metadata.
+ */
+ class ReflectionInfo {
+
+ constructor(annotations?: any[], parameters?: any[][], factory?: Function, interfaces?: any[], propMetadata?: {[key: string]: any[]});
+
+ annotations: any[];
+
+ parameters: any[][];
+
+ factory: Function;
+
+ interfaces: any[];
+
+ propMetadata: {[key: string]: any[]};
+
+ }
+
+
+ /**
+ * The {@link Reflector} used internally in Angular to access metadata
+ * about symbols.
+ */
+ var reflector: any;
+}
+
+export = core;
diff --git a/app/typings/angular2/core_amb.d.ts b/app/typings/angular2/core_amb.d.ts
new file mode 100644
index 0000000..de794f1
--- /dev/null
+++ b/app/typings/angular2/core_amb.d.ts
@@ -0,0 +1,5 @@
+
+declare module "angular2/core" {
+ import * as core from 'core';
+ export = core;
+}
diff --git a/app/typings/angular2/platform/browser.d.ts b/app/typings/angular2/platform/browser.d.ts
new file mode 100644
index 0000000..bc78316
--- /dev/null
+++ b/app/typings/angular2/platform/browser.d.ts
@@ -0,0 +1,467 @@
+// Type definitions for Angular v2.0.0-local_sha.2a2f9a9
+// Project: http://angular.io/
+// Definitions by: angular team ;
+
+ hasAttribute(element: any, attribute: string): boolean;
+
+ getAttribute(element: any, attribute: string): string;
+
+ setAttribute(element: any, name: string, value: string): void;
+
+ setAttributeNS(element: any, ns: string, name: string, value: string): void;
+
+ removeAttribute(element: any, attribute: string): void;
+
+ templateAwareRoot(el: any): any;
+
+ createHtmlDocument(): HTMLDocument;
+
+ defaultDoc(): HTMLDocument;
+
+ getBoundingClientRect(el: any): any;
+
+ getTitle(): string;
+
+ setTitle(newTitle: string): void;
+
+ elementMatches(n: any, selector: string): boolean;
+
+ isTemplateElement(el: any): boolean;
+
+ isTextNode(node: Node): boolean;
+
+ isCommentNode(node: Node): boolean;
+
+ isElementNode(node: Node): boolean;
+
+ hasShadowRoot(node: any): boolean;
+
+ isShadowRoot(node: any): boolean;
+
+ importIntoDoc(node: Node): any;
+
+ adoptNode(node: Node): any;
+
+ getHref(el: Element): string;
+
+ getEventKey(event: any): string;
+
+ getGlobalEventTarget(target: string): EventTarget;
+
+ getHistory(): History;
+
+ getLocation(): Location;
+
+ getBaseHref(): string;
+
+ resetBaseElement(): void;
+
+ getUserAgent(): string;
+
+ setData(element: any, name: string, value: string): void;
+
+ getData(element: any, name: string): string;
+
+ getComputedStyle(element: any): any;
+
+ setGlobalVar(path: string, value: any): void;
+
+ requestAnimationFrame(callback: any): number;
+
+ cancelAnimationFrame(id: number): void;
+
+ performanceNow(): number;
+
+ }
+
+
+ /**
+ * Predicates for use with {@link core.DebugElement}'s query functions.
+ */
+ class By {
+
+ /**
+ * Match all elements.
+ *
+ * ## Example
+ *
+ * {@example platform/dom/debug/ts/by/by.ts region='by_all'}
+ */
+ static all(): Predicate;
+
+ /**
+ * Match elements by the given CSS selector.
+ *
+ * ## Example
+ *
+ * {@example platform/dom/debug/ts/by/by.ts region='by_css'}
+ */
+ static css(selector: string): Predicate;
+
+ /**
+ * Match elements that have the given directive present.
+ *
+ * ## Example
+ *
+ * {@example platform/dom/debug/ts/by/by.ts region='by_directive'}
+ */
+ static directive(type: core.Type): Predicate;
+
+ }
+
+
+ /**
+ * A service that can be used to get and set the title of a current HTML document.
+ *
+ * Since an Angular 2 application can't be bootstrapped on the entire HTML document (`` tag)
+ * it is not possible to bind to the `text` property of the `HTMLTitleElement` elements
+ * (representing the `` tag). Instead, this service can be used to set and get the current
+ * title value.
+ */
+ class Title {
+
+ /**
+ * Get the title of the current HTML document.
+ * @returns {string}
+ */
+ getTitle(): string;
+
+ /**
+ * Set the title of the current HTML document.
+ * @param newTitle
+ */
+ setTitle(newTitle: string): void;
+
+ }
+
+
+ /**
+ * A DI Token representing the main rendering context. In a browser this is the DOM Document.
+ *
+ * Note: Document might not be available in the Application Context when Application and Rendering
+ * Contexts are not the same (e.g. when running the application into a Web Worker).
+ */
+ let DOCUMENT: core.OpaqueToken;
+
+
+
+ /**
+ * Enabled Angular 2 debug tools that are accessible via your browser's
+ * developer console.
+ *
+ * Usage:
+ *
+ * 1. Open developer console (e.g. in Chrome Ctrl + Shift + j)
+ * 1. core.Type `ng.` (usually the console will show auto-complete suggestion)
+ * 1. Try the change detection profiler `ng.profiler.timeChangeDetection()`
+ * then hit Enter.
+ */
+ function enableDebugTools(ref: core.ComponentRef): void;
+
+
+
+ /**
+ * Disables Angular 2 tools.
+ */
+ function disableDebugTools(): void;
+
+
+
+ /**
+ * An array of providers that should be passed into `application()` when bootstrapping a component.
+ */
+ let BROWSER_APP_PROVIDERS: Array<any /*core.Type | Provider | any[]*/>;
+
+
+
+ /**
+ * Bootstrapping for Angular applications.
+ *
+ * You instantiate an Angular application by explicitly specifying a component to use
+ * as the root component for your application via the `bootstrap()` method.
+ *
+ * ## Simple Example
+ *
+ * Assuming this `index.html`:
+ *
+ * ```html
+ * <html>
+ * <!-- load Angular script tags here. -->
+ * <body>
+ * <my-app>loading...</my-app>
+ * </body>
+ * </html>
+ * ```
+ *
+ * An application is bootstrapped inside an existing browser DOM, typically `index.html`.
+ * Unlike Angular 1, Angular 2 does not compile/process providers in `index.html`. This is
+ * mainly for security reasons, as well as architectural changes in Angular 2. This means
+ * that `index.html` can safely be processed using server-side technologies such as
+ * providers. Bindings can thus use double-curly `{{ syntax }}` without collision from
+ * Angular 2 component double-curly `{{ syntax }}`.
+ *
+ * We can use this script code:
+ *
+ * {@example core/ts/bootstrap/bootstrap.ts region='bootstrap'}
+ *
+ * When the app developer invokes `bootstrap()` with the root component `MyApp` as its
+ * argument, Angular performs the following tasks:
+ *
+ * 1. It uses the component's `selector` property to locate the DOM element which needs
+ * to be upgraded into the angular component.
+ * 2. It creates a new child injector (from the platform injector). Optionally, you can
+ * also override the injector configuration for an app by invoking `bootstrap` with the
+ * `componentInjectableBindings` argument.
+ * 3. It creates a new `Zone` and connects it to the angular application's change detection
+ * domain instance.
+ * 4. It creates an emulated or shadow DOM on the selected component's host element and loads the
+ * template into it.
+ * 5. It instantiates the specified component.
+ * 6. Finally, Angular performs change detection to apply the initial data providers for the
+ * application.
+ *
+ *
+ * ## Bootstrapping Multiple Applications
+ *
+ * When working within a browser window, there are many singleton resources: cookies, title,
+ * location, and others. Angular services that represent these resources must likewise be
+ * shared across all Angular applications that occupy the same browser window. For this
+ * reason, Angular creates exactly one global platform object which stores all shared
+ * services, and each angular application injector has the platform injector as its parent.
+ *
+ * Each application has its own private injector as well. When there are multiple
+ * applications on a page, Angular treats each application injector's services as private
+ * to that application.
+ *
+ * ## API
+ *
+ * - `appComponentType`: The root component which should act as the application. This is
+ * a reference to a `core.Type` which is annotated with `@Component(...)`.
+ * - `customProviders`: An additional set of providers that can be added to the
+ * app injector to override default injection behavior.
+ *
+ * Returns a `Promise` of {@link core.ComponentRef}.
+ */
+ function bootstrap(appComponentType: core.Type, customProviders?: Array<any /*core.Type | Provider | any[]*/>): Promise<core.ComponentRef>;
+}
+
+export = browser;
diff --git a/app/typings/angular2/platform/browser_amb.d.ts b/app/typings/angular2/platform/browser_amb.d.ts
new file mode 100644
index 0000000..11edfa7
--- /dev/null
+++ b/app/typings/angular2/platform/browser_amb.d.ts
@@ -0,0 +1,5 @@
+
+declare module "angular2/platform/browser" {
+ import * as browser from 'browser';
+ export = browser;
+}
diff --git a/app/typings/angular2/router.d.ts b/app/typings/angular2/router.d.ts
new file mode 100644
index 0000000..4a47983
--- /dev/null
+++ b/app/typings/angular2/router.d.ts
@@ -0,0 +1,1331 @@
+// Type definitions for Angular v2.0.0-local_sha.2a2f9a9
+// Project: http://angular.io/
+// Definitions by: angular team <https://github.com/angular/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+// ***********************************************************
+// This file is generated by the Angular build process.
+// Please do not create manual edits or send pull requests
+// modifying this file.
+// ***********************************************************
+
+import * as core from 'core';
+
+/**
+ * @namespace
+ * @description
+ * Maps application URLs into application states, to support deep-linking and navigation.
+ */
+declare namespace ngRouter {
+ /**
+ * The `Router` is responsible for mapping URLs to components.
+ *
+ * You can see the state of the router by inspecting the read-only field `router.navigating`.
+ * This may be useful for showing a spinner, for instance.
+ *
+ * ## Concepts
+ *
+ * Routers and component instances have a 1:1 correspondence.
+ *
+ * The router holds reference to a number of {@link RouterOutlet}.
+ * An outlet is a placeholder that the router dynamically fills in depending on the current URL.
+ *
+ * When the router navigates from a URL, it must first recognize it and serialize it into an
+ * `Instruction`.
+ * The router uses the `RouteRegistry` to get an `Instruction`.
+ */
+ class Router {
+
+ constructor(registry: RouteRegistry, parent: Router, hostComponent: any);
+
+ navigating: boolean;
+
+ lastNavigationAttempt: string;
+
+ registry: RouteRegistry;
+
+ parent: Router;
+
+ hostComponent: any;
+
+ /**
+ * Constructs a child router. You probably don't need to use this unless you're writing a reusable
+ * component.
+ */
+ childRouter(hostComponent: any): Router;
+
+ /**
+ * Constructs a child router. You probably don't need to use this unless you're writing a reusable
+ * component.
+ */
+ auxRouter(hostComponent: any): Router;
+
+ /**
+ * Register an outlet to be notified of primary route changes.
+ *
+ * You probably don't need to use this unless you're writing a reusable component.
+ */
+ registerPrimaryOutlet(outlet: RouterOutlet): Promise<boolean>;
+
+ /**
+ * Register an outlet to notified of auxiliary route changes.
+ *
+ * You probably don't need to use this unless you're writing a reusable component.
+ */
+ registerAuxOutlet(outlet: RouterOutlet): Promise<boolean>;
+
+ /**
+ * Given an instruction, returns `true` if the instruction is currently active,
+ * otherwise `false`.
+ */
+ isRouteActive(instruction: Instruction): boolean;
+
+ /**
+ * Dynamically update the routing configuration and trigger a navigation.
+ *
+ * ### Usage
+ *
+ * ```
+ * router.config([
+ * { 'path': '/', 'component': IndexComp },
+ * { 'path': '/user/:id', 'component': UserComp },
+ * ]);
+ * ```
+ */
+ config(definitions: RouteDefinition[]): Promise<any>;
+
+ /**
+ * Navigate based on the provided Route Link DSL. It's preferred to navigate with this method
+ * over `navigateByUrl`.
+ *
+ * ### Usage
+ *
+ * This method takes an array representing the Route Link DSL:
+ * ```
+ * ['./MyCmp', {param: 3}]
+ * ```
+ * See the {@link RouterLink} directive for more.
+ */
+ navigate(linkParams: any[]): Promise<any>;
+
+ /**
+ * Navigate to a URL. Returns a promise that resolves when navigation is complete.
+ * It's preferred to navigate with `navigate` instead of this method, since URLs are more brittle.
+ *
+ * If the given URL begins with a `/`, router will navigate absolutely.
+ * If the given URL does not begin with `/`, the router will navigate relative to this component.
+ */
+ navigateByUrl(url: string, _skipLocationChange?: boolean): Promise<any>;
+
+ /**
+ * Navigate via the provided instruction. Returns a promise that resolves when navigation is
+ * complete.
+ */
+ navigateByInstruction(instruction: Instruction, _skipLocationChange?: boolean): Promise<any>;
+
+ /**
+ * Updates this router and all descendant routers according to the given instruction
+ */
+ commit(instruction: Instruction, _skipLocationChange?: boolean): Promise<any>;
+
+ /**
+ * Subscribe to URL updates from the router
+ */
+ subscribe(onNext: (value: any) => void): Object;
+
+ /**
+ * Removes the contents of this router's outlet and all descendant outlets
+ */
+ deactivate(instruction: Instruction): Promise<any>;
+
+ /**
+ * Given a URL, returns an instruction representing the component graph
+ */
+ recognize(url: string): Promise<Instruction>;
+
+ /**
+ * Navigates to either the last URL successfully navigated to, or the last URL requested if the
+ * router has yet to successfully navigate.
+ */
+ renavigate(): Promise<any>;
+
+ /**
+ * Generate an `Instruction` based on the provided Route Link DSL.
+ */
+ generate(linkParams: any[]): Instruction;
+
+ }
+
+
+ /**
+ * A router outlet is a placeholder that Angular dynamically fills based on the application's route.
+ *
+ * ## Use
+ *
+ * ```
+ * <router-outlet></router-outlet>
+ * ```
+ */
+ class RouterOutlet {
+
+ constructor(_elementRef: core.ElementRef, _loader: core.DynamicComponentLoader, _parentRouter:Router, nameAttr: string);
+
+ name: string;
+
+ /**
+ * Called by the Router to instantiate a new component during the commit phase of a navigation.
+ * This method in turn is responsible for calling the `routerOnActivate` hook of its child.
+ */
+ activate(nextInstruction: ComponentInstruction): Promise<any>;
+
+ /**
+ * Called by the {@link Router} during the commit phase of a navigation when an outlet
+ * reuses a component between different routes.
+ * This method in turn is responsible for calling the `routerOnReuse` hook of its child.
+ */
+ reuse(nextInstruction: ComponentInstruction): Promise<any>;
+
+ /**
+ * Called by the {@link Router} when an outlet disposes of a component's contents.
+ * This method in turn is responsible for calling the `routerOnDeactivate` hook of its child.
+ */
+ deactivate(nextInstruction: ComponentInstruction): Promise<any>;
+
+ /**
+ * Called by the {@link Router} during recognition phase of a navigation.
+ *
+ * If this resolves to `false`, the given navigation is cancelled.
+ *
+ * This method delegates to the child component's `routerCanDeactivate` hook if it exists,
+ * and otherwise resolves to true.
+ */
+ routerCanDeactivate(nextInstruction: ComponentInstruction): Promise<boolean>;
+
+ /**
+ * Called by the {@link Router} during recognition phase of a navigation.
+ *
+ * If the new child component has a different core.Type than the existing child component,
+ * this will resolve to `false`. You can't reuse an old component when the new component
+ * is of a different core.Type.
+ *
+ * Otherwise, this method delegates to the child component's `routerCanReuse` hook if it exists,
+ * or resolves to true if the hook is not present.
+ */
+ routerCanReuse(nextInstruction: ComponentInstruction): Promise<boolean>;
+
+ }
+
+
+ /**
+ * The RouterLink directive lets you link to specific parts of your app.
+ *
+ * Consider the following route configuration:
+ *
+ * ```
+ * @RouteConfig([
+ * { path: '/user', component: UserCmp, as: 'User' }
+ * ]);
+ * class MyComp {}
+ * ```
+ *
+ * When linking to this `User` route, you can write:
+ *
+ * ```
+ * <a [routerLink]="['./User']">link to user component</a>
+ * ```
+ *
+ * RouterLink expects the value to be an array of route names, followed by the params
+ * for that level of routing. For instance `['/Team', {teamId: 1}, 'User', {userId: 2}]`
+ * means that we want to generate a link for the `Team` route with params `{teamId: 1}`,
+ * and with a child route `User` with params `{userId: 2}`.
+ *
+ * The first route name should be prepended with `/`, `./`, or `../`.
+ * If the route begins with `/`, the router will look up the route from the root of the app.
+ * If the route begins with `./`, the router will instead look in the current component's
+ * children for the route. And if the route begins with `../`, the router will look at the
+ * current component's parent.
+ */
+ class RouterLink {
+
+ constructor(_router: Router, _location: Location);
+
+ visibleHref: string;
+
+ target: string;
+
+ isRouteActive: boolean;
+
+ routeParams: any;
+
+ onClick(): boolean;
+
+ }
+
+
+ /**
+ * `RouteParams` is an immutable map of parameters for the given route
+ * based on the url matcher and optional parameters for that route.
+ *
+ * You can inject `RouteParams` into the constructor of a component to use it.
+ *
+ * ### Example
+ *
+ * ```
+ * import {Component} from 'angular2/core';
+ * import {bootstrap} from 'angular2/platform/browser';
+ * import {Router, ROUTER_DIRECTIVES, ROUTER_PROVIDERS, RouteConfig} from 'angular2/router';
+ *
+ * @Component({directives: [ROUTER_DIRECTIVES]})
+ * @RouteConfig([
+ * {path: '/user/:id', component: UserCmp, as: 'UserCmp'},
+ * ])
+ * class AppCmp {}
+ *
+ * @Component({ template: 'user: {{id}}' })
+ * class UserCmp {
+ * id: string;
+ * constructor(params: RouteParams) {
+ * this.id = params.get('id');
+ * }
+ * }
+ *
+ * bootstrap(AppCmp, ROUTER_PROVIDERS);
+ * ```
+ */
+ class RouteParams {
+
+ constructor(params: {[key: string]: string});
+
+ params: {[key: string]: string};
+
+ get(param: string): string;
+
+ }
+
+
+ /**
+ * `RouteData` is an immutable map of additional data you can configure in your {@link Route}.
+ *
+ * You can inject `RouteData` into the constructor of a component to use it.
+ *
+ * ### Example
+ *
+ * ```
+ * import {Component, View} from 'angular2/core';
+ * import {bootstrap} from 'angular2/platform/browser';
+ * import {Router, ROUTER_DIRECTIVES, routerBindings, RouteConfig} from 'angular2/router';
+ *
+ * @Component({...})
+ * @View({directives: [ROUTER_DIRECTIVES]})
+ * @RouteConfig([
+ * {path: '/user/:id', component: UserCmp, as: 'UserCmp', data: {isAdmin: true}},
+ * ])
+ * class AppCmp {}
+ *
+ * @Component({...})
+ * @View({ template: 'user: {{isAdmin}}' })
+ * class UserCmp {
+ * string: isAdmin;
+ * constructor(data: RouteData) {
+ * this.isAdmin = data.get('isAdmin');
+ * }
+ * }
+ *
+ * bootstrap(AppCmp, routerBindings(AppCmp));
+ * ```
+ */
+ class RouteData {
+
+ constructor(data?: {[key: string]: any});
+
+ data: {[key: string]: any};
+
+ get(key: string): any;
+
+ }
+
+
+ /**
+ * `PlatformLocation` encapsulates all of the direct calls to platform APIs.
+ * This class should not be used directly by an application developer. Instead, use
+ * {@link Location}.
+ */
+ class PlatformLocation {
+
+ constructor();
+
+ getBaseHrefFromDOM(): string;
+
+ onPopState(fn: EventListener): void;
+
+ onHashChange(fn: EventListener): void;
+
+ pathname: string;
+
+ search: string;
+
+ hash: string;
+
+ pushState(state: any, title: string, url: string): void;
+
+ replaceState(state: any, title: string, url: string): void;
+
+ forward(): void;
+
+ back(): void;
+
+ }
+
+
+ /**
+ * The RouteRegistry holds route configurations for each component in an Angular app.
+ * It is responsible for creating Instructions from URLs, and generating URLs based on route and
+ * parameters.
+ */
+ class RouteRegistry {
+
+ constructor(_rootComponent: core.Type);
+
+ /**
+ * Given a component and a configuration object, add the route to this registry
+ */
+ config(parentComponent: any, config: RouteDefinition): void;
+
+ /**
+ * Reads the annotations of a component and configures the registry based on them
+ */
+ configFromComponent(component: any): void;
+
+ /**
+ * Given a URL and a parent component, return the most specific instruction for navigating
+ * the application into the state specified by the url
+ */
+ recognize(url: string, ancestorInstructions: Instruction[]): Promise<Instruction>;
+
+ /**
+ * Given a normalized list with component names and params like: `['user', {id: 3 }]`
+ * generates a url with a leading slash relative to the provided `parentComponent`.
+ *
+ * If the optional param `_aux` is `true`, then we generate starting at an auxiliary
+ * route boundary.
+ */
+ generate(linkParams: any[], ancestorInstructions: Instruction[], _aux?: any): Instruction;
+
+ hasRoute(name: string, parentComponent: any): boolean;
+
+ generateDefault(componentCursor: core.Type): Instruction;
+
+ }
+
+
+ /**
+ * Token used to bind the component with the top-level {@link RouteConfig}s for the
+ * application.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/iRUP8B5OUbxCWQ3AcIDm))
+ *
+ * ```
+ * import {Component} from 'angular2/core';
+ * import {
+ * ROUTER_DIRECTIVES,
+ * ROUTER_PROVIDERS,
+ * RouteConfig
+ * } from 'angular2/router';
+ *
+ * @Component({directives: [ROUTER_DIRECTIVES]})
+ * @RouteConfig([
+ * {...},
+ * ])
+ * class AppCmp {
+ * // ...
+ * }
+ *
+ * bootstrap(AppCmp, [ROUTER_PROVIDERS]);
+ * ```
+ */
+ let ROUTER_PRIMARY_COMPONENT: OpaqueToken;
+
+
+
+ /**
+ * `LocationStrategy` is responsible for representing and reading route state
+ * from the browser's URL. Angular provides two strategies:
+ * {@link HashLocationStrategy} (default) and {@link PathLocationStrategy}.
+ *
+ * This is used under the hood of the {@link Location} service.
+ *
+ * Applications should use the {@link Router} or {@link Location} services to
+ * interact with application route state.
+ *
+ * For instance, {@link HashLocationStrategy} produces URLs like
+ * `http://example.com#/foo`, and {@link PathLocationStrategy} produces
+ * `http://example.com/foo` as an equivalent URL.
+ *
+ * See these two classes for more.
+ */
+ abstract class LocationStrategy {
+
+ path(): string;
+
+ prepareExternalUrl(internal: string): string;
+
+ pushState(state: any, title: string, url: string, queryParams: string): void;
+
+ replaceState(state: any, title: string, url: string, queryParams: string): void;
+
+ forward(): void;
+
+ back(): void;
+
+ onPopState(fn: (_: any) => any): void;
+
+ getBaseHref(): string;
+
+ }
+
+
+ /**
+ * The `APP_BASE_HREF` token represents the base href to be used with the
+ * {@link PathLocationStrategy}.
+ *
+ * If you're using {@link PathLocationStrategy}, you must provide a provider to a string
+ * representing the URL prefix that should be preserved when generating and recognizing
+ * URLs.
+ *
+ * ### Example
+ *
+ * ```
+ * import {Component} from 'angular2/core';
+ * import {ROUTER_DIRECTIVES, ROUTER_PROVIDERS, RouteConfig} from 'angular2/router';
+ *
+ * @Component({directives: [ROUTER_DIRECTIVES]})
+ * @RouteConfig([
+ * {...},
+ * ])
+ * class AppCmp {
+ * // ...
+ * }
+ *
+ * bootstrap(AppCmp, [
+ * ROUTER_PROVIDERS,
+ * PathLocationStrategy,
+ * provide(APP_BASE_HREF, {useValue: '/my/app'})
+ * ]);
+ * ```
+ */
+ let APP_BASE_HREF: OpaqueToken;
+
+
+
+ /**
+ * `HashLocationStrategy` is a {@link LocationStrategy} used to configure the
+ * {@link Location} service to represent its state in the
+ * [hash fragment](https://en.wikipedia.org/wiki/Uniform_Resource_Locator#Syntax)
+ * of the browser's URL.
+ *
+ * For instance, if you call `location.go('/foo')`, the browser's URL will become
+ * `example.com#/foo`.
+ *
+ * ### Example
+ *
+ * ```
+ * import {Component, provide} from 'angular2/core';
+ * import {
+ * ROUTER_DIRECTIVES,
+ * ROUTER_PROVIDERS,
+ * RouteConfig,
+ * Location,
+ * LocationStrategy,
+ * HashLocationStrategy
+ * } from 'angular2/router';
+ *
+ * @Component({directives: [ROUTER_DIRECTIVES]})
+ * @RouteConfig([
+ * {...},
+ * ])
+ * class AppCmp {
+ * constructor(location: Location) {
+ * location.go('/foo');
+ * }
+ * }
+ *
+ * bootstrap(AppCmp, [
+ * ROUTER_PROVIDERS,
+ * provide(LocationStrategy, {useClass: HashLocationStrategy})
+ * ]);
+ * ```
+ */
+ class HashLocationStrategy extends LocationStrategy {
+
+ constructor(_platformLocation: PlatformLocation, _baseHref?: string);
+
+ onPopState(fn: EventListener): void;
+
+ getBaseHref(): string;
+
+ path(): string;
+
+ prepareExternalUrl(internal: string): string;
+
+ pushState(state: any, title: string, path: string, queryParams: string): void;
+
+ replaceState(state: any, title: string, path: string, queryParams: string): void;
+
+ forward(): void;
+
+ back(): void;
+
+ }
+
+
+ /**
+ * `PathLocationStrategy` is a {@link LocationStrategy} used to configure the
+ * {@link Location} service to represent its state in the
+ * [path](https://en.wikipedia.org/wiki/Uniform_Resource_Locator#Syntax) of the
+ * browser's URL.
+ *
+ * `PathLocationStrategy` is the default binding for {@link LocationStrategy}
+ * provided in {@link ROUTER_PROVIDERS}.
+ *
+ * If you're using `PathLocationStrategy`, you must provide a provider for
+ * {@link APP_BASE_HREF} to a string representing the URL prefix that should
+ * be preserved when generating and recognizing URLs.
+ *
+ * For instance, if you provide an `APP_BASE_HREF` of `'/my/app'` and call
+ * `location.go('/foo')`, the browser's URL will become
+ * `example.com/my/app/foo`.
+ *
+ * ### Example
+ *
+ * ```
+ * import {Component, provide} from 'angular2/core';
+ * import {
+ * APP_BASE_HREF
+ * ROUTER_DIRECTIVES,
+ * ROUTER_PROVIDERS,
+ * RouteConfig,
+ * Location
+ * } from 'angular2/router';
+ *
+ * @Component({directives: [ROUTER_DIRECTIVES]})
+ * @RouteConfig([
+ * {...},
+ * ])
+ * class AppCmp {
+ * constructor(location: Location) {
+ * location.go('/foo');
+ * }
+ * }
+ *
+ * bootstrap(AppCmp, [
+ * ROUTER_PROVIDERS, // includes binding to PathLocationStrategy
+ * provide(APP_BASE_HREF, {useValue: '/my/app'})
+ * ]);
+ * ```
+ */
+ class PathLocationStrategy extends LocationStrategy {
+
+ constructor(_platformLocation: PlatformLocation, href?: string);
+
+ onPopState(fn: EventListener): void;
+
+ getBaseHref(): string;
+
+ prepareExternalUrl(internal: string): string;
+
+ path(): string;
+
+ pushState(state: any, title: string, url: string, queryParams: string): void;
+
+ replaceState(state: any, title: string, url: string, queryParams: string): void;
+
+ forward(): void;
+
+ back(): void;
+
+ }
+
+
+ /**
+ * `Location` is a service that applications can use to interact with a browser's URL.
+ * Depending on which {@link LocationStrategy} is used, `Location` will either persist
+ * to the URL's path or the URL's hash segment.
+ *
+ * Note: it's better to use {@link Router#navigate} service to trigger route changes. Use
+ * `Location` only if you need to interact with or create normalized URLs outside of
+ * routing.
+ *
+ * `Location` is responsible for normalizing the URL against the application's base href.
+ * A normalized URL is absolute from the URL host, includes the application's base href, and has no
+ * trailing slash:
+ * - `/my/app/user/123` is normalized
+ * - `my/app/user/123` **is not** normalized
+ * - `/my/app/user/123/` **is not** normalized
+ *
+ * ### Example
+ *
+ * ```
+ * import {Component} from 'angular2/core';
+ * import {
+ * ROUTER_DIRECTIVES,
+ * ROUTER_PROVIDERS,
+ * RouteConfig,
+ * Location
+ * } from 'angular2/router';
+ *
+ * @Component({directives: [ROUTER_DIRECTIVES]})
+ * @RouteConfig([
+ * {...},
+ * ])
+ * class AppCmp {
+ * constructor(location: Location) {
+ * location.go('/foo');
+ * }
+ * }
+ *
+ * bootstrap(AppCmp, [ROUTER_PROVIDERS]);
+ * ```
+ */
+ class Location {
+
+ constructor(platformStrategy: LocationStrategy);
+
+ platformStrategy: LocationStrategy;
+
+ /**
+ * Returns the normalized URL path.
+ */
+ path(): string;
+
+ /**
+ * Given a string representing a URL, returns the normalized URL path without leading or
+ * trailing slashes
+ */
+ normalize(url: string): string;
+
+ /**
+ * Given a string representing a URL, returns the platform-specific external URL path.
+ * If the given URL doesn't begin with a leading slash (`'/'`), this method adds one
+ * before normalizing. This method will also add a hash if `HashLocationStrategy` is
+ * used, or the `APP_BASE_HREF` if the `PathLocationStrategy` is in use.
+ */
+ prepareExternalUrl(url: string): string;
+
+ /**
+ * Changes the browsers URL to the normalized version of the given URL, and pushes a
+ * new item onto the platform's history.
+ */
+ go(path: string, query?: string): void;
+
+ /**
+ * Changes the browsers URL to the normalized version of the given URL, and replaces
+ * the top item on the platform's history stack.
+ */
+ replaceState(path: string, query?: string): void;
+
+ /**
+ * Navigates forward in the platform's history.
+ */
+ forward(): void;
+
+ /**
+ * Navigates back in the platform's history.
+ */
+ back(): void;
+
+ /**
+ * Subscribe to the platform's `popState` events.
+ */
+ subscribe(onNext: (value: any) => void, onThrow?: (exception: any) => void, onReturn?: () => void): Object;
+
+ }
+
+
+ /**
+ * Defines route lifecycle method `routerOnActivate`, which is called by the router at the end of a
+ * successful route navigation.
+ *
+ * For a single component's navigation, only one of either {@link OnActivate} or {@link OnReuse}
+ * will be called depending on the result of {@link CanReuse}.
+ *
+ * The `routerOnActivate` hook is called with two {@link ComponentInstruction}s as parameters, the
+ * first
+ * representing the current route being navigated to, and the second parameter representing the
+ * previous route or `null`.
+ *
+ * If `routerOnActivate` returns a promise, the route change will wait until the promise settles to
+ * instantiate and activate child components.
+ *
+ * ### Example
+ * {@example router/ts/on_activate/on_activate_example.ts region='routerOnActivate'}
+ */
+ interface OnActivate {
+
+ routerOnActivate(nextInstruction: ComponentInstruction, prevInstruction: ComponentInstruction): any;
+
+ }
+
+
+ /**
+ * Defines route lifecycle method `routerOnDeactivate`, which is called by the router before
+ * destroying
+ * a component as part of a route change.
+ *
+ * The `routerOnDeactivate` hook is called with two {@link ComponentInstruction}s as parameters, the
+ * first
+ * representing the current route being navigated to, and the second parameter representing the
+ * previous route.
+ *
+ * If `routerOnDeactivate` returns a promise, the route change will wait until the promise settles.
+ *
+ * ### Example
+ * {@example router/ts/on_deactivate/on_deactivate_example.ts region='routerOnDeactivate'}
+ */
+ interface OnDeactivate {
+
+ routerOnDeactivate(nextInstruction: ComponentInstruction, prevInstruction: ComponentInstruction): any;
+
+ }
+
+
+ /**
+ * Defines route lifecycle method `routerOnReuse`, which is called by the router at the end of a
+ * successful route navigation when {@link CanReuse} is implemented and returns or resolves to true.
+ *
+ * For a single component's navigation, only one of either {@link OnActivate} or {@link OnReuse}
+ * will be called, depending on the result of {@link CanReuse}.
+ *
+ * The `routerOnReuse` hook is called with two {@link ComponentInstruction}s as parameters, the
+ * first
+ * representing the current route being navigated to, and the second parameter representing the
+ * previous route or `null`.
+ *
+ * ### Example
+ * {@example router/ts/reuse/reuse_example.ts region='reuseCmp'}
+ */
+ interface OnReuse {
+
+ routerOnReuse(nextInstruction: ComponentInstruction, prevInstruction: ComponentInstruction): any;
+
+ }
+
+
+ /**
+ * Defines route lifecycle method `routerCanDeactivate`, which is called by the router to determine
+ * if a component can be removed as part of a navigation.
+ *
+ * The `routerCanDeactivate` hook is called with two {@link ComponentInstruction}s as parameters,
+ * the
+ * first representing the current route being navigated to, and the second parameter
+ * representing the previous route.
+ *
+ * If `routerCanDeactivate` returns or resolves to `false`, the navigation is cancelled. If it
+ * returns or
+ * resolves to `true`, then the navigation continues, and the component will be deactivated
+ * (the {@link OnDeactivate} hook will be run) and removed.
+ *
+ * If `routerCanDeactivate` throws or rejects, the navigation is also cancelled.
+ *
+ * ### Example
+ * {@example router/ts/can_deactivate/can_deactivate_example.ts region='routerCanDeactivate'}
+ */
+ interface CanDeactivate {
+
+ routerCanDeactivate(nextInstruction: ComponentInstruction, prevInstruction: ComponentInstruction): any;
+
+ }
+
+
+ /**
+ * Defines route lifecycle method `routerCanReuse`, which is called by the router to determine
+ * whether a
+ * component should be reused across routes, or whether to destroy and instantiate a new component.
+ *
+ * The `routerCanReuse` hook is called with two {@link ComponentInstruction}s as parameters, the
+ * first
+ * representing the current route being navigated to, and the second parameter representing the
+ * previous route.
+ *
+ * If `routerCanReuse` returns or resolves to `true`, the component instance will be reused and the
+ * {@link OnDeactivate} hook will be run. If `routerCanReuse` returns or resolves to `false`, a new
+ * component will be instantiated, and the existing component will be deactivated and removed as
+ * part of the navigation.
+ *
+ * If `routerCanReuse` throws or rejects, the navigation will be cancelled.
+ *
+ * ### Example
+ * {@example router/ts/reuse/reuse_example.ts region='reuseCmp'}
+ */
+ interface CanReuse {
+
+ routerCanReuse(nextInstruction: ComponentInstruction, prevInstruction: ComponentInstruction): any;
+
+ }
+
+
+ /**
+ * Defines route lifecycle hook `CanActivate`, which is called by the router to determine
+ * if a component can be instantiated as part of a navigation.
+ *
+ * <aside class="is-right">
+ * Note that unlike other lifecycle hooks, this one uses an annotation rather than an interface.
+ * This is because the `CanActivate` function is called before the component is instantiated.
+ * </aside>
+ *
+ * The `CanActivate` hook is called with two {@link ComponentInstruction}s as parameters, the first
+ * representing the current route being navigated to, and the second parameter representing the
+ * previous route or `null`.
+ *
+ * ```typescript
+ * @CanActivate((next, prev) => boolean | Promise<boolean>)
+ * ```
+ *
+ * If `CanActivate` returns or resolves to `false`, the navigation is cancelled.
+ * If `CanActivate` throws or rejects, the navigation is also cancelled.
+ * If `CanActivate` returns or resolves to `true`, navigation continues, the component is
+ * instantiated, and the {@link OnActivate} hook of that component is called if implemented.
+ *
+ * ### Example
+ *
+ * {@example router/ts/can_activate/can_activate_example.ts region='canActivate' }
+ */
+ var CanActivate: (hook: (next: ComponentInstruction, prev: ComponentInstruction) =>
+ Promise<boolean>| boolean) => ClassDecorator;
+
+
+
+ /**
+ * `Instruction` is a tree of {@link ComponentInstruction}s with all the information needed
+ * to transition each component in the app to a given route, including all auxiliary routes.
+ *
+ * `Instruction`s can be created using {@link Router#generate}, and can be used to
+ * perform route changes with {@link Router#navigateByInstruction}.
+ *
+ * ### Example
+ *
+ * ```
+ * import {Component} from 'angular2/core';
+ * import {bootstrap} from 'angular2/platform/browser';
+ * import {Router, ROUTER_DIRECTIVES, ROUTER_PROVIDERS, RouteConfig} from 'angular2/router';
+ *
+ * @Component({directives: [ROUTER_DIRECTIVES]})
+ * @RouteConfig([
+ * {...},
+ * ])
+ * class AppCmp {
+ * constructor(router: Router) {
+ * var instruction = router.generate(['/MyRoute']);
+ * router.navigateByInstruction(instruction);
+ * }
+ * }
+ *
+ * bootstrap(AppCmp, ROUTER_PROVIDERS);
+ * ```
+ */
+ abstract class Instruction {
+
+ component: ComponentInstruction;
+
+ child: Instruction;
+
+ auxInstruction: {[key: string]: Instruction};
+
+ urlPath: string;
+
+ urlParams: string[];
+
+ specificity: number;
+
+ resolveComponent(): Promise<ComponentInstruction>;
+
+ /**
+ * converts the instruction into a URL string
+ */
+ toRootUrl(): string;
+
+ toUrlQuery(): string;
+
+ /**
+ * Returns a new instruction that shares the state of the existing instruction, but with
+ * the given child {@link Instruction} replacing the existing child.
+ */
+ replaceChild(child: Instruction): Instruction;
+
+ /**
+ * If the final URL for the instruction is ``
+ */
+ toUrlPath(): string;
+
+ toLinkUrl(): string;
+
+ }
+
+
+ /**
+ * A `ComponentInstruction` represents the route state for a single component. An `Instruction` is
+ * composed of a tree of these `ComponentInstruction`s.
+ *
+ * `ComponentInstructions` is a public API. Instances of `ComponentInstruction` are passed
+ * to route lifecycle hooks, like {@link CanActivate}.
+ *
+ * `ComponentInstruction`s are [https://en.wikipedia.org/wiki/Hash_consing](hash consed). You should
+ * never construct one yourself with "new." Instead, rely on {@link Router/RouteRecognizer} to
+ * construct `ComponentInstruction`s.
+ *
+ * You should not modify this object. It should be treated as immutable.
+ */
+ class ComponentInstruction {
+
+ constructor(urlPath: string, urlParams: string[], data: RouteData, componentType: any, terminal: boolean, specificity: number, params?: {[key: string]: any});
+
+ reuse: boolean;
+
+ routeData: RouteData;
+
+ urlPath: string;
+
+ urlParams: string[];
+
+ componentType: any;
+
+ terminal: boolean;
+
+ specificity: number;
+
+ params: {[key: string]: any};
+
+ }
+
+
+ /**
+ * Creates a token that can be used in a DI Provider.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/Ys9ezXpj2Mnoy3Uc8KBp?p=preview))
+ *
+ * ```typescript
+ * var t = new OpaqueToken("value");
+ *
+ * var injector = Injector.resolveAndCreate([
+ * provide(t, {useValue: "providedValue"})
+ * ]);
+ *
+ * expect(injector.get(t)).toEqual("bindingValue");
+ * ```
+ *
+ * Using an `OpaqueToken` is preferable to using strings as tokens because of possible collisions
+ * caused by multiple providers using the same string as two different tokens.
+ *
+ * Using an `OpaqueToken` is preferable to using an `Object` as tokens because it provides better
+ * error messages.
+ */
+ class OpaqueToken {
+
+ constructor(_desc: string);
+
+ toString(): string;
+
+ }
+
+
+ /**
+ * A list of directives. To use the router directives like {@link RouterOutlet} and
+ * {@link RouterLink}, add this to your `directives` array in the {@link View} decorator of your
+ * component.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/iRUP8B5OUbxCWQ3AcIDm))
+ *
+ * ```
+ * import {Component} from 'angular2/core';
+ * import {ROUTER_DIRECTIVES, ROUTER_PROVIDERS, RouteConfig} from 'angular2/router';
+ *
+ * @Component({directives: [ROUTER_DIRECTIVES]})
+ * @RouteConfig([
+ * {...},
+ * ])
+ * class AppCmp {
+ * // ...
+ * }
+ *
+ * bootstrap(AppCmp, [ROUTER_PROVIDERS]);
+ * ```
+ */
+ let ROUTER_DIRECTIVES: any[];
+
+
+
+ /**
+ * A list of {@link Provider}s. To use the router, you must add this to your application.
+ *
+ * ### Example ([live demo](http://plnkr.co/edit/iRUP8B5OUbxCWQ3AcIDm))
+ *
+ * ```
+ * import {Component} from 'angular2/core';
+ * import {
+ * ROUTER_DIRECTIVES,
+ * ROUTER_PROVIDERS,
+ * RouteConfig
+ * } from 'angular2/router';
+ *
+ * @Component({directives: [ROUTER_DIRECTIVES]})
+ * @RouteConfig([
+ * {...},
+ * ])
+ * class AppCmp {
+ * // ...
+ * }
+ *
+ * bootstrap(AppCmp, [ROUTER_PROVIDERS]);
+ * ```
+ */
+ let ROUTER_PROVIDERS: any[];
+
+
+
+ /**
+ * Use {@link ROUTER_PROVIDERS} instead.
+ *
+ * @deprecated
+ */
+ let ROUTER_BINDINGS: any;
+
+
+
+ /**
+ * `Route` is a type of {@link RouteDefinition} used to route a path to a component.
+ *
+ * It has the following properties:
+ * - `path` is a string that uses the route matcher DSL.
+ * - `component` a component type.
+ * - `name` is an optional `CamelCase` string representing the name of the route.
+ * - `data` is an optional property of any type representing arbitrary route metadata for the given
+ * route. It is injectable via {@link RouteData}.
+ * - `useAsDefault` is a boolean value. If `true`, the child route will be navigated to if no child
+ * route is specified during the navigation.
+ *
+ * ### Example
+ * ```
+ * import {RouteConfig} from 'angular2/router';
+ *
+ * @RouteConfig([
+ * {path: '/home', component: HomeCmp, name: 'HomeCmp' }
+ * ])
+ * class MyApp {}
+ * ```
+ */
+ class Route implements RouteDefinition {
+
+ constructor({path, component, name, data, useAsDefault}: {
+ path: string,
+ component: core.Type, name?: string, data?: {[key: string]: any}, useAsDefault?: boolean
+ });
+
+ data: {[key: string]: any};
+
+ path: string;
+
+ component: core.Type;
+
+ name: string;
+
+ useAsDefault: boolean;
+
+ aux: string;
+
+ loader: Function;
+
+ redirectTo: any[];
+
+ }
+
+
+ /**
+ * `Redirect` is a type of {@link RouteDefinition} used to route a path to a canonical route.
+ *
+ * It has the following properties:
+ * - `path` is a string that uses the route matcher DSL.
+ * - `redirectTo` is an array representing the link DSL.
+ *
+ * Note that redirects **do not** affect how links are generated. For that, see the `useAsDefault`
+ * option.
+ *
+ * ### Example
+ * ```
+ * import {RouteConfig} from 'angular2/router';
+ *
+ * @RouteConfig([
+ * {path: '/', redirectTo: ['/Home'] },
+ * {path: '/home', component: HomeCmp, name: 'Home'}
+ * ])
+ * class MyApp {}
+ * ```
+ */
+ class Redirect implements RouteDefinition {
+
+ constructor({path, redirectTo}: {path: string, redirectTo: any[]});
+
+ path: string;
+
+ redirectTo: any[];
+
+ name: string;
+
+ loader: Function;
+
+ data: any;
+
+ aux: string;
+
+ useAsDefault: boolean;
+
+ }
+
+
+ /**
+ * `AuxRoute` is a type of {@link RouteDefinition} used to define an auxiliary route.
+ *
+ * It takes an object with the following properties:
+ * - `path` is a string that uses the route matcher DSL.
+ * - `component` a component type.
+ * - `name` is an optional `CamelCase` string representing the name of the route.
+ * - `data` is an optional property of any type representing arbitrary route metadata for the given
+ * route. It is injectable via {@link RouteData}.
+ *
+ * ### Example
+ * ```
+ * import {RouteConfig, AuxRoute} from 'angular2/router';
+ *
+ * @RouteConfig([
+ * new AuxRoute({path: '/home', component: HomeCmp})
+ * ])
+ * class MyApp {}
+ * ```
+ */
+ class AuxRoute implements RouteDefinition {
+
+ constructor({path, component, name}: {path: string, component: core.Type, name?: string});
+
+ data: {[key: string]: any};
+
+ path: string;
+
+ component: core.Type;
+
+ name: string;
+
+ aux: string;
+
+ loader: Function;
+
+ redirectTo: any[];
+
+ useAsDefault: boolean;
+
+ }
+
+
+ /**
+ * `AsyncRoute` is a type of {@link RouteDefinition} used to route a path to an asynchronously
+ * loaded component.
+ *
+ * It has the following properties:
+ * - `path` is a string that uses the route matcher DSL.
+ * - `loader` is a function that returns a promise that resolves to a component.
+ * - `name` is an optional `CamelCase` string representing the name of the route.
+ * - `data` is an optional property of any type representing arbitrary route metadata for the given
+ * route. It is injectable via {@link RouteData}.
+ * - `useAsDefault` is a boolean value. If `true`, the child route will be navigated to if no child
+ * route is specified during the navigation.
+ *
+ * ### Example
+ * ```
+ * import {RouteConfig} from 'angular2/router';
+ *
+ * @RouteConfig([
+ * {path: '/home', loader: () => Promise.resolve(MyLoadedCmp), name: 'MyLoadedCmp'}
+ * ])
+ * class MyApp {}
+ * ```
+ */
+ class AsyncRoute implements RouteDefinition {
+
+ constructor({path, loader, name, data, useAsDefault}: {
+ path: string,
+ loader: Function, name?: string, data?: {[key: string]: any}, useAsDefault?: boolean
+ });
+
+ data: {[key: string]: any};
+
+ path: string;
+
+ loader: Function;
+
+ name: string;
+
+ useAsDefault: boolean;
+
+ aux: string;
+
+ }
+
+
+ /**
+ * `RouteDefinition` defines a route within a {@link RouteConfig} decorator.
+ *
+ * Supported keys:
+ * - `path` or `aux` (requires exactly one of these)
+ * - `component`, `loader`, `redirectTo` (requires exactly one of these)
+ * - `name` or `as` (optional) (requires exactly one of these)
+ * - `data` (optional)
+ *
+ * See also {@link Route}, {@link AsyncRoute}, {@link AuxRoute}, and {@link Redirect}.
+ */
+ interface RouteDefinition {
+
+ path?: string;
+
+ aux?: string;
+
+ component?: core.Type | ComponentDefinition;
+
+ loader?: Function;
+
+ redirectTo?: any[];
+
+ as?: string;
+
+ name?: string;
+
+ data?: any;
+
+ useAsDefault?: boolean;
+
+ }
+
+
+ /**
+ * The `RouteConfig` decorator defines routes for a given component.
+ *
+ * It takes an array of {@link RouteDefinition}s.
+ */
+ var RouteConfig: (configs: RouteDefinition[]) => ClassDecorator;
+
+
+
+ /**
+ * Represents either a component type (`type` is `component`) or a loader function
+ * (`type` is `loader`).
+ *
+ * See also {@link RouteDefinition}.
+ */
+ interface ComponentDefinition {
+
+ type: string;
+
+ loader?: Function;
+
+ component?: core.Type;
+
+ }
+}
+
+export = ngRouter;
diff --git a/app/typings/angular2/router_amb.d.ts b/app/typings/angular2/router_amb.d.ts
new file mode 100644
index 0000000..6f9ed6d
--- /dev/null
+++ b/app/typings/angular2/router_amb.d.ts
@@ -0,0 +1,5 @@
+
+declare module "angular2/router" {
+ import * as ngRouter from 'router';
+ export = ngRouter;
+}
diff --git a/app/typings/main.d.ts b/app/typings/main.d.ts
new file mode 100644
index 0000000..3114385
--- /dev/null
+++ b/app/typings/main.d.ts
@@ -0,0 +1,3 @@
+/// <reference path="main/ambient/es6-promise/es6-promise.d.ts" />
+/// <reference path="main/ambient/es6-shim/es6-shim.d.ts" />
+/// <reference path="main/ambient/meteor/meteor.d.ts" />
diff --git a/app/typings/main/ambient/es6-promise/es6-promise.d.ts b/app/typings/main/ambient/es6-promise/es6-promise.d.ts
new file mode 100644
index 0000000..02c5a6c
--- /dev/null
+++ b/app/typings/main/ambient/es6-promise/es6-promise.d.ts
@@ -0,0 +1,77 @@
+// Compiled using typings@0.6.10
+// Source: https://raw.githubusercontent.com/DefinitelyTyped/DefinitelyTyped/e1699c41087960df7678f413312213fb1f980307/es6-promise/es6-promise.d.ts
+// Type definitions for es6-promise
+// Project: https://github.com/jakearchibald/ES6-Promise
+// Definitions by: François de Campredon <https://github.com/fdecampredon/>, vvakame <https://github.com/vvakame>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+interface Thenable<T> {
+ then<U>(onFulfilled?: (value: T) => U | Thenable<U>, onRejected?: (error: any) => U | Thenable<U>): Thenable<U>;
+ then<U>(onFulfilled?: (value: T) => U | Thenable<U>, onRejected?: (error: any) => void): Thenable<U>;
+ catch<U>(onRejected?: (error: any) => U | Thenable<U>): Thenable<U>;
+}
+
+declare class Promise<T> implements Thenable<T> {
+ /**
+ * If you call resolve in the body of the callback passed to the constructor,
+ * your promise is fulfilled with result object passed to resolve.
+ * If you call reject your promise is rejected with the object passed to reject.
+ * For consistency and debugging (eg stack traces), obj should be an instanceof Error.
+ * Any errors thrown in the constructor callback will be implicitly passed to reject().
+ */
+ constructor(callback: (resolve : (value?: T | Thenable<T>) => void, reject: (error?: any) => void) => void);
+
+ /**
+ * onFulfilled is called when/if "promise" resolves. onRejected is called when/if "promise" rejects.
+ * Both are optional, if either/both are omitted the next onFulfilled/onRejected in the chain is called.
+ * Both callbacks have a single parameter , the fulfillment value or rejection reason.
+ * "then" returns a new promise equivalent to the value you return from onFulfilled/onRejected after being passed through Promise.resolve.
+ * If an error is thrown in the callback, the returned promise rejects with that error.
+ *
+ * @param onFulfilled called when/if "promise" resolves
+ * @param onRejected called when/if "promise" rejects
+ */
+ then<U>(onFulfilled?: (value: T) => U | Thenable<U>, onRejected?: (error: any) => U | Thenable<U>): Promise<U>;
+ then<U>(onFulfilled?: (value: T) => U | Thenable<U>, onRejected?: (error: any) => void): Promise<U>;
+
+ /**
+ * Sugar for promise.then(undefined, onRejected)
+ *
+ * @param onRejected called when/if "promise" rejects
+ */
+ catch<U>(onRejected?: (error: any) => U | Thenable<U>): Promise<U>;
+}
+
+declare module Promise {
+ /**
+ * Make a new promise from the thenable.
+ * A thenable is promise-like in as far as it has a "then" method.
+ */
+ function resolve<T>(value?: T | Thenable<T>): Promise<T>;
+
+ /**
+ * Make a promise that rejects to obj. For consistency and debugging (eg stack traces), obj should be an instanceof Error
+ */
+ function reject(error: any): Promise<any>;
+ function reject<T>(error: T): Promise<T>;
+
+ /**
+ * Make a promise that fulfills when every item in the array fulfills, and rejects if (and when) any item rejects.
+ * the array passed to all can be a mixture of promise-like objects and other objects.
+ * The fulfillment value is an array (in order) of fulfillment values. The rejection value is the first rejection value.
+ */
+ function all<T>(promises: (T | Thenable<T>)[]): Promise<T[]>;
+
+ /**
+ * Make a Promise that fulfills when any item fulfills, and rejects if any item rejects.
+ */
+ function race<T>(promises: (T | Thenable<T>)[]): Promise<T>;
+}
+
+declare module 'es6-promise' {
+ var foo: typeof Promise; // Temp variable to reference Promise in local context
+ module rsvp {
+ export var Promise: typeof foo;
+ }
+ export = rsvp;
+}
\ No newline at end of file
diff --git a/app/typings/main/ambient/es6-shim/es6-shim.d.ts b/app/typings/main/ambient/es6-shim/es6-shim.d.ts
new file mode 100644
index 0000000..50f2134
--- /dev/null
+++ b/app/typings/main/ambient/es6-shim/es6-shim.d.ts
@@ -0,0 +1,670 @@
+// Compiled using typings@0.6.10
+// Source: https://raw.githubusercontent.com/DefinitelyTyped/DefinitelyTyped/4de74cb527395c13ba20b438c3a7a419ad931f1c/es6-shim/es6-shim.d.ts
+// Type definitions for es6-shim v0.31.2
+// Project: https://github.com/paulmillr/es6-shim
+// Definitions by: Ron Buckton <http://github.com/rbuckton>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare type PropertyKey = string | number | symbol;
+
+interface IteratorResult<T> {
+ done: boolean;
+ value?: T;
+}
+
+interface IterableShim<T> {
+ /**
+ * Shim for an ES6 iterable. Not intended for direct use by user code.
+ */
+ "_es6-shim iterator_"(): Iterator<T>;
+}
+
+interface Iterator<T> {
+ next(value?: any): IteratorResult<T>;
+ return?(value?: any): IteratorResult<T>;
+ throw?(e?: any): IteratorResult<T>;
+}
+
+interface IterableIteratorShim<T> extends IterableShim<T>, Iterator<T> {
+ /**
+ * Shim for an ES6 iterable iterator. Not intended for direct use by user code.
+ */
+ "_es6-shim iterator_"(): IterableIteratorShim<T>;
+}
+
+interface StringConstructor {
+ /**
+ * Return the String value whose elements are, in order, the elements in the List elements.
+ * If length is 0, the empty string is returned.
+ */
+ fromCodePoint(...codePoints: number[]): string;
+
+ /**
+ * String.raw is intended for use as a tag function of a Tagged Template String. When called
+ * as such the first argument will be a well formed template call site object and the rest
+ * parameter will contain the substitution values.
+ * @param template A well-formed template string call site representation.
+ * @param substitutions A set of substitution values.
+ */
+ raw(template: TemplateStringsArray, ...substitutions: any[]): string;
+}
+
+interface String {
+ /**
+ * Returns a nonnegative integer Number less than 1114112 (0x110000) that is the code point
+ * value of the UTF-16 encoded code point starting at the string element at position pos in
+ * the String resulting from converting this object to a String.
+ * If there is no element at that position, the result is undefined.
+ * If a valid UTF-16 surrogate pair does not begin at pos, the result is the code unit at pos.
+ */
+ codePointAt(pos: number): number;
+
+ /**
+ * Returns true if searchString appears as a substring of the result of converting this
+ * object to a String, at one or more positions that are
+ * greater than or equal to position; otherwise, returns false.
+ * @param searchString search string
+ * @param position If position is undefined, 0 is assumed, so as to search all of the String.
+ */
+ includes(searchString: string, position?: number): boolean;
+
+ /**
+ * Returns true if the sequence of elements of searchString converted to a String is the
+ * same as the corresponding elements of this object (converted to a String) starting at
+ * endPosition – length(this). Otherwise returns false.
+ */
+ endsWith(searchString: string, endPosition?: number): boolean;
+
+ /**
+ * Returns a String value that is made from count copies appended together. If count is 0,
+ * T is the empty String is returned.
+ * @param count number of copies to append
+ */
+ repeat(count: number): string;
+
+ /**
+ * Returns true if the sequence of elements of searchString converted to a String is the
+ * same as the corresponding elements of this object (converted to a String) starting at
+ * position. Otherwise returns false.
+ */
+ startsWith(searchString: string, position?: number): boolean;
+
+ /**
+ * Returns an <a> HTML anchor element and sets the name attribute to the text value
+ * @param name
+ */
+ anchor(name: string): string;
+
+ /** Returns a <big> HTML element */
+ big(): string;
+
+ /** Returns a <blink> HTML element */
+ blink(): string;
+
+ /** Returns a <b> HTML element */
+ bold(): string;
+
+ /** Returns a <tt> HTML element */
+ fixed(): string
+
+ /** Returns a <font> HTML element and sets the color attribute value */
+ fontcolor(color: string): string
+
+ /** Returns a <font> HTML element and sets the size attribute value */
+ fontsize(size: number): string;
+
+ /** Returns a <font> HTML element and sets the size attribute value */
+ fontsize(size: string): string;
+
+ /** Returns an <i> HTML element */
+ italics(): string;
+
+ /** Returns an <a> HTML element and sets the href attribute value */
+ link(url: string): string;
+
+ /** Returns a <small> HTML element */
+ small(): string;
+
+ /** Returns a <strike> HTML element */
+ strike(): string;
+
+ /** Returns a <sub> HTML element */
+ sub(): string;
+
+ /** Returns a <sup> HTML element */
+ sup(): string;
+
+ /**
+ * Shim for an ES6 iterable. Not intended for direct use by user code.
+ */
+ "_es6-shim iterator_"(): IterableIteratorShim<string>;
+}
+
+interface ArrayConstructor {
+ /**
+ * Creates an array from an array-like object.
+ * @param arrayLike An array-like object to convert to an array.
+ * @param mapfn A mapping function to call on every element of the array.
+ * @param thisArg Value of 'this' used to invoke the mapfn.
+ */
+ from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): Array<U>;
+
+ /**
+ * Creates an array from an iterable object.
+ * @param iterable An iterable object to convert to an array.
+ * @param mapfn A mapping function to call on every element of the array.
+ * @param thisArg Value of 'this' used to invoke the mapfn.
+ */
+ from<T, U>(iterable: IterableShim<T>, mapfn: (v: T, k: number) => U, thisArg?: any): Array<U>;
+
+ /**
+ * Creates an array from an array-like object.
+ * @param arrayLike An array-like object to convert to an array.
+ */
+ from<T>(arrayLike: ArrayLike<T>): Array<T>;
+
+ /**
+ * Creates an array from an iterable object.
+ * @param iterable An iterable object to convert to an array.
+ */
+ from<T>(iterable: IterableShim<T>): Array<T>;
+
+ /**
+ * Returns a new array from a set of elements.
+ * @param items A set of elements to include in the new array object.
+ */
+ of<T>(...items: T[]): Array<T>;
+}
+
+interface Array<T> {
+ /**
+ * Returns the value of the first element in the array where predicate is true, and undefined
+ * otherwise.
+ * @param predicate find calls predicate once for each element of the array, in ascending
+ * order, until it finds one where predicate returns true. If such an element is found, find
+ * immediately returns that element value. Otherwise, find returns undefined.
+ * @param thisArg If provided, it will be used as the this value for each invocation of
+ * predicate. If it is not provided, undefined is used instead.
+ */
+ find(predicate: (value: T, index: number, obj: Array<T>) => boolean, thisArg?: any): T;
+
+ /**
+ * Returns the index of the first element in the array where predicate is true, and undefined
+ * otherwise.
+ * @param predicate find calls predicate once for each element of the array, in ascending
+ * order, until it finds one where predicate returns true. If such an element is found, find
+ * immediately returns that element value. Otherwise, find returns undefined.
+ * @param thisArg If provided, it will be used as the this value for each invocation of
+ * predicate. If it is not provided, undefined is used instead.
+ */
+ findIndex(predicate: (value: T) => boolean, thisArg?: any): number;
+
+ /**
+ * Returns the this object after filling the section identified by start and end with value
+ * @param value value to fill array section with
+ * @param start index to start filling the array at. If start is negative, it is treated as
+ * length+start where length is the length of the array.
+ * @param end index to stop filling the array at. If end is negative, it is treated as
+ * length+end.
+ */
+ fill(value: T, start?: number, end?: number): T[];
+
+ /**
+ * Returns the this object after copying a section of the array identified by start and end
+ * to the same array starting at position target
+ * @param target If target is negative, it is treated as length+target where length is the
+ * length of the array.
+ * @param start If start is negative, it is treated as length+start. If end is negative, it
+ * is treated as length+end.
+ * @param end If not specified, length of the this object is used as its default value.
+ */
+ copyWithin(target: number, start: number, end?: number): T[];
+
+ /**
+ * Returns an array of key, value pairs for every entry in the array
+ */
+ entries(): IterableIteratorShim<[number, T]>;
+
+ /**
+ * Returns an list of keys in the array
+ */
+ keys(): IterableIteratorShim<number>;
+
+ /**
+ * Returns an list of values in the array
+ */
+ values(): IterableIteratorShim<T>;
+
+ /**
+ * Shim for an ES6 iterable. Not intended for direct use by user code.
+ */
+ "_es6-shim iterator_"(): IterableIteratorShim<T>;
+}
+
+interface NumberConstructor {
+ /**
+ * The value of Number.EPSILON is the difference between 1 and the smallest value greater than 1
+ * that is representable as a Number value, which is approximately:
+ * 2.2204460492503130808472633361816 x 10−16.
+ */
+ EPSILON: number;
+
+ /**
+ * Returns true if passed value is finite.
+ * Unlike the global isFininte, Number.isFinite doesn't forcibly convert the parameter to a
+ * number. Only finite values of the type number, result in true.
+ * @param number A numeric value.
+ */
+ isFinite(number: number): boolean;
+
+ /**
+ * Returns true if the value passed is an integer, false otherwise.
+ * @param number A numeric value.
+ */
+ isInteger(number: number): boolean;
+
+ /**
+ * Returns a Boolean value that indicates whether a value is the reserved value NaN (not a
+ * number). Unlike the global isNaN(), Number.isNaN() doesn't forcefully convert the parameter
+ * to a number. Only values of the type number, that are also NaN, result in true.
+ * @param number A numeric value.
+ */
+ isNaN(number: number): boolean;
+
+ /**
+ * Returns true if the value passed is a safe integer.
+ * @param number A numeric value.
+ */
+ isSafeInteger(number: number): boolean;
+
+ /**
+ * The value of the largest integer n such that n and n + 1 are both exactly representable as
+ * a Number value.
+ * The value of Number.MIN_SAFE_INTEGER is 9007199254740991 2^53 − 1.
+ */
+ MAX_SAFE_INTEGER: number;
+
+ /**
+ * The value of the smallest integer n such that n and n − 1 are both exactly representable as
+ * a Number value.
+ * The value of Number.MIN_SAFE_INTEGER is −9007199254740991 (−(2^53 − 1)).
+ */
+ MIN_SAFE_INTEGER: number;
+
+ /**
+ * Converts a string to a floating-point number.
+ * @param string A string that contains a floating-point number.
+ */
+ parseFloat(string: string): number;
+
+ /**
+ * Converts A string to an integer.
+ * @param s A string to convert into a number.
+ * @param radix A value between 2 and 36 that specifies the base of the number in numString.
+ * If this argument is not supplied, strings with a prefix of '0x' are considered hexadecimal.
+ * All other strings are considered decimal.
+ */
+ parseInt(string: string, radix?: number): number;
+}
+
+interface ObjectConstructor {
+ /**
+ * Copy the values of all of the enumerable own properties from one or more source objects to a
+ * target object. Returns the target object.
+ * @param target The target object to copy to.
+ * @param sources One or more source objects to copy properties from.
+ */
+ assign(target: any, ...sources: any[]): any;
+
+ /**
+ * Returns true if the values are the same value, false otherwise.
+ * @param value1 The first value.
+ * @param value2 The second value.
+ */
+ is(value1: any, value2: any): boolean;
+
+ /**
+ * Sets the prototype of a specified object o to object proto or null. Returns the object o.
+ * @param o The object to change its prototype.
+ * @param proto The value of the new prototype or null.
+ * @remarks Requires `__proto__` support.
+ */
+ setPrototypeOf(o: any, proto: any): any;
+}
+
+interface RegExp {
+ /**
+ * Returns a string indicating the flags of the regular expression in question. This field is read-only.
+ * The characters in this string are sequenced and concatenated in the following order:
+ *
+ * - "g" for global
+ * - "i" for ignoreCase
+ * - "m" for multiline
+ * - "u" for unicode
+ * - "y" for sticky
+ *
+ * If no flags are set, the value is the empty string.
+ */
+ flags: string;
+}
+
+interface Math {
+ /**
+ * Returns the number of leading zero bits in the 32-bit binary representation of a number.
+ * @param x A numeric expression.
+ */
+ clz32(x: number): number;
+
+ /**
+ * Returns the result of 32-bit multiplication of two numbers.
+ * @param x First number
+ * @param y Second number
+ */
+ imul(x: number, y: number): number;
+
+ /**
+ * Returns the sign of the x, indicating whether x is positive, negative or zero.
+ * @param x The numeric expression to test
+ */
+ sign(x: number): number;
+
+ /**
+ * Returns the base 10 logarithm of a number.
+ * @param x A numeric expression.
+ */
+ log10(x: number): number;
+
+ /**
+ * Returns the base 2 logarithm of a number.
+ * @param x A numeric expression.
+ */
+ log2(x: number): number;
+
+ /**
+ * Returns the natural logarithm of 1 + x.
+ * @param x A numeric expression.
+ */
+ log1p(x: number): number;
+
+ /**
+ * Returns the result of (e^x - 1) of x (e raised to the power of x, where e is the base of
+ * the natural logarithms).
+ * @param x A numeric expression.
+ */
+ expm1(x: number): number;
+
+ /**
+ * Returns the hyperbolic cosine of a number.
+ * @param x A numeric expression that contains an angle measured in radians.
+ */
+ cosh(x: number): number;
+
+ /**
+ * Returns the hyperbolic sine of a number.
+ * @param x A numeric expression that contains an angle measured in radians.
+ */
+ sinh(x: number): number;
+
+ /**
+ * Returns the hyperbolic tangent of a number.
+ * @param x A numeric expression that contains an angle measured in radians.
+ */
+ tanh(x: number): number;
+
+ /**
+ * Returns the inverse hyperbolic cosine of a number.
+ * @param x A numeric expression that contains an angle measured in radians.
+ */
+ acosh(x: number): number;
+
+ /**
+ * Returns the inverse hyperbolic sine of a number.
+ * @param x A numeric expression that contains an angle measured in radians.
+ */
+ asinh(x: number): number;
+
+ /**
+ * Returns the inverse hyperbolic tangent of a number.
+ * @param x A numeric expression that contains an angle measured in radians.
+ */
+ atanh(x: number): number;
+
+ /**
+ * Returns the square root of the sum of squares of its arguments.
+ * @param values Values to compute the square root for.
+ * If no arguments are passed, the result is +0.
+ * If there is only one argument, the result is the absolute value.
+ * If any argument is +Infinity or -Infinity, the result is +Infinity.
+ * If any argument is NaN, the result is NaN.
+ * If all arguments are either +0 or −0, the result is +0.
+ */
+ hypot(...values: number[]): number;
+
+ /**
+ * Returns the integral part of the a numeric expression, x, removing any fractional digits.
+ * If x is already an integer, the result is x.
+ * @param x A numeric expression.
+ */
+ trunc(x: number): number;
+
+ /**
+ * Returns the nearest single precision float representation of a number.
+ * @param x A numeric expression.
+ */
+ fround(x: number): number;
+
+ /**
+ * Returns an implementation-dependent approximation to the cube root of number.
+ * @param x A numeric expression.
+ */
+ cbrt(x: number): number;
+}
+
+interface PromiseLike<T> {
+ /**
+ * Attaches callbacks for the resolution and/or rejection of the Promise.
+ * @param onfulfilled The callback to execute when the Promise is resolved.
+ * @param onrejected The callback to execute when the Promise is rejected.
+ * @returns A Promise for the completion of which ever callback is executed.
+ */
+ then<TResult>(onfulfilled?: (value: T) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => TResult | PromiseLike<TResult>): PromiseLike<TResult>;
+ then<TResult>(onfulfilled?: (value: T) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => void): PromiseLike<TResult>;
+}
+
+/**
+ * Represents the completion of an asynchronous operation
+ */
+interface Promise<T> {
+ /**
+ * Attaches callbacks for the resolution and/or rejection of the Promise.
+ * @param onfulfilled The callback to execute when the Promise is resolved.
+ * @param onrejected The callback to execute when the Promise is rejected.
+ * @returns A Promise for the completion of which ever callback is executed.
+ */
+ then<TResult>(onfulfilled?: (value: T) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => TResult | PromiseLike<TResult>): Promise<TResult>;
+ then<TResult>(onfulfilled?: (value: T) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => void): Promise<TResult>;
+
+ /**
+ * Attaches a callback for only the rejection of the Promise.
+ * @param onrejected The callback to execute when the Promise is rejected.
+ * @returns A Promise for the completion of the callback.
+ */
+ catch(onrejected?: (reason: any) => T | PromiseLike<T>): Promise<T>;
+ catch(onrejected?: (reason: any) => void): Promise<T>;
+}
+
+interface PromiseConstructor {
+ /**
+ * A reference to the prototype.
+ */
+ prototype: Promise<any>;
+
+ /**
+ * Creates a new Promise.
+ * @param executor A callback used to initialize the promise. This callback is passed two arguments:
+ * a resolve callback used resolve the promise with a value or the result of another promise,
+ * and a reject callback used to reject the promise with a provided reason or error.
+ */
+ new <T>(executor: (resolve: (value?: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void): Promise<T>;
+
+ /**
+ * Creates a Promise that is resolved with an array of results when all of the provided Promises
+ * resolve, or rejected when any Promise is rejected.
+ * @param values An array of Promises.
+ * @returns A new Promise.
+ */
+ all<T>(values: IterableShim<T | PromiseLike<T>>): Promise<T[]>;
+
+ /**
+ * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
+ * or rejected.
+ * @param values An array of Promises.
+ * @returns A new Promise.
+ */
+ race<T>(values: IterableShim<T | PromiseLike<T>>): Promise<T>;
+
+ /**
+ * Creates a new rejected promise for the provided reason.
+ * @param reason The reason the promise was rejected.
+ * @returns A new rejected Promise.
+ */
+ reject(reason: any): Promise<void>;
+
+ /**
+ * Creates a new rejected promise for the provided reason.
+ * @param reason The reason the promise was rejected.
+ * @returns A new rejected Promise.
+ */
+ reject<T>(reason: any): Promise<T>;
+
+ /**
+ * Creates a new resolved promise for the provided value.
+ * @param value A promise.
+ * @returns A promise whose internal state matches the provided promise.
+ */
+ resolve<T>(value: T | PromiseLike<T>): Promise<T>;
+
+ /**
+ * Creates a new resolved promise .
+ * @returns A resolved promise.
+ */
+ resolve(): Promise<void>;
+}
+
+declare var Promise: PromiseConstructor;
+
+interface Map<K, V> {
+ clear(): void;
+ delete(key: K): boolean;
+ forEach(callbackfn: (value: V, index: K, map: Map<K, V>) => void, thisArg?: any): void;
+ get(key: K): V;
+ has(key: K): boolean;
+ set(key: K, value?: V): Map<K, V>;
+ size: number;
+ entries(): IterableIteratorShim<[K, V]>;
+ keys(): IterableIteratorShim<K>;
+ values(): IterableIteratorShim<V>;
+}
+
+interface MapConstructor {
+ new <K, V>(): Map<K, V>;
+ new <K, V>(iterable: IterableShim<[K, V]>): Map<K, V>;
+ prototype: Map<any, any>;
+}
+
+declare var Map: MapConstructor;
+
+interface Set<T> {
+ add(value: T): Set<T>;
+ clear(): void;
+ delete(value: T): boolean;
+ forEach(callbackfn: (value: T, index: T, set: Set<T>) => void, thisArg?: any): void;
+ has(value: T): boolean;
+ size: number;
+ entries(): IterableIteratorShim<[T, T]>;
+ keys(): IterableIteratorShim<T>;
+ values(): IterableIteratorShim<T>;
+}
+
+interface SetConstructor {
+ new <T>(): Set<T>;
+ new <T>(iterable: IterableShim<T>): Set<T>;
+ prototype: Set<any>;
+}
+
+declare var Set: SetConstructor;
+
+interface WeakMap<K, V> {
+ delete(key: K): boolean;
+ get(key: K): V;
+ has(key: K): boolean;
+ set(key: K, value?: V): WeakMap<K, V>;
+}
+
+interface WeakMapConstructor {
+ new <K, V>(): WeakMap<K, V>;
+ new <K, V>(iterable: IterableShim<[K, V]>): WeakMap<K, V>;
+ prototype: WeakMap<any, any>;
+}
+
+declare var WeakMap: WeakMapConstructor;
+
+interface WeakSet<T> {
+ add(value: T): WeakSet<T>;
+ delete(value: T): boolean;
+ has(value: T): boolean;
+}
+
+interface WeakSetConstructor {
+ new <T>(): WeakSet<T>;
+ new <T>(iterable: IterableShim<T>): WeakSet<T>;
+ prototype: WeakSet<any>;
+}
+
+declare var WeakSet: WeakSetConstructor;
+
+declare module Reflect {
+ function apply(target: Function, thisArgument: any, argumentsList: ArrayLike<any>): any;
+ function construct(target: Function, argumentsList: ArrayLike<any>): any;
+ function defineProperty(target: any, propertyKey: PropertyKey, attributes: PropertyDescriptor): boolean;
+ function deleteProperty(target: any, propertyKey: PropertyKey): boolean;
+ function enumerate(target: any): IterableIteratorShim<any>;
+ function get(target: any, propertyKey: PropertyKey, receiver?: any): any;
+ function getOwnPropertyDescriptor(target: any, propertyKey: PropertyKey): PropertyDescriptor;
+ function getPrototypeOf(target: any): any;
+ function has(target: any, propertyKey: PropertyKey): boolean;
+ function isExtensible(target: any): boolean;
+ function ownKeys(target: any): Array<PropertyKey>;
+ function preventExtensions(target: any): boolean;
+ function set(target: any, propertyKey: PropertyKey, value: any, receiver?: any): boolean;
+ function setPrototypeOf(target: any, proto: any): boolean;
+}
+
+declare module "es6-shim" {
+ var String: StringConstructor;
+ var Array: ArrayConstructor;
+ var Number: NumberConstructor;
+ var Math: Math;
+ var Object: ObjectConstructor;
+ var Map: MapConstructor;
+ var Set: SetConstructor;
+ var WeakMap: WeakMapConstructor;
+ var WeakSet: WeakSetConstructor;
+ var Promise: PromiseConstructor;
+ module Reflect {
+ function apply(target: Function, thisArgument: any, argumentsList: ArrayLike<any>): any;
+ function construct(target: Function, argumentsList: ArrayLike<any>): any;
+ function defineProperty(target: any, propertyKey: PropertyKey, attributes: PropertyDescriptor): boolean;
+ function deleteProperty(target: any, propertyKey: PropertyKey): boolean;
+ function enumerate(target: any): Iterator<any>;
+ function get(target: any, propertyKey: PropertyKey, receiver?: any): any;
+ function getOwnPropertyDescriptor(target: any, propertyKey: PropertyKey): PropertyDescriptor;
+ function getPrototypeOf(target: any): any;
+ function has(target: any, propertyKey: PropertyKey): boolean;
+ function isExtensible(target: any): boolean;
+ function ownKeys(target: any): Array<PropertyKey>;
+ function preventExtensions(target: any): boolean;
+ function set(target: any, propertyKey: PropertyKey, value: any, receiver?: any): boolean;
+ function setPrototypeOf(target: any, proto: any): boolean;
+ }
+}
\ No newline at end of file
diff --git a/app/typings/main/ambient/meteor/meteor.d.ts b/app/typings/main/ambient/meteor/meteor.d.ts
new file mode 100644
index 0000000..8702374
--- /dev/null
+++ b/app/typings/main/ambient/meteor/meteor.d.ts
@@ -0,0 +1,632 @@
+// Compiled using typings@0.6.9
+// Source: https://raw.githubusercontent.com/DefinitelyTyped/DefinitelyTyped/26ce5ade660b3386773d1964d727192f30231f9e/meteor/meteor.d.ts
+// Type definitions for Meteor 0.9.1
+// Project: http://www.meteor.com/
+// Definitions by: Dave Allen <https://github.com/fullflavedave>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/**
+ * These are the modules and interfaces that can't be automatically generated from the Meteor api.js file
+ */
+declare module Meteor {
+ interface EJSONObject extends Object {}
+
+ interface LoginWithExternalServiceOptions {
+ requestPermissions?: string[];
+ requestOfflineToken?: Boolean;
+ forceApprovalPrompt?: Boolean;
+ userEmail?: string;
+ }
+
+ function loginWithMeteorDeveloperAccount(options?: Meteor.LoginWithExternalServiceOptions, callback?: Function): void;
+ function loginWithFacebook(options?: Meteor.LoginWithExternalServiceOptions, callback?: Function): void;
+ function loginWithGithub(options?: Meteor.LoginWithExternalServiceOptions, callback?: Function): void;
+ function loginWithGoogle(options?: Meteor.LoginWithExternalServiceOptions, callback?: Function): void;
+ function loginWithMeetup(options?: Meteor.LoginWithExternalServiceOptions, callback?: Function): void;
+ function loginWithTwitter(options?: Meteor.LoginWithExternalServiceOptions, callback?: Function): void;
+ function loginWithWeibo(options?: Meteor.LoginWithExternalServiceOptions, callback?: Function): void;
+
+ interface UserEmail {
+ address:string;
+ verified:boolean;
+ }
+
+ interface User {
+ _id?:string;
+ username?:string;
+ emails?:Meteor.UserEmail[];
+ createdAt?: number;
+ profile?: any;
+ services?: any;
+ }
+
+ interface SubscriptionHandle {
+ stop(): void;
+ ready(): boolean;
+ }
+
+ interface TemplateBase {
+ [templateName: string]: Meteor.Template;
+ }
+
+ interface RenderedTemplate extends Object {}
+
+ interface DataContext extends Object {}
+
+ interface Tinytest {
+ add(name:string, func:Function);
+ addAsync(name:string, func:Function);
+ }
+
+ enum StatusEnum {
+ connected,
+ connecting,
+ failed,
+ waiting,
+ offline
+ }
+
+ interface LiveQueryHandle {
+ stop(): void;
+ }
+
+ interface EmailFields {
+ subject?: Function;
+ text?: Function;
+ }
+
+ interface EmailTemplates {
+ from: string;
+ siteName: string;
+ resetPassword: Meteor.EmailFields;
+ enrollAccount: Meteor.EmailFields;
+ verifyEmail: Meteor.EmailFields;
+ }
+
+ interface AccountsBase {
+ EmailTemplates: {
+ from: string;
+ siteName: string;
+ resetPassword: Meteor.EmailFields;
+ enrollAccount: Meteor.EmailFields;
+ verifyEmail: Meteor.EmailFields;
+ }
+ loginServicesConfigured(): boolean;
+ }
+
+ interface MatchBase {
+ Any;
+ String;
+ Integer;
+ Boolean;
+ undefined;
+ null;
+ Object;
+ Optional(pattern):boolean;
+ ObjectIncluding(dico):boolean;
+ OneOf(...patterns);
+ Where(condition);
+ }
+
+ interface AllowDenyOptions {
+ insert?: (userId:string, doc) => boolean;
+ update?: (userId, doc, fieldNames, modifier) => boolean;
+ remove?: (userId, doc) => boolean;
+ fetch?: string[];
+ transform?: Function;
+ }
+
+ interface Error {
+ error: number;
+ reason?: string;
+ details?: string;
+ }
+}
+
+declare module Mongo {
+ interface CollectionFieldSpecifier {
+ [id: string]: Number;
+ }
+
+ enum CollectionIdGenerationEnum {
+ STRING,
+ MONGO
+ }
+
+// interface CollectionOptions {
+// connection: Object;
+// idGeneration: Mongo.CollectionIdGenerationEnum;
+// transform?: (document)=>any;
+// }
+//
+// function Collection<T>(name:string, options?: Mongo.CollectionOptions) : void;
+}
+
+declare module Tracker {
+ function Computation(): void;
+ interface Computation {
+
+ }
+ function Dependency(): void;
+ interface Dependency {
+ changed(): void;
+ depend(fromComputation: Tracker.Computation): boolean;
+ hasDependents(): boolean;
+ }
+}
+
+declare module Package {
+ function describe(metadata:PackageDescribeAPI);
+ function on_use(func:{(api:Api, where?:string[]):void});
+ function on_use(func:{(api:Api, where?:string):void});
+ function on_test(func:{(api:Api):void}) ;
+ function register_extension(extension:string, options:PackageRegisterExtensionOptions);
+ interface PackageRegisterExtensionOptions {(bundle:Bundle, source_path:string, serve_path:string, where?:string[]):void}
+ interface PackageDescribeAPI {
+ summary: string;
+ }
+ interface Api {
+ export(variable:string);
+ export(variables:string[]);
+ use(deps:string, where?:string[]);
+ use(deps:string, where?:string);
+ use(deps:string[], where?:string[]);
+ use(deps:string[], where?:string);
+ add_files(file:string, where?:string[]);
+ add_files(file:string, where?:string);
+ add_files(file:string[], where?:string[]);
+ add_files(file:string[], where?:string);
+ imply(package:string);
+ imply(packages:string[]);
+ }
+ interface BundleOptions {
+ type: string;
+ path: string;
+ data: any;
+ where: string[];
+ }
+ interface Bundle {
+ add_resource(options:BundleOptions);
+ error(diagnostics:string);
+ }
+}
+
+declare module Npm {
+ function require(module:string);
+ function depends(dependencies:{[id:string]:string});
+}
+
+declare module HTTP {
+ enum HTTPMethodEnum {
+ GET,
+ POST,
+ PUT,
+ DELETE
+ }
+
+ interface HTTPRequest {
+ content?:string;
+ data?:any;
+ query?:string;
+ params?:{[id:string]:string};
+ auth?:string;
+ headers?:{[id:string]:string};
+ timeout?:number;
+ followRedirects?:boolean;
+ }
+
+ interface HTTPResponse {
+ statusCode:number;
+ content:string;
+ // response is not always json
+ data:any;
+ headers:{[id:string]:string};
+ }
+}
+
+declare module Email {
+ interface EmailMessage {
+ from: string;
+ to: any; // string or string[]
+ cc?: any; // string or string[]
+ bcc?: any; // string or string[]
+ replyTo?: any; // string or string[]
+ subject: string;
+ text?: string;
+ html?: string;
+ headers?: {[id: string]: string};
+ }
+}
+
+declare module DDP {
+ interface DDPStatic {
+ subscribe(name, ...rest);
+ call(method:string, ...parameters):void;
+ apply(method:string, ...parameters):void;
+ methods(IMeteorMethodsDictionary);
+ status():DDPStatus;
+ reconnect();
+ disconnect();
+ onReconnect();
+ }
+
+ interface DDPStatus {
+ connected: boolean;
+ status: Meteor.StatusEnum;
+ retryCount: number;
+ //To turn this into an interval until the next reconnection, use retryTime - (new Date()).getTime()
+ retryTime?: number;
+ reason?: string;
+ }
+}
+
+declare module Random {
+ function fraction():number;
+ function hexString(numberOfDigits:number):string; // @param numberOfDigits, @returns a random hex string of the given length
+ function choice(array:any[]):string; // @param array, @return a random element in array
+ function choice(str:string):string; // @param str, @return a random char in str
+}
+
+declare module Blaze {
+ interface View {
+ name: string;
+ parentView: Blaze.View;
+ isCreated: boolean;
+ isRendered: boolean;
+ isDestroyed: boolean;
+ renderCount: number;
+ autorun(runFunc: Function): void;
+ onViewCreated(func: Function): void;
+ onViewReady(func: Function): void;
+ onViewDestroyed(func: Function): void;
+ firstNode(): Node;
+ lastNode(): Node;
+ template: Blaze.Template;
+ templateInstance(): any;
+ }
+ interface Template {
+ viewName: string;
+ renderFunction: Function;
+ constructView(): Blaze.View;
+ }
+}
+
+/**
+ * These modules and interfaces are automatically generated from the Meteor api.js file
+ */
+declare module Meteor {
+ var isClient: boolean;
+ var isServer: boolean;
+ var isCordova: boolean;
+ function startup(func: Function): void;
+ function wrapAsync(func: Function, context?: Object): any;
+ function absoluteUrl(path?: string, options?: {
+ secure?: Boolean;
+ replaceLocalhost?: Boolean;
+ rootUrl?: string;
+ }): string;
+ var settings: {[id:string]: any};
+ var release: string;
+ function publish(name: string, func: Function): void;
+ function subscribe(name, ...args): SubscriptionHandle;
+ function methods(methods: Object): void;
+ function Error(error, reason?, details?): void;
+ function call(name: string, ...params): void;
+ function apply(name: string, params, options?: {
+ wait?: Boolean;
+ onResultReceived?: Function;
+ }, asyncCallback?): void;
+ function status(): Meteor.StatusEnum;
+ function reconnect(): void;
+ function disconnect(): void;
+ function onConnection(callback: Function): void;
+ function user(): Meteor.User;
+ function userId(): string;
+ var users: Mongo.Collection<User>;
+ function loggingIn(): boolean;
+ function logout(callback?: Function): void;
+ function logoutOtherClients(callback?: Function): void;
+ function loginWithPassword(user: any, password: string, callback?: Function): void;
+ function loginWithExternalService(options?: {
+ requestPermissions?: string[];
+ requestOfflineToken?: Boolean;
+ forceApprovalPrompt?: Boolean;
+ userEmail?: string;
+ loginStyle?: string;
+ }, callback?: Function): void;
+ function setTimeout(func: Function, delay: number): number;
+ function setInterval(func: Function, delay: number): number;
+ function clearTimeout(id: number): void;
+ function clearInterval(id: number): void;
+ function EnvironmentVariable(): void;
+ function get(): string;
+ function withValue(value: any, func: Function): void;
+ function bindEnvironment(func: Function, onException: Function, _this: Object): Function;
+}
+
+declare module Meteor {
+ interface EJSON {
+ parse(str: string): EJSON;
+ stringify(val: Meteor.EJSON, options?: {
+ indent?: any; // boolean, integer, or string
+ canonical?: Boolean;
+ }): string;
+ fromJSONValue(val: JSON): any;
+ toJSONValue(val: Meteor.EJSON): JSON;
+ equals(a: Meteor.EJSONObject, b: Meteor.EJSONObject, options?: {
+ keyOrderSensitive?: Boolean;
+ }): boolean;
+ clone<T>(v:T): T; /** TODO: add return value **/
+ newBinary(size: number): any;
+ isBinary(x): boolean;
+ addType(name: string, factory: Function): void;
+ }
+}
+
+declare module DDP {
+ function connect(url: string): DDP.DDPStatic;
+}
+
+declare module Mongo {
+ function Collection<T>(name: string, options?: {
+ connection?: Object;
+ idGeneration?: Mongo.CollectionIdGenerationEnum;
+ transform?: (document)=>any;
+ }): void;
+ function ObjectID(hexString: string): void;
+}
+
+declare module Mongo {
+ interface Collection<T> {
+ find(selector?: any, options?: {
+ sort?: any;
+ skip?: number;
+ limit?: number;
+ fields?: Mongo.CollectionFieldSpecifier;
+ reactive?: Boolean;
+ transform?: (document)=>any;
+ }): Mongo.Cursor<T>;
+ findOne(selector?: any, options?: {
+ sort?: any;
+ skip?: number;
+ fields?: Mongo.CollectionFieldSpecifier;
+ reactive?: Boolean;
+ transform?: (document)=>any;
+ }): Meteor.EJSONObject;
+ insert(doc: Object, callback?: Function): string;
+ update(selector: any, modifier: any, options?: {
+ multi?: Boolean;
+ upsert?: Boolean;
+ }, callback?: Function): number;
+ upsert(selector: any, modifier: any, options?: {
+ multi?: Boolean;
+ }, callback?: Function): {numberAffected?: number; insertedId?: string;};
+ remove(selector: any, callback?: Function): void;
+ allow(options: Meteor.AllowDenyOptions): boolean;
+ deny(options: Meteor.AllowDenyOptions): boolean;
+ }
+}
+
+declare module Mongo {
+ interface Cursor<T> {
+ count(): number;
+ fetch(): any[];
+ forEach(callback: Function, thisArg?: any): void;
+ map(callback: Function, thisArg?: any): void;
+ observe(callbacks: Object): Meteor.LiveQueryHandle;
+ observeChanges(callbacks: Object): Meteor.LiveQueryHandle;
+ }
+}
+
+declare module Random {
+ function id(): string;
+}
+
+declare module Tracker {
+ function autorun(runFunc: Function): Tracker.Computation;
+ function flush(): void;
+ function nonreactive(func: Function): void;
+ var active: boolean;
+ var currentComputation: Tracker.Computation;
+ function onInvalidate(callback: Function): void;
+ function afterFlush(callback: Function): void;
+}
+
+declare module Tracker {
+ interface Computation {
+ stop(): void;
+ invalidate(): void;
+ onInvalidate(callback: Function): void;
+ stopped: boolean;
+ invalidated: boolean;
+ firstRun: boolean;
+ }
+}
+
+declare module Tracker {
+ interface Dependency {
+ changed(): void;
+ depend(fromComputation?: Tracker.Computation): boolean;
+ hasDependents(): boolean;
+ }
+}
+
+declare module Meteor {
+ interface Accounts extends Meteor.AccountsBase {
+ config(options: {
+ sendVerificationEmail?: Boolean;
+ forbidClientAccountCreation?: Boolean;
+ restrictCreationByEmailDomain?: any; // string or Function
+ loginExpirationInDays?: number;
+ oauthSecretKey?: string;
+ }): void;
+ ui: {
+ config(options: {
+ requestPermissions?: Object;
+ requestOfflineToken?: Object;
+ forceApprovalPrompt?: Boolean;
+ passwordSignupFields?: string;
+ }); /** TODO: add return value **/
+ }
+ validateNewUser(func: Function): void;
+ onCreateUser(func: Function): void;
+ validateLoginAttempt(func: Function); /** TODO: add return value **/
+ onLogin(func: Function); /** TODO: add return value **/
+ onLoginFailure(func: Function); /** TODO: add return value **/
+ createUser(options: {
+ username?: string;
+ email?: string;
+ password?: string;
+ profile?: Object;
+ }, callback?: Function): string;
+ changePassword(oldPassword: string, newPassword: string, callback?: Function): void;
+ forgotPassword(options: {
+ email?: string;
+ }, callback?: Function): void;
+ resetPassword(token: string, newPassword: string, callback?: Function): void;
+ setPassword(userId: string, newPassword: string): void;
+ verifyEmail(token: string, callback?: Function): void;
+ sendResetPasswordEmail(userId: string, email?: string): void;
+ sendEnrollmentEmail(userId: string, email?: string): void;
+ sendVerificationEmail(userId: string, email?: string): void;
+ emailTemplates: Meteor.EmailTemplates;
+ }
+}
+
+declare module Meteor {
+ interface Match extends Meteor.MatchBase {
+ test(value: any, pattern: any): boolean;
+ }
+}
+
+declare module Meteor {
+ interface Session {
+ set(key: string, value: any): void;
+ setDefault(key: string, value: any): void;
+ get(key: string): any;
+ equals(key: string, value: any): boolean;
+ }
+}
+
+declare module HTTP {
+ function call(method: string, url, options?: {
+ content?: string;
+ data?: Object;
+ query?: string;
+ params?: Object;
+ auth?: string;
+ headers?: Object;
+ timeout?: number;
+ followRedirects?: Boolean;
+ }, asyncCallback?): HTTP.HTTPResponse;
+ function get(url, options?: {
+ }, asyncCallback?): HTTP.HTTPResponse;
+ function post(url, options?: {
+ }, asyncCallback?): HTTP.HTTPResponse;
+ function put(url, options?: {
+ }, asyncCallback?): HTTP.HTTPResponse;
+ function del(url, options?: {
+ }, asyncCallback?): HTTP.HTTPResponse;
+}
+
+declare module Meteor {
+ interface Template {
+ rendered: Function;
+ created: Function;
+ destroyed: Function;
+ events(eventMap: {[id:string]: Function}): void;
+ helpers(helpers: Object): void;
+ findAll(selector: string); /** TODO: add return value **/
+ $(selector: string); /** TODO: add return value **/
+ find(selector?: string); /** TODO: add return value **/
+ firstNode; /** TODO: add return value **/
+ lastNode; /** TODO: add return value **/
+ data; /** TODO: add return value **/
+ autorun(runFunc: Function); /** TODO: add return value **/
+ view; /** TODO: add return value **/
+ registerHelper(name: string, func: Function); /** TODO: add return value **/
+ body; /** TODO: add return value **/
+ currentData(); /** TODO: add return value **/
+ instance(); /** TODO: add return value **/
+ parentData(numLevels: number); /** TODO: add return value **/
+ }
+}
+
+declare module Blaze {
+ function render(templateOrView: any, parentNode: Node, nextNode?: Node, parentView?: Blaze.View): Blaze.View;
+ function renderWithData(templateOrView: any, data: any, parentNode: Node, nextNode?: Node, parentView?: Blaze.View): Blaze.View;
+ function remove(renderedView: Blaze.View): void;
+ function With(data: any, contentFunc: Function); /** TODO: add return value **/
+ function If(conditionFunc: Function, contentFunc: Function, elseFunc?: Function); /** TODO: add return value **/
+ function Unless(conditionFunc: Function, contentFunc: Function, elseFunc?: Function); /** TODO: add return value **/
+ function Each(argFunc: Function, contentFunc: Function, elseFunc?: Function); /** TODO: add return value **/
+ function getData(elementOrView?: any); /** TODO: add return value **/
+ var currentView; /** TODO: add return value **/
+ function getView(element?: HTMLElement); /** TODO: add return value **/
+ function toHTML(templateOrView: any): string;
+ function toHTMLWithData(templateOrView: any, data: any): string;
+ function View(name?: string, renderFunction?: Function): void;
+ function Template(viewName?: string, renderFunction?: Function): void;
+ function isTemplate(value: any): boolean;
+}
+
+declare module Meteor {
+ interface ReactiveVar {
+ get(); /** TODO: add return value **/
+ set(newValue: any); /** TODO: add return value **/
+ }
+}
+
+declare module Email {
+ function send(options: {
+ from?: string;
+ to?: any; // string or string[]
+ cc?: any; // string or string[]
+ bcc?: any; // string or string[]
+ replyTo?: any; // string or string[]
+ subject?: string;
+ text?: string;
+ html?: string;
+ headers?: Object;
+ }): void;
+}
+
+declare module Assets {
+ function getText(assetPath: string, asyncCallback?: Function): string;
+ function getBinary(assetPath: string, asyncCallback?: Function): Meteor.EJSON;
+}
+
+declare module Meteor {
+ interface Package {
+ describe(options: {
+ summary?: string;
+ version?: string;
+ name?: string;
+ git?: string;
+ }); /** TODO: add return value **/
+ onUse(f: Function); /** TODO: add return value **/
+ onTest(f: Function); /** TODO: add return value **/
+ describe(options: {
+ }); /** TODO: add return value **/
+ }
+}
+
+declare module Meteor {
+ interface Api {
+ use(packageNameAndVersion?: string, architecture?: string, options?: {
+ weak?: Boolean;
+ unordered?: Boolean;
+ }); /** TODO: add return value **/
+ versionsFrom(meteorversion: string); /** TODO: add return value **/
+ imply(packagespecOrpackagespecs: any); /** TODO: add return value **/
+ export(exportedObject: string, architecture?: string); /** TODO: add return value **/
+ addFiles(filenameOrfilenames: any); /** TODO: add return value **/
+ }
+}
+
+declare var Template: Meteor.TemplateBase;
+declare var Session: Meteor.Session;
+declare var Accounts: Meteor.Accounts;
+declare var Match: Meteor.Match;
+declare var EJSON: Meteor.EJSON;
+declare var Tinytest: Meteor.Tinytest;
\ No newline at end of file
diff --git a/bin/.gitkeep b/bin/.gitkeep
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/bin/.gitkeep
@@ -0,0 +1 @@
+
diff --git a/build/.gitkeep b/build/.gitkeep
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/build/.gitkeep
@@ -0,0 +1 @@
+
diff --git a/build/README b/build/README
new file mode 100644
index 0000000..003af16
--- /dev/null
+++ b/build/README
@@ -0,0 +1,4 @@
+Application production builds can go in this directory. To build your
+application for staging or production run this command:
+
+> iron build
diff --git a/config/.gitkeep b/config/.gitkeep
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/config/.gitkeep
@@ -0,0 +1 @@
+
diff --git a/config/development/env.sh b/config/development/env.sh
new file mode 100644
index 0000000..2c52db7
--- /dev/null
+++ b/config/development/env.sh
@@ -0,0 +1,9 @@
+# This .sh file will be sourced before starting your application.
+# You can use it to put environment variables you want accessible
+# to the server side of your app by using process.env.MY_VAR
+#
+# Example:
+# export MONGO_URL="mongodb://localhost:27017/myapp-development"
+# export ROOT_URL="http://localhost:3000"
+
+export SAMPLE_VARIABLE="somevalue"
diff --git a/config/development/settings.json b/config/development/settings.json
new file mode 100644
index 0000000..159251e
--- /dev/null
+++ b/config/development/settings.json
@@ -0,0 +1,7 @@
+{
+ "public": {
+ "appName": "Meteor-v1.3-Ionic2-Starter"
+ },
+
+ "sample": "config/development/settings.json"
+}
diff --git a/config/production/env.sh b/config/production/env.sh
new file mode 100644
index 0000000..2c52db7
--- /dev/null
+++ b/config/production/env.sh
@@ -0,0 +1,9 @@
+# This .sh file will be sourced before starting your application.
+# You can use it to put environment variables you want accessible
+# to the server side of your app by using process.env.MY_VAR
+#
+# Example:
+# export MONGO_URL="mongodb://localhost:27017/myapp-development"
+# export ROOT_URL="http://localhost:3000"
+
+export SAMPLE_VARIABLE="somevalue"
diff --git a/config/production/settings.json b/config/production/settings.json
new file mode 100644
index 0000000..8670ce7
--- /dev/null
+++ b/config/production/settings.json
@@ -0,0 +1,6 @@
+{
+ "public": {
+ },
+
+ "sample": "value"
+}