`
+ * - Next parent has the `Dependency` directive and so the dependency is satisfied.
+ *
+ * Angular injects `dependency=2`.
+ *
+ * @exportedAs angular2/annotations
+ */
+ class AncestorAnnotation extends Visibility {
+ }
+
+
+ /**
+ * Specifies that an injector should retrieve a dependency from the direct parent.
+ *
+ * ## Example
+ *
+ * Here is a simple directive that retrieves a dependency from its parent element.
+ *
+ * ```
+ * @Directive({
+ * selector: '[dependency]',
+ * properties: [
+ * 'id: dependency'
+ * ]
+ * })
+ * class Dependency {
+ * id:string;
+ * }
+ *
+ *
+ * @Directive({
+ * selector: '[my-directive]'
+ * })
+ * class Dependency {
+ * constructor(@Parent() dependency:Dependency) {
+ * expect(dependency.id).toEqual(1);
+ * };
+ * }
+ * ```
+ *
+ * We use this with the following HTML template:
+ *
+ * ```
+ *
+ * ```
+ * The `@Parent()` annotation in our constructor forces the injector to retrieve the dependency from
+ * the
+ * parent element (even thought the current element could resolve it): Angular injects
+ * `dependency=1`.
+ *
+ * @exportedAs angular2/annotations
+ */
+ class ParentAnnotation extends Visibility {
+ }
+
+
+ /**
+ * Specifies that an injector should retrieve a dependency from any ancestor element.
+ *
+ * An ancestor is any element between the parent element and shadow root.
+ *
+ *
+ * ## Example
+ *
+ * Here is a simple directive that retrieves a dependency from an ancestor element.
+ *
+ * ```
+ * @Directive({
+ * selector: '[dependency]',
+ * properties: [
+ * 'id: dependency'
+ * ]
+ * })
+ * class Dependency {
+ * id:string;
+ * }
+ *
+ *
+ * @Directive({
+ * selector: '[my-directive]'
+ * })
+ * class Dependency {
+ * constructor(@Unbounded() dependency:Dependency) {
+ * expect(dependency.id).toEqual(2);
+ * };
+ * }
+ * ```
+ *
+ * @exportedAs angular2/annotations
+ */
+ class UnboundedAnnotation extends Visibility {
+ }
+
+ /**
+ * Declares the available HTML templates for an application.
+ *
+ * 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 Component}.
+ *
+ * ## Example
+ *
+ * ```
+ * @Component({
+ * selector: 'greet'
+ * })
+ * @View({
+ * template: 'Hello {{name}}!',
+ * directives: [GreetUser, Bold]
+ * })
+ * class Greet {
+ * name: string;
+ *
+ * constructor() {
+ * this.name = 'World';
+ * }
+ * }
+ * ```
+ */
+ function View(arg: _ViewArg): (target: any) => any;
+ interface _ViewArg {
+ /**
+ * Specifies a template URL for an angular component.
+ *
+ * NOTE: either `templateUrl` or `template` should be used, but not both.
+ */
+ templateUrl?: string;
+
+ /**
+ * Specifies an inline template for an angular component.
+ *
+ * NOTE: either `templateUrl` or `template` should be used, but not both.
+ */
+ template?: 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'
+ * })
+ * @View({
+ * directives: [For]
+ * template: '
+ *
'
+ * })
+ * class MyComponent {
+ * }
+ * ```
+ */
+ // TODO(tbosch): use Type | Binding | List
when Dart supports union types,
+ // as otherwise we would need to import Binding type and Dart would warn
+ // for an unused import.
+ directives?: List>;
+
+ /**
+ * Specify a custom renderer for this View.
+ * If this is set, neither `template`, `templateURL` nor `directives` are used.
+ */
+ renderer?: string;
+ }
+
+ class ViewAnnotation {
+ }
+
+
+ /**
+ * 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
+ *
+ *
+ *
+ * loading...
+ *
+ *
+ * ```
+ *
+ * An application is bootstrapped inside an existing browser DOM, typically `index.html`. Unlike
+ * Angular 1, Angular 2
+ * does not compile/process bindings 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
+ * bindings. Bindings can thus use double-curly `{{ syntax }}` without collision from Angular 2
+ * component double-curly
+ * `{{ syntax }}`.
+ *
+ * We can use this script code:
+ *
+ * ```
+ * @Component({
+ * selector: 'my-app'
+ * })
+ * @View({
+ * template: 'Hello {{ name }}!'
+ * })
+ * class MyApp {
+ * name:string;
+ *
+ * constructor() {
+ * this.name = 'World';
+ * }
+ * }
+ *
+ * main() {
+ * return bootstrap(MyApp);
+ * }
+ * ```
+ *
+ * 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) and configures the injector with
+ * the component's
+ * `appInjector`. 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 a 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 bindings for the
+ * application.
+ *
+ *
+ * ## Instantiating Multiple Applications on a Single Page
+ *
+ * There are two ways to do this.
+ *
+ *
+ * ### Isolated Applications
+ *
+ * Angular creates a new application each time that the `bootstrap()` method is invoked. When
+ * multiple applications
+ * are created for a page, Angular treats each application as independent within an isolated change
+ * detection and
+ * `Zone` domain. If you need to share data between applications, use the strategy described in the
+ * next
+ * section, "Applications That Share Change Detection."
+ *
+ *
+ * ### Applications That Share Change Detection
+ *
+ * If you need to bootstrap multiple applications that share common data, the applications must
+ * share a common
+ * change detection and zone. To do that, create a meta-component that lists the application
+ * components in its template.
+ * By only invoking the `bootstrap()` method once, with the meta-component as its argument, you
+ * ensure that only a
+ * single change detection zone is created and therefore data can be shared across the applications.
+ *
+ *
+ * ## Platform Injector
+ *
+ * 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
+ * injector 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 `Type`
+ * which is annotated with `@Component(...)`.
+ * - `componentInjectableBindings`: An additional set of bindings that can be added to `appInjector`
+ * for the
+ * Component to override default injection behavior.
+ * - `errorReporter`: `function(exception:any, stackTrace:string)` a default error reporter for
+ * unhandled exceptions.
+ *
+ * Returns a `Promise` with the application`s private Injector.
+ *
+ * @exportedAs angular2/core
+ */
+ function bootstrap(appComponentType: Type, componentInjectableBindings?: List>, errorReporter?: Function) : Promise ;
+
+ class ApplicationRef {
+ dispose(): any;
+ hostComponent: any;
+ hostComponentType: any;
+ injector: any;
+ }
+
+ var appComponentRefToken : OpaqueToken ;
+
+ var appComponentTypeToken : OpaqueToken ;
+
+
+ /**
+ * Specifies that a