diff --git a/docs/public-docs-package/index.js b/docs/public-docs-package/index.js
index 08e42b77e9..3ebb3c2571 100644
--- a/docs/public-docs-package/index.js
+++ b/docs/public-docs-package/index.js
@@ -5,7 +5,7 @@ module.exports = new Package('angular-v2-public-docs', [basePackage])
 
 .config(function(readTypeScriptModules) {
   readTypeScriptModules.sourceFiles = [
-    'angular2/annotations.ts',
+    'angular2/metadata.ts',
     'angular2/change_detection.ts',
     'angular2/core.ts',
     'angular2/di.ts',
diff --git a/modules/angular2/angular2.ts b/modules/angular2/angular2.ts
index 640a4d18dd..d8124b4bab 100644
--- a/modules/angular2/angular2.ts
+++ b/modules/angular2/angular2.ts
@@ -7,7 +7,7 @@ export {commonBootstrap as bootstrap} from 'angular2/src/core/application_common
 // angular2_exports.ts. Re-exporting from angular2_exports.ts causes systemjs
 // to resolve imports very very very slowly. See also a similar notice in
 // bootstrap.ts
-export * from './annotations';
+export * from './metadata';
 export * from './change_detection';
 export * from './core';
 export * from './di';
diff --git a/modules/angular2/angular2_exports.ts b/modules/angular2/angular2_exports.ts
index ed8c911a4b..e781b14e12 100644
--- a/modules/angular2/angular2_exports.ts
+++ b/modules/angular2/angular2_exports.ts
@@ -1,4 +1,4 @@
-export * from './annotations';
+export * from './metadata';
 export * from './change_detection';
 export * from './core';
 export * from './di';
diff --git a/modules/angular2/annotations.ts b/modules/angular2/annotations.ts
deleted file mode 100644
index bb17a972ad..0000000000
--- a/modules/angular2/annotations.ts
+++ /dev/null
@@ -1,50 +0,0 @@
-/**
- * @module
- * @description
- *
- * Annotations provide the additional information that Angular requires in order to run your
- * application. This module
- * contains {@link Component}, {@link Directive}, and {@link View} annotations, as well as
- * the {@link Host} annotation that is used by Angular to resolve dependencies.
- *
- */
-
-export {
-  ComponentAnnotation,
-  DirectiveAnnotation,
-  PipeAnnotation,
-  LifecycleEvent
-} from './src/core/annotations/annotations';
-
-export {ViewAnnotation, ViewEncapsulation} from 'angular2/src/core/annotations/view';
-export {QueryAnnotation, AttributeAnnotation} from 'angular2/src/core/annotations/di';
-
-export {
-  OnAllChangesDone,
-  OnChange,
-  OnDestroy,
-  OnInit,
-  OnCheck
-} from 'angular2/src/core/compiler/interfaces';
-
-
-export {Class, ClassDefinition, TypeDecorator} from 'angular2/src/util/decorators';
-
-export {
-  Attribute,
-  AttributeFactory,
-  Component,
-  ComponentDecorator,
-  ComponentFactory,
-  Directive,
-  DirectiveDecorator,
-  DirectiveFactory,
-  View,
-  ViewDecorator,
-  ViewFactory,
-  Query,
-  QueryFactory,
-  ViewQuery,
-  Pipe,
-  PipeFactory
-} from 'angular2/src/core/annotations/decorators';
diff --git a/modules/angular2/bootstrap.ts b/modules/angular2/bootstrap.ts
index ddc827d5de..76f53dbada 100644
--- a/modules/angular2/bootstrap.ts
+++ b/modules/angular2/bootstrap.ts
@@ -7,7 +7,7 @@ export {bootstrap} from 'angular2/src/core/application';
 // angular2_exports.ts. Re-exporting from angular2_exports.ts causes systemjs
 // to resolve imports very very very slowly. See also a similar notice in
 // angular2.ts
-export * from './annotations';
+export * from './metadata';
 export * from './change_detection';
 export * from './core';
 export * from './di';
diff --git a/modules/angular2/metadata.dart b/modules/angular2/metadata.dart
new file mode 100644
index 0000000000..81484884f2
--- /dev/null
+++ b/modules/angular2/metadata.dart
@@ -0,0 +1,4 @@
+library angular2.metadata;
+
+export 'package:angular2/src/core/metadata.dart';
+export 'package:angular2/src/core/compiler/interfaces.dart';
diff --git a/modules/angular2/metadata.ts b/modules/angular2/metadata.ts
new file mode 100644
index 0000000000..7223a51b10
--- /dev/null
+++ b/modules/angular2/metadata.ts
@@ -0,0 +1,48 @@
+/**
+ * @module
+ * @description
+ *
+ * Annotations provide the additional information that Angular requires in order to run your
+ * application. This module
+ * contains {@link ComponentMetadata}, {@link DirectiveMetadata}, and {@link ViewMetadata}
+ * annotations, as well as
+ * the {@link Host} annotation that is used by Angular to resolve dependencies.
+ *
+ */
+
+export {
+  ComponentMetadata,
+  DirectiveMetadata,
+  PipeMetadata,
+  LifecycleEvent,
+  ViewMetadata,
+  ViewEncapsulation,
+  QueryMetadata,
+  AttributeMetadata,
+  Attribute,
+  AttributeFactory,
+  Component,
+  ComponentDecorator,
+  ComponentFactory,
+  Directive,
+  DirectiveDecorator,
+  DirectiveFactory,
+  View,
+  ViewDecorator,
+  ViewFactory,
+  Query,
+  QueryFactory,
+  ViewQuery,
+  Pipe,
+  PipeFactory
+} from './src/core/metadata';
+
+export {
+  OnAllChangesDone,
+  OnChange,
+  OnDestroy,
+  OnInit,
+  OnCheck
+} from './src/core/compiler/interfaces';
+
+export {Class, ClassDefinition, TypeDecorator} from './src/util/decorators';
diff --git a/modules/angular2/render.ts b/modules/angular2/render.ts
index df60f7bcce..f0b3f69e8e 100644
--- a/modules/angular2/render.ts
+++ b/modules/angular2/render.ts
@@ -5,7 +5,7 @@
  */
 
 export {
-  DirectiveMetadata,
+  RenderDirectiveMetadata,
   DomRenderer,
   RenderEventDispatcher,
   Renderer,
diff --git a/modules/angular2/src/change_detection/change_detection_util.ts b/modules/angular2/src/change_detection/change_detection_util.ts
index f6d6777b6d..3bf63216c5 100644
--- a/modules/angular2/src/change_detection/change_detection_util.ts
+++ b/modules/angular2/src/change_detection/change_detection_util.ts
@@ -6,7 +6,8 @@ import {implementsOnDestroy} from './pipe_lifecycle_reflector';
 
 
 /**
- * Indicates that the result of a {@link Pipe} transformation has changed even though the reference
+ * 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.
diff --git a/modules/angular2/src/core/annotations/annotations.dart b/modules/angular2/src/core/annotations/annotations.dart
deleted file mode 100644
index cc4f68947d..0000000000
--- a/modules/angular2/src/core/annotations/annotations.dart
+++ /dev/null
@@ -1,8 +0,0 @@
-/**
- * This indirection is needed for TS compilation path.
- * See comment in annotations.es6.
- */
-
-library angular2.core.annotations.annotations;
-
-export "../annotations_impl/annotations.dart";
diff --git a/modules/angular2/src/core/annotations/annotations.ts b/modules/angular2/src/core/annotations/annotations.ts
deleted file mode 100644
index 8e11e0eb54..0000000000
--- a/modules/angular2/src/core/annotations/annotations.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-/**
- * This indirection is needed to free up Component, etc symbols in the public API
- * to be used by the decorator versions of these annotations.
- */
-
-export {
-  Component as ComponentAnnotation,
-  Directive as DirectiveAnnotation,
-  Pipe as PipeAnnotation,
-  LifecycleEvent
-} from '../annotations_impl/annotations';
diff --git a/modules/angular2/src/core/annotations/decorators.dart b/modules/angular2/src/core/annotations/decorators.dart
deleted file mode 100644
index f2976668a8..0000000000
--- a/modules/angular2/src/core/annotations/decorators.dart
+++ /dev/null
@@ -1,5 +0,0 @@
-library angular2.core.decorators;
-
-export '../annotations_impl/annotations.dart';
-export '../annotations_impl/view.dart';
-export '../annotations_impl/di.dart';
diff --git a/modules/angular2/src/core/annotations/di.dart b/modules/angular2/src/core/annotations/di.dart
deleted file mode 100644
index 8b182acb0d..0000000000
--- a/modules/angular2/src/core/annotations/di.dart
+++ /dev/null
@@ -1,3 +0,0 @@
-library angular2.core.annotations.di;
-
-export "../annotations_impl/di.dart";
diff --git a/modules/angular2/src/core/annotations/di.ts b/modules/angular2/src/core/annotations/di.ts
deleted file mode 100644
index 61a23c1c9b..0000000000
--- a/modules/angular2/src/core/annotations/di.ts
+++ /dev/null
@@ -1,5 +0,0 @@
-export {
-  Query as QueryAnnotation,
-  ViewQuery as ViewQueryAnnotation,
-  Attribute as AttributeAnnotation,
-} from '../annotations_impl/di';
diff --git a/modules/angular2/src/core/annotations/view.dart b/modules/angular2/src/core/annotations/view.dart
deleted file mode 100644
index 30171a89dc..0000000000
--- a/modules/angular2/src/core/annotations/view.dart
+++ /dev/null
@@ -1,3 +0,0 @@
-library angular2.core.annotations.view;
-
-export "../annotations_impl/view.dart";
diff --git a/modules/angular2/src/core/annotations/view.ts b/modules/angular2/src/core/annotations/view.ts
deleted file mode 100644
index 231296f66e..0000000000
--- a/modules/angular2/src/core/annotations/view.ts
+++ /dev/null
@@ -1 +0,0 @@
-export {View as ViewAnnotation, ViewEncapsulation} from '../annotations_impl/view';
diff --git a/modules/angular2/src/core/application_common.ts b/modules/angular2/src/core/application_common.ts
index 0e632c3b07..8bd5289198 100644
--- a/modules/angular2/src/core/application_common.ts
+++ b/modules/angular2/src/core/application_common.ts
@@ -359,12 +359,12 @@ export class ApplicationRef {
   }
 
   /**
-   * Returns the current {@link Component} type.
+   * Returns the current {@link ComponentMetadata} type.
    */
   get hostComponentType(): Type { return this._hostComponentType; }
 
   /**
-   * Returns the current {@link Component} instance.
+   * Returns the current {@link ComponentMetadata} instance.
    */
   get hostComponent(): any { return this._hostComponent.instance; }
 
diff --git a/modules/angular2/src/core/compiler/compiler.ts b/modules/angular2/src/core/compiler/compiler.ts
index 45e13164e6..4aee86ad9f 100644
--- a/modules/angular2/src/core/compiler/compiler.ts
+++ b/modules/angular2/src/core/compiler/compiler.ts
@@ -20,7 +20,7 @@ import {ProtoViewRef} from './view_ref';
 import {DirectiveBinding} from './element_injector';
 import {ViewResolver} from './view_resolver';
 import {PipeResolver} from './pipe_resolver';
-import {View} from '../annotations_impl/view';
+import {ViewMetadata} from 'angular2/metadata';
 import {ComponentUrlMapper} from './component_url_mapper';
 import {ProtoViewFactory} from './proto_view_factory';
 import {UrlResolver} from 'angular2/src/services/url_resolver';
@@ -30,7 +30,14 @@ import {wtfStartTimeRange, wtfEndTimeRange} from '../../profile/profile';
 import {PipeBinding} from '../pipes/pipe_binding';
 import {DEFAULT_PIPES_TOKEN} from 'angular2/pipes';
 
-import * as renderApi from 'angular2/src/render/api';
+import {
+  RenderDirectiveMetadata,
+  ViewDefinition,
+  RenderCompiler,
+  ViewType,
+  RenderProtoViewMergeMapping,
+  RenderProtoViewRef
+} from 'angular2/src/render/api';
 
 /**
  * Cache that stores the AppProtoView of the template of a component.
@@ -97,8 +104,8 @@ export class Compiler {
               @Inject(DEFAULT_PIPES_TOKEN) _defaultPipes: Type[],
               private _compilerCache: CompilerCache, private _viewResolver: ViewResolver,
               private _componentUrlMapper: ComponentUrlMapper, private _urlResolver: UrlResolver,
-              private _render: renderApi.RenderCompiler,
-              private _protoViewFactory: ProtoViewFactory, appUrl: AppRootUrl) {
+              private _render: RenderCompiler, private _protoViewFactory: ProtoViewFactory,
+              appUrl: AppRootUrl) {
     this._defaultPipes = _defaultPipes;
     this._appUrl = appUrl.value;
   }
@@ -215,7 +222,7 @@ export class Compiler {
                                    componentPath: Map<Type, AppProtoView>): Promise<AppProtoView> {
     var nestedPVPromises = [];
     componentPath = MapWrapper.clone(componentPath);
-    if (appProtoViews[0].type === renderApi.ViewType.COMPONENT) {
+    if (appProtoViews[0].type === ViewType.COMPONENT) {
       componentPath.set(componentType, appProtoViews[0]);
     }
     appProtoViews.forEach(appProtoView => {
@@ -230,7 +237,7 @@ export class Compiler {
               if (appProtoView.isEmbeddedFragment) {
                 throw new BaseException(
                     `<ng-content> is used within the recursive path of ${stringify(nestedComponentType)}`);
-              } else if (appProtoView.type === renderApi.ViewType.COMPONENT) {
+              } else if (appProtoView.type === ViewType.COMPONENT) {
                 throw new BaseException(
                     `Unconditional component cycle in ${stringify(nestedComponentType)}`);
               } else {
@@ -253,18 +260,17 @@ export class Compiler {
   }
 
   private _mergeProtoView(appProtoView: AppProtoView): Promise<any> {
-    if (appProtoView.type !== renderApi.ViewType.HOST &&
-        appProtoView.type !== renderApi.ViewType.EMBEDDED) {
+    if (appProtoView.type !== ViewType.HOST && appProtoView.type !== ViewType.EMBEDDED) {
       return null;
     }
     return this._render.mergeProtoViewsRecursively(this._collectMergeRenderProtoViews(appProtoView))
-        .then((mergeResult: renderApi.RenderProtoViewMergeMapping) => {
+        .then((mergeResult: RenderProtoViewMergeMapping) => {
           appProtoView.mergeMapping = new AppProtoViewMergeMapping(mergeResult);
         });
   }
 
-  private _collectMergeRenderProtoViews(
-      appProtoView: AppProtoView): List<renderApi.RenderProtoViewRef | List<any>> {
+  private _collectMergeRenderProtoViews(appProtoView:
+                                            AppProtoView): List<RenderProtoViewRef | List<any>> {
     var result = [appProtoView.render];
     for (var i = 0; i < appProtoView.elementBinders.length; i++) {
       var binder = appProtoView.elementBinders[i];
@@ -290,7 +296,7 @@ export class Compiler {
     return componentElementBinders;
   }
 
-  private _buildRenderTemplate(component, view, directives): renderApi.ViewDefinition {
+  private _buildRenderTemplate(component, view, directives): ViewDefinition {
     var componentUrl =
         this._urlResolver.resolve(this._appUrl, this._componentUrlMapper.getUrl(component));
     var templateAbsUrl = null;
@@ -307,7 +313,7 @@ export class Compiler {
       styleAbsUrls =
           ListWrapper.map(view.styleUrls, url => this._urlResolver.resolve(componentUrl, url));
     }
-    return new renderApi.ViewDefinition({
+    return new ViewDefinition({
       componentId: stringify(component),
       templateAbsUrl: templateAbsUrl, template: view.template,
       styleAbsUrls: styleAbsUrls,
@@ -317,14 +323,14 @@ export class Compiler {
     });
   }
 
-  private _flattenPipes(view: View): any[] {
+  private _flattenPipes(view: ViewMetadata): any[] {
     if (isBlank(view.pipes)) return this._defaultPipes;
     var pipes = ListWrapper.clone(this._defaultPipes);
     this._flattenList(view.pipes, pipes);
     return pipes;
   }
 
-  private _flattenDirectives(view: View): List<Type> {
+  private _flattenDirectives(view: ViewMetadata): List<Type> {
     if (isBlank(view.directives)) return [];
     var directives = [];
     this._flattenList(view.directives, directives);
@@ -347,7 +353,7 @@ export class Compiler {
   }
 
   private static _assertTypeIsComponent(directiveBinding: DirectiveBinding): void {
-    if (directiveBinding.metadata.type !== renderApi.DirectiveMetadata.COMPONENT_TYPE) {
+    if (directiveBinding.metadata.type !== RenderDirectiveMetadata.COMPONENT_TYPE) {
       throw new BaseException(
           `Could not load '${stringify(directiveBinding.key.token)}' because it is not a component.`);
     }
diff --git a/modules/angular2/src/core/compiler/component_url_mapper.ts b/modules/angular2/src/core/compiler/component_url_mapper.ts
index aa83f88c5d..9e94b54206 100644
--- a/modules/angular2/src/core/compiler/component_url_mapper.ts
+++ b/modules/angular2/src/core/compiler/component_url_mapper.ts
@@ -3,7 +3,7 @@ import {Type, isPresent} from 'angular2/src/facade/lang';
 import {Map, MapWrapper} from 'angular2/src/facade/collection';
 
 /**
- * Resolve a `Type` from a {@link Component} into a URL.
+ * Resolve a `Type` from a {@link ComponentMetadata} into a URL.
  *
  * This interface can be overridden by the application developer to create custom behavior.
  *
diff --git a/modules/angular2/src/core/compiler/directive_lifecycle_reflector.dart b/modules/angular2/src/core/compiler/directive_lifecycle_reflector.dart
index 76e3ea61e3..f9b1a2b7a1 100644
--- a/modules/angular2/src/core/compiler/directive_lifecycle_reflector.dart
+++ b/modules/angular2/src/core/compiler/directive_lifecycle_reflector.dart
@@ -1,10 +1,10 @@
 library angular2.src.core.compiler.directive_lifecycle_reflector;
 
-import 'package:angular2/src/core/annotations_impl/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 import 'package:angular2/src/core/compiler/interfaces.dart';
 import 'package:angular2/src/reflection/reflection.dart';
 
-bool hasLifecycleHook(LifecycleEvent e, type, Directive annotation) {
+bool hasLifecycleHook(LifecycleEvent e, type, DirectiveMetadata annotation) {
   if (annotation.lifecycle != null) {
     return annotation.lifecycle.contains(e);
   } else {
diff --git a/modules/angular2/src/core/compiler/directive_lifecycle_reflector.ts b/modules/angular2/src/core/compiler/directive_lifecycle_reflector.ts
index c545f5040a..c34bc81160 100644
--- a/modules/angular2/src/core/compiler/directive_lifecycle_reflector.ts
+++ b/modules/angular2/src/core/compiler/directive_lifecycle_reflector.ts
@@ -1,7 +1,7 @@
 import {Type, isPresent} from 'angular2/src/facade/lang';
-import {LifecycleEvent, Directive} from 'angular2/src/core/annotations_impl/annotations';
+import {LifecycleEvent, DirectiveMetadata} from 'angular2/metadata';
 
-export function hasLifecycleHook(e: LifecycleEvent, type, annotation: Directive): boolean {
+export function hasLifecycleHook(e: LifecycleEvent, type, annotation: DirectiveMetadata): boolean {
   if (isPresent(annotation.lifecycle)) {
     return annotation.lifecycle.indexOf(e) !== -1;
   } else {
diff --git a/modules/angular2/src/core/compiler/directive_resolver.ts b/modules/angular2/src/core/compiler/directive_resolver.ts
index b8fb2ebdac..6f55c8c3b5 100644
--- a/modules/angular2/src/core/compiler/directive_resolver.ts
+++ b/modules/angular2/src/core/compiler/directive_resolver.ts
@@ -1,10 +1,10 @@
 import {resolveForwardRef, Injectable} from 'angular2/di';
 import {Type, isPresent, BaseException, stringify} from 'angular2/src/facade/lang';
-import {Directive} from '../annotations_impl/annotations';
+import {DirectiveMetadata} from 'angular2/metadata';
 import {reflector} from 'angular2/src/reflection/reflection';
 
 /**
- * Resolve a `Type` for {@link Directive}.
+ * Resolve a `Type` for {@link DirectiveMetadata}.
  *
  * This interface can be overridden by the application developer to create custom behavior.
  *
@@ -13,14 +13,14 @@ import {reflector} from 'angular2/src/reflection/reflection';
 @Injectable()
 export class DirectiveResolver {
   /**
-   * Return {@link Directive} for a given `Type`.
+   * Return {@link DirectiveMetadata} for a given `Type`.
    */
-  resolve(type: Type): Directive {
+  resolve(type: Type): DirectiveMetadata {
     var annotations = reflector.annotations(resolveForwardRef(type));
     if (isPresent(annotations)) {
       for (var i = 0; i < annotations.length; i++) {
         var annotation = annotations[i];
-        if (annotation instanceof Directive) {
+        if (annotation instanceof DirectiveMetadata) {
           return annotation;
         }
       }
diff --git a/modules/angular2/src/core/compiler/element_injector.ts b/modules/angular2/src/core/compiler/element_injector.ts
index 98b0682182..6982b980b2 100644
--- a/modules/angular2/src/core/compiler/element_injector.ts
+++ b/modules/angular2/src/core/compiler/element_injector.ts
@@ -31,19 +31,19 @@ import {
   BindingWithVisibility
 } from 'angular2/src/di/injector';
 
-import {Attribute, Query} from 'angular2/src/core/annotations_impl/di';
+import {AttributeMetadata, QueryMetadata} from '../metadata/di';
 
 import * as viewModule from './view';
 import * as avmModule from './view_manager';
 import {ViewContainerRef} from './view_container_ref';
 import {ElementRef} from './element_ref';
 import {TemplateRef} from './template_ref';
-import {Directive, Component, LifecycleEvent} from 'angular2/src/core/annotations_impl/annotations';
+import {DirectiveMetadata, ComponentMetadata, LifecycleEvent} from '../metadata/directives';
 import {hasLifecycleHook} from './directive_lifecycle_reflector';
 import {ChangeDetector, ChangeDetectorRef} from 'angular2/src/change_detection/change_detection';
 import {QueryList} from './query_list';
 import {reflector} from 'angular2/src/reflection/reflection';
-import {DirectiveMetadata} from 'angular2/src/render/api';
+import {RenderDirectiveMetadata} from 'angular2/src/render/api';
 import {PipeBinding} from '../pipes/pipe_binding';
 
 var _staticKeys;
@@ -160,7 +160,7 @@ export class TreeNode<T extends TreeNode<any>> {
 export class DirectiveDependency extends Dependency {
   constructor(key: Key, optional: boolean, lowerBoundVisibility: Object,
               upperBoundVisibility: Object, properties: List<any>, public attributeName: string,
-              public queryDecorator: Query) {
+              public queryDecorator: QueryMetadata) {
     super(key, optional, lowerBoundVisibility, upperBoundVisibility, properties);
     this._verify();
   }
@@ -181,12 +181,12 @@ export class DirectiveDependency extends Dependency {
   }
 
   static _attributeName(properties): string {
-    var p = <Attribute>ListWrapper.find(properties, (p) => p instanceof Attribute);
+    var p = <AttributeMetadata>ListWrapper.find(properties, (p) => p instanceof AttributeMetadata);
     return isPresent(p) ? p.attributeName : null;
   }
 
-  static _query(properties): Query {
-    return <Query>ListWrapper.find(properties, (p) => p instanceof Query);
+  static _query(properties): QueryMetadata {
+    return <QueryMetadata>ListWrapper.find(properties, (p) => p instanceof QueryMetadata);
   }
 }
 
@@ -194,7 +194,7 @@ export class DirectiveBinding extends ResolvedBinding {
   constructor(key: Key, factory: Function, dependencies: List<Dependency>,
               public resolvedBindings: List<ResolvedBinding>,
               public resolvedViewBindings: List<ResolvedBinding>,
-              public metadata: DirectiveMetadata) {
+              public metadata: RenderDirectiveMetadata) {
     super(key, factory, dependencies);
   }
 
@@ -218,21 +218,21 @@ export class DirectiveBinding extends ResolvedBinding {
 
   get changeDetection() { return this.metadata.changeDetection; }
 
-  static createFromBinding(binding: Binding, ann: Directive): DirectiveBinding {
+  static createFromBinding(binding: Binding, ann: DirectiveMetadata): DirectiveBinding {
     if (isBlank(ann)) {
-      ann = new Directive();
+      ann = new DirectiveMetadata();
     }
 
     var rb = binding.resolve();
     var deps = ListWrapper.map(rb.dependencies, DirectiveDependency.createFrom);
     var resolvedBindings = isPresent(ann.bindings) ? Injector.resolve(ann.bindings) : [];
-    var resolvedViewBindings = ann instanceof Component && isPresent(ann.viewBindings) ?
+    var resolvedViewBindings = ann instanceof ComponentMetadata && isPresent(ann.viewBindings) ?
                                    Injector.resolve(ann.viewBindings) :
                                    [];
-    var metadata = DirectiveMetadata.create({
+    var metadata = RenderDirectiveMetadata.create({
       id: stringify(rb.key.token),
-      type: ann instanceof Component ? DirectiveMetadata.COMPONENT_TYPE :
-                                       DirectiveMetadata.DIRECTIVE_TYPE,
+      type: ann instanceof ComponentMetadata ? RenderDirectiveMetadata.COMPONENT_TYPE :
+                                               RenderDirectiveMetadata.DIRECTIVE_TYPE,
       selector: ann.selector,
       compileChildren: ann.compileChildren,
       events: ann.events,
@@ -246,7 +246,7 @@ export class DirectiveBinding extends ResolvedBinding {
       callOnInit: hasLifecycleHook(LifecycleEvent.onInit, rb.key.token, ann),
       callOnAllChangesDone: hasLifecycleHook(LifecycleEvent.onAllChangesDone, rb.key.token, ann),
 
-      changeDetection: ann instanceof Component ? ann.changeDetection : null,
+      changeDetection: ann instanceof ComponentMetadata ? ann.changeDetection : null,
 
       exportAs: ann.exportAs
     });
@@ -264,7 +264,7 @@ export class DirectiveBinding extends ResolvedBinding {
     return readAttributes;
   }
 
-  static createFromType(type: Type, annotation: Directive): DirectiveBinding {
+  static createFromType(type: Type, annotation: DirectiveMetadata): DirectiveBinding {
     var binding = new Binding(type, {toClass: type});
     return DirectiveBinding.createFromBinding(binding, annotation);
   }
@@ -608,7 +608,7 @@ export class ElementInjector extends TreeNode<ElementInjector> implements Depend
       if (dirDep.key.id === StaticKeys.instance().changeDetectorRefId) {
         // We provide the component's view change detector to components and
         // the surrounding component's change detector to directives.
-        if (dirBin.metadata.type === DirectiveMetadata.COMPONENT_TYPE) {
+        if (dirBin.metadata.type === RenderDirectiveMetadata.COMPONENT_TYPE) {
           var componentView = this._preBuiltObjects.view.getNestedView(
               this._preBuiltObjects.elementRef.boundElementIndex);
           return componentView.changeDetector.ref;
@@ -713,7 +713,7 @@ export class ElementInjector extends TreeNode<ElementInjector> implements Depend
     matched.forEach(s => queryRef.list.add(s));
   }
 
-  private _createQueryRef(query: Query): void {
+  private _createQueryRef(query: QueryMetadata): void {
     var queryList = new QueryList<any>();
     if (isBlank(this._query0)) {
       this._query0 = new QueryRef(query, queryList, this);
@@ -726,7 +726,7 @@ export class ElementInjector extends TreeNode<ElementInjector> implements Depend
     }
   }
 
-  addDirectivesMatchingQuery(query: Query, list: any[]): void {
+  addDirectivesMatchingQuery(query: QueryMetadata, list: any[]): void {
     var templateRef = this._preBuiltObjects.templateRef;
     if (query.selector === TemplateRef && isPresent(templateRef)) {
       list.push(templateRef);
@@ -873,7 +873,7 @@ interface _ElementInjectorStrategy {
   getComponent(): any;
   isComponentKey(key: Key): boolean;
   buildQueries(): void;
-  addDirectivesMatchingQuery(q: Query, res: any[]): void;
+  addDirectivesMatchingQuery(q: QueryMetadata, res: any[]): void;
   getComponentBinding(): DirectiveBinding;
   hydrate(): void;
   dehydrate(): void;
@@ -1006,7 +1006,7 @@ class ElementInjectorInlineStrategy implements _ElementInjectorStrategy {
     }
   }
 
-  addDirectivesMatchingQuery(query: Query, list: any[]): void {
+  addDirectivesMatchingQuery(query: QueryMetadata, list: any[]): void {
     var i = this.injectorStrategy;
     var p = i.protoStrategy;
 
@@ -1112,7 +1112,7 @@ class ElementInjectorDynamicStrategy implements _ElementInjectorStrategy {
     }
   }
 
-  addDirectivesMatchingQuery(query: Query, list: any[]): void {
+  addDirectivesMatchingQuery(query: QueryMetadata, list: any[]): void {
     var ist = this.injectorStrategy;
     var p = ist.protoStrategy;
 
@@ -1144,7 +1144,7 @@ export class QueryError extends BaseException {
 }
 
 export class QueryRef {
-  constructor(public query: Query, public list: QueryList<any>,
+  constructor(public query: QueryMetadata, public list: QueryList<any>,
               public originator: ElementInjector) {}
 
   get isViewQuery(): boolean { return this.query.isViewQuery; }
diff --git a/modules/angular2/src/core/compiler/pipe_resolver.ts b/modules/angular2/src/core/compiler/pipe_resolver.ts
index a18923bb64..2ecc61a844 100644
--- a/modules/angular2/src/core/compiler/pipe_resolver.ts
+++ b/modules/angular2/src/core/compiler/pipe_resolver.ts
@@ -1,10 +1,10 @@
 import {resolveForwardRef, Injectable} from 'angular2/di';
 import {Type, isPresent, BaseException, stringify} from 'angular2/src/facade/lang';
-import {Pipe} from '../annotations_impl/annotations';
+import {PipeMetadata} from '../metadata/directives';
 import {reflector} from 'angular2/src/reflection/reflection';
 
 /**
- * Resolve a `Type` for {@link Pipe}.
+ * Resolve a `Type` for {@link PipeMetadata}.
  *
  * This interface can be overridden by the application developer to create custom behavior.
  *
@@ -13,14 +13,14 @@ import {reflector} from 'angular2/src/reflection/reflection';
 @Injectable()
 export class PipeResolver {
   /**
-   * Return {@link Pipe} for a given `Type`.
+   * Return {@link PipeMetadata} for a given `Type`.
    */
-  resolve(type: Type): Pipe {
+  resolve(type: Type): PipeMetadata {
     var metas = reflector.annotations(resolveForwardRef(type));
     if (isPresent(metas)) {
       for (var i = 0; i < metas.length; i++) {
         var annotation = metas[i];
-        if (annotation instanceof Pipe) {
+        if (annotation instanceof PipeMetadata) {
           return annotation;
         }
       }
diff --git a/modules/angular2/src/core/compiler/proto_view_factory.ts b/modules/angular2/src/core/compiler/proto_view_factory.ts
index d31c076cbf..fef99ed9ee 100644
--- a/modules/angular2/src/core/compiler/proto_view_factory.ts
+++ b/modules/angular2/src/core/compiler/proto_view_factory.ts
@@ -18,7 +18,14 @@ import {
 import {PipeBinding} from 'angular2/src/core/pipes/pipe_binding';
 import {ProtoPipes} from 'angular2/src/core/pipes/pipes';
 
-import * as renderApi from 'angular2/src/render/api';
+import {
+  RenderDirectiveMetadata,
+  RenderElementBinder,
+  PropertyBindingType,
+  DirectiveBinder,
+  ProtoViewDto,
+  ViewType
+} from 'angular2/src/render/api';
 import {AppProtoView} from './view';
 import {ElementBinder} from './element_binder';
 import {ProtoElementInjector, DirectiveBinding} from './element_injector';
@@ -26,8 +33,8 @@ import {ProtoElementInjector, DirectiveBinding} from './element_injector';
 export class BindingRecordsCreator {
   _directiveRecordsMap: Map<number, DirectiveRecord> = new Map();
 
-  getEventBindingRecords(elementBinders: List<renderApi.ElementBinder>,
-                         allDirectiveMetadatas: renderApi.DirectiveMetadata[]): BindingRecord[] {
+  getEventBindingRecords(elementBinders: List<RenderElementBinder>,
+                         allDirectiveMetadatas: RenderDirectiveMetadata[]): BindingRecord[] {
     var res = [];
     for (var boundElementIndex = 0; boundElementIndex < elementBinders.length;
          boundElementIndex++) {
@@ -41,16 +48,15 @@ export class BindingRecordsCreator {
   }
 
   private _createTemplateEventRecords(res: BindingRecord[],
-                                      renderElementBinder: renderApi.ElementBinder,
+                                      renderElementBinder: RenderElementBinder,
                                       boundElementIndex: number): void {
     renderElementBinder.eventBindings.forEach(eb => {
       res.push(BindingRecord.createForEvent(eb.source, eb.fullName, boundElementIndex));
     });
   }
 
-  private _createHostEventRecords(res: BindingRecord[],
-                                  renderElementBinder: renderApi.ElementBinder,
-                                  allDirectiveMetadatas: renderApi.DirectiveMetadata[],
+  private _createHostEventRecords(res: BindingRecord[], renderElementBinder: RenderElementBinder,
+                                  allDirectiveMetadatas: RenderDirectiveMetadata[],
                                   boundElementIndex: number): void {
     for (var i = 0; i < renderElementBinder.directives.length; ++i) {
       var dir = renderElementBinder.directives[i];
@@ -63,9 +69,9 @@ export class BindingRecordsCreator {
   }
 
   getPropertyBindingRecords(textBindings: List<ASTWithSource>,
-                            elementBinders: List<renderApi.ElementBinder>,
+                            elementBinders: List<RenderElementBinder>,
                             allDirectiveMetadatas:
-                                List<renderApi.DirectiveMetadata>): List<BindingRecord> {
+                                List<RenderDirectiveMetadata>): List<BindingRecord> {
     var bindings = [];
 
     this._createTextNodeRecords(bindings, textBindings);
@@ -80,9 +86,8 @@ export class BindingRecordsCreator {
     return bindings;
   }
 
-  getDirectiveRecords(elementBinders: List<renderApi.ElementBinder>,
-                      allDirectiveMetadatas:
-                          List<renderApi.DirectiveMetadata>): List<DirectiveRecord> {
+  getDirectiveRecords(elementBinders: List<RenderElementBinder>,
+                      allDirectiveMetadatas: List<RenderDirectiveMetadata>): List<DirectiveRecord> {
     var directiveRecords = [];
 
     for (var elementIndex = 0; elementIndex < elementBinders.length; ++elementIndex) {
@@ -103,18 +108,18 @@ export class BindingRecordsCreator {
   }
 
   _createElementPropertyRecords(bindings: List<BindingRecord>, boundElementIndex: number,
-                                renderElementBinder: renderApi.ElementBinder) {
+                                renderElementBinder: RenderElementBinder) {
     ListWrapper.forEach(renderElementBinder.propertyBindings, (binding) => {
-      if (binding.type === renderApi.PropertyBindingType.PROPERTY) {
+      if (binding.type === PropertyBindingType.PROPERTY) {
         bindings.push(BindingRecord.createForElementProperty(binding.astWithSource,
                                                              boundElementIndex, binding.property));
-      } else if (binding.type === renderApi.PropertyBindingType.ATTRIBUTE) {
+      } else if (binding.type === PropertyBindingType.ATTRIBUTE) {
         bindings.push(BindingRecord.createForElementAttribute(binding.astWithSource,
                                                               boundElementIndex, binding.property));
-      } else if (binding.type === renderApi.PropertyBindingType.CLASS) {
+      } else if (binding.type === PropertyBindingType.CLASS) {
         bindings.push(BindingRecord.createForElementClass(binding.astWithSource, boundElementIndex,
                                                           binding.property));
-      } else if (binding.type === renderApi.PropertyBindingType.STYLE) {
+      } else if (binding.type === PropertyBindingType.STYLE) {
         bindings.push(BindingRecord.createForElementStyle(binding.astWithSource, boundElementIndex,
                                                           binding.property, binding.unit));
       }
@@ -122,8 +127,8 @@ export class BindingRecordsCreator {
   }
 
   _createDirectiveRecords(bindings: List<BindingRecord>, boundElementIndex: number,
-                          directiveBinders: List<renderApi.DirectiveBinder>,
-                          allDirectiveMetadatas: List<renderApi.DirectiveMetadata>) {
+                          directiveBinders: List<DirectiveBinder>,
+                          allDirectiveMetadatas: List<RenderDirectiveMetadata>) {
     for (var i = 0; i < directiveBinders.length; i++) {
       var directiveBinder = directiveBinders[i];
       var directiveMetadata = allDirectiveMetadatas[directiveBinder.directiveIndex];
@@ -154,16 +159,16 @@ export class BindingRecordsCreator {
       // host properties
       ListWrapper.forEach(directiveBinder.hostPropertyBindings, (binding) => {
         var dirIndex = new DirectiveIndex(boundElementIndex, i);
-        if (binding.type === renderApi.PropertyBindingType.PROPERTY) {
+        if (binding.type === PropertyBindingType.PROPERTY) {
           bindings.push(BindingRecord.createForHostProperty(dirIndex, binding.astWithSource,
                                                             binding.property));
-        } else if (binding.type === renderApi.PropertyBindingType.ATTRIBUTE) {
+        } else if (binding.type === PropertyBindingType.ATTRIBUTE) {
           bindings.push(BindingRecord.createForHostAttribute(dirIndex, binding.astWithSource,
                                                              binding.property));
-        } else if (binding.type === renderApi.PropertyBindingType.CLASS) {
+        } else if (binding.type === PropertyBindingType.CLASS) {
           bindings.push(
               BindingRecord.createForHostClass(dirIndex, binding.astWithSource, binding.property));
-        } else if (binding.type === renderApi.PropertyBindingType.STYLE) {
+        } else if (binding.type === PropertyBindingType.STYLE) {
           bindings.push(BindingRecord.createForHostStyle(dirIndex, binding.astWithSource,
                                                          binding.property, binding.unit));
         }
@@ -172,7 +177,7 @@ export class BindingRecordsCreator {
   }
 
   _getDirectiveRecord(boundElementIndex: number, directiveIndex: number,
-                      directiveMetadata: renderApi.DirectiveMetadata): DirectiveRecord {
+                      directiveMetadata: RenderDirectiveMetadata): DirectiveRecord {
     var id = boundElementIndex * 100 + directiveIndex;
 
     if (!this._directiveRecordsMap.has(id)) {
@@ -198,8 +203,7 @@ export class ProtoViewFactory {
    */
   constructor(public _changeDetection: ChangeDetection) {}
 
-  createAppProtoViews(hostComponentBinding: DirectiveBinding,
-                      rootRenderProtoView: renderApi.ProtoViewDto,
+  createAppProtoViews(hostComponentBinding: DirectiveBinding, rootRenderProtoView: ProtoViewDto,
                       allDirectives: List<DirectiveBinding>, pipes: PipeBinding[]): AppProtoView[] {
     var allRenderDirectiveMetadata =
         ListWrapper.map(allDirectives, directiveBinding => directiveBinding.metadata);
@@ -233,8 +237,8 @@ export class ProtoViewFactory {
  * for the given ProtoView and all nested ProtoViews.
  */
 export function getChangeDetectorDefinitions(
-    hostComponentMetadata: renderApi.DirectiveMetadata, rootRenderProtoView: renderApi.ProtoViewDto,
-    allRenderDirectiveMetadata: List<renderApi.DirectiveMetadata>): List<ChangeDetectorDefinition> {
+    hostComponentMetadata: RenderDirectiveMetadata, rootRenderProtoView: ProtoViewDto,
+    allRenderDirectiveMetadata: List<RenderDirectiveMetadata>): List<ChangeDetectorDefinition> {
   var nestedPvsWithIndex = _collectNestedProtoViews(rootRenderProtoView);
   var nestedPvVariableNames = _collectNestedProtoViewsVariableNames(nestedPvsWithIndex);
   return _getChangeDetectorDefinitions(hostComponentMetadata, nestedPvsWithIndex,
@@ -242,7 +246,7 @@ export function getChangeDetectorDefinitions(
 }
 
 function _collectNestedProtoViews(
-    renderProtoView: renderApi.ProtoViewDto, parentIndex: number = null, boundElementIndex = null,
+    renderProtoView: ProtoViewDto, parentIndex: number = null, boundElementIndex = null,
     result: List<RenderProtoViewWithIndex> = null): List<RenderProtoViewWithIndex> {
   if (isBlank(result)) {
     result = [];
@@ -263,9 +267,9 @@ function _collectNestedProtoViews(
 }
 
 function _getChangeDetectorDefinitions(
-    hostComponentMetadata: renderApi.DirectiveMetadata,
+    hostComponentMetadata: RenderDirectiveMetadata,
     nestedPvsWithIndex: List<RenderProtoViewWithIndex>, nestedPvVariableNames: List<List<string>>,
-    allRenderDirectiveMetadata: List<renderApi.DirectiveMetadata>): List<ChangeDetectorDefinition> {
+    allRenderDirectiveMetadata: List<RenderDirectiveMetadata>): List<ChangeDetectorDefinition> {
   return ListWrapper.map(nestedPvsWithIndex, (pvWithIndex) => {
     var elementBinders = pvWithIndex.renderProtoView.elementBinders;
     var bindingRecordsCreator = new BindingRecordsCreator();
@@ -277,10 +281,10 @@ function _getChangeDetectorDefinitions(
         bindingRecordsCreator.getDirectiveRecords(elementBinders, allRenderDirectiveMetadata);
     var strategyName = DEFAULT;
     var typeString;
-    if (pvWithIndex.renderProtoView.type === renderApi.ViewType.COMPONENT) {
+    if (pvWithIndex.renderProtoView.type === ViewType.COMPONENT) {
       strategyName = hostComponentMetadata.changeDetection;
       typeString = 'comp';
-    } else if (pvWithIndex.renderProtoView.type === renderApi.ViewType.HOST) {
+    } else if (pvWithIndex.renderProtoView.type === ViewType.HOST) {
       typeString = 'host';
     } else {
       typeString = 'embedded';
@@ -293,7 +297,7 @@ function _getChangeDetectorDefinitions(
 }
 
 function _createAppProtoView(
-    renderProtoView: renderApi.ProtoViewDto, protoChangeDetector: ProtoChangeDetector,
+    renderProtoView: ProtoViewDto, protoChangeDetector: ProtoChangeDetector,
     variableBindings: Map<string, string>, allDirectives: List<DirectiveBinding>,
     pipes: PipeBinding[]): AppProtoView {
   var elementBinders = renderProtoView.elementBinders;
@@ -346,7 +350,7 @@ function _createVariableNames(parentVariableNames: List<string>, renderProtoView
   return res;
 }
 
-export function createVariableLocations(elementBinders: List<renderApi.ElementBinder>):
+export function createVariableLocations(elementBinders: List<RenderElementBinder>):
     Map<string, number> {
   var variableLocations = new Map();
   for (var i = 0; i < elementBinders.length; i++) {
@@ -368,7 +372,7 @@ function _createElementBinders(protoView, elementBinders, allDirectiveBindings)
         ListWrapper.map(dirs, (dir) => allDirectiveBindings[dir.directiveIndex]);
     var componentDirectiveBinding = null;
     if (directiveBindings.length > 0) {
-      if (directiveBindings[0].metadata.type === renderApi.DirectiveMetadata.COMPONENT_TYPE) {
+      if (directiveBindings[0].metadata.type === RenderDirectiveMetadata.COMPONENT_TYPE) {
         componentDirectiveBinding = directiveBindings[0];
       }
     }
@@ -439,7 +443,7 @@ function _createElementBinder(protoView: AppProtoView, boundElementIndex, render
   return elBinder;
 }
 
-export function createDirectiveVariableBindings(renderElementBinder: renderApi.ElementBinder,
+export function createDirectiveVariableBindings(renderElementBinder: RenderElementBinder,
                                                 directiveBindings: List<DirectiveBinding>):
     Map<string, number> {
   var directiveVariableBindings = new Map();
@@ -478,7 +482,7 @@ function _findDirectiveIndexByExportAs(renderElementBinder, directiveBindings, e
 function _directiveExportAs(directive): string {
   var directiveExportAs = directive.metadata.exportAs;
   if (isBlank(directiveExportAs) &&
-      directive.metadata.type === renderApi.DirectiveMetadata.COMPONENT_TYPE) {
+      directive.metadata.type === RenderDirectiveMetadata.COMPONENT_TYPE) {
     return "$implicit";
   } else {
     return directiveExportAs;
@@ -486,7 +490,7 @@ function _directiveExportAs(directive): string {
 }
 
 class RenderProtoViewWithIndex {
-  constructor(public renderProtoView: renderApi.ProtoViewDto, public index: number,
+  constructor(public renderProtoView: ProtoViewDto, public index: number,
               public parentIndex: number, public boundElementIndex: number) {}
 }
 
diff --git a/modules/angular2/src/core/compiler/view_resolver.ts b/modules/angular2/src/core/compiler/view_resolver.ts
index fe85096698..89d0b6de1c 100644
--- a/modules/angular2/src/core/compiler/view_resolver.ts
+++ b/modules/angular2/src/core/compiler/view_resolver.ts
@@ -1,5 +1,5 @@
 import {Injectable} from 'angular2/di';
-import {View} from 'angular2/src/core/annotations_impl/view';
+import {ViewMetadata} from '../metadata/view';
 
 import {Type, stringify, isBlank, BaseException} from 'angular2/src/facade/lang';
 import {Map, MapWrapper, List, ListWrapper} from 'angular2/src/facade/collection';
@@ -11,7 +11,7 @@ import {reflector} from 'angular2/src/reflection/reflection';
 export class ViewResolver {
   _cache: Map<Type, /*node*/ any> = new Map();
 
-  resolve(component: Type): View {
+  resolve(component: Type): ViewMetadata {
     var view = this._cache.get(component);
 
     if (isBlank(view)) {
@@ -22,11 +22,11 @@ export class ViewResolver {
     return view;
   }
 
-  _resolve(component: Type): View {
+  _resolve(component: Type): ViewMetadata {
     var annotations = reflector.annotations(component);
     for (var i = 0; i < annotations.length; i++) {
       var annotation = annotations[i];
-      if (annotation instanceof View) {
+      if (annotation instanceof ViewMetadata) {
         return annotation;
       }
     }
diff --git a/modules/angular2/src/core/metadata.dart b/modules/angular2/src/core/metadata.dart
new file mode 100644
index 0000000000..f968a71708
--- /dev/null
+++ b/modules/angular2/src/core/metadata.dart
@@ -0,0 +1,97 @@
+library angular2.src.core.metadata;
+
+import "package:angular2/src/facade/collection.dart" show List;
+import "./metadata/di.dart";
+import "./metadata/directives.dart";
+import "./metadata/view.dart";
+
+export "./metadata/di.dart";
+export "./metadata/directives.dart";
+export "./metadata/view.dart";
+
+/**
+ * See: [DirectiveMetadata] for docs.
+ */
+class Directive extends DirectiveMetadata {
+  const Directive({String selector, List<String> properties,
+  List<String> events, Map<String, String> host,
+  List<LifecycleEvent> lifecycle, List bindings, String exportAs,
+  bool compileChildren: true})
+    : super(
+    selector: selector,
+    properties: properties,
+    events: events,
+    host: host,
+    lifecycle: lifecycle,
+    bindings: bindings,
+    exportAs: exportAs,
+    compileChildren: compileChildren);
+}
+
+/**
+ * See: [ComponentMetadata] for docs.
+ */
+class Component extends ComponentMetadata {
+  const Component({String selector, List<String> properties,
+  List<String> events, Map<String, String> host,
+  List<LifecycleEvent> lifecycle, List bindings, String exportAs,
+  bool compileChildren, List viewBindings, String changeDetection})
+    : super(
+    selector: selector,
+    properties: properties,
+    events: events,
+    host: host,
+    lifecycle: lifecycle,
+    bindings: bindings,
+    exportAs: exportAs,
+    compileChildren: compileChildren,
+    viewBindings: viewBindings,
+    changeDetection: changeDetection);
+}
+
+/**
+ * See: [ViewMetadata] for docs.
+ */
+class View extends ViewMetadata {
+  const View({String templateUrl, String template, dynamic directives,
+  dynamic pipes, ViewEncapsulation encapsulation, List<String> styles,
+  List<String> styleUrls})
+    : super(
+    templateUrl: templateUrl,
+    template: template,
+    directives: directives,
+    pipes: pipes,
+    encapsulation: encapsulation,
+    styles: styles,
+    styleUrls: styleUrls);
+}
+
+/**
+ * See: [PipeMetadata] for docs.
+ */
+class Pipe extends PipeMetadata {
+  const Pipe({name}) : super(name: name);
+}
+
+/**
+ * See: [AttributeMetadata] for docs.
+ */
+class Attribute extends AttributeMetadata {
+  const Attribute(String attributeName) : super(attributeName);
+}
+
+/**
+ * See: [QueryMetadata] for docs.
+ */
+class Query extends QueryMetadata {
+  const Query(dynamic /*Type | string*/ selector, {bool descendants: false})
+    : super(selector, descendants: descendants);
+}
+
+/**
+ * See: [ViewQueryMetadata] for docs.
+ */
+class ViewQuery extends ViewQueryMetadata {
+  const ViewQuery(dynamic /*Type | string*/ selector, {bool descendants: false})
+    : super(selector, descendants: descendants);
+}
diff --git a/modules/angular2/src/core/annotations/decorators.ts b/modules/angular2/src/core/metadata.ts
similarity index 76%
rename from modules/angular2/src/core/annotations/decorators.ts
rename to modules/angular2/src/core/metadata.ts
index c1c40a89dc..f7c2513640 100644
--- a/modules/angular2/src/core/annotations/decorators.ts
+++ b/modules/angular2/src/core/metadata.ts
@@ -1,30 +1,57 @@
-import {
-  ComponentAnnotation,
-  DirectiveAnnotation,
-  PipeAnnotation,
+/**
+ * This indirection is needed to free up Component, etc symbols in the public API
+ * to be used by the decorator versions of these annotations.
+ */
+
+export {
+  QueryMetadata,
+  ViewQueryMetadata,
+  AttributeMetadata,
+} from './metadata/di';
+
+export {
+  ComponentMetadata,
+  DirectiveMetadata,
+  PipeMetadata,
   LifecycleEvent
-} from './annotations';
-import {ViewAnnotation} from './view';
-import {AttributeAnnotation, QueryAnnotation, ViewQueryAnnotation} from './di';
-import {makeDecorator, makeParamDecorator, TypeDecorator, Class} from '../../util/decorators';
+} from './metadata/directives';
+
+export {ViewMetadata, ViewEncapsulation} from './metadata/view';
+
+
+import {
+  QueryMetadata,
+  ViewQueryMetadata,
+  AttributeMetadata,
+} from './metadata/di';
+
+import {
+  ComponentMetadata,
+  DirectiveMetadata,
+  PipeMetadata,
+  LifecycleEvent
+} from './metadata/directives';
+
+import {ViewMetadata, ViewEncapsulation} from './metadata/view';
+
+import {makeDecorator, makeParamDecorator, TypeDecorator, Class} from '../util/decorators';
 import {Type} from 'angular2/src/facade/lang';
-import {ViewEncapsulation} from 'angular2/src/render/api';
 
 /**
- * Interface for the {@link Directive} decorator function.
+ * Interface for the {@link DirectiveMetadata} decorator function.
  *
  * See {@link DirectiveFactory}.
  */
 export interface DirectiveDecorator extends TypeDecorator {}
 
 /**
- * Interface for the {@link Component} decorator function.
+ * Interface for the {@link ComponentMetadata} decorator function.
  *
  * See {@link ComponentFactory}.
  */
 export interface ComponentDecorator extends TypeDecorator {
   /**
-   * Chain {@link View} annotation.
+   * Chain {@link ViewMetadata} annotation.
    */
   View(obj: {
     templateUrl?: string,
@@ -38,13 +65,13 @@ export interface ComponentDecorator extends TypeDecorator {
 }
 
 /**
- * Interface for the {@link View} decorator function.
+ * Interface for the {@link ViewMetadata} decorator function.
  *
  * See {@link ViewFactory}.
  */
 export interface ViewDecorator extends TypeDecorator {
   /**
-   * Chain {@link View} annotation.
+   * Chain {@link ViewMetadata} annotation.
    */
   View(obj: {
     templateUrl?: string,
@@ -58,7 +85,7 @@ export interface ViewDecorator extends TypeDecorator {
 }
 
 /**
- * {@link Directive} factory for creating annotations, decorators or DSL.
+ * {@link DirectiveMetadata} factory for creating annotations, decorators or DSL.
  *
  * ## Example as TypeScript Decorator
  *
@@ -107,7 +134,7 @@ export interface DirectiveFactory {
     selector?: string, properties?: List<string>, events?: List<string>,
         host?: StringMap<string, string>, lifecycle?: List<LifecycleEvent>, bindings?: List<any>,
         exportAs?: string, compileChildren?: boolean;
-  }): DirectiveAnnotation;
+  }): DirectiveMetadata;
 }
 
 /**
@@ -177,7 +204,7 @@ export interface ComponentFactory {
     compileChildren?: boolean,
     viewBindings?: List<any>,
     changeDetection?: string,
-  }): ComponentAnnotation;
+  }): ComponentMetadata;
 }
 
 /**
@@ -239,11 +266,11 @@ export interface ViewFactory {
     encapsulation?: ViewEncapsulation,
     styles?: List<string>,
     styleUrls?: List<string>,
-  }): ViewAnnotation;
+  }): ViewMetadata;
 }
 
 /**
- * {@link Attribute} factory for creating annotations, decorators or DSL.
+ * {@link AttributeMetadata} factory for creating annotations, decorators or DSL.
  *
  * ## Example as TypeScript Decorator
  *
@@ -290,11 +317,11 @@ export interface ViewFactory {
  */
 export interface AttributeFactory {
   (name: string): TypeDecorator;
-  new (name: string): AttributeAnnotation;
+  new (name: string): AttributeMetadata;
 }
 
 /**
- * {@link Query} factory for creating annotations, decorators or DSL.
+ * {@link QueryMetadata} factory for creating annotations, decorators or DSL.
  *
  * ## Example as TypeScript Decorator
  *
@@ -341,11 +368,11 @@ export interface AttributeFactory {
  */
 export interface QueryFactory {
   (selector: Type | string, {descendants}?: {descendants?: boolean}): ParameterDecorator;
-  new (selector: Type | string, {descendants}?: {descendants?: boolean}): QueryAnnotation;
+  new (selector: Type | string, {descendants}?: {descendants?: boolean}): QueryMetadata;
 }
 
 /**
- * {@link Pipe} factory for creating decorators.
+ * {@link PipeMetadata} factory for creating decorators.
  *
  * ## Example as TypeScript Decorator
  *
@@ -370,38 +397,38 @@ export interface PipeFactory {
 }
 
 /**
- * {@link Component} factory function.
+ * {@link ComponentMetadata} factory function.
  */
 export var Component: ComponentFactory =
-    <ComponentFactory>makeDecorator(ComponentAnnotation, (fn: any) => fn.View = View);
+    <ComponentFactory>makeDecorator(ComponentMetadata, (fn: any) => fn.View = View);
 /**
- * {@link Directive} factory function.
+ * {@link DirectiveMetadata} factory function.
  */
-export var Directive: DirectiveFactory = <DirectiveFactory>makeDecorator(DirectiveAnnotation);
+export var Directive: DirectiveFactory = <DirectiveFactory>makeDecorator(DirectiveMetadata);
 
 /**
- * {@link View} factory function.
+ * {@link ViewMetadata} factory function.
  */
 export var View: ViewFactory =
-    <ViewFactory>makeDecorator(ViewAnnotation, (fn: any) => fn.View = View);
+    <ViewFactory>makeDecorator(ViewMetadata, (fn: any) => fn.View = View);
 
 /**
- * {@link Attribute} factory function.
+ * {@link AttributeMetadata} factory function.
  */
-export var Attribute: AttributeFactory = makeParamDecorator(AttributeAnnotation);
+export var Attribute: AttributeFactory = makeParamDecorator(AttributeMetadata);
 
 /**
- * {@link Query} factory function.
+ * {@link QueryMetadata} factory function.
  */
-export var Query: QueryFactory = makeParamDecorator(QueryAnnotation);
+export var Query: QueryFactory = makeParamDecorator(QueryMetadata);
 
 
 /**
- * {@link ViewQuery} factory function.
+ * {@link ViewQueryMetadata} factory function.
  */
-export var ViewQuery: QueryFactory = makeParamDecorator(ViewQueryAnnotation);
+export var ViewQuery: QueryFactory = makeParamDecorator(ViewQueryMetadata);
 
 /**
- * {@link Pipe} factory function.
+ * {@link PipeMetadata} factory function.
  */
-export var Pipe: PipeFactory = <PipeFactory>makeDecorator(PipeAnnotation);
+export var Pipe: PipeFactory = <PipeFactory>makeDecorator(PipeMetadata);
diff --git a/modules/angular2/src/core/annotations_impl/di.ts b/modules/angular2/src/core/metadata/di.ts
similarity index 93%
rename from modules/angular2/src/core/annotations_impl/di.ts
rename to modules/angular2/src/core/metadata/di.ts
index 1221be9ae4..e0b5ff0849 100644
--- a/modules/angular2/src/core/annotations_impl/di.ts
+++ b/modules/angular2/src/core/metadata/di.ts
@@ -29,7 +29,7 @@ import {resolveForwardRef} from 'angular2/di';
  * ```
  */
 @CONST()
-export class Attribute extends DependencyMetadata {
+export class AttributeMetadata extends DependencyMetadata {
   constructor(public attributeName: string) { super(); }
 
   get token() {
@@ -49,7 +49,7 @@ export class Attribute extends DependencyMetadata {
  * See {@link QueryList} for usage and example.
  */
 @CONST()
-export class Query extends DependencyMetadata {
+export class QueryMetadata extends DependencyMetadata {
   descendants: boolean;
   constructor(private _selector: Type | string,
               {descendants = false}: {descendants?: boolean} = {}) {
@@ -74,7 +74,7 @@ export class Query extends DependencyMetadata {
  * See {@link QueryList} for usage and example.
  */
 @CONST()
-export class ViewQuery extends Query {
+export class ViewQueryMetadata extends QueryMetadata {
   constructor(_selector: Type | string, {descendants = false}: {descendants?: boolean} = {}) {
     super(_selector, {descendants: descendants});
   }
diff --git a/modules/angular2/src/core/annotations_impl/annotations.ts b/modules/angular2/src/core/metadata/directives.ts
similarity index 97%
rename from modules/angular2/src/core/annotations_impl/annotations.ts
rename to modules/angular2/src/core/metadata/directives.ts
index 85b17e381b..4e36f42dff 100644
--- a/modules/angular2/src/core/annotations_impl/annotations.ts
+++ b/modules/angular2/src/core/metadata/directives.ts
@@ -6,7 +6,7 @@ import {DEFAULT} from 'angular2/change_detection';
 /**
  * Directives allow you to attach behavior to elements in the DOM.
  *
- * {@link Directive}s with an embedded view are called {@link Component}s.
+ * {@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
@@ -39,7 +39,7 @@ import {DEFAULT} from 'angular2/change_detection';
  * 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 View}:
+ * {@link ViewMetadata}:
  *
  * 1. Dependencies on the current element
  * 2. Dependencies on element injectors and their parents until it encounters a Shadow DOM boundary
@@ -64,7 +64,7 @@ import {DEFAULT} from 'angular2/change_detection';
  * 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 Directive} directives only
+ * {@link DirectiveMetadata} directives only
  * - `bindingPropagation: BindingPropagation` to control change detection in a more granular way.
  *
  * ## Example
@@ -288,7 +288,7 @@ import {DEFAULT} from 'angular2/change_detection';
  * location in the current view
  * where these actions are performed.
  *
- * Views are always created as children of the current {@link View}, and as siblings of the
+ * Views are always created as children of the current {@link ViewMetadata}, and as siblings of the
  * `<template>` element. Thus a
  * directive in a child view cannot inject the directive that created it.
  *
@@ -378,7 +378,7 @@ import {DEFAULT} from 'angular2/change_detection';
  * view occurs on the second `<li></li>` which is a sibling to the `<template>` element.
  */
 @CONST()
-export class Directive extends InjectableMetadata {
+export class DirectiveMetadata extends InjectableMetadata {
   /**
    * The CSS selector that triggers the instantiation of a directive.
    *
@@ -422,7 +422,7 @@ export class Directive extends InjectableMetadata {
    * - `directiveProperty` specifies the component property where the value is written.
    * - `bindingProperty` specifies the DOM property where the value is read from.
    *
-   * You can include a {@link Pipe} when specifying a `bindingProperty` to allow for data
+   * You can include a {@link PipeMetadata} when specifying a `bindingProperty` to allow for data
    * transformation and structural change detection of the value. These pipes will be evaluated in
    * the context of this component.
    *
@@ -768,7 +768,7 @@ export class Directive extends InjectableMetadata {
  *
  * All template expressions and statements are then evaluated against the component instance.
  *
- * For details on the `@View` annotation, see {@link View}.
+ * For details on the `@View` annotation, see {@link ViewMetadata}.
  *
  * ## Example
  *
@@ -790,7 +790,7 @@ export class Directive extends InjectableMetadata {
  *
  */
 @CONST()
-export class Component extends Directive {
+export class ComponentMetadata extends DirectiveMetadata {
   /**
    * Defines the used change detection strategy.
    *
@@ -884,7 +884,7 @@ export class Component extends Directive {
  */
 export enum LifecycleEvent {
   /**
-   * Notify a directive whenever a {@link View} that contains it is destroyed.
+   * Notify a directive whenever a {@link ViewMetadata} that contains it is destroyed.
    *
    * ## Example
    *
@@ -1022,7 +1022,7 @@ export enum LifecycleEvent {
  * ```
  */
 @CONST()
-export class Pipe extends InjectableMetadata {
+export class PipeMetadata extends InjectableMetadata {
   name: string;
 
   constructor({name}: {name: string}) {
diff --git a/modules/angular2/src/core/annotations_impl/view.ts b/modules/angular2/src/core/metadata/view.ts
similarity index 98%
rename from modules/angular2/src/core/annotations_impl/view.ts
rename to modules/angular2/src/core/metadata/view.ts
index eb83dfd0ea..ed6726921f 100644
--- a/modules/angular2/src/core/annotations_impl/view.ts
+++ b/modules/angular2/src/core/metadata/view.ts
@@ -13,7 +13,7 @@ export {ViewEncapsulation} from 'angular2/src/render/api';
  * 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}.
+ * For details on the `@Component` annotation, see {@link ComponentMetadata}.
  *
  * ## Example
  *
@@ -35,7 +35,7 @@ export {ViewEncapsulation} from 'angular2/src/render/api';
  * ```
  */
 @CONST()
-export class View {
+export class ViewMetadata {
   /**
    * Specifies a template URL for an angular component.
    *
diff --git a/modules/angular2/src/core/pipes/pipe_binding.ts b/modules/angular2/src/core/pipes/pipe_binding.ts
index bd6a1643fb..c02f574538 100644
--- a/modules/angular2/src/core/pipes/pipe_binding.ts
+++ b/modules/angular2/src/core/pipes/pipe_binding.ts
@@ -1,15 +1,15 @@
 import {Type} from 'angular2/src/facade/lang';
 import {Key, Dependency, ResolvedBinding, Binding} from 'angular2/di';
-import {Pipe} from 'angular2/src/core/annotations_impl/annotations';
+import {PipeMetadata} from '../metadata/directives';
 
 export class PipeBinding extends ResolvedBinding {
   constructor(public name: string, key: Key, factory: Function, dependencies: Dependency[]) {
     super(key, factory, dependencies);
   }
 
-  static createFromType(type: Type, metadata: Pipe): PipeBinding {
+  static createFromType(type: Type, metadata: PipeMetadata): PipeBinding {
     var binding = new Binding(type, {toClass: type});
     var rb = binding.resolve();
     return new PipeBinding(metadata.name, rb.key, rb.factory, rb.dependencies);
   }
-}
\ No newline at end of file
+}
diff --git a/modules/angular2/src/core/pipes/pipes.ts b/modules/angular2/src/core/pipes/pipes.ts
index 31a6395209..5f0e80b76b 100644
--- a/modules/angular2/src/core/pipes/pipes.ts
+++ b/modules/angular2/src/core/pipes/pipes.ts
@@ -5,7 +5,7 @@ import * as cd from 'angular2/src/change_detection/pipes';
 
 export class ProtoPipes {
   /**
-   * Map of {@link Pipe} names to {@link Pipe} implementations.
+   * Map of {@link PipeMetadata} names to {@link PipeMetadata} implementations.
    */
   config: StringMap<string, PipeBinding> = {};
 
diff --git a/modules/angular2/src/directives/ng_class.ts b/modules/angular2/src/directives/ng_class.ts
index 0a2f331790..ad83203be0 100644
--- a/modules/angular2/src/directives/ng_class.ts
+++ b/modules/angular2/src/directives/ng_class.ts
@@ -1,5 +1,5 @@
 import {isPresent, isString, StringWrapper, isBlank} from 'angular2/src/facade/lang';
-import {Directive, LifecycleEvent} from 'angular2/annotations';
+import {Directive, LifecycleEvent} from 'angular2/metadata';
 import {ElementRef} from 'angular2/core';
 import {Renderer} from 'angular2/src/render/api';
 import {
diff --git a/modules/angular2/src/directives/ng_for.ts b/modules/angular2/src/directives/ng_for.ts
index af6f126702..40d3da30b8 100644
--- a/modules/angular2/src/directives/ng_for.ts
+++ b/modules/angular2/src/directives/ng_for.ts
@@ -1,4 +1,4 @@
-import {Directive, LifecycleEvent} from 'angular2/annotations';
+import {Directive, LifecycleEvent} from 'angular2/metadata';
 import {ViewContainerRef, ViewRef, TemplateRef} from 'angular2/core';
 import {ChangeDetectorRef, IterableDiffer, IterableDiffers} from 'angular2/change_detection';
 import {isPresent, isBlank} from 'angular2/src/facade/lang';
diff --git a/modules/angular2/src/directives/ng_if.ts b/modules/angular2/src/directives/ng_if.ts
index bf4ac171d8..7536dcfa5e 100644
--- a/modules/angular2/src/directives/ng_if.ts
+++ b/modules/angular2/src/directives/ng_if.ts
@@ -1,4 +1,4 @@
-import {Directive} from 'angular2/annotations';
+import {Directive} from 'angular2/metadata';
 import {ViewContainerRef, TemplateRef} from 'angular2/core';
 import {isBlank} from 'angular2/src/facade/lang';
 
diff --git a/modules/angular2/src/directives/ng_non_bindable.ts b/modules/angular2/src/directives/ng_non_bindable.ts
index 2829fad541..3608098fe5 100644
--- a/modules/angular2/src/directives/ng_non_bindable.ts
+++ b/modules/angular2/src/directives/ng_non_bindable.ts
@@ -1,4 +1,4 @@
-import {Directive} from 'angular2/annotations';
+import {Directive} from 'angular2/metadata';
 
 /**
  * The `NgNonBindable` directive tells Angular not to compile or bind the contents of the current
diff --git a/modules/angular2/src/directives/ng_style.ts b/modules/angular2/src/directives/ng_style.ts
index 2408d6fd5c..cf9f4801bf 100644
--- a/modules/angular2/src/directives/ng_style.ts
+++ b/modules/angular2/src/directives/ng_style.ts
@@ -1,4 +1,4 @@
-import {Directive, LifecycleEvent} from 'angular2/annotations';
+import {Directive, LifecycleEvent} from 'angular2/metadata';
 import {ElementRef} from 'angular2/core';
 import {KeyValueDiffer, KeyValueDiffers} from 'angular2/change_detection';
 import {isPresent, isBlank, print} from 'angular2/src/facade/lang';
diff --git a/modules/angular2/src/directives/ng_switch.ts b/modules/angular2/src/directives/ng_switch.ts
index c9e237ea25..46945c9d44 100644
--- a/modules/angular2/src/directives/ng_switch.ts
+++ b/modules/angular2/src/directives/ng_switch.ts
@@ -1,4 +1,4 @@
-import {Directive} from 'angular2/annotations';
+import {Directive} from 'angular2/metadata';
 import {Host} from 'angular2/di';
 import {ViewContainerRef, TemplateRef} from 'angular2/core';
 import {isPresent, isBlank, normalizeBlank, CONST_EXPR} from 'angular2/src/facade/lang';
diff --git a/modules/angular2/src/forms/directives/checkbox_value_accessor.ts b/modules/angular2/src/forms/directives/checkbox_value_accessor.ts
index eb768c2b78..ac408e2c33 100644
--- a/modules/angular2/src/forms/directives/checkbox_value_accessor.ts
+++ b/modules/angular2/src/forms/directives/checkbox_value_accessor.ts
@@ -1,5 +1,5 @@
 import {Renderer} from 'angular2/render';
-import {Directive} from 'angular2/annotations';
+import {Directive} from 'angular2/metadata';
 import {ElementRef} from 'angular2/core';
 import {Self} from 'angular2/di';
 
diff --git a/modules/angular2/src/forms/directives/default_value_accessor.ts b/modules/angular2/src/forms/directives/default_value_accessor.ts
index 4d8858d78b..8d0b6cbff0 100644
--- a/modules/angular2/src/forms/directives/default_value_accessor.ts
+++ b/modules/angular2/src/forms/directives/default_value_accessor.ts
@@ -1,5 +1,5 @@
 import {Renderer} from 'angular2/render';
-import {Directive} from 'angular2/annotations';
+import {Directive} from 'angular2/metadata';
 import {ElementRef} from 'angular2/core';
 import {Self} from 'angular2/di';
 import {NgControl} from './ng_control';
diff --git a/modules/angular2/src/forms/directives/ng_control_group.ts b/modules/angular2/src/forms/directives/ng_control_group.ts
index dfd7785a11..b6a60eb366 100644
--- a/modules/angular2/src/forms/directives/ng_control_group.ts
+++ b/modules/angular2/src/forms/directives/ng_control_group.ts
@@ -1,4 +1,4 @@
-import {Directive, LifecycleEvent} from 'angular2/annotations';
+import {Directive, LifecycleEvent} from 'angular2/metadata';
 import {Inject, Host, SkipSelf, forwardRef, Binding} from 'angular2/di';
 import {List, ListWrapper} from 'angular2/src/facade/collection';
 import {CONST_EXPR} from 'angular2/src/facade/lang';
diff --git a/modules/angular2/src/forms/directives/ng_control_name.ts b/modules/angular2/src/forms/directives/ng_control_name.ts
index 9d9b644afc..cd48121e17 100644
--- a/modules/angular2/src/forms/directives/ng_control_name.ts
+++ b/modules/angular2/src/forms/directives/ng_control_name.ts
@@ -3,7 +3,7 @@ import {EventEmitter, ObservableWrapper} from 'angular2/src/facade/async';
 import {List, StringMap} from 'angular2/src/facade/collection';
 
 import {QueryList} from 'angular2/core';
-import {Query, Directive, LifecycleEvent} from 'angular2/annotations';
+import {Query, Directive, LifecycleEvent} from 'angular2/metadata';
 import {forwardRef, Host, SkipSelf, Binding, Inject} from 'angular2/di';
 
 import {ControlContainer} from './control_container';
diff --git a/modules/angular2/src/forms/directives/ng_form.ts b/modules/angular2/src/forms/directives/ng_form.ts
index f24bede943..3b4dc88371 100644
--- a/modules/angular2/src/forms/directives/ng_form.ts
+++ b/modules/angular2/src/forms/directives/ng_form.ts
@@ -6,7 +6,7 @@ import {
 } from 'angular2/src/facade/async';
 import {StringMapWrapper, List, ListWrapper} from 'angular2/src/facade/collection';
 import {isPresent, isBlank, CONST_EXPR} from 'angular2/src/facade/lang';
-import {Directive} from 'angular2/annotations';
+import {Directive} from 'angular2/metadata';
 import {forwardRef, Binding} from 'angular2/di';
 import {NgControl} from './ng_control';
 import {Form} from './form_interface';
diff --git a/modules/angular2/src/forms/directives/ng_form_control.ts b/modules/angular2/src/forms/directives/ng_form_control.ts
index 669d7fc920..f460c42816 100644
--- a/modules/angular2/src/forms/directives/ng_form_control.ts
+++ b/modules/angular2/src/forms/directives/ng_form_control.ts
@@ -2,7 +2,7 @@ import {CONST_EXPR} from 'angular2/src/facade/lang';
 import {EventEmitter, ObservableWrapper} from 'angular2/src/facade/async';
 
 import {QueryList} from 'angular2/core';
-import {Query, Directive, LifecycleEvent} from 'angular2/annotations';
+import {Query, Directive, LifecycleEvent} from 'angular2/metadata';
 import {forwardRef, Binding} from 'angular2/di';
 
 import {NgControl} from './ng_control';
diff --git a/modules/angular2/src/forms/directives/ng_form_model.ts b/modules/angular2/src/forms/directives/ng_form_model.ts
index 46f6981fdd..bc4d903bd2 100644
--- a/modules/angular2/src/forms/directives/ng_form_model.ts
+++ b/modules/angular2/src/forms/directives/ng_form_model.ts
@@ -2,7 +2,7 @@ import {CONST_EXPR} from 'angular2/src/facade/lang';
 import {List, ListWrapper} from 'angular2/src/facade/collection';
 import {ObservableWrapper, EventEmitter} from 'angular2/src/facade/async';
 
-import {Directive, LifecycleEvent} from 'angular2/annotations';
+import {Directive, LifecycleEvent} from 'angular2/metadata';
 import {forwardRef, Binding} from 'angular2/di';
 import {NgControl} from './ng_control';
 import {NgControlGroup} from './ng_control_group';
diff --git a/modules/angular2/src/forms/directives/ng_model.ts b/modules/angular2/src/forms/directives/ng_model.ts
index dbc0f908ee..c598619434 100644
--- a/modules/angular2/src/forms/directives/ng_model.ts
+++ b/modules/angular2/src/forms/directives/ng_model.ts
@@ -2,7 +2,7 @@ import {CONST_EXPR} from 'angular2/src/facade/lang';
 import {EventEmitter, ObservableWrapper} from 'angular2/src/facade/async';
 
 import {QueryList} from 'angular2/core';
-import {Query, Directive, LifecycleEvent} from 'angular2/annotations';
+import {Query, Directive, LifecycleEvent} from 'angular2/metadata';
 import {forwardRef, Binding} from 'angular2/di';
 
 import {NgControl} from './ng_control';
diff --git a/modules/angular2/src/forms/directives/select_control_value_accessor.ts b/modules/angular2/src/forms/directives/select_control_value_accessor.ts
index 7366ddbdd8..89662783a4 100644
--- a/modules/angular2/src/forms/directives/select_control_value_accessor.ts
+++ b/modules/angular2/src/forms/directives/select_control_value_accessor.ts
@@ -1,7 +1,7 @@
 import {Renderer} from 'angular2/render';
 import {ElementRef, QueryList} from 'angular2/core';
 import {Self} from 'angular2/di';
-import {Query, Directive} from 'angular2/annotations';
+import {Query, Directive} from 'angular2/metadata';
 
 import {NgControl} from './ng_control';
 import {ControlValueAccessor} from './control_value_accessor';
diff --git a/modules/angular2/src/forms/directives/validators.ts b/modules/angular2/src/forms/directives/validators.ts
index 328fb7832f..c873da7f33 100644
--- a/modules/angular2/src/forms/directives/validators.ts
+++ b/modules/angular2/src/forms/directives/validators.ts
@@ -1,6 +1,6 @@
 import {forwardRef, Binding} from 'angular2/di';
 import {CONST_EXPR} from 'angular2/src/facade/lang';
-import {Directive} from 'angular2/annotations';
+import {Directive} from 'angular2/metadata';
 import {Validators} from '../validators';
 
 export class NgValidator {
diff --git a/modules/angular2/src/mock/view_resolver_mock.ts b/modules/angular2/src/mock/view_resolver_mock.ts
index 446e8f252d..87844bd234 100644
--- a/modules/angular2/src/mock/view_resolver_mock.ts
+++ b/modules/angular2/src/mock/view_resolver_mock.ts
@@ -1,24 +1,24 @@
 import {Map, MapWrapper, ListWrapper} from 'angular2/src/facade/collection';
 import {Type, isPresent, BaseException, stringify, isBlank} from 'angular2/src/facade/lang';
 
-import {View} from 'angular2/src/core/annotations_impl/view';
+import {ViewMetadata} from '../core/metadata';
 import {ViewResolver} from 'angular2/src/core/compiler/view_resolver';
 
 export class MockViewResolver extends ViewResolver {
-  _views: Map<Type, View> = new Map();
+  _views: Map<Type, ViewMetadata> = new Map();
   _inlineTemplates: Map<Type, string> = new Map();
-  _viewCache: Map<Type, View> = new Map();
+  _viewCache: Map<Type, ViewMetadata> = new Map();
   _directiveOverrides: Map<Type, Map<Type, Type>> = new Map();
 
   constructor() { super(); }
 
   /**
-   * Overrides the {@link View} for a component.
+   * Overrides the {@link ViewMetadata} for a component.
    *
    * @param {Type} component
    * @param {ViewDefinition} view
    */
-  setView(component: Type, view: View): void {
+  setView(component: Type, view: ViewMetadata): void {
     this._checkOverrideable(component);
     this._views.set(component, view);
   }
@@ -35,7 +35,7 @@ export class MockViewResolver extends ViewResolver {
   }
 
   /**
-   * Overrides a directive from the component {@link View}.
+   * Overrides a directive from the component {@link ViewMetadata}.
    *
    * @param {Type} component
    * @param {Type} from
@@ -55,8 +55,8 @@ export class MockViewResolver extends ViewResolver {
   }
 
   /**
-   * Returns the {@link View} for a component:
-   * - Set the {@link View} to the overridden view when it exists or fallback to the default
+   * Returns the {@link ViewMetadata} for a component:
+   * - Set the {@link ViewMetadata} to the overridden view when it exists or fallback to the default
    * `ViewResolver`,
    *   see `setView`.
    * - Override the directives, see `overrideViewDirective`.
@@ -65,7 +65,7 @@ export class MockViewResolver extends ViewResolver {
    * @param component
    * @returns {ViewDefinition}
    */
-  resolve(component: Type): View {
+  resolve(component: Type): ViewMetadata {
     var view = this._viewCache.get(component);
     if (isPresent(view)) return view;
 
@@ -87,13 +87,14 @@ export class MockViewResolver extends ViewResolver {
         }
         directives[srcIndex] = to;
       });
-      view = new View(
+      view = new ViewMetadata(
           {template: view.template, templateUrl: view.templateUrl, directives: directives});
     }
 
     var inlineTemplate = this._inlineTemplates.get(component);
     if (isPresent(inlineTemplate)) {
-      view = new View({template: inlineTemplate, templateUrl: null, directives: view.directives});
+      view = new ViewMetadata(
+          {template: inlineTemplate, templateUrl: null, directives: view.directives});
     }
 
     this._viewCache.set(component, view);
diff --git a/modules/angular2/src/pipes/async_pipe.ts b/modules/angular2/src/pipes/async_pipe.ts
index 6280261373..54c02aad15 100644
--- a/modules/angular2/src/pipes/async_pipe.ts
+++ b/modules/angular2/src/pipes/async_pipe.ts
@@ -6,7 +6,7 @@ import {PipeTransform, PipeOnDestroy, WrappedValue} from 'angular2/change_detect
 import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
 import {ChangeDetectorRef} from 'angular2/change_detection';
 
-import {Pipe} from 'angular2/src/core/annotations/decorators';
+import {Pipe} from '../core/metadata';
 
 
 class ObservableStrategy {
@@ -127,4 +127,4 @@ export class AsyncPipe implements PipeTransform, PipeOnDestroy {
       this._ref.requestCheck();
     }
   }
-}
\ No newline at end of file
+}
diff --git a/modules/angular2/src/pipes/date_pipe.ts b/modules/angular2/src/pipes/date_pipe.ts
index bb91ea2d12..4bf8dd88ce 100644
--- a/modules/angular2/src/pipes/date_pipe.ts
+++ b/modules/angular2/src/pipes/date_pipe.ts
@@ -15,7 +15,7 @@ import {StringMapWrapper, ListWrapper} from 'angular2/src/facade/collection';
 import {PipeTransform, WrappedValue} from 'angular2/change_detection';
 import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
 
-import {Pipe} from 'angular2/src/core/annotations/decorators';
+import {Pipe} from '../core/metadata';
 
 // TODO: move to a global configable location along with other i18n components.
 var defaultLocale: string = 'en-US';
diff --git a/modules/angular2/src/pipes/json_pipe.ts b/modules/angular2/src/pipes/json_pipe.ts
index 3357b7734b..4fb41350cb 100644
--- a/modules/angular2/src/pipes/json_pipe.ts
+++ b/modules/angular2/src/pipes/json_pipe.ts
@@ -3,7 +3,7 @@ import {Injectable} from 'angular2/di';
 
 import {PipeTransform, WrappedValue} from 'angular2/change_detection';
 
-import {Pipe} from 'angular2/src/core/annotations/decorators';
+import {Pipe} from '../core/metadata';
 
 /**
  * Implements json transforms to any object.
diff --git a/modules/angular2/src/pipes/limit_to_pipe.ts b/modules/angular2/src/pipes/limit_to_pipe.ts
index 721e0bbaed..7cd2bccdeb 100644
--- a/modules/angular2/src/pipes/limit_to_pipe.ts
+++ b/modules/angular2/src/pipes/limit_to_pipe.ts
@@ -13,7 +13,7 @@ import {Injectable} from 'angular2/di';
 import {PipeTransform, WrappedValue} from 'angular2/change_detection';
 import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
 
-import {Pipe} from 'angular2/src/core/annotations/decorators';
+import {Pipe} from '../core/metadata';
 
 /**
  * Creates a new List or String containing only a prefix/suffix of the
diff --git a/modules/angular2/src/pipes/lowercase_pipe.ts b/modules/angular2/src/pipes/lowercase_pipe.ts
index afd07656c1..8d97f17187 100644
--- a/modules/angular2/src/pipes/lowercase_pipe.ts
+++ b/modules/angular2/src/pipes/lowercase_pipe.ts
@@ -5,7 +5,7 @@ import {PipeTransform, WrappedValue} from 'angular2/change_detection';
 import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
 
 
-import {Pipe} from 'angular2/src/core/annotations/decorators';
+import {Pipe} from '../core/metadata';
 
 /**
  * Implements lowercase transforms to text.
diff --git a/modules/angular2/src/pipes/number_pipe.ts b/modules/angular2/src/pipes/number_pipe.ts
index f0c2424445..a4e387d13b 100644
--- a/modules/angular2/src/pipes/number_pipe.ts
+++ b/modules/angular2/src/pipes/number_pipe.ts
@@ -16,7 +16,7 @@ import {ListWrapper} from 'angular2/src/facade/collection';
 import {PipeTransform, WrappedValue} from 'angular2/change_detection';
 import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
 
-import {Pipe} from 'angular2/src/core/annotations/decorators';
+import {Pipe} from '../core/metadata';
 
 var defaultLocale: string = 'en-US';
 var _re = RegExpWrapper.create('^(\\d+)?\\.((\\d+)(\\-(\\d+))?)?$');
diff --git a/modules/angular2/src/pipes/uppercase_pipe.ts b/modules/angular2/src/pipes/uppercase_pipe.ts
index 9227c85944..888a088e9a 100644
--- a/modules/angular2/src/pipes/uppercase_pipe.ts
+++ b/modules/angular2/src/pipes/uppercase_pipe.ts
@@ -4,7 +4,7 @@ import {Injectable} from 'angular2/di';
 import {PipeTransform, WrappedValue} from 'angular2/change_detection';
 import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
 
-import {Pipe} from 'angular2/src/core/annotations/decorators';
+import {Pipe} from '../core/metadata';
 
 /**
  * Implements uppercase transforms to text.
diff --git a/modules/angular2/src/render/api.ts b/modules/angular2/src/render/api.ts
index 03f6b4d198..357fee02a5 100644
--- a/modules/angular2/src/render/api.ts
+++ b/modules/angular2/src/render/api.ts
@@ -36,7 +36,7 @@ export class ElementPropertyBinding {
               public property: string, public unit: string = null) {}
 }
 
-export class ElementBinder {
+export class RenderElementBinder {
   index: number;
   parentIndex: number;
   distanceToParent: number;
@@ -110,7 +110,7 @@ export enum ViewType {
 
 export class ProtoViewDto {
   render: RenderProtoViewRef;
-  elementBinders: List<ElementBinder>;
+  elementBinders: List<RenderElementBinder>;
   variableBindings: Map<string, string>;
   type: ViewType;
   textBindings: List<ASTWithSource>;
@@ -119,7 +119,7 @@ export class ProtoViewDto {
   constructor({render, elementBinders, variableBindings, type, textBindings,
                transitiveNgContentCount}: {
     render?: RenderProtoViewRef,
-    elementBinders?: List<ElementBinder>,
+    elementBinders?: List<RenderElementBinder>,
     variableBindings?: Map<string, string>,
     type?: ViewType,
     textBindings?: List<ASTWithSource>,
@@ -134,7 +134,7 @@ export class ProtoViewDto {
   }
 }
 
-export class DirectiveMetadata {
+export class RenderDirectiveMetadata {
   static get DIRECTIVE_TYPE() { return 0; }
   static get COMPONENT_TYPE() { return 1; }
   id: any;
@@ -220,7 +220,7 @@ export class DirectiveMetadata {
     callOnAllChangesDone?: boolean,
     changeDetection?: string,
     exportAs?: string
-  }): DirectiveMetadata {
+  }): RenderDirectiveMetadata {
     let hostListeners = new Map();
     let hostProperties = new Map();
     let hostAttributes = new Map();
@@ -228,7 +228,7 @@ export class DirectiveMetadata {
 
     if (isPresent(host)) {
       MapWrapper.forEach(host, (value: string, key: string) => {
-        var matches = RegExpWrapper.firstMatch(DirectiveMetadata._hostRegExp, key);
+        var matches = RegExpWrapper.firstMatch(RenderDirectiveMetadata._hostRegExp, key);
         if (isBlank(matches)) {
           hostAttributes.set(key, value);
         } else if (isPresent(matches[1])) {
@@ -241,7 +241,7 @@ export class DirectiveMetadata {
       });
     }
 
-    return new DirectiveMetadata({
+    return new RenderDirectiveMetadata({
       id: id,
       selector: selector,
       compileChildren: compileChildren,
@@ -296,7 +296,7 @@ export class ViewDefinition {
   componentId: string;
   templateAbsUrl: string;
   template: string;
-  directives: List<DirectiveMetadata>;
+  directives: List<RenderDirectiveMetadata>;
   styleAbsUrls: List<string>;
   styles: List<string>;
   encapsulation: ViewEncapsulation;
@@ -308,7 +308,7 @@ export class ViewDefinition {
     template?: string,
     styleAbsUrls?: List<string>,
     styles?: List<string>,
-    directives?: List<DirectiveMetadata>,
+    directives?: List<RenderDirectiveMetadata>,
     encapsulation?: ViewEncapsulation
   } = {}) {
     this.componentId = componentId;
@@ -348,7 +348,7 @@ export class RenderCompiler {
   /**
    * Creats a ProtoViewDto that contains a single nested component with the given componentId.
    */
-  compileHost(directiveMetadata: DirectiveMetadata): Promise<ProtoViewDto> { return null; }
+  compileHost(directiveMetadata: RenderDirectiveMetadata): Promise<ProtoViewDto> { return null; }
 
   /**
    * Compiles a single DomProtoView. Non recursive so that
diff --git a/modules/angular2/src/render/dom/compiler/compiler.ts b/modules/angular2/src/render/dom/compiler/compiler.ts
index b12c7c8216..7bbdfe968c 100644
--- a/modules/angular2/src/render/dom/compiler/compiler.ts
+++ b/modules/angular2/src/render/dom/compiler/compiler.ts
@@ -8,7 +8,7 @@ import {
   ViewDefinition,
   ProtoViewDto,
   ViewType,
-  DirectiveMetadata,
+  RenderDirectiveMetadata,
   RenderCompiler,
   RenderProtoViewRef,
   RenderProtoViewMergeMapping,
@@ -50,7 +50,7 @@ export class DomCompiler extends RenderCompiler {
         });
   }
 
-  compileHost(directiveMetadata: DirectiveMetadata): Promise<ProtoViewDto> {
+  compileHost(directiveMetadata: RenderDirectiveMetadata): Promise<ProtoViewDto> {
     let hostViewDef = new ViewDefinition({
       componentId: directiveMetadata.id,
       templateAbsUrl: null, template: null,
diff --git a/modules/angular2/src/render/dom/compiler/directive_parser.ts b/modules/angular2/src/render/dom/compiler/directive_parser.ts
index a1496c1af0..906a49e66f 100644
--- a/modules/angular2/src/render/dom/compiler/directive_parser.ts
+++ b/modules/angular2/src/render/dom/compiler/directive_parser.ts
@@ -9,7 +9,7 @@ import {CompileStep} from './compile_step';
 import {CompileElement} from './compile_element';
 import {CompileControl} from './compile_control';
 
-import {DirectiveMetadata} from '../../api';
+import {RenderDirectiveMetadata} from '../../api';
 import {dashCaseToCamelCase, camelCaseToDashCase, EVENT_TARGET_SEPARATOR} from '../util';
 import {DirectiveBuilder, ElementBinderBuilder} from '../view/proto_view_builder';
 
@@ -20,7 +20,7 @@ import {DirectiveBuilder, ElementBinderBuilder} from '../view/proto_view_builder
 export class DirectiveParser implements CompileStep {
   _selectorMatcher: SelectorMatcher = new SelectorMatcher();
 
-  constructor(public _parser: Parser, public _directives: List<DirectiveMetadata>) {
+  constructor(public _parser: Parser, public _directives: List<RenderDirectiveMetadata>) {
     for (var i = 0; i < _directives.length; i++) {
       var directive = _directives[i];
       var selector = CssSelector.parse(directive.selector);
@@ -48,7 +48,7 @@ export class DirectiveParser implements CompileStep {
       var directive = this._directives[directiveIndex];
 
       elementBinder = current.bindElement();
-      if (directive.type === DirectiveMetadata.COMPONENT_TYPE) {
+      if (directive.type === RenderDirectiveMetadata.COMPONENT_TYPE) {
         this._ensureHasOnlyOneComponent(elementBinder, current.elementDescription);
 
         // components need to go first, so it is easier to locate them in the result.
diff --git a/modules/angular2/src/render/dom/convert.ts b/modules/angular2/src/render/dom/convert.ts
index 7259b9fdff..7c041c6f3c 100644
--- a/modules/angular2/src/render/dom/convert.ts
+++ b/modules/angular2/src/render/dom/convert.ts
@@ -1,12 +1,12 @@
 import {ListWrapper, MapWrapper} from 'angular2/src/facade/collection';
 import {isPresent, isArray} from 'angular2/src/facade/lang';
-import {DirectiveMetadata} from 'angular2/src/render/api';
+import {RenderDirectiveMetadata} from 'angular2/src/render/api';
 
 /**
  * Converts a [DirectiveMetadata] to a map representation. This creates a copy,
  * that is, subsequent changes to `meta` will not be mirrored in the map.
  */
-export function directiveMetadataToMap(meta: DirectiveMetadata): Map<string, any> {
+export function directiveMetadataToMap(meta: RenderDirectiveMetadata): Map<string, any> {
   return MapWrapper.createFromPairs([
     ['id', meta.id],
     ['selector', meta.selector],
@@ -35,8 +35,8 @@ export function directiveMetadataToMap(meta: DirectiveMetadata): Map<string, any
  * [DirectiveMetadata] object. This creates a copy, that is, subsequent changes
  * to `map` will not be mirrored in the [DirectiveMetadata] object.
  */
-export function directiveMetadataFromMap(map: Map<string, any>): DirectiveMetadata {
-  return new DirectiveMetadata({
+export function directiveMetadataFromMap(map: Map<string, any>): RenderDirectiveMetadata {
+  return new RenderDirectiveMetadata({
     id:<string>map.get('id'),
     selector:<string>map.get('selector'),
     compileChildren:<boolean>map.get('compileChildren'),
diff --git a/modules/angular2/src/render/dom/view/proto_view_builder.ts b/modules/angular2/src/render/dom/view/proto_view_builder.ts
index 697b2f4bd1..1e4766ef2b 100644
--- a/modules/angular2/src/render/dom/view/proto_view_builder.ts
+++ b/modules/angular2/src/render/dom/view/proto_view_builder.ts
@@ -23,7 +23,16 @@ import {DomElementBinder, Event, HostAction} from './element_binder';
 import {ElementSchemaRegistry} from '../schema/element_schema_registry';
 import {TemplateCloner} from '../template_cloner';
 
-import * as api from '../../api';
+import {
+  ViewType,
+  ViewEncapsulation,
+  ProtoViewDto,
+  DirectiveBinder,
+  RenderElementBinder,
+  EventBinding,
+  ElementPropertyBinding,
+  PropertyBindingType
+} from '../../api';
 
 import {
   NG_BINDING_CLASS,
@@ -39,8 +48,8 @@ export class ProtoViewBuilder {
   ngContentCount: number = 0;
   hostAttributes: Map<string, string> = new Map();
 
-  constructor(public rootElement, public type: api.ViewType,
-              public viewEncapsulation: api.ViewEncapsulation) {}
+  constructor(public rootElement, public type: ViewType,
+              public viewEncapsulation: ViewEncapsulation) {}
 
   bindElement(element: HTMLElement, description: string = null): ElementBinderBuilder {
     var builder = new ElementBinderBuilder(this.elements.length, element, description);
@@ -70,7 +79,7 @@ export class ProtoViewBuilder {
 
   setHostAttribute(name: string, value: string) { this.hostAttributes.set(name, value); }
 
-  build(schemaRegistry: ElementSchemaRegistry, templateCloner: TemplateCloner): api.ProtoViewDto {
+  build(schemaRegistry: ElementSchemaRegistry, templateCloner: TemplateCloner): ProtoViewDto {
     var domElementBinders = [];
 
     var apiElementBinders = [];
@@ -89,7 +98,7 @@ export class ProtoViewBuilder {
         ebb.eventBuilder.merge(dbb.eventBuilder);
         ListWrapper.forEach(dbb.templatePropertyNames,
                             (name) => directiveTemplatePropertyNames.add(name));
-        return new api.DirectiveBinder({
+        return new DirectiveBinder({
           directiveIndex: dbb.directiveIndex,
           propertyBindings: dbb.propertyBindings,
           eventBindings: dbb.eventBindings,
@@ -109,7 +118,7 @@ export class ProtoViewBuilder {
         textNodeExpressions.push(expression);
         textNodeIndices.push(nodeIndex);
       });
-      apiElementBinders.push(new api.ElementBinder({
+      apiElementBinders.push(new RenderElementBinder({
         index: ebb.index,
         parentIndex: parentIndex,
         distanceToParent: ebb.distanceToParent,
@@ -132,7 +141,7 @@ export class ProtoViewBuilder {
       }));
     });
     var rootNodeCount = DOM.childNodes(DOM.content(this.rootElement)).length;
-    return new api.ProtoViewDto({
+    return new ProtoViewDto({
       render: new DomProtoViewRef(DomProtoView.create(
           templateCloner, this.type, this.rootElement, this.viewEncapsulation, [rootNodeCount],
           rootTextNodeIndices, domElementBinders, this.hostAttributes)),
@@ -152,7 +161,7 @@ export class ElementBinderBuilder {
   nestedProtoView: ProtoViewBuilder = null;
   propertyBindings: Map<string, ASTWithSource> = new Map();
   variableBindings: Map<string, string> = new Map();
-  eventBindings: List<api.EventBinding> = [];
+  eventBindings: List<EventBinding> = [];
   eventBuilder: EventBuilder = new EventBuilder();
   textBindings: Map<Node, ASTWithSource> = new Map();
   readAttributes: Map<string, string> = new Map();
@@ -185,7 +194,7 @@ export class ElementBinderBuilder {
       throw new BaseException('Only one nested view per element is allowed');
     }
     this.nestedProtoView =
-        new ProtoViewBuilder(rootElement, api.ViewType.EMBEDDED, api.ViewEncapsulation.NONE);
+        new ProtoViewBuilder(rootElement, ViewType.EMBEDDED, ViewEncapsulation.NONE);
     return this.nestedProtoView;
   }
 
@@ -230,7 +239,7 @@ export class DirectiveBuilder {
   // property names used in the template
   templatePropertyNames: List<string> = [];
   hostPropertyBindings: Map<string, ASTWithSource> = new Map();
-  eventBindings: List<api.EventBinding> = [];
+  eventBindings: List<EventBinding> = [];
   eventBuilder: EventBuilder = new EventBuilder();
 
   constructor(public directiveIndex: number) {}
@@ -261,14 +270,14 @@ export class EventBuilder extends AstTransformer {
 
   constructor() { super(); }
 
-  add(name: string, source: ASTWithSource, target: string): api.EventBinding {
+  add(name: string, source: ASTWithSource, target: string): EventBinding {
     // TODO(tbosch): reenable this when we are parsing element properties
     // out of action expressions
     // var adjustedAst = astWithSource.ast.visit(this);
     var adjustedAst = source.ast;
     var fullName = isPresent(target) ? target + EVENT_TARGET_SEPARATOR + name : name;
-    var result = new api.EventBinding(
-        fullName, new ASTWithSource(adjustedAst, source.source, source.location));
+    var result =
+        new EventBinding(fullName, new ASTWithSource(adjustedAst, source.source, source.location));
     var event = new Event(name, target, fullName);
     if (isBlank(target)) {
       this.localEvents.push(event);
@@ -331,7 +340,7 @@ const STYLE_PREFIX = 'style';
 function buildElementPropertyBindings(
     schemaRegistry: ElementSchemaRegistry, protoElement: /*element*/ any, isNgComponent: boolean,
     bindingsInTemplate: Map<string, ASTWithSource>, directiveTemplatePropertyNames: Set<string>):
-    List<api.ElementPropertyBinding> {
+    List<ElementPropertyBinding> {
   var propertyBindings = [];
 
   MapWrapper.forEach(bindingsInTemplate, (ast, propertyNameInTemplate) => {
@@ -361,8 +370,8 @@ function buildElementPropertyBindings(
 
 function isValidElementPropertyBinding(schemaRegistry: ElementSchemaRegistry,
                                        protoElement: /*element*/ any, isNgComponent: boolean,
-                                       binding: api.ElementPropertyBinding): boolean {
-  if (binding.type === api.PropertyBindingType.PROPERTY) {
+                                       binding: ElementPropertyBinding): boolean {
+  if (binding.type === PropertyBindingType.PROPERTY) {
     if (!isNgComponent) {
       return schemaRegistry.hasProperty(protoElement, binding.property);
     } else {
@@ -374,19 +383,19 @@ function isValidElementPropertyBinding(schemaRegistry: ElementSchemaRegistry,
 }
 
 function createElementPropertyBinding(schemaRegistry: ElementSchemaRegistry, ast: ASTWithSource,
-                                      propertyNameInTemplate: string): api.ElementPropertyBinding {
+                                      propertyNameInTemplate: string): ElementPropertyBinding {
   var parts = StringWrapper.split(propertyNameInTemplate, PROPERTY_PARTS_SEPARATOR);
   if (parts.length === 1) {
     var propName = schemaRegistry.getMappedPropName(parts[0]);
-    return new api.ElementPropertyBinding(api.PropertyBindingType.PROPERTY, ast, propName);
+    return new ElementPropertyBinding(PropertyBindingType.PROPERTY, ast, propName);
   } else if (parts[0] == ATTRIBUTE_PREFIX) {
-    return new api.ElementPropertyBinding(api.PropertyBindingType.ATTRIBUTE, ast, parts[1]);
+    return new ElementPropertyBinding(PropertyBindingType.ATTRIBUTE, ast, parts[1]);
   } else if (parts[0] == CLASS_PREFIX) {
-    return new api.ElementPropertyBinding(api.PropertyBindingType.CLASS, ast,
-                                          camelCaseToDashCase(parts[1]));
+    return new ElementPropertyBinding(PropertyBindingType.CLASS, ast,
+                                      camelCaseToDashCase(parts[1]));
   } else if (parts[0] == STYLE_PREFIX) {
     var unit = parts.length > 2 ? parts[2] : null;
-    return new api.ElementPropertyBinding(api.PropertyBindingType.STYLE, ast, parts[1], unit);
+    return new ElementPropertyBinding(PropertyBindingType.STYLE, ast, parts[1], unit);
   } else {
     throw new BaseException(`Invalid property name ${propertyNameInTemplate}`);
   }
diff --git a/modules/angular2/src/router/router_link.ts b/modules/angular2/src/router/router_link.ts
index 26d503169c..f3b41c44b8 100644
--- a/modules/angular2/src/router/router_link.ts
+++ b/modules/angular2/src/router/router_link.ts
@@ -1,4 +1,4 @@
-import {Directive} from 'angular2/src/core/annotations/decorators';
+import {Directive} from '../core/metadata';
 import {List, StringMap, StringMapWrapper} from 'angular2/src/facade/collection';
 
 import {Router} from './router';
diff --git a/modules/angular2/src/router/router_outlet.ts b/modules/angular2/src/router/router_outlet.ts
index 0ec1ac6e73..5966fb3cb0 100644
--- a/modules/angular2/src/router/router_outlet.ts
+++ b/modules/angular2/src/router/router_outlet.ts
@@ -2,7 +2,7 @@ import {Promise, PromiseWrapper} from 'angular2/src/facade/async';
 import {StringMapWrapper} from 'angular2/src/facade/collection';
 import {isBlank, isPresent} from 'angular2/src/facade/lang';
 
-import {Directive, Attribute} from 'angular2/src/core/annotations/decorators';
+import {Directive, Attribute} from '../core/metadata';
 import {DynamicComponentLoader, ComponentRef, ElementRef} from 'angular2/core';
 import {Injector, bind, Dependency, UNDEFINED} from 'angular2/di';
 
diff --git a/modules/angular2/src/test_lib/test_component_builder.ts b/modules/angular2/src/test_lib/test_component_builder.ts
index 8d42e31d89..b016884659 100644
--- a/modules/angular2/src/test_lib/test_component_builder.ts
+++ b/modules/angular2/src/test_lib/test_component_builder.ts
@@ -4,7 +4,7 @@ import {Type, isPresent, BaseException, isBlank} from 'angular2/src/facade/lang'
 import {Promise} from 'angular2/src/facade/async';
 import {List, ListWrapper, MapWrapper} from 'angular2/src/facade/collection';
 
-import {View} from 'angular2/src/core/annotations_impl/view';
+import {ViewMetadata} from '../core/metadata';
 
 import {ViewResolver} from 'angular2/src/core/compiler/view_resolver';
 import {AppView} from 'angular2/src/core/compiler/view';
@@ -48,7 +48,7 @@ var _nextRootElementId = 0;
 @Injectable()
 export class TestComponentBuilder {
   _injector: Injector;
-  _viewOverrides: Map<Type, View>;
+  _viewOverrides: Map<Type, ViewMetadata>;
   _directiveOverrides: Map<Type, Map<Type, Type>>;
   _templateOverrides: Map<Type, string>;
 
@@ -68,8 +68,8 @@ export class TestComponentBuilder {
   }
 
   /**
-   * Overrides only the html of a {@link Component}.
-   * All the other properties of the component's {@link View} are preserved.
+   * Overrides only the html of a {@link ComponentMetadata}.
+   * All the other properties of the component's {@link ViewMetadata} are preserved.
    *
    * @param {Type} component
    * @param {string} html
@@ -83,21 +83,21 @@ export class TestComponentBuilder {
   }
 
   /**
-   * Overrides a component's {@link View}.
+   * Overrides a component's {@link ViewMetadata}.
    *
    * @param {Type} component
    * @param {view} View
    *
    * @return {TestComponentBuilder}
    */
-  overrideView(componentType: Type, view: View): TestComponentBuilder {
+  overrideView(componentType: Type, view: ViewMetadata): TestComponentBuilder {
     var clone = this._clone();
     clone._viewOverrides.set(componentType, view);
     return clone;
   }
 
   /**
-   * Overrides the directives from the component {@link View}.
+   * Overrides the directives from the component {@link ViewMetadata}.
    *
    * @param {Type} component
    * @param {Type} from
diff --git a/modules/angular2/src/transform/common/annotation_matcher.dart b/modules/angular2/src/transform/common/annotation_matcher.dart
index 92c29a7c3b..8813b8a95c 100644
--- a/modules/angular2/src/transform/common/annotation_matcher.dart
+++ b/modules/angular2/src/transform/common/annotation_matcher.dart
@@ -18,16 +18,11 @@ const INJECTABLES = const [
 ];
 
 const DIRECTIVES = const [
-  const ClassDescriptor(
-      'Directive', 'package:angular2/src/core/annotations/annotations.dart',
+  const ClassDescriptor('Directive', 'package:angular2/src/core/metadatada/directive.dart',
       superClass: 'Injectable'),
-  const ClassDescriptor(
-      'Directive', 'package:angular2/src/core/annotations/decorators.dart',
+  const ClassDescriptor('Directive', 'package:angular2/src/core/metadata.dart',
       superClass: 'Injectable'),
-  const ClassDescriptor('Directive',
-      'package:angular2/src/core/annotations_impl/annotations.dart',
-      superClass: 'Injectable'),
-  const ClassDescriptor('Directive', 'package:angular2/annotations.dart',
+  const ClassDescriptor('Directive', 'package:angular2/metadata.dart',
       superClass: 'Injectable'),
   const ClassDescriptor('Directive', 'package:angular2/angular2.dart',
       superClass: 'Injectable'),
@@ -38,34 +33,26 @@ const DIRECTIVES = const [
 ];
 
 const COMPONENTS = const [
-  const ClassDescriptor(
-      'Component', 'package:angular2/src/core/annotations/annotations.dart',
+  const ClassDescriptor('Component', 'package:angular2/src/core/metadata/directive.dart',
       superClass: 'Directive'),
-  const ClassDescriptor(
-      'Component', 'package:angular2/src/core/annotations/decorators.dart',
+  const ClassDescriptor('Component', 'package:angular2/src/core/metadata.dart',
       superClass: 'Directive'),
-  const ClassDescriptor('Component',
-      'package:angular2/src/core/annotations_impl/annotations.dart',
-      superClass: 'Directive'),
-  const ClassDescriptor('Component', 'package:angular2/annotations.dart',
+  const ClassDescriptor('Component', 'package:angular2/metadata.dart',
       superClass: 'Directive'),
   const ClassDescriptor('Component', 'package:angular2/angular2.dart',
       superClass: 'Directive'),
   const ClassDescriptor('Component', 'package:angular2/bootstrap_static.dart',
       superClass: 'Directive'),
   const ClassDescriptor('Component', 'package:angular2/core.dart',
-      superClass: 'Directive'),
+      superClass: '`Directive'),
 ];
 
 const VIEWS = const [
-  const ClassDescriptor('View', 'package:angular2/view.dart'),
   const ClassDescriptor('View', 'package:angular2/angular2.dart'),
   const ClassDescriptor('View', 'package:angular2/bootstrap_static.dart'),
   const ClassDescriptor('View', 'package:angular2/core.dart'),
-  const ClassDescriptor(
-      'View', 'package:angular2/src/core/annotations/view.dart'),
-  const ClassDescriptor(
-      'View', 'package:angular2/src/core/annotations_impl/view.dart'),
+  const ClassDescriptor('View', 'package:angular2/src/core/metadata/view.dart'),
+  const ClassDescriptor('View', 'package:angular2/src/core/metadata.dart'),
 ];
 
 /// Checks if a given [Annotation] matches any of the given
diff --git a/modules/angular2/src/transform/common/directive_metadata_reader.dart b/modules/angular2/src/transform/common/directive_metadata_reader.dart
index d9e7170d94..3c36a50b65 100644
--- a/modules/angular2/src/transform/common/directive_metadata_reader.dart
+++ b/modules/angular2/src/transform/common/directive_metadata_reader.dart
@@ -4,10 +4,10 @@ import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:angular2/src/render/api.dart';
 
-/// Reads [DirectiveMetadata] from the `node`. `node` is expected to be an
+/// Reads [RenderDirectiveMetadata] from the `node`. `node` is expected to be an
 /// instance of [Annotation], [NodeList<Annotation>], ListLiteral, or
 /// [InstanceCreationExpression].
-DirectiveMetadata readDirectiveMetadata(dynamic node) {
+RenderDirectiveMetadata readDirectiveMetadata(dynamic node) {
   assert(node is Annotation ||
       node is NodeList ||
       node is InstanceCreationExpression ||
@@ -22,10 +22,10 @@ num _getDirectiveType(String annotationName, Element element) {
   // TODO(kegluneq): Detect subtypes & implementations of `Directive`s.
   switch (annotationName) {
     case 'Directive':
-      byNameMatch = DirectiveMetadata.DIRECTIVE_TYPE;
+      byNameMatch = RenderDirectiveMetadata.DIRECTIVE_TYPE;
       break;
     case 'Component':
-      byNameMatch = DirectiveMetadata.COMPONENT_TYPE;
+      byNameMatch = RenderDirectiveMetadata.COMPONENT_TYPE;
       break;
     default:
       return -1;
@@ -34,8 +34,8 @@ num _getDirectiveType(String annotationName, Element element) {
     var byResolvedAst = -1;
     var libName = element.library.name;
     // If we have resolved, ensure the library is correct.
-    if (libName == 'angular2.src.core.annotations.annotations' ||
-        libName == 'angular2.src.core.annotations_impl.annotations') {
+    if (libName == 'angular2.src.core.metadata.directives' ||
+        libName == 'angular2.src.core.metadata') {
       byResolvedAst = byNameMatch;
     }
     // TODO(kegluneq): @keertip, can we expose this as a warning?
@@ -45,7 +45,7 @@ num _getDirectiveType(String annotationName, Element element) {
 }
 
 /// Visitor responsible for processing the `annotations` property of a
-/// [RegisterType] object and pulling out [DirectiveMetadata].
+/// [RegisterType] object and pulling out [RenderDirectiveMetadata].
 class _DirectiveMetadataVisitor extends Object
     with RecursiveAstVisitor<Object> {
   bool get _hasMeta => _type != null;
@@ -87,7 +87,7 @@ class _DirectiveMetadataVisitor extends Object
     _events = [];
   }
 
-  DirectiveMetadata get meta => DirectiveMetadata.create(
+  RenderDirectiveMetadata get meta => RenderDirectiveMetadata.create(
       type: _type,
       selector: _selector,
       compileChildren: _compileChildren,
diff --git a/modules/angular2/src/transform/common/interface_matcher.dart b/modules/angular2/src/transform/common/interface_matcher.dart
index c366fe4add..68a12fcac6 100644
--- a/modules/angular2/src/transform/common/interface_matcher.dart
+++ b/modules/angular2/src/transform/common/interface_matcher.dart
@@ -11,32 +11,32 @@ export 'class_matcher_base.dart' show ClassDescriptor;
 /// covers all libraries which provide them.
 const _ON_CHANGE_INTERFACES = const [
   const ClassDescriptor('OnChange', 'package:angular2/angular2.dart'),
-  const ClassDescriptor('OnChange', 'package:angular2/annotations.dart'),
+  const ClassDescriptor('OnChange', 'package:angular2/metadata.dart'),
   const ClassDescriptor(
       'OnChange', 'package:angular2/src/core/compiler/interfaces.dart'),
 ];
 const _ON_DESTROY_INTERFACES = const [
   const ClassDescriptor('OnDestroy', 'package:angular2/angular2.dart'),
-  const ClassDescriptor('OnDestroy', 'package:angular2/annotations.dart'),
+  const ClassDescriptor('OnDestroy', 'package:angular2/metadata.dart'),
   const ClassDescriptor(
       'OnDestroy', 'package:angular2/src/core/compiler/interfaces.dart'),
 ];
 const _ON_CHECK_INTERFACES = const [
   const ClassDescriptor('OnCheck', 'package:angular2/angular2.dart'),
-  const ClassDescriptor('OnCheck', 'package:angular2/annotations.dart'),
+  const ClassDescriptor('OnCheck', 'package:angular2/metadata.dart'),
   const ClassDescriptor(
       'OnCheck', 'package:angular2/src/core/compiler/interfaces.dart'),
 ];
 const _ON_INIT_INTERFACES = const [
   const ClassDescriptor('OnInit', 'package:angular2/angular2.dart'),
-  const ClassDescriptor('OnInit', 'package:angular2/annotations.dart'),
+  const ClassDescriptor('OnInit', 'package:angular2/metadata.dart'),
   const ClassDescriptor(
       'OnInit', 'package:angular2/src/core/compiler/interfaces.dart'),
 ];
 const _ON_ALL_CHANGES_DONE_INTERFACES = const [
   const ClassDescriptor('OnAllChangesDone', 'package:angular2/angular2.dart'),
   const ClassDescriptor(
-      'OnAllChangesDone', 'package:angular2/annotations.dart'),
+      'OnAllChangesDone', 'package:angular2/metadata.dart'),
   const ClassDescriptor(
       'OnAllChangesDone', 'package:angular2/src/core/compiler/interfaces.dart')
 ];
diff --git a/modules/angular2/src/transform/common/ng_meta.dart b/modules/angular2/src/transform/common/ng_meta.dart
index eca4f97e50..a5978dd0df 100644
--- a/modules/angular2/src/transform/common/ng_meta.dart
+++ b/modules/angular2/src/transform/common/ng_meta.dart
@@ -20,7 +20,7 @@ import 'logging.dart';
 /// easier.
 class NgMeta {
   /// Directive metadata for each type annotated as a directive.
-  final Map<String, DirectiveMetadata> types;
+  final Map<String, RenderDirectiveMetadata> types;
 
   /// List of other types and names associated with a given name.
   final Map<String, List<String>> aliases;
@@ -66,7 +66,7 @@ class NgMeta {
   }
 
   /// Returns the metadata for every type associated with the given [alias].
-  List<DirectiveMetadata> flatten(String alias) {
+  List<RenderDirectiveMetadata> flatten(String alias) {
     var result = [];
     var seen = new Set();
     helper(name) {
diff --git a/modules/angular2/src/transform/common/registered_type.dart b/modules/angular2/src/transform/common/registered_type.dart
index b1834d7c41..0cdc5e67bf 100644
--- a/modules/angular2/src/transform/common/registered_type.dart
+++ b/modules/angular2/src/transform/common/registered_type.dart
@@ -23,7 +23,7 @@ class RegisteredType {
   /// The annotations registered.
   final Expression annotations;
 
-  DirectiveMetadata _directiveMetadata = null;
+  RenderDirectiveMetadata _directiveMetadata = null;
 
   RegisteredType._(this.typeName, this.registerMethod, this.factoryFn,
       this.parameters, this.annotations);
@@ -37,7 +37,7 @@ class RegisteredType {
         visitor.factoryFn, visitor.parameters, visitor.annotations);
   }
 
-  DirectiveMetadata get directiveMetadata {
+  RenderDirectiveMetadata get directiveMetadata {
     if (_directiveMetadata == null) {
       try {
         _directiveMetadata = readDirectiveMetadata(annotations);
diff --git a/modules/angular2/src/transform/directive_processor/visitors.dart b/modules/angular2/src/transform/directive_processor/visitors.dart
index 810fb05f80..fea0a55a63 100644
--- a/modules/angular2/src/transform/directive_processor/visitors.dart
+++ b/modules/angular2/src/transform/directive_processor/visitors.dart
@@ -3,7 +3,7 @@ library angular2.transform.directive_processor.visitors;
 import 'dart:async';
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/src/generated/java_core.dart';
-import 'package:angular2/annotations.dart' show LifecycleEvent;
+import 'package:angular2/metadata.dart' show LifecycleEvent;
 import 'package:angular2/src/render/xhr.dart' show XHR;
 import 'package:angular2/src/transform/common/annotation_matcher.dart';
 import 'package:angular2/src/transform/common/async_string_writer.dart';
diff --git a/modules/angular2/src/transform/template_compiler/view_definition_creator.dart b/modules/angular2/src/transform/template_compiler/view_definition_creator.dart
index 4fe0dd936c..71ec630bc6 100644
--- a/modules/angular2/src/transform/template_compiler/view_definition_creator.dart
+++ b/modules/angular2/src/transform/template_compiler/view_definition_creator.dart
@@ -27,7 +27,7 @@ class ViewDefinitionResults {
 }
 
 class ViewDefinitionEntry {
-  final DirectiveMetadata hostMetadata;
+  final RenderDirectiveMetadata hostMetadata;
   final ViewDefinition viewDef;
 
   ViewDefinitionEntry._(this.hostMetadata, this.viewDef);
@@ -113,7 +113,7 @@ class _ViewDefinitionCreator {
 
   /// Reads the `.ng_meta.json` files associated with all of `entryPoint`'s
   /// imports and creates a map `Type` name, prefixed if appropriate to the
-  /// associated [DirectiveMetadata].
+  /// associated [RenderDirectiveMetadata].
   ///
   /// For example, if in `entryPoint` we have:
   ///
@@ -129,13 +129,13 @@ class _ViewDefinitionCreator {
   /// ```
   ///
   /// This method will look for `component.ng_meta.json`to contain the
-  /// serialized [DirectiveMetadata] for `MyComponent` and any other
+  /// serialized [RenderDirectiveMetadata] for `MyComponent` and any other
   /// `Directive`s declared in `component.dart`. We use this information to
   /// build a map:
   ///
   /// ```
   /// {
-  ///   "prefix.MyComponent": [DirectiveMetadata for MyComponent],
+  ///   "prefix.MyComponent": [RenderDirectiveMetadata for MyComponent],
   ///   ...<any other entries>...
   /// }
   /// ```
@@ -184,7 +184,7 @@ class _TemplateExtractVisitor extends Object with RecursiveAstVisitor<Object> {
   @override
   Object visitInstanceCreationExpression(InstanceCreationExpression node) {
     if (_isViewAnnotation(node)) {
-      viewDef = new ViewDefinition(directives: <DirectiveMetadata>[]);
+      viewDef = new ViewDefinition(directives: <RenderDirectiveMetadata>[]);
       node.visitChildren(this);
     }
     return null;
diff --git a/modules/angular2/src/util/decorators.dart b/modules/angular2/src/util/decorators.dart
index e26022dc05..f7d274607e 100644
--- a/modules/angular2/src/util/decorators.dart
+++ b/modules/angular2/src/util/decorators.dart
@@ -1 +1 @@
-library util_decorators;
+library angular2.core.util.decorators;
diff --git a/modules/angular2/src/util/decorators.ts b/modules/angular2/src/util/decorators.ts
index 582c9e96e9..4be326eee8 100644
--- a/modules/angular2/src/util/decorators.ts
+++ b/modules/angular2/src/util/decorators.ts
@@ -53,7 +53,7 @@ export interface TypeDecorator {
   // ParameterDecorator is declared in lib.d.ts as a `declare type`
   // so we cannot declare this interface as a subtype.
   // see https://github.com/angular/angular/issues/3379#issuecomment-126169417
-  (target: Object, propertyKey: string | symbol, parameterIndex: number): void;
+  (target: Object, propertyKey?: string | symbol, parameterIndex?: number): void;
 
   /**
    * Storage for the accumulated annotations so far used by the DSL syntax.
diff --git a/modules/angular2/src/web-workers/shared/serializer.ts b/modules/angular2/src/web-workers/shared/serializer.ts
index 0c472d4195..2ed922ed83 100644
--- a/modules/angular2/src/web-workers/shared/serializer.ts
+++ b/modules/angular2/src/web-workers/shared/serializer.ts
@@ -16,8 +16,8 @@ import {
 } from "angular2/src/facade/collection";
 import {
   ProtoViewDto,
-  DirectiveMetadata,
-  ElementBinder,
+  RenderDirectiveMetadata,
+  RenderElementBinder,
   DirectiveBinder,
   ElementPropertyBinding,
   EventBinding,
@@ -85,9 +85,9 @@ export class Serializer {
       return this._serializeDirectiveBinder(obj);
     } else if (type == ProtoViewDto) {
       return this._serializeProtoViewDto(obj);
-    } else if (type == ElementBinder) {
+    } else if (type == RenderElementBinder) {
       return this._serializeElementBinder(obj);
-    } else if (type == DirectiveMetadata) {
+    } else if (type == RenderDirectiveMetadata) {
       return this._serializeDirectiveMetadata(obj);
     } else if (type == ASTWithSource) {
       return this._serializeASTWithSource(obj);
@@ -129,9 +129,9 @@ export class Serializer {
       return this._deserializeDirectiveBinder(map);
     } else if (type == ProtoViewDto) {
       return this._deserializeProtoViewDto(map);
-    } else if (type == DirectiveMetadata) {
+    } else if (type == RenderDirectiveMetadata) {
       return this._deserializeDirectiveMetadata(map);
-    } else if (type == ElementBinder) {
+    } else if (type == RenderElementBinder) {
       return this._deserializeElementBinder(map);
     } else if (type == ASTWithSource) {
       return this._deserializeASTWithSource(map, data);
@@ -271,7 +271,7 @@ export class Serializer {
       'componentId': view.componentId,
       'templateAbsUrl': view.templateAbsUrl,
       'template': view.template,
-      'directives': this.serialize(view.directives, DirectiveMetadata),
+      'directives': this.serialize(view.directives, RenderDirectiveMetadata),
       'styleAbsUrls': view.styleAbsUrls,
       'styles': view.styles,
       'encapsulation': serializeEnum(view.encapsulation)
@@ -282,7 +282,7 @@ export class Serializer {
     return new ViewDefinition({
       componentId: obj['componentId'],
       templateAbsUrl: obj['templateAbsUrl'], template: obj['template'],
-      directives: this.deserialize(obj['directives'], DirectiveMetadata),
+      directives: this.deserialize(obj['directives'], RenderDirectiveMetadata),
       styleAbsUrls: obj['styleAbsUrls'],
       styles: obj['styles'],
       encapsulation:
@@ -308,7 +308,7 @@ export class Serializer {
     });
   }
 
-  private _serializeElementBinder(binder: ElementBinder): Object {
+  private _serializeElementBinder(binder: RenderElementBinder): Object {
     return {
       'index': binder.index,
       'parentIndex': binder.parentIndex,
@@ -322,8 +322,8 @@ export class Serializer {
     };
   }
 
-  private _deserializeElementBinder(obj: StringMap<string, any>): ElementBinder {
-    return new ElementBinder({
+  private _deserializeElementBinder(obj: StringMap<string, any>): RenderElementBinder {
+    return new RenderElementBinder({
       index: obj['index'],
       parentIndex: obj['parentIndex'],
       distanceToParent: obj['distanceToParent'],
@@ -339,7 +339,7 @@ export class Serializer {
   private _serializeProtoViewDto(view: ProtoViewDto): Object {
     return {
       'render': this._protoViewStore.serialize(view.render),
-      'elementBinders': this.serialize(view.elementBinders, ElementBinder),
+      'elementBinders': this.serialize(view.elementBinders, RenderElementBinder),
       'variableBindings': this.mapToObject(view.variableBindings),
       'type': serializeEnum(view.type),
       'textBindings': this.serialize(view.textBindings, ASTWithSource),
@@ -350,7 +350,7 @@ export class Serializer {
   private _deserializeProtoViewDto(obj: StringMap<string, any>): ProtoViewDto {
     return new ProtoViewDto({
       render: this._protoViewStore.deserialize(obj["render"]),
-      elementBinders: this.deserialize(obj['elementBinders'], ElementBinder),
+      elementBinders: this.deserialize(obj['elementBinders'], RenderElementBinder),
       variableBindings: this.objectToMap(obj['variableBindings']),
       textBindings: this.deserialize(obj['textBindings'], ASTWithSource, "interpolation"),
       type: deserializeEnum(obj['type'], this._enumRegistry.get(ViewType)),
@@ -358,7 +358,7 @@ export class Serializer {
     });
   }
 
-  private _serializeDirectiveMetadata(meta: DirectiveMetadata): Object {
+  private _serializeDirectiveMetadata(meta: RenderDirectiveMetadata): Object {
     var obj = {
       'id': meta.id,
       'selector': meta.selector,
@@ -381,8 +381,8 @@ export class Serializer {
     };
     return obj;
   }
-  private _deserializeDirectiveMetadata(obj: StringMap<string, any>): DirectiveMetadata {
-    return new DirectiveMetadata({
+  private _deserializeDirectiveMetadata(obj: StringMap<string, any>): RenderDirectiveMetadata {
+    return new RenderDirectiveMetadata({
       id: obj['id'],
       selector: obj['selector'],
       compileChildren: obj['compileChildren'],
diff --git a/modules/angular2/src/web-workers/ui/impl.ts b/modules/angular2/src/web-workers/ui/impl.ts
index 41eafa4ea2..0421d3c103 100644
--- a/modules/angular2/src/web-workers/ui/impl.ts
+++ b/modules/angular2/src/web-workers/ui/impl.ts
@@ -9,7 +9,7 @@ import {createInjector} from "./di_bindings";
 import {
   Renderer,
   RenderCompiler,
-  DirectiveMetadata,
+  RenderDirectiveMetadata,
   ProtoViewDto,
   ViewDefinition,
   RenderProtoViewRef,
@@ -94,7 +94,7 @@ export class WebWorkerMain {
     var promise: Promise<any>;
     switch (data.method) {
       case "compileHost":
-        var directiveMetadata = this._serializer.deserialize(data.args[0], DirectiveMetadata);
+        var directiveMetadata = this._serializer.deserialize(data.args[0], RenderDirectiveMetadata);
         promise = this._renderCompiler.compileHost(directiveMetadata);
         this._wrapWebWorkerPromise(data.id, promise, ProtoViewDto);
         break;
diff --git a/modules/angular2/src/web-workers/worker/renderer.ts b/modules/angular2/src/web-workers/worker/renderer.ts
index ee708c8645..5c8b3fc1c2 100644
--- a/modules/angular2/src/web-workers/worker/renderer.ts
+++ b/modules/angular2/src/web-workers/worker/renderer.ts
@@ -1,7 +1,7 @@
 import {
   Renderer,
   RenderCompiler,
-  DirectiveMetadata,
+  RenderDirectiveMetadata,
   ProtoViewDto,
   ViewDefinition,
   RenderProtoViewRef,
@@ -28,8 +28,8 @@ export class WebWorkerCompiler implements RenderCompiler {
   /**
    * Creats a ProtoViewDto that contains a single nested component with the given componentId.
    */
-  compileHost(directiveMetadata: DirectiveMetadata): Promise<ProtoViewDto> {
-    var fnArgs: List<FnArg> = [new FnArg(directiveMetadata, DirectiveMetadata)];
+  compileHost(directiveMetadata: RenderDirectiveMetadata): Promise<ProtoViewDto> {
+    var fnArgs: List<FnArg> = [new FnArg(directiveMetadata, RenderDirectiveMetadata)];
     var args: UiArguments = new UiArguments("compiler", "compileHost", fnArgs);
     return this._messageBroker.runOnUiThread(args, ProtoViewDto);
   }
diff --git a/modules/angular2/test/benchmark/transform/bind_generator/simple.dart b/modules/angular2/test/benchmark/transform/bind_generator/simple.dart
index 6e60956e28..6f3bed3371 100644
--- a/modules/angular2/test/benchmark/transform/bind_generator/simple.dart
+++ b/modules/angular2/test/benchmark/transform/bind_generator/simple.dart
@@ -25,7 +25,7 @@ const aContents = '''
 library bar.ng_deps.dart;
 
 import 'bar.dart';
-import 'package:angular2/src/core/annotations/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 
 bool _visited = false;
 void initReflector(reflector) {
diff --git a/modules/angular2/test/benchmark/transform/directive_linker/simple.dart b/modules/angular2/test/benchmark/transform/directive_linker/simple.dart
index 26084d34ee..679632d2a3 100644
--- a/modules/angular2/test/benchmark/transform/directive_linker/simple.dart
+++ b/modules/angular2/test/benchmark/transform/directive_linker/simple.dart
@@ -41,7 +41,7 @@ const bContents = '''
 library b.ng_deps.dart;
 
 import 'b.dart';
-import 'package:angular2/src/core/annotations/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 
 bool _visited = false;
 void initReflector(reflector) {
@@ -60,7 +60,7 @@ const cContents = '''
 library c.ng_deps.dart;
 
 import 'c.dart';
-import 'package:angular2/src/core/annotations/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 import 'b.dart' as dep;
 
 bool _visited = false;
diff --git a/modules/angular2/test/benchmark/transform/directive_processor/simple.dart b/modules/angular2/test/benchmark/transform/directive_processor/simple.dart
index 1dde61f4ed..08ce529995 100644
--- a/modules/angular2/test/benchmark/transform/directive_processor/simple.dart
+++ b/modules/angular2/test/benchmark/transform/directive_processor/simple.dart
@@ -24,7 +24,7 @@ Future runBenchmark() async {
 const aContents = '''
 library dinner.soup;
 
-import 'package:angular2/src/core/annotations/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 
 @Component(selector: '[soup]')
 class SoupComponent {
diff --git a/modules/angular2/test/core/application_spec.ts b/modules/angular2/test/core/application_spec.ts
index 62f127a188..f4b1417d8b 100644
--- a/modules/angular2/test/core/application_spec.ts
+++ b/modules/angular2/test/core/application_spec.ts
@@ -12,7 +12,7 @@ import {
 } from 'angular2/test_lib';
 import {isPresent, stringify} from 'angular2/src/facade/lang';
 import {bootstrap, ApplicationRef} from 'angular2/src/core/application';
-import {Component, Directive, View} from 'angular2/annotations';
+import {Component, Directive, View} from 'angular2/metadata';
 import {DOM} from 'angular2/src/dom/dom_adapter';
 import {PromiseWrapper} from 'angular2/src/facade/async';
 import {bind, Inject, Injector} from 'angular2/di';
diff --git a/modules/angular2/test/core/compiler/compiler_spec.ts b/modules/angular2/test/core/compiler/compiler_spec.ts
index 2bca4bd222..5fa08b038a 100644
--- a/modules/angular2/test/core/compiler/compiler_spec.ts
+++ b/modules/angular2/test/core/compiler/compiler_spec.ts
@@ -22,8 +22,7 @@ import {AppProtoView} from 'angular2/src/core/compiler/view';
 import {ElementBinder} from 'angular2/src/core/compiler/element_binder';
 import {DirectiveResolver} from 'angular2/src/core/compiler/directive_resolver';
 import {PipeResolver} from 'angular2/src/core/compiler/pipe_resolver';
-import {Attribute, View, Component, Directive, Pipe} from 'angular2/annotations';
-import * as viewAnn from 'angular2/src/core/annotations_impl/view';
+import {Attribute, ViewMetadata, Component, Directive, Pipe} from 'angular2/metadata';
 import {internalProtoView} from 'angular2/src/core/compiler/view_ref';
 import {DirectiveBinding} from 'angular2/src/core/compiler/element_injector';
 import {ViewResolver} from 'angular2/src/core/compiler/view_resolver';
@@ -35,7 +34,16 @@ import {ProtoViewFactory} from 'angular2/src/core/compiler/proto_view_factory';
 
 import {UrlResolver} from 'angular2/src/services/url_resolver';
 import {AppRootUrl} from 'angular2/src/services/app_root_url';
-import * as renderApi from 'angular2/src/render/api';
+import {
+  ProtoViewDto,
+  ViewType,
+  RenderProtoViewRef,
+  ViewDefinition,
+  RenderProtoViewMergeMapping,
+  RenderDirectiveMetadata,
+  DirectiveBinder,
+  RenderElementBinder
+} from 'angular2/src/render/api';
 // TODO(tbosch): Spys don't support named modules...
 import {RenderCompiler} from 'angular2/src/render/api';
 import {PipeBinding} from 'angular2/src/core/pipes/pipe_binding';
@@ -48,8 +56,7 @@ export function main() {
         cmpUrlMapper, rootProtoView;
     var renderCompileRequests: any[];
 
-    function createCompiler(renderCompileResults:
-                                List<renderApi.ProtoViewDto | Promise<renderApi.ProtoViewDto>>,
+    function createCompiler(renderCompileResults: List<ProtoViewDto | Promise<ProtoViewDto>>,
                             protoViewFactoryResults: List<AppProtoView>) {
       var urlResolver = new UrlResolver();
       renderCompileRequests = [];
@@ -73,12 +80,12 @@ export function main() {
       renderCompiler = new SpyRenderCompiler();
       renderCompiler.spy('compileHost')
           .andCallFake((componentId) => {
-            return PromiseWrapper.resolve(createRenderProtoView(
-                [createRenderComponentElementBinder(0)], renderApi.ViewType.HOST));
+            return PromiseWrapper.resolve(
+                createRenderProtoView([createRenderComponentElementBinder(0)], ViewType.HOST));
           });
       renderCompiler.spy('mergeProtoViewsRecursively')
-          .andCallFake((protoViewRefs: List<renderApi.RenderProtoViewRef | List<any>>) => {
-            return PromiseWrapper.resolve(new renderApi.RenderProtoViewMergeMapping(
+          .andCallFake((protoViewRefs: List<RenderProtoViewRef | List<any>>) => {
+            return PromiseWrapper.resolve(new RenderProtoViewMergeMapping(
                 new MergedRenderProtoViewRef(protoViewRefs), 1, [], 0, [], [], [null]));
           });
       // TODO spy on .compile and return RenderProtoViewRef, same for compileHost
@@ -87,7 +94,7 @@ export function main() {
 
     describe('serialize template', () => {
 
-      function captureTemplate(template: viewAnn.View): Promise<renderApi.ViewDefinition> {
+      function captureTemplate(template: ViewMetadata): Promise<ViewDefinition> {
         tplResolver.setView(MainComponent, template);
         var compiler =
             createCompiler([createRenderProtoView()], [rootProtoView, createProtoView()]);
@@ -98,8 +105,8 @@ export function main() {
             });
       }
 
-      function captureDirective(directive): Promise<renderApi.DirectiveMetadata> {
-        return captureTemplate(new viewAnn.View({template: '<div></div>', directives: [directive]}))
+      function captureDirective(directive): Promise<RenderDirectiveMetadata> {
+        return captureTemplate(new ViewMetadata({template: '<div></div>', directives: [directive]}))
             .then((renderTpl) => {
               expect(renderTpl.directives.length).toBe(1);
               return renderTpl.directives[0];
@@ -107,7 +114,7 @@ export function main() {
       }
 
       it('should fill the componentId', inject([AsyncTestCompleter], (async) => {
-           captureTemplate(new viewAnn.View({template: '<div></div>'}))
+           captureTemplate(new ViewMetadata({template: '<div></div>'}))
                .then((renderTpl) => {
                  expect(renderTpl.componentId).toEqual(stringify(MainComponent));
                  async.done();
@@ -115,7 +122,7 @@ export function main() {
          }));
 
       it('should fill inline template', inject([AsyncTestCompleter], (async) => {
-           captureTemplate(new viewAnn.View({template: '<div></div>'}))
+           captureTemplate(new ViewMetadata({template: '<div></div>'}))
                .then((renderTpl) => {
                  expect(renderTpl.template).toEqual('<div></div>');
                  async.done();
@@ -125,7 +132,7 @@ export function main() {
       it('should fill templateAbsUrl given inline templates',
          inject([AsyncTestCompleter], (async) => {
            cmpUrlMapper.setComponentUrl(MainComponent, '/cmp/main.js');
-           captureTemplate(new viewAnn.View({template: '<div></div>'}))
+           captureTemplate(new ViewMetadata({template: '<div></div>'}))
                .then((renderTpl) => {
                  expect(renderTpl.templateAbsUrl).toEqual('http://www.app.com/cmp/main.js');
                  async.done();
@@ -135,7 +142,7 @@ export function main() {
       it('should not fill templateAbsUrl given no inline template or template url',
          inject([AsyncTestCompleter], (async) => {
            cmpUrlMapper.setComponentUrl(MainComponent, '/cmp/main.js');
-           captureTemplate(new viewAnn.View({template: null, templateUrl: null}))
+           captureTemplate(new ViewMetadata({template: null, templateUrl: null}))
                .then((renderTpl) => {
                  expect(renderTpl.templateAbsUrl).toBe(null);
                  async.done();
@@ -144,7 +151,7 @@ export function main() {
 
       it('should fill templateAbsUrl given url template', inject([AsyncTestCompleter], (async) => {
            cmpUrlMapper.setComponentUrl(MainComponent, '/cmp/main.js');
-           captureTemplate(new viewAnn.View({templateUrl: 'tpl/main.html'}))
+           captureTemplate(new ViewMetadata({templateUrl: 'tpl/main.html'}))
                .then((renderTpl) => {
                  expect(renderTpl.templateAbsUrl).toEqual('http://www.app.com/cmp/tpl/main.html');
                  async.done();
@@ -153,7 +160,7 @@ export function main() {
 
       it('should fill styleAbsUrls given styleUrls', inject([AsyncTestCompleter], (async) => {
            cmpUrlMapper.setComponentUrl(MainComponent, '/cmp/main.js');
-           captureTemplate(new viewAnn.View({styleUrls: ['css/1.css', 'css/2.css']}))
+           captureTemplate(new ViewMetadata({styleUrls: ['css/1.css', 'css/2.css']}))
                .then((renderTpl) => {
                  expect(renderTpl.styleAbsUrls)
                      .toEqual(
@@ -181,7 +188,7 @@ export function main() {
       it('should fill directive.type for components', inject([AsyncTestCompleter], (async) => {
            captureDirective(MainComponent)
                .then((renderDir) => {
-                 expect(renderDir.type).toEqual(renderApi.DirectiveMetadata.COMPONENT_TYPE);
+                 expect(renderDir.type).toEqual(RenderDirectiveMetadata.COMPONENT_TYPE);
                  async.done();
                });
          }));
@@ -190,7 +197,7 @@ export function main() {
          inject([AsyncTestCompleter], (async) => {
            captureDirective(SomeDynamicComponentDirective)
                .then((renderDir) => {
-                 expect(renderDir.type).toEqual(renderApi.DirectiveMetadata.COMPONENT_TYPE);
+                 expect(renderDir.type).toEqual(RenderDirectiveMetadata.COMPONENT_TYPE);
                  async.done();
                });
          }));
@@ -199,7 +206,7 @@ export function main() {
          inject([AsyncTestCompleter], (async) => {
            captureDirective(SomeDirective)
                .then((renderDir) => {
-                 expect(renderDir.type).toEqual(renderApi.DirectiveMetadata.DIRECTIVE_TYPE);
+                 expect(renderDir.type).toEqual(RenderDirectiveMetadata.DIRECTIVE_TYPE);
                  async.done();
                });
          }));
@@ -269,7 +276,7 @@ export function main() {
     describe('call ProtoViewFactory', () => {
 
       it('should pass the ProtoViewDto', inject([AsyncTestCompleter], (async) => {
-           tplResolver.setView(MainComponent, new viewAnn.View({template: '<div></div>'}));
+           tplResolver.setView(MainComponent, new ViewMetadata({template: '<div></div>'}));
            var renderProtoView = createRenderProtoView();
            var expectedProtoView = createProtoView();
            var compiler = createCompiler([renderProtoView], [rootProtoView, expectedProtoView]);
@@ -282,7 +289,7 @@ export function main() {
          }));
 
       it('should pass the component binding', inject([AsyncTestCompleter], (async) => {
-           tplResolver.setView(MainComponent, new viewAnn.View({template: '<div></div>'}));
+           tplResolver.setView(MainComponent, new ViewMetadata({template: '<div></div>'}));
            var compiler =
                createCompiler([createRenderProtoView()], [rootProtoView, createProtoView()]);
            compiler.compileInHost(MainComponent)
@@ -296,7 +303,7 @@ export function main() {
       it('should pass the directive bindings', inject([AsyncTestCompleter], (async) => {
            tplResolver.setView(
                MainComponent,
-               new viewAnn.View({template: '<div></div>', directives: [SomeDirective]}));
+               new ViewMetadata({template: '<div></div>', directives: [SomeDirective]}));
            var compiler =
                createCompiler([createRenderProtoView()], [rootProtoView, createProtoView()]);
            compiler.compileInHost(MainComponent)
@@ -310,7 +317,7 @@ export function main() {
 
       it('should pass the pipe bindings', inject([AsyncTestCompleter], (async) => {
            tplResolver.setView(MainComponent,
-                               new viewAnn.View({template: '<div></div>', pipes: [SomePipe]}));
+                               new ViewMetadata({template: '<div></div>', pipes: [SomePipe]}));
            var compiler =
                createCompiler([createRenderProtoView()], [rootProtoView, createProtoView()]);
            compiler.compileInHost(MainComponent)
@@ -324,7 +331,7 @@ export function main() {
 
       it('should use the protoView of the ProtoViewFactory',
          inject([AsyncTestCompleter], (async) => {
-           tplResolver.setView(MainComponent, new viewAnn.View({template: '<div></div>'}));
+           tplResolver.setView(MainComponent, new ViewMetadata({template: '<div></div>'}));
            var compiler =
                createCompiler([createRenderProtoView()], [rootProtoView, createProtoView()]);
            compiler.compileInHost(MainComponent)
@@ -337,8 +344,8 @@ export function main() {
     });
 
     it('should load nested components', inject([AsyncTestCompleter], (async) => {
-         tplResolver.setView(MainComponent, new viewAnn.View({template: '<div></div>'}));
-         tplResolver.setView(NestedComponent, new viewAnn.View({template: '<div></div>'}));
+         tplResolver.setView(MainComponent, new ViewMetadata({template: '<div></div>'}));
+         tplResolver.setView(NestedComponent, new ViewMetadata({template: '<div></div>'}));
          var mainProtoView =
              createProtoView([createComponentElementBinder(directiveResolver, NestedComponent)]);
          var nestedProtoView = createProtoView();
@@ -361,17 +368,16 @@ export function main() {
        }));
 
     it('should load nested components in viewcontainers', inject([AsyncTestCompleter], (async) => {
-         tplResolver.setView(MainComponent, new viewAnn.View({template: '<div></div>'}));
-         tplResolver.setView(NestedComponent, new viewAnn.View({template: '<div></div>'}));
-         var viewportProtoView =
-             createProtoView([createComponentElementBinder(directiveResolver, NestedComponent)],
-                             renderApi.ViewType.EMBEDDED);
+         tplResolver.setView(MainComponent, new ViewMetadata({template: '<div></div>'}));
+         tplResolver.setView(NestedComponent, new ViewMetadata({template: '<div></div>'}));
+         var viewportProtoView = createProtoView(
+             [createComponentElementBinder(directiveResolver, NestedComponent)], ViewType.EMBEDDED);
          var mainProtoView = createProtoView([createViewportElementBinder(viewportProtoView)]);
          var nestedProtoView = createProtoView();
          var renderPvDtos = [
            createRenderProtoView([
-             createRenderViewportElementBinder(createRenderProtoView(
-                 [createRenderComponentElementBinder(0)], renderApi.ViewType.EMBEDDED))
+             createRenderViewportElementBinder(
+                 createRenderProtoView([createRenderComponentElementBinder(0)], ViewType.EMBEDDED))
            ]),
            createRenderProtoView()
          ];
@@ -391,7 +397,7 @@ export function main() {
        }));
 
     it('should cache compiled host components', inject([AsyncTestCompleter], (async) => {
-         tplResolver.setView(MainComponent, new viewAnn.View({template: '<div></div>'}));
+         tplResolver.setView(MainComponent, new ViewMetadata({template: '<div></div>'}));
          var mainPv = createProtoView();
          var compiler = createCompiler([createRenderProtoView([])], [rootProtoView, mainPv]);
          compiler.compileInHost(MainComponent)
@@ -429,9 +435,9 @@ export function main() {
 
 
     it('should cache compiled nested components', inject([AsyncTestCompleter], (async) => {
-         tplResolver.setView(MainComponent, new viewAnn.View({template: '<div></div>'}));
-         tplResolver.setView(MainComponent2, new viewAnn.View({template: '<div></div>'}));
-         tplResolver.setView(NestedComponent, new viewAnn.View({template: '<div></div>'}));
+         tplResolver.setView(MainComponent, new ViewMetadata({template: '<div></div>'}));
+         tplResolver.setView(MainComponent2, new ViewMetadata({template: '<div></div>'}));
+         tplResolver.setView(NestedComponent, new ViewMetadata({template: '<div></div>'}));
          var rootProtoView2 = createRootProtoView(directiveResolver, MainComponent2);
          var mainPv =
              createProtoView([createComponentElementBinder(directiveResolver, NestedComponent)]);
@@ -459,9 +465,8 @@ export function main() {
        }));
 
     it('should re-use components being compiled', inject([AsyncTestCompleter], (async) => {
-         tplResolver.setView(MainComponent, new viewAnn.View({template: '<div></div>'}));
-         var renderProtoViewCompleter: PromiseCompleter<renderApi.ProtoViewDto> =
-             PromiseWrapper.completer();
+         tplResolver.setView(MainComponent, new ViewMetadata({template: '<div></div>'}));
+         var renderProtoViewCompleter: PromiseCompleter<ProtoViewDto> = PromiseWrapper.completer();
          var expectedProtoView = createProtoView();
          var compiler = createCompiler([renderProtoViewCompleter.promise],
                                        [rootProtoView, rootProtoView, expectedProtoView]);
@@ -482,7 +487,7 @@ export function main() {
 
     it('should throw on unconditional recursive components',
        inject([AsyncTestCompleter], (async) => {
-         tplResolver.setView(MainComponent, new viewAnn.View({template: '<div></div>'}));
+         tplResolver.setView(MainComponent, new ViewMetadata({template: '<div></div>'}));
          var mainProtoView =
              createProtoView([createComponentElementBinder(directiveResolver, MainComponent)]);
          var compiler =
@@ -498,15 +503,14 @@ export function main() {
 
     it('should allow recursive components that are connected via an embedded ProtoView',
        inject([AsyncTestCompleter], (async) => {
-         tplResolver.setView(MainComponent, new viewAnn.View({template: '<div></div>'}));
-         var viewportProtoView =
-             createProtoView([createComponentElementBinder(directiveResolver, MainComponent)],
-                             renderApi.ViewType.EMBEDDED);
+         tplResolver.setView(MainComponent, new ViewMetadata({template: '<div></div>'}));
+         var viewportProtoView = createProtoView(
+             [createComponentElementBinder(directiveResolver, MainComponent)], ViewType.EMBEDDED);
          var mainProtoView = createProtoView([createViewportElementBinder(viewportProtoView)]);
          var renderPvDtos = [
            createRenderProtoView([
-             createRenderViewportElementBinder(createRenderProtoView(
-                 [createRenderComponentElementBinder(0)], renderApi.ViewType.EMBEDDED))
+             createRenderViewportElementBinder(
+                 createRenderProtoView([createRenderComponentElementBinder(0)], ViewType.EMBEDDED))
            ]),
            createRenderProtoView()
          ];
@@ -530,15 +534,15 @@ export function main() {
 
     it('should throw on recursive components that are connected via an embedded ProtoView with <ng-content>',
        inject([AsyncTestCompleter], (async) => {
-         tplResolver.setView(MainComponent, new viewAnn.View({template: '<div></div>'}));
+         tplResolver.setView(MainComponent, new ViewMetadata({template: '<div></div>'}));
          var viewportProtoView =
              createProtoView([createComponentElementBinder(directiveResolver, MainComponent)],
-                             renderApi.ViewType.EMBEDDED, true);
+                             ViewType.EMBEDDED, true);
          var mainProtoView = createProtoView([createViewportElementBinder(viewportProtoView)]);
          var renderPvDtos = [
            createRenderProtoView([
-             createRenderViewportElementBinder(createRenderProtoView(
-                 [createRenderComponentElementBinder(0)], renderApi.ViewType.EMBEDDED))
+             createRenderViewportElementBinder(
+                 createRenderProtoView([createRenderComponentElementBinder(0)], ViewType.EMBEDDED))
            ]),
            createRenderProtoView()
          ];
@@ -554,10 +558,9 @@ export function main() {
 
 
     it('should create host proto views', inject([AsyncTestCompleter], (async) => {
-         tplResolver.setView(MainComponent, new viewAnn.View({template: '<div></div>'}));
-         var rootProtoView =
-             createProtoView([createComponentElementBinder(directiveResolver, MainComponent)],
-                             renderApi.ViewType.HOST);
+         tplResolver.setView(MainComponent, new ViewMetadata({template: '<div></div>'}));
+         var rootProtoView = createProtoView(
+             [createComponentElementBinder(directiveResolver, MainComponent)], ViewType.HOST);
          var mainProtoView = createProtoView();
          var compiler = createCompiler([createRenderProtoView()], [rootProtoView, mainProtoView]);
          compiler.compileInHost(MainComponent)
@@ -582,13 +585,13 @@ function createDirectiveBinding(directiveResolver, type): DirectiveBinding {
   return DirectiveBinding.createFromType(type, annotation);
 }
 
-function createProtoView(elementBinders = null, type: renderApi.ViewType = null,
+function createProtoView(elementBinders = null, type: ViewType = null,
                          isEmbeddedFragment: boolean = false): AppProtoView {
   if (isBlank(type)) {
-    type = renderApi.ViewType.COMPONENT;
+    type = ViewType.COMPONENT;
   }
-  var pv = new AppProtoView(type, isEmbeddedFragment, new renderApi.RenderProtoViewRef(), null,
-                            null, new Map(), null, null);
+  var pv = new AppProtoView(type, isEmbeddedFragment, new RenderProtoViewRef(), null, null,
+                            new Map(), null, null);
   if (isBlank(elementBinders)) {
     elementBinders = [];
   }
@@ -607,30 +610,28 @@ function createViewportElementBinder(nestedProtoView): ElementBinder {
   return elBinder;
 }
 
-function createRenderProtoView(elementBinders = null, type: renderApi.ViewType = null):
-    renderApi.ProtoViewDto {
+function createRenderProtoView(elementBinders = null, type: ViewType = null): ProtoViewDto {
   if (isBlank(type)) {
-    type = renderApi.ViewType.COMPONENT;
+    type = ViewType.COMPONENT;
   }
   if (isBlank(elementBinders)) {
     elementBinders = [];
   }
-  return new renderApi.ProtoViewDto(
-      {elementBinders: elementBinders, type: type, render: new renderApi.RenderProtoViewRef()});
+  return new ProtoViewDto(
+      {elementBinders: elementBinders, type: type, render: new RenderProtoViewRef()});
 }
 
-function createRenderComponentElementBinder(directiveIndex): renderApi.ElementBinder {
-  return new renderApi.ElementBinder(
-      {directives: [new renderApi.DirectiveBinder({directiveIndex: directiveIndex})]});
+function createRenderComponentElementBinder(directiveIndex): RenderElementBinder {
+  return new RenderElementBinder(
+      {directives: [new DirectiveBinder({directiveIndex: directiveIndex})]});
 }
 
-function createRenderViewportElementBinder(nestedProtoView): renderApi.ElementBinder {
-  return new renderApi.ElementBinder({nestedProtoView: nestedProtoView});
+function createRenderViewportElementBinder(nestedProtoView): RenderElementBinder {
+  return new RenderElementBinder({nestedProtoView: nestedProtoView});
 }
 
 function createRootProtoView(directiveResolver, type): AppProtoView {
-  return createProtoView([createComponentElementBinder(directiveResolver, type)],
-                         renderApi.ViewType.HOST);
+  return createProtoView([createComponentElementBinder(directiveResolver, type)], ViewType.HOST);
 }
 
 @Component({selector: 'main-comp'})
@@ -699,16 +700,16 @@ class SpyDirectiveResolver extends SpyObject {
 }
 
 class FakeViewResolver extends ViewResolver {
-  _cmpViews: Map<Type, viewAnn.View> = new Map();
+  _cmpViews: Map<Type, ViewMetadata> = new Map();
 
   constructor() { super(); }
 
-  resolve(component: Type): viewAnn.View {
+  resolve(component: Type): ViewMetadata {
     // returns null for dynamic components
     return this._cmpViews.has(component) ? this._cmpViews.get(component) : null;
   }
 
-  setView(component: Type, view: viewAnn.View): void { this._cmpViews.set(component, view); }
+  setView(component: Type, view: ViewMetadata): void { this._cmpViews.set(component, view); }
 }
 
 class FakeProtoViewFactory extends ProtoViewFactory {
@@ -719,15 +720,15 @@ class FakeProtoViewFactory extends ProtoViewFactory {
     this.requests = [];
   }
 
-  createAppProtoViews(componentBinding: DirectiveBinding, renderProtoView: renderApi.ProtoViewDto,
+  createAppProtoViews(componentBinding: DirectiveBinding, renderProtoView: ProtoViewDto,
                       directives: List<DirectiveBinding>, pipes: PipeBinding[]): AppProtoView[] {
     this.requests.push([componentBinding, renderProtoView, directives, pipes]);
     return collectEmbeddedPvs(ListWrapper.removeAt(this.results, 0));
   }
 }
 
-class MergedRenderProtoViewRef extends renderApi.RenderProtoViewRef {
-  constructor(public originals: renderApi.RenderProtoViewRef[]) { super(); }
+class MergedRenderProtoViewRef extends RenderProtoViewRef {
+  constructor(public originals: RenderProtoViewRef[]) { super(); }
 }
 
 function originalRenderProtoViewRefs(appProtoView: AppProtoView) {
diff --git a/modules/angular2/test/core/compiler/directive_lifecycle_spec.ts b/modules/angular2/test/core/compiler/directive_lifecycle_spec.ts
index 55830087dd..5cad210af5 100644
--- a/modules/angular2/test/core/compiler/directive_lifecycle_spec.ts
+++ b/modules/angular2/test/core/compiler/directive_lifecycle_spec.ts
@@ -13,7 +13,7 @@ import {
   proxy
 } from 'angular2/test_lib';
 
-import {Directive, LifecycleEvent} from 'angular2/src/core/annotations_impl/annotations';
+import {DirectiveMetadata, LifecycleEvent} from '../../../src/core/metadata';
 import {DirectiveBinding} from 'angular2/src/core/compiler/element_injector';
 
 export function main() {
@@ -25,87 +25,99 @@ export function main() {
 
       describe("onChange", () => {
         it("should be true when the directive has the onChange method", () => {
-          expect(metadata(DirectiveWithOnChangeMethod, new Directive({})).callOnChange).toBe(true);
+          expect(metadata(DirectiveWithOnChangeMethod, new DirectiveMetadata({})).callOnChange)
+              .toBe(true);
         });
 
         it("should be true when the lifecycle includes onChange", () => {
-          expect(metadata(DirectiveNoHooks, new Directive({lifecycle: [LifecycleEvent.onChange]}))
+          expect(metadata(DirectiveNoHooks,
+                          new DirectiveMetadata({lifecycle: [LifecycleEvent.onChange]}))
                      .callOnChange)
               .toBe(true);
         });
 
-        it("should be false otherwise",
-           () => { expect(metadata(DirectiveNoHooks, new Directive()).callOnChange).toBe(false); });
+        it("should be false otherwise", () => {
+          expect(metadata(DirectiveNoHooks, new DirectiveMetadata()).callOnChange).toBe(false);
+        });
 
         it("should be false when empty lifecycle", () => {
-          expect(metadata(DirectiveWithOnChangeMethod, new Directive({lifecycle: []})).callOnChange)
+          expect(metadata(DirectiveWithOnChangeMethod, new DirectiveMetadata({lifecycle: []}))
+                     .callOnChange)
               .toBe(false);
         });
       });
 
       describe("onDestroy", () => {
         it("should be true when the directive has the onDestroy method", () => {
-          expect(metadata(DirectiveWithOnDestroyMethod, new Directive({})).callOnDestroy)
+          expect(metadata(DirectiveWithOnDestroyMethod, new DirectiveMetadata({})).callOnDestroy)
               .toBe(true);
         });
 
         it("should be true when the lifecycle includes onDestroy", () => {
-          expect(metadata(DirectiveNoHooks, new Directive({lifecycle: [LifecycleEvent.onDestroy]}))
+          expect(metadata(DirectiveNoHooks,
+                          new DirectiveMetadata({lifecycle: [LifecycleEvent.onDestroy]}))
                      .callOnDestroy)
               .toBe(true);
         });
 
         it("should be false otherwise", () => {
-          expect(metadata(DirectiveNoHooks, new Directive()).callOnDestroy).toBe(false);
+          expect(metadata(DirectiveNoHooks, new DirectiveMetadata()).callOnDestroy).toBe(false);
         });
       });
 
       describe("onInit", () => {
         it("should be true when the directive has the onInit method", () => {
-          expect(metadata(DirectiveWithOnInitMethod, new Directive({})).callOnInit).toBe(true);
+          expect(metadata(DirectiveWithOnInitMethod, new DirectiveMetadata({})).callOnInit)
+              .toBe(true);
         });
 
         it("should be true when the lifecycle includes onDestroy", () => {
-          expect(metadata(DirectiveNoHooks, new Directive({lifecycle: [LifecycleEvent.onInit]}))
+          expect(metadata(DirectiveNoHooks,
+                          new DirectiveMetadata({lifecycle: [LifecycleEvent.onInit]}))
                      .callOnInit)
               .toBe(true);
         });
 
-        it("should be false otherwise",
-           () => { expect(metadata(DirectiveNoHooks, new Directive()).callOnInit).toBe(false); });
+        it("should be false otherwise", () => {
+          expect(metadata(DirectiveNoHooks, new DirectiveMetadata()).callOnInit).toBe(false);
+        });
       });
 
       describe("onCheck", () => {
         it("should be true when the directive has the onCheck method", () => {
-          expect(metadata(DirectiveWithOnCheckMethod, new Directive({})).callOnCheck).toBe(true);
+          expect(metadata(DirectiveWithOnCheckMethod, new DirectiveMetadata({})).callOnCheck)
+              .toBe(true);
         });
 
         it("should be true when the lifecycle includes onCheck", () => {
-          expect(metadata(DirectiveNoHooks, new Directive({lifecycle: [LifecycleEvent.onCheck]}))
+          expect(metadata(DirectiveNoHooks,
+                          new DirectiveMetadata({lifecycle: [LifecycleEvent.onCheck]}))
                      .callOnCheck)
               .toBe(true);
         });
 
-        it("should be false otherwise",
-           () => { expect(metadata(DirectiveNoHooks, new Directive()).callOnCheck).toBe(false); });
+        it("should be false otherwise", () => {
+          expect(metadata(DirectiveNoHooks, new DirectiveMetadata()).callOnCheck).toBe(false);
+        });
       });
 
       describe("onAllChangesDone", () => {
         it("should be true when the directive has the onAllChangesDone method", () => {
-          expect(
-              metadata(DirectiveWithOnAllChangesDoneMethod, new Directive({})).callOnAllChangesDone)
+          expect(metadata(DirectiveWithOnAllChangesDoneMethod, new DirectiveMetadata({}))
+                     .callOnAllChangesDone)
               .toBe(true);
         });
 
         it("should be true when the lifecycle includes onAllChangesDone", () => {
           expect(metadata(DirectiveNoHooks,
-                          new Directive({lifecycle: [LifecycleEvent.onAllChangesDone]}))
+                          new DirectiveMetadata({lifecycle: [LifecycleEvent.onAllChangesDone]}))
                      .callOnAllChangesDone)
               .toBe(true);
         });
 
         it("should be false otherwise", () => {
-          expect(metadata(DirectiveNoHooks, new Directive()).callOnAllChangesDone).toBe(false);
+          expect(metadata(DirectiveNoHooks, new DirectiveMetadata()).callOnAllChangesDone)
+              .toBe(false);
         });
       });
     });
diff --git a/modules/angular2/test/core/compiler/directive_metadata_reader_spec.ts b/modules/angular2/test/core/compiler/directive_metadata_reader_spec.ts
index 7be276f527..f3fab6de37 100644
--- a/modules/angular2/test/core/compiler/directive_metadata_reader_spec.ts
+++ b/modules/angular2/test/core/compiler/directive_metadata_reader_spec.ts
@@ -1,7 +1,6 @@
 import {ddescribe, describe, it, iit, expect, beforeEach} from 'angular2/test_lib';
 import {DirectiveResolver} from 'angular2/src/core/compiler/directive_resolver';
-import {Directive} from 'angular2/annotations';
-import * as dirAnn from 'angular2/src/core/annotations_impl/annotations';
+import {DirectiveMetadata, Directive} from 'angular2/metadata';
 
 @Directive({selector: 'someDirective'})
 class SomeDirective {
@@ -21,7 +20,7 @@ export function main() {
 
     it('should read out the Directive annotation', () => {
       var directiveMetadata = reader.resolve(SomeDirective);
-      expect(directiveMetadata).toEqual(new dirAnn.Directive({selector: 'someDirective'}));
+      expect(directiveMetadata).toEqual(new Directive({selector: 'someDirective'}));
     });
 
     it('should throw if not matching annotation is found', () => {
@@ -31,7 +30,7 @@ export function main() {
 
     it('should not read parent class Directive annotations', function() {
       var directiveMetadata = reader.resolve(SomeChildDirective);
-      expect(directiveMetadata).toEqual(new dirAnn.Directive({selector: 'someChildDirective'}));
+      expect(directiveMetadata).toEqual(new Directive({selector: 'someChildDirective'}));
     });
   });
 }
diff --git a/modules/angular2/test/core/compiler/dynamic_component_loader_spec.ts b/modules/angular2/test/core/compiler/dynamic_component_loader_spec.ts
index 838b8b551a..f37129f82d 100644
--- a/modules/angular2/test/core/compiler/dynamic_component_loader_spec.ts
+++ b/modules/angular2/test/core/compiler/dynamic_component_loader_spec.ts
@@ -20,8 +20,7 @@ import {
 
 import {Injector} from 'angular2/di';
 import {NgIf} from 'angular2/directives';
-import {Component, View, LifecycleEvent} from 'angular2/annotations';
-import * as viewAnn from 'angular2/src/core/annotations_impl/view';
+import {Component, View, ViewMetadata, LifecycleEvent} from 'angular2/metadata';
 import {DynamicComponentLoader} from 'angular2/src/core/compiler/dynamic_component_loader';
 import {ElementRef} from 'angular2/src/core/compiler/element_ref';
 import {DOCUMENT} from 'angular2/src/render/render';
@@ -35,7 +34,7 @@ export function main() {
                 (loader, tcb: TestComponentBuilder, async) => {
                   tcb.overrideView(
                          MyComp,
-                         new viewAnn.View(
+                         new ViewMetadata(
                              {template: '<location #loc></location>', directives: [Location]}))
                       .createAsync(MyComp)
                       .then((tc) => {
@@ -53,7 +52,7 @@ export function main() {
                 (loader, tcb: TestComponentBuilder, async) => {
                   tcb.overrideView(
                          MyComp,
-                         new viewAnn.View(
+                         new ViewMetadata(
                              {template: '<location #loc></location>', directives: [Location]}))
                       .createAsync(MyComp)
                       .then((tc) => {
@@ -70,13 +69,13 @@ export function main() {
       it('should allow to dispose even if the location has been removed',
          inject([DynamicComponentLoader, TestComponentBuilder, AsyncTestCompleter],
                 (loader, tcb: TestComponentBuilder, async) => {
-                  tcb.overrideView(MyComp, new viewAnn.View({
-                       template: '<child-cmp *ng-if="ctxBoolProp"></child-cmp>',
-                       directives: [NgIf, ChildComp]
-                     }))
+                  tcb.overrideView(MyComp, new ViewMetadata({
+                                     template: '<child-cmp *ng-if="ctxBoolProp"></child-cmp>',
+                                     directives: [NgIf, ChildComp]
+                                   }))
                       .overrideView(
                           ChildComp,
-                          new viewAnn.View(
+                          new ViewMetadata(
                               {template: '<location #loc></location>', directives: [Location]}))
                       .createAsync(MyComp)
                       .then((tc) => {
@@ -103,7 +102,7 @@ export function main() {
              [DynamicComponentLoader, TestComponentBuilder, AsyncTestCompleter],
              (loader, tcb: TestComponentBuilder, async) => {
                tcb.overrideView(
-                      MyComp, new viewAnn.View(
+                      MyComp, new ViewMetadata(
                                   {template: '<location #loc></location>', directives: [Location]}))
                    .createAsync(MyComp)
                    .then((tc) => {
@@ -125,7 +124,7 @@ export function main() {
                 (loader, tcb: TestComponentBuilder, async) => {
                   tcb.overrideView(
                          MyComp,
-                         new viewAnn.View(
+                         new ViewMetadata(
                              {template: '<location #loc></location>', directives: [Location]}))
                       .createAsync(MyComp)
                       .then((tc) => {
@@ -140,10 +139,11 @@ export function main() {
     describe("loading next to a location", () => {
       it('should work', inject([DynamicComponentLoader, TestComponentBuilder, AsyncTestCompleter],
                                (loader, tcb: TestComponentBuilder, async) => {
-                                 tcb.overrideView(MyComp, new viewAnn.View({
-                                      template: '<div><location #loc></location></div>',
-                                      directives: [Location]
-                                    }))
+                                 tcb.overrideView(
+                                        MyComp, new ViewMetadata({
+                                          template: '<div><location #loc></location></div>',
+                                          directives: [Location]
+                                        }))
                                      .createAsync(MyComp)
                                      .then((tc) => {
                                        loader.loadNextToLocation(DynamicallyLoaded, tc.elementRef)
@@ -160,10 +160,10 @@ export function main() {
       it('should return a disposable component ref',
          inject([DynamicComponentLoader, TestComponentBuilder, AsyncTestCompleter],
                 (loader, tcb: TestComponentBuilder, async) => {
-                  tcb.overrideView(MyComp, new viewAnn.View({
-                       template: '<div><location #loc></location></div>',
-                       directives: [Location]
-                     }))
+                  tcb.overrideView(MyComp, new ViewMetadata({
+                                     template: '<div><location #loc></location></div>',
+                                     directives: [Location]
+                                   }))
                       .
 
                       createAsync(MyComp)
@@ -193,10 +193,10 @@ export function main() {
       it('should update host properties',
          inject([DynamicComponentLoader, TestComponentBuilder, AsyncTestCompleter],
                 (loader, tcb: TestComponentBuilder, async) => {
-                  tcb.overrideView(MyComp, new viewAnn.View({
-                       template: '<div><location #loc></location></div>',
-                       directives: [Location]
-                     }))
+                  tcb.overrideView(MyComp, new ViewMetadata({
+                                     template: '<div><location #loc></location></div>',
+                                     directives: [Location]
+                                   }))
 
                       .createAsync(MyComp)
                       .then((tc) => {
diff --git a/modules/angular2/test/core/compiler/element_injector_spec.ts b/modules/angular2/test/core/compiler/element_injector_spec.ts
index b5e425f3d4..d09ad722cb 100644
--- a/modules/angular2/test/core/compiler/element_injector_spec.ts
+++ b/modules/angular2/test/core/compiler/element_injector_spec.ts
@@ -32,14 +32,13 @@ import {
   DirectiveBinding,
   TreeNode
 } from 'angular2/src/core/compiler/element_injector';
-import * as dirAnn from 'angular2/src/core/annotations_impl/annotations';
 import {
   Attribute,
   Query,
-  Component,
-  Directive,
+  ComponentMetadata,
+  DirectiveMetadata,
   LifecycleEvent
-} from 'angular2/annotations';
+} from 'angular2/metadata';
 import {bind, Injector, Binding, Optional, Inject, Injectable, Self, SkipSelf, InjectMetadata, Host, HostMetadata, SkipSelfMetadata} from 'angular2/di';
 import {AppProtoView, AppView} from 'angular2/src/core/compiler/view';
 import {ViewContainerRef} from 'angular2/src/core/compiler/view_container_ref';
@@ -420,7 +419,7 @@ export function main() {
     describe('event emitters', () => {
       it('should return a list of event accessors', () => {
         var binding = DirectiveBinding.createFromType(HasEventEmitter,
-                                                      new dirAnn.Directive({events: ['emitter']}));
+                                                      new DirectiveMetadata({events: ['emitter']}));
 
         var inj = createPei(null, 0, [binding]);
         expect(inj.eventEmitterAccessors.length).toEqual(1);
@@ -432,7 +431,7 @@ export function main() {
 
       it('should allow a different event vs field name', () => {
         var binding = DirectiveBinding.createFromType(HasEventEmitter,
-            new dirAnn.Directive({events: ['emitter: publicEmitter']}));
+            new DirectiveMetadata({events: ['emitter: publicEmitter']}));
 
         var inj = createPei(null, 0, [binding]);
         expect(inj.eventEmitterAccessors.length).toEqual(1);
@@ -444,7 +443,7 @@ export function main() {
 
       it('should return a list of hostAction accessors', () => {
         var binding = DirectiveBinding.createFromType(
-            HasEventEmitter, new dirAnn.Directive({host: {'@hostActionName': 'onAction'}}));
+            HasEventEmitter, new DirectiveMetadata({host: {'@hostActionName': 'onAction'}}));
 
         var inj = createPei(null, 0, [binding]);
         expect(inj.hostActionAccessors.length).toEqual(1);
@@ -460,8 +459,8 @@ export function main() {
         var pei = createPei(null, 0, [
           DirectiveBinding.createFromType(
               SimpleDirective,
-              new dirAnn.Component({bindings: [bind('injectable1').toValue('injectable1')]})),
-          DirectiveBinding.createFromType(SomeOtherDirective, new dirAnn.Component({
+              new ComponentMetadata({bindings: [bind('injectable1').toValue('injectable1')]})),
+          DirectiveBinding.createFromType(SomeOtherDirective, new ComponentMetadata({
             bindings: [bind('injectable2').toValue('injectable2')]
           }))
         ]);
@@ -474,7 +473,7 @@ export function main() {
 
       it("should collect view bindings from the component", () => {
         var pei = createPei(null, 0,
-                            [DirectiveBinding.createFromType(SimpleDirective, new dirAnn.Component({
+                            [DirectiveBinding.createFromType(SimpleDirective, new ComponentMetadata({
                               viewBindings: [bind('injectable1').toValue('injectable1')]
                             }))],
                             0, true);
@@ -487,7 +486,7 @@ export function main() {
         var pei = createPei(null, 0, [
           DirectiveBinding.createFromType(
               SimpleDirective,
-              new dirAnn.Component({
+              new ComponentMetadata({
                 viewBindings: [[[bind('view').toValue('view')]]],
                 bindings: [[[bind('host').toValue('host')]]]
               }))
@@ -595,11 +594,11 @@ export function main() {
              function() {
                var childInj = parentChildInjectors(
                    ListWrapper.concat(
-                       [DirectiveBinding.createFromType(SimpleDirective, new dirAnn.Component({
+                       [DirectiveBinding.createFromType(SimpleDirective, new ComponentMetadata({
                          bindings: [bind('injectable1').toValue('injectable1')]
                        }))],
                        extraBindings),
-                   [DirectiveBinding.createFromType(SimpleDirective, new dirAnn.Component({
+                   [DirectiveBinding.createFromType(SimpleDirective, new ComponentMetadata({
                      bindings: [
                        bind('injectable1')
                            .toValue('new-injectable1'),
@@ -624,7 +623,7 @@ export function main() {
 
             var inj = injector(ListWrapper.concat(
                 [DirectiveBinding.createFromType(SimpleDirective,
-                  new dirAnn.Directive({bindings: bindings}))],
+                  new DirectiveMetadata({bindings: bindings}))],
                 extraBindings));
 
             expect(inj.get('injectable2')).toEqual('injectable1-injectable2');
@@ -642,7 +641,7 @@ export function main() {
 
 
             var inj = injector(ListWrapper.concat(
-                [DirectiveBinding.createFromType(SimpleDirective, new dirAnn.Component({
+                [DirectiveBinding.createFromType(SimpleDirective, new ComponentMetadata({
                   viewBindings: viewBindings}))], extraBindings),
                 null, true);
             expect(inj.get('injectable2')).toEqual('injectable1-injectable2');
@@ -650,7 +649,7 @@ export function main() {
 
           it("should instantiate components that depend on viewBindings bindings", () => {
             var inj = injector(
-                ListWrapper.concat([DirectiveBinding.createFromType(NeedsService, new dirAnn.Component({
+                ListWrapper.concat([DirectiveBinding.createFromType(NeedsService, new ComponentMetadata({
                                      viewBindings: [bind('service').toValue('service')]
                                    }))],
                                    extraBindings),
@@ -661,7 +660,7 @@ export function main() {
           it("should instantiate bindings lazily", () => {
             var created = false;
             var inj = injector(
-                ListWrapper.concat([DirectiveBinding.createFromType(SimpleDirective, new dirAnn.Component({
+                ListWrapper.concat([DirectiveBinding.createFromType(SimpleDirective, new ComponentMetadata({
                                      bindings: [bind('service').toFactory(() => created = true)]
                                    }))],
                                    extraBindings),
@@ -677,7 +676,7 @@ export function main() {
           it("should instantiate view bindings lazily", () => {
             var created = false;
             var inj = injector(
-                ListWrapper.concat([DirectiveBinding.createFromType(SimpleDirective, new dirAnn.Component({
+                ListWrapper.concat([DirectiveBinding.createFromType(SimpleDirective, new ComponentMetadata({
                                      viewBindings: [bind('service').toFactory(() => created = true)]
                                    }))],
                                    extraBindings),
@@ -692,7 +691,7 @@ export function main() {
 
           it("should not instantiate other directives that depend on viewBindings bindings",
              () => {
-               var directiveAnnotation = new dirAnn.Component({
+               var directiveAnnotation = new ComponentMetadata({
                  viewBindings: ListWrapper.concat([bind("service").toValue("service")], extraBindings)
                });
                var componentDirective =
@@ -704,7 +703,7 @@ export function main() {
 
           it("should instantiate directives that depend on bindings bindings of other directives", () => {
             var shadowInj = hostShadowInjectors(
-                ListWrapper.concat([DirectiveBinding.createFromType(SimpleDirective, new dirAnn.Component({
+                ListWrapper.concat([DirectiveBinding.createFromType(SimpleDirective, new ComponentMetadata({
                       bindings: [bind('service').toValue('hostService')]})
                     )], extraBindings),
                 ListWrapper.concat([NeedsService], extraBindings)
@@ -742,7 +741,7 @@ export function main() {
 
           it("should prioritize viewBindings over bindings for the same binding", () => {
             var inj = injector(
-                ListWrapper.concat([DirectiveBinding.createFromType(NeedsService, new dirAnn.Component({
+                ListWrapper.concat([DirectiveBinding.createFromType(NeedsService, new ComponentMetadata({
                       bindings: [bind('service').toValue('hostService')],
                       viewBindings: [bind('service').toValue('viewService')]})
                     )], extraBindings), null, true);
@@ -755,7 +754,7 @@ export function main() {
               hostShadowInjectors(
                 ListWrapper.concat([
                   SimpleDirective,
-                  DirectiveBinding.createFromType(SomeOtherDirective, new dirAnn.Directive({
+                  DirectiveBinding.createFromType(SomeOtherDirective, new DirectiveMetadata({
                       bindings: [bind('service').toValue('hostService')]})
                   )], extraBindings),
 
@@ -827,7 +826,7 @@ export function main() {
 
           it("should instantiate directives that depend on the containing component", () => {
             var directiveBinding =
-                DirectiveBinding.createFromType(SimpleDirective, new dirAnn.Component());
+                DirectiveBinding.createFromType(SimpleDirective, new ComponentMetadata());
             var shadow = hostShadowInjectors(ListWrapper.concat([directiveBinding], extraBindings),
                                              [NeeedsDirectiveFromHost]);
 
@@ -839,7 +838,7 @@ export function main() {
           it("should not instantiate directives that depend on other directives in the containing component's ElementInjector",
              () => {
                var directiveBinding =
-                   DirectiveBinding.createFromType(SomeOtherDirective, new dirAnn.Component());
+                   DirectiveBinding.createFromType(SomeOtherDirective, new ComponentMetadata());
                expect(() =>
                       {
                         hostShadowInjectors(
@@ -855,7 +854,7 @@ export function main() {
           it("should call onDestroy on directives subscribed to this event", () => {
             var inj = injector(ListWrapper.concat(
                 [DirectiveBinding.createFromType(DirectiveWithDestroy,
-                                                 new dirAnn.Directive({lifecycle: [LifecycleEvent.onDestroy]}))],
+                                                 new DirectiveMetadata({lifecycle: [LifecycleEvent.onDestroy]}))],
                 extraBindings));
             var destroy = inj.get(DirectiveWithDestroy);
             inj.dehydrate();
@@ -865,7 +864,7 @@ export function main() {
           it("should work with services", () => {
             var inj = injector(ListWrapper.concat(
                 [DirectiveBinding.createFromType(
-                    SimpleDirective, new dirAnn.Directive({bindings: [SimpleService]}))],
+                    SimpleDirective, new DirectiveMetadata({bindings: [SimpleService]}))],
                 extraBindings));
             inj.dehydrate();
           });
@@ -942,7 +941,7 @@ export function main() {
             var childView = new DummyView();
             childView.changeDetector = cd;
             view.spy('getNestedView').andReturn(childView);
-            var binding = DirectiveBinding.createFromType(ComponentNeedsChangeDetectorRef, new dirAnn.Component());
+            var binding = DirectiveBinding.createFromType(ComponentNeedsChangeDetectorRef, new ComponentMetadata());
             var inj = injector(ListWrapper.concat([binding], extraBindings), null, true,
                                new PreBuiltObjects(null, view, <any>new DummyElementRef(), null));
 
@@ -953,7 +952,7 @@ export function main() {
             var cd = new DynamicChangeDetector(null, null, null, [], [], []);
             var view = <any>new DummyView();
             view.changeDetector =cd;
-            var binding = DirectiveBinding.createFromType(DirectiveNeedsChangeDetectorRef, new dirAnn.Directive());
+            var binding = DirectiveBinding.createFromType(DirectiveNeedsChangeDetectorRef, new DirectiveMetadata());
             var inj = injector(ListWrapper.concat([binding], extraBindings), null, false,
                                new PreBuiltObjects(null, view, <any>new DummyElementRef(), null));
 
diff --git a/modules/angular2/test/core/compiler/integration_spec.ts b/modules/angular2/test/core/compiler/integration_spec.ts
index 92ff03894f..42e2b77baf 100644
--- a/modules/angular2/test/core/compiler/integration_spec.ts
+++ b/modules/angular2/test/core/compiler/integration_spec.ts
@@ -61,8 +61,7 @@ import {
   ON_PUSH
 } from 'angular2/src/change_detection/change_detection';
 
-import {Directive, Component, View, Attribute, Query, Pipe} from 'angular2/annotations';
-import * as viewAnn from 'angular2/src/core/annotations_impl/view';
+import {Directive, Component, View, ViewMetadata, Attribute, Query, Pipe} from 'angular2/metadata';
 
 import {QueryList} from 'angular2/src/core/compiler/query_list';
 
@@ -89,7 +88,7 @@ export function main() {
     describe('react to record changes', function() {
       it('should consume text node changes',
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-           tcb.overrideView(MyComp, new viewAnn.View({template: '<div>{{ctxProp}}</div>'}))
+           tcb.overrideView(MyComp, new ViewMetadata({template: '<div>{{ctxProp}}</div>'}))
                .createAsync(MyComp)
                .then((rootTC) => {
                  rootTC.componentInstance.ctxProp = 'Hello World!';
@@ -103,7 +102,7 @@ export function main() {
 
       it('should update text node with a blank string when interpolation evaluates to null',
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-           tcb.overrideView(MyComp, new viewAnn.View({template: '<div>{{null}}{{ctxProp}}</div>'}))
+           tcb.overrideView(MyComp, new ViewMetadata({template: '<div>{{null}}{{ctxProp}}</div>'}))
                .createAsync(MyComp)
                .then((rootTC) => {
                  rootTC.componentInstance.ctxProp = null;
@@ -116,7 +115,7 @@ export function main() {
 
       it('should consume element binding changes',
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-           tcb.overrideView(MyComp, new viewAnn.View({template: '<div [id]="ctxProp"></div>'}))
+           tcb.overrideView(MyComp, new ViewMetadata({template: '<div [id]="ctxProp"></div>'}))
                .createAsync(MyComp)
                .then((rootTC) => {
 
@@ -131,7 +130,7 @@ export function main() {
       it('should consume binding to aria-* attributes',
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
            tcb.overrideView(MyComp,
-                            new viewAnn.View({template: '<div [attr.aria-label]="ctxProp"></div>'}))
+                            new ViewMetadata({template: '<div [attr.aria-label]="ctxProp"></div>'}))
 
                .createAsync(MyComp)
                .then((rootTC) => {
@@ -155,7 +154,7 @@ export function main() {
       it('should consume binding to property names where attr name and property name do not match',
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
            tcb.overrideView(MyComp,
-                            new viewAnn.View({template: '<div [tabindex]="ctxNumProp"></div>'}))
+                            new ViewMetadata({template: '<div [tabindex]="ctxNumProp"></div>'}))
 
                .createAsync(MyComp)
                .then((rootTC) => {
@@ -174,7 +173,7 @@ export function main() {
       it('should consume binding to camel-cased properties using dash-cased syntax in templates',
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
            tcb.overrideView(MyComp,
-                            new viewAnn.View({template: '<input [read-only]="ctxBoolProp">'}))
+                            new ViewMetadata({template: '<input [read-only]="ctxBoolProp">'}))
 
                .createAsync(MyComp)
                .then((rootTC) => {
@@ -193,7 +192,7 @@ export function main() {
       it('should consume binding to inner-html',
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
            tcb.overrideView(MyComp,
-                            new viewAnn.View({template: '<div inner-html="{{ctxProp}}"></div>'}))
+                            new ViewMetadata({template: '<div inner-html="{{ctxProp}}"></div>'}))
 
                .createAsync(MyComp)
                .then((rootTC) => {
@@ -216,7 +215,7 @@ export function main() {
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
            tcb.overrideView(
                   MyComp,
-                  new viewAnn.View({template: '<div class="initial" [class]="ctxProp"></div>'}))
+                  new ViewMetadata({template: '<div class="initial" [class]="ctxProp"></div>'}))
 
                .createAsync(MyComp)
                .then((rootTC) => {
@@ -240,7 +239,7 @@ export function main() {
                      '<div my-dir elprop="Hi {{\'there!\'}}"></div>' +
                      '<div my-dir elprop="One more {{ctxProp}}"></div>' +
                      '</div>';
-           tcb.overrideView(MyComp, new viewAnn.View({template: tpl, directives: [MyDir]}))
+           tcb.overrideView(MyComp, new ViewMetadata({template: tpl, directives: [MyDir]}))
 
                .createAsync(MyComp)
                .then((rootTC) => {
@@ -260,31 +259,32 @@ export function main() {
 
       describe('pipes', () => {
         it("should support pipes in bindings",
-           inject([TestComponentBuilder, AsyncTestCompleter],
-                  (tcb: TestComponentBuilder, async) => {
-                    tcb.overrideView(MyComp, new viewAnn.View({
-                         template: '<div my-dir #dir="mydir" [elprop]="ctxProp | double"></div>',
-                         directives: [MyDir],
-                         pipes: [DoublePipe]
-                       }))
+           inject(
+               [TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
+                 tcb.overrideView(
+                        MyComp, new ViewMetadata({
+                          template: '<div my-dir #dir="mydir" [elprop]="ctxProp | double"></div>',
+                          directives: [MyDir],
+                          pipes: [DoublePipe]
+                        }))
 
-                        .createAsync(MyComp)
-                        .then((rootTC) => {
-                          rootTC.componentInstance.ctxProp = 'a';
-                          rootTC.detectChanges();
+                     .createAsync(MyComp)
+                     .then((rootTC) => {
+                       rootTC.componentInstance.ctxProp = 'a';
+                       rootTC.detectChanges();
 
-                          var dir = rootTC.componentViewChildren[0].getLocal('dir');
-                          expect(dir.dirProp).toEqual('aa');
-                          async.done();
-                        });
-                  }));
+                       var dir = rootTC.componentViewChildren[0].getLocal('dir');
+                       expect(dir.dirProp).toEqual('aa');
+                       async.done();
+                     });
+               }));
       });
 
       it('should support nested components.',
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
            tcb.overrideView(
                   MyComp,
-                  new viewAnn.View({template: '<child-cmp></child-cmp>', directives: [ChildComp]}))
+                  new ViewMetadata({template: '<child-cmp></child-cmp>', directives: [ChildComp]}))
 
                .createAsync(MyComp)
                .then((rootTC) => {
@@ -299,10 +299,10 @@ export function main() {
       // GH issue 328 - https://github.com/angular/angular/issues/328
       it('should support different directive types on a single node',
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-           tcb.overrideView(MyComp, new viewAnn.View({
-                template: '<child-cmp my-dir [elprop]="ctxProp"></child-cmp>',
-                directives: [MyDir, ChildComp]
-              }))
+           tcb.overrideView(MyComp, new ViewMetadata({
+                              template: '<child-cmp my-dir [elprop]="ctxProp"></child-cmp>',
+                              directives: [MyDir, ChildComp]
+                            }))
 
                .createAsync(MyComp)
                .then((rootTC) => {
@@ -321,11 +321,11 @@ export function main() {
 
       it('should support directives where a binding attribute is not given',
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-           tcb.overrideView(MyComp, new viewAnn.View({
-                // No attribute "el-prop" specified.
-                template: '<p my-dir></p>',
-                directives: [MyDir]
-              }))
+           tcb.overrideView(MyComp, new ViewMetadata({
+                              // No attribute "el-prop" specified.
+                              template: '<p my-dir></p>',
+                              directives: [MyDir]
+                            }))
 
                .createAsync(MyComp)
                .then((rootTC) => { async.done(); });
@@ -333,14 +333,15 @@ export function main() {
 
       it('should execute a given directive once, even if specified multiple times',
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-           tcb.overrideView(MyComp, new viewAnn.View({
-                template: '<p no-duplicate></p>',
-                directives: [
-                  DuplicateDir,
-                  DuplicateDir,
-                  [DuplicateDir, [DuplicateDir, bind(DuplicateDir).toClass(DuplicateDir)]]
-                ]
-              }))
+           tcb.overrideView(
+                  MyComp, new ViewMetadata({
+                    template: '<p no-duplicate></p>',
+                    directives: [
+                      DuplicateDir,
+                      DuplicateDir,
+                      [DuplicateDir, [DuplicateDir, bind(DuplicateDir).toClass(DuplicateDir)]]
+                    ]
+                  }))
                .createAsync(MyComp)
                .then((rootTC) => {
                  expect(rootTC.nativeElement).toHaveText('noduplicate');
@@ -350,14 +351,14 @@ export function main() {
 
       it('should use the last directive binding per directive',
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-           tcb.overrideView(MyComp, new viewAnn.View({
-                template: '<p no-duplicate></p>',
-                directives: [
-                  bind(DuplicateDir)
-                      .toClass(DuplicateDir),
-                  bind(DuplicateDir).toClass(OtherDuplicateDir)
-                ]
-              }))
+           tcb.overrideView(MyComp, new ViewMetadata({
+                              template: '<p no-duplicate></p>',
+                              directives: [
+                                bind(DuplicateDir)
+                                    .toClass(DuplicateDir),
+                                bind(DuplicateDir).toClass(OtherDuplicateDir)
+                              ]
+                            }))
                .createAsync(MyComp)
                .then((rootTC) => {
                  expect(rootTC.nativeElement).toHaveText('othernoduplicate');
@@ -367,7 +368,7 @@ export function main() {
 
       it('should support directives where a selector matches property binding',
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-           tcb.overrideView(MyComp, new viewAnn.View(
+           tcb.overrideView(MyComp, new ViewMetadata(
                                         {template: '<p [id]="ctxProp"></p>', directives: [IdDir]}))
 
                .createAsync(MyComp)
@@ -389,10 +390,10 @@ export function main() {
 
       it('should allow specifying directives as bindings',
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-           tcb.overrideView(MyComp, new viewAnn.View({
-                template: '<child-cmp></child-cmp>',
-                directives: [bind(ChildComp).toClass(ChildComp)]
-              }))
+           tcb.overrideView(MyComp, new ViewMetadata({
+                              template: '<child-cmp></child-cmp>',
+                              directives: [bind(ChildComp).toClass(ChildComp)]
+                            }))
 
                .createAsync(MyComp)
                .then((rootTC) => {
@@ -405,10 +406,10 @@ export function main() {
 
       it('should read directives metadata from their binding token',
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-           tcb.overrideView(MyComp, new viewAnn.View({
-                template: '<div public-api><div needs-public-api></div></div>',
-                directives: [bind(PublicApi).toClass(PrivateImpl), NeedsPublicApi]
-              }))
+           tcb.overrideView(MyComp, new ViewMetadata({
+                              template: '<div public-api><div needs-public-api></div></div>',
+                              directives: [bind(PublicApi).toClass(PrivateImpl), NeedsPublicApi]
+                            }))
 
                .createAsync(MyComp)
                .then((rootTC) => { async.done(); });
@@ -416,11 +417,12 @@ export function main() {
 
       it('should support template directives via `<template>` elements.',
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-           tcb.overrideView(MyComp, new viewAnn.View({
-                template:
-                    '<div><template some-viewport var-greeting="some-tmpl"><copy-me>{{greeting}}</copy-me></template></div>',
-                directives: [SomeViewport]
-              }))
+           tcb.overrideView(
+                  MyComp, new ViewMetadata({
+                    template:
+                        '<div><template some-viewport var-greeting="some-tmpl"><copy-me>{{greeting}}</copy-me></template></div>',
+                    directives: [SomeViewport]
+                  }))
 
                .createAsync(MyComp)
                .then((rootTC) => {
@@ -438,11 +440,12 @@ export function main() {
 
       it('should support template directives via `template` attribute.',
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-           tcb.overrideView(MyComp, new viewAnn.View({
-                template:
-                    '<div><copy-me template="some-viewport: var greeting=some-tmpl">{{greeting}}</copy-me></div>',
-                directives: [SomeViewport]
-              }))
+           tcb.overrideView(
+                  MyComp, new ViewMetadata({
+                    template:
+                        '<div><copy-me template="some-viewport: var greeting=some-tmpl">{{greeting}}</copy-me></div>',
+                    directives: [SomeViewport]
+                  }))
 
                .createAsync(MyComp)
                .then((rootTC) => {
@@ -459,11 +462,12 @@ export function main() {
 
       it('should allow to transplant embedded ProtoViews into other ViewContainers',
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-           tcb.overrideView(MyComp, new viewAnn.View({
-                template:
-                    '<some-directive><toolbar><template toolbarpart var-toolbar-prop="toolbarProp">{{ctxProp}},{{toolbarProp}},<cmp-with-host></cmp-with-host></template></toolbar></some-directive>',
-                directives: [SomeDirective, CompWithHost, ToolbarComponent, ToolbarPart]
-              }))
+           tcb.overrideView(
+                  MyComp, new ViewMetadata({
+                    template:
+                        '<some-directive><toolbar><template toolbarpart var-toolbar-prop="toolbarProp">{{ctxProp}},{{toolbarProp}},<cmp-with-host></cmp-with-host></template></toolbar></some-directive>',
+                    directives: [SomeDirective, CompWithHost, ToolbarComponent, ToolbarPart]
+                  }))
                .createAsync(MyComp)
                .then((rootTC) => {
                  rootTC.componentInstance.ctxProp = 'From myComp';
@@ -480,27 +484,27 @@ export function main() {
       describe("variable bindings", () => {
         it('should assign a component to a var-',
            inject([TestComponentBuilder, AsyncTestCompleter],
-                  (tcb: TestComponentBuilder,
-                   async) => {tcb.overrideView(MyComp, new viewAnn.View({
-                                   template: '<p><child-cmp var-alice></child-cmp></p>',
-                                   directives: [ChildComp]
-                                 }))
+                  (tcb: TestComponentBuilder, async) => {
+                      tcb.overrideView(MyComp, new ViewMetadata({
+                                         template: '<p><child-cmp var-alice></child-cmp></p>',
+                                         directives: [ChildComp]
+                                       }))
 
-                                  .createAsync(MyComp)
-                                  .then((rootTC) => {
-                                    expect(rootTC.componentViewChildren[0].getLocal('alice'))
-                                        .toBeAnInstanceOf(ChildComp);
+                          .createAsync(MyComp)
+                          .then((rootTC) => {
+                            expect(rootTC.componentViewChildren[0].getLocal('alice'))
+                                .toBeAnInstanceOf(ChildComp);
 
-                                    async.done();
-                                  })}));
+                            async.done();
+                          })}));
 
         it('should assign a directive to a var-',
            inject([TestComponentBuilder, AsyncTestCompleter],
                   (tcb: TestComponentBuilder, async) => {
-                    tcb.overrideView(MyComp, new viewAnn.View({
-                         template: '<p><div export-dir #localdir="dir"></div></p>',
-                         directives: [ExportDir]
-                       }))
+                    tcb.overrideView(MyComp, new ViewMetadata({
+                                       template: '<p><div export-dir #localdir="dir"></div></p>',
+                                       directives: [ExportDir]
+                                     }))
 
                         .createAsync(MyComp)
                         .then((rootTC) => {
@@ -512,52 +516,56 @@ export function main() {
                   }));
 
         it('should make the assigned component accessible in property bindings',
-           inject([TestComponentBuilder, AsyncTestCompleter],
-                  (tcb: TestComponentBuilder, async) => {
-                      tcb.overrideView(MyComp, new viewAnn.View({
-                           template: '<p><child-cmp var-alice></child-cmp>{{alice.ctxProp}}</p>',
-                           directives: [ChildComp]
-                         }))
+           inject(
+               [TestComponentBuilder, AsyncTestCompleter],
+               (tcb: TestComponentBuilder, async) => {
+                   tcb.overrideView(
+                          MyComp, new ViewMetadata({
+                            template: '<p><child-cmp var-alice></child-cmp>{{alice.ctxProp}}</p>',
+                            directives: [ChildComp]
+                          }))
 
-                          .createAsync(MyComp)
-                          .then((rootTC) => {
-                            rootTC.detectChanges();
+                       .createAsync(MyComp)
+                       .then((rootTC) => {
+                         rootTC.detectChanges();
 
-                            expect(rootTC.nativeElement)
-                                .toHaveText('hellohello');  // this first one is the
-                                                            // component, the second one is
-                                                            // the text binding
-                            async.done();
-                          })}));
+                         expect(rootTC.nativeElement)
+                             .toHaveText('hellohello');  // this first one is the
+                                                         // component, the second one is
+                                                         // the text binding
+                         async.done();
+                       })}));
 
         it('should assign two component instances each with a var-',
-           inject([TestComponentBuilder, AsyncTestCompleter],
-                  (tcb: TestComponentBuilder, async) => {
-                      tcb.overrideView(MyComp, new viewAnn.View({
-                           template: '<p><child-cmp var-alice></child-cmp><child-cmp var-bob></p>',
-                           directives: [ChildComp]
-                         }))
+           inject(
+               [TestComponentBuilder, AsyncTestCompleter],
+               (tcb: TestComponentBuilder, async) => {
+                   tcb.overrideView(
+                          MyComp, new ViewMetadata({
+                            template: '<p><child-cmp var-alice></child-cmp><child-cmp var-bob></p>',
+                            directives: [ChildComp]
+                          }))
 
-                          .createAsync(MyComp)
-                          .then((rootTC) => {
+                       .createAsync(MyComp)
+                       .then((rootTC) => {
 
-                            expect(rootTC.componentViewChildren[0].getLocal('alice'))
-                                .toBeAnInstanceOf(ChildComp);
-                            expect(rootTC.componentViewChildren[0].getLocal('bob'))
-                                .toBeAnInstanceOf(ChildComp);
-                            expect(rootTC.componentViewChildren[0].getLocal('alice'))
-                                .not.toBe(rootTC.componentViewChildren[0].getLocal('bob'));
+                         expect(rootTC.componentViewChildren[0].getLocal('alice'))
+                             .toBeAnInstanceOf(ChildComp);
+                         expect(rootTC.componentViewChildren[0].getLocal('bob'))
+                             .toBeAnInstanceOf(ChildComp);
+                         expect(rootTC.componentViewChildren[0].getLocal('alice'))
+                             .not.toBe(rootTC.componentViewChildren[0].getLocal('bob'));
 
-                            async.done();
-                          })}));
+                         async.done();
+                       })}));
 
         it('should assign the component instance to a var- with shorthand syntax',
            inject([TestComponentBuilder, AsyncTestCompleter],
                   (tcb: TestComponentBuilder,
-                   async) => {tcb.overrideView(MyComp, new viewAnn.View({
-                                   template: '<child-cmp #alice></child-cmp>',
-                                   directives: [ChildComp]
-                                 }))
+                   async) => {tcb.overrideView(MyComp, new ViewMetadata({
+                                                 template: '<child-cmp #alice></child-cmp>',
+                                                 directives: [ChildComp]
+                                               }))
 
                                   .createAsync(MyComp)
                                   .then((rootTC) => {
@@ -572,7 +580,7 @@ export function main() {
            inject([TestComponentBuilder, AsyncTestCompleter],
                   (tcb: TestComponentBuilder, async) => {
                       tcb.overrideView(MyComp,
-                                       new viewAnn.View(
+                                       new ViewMetadata(
                                            {template: '<p><div var-alice><i>Hello</i></div></p>'}))
 
                           .createAsync(MyComp)
@@ -588,10 +596,10 @@ export function main() {
         it('should change dash-case to camel-case',
            inject([TestComponentBuilder, AsyncTestCompleter],
                   (tcb: TestComponentBuilder, async) => {
-                    tcb.overrideView(MyComp, new viewAnn.View({
-                         template: '<p><child-cmp var-super-alice></child-cmp></p>',
-                         directives: [ChildComp]
-                       }))
+                    tcb.overrideView(MyComp, new ViewMetadata({
+                                       template: '<p><child-cmp var-super-alice></child-cmp></p>',
+                                       directives: [ChildComp]
+                                     }))
 
                         .createAsync(MyComp)
                         .then((rootTC) => {
@@ -605,11 +613,12 @@ export function main() {
         it('should allow to use variables in a for loop',
            inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder,
                                                                async) => {
-             tcb.overrideView(MyComp, new viewAnn.View({
-                  template:
-                      '<div><div *ng-for="var i of [1]"><child-cmp-no-template #cmp></child-cmp-no-template>{{i}}-{{cmp.ctxProp}}</div></div>',
-                  directives: [ChildCompNoTemplate, NgFor]
-                }))
+             tcb.overrideView(
+                    MyComp, new ViewMetadata({
+                      template:
+                          '<div><div *ng-for="var i of [1]"><child-cmp-no-template #cmp></child-cmp-no-template>{{i}}-{{cmp.ctxProp}}</div></div>',
+                      directives: [ChildCompNoTemplate, NgFor]
+                    }))
 
                  .createAsync(MyComp)
                  .then((rootTC) => {
@@ -628,10 +637,10 @@ export function main() {
            inject([TestComponentBuilder, AsyncTestCompleter],
                   (tcb: TestComponentBuilder, async) => {
 
-                      tcb.overrideView(MyComp, new viewAnn.View({
-                           template: '<push-cmp-with-ref #cmp></push-cmp-with-ref>',
-                           directives: [[[PushCmpWithRef]]]
-                         }))
+                      tcb.overrideView(MyComp, new ViewMetadata({
+                                         template: '<push-cmp-with-ref #cmp></push-cmp-with-ref>',
+                                         directives: [[[PushCmpWithRef]]]
+                                       }))
 
                           .createAsync(MyComp)
                           .then((rootTC) => {
@@ -655,10 +664,10 @@ export function main() {
            inject([TestComponentBuilder, AsyncTestCompleter],
                   (tcb: TestComponentBuilder, async) => {
 
-                      tcb.overrideView(MyComp, new viewAnn.View({
-                           template: '<push-cmp [prop]="ctxProp" #cmp></push-cmp>',
-                           directives: [[[PushCmp]]]
-                         }))
+                      tcb.overrideView(MyComp, new ViewMetadata({
+                                         template: '<push-cmp [prop]="ctxProp" #cmp></push-cmp>',
+                                         directives: [[[PushCmp]]]
+                                       }))
 
                           .createAsync(MyComp)
                           .then((rootTC) => {
@@ -676,37 +685,39 @@ export function main() {
                           })}));
 
         it('should not affect updating properties on the component',
-           inject(
-               [TestComponentBuilder, AsyncTestCompleter],
-               (tcb: TestComponentBuilder, async) => {
-                   tcb.overrideView(MyComp, new viewAnn.View({
-                        template: '<push-cmp-with-ref [prop]="ctxProp" #cmp></push-cmp-with-ref>',
-                        directives: [[[PushCmpWithRef]]]
-                      }))
+           inject([TestComponentBuilder, AsyncTestCompleter],
+                  (tcb: TestComponentBuilder, async) => {
+                      tcb.overrideView(
+                             MyComp, new ViewMetadata({
+                               template:
+                                   '<push-cmp-with-ref [prop]="ctxProp" #cmp></push-cmp-with-ref>',
+                               directives: [[[PushCmpWithRef]]]
+                             }))
 
-                       .createAsync(MyComp)
-                       .then((rootTC) => {
+                          .createAsync(MyComp)
+                          .then((rootTC) => {
 
-                         var cmp = rootTC.componentViewChildren[0].getLocal('cmp');
+                            var cmp = rootTC.componentViewChildren[0].getLocal('cmp');
 
-                         rootTC.componentInstance.ctxProp = "one";
-                         rootTC.detectChanges();
-                         expect(cmp.prop).toEqual("one");
+                            rootTC.componentInstance.ctxProp = "one";
+                            rootTC.detectChanges();
+                            expect(cmp.prop).toEqual("one");
 
-                         rootTC.componentInstance.ctxProp = "two";
-                         rootTC.detectChanges();
-                         expect(cmp.prop).toEqual("two");
+                            rootTC.componentInstance.ctxProp = "two";
+                            rootTC.detectChanges();
+                            expect(cmp.prop).toEqual("two");
 
-                         async.done();
-                       })}));
+                            async.done();
+                          })}));
 
         if (DOM.supportsDOMEvents()) {
           it('should be checked when an async pipe requests a check',
              inject([TestComponentBuilder], fakeAsync((tcb: TestComponentBuilder) => {
-                      tcb = tcb.overrideView(MyComp, new viewAnn.View({
-                        template: '<push-cmp-with-async #cmp></push-cmp-with-async>',
-                        directives: [[[PushCmpWithAsyncPipe]]]
-                      }));
+                      tcb = tcb.overrideView(
+                          MyComp, new ViewMetadata({
+                            template: '<push-cmp-with-async #cmp></push-cmp-with-async>',
+                            directives: [[[PushCmpWithAsyncPipe]]]
+                          }));
 
                       var rootTC;
                       tcb.createAsync(MyComp).then(root => { rootTC = root; });
@@ -732,15 +743,15 @@ export function main() {
       it('should create a component that injects an @Host',
          inject([TestComponentBuilder, AsyncTestCompleter],
                 (tcb: TestComponentBuilder, async) => {
-                    tcb.overrideView(MyComp, new viewAnn.View({
-                         template: `
+                    tcb.overrideView(MyComp, new ViewMetadata({
+                                       template: `
             <some-directive>
               <p>
                 <cmp-with-host #child></cmp-with-host>
               </p>
             </some-directive>`,
-                         directives: [SomeDirective, CompWithHost]
-                       }))
+                                       directives: [SomeDirective, CompWithHost]
+                                     }))
 
                         .createAsync(MyComp)
                         .then((rootTC) => {
@@ -753,15 +764,15 @@ export function main() {
 
       it('should create a component that injects an @Host through viewcontainer directive',
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-           tcb.overrideView(MyComp, new viewAnn.View({
-                template: `
+           tcb.overrideView(MyComp, new ViewMetadata({
+                              template: `
             <some-directive>
               <p *ng-if="true">
                 <cmp-with-host #child></cmp-with-host>
               </p>
             </some-directive>`,
-                directives: [SomeDirective, CompWithHost, NgIf]
-              }))
+                              directives: [SomeDirective, CompWithHost, NgIf]
+                            }))
 
                .createAsync(MyComp)
                .then((rootTC) => {
@@ -778,10 +789,10 @@ export function main() {
 
       it('should support events via EventEmitter',
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-           tcb.overrideView(MyComp, new viewAnn.View({
-                template: '<div emitter listener></div>',
-                directives: [DirectiveEmitingEvent, DirectiveListeningEvent]
-              }))
+           tcb.overrideView(MyComp, new ViewMetadata({
+                              template: '<div emitter listener></div>',
+                              directives: [DirectiveEmitingEvent, DirectiveListeningEvent]
+                            }))
 
                .createAsync(MyComp)
                .then((rootTC) => {
@@ -803,10 +814,10 @@ export function main() {
 
       it('should support [()] syntax',
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-           tcb.overrideView(MyComp, new viewAnn.View({
-                template: '<div [(control)]="ctxProp" two-way></div>',
-                directives: [DirectiveWithTwoWayBinding]
-              }))
+           tcb.overrideView(MyComp, new ViewMetadata({
+                              template: '<div [(control)]="ctxProp" two-way></div>',
+                              directives: [DirectiveWithTwoWayBinding]
+                            }))
 
                .createAsync(MyComp)
                .then((rootTC) => {
@@ -831,10 +842,10 @@ export function main() {
         it("should support invoking methods on the host element via hostActions",
            inject(
                [TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-                 tcb.overrideView(MyComp, new viewAnn.View({
-                      template: '<div update-host-actions></div>',
-                      directives: [DirectiveUpdatingHostActions]
-                    }))
+                 tcb.overrideView(MyComp, new ViewMetadata({
+                                    template: '<div update-host-actions></div>',
+                                    directives: [DirectiveUpdatingHostActions]
+                                  }))
 
                      .createAsync(MyComp)
                      .then((rootTC) => {
@@ -856,7 +867,7 @@ export function main() {
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
            tcb.overrideView(
                   MyComp,
-                  new viewAnn.View(
+                  new ViewMetadata(
                       {template: '<div listener></div>', directives: [DirectiveListeningDomEvent]}))
 
                .createAsync(MyComp)
@@ -877,7 +888,7 @@ export function main() {
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
            tcb.overrideView(
                   MyComp,
-                  new viewAnn.View(
+                  new ViewMetadata(
                       {template: '<div listener></div>', directives: [DirectiveListeningDomEvent]}))
 
                .createAsync(MyComp)
@@ -902,10 +913,10 @@ export function main() {
 
       it('should support updating host element via hostAttributes',
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-           tcb.overrideView(MyComp, new viewAnn.View({
-                template: '<div update-host-attributes></div>',
-                directives: [DirectiveUpdatingHostAttributes]
-              }))
+           tcb.overrideView(MyComp, new ViewMetadata({
+                              template: '<div update-host-attributes></div>',
+                              directives: [DirectiveUpdatingHostAttributes]
+                            }))
 
                .createAsync(MyComp)
                .then((rootTC) => {
@@ -920,10 +931,10 @@ export function main() {
 
       it('should support updating host element via hostProperties',
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-           tcb.overrideView(MyComp, new viewAnn.View({
-                template: '<div update-host-properties></div>',
-                directives: [DirectiveUpdatingHostProperties]
-              }))
+           tcb.overrideView(MyComp, new ViewMetadata({
+                              template: '<div update-host-properties></div>',
+                              directives: [DirectiveUpdatingHostProperties]
+                            }))
 
                .createAsync(MyComp)
                .then((rootTC) => {
@@ -945,12 +956,15 @@ export function main() {
         it('should support preventing default on render events',
            inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder,
                                                                async) => {
-             tcb.overrideView(MyComp, new viewAnn.View({
-                  template:
-                      '<input type="checkbox" listenerprevent></input><input type="checkbox" listenernoprevent></input>',
-                  directives:
-                      [DirectiveListeningDomEventPrevent, DirectiveListeningDomEventNoPrevent]
-                }))
+             tcb.overrideView(
+                    MyComp, new ViewMetadata({
+                      template:
+                          '<input type="checkbox" listenerprevent></input><input type="checkbox" listenernoprevent></input>',
+                      directives: [
+                        DirectiveListeningDomEventPrevent,
+                        DirectiveListeningDomEventNoPrevent
+                      ]
+                    }))
 
                  .createAsync(MyComp)
                  .then((rootTC) => {
@@ -973,10 +987,12 @@ export function main() {
 
       it('should support render global events from multiple directives',
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-           tcb.overrideView(MyComp, new viewAnn.View({
-                template: '<div *ng-if="ctxBoolProp" listener listenerother></div>',
-                directives: [NgIf, DirectiveListeningDomEvent, DirectiveListeningDomEventOther]
-              }))
+           tcb.overrideView(
+                  MyComp, new ViewMetadata({
+                    template: '<div *ng-if="ctxBoolProp" listener listenerother></div>',
+                    directives:
+                        [NgIf, DirectiveListeningDomEvent, DirectiveListeningDomEventOther]
+                  }))
 
                .createAsync(MyComp)
                .then((rootTC) => {
@@ -1013,10 +1029,10 @@ export function main() {
         it('should allow to create a ViewContainerRef at any bound location',
            inject([TestComponentBuilder, AsyncTestCompleter, Compiler],
                   (tcb: TestComponentBuilder, async, compiler) => {
-                    tcb.overrideView(MyComp, new viewAnn.View({
-                         template: '<div><dynamic-vp #dynamic></dynamic-vp></div>',
-                         directives: [DynamicViewport]
-                       }))
+                    tcb.overrideView(MyComp, new ViewMetadata({
+                                       template: '<div><dynamic-vp #dynamic></dynamic-vp></div>',
+                                       directives: [DynamicViewport]
+                                     }))
 
                         .createAsync(MyComp)
                         .then((rootTC) => {
@@ -1037,7 +1053,7 @@ export function main() {
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
            tcb.overrideView(
                   MyComp,
-                  new viewAnn.View(
+                  new ViewMetadata(
                       {template: '<input static type="text" title>', directives: [NeedsAttribute]}))
                .createAsync(MyComp)
                .then((rootTC) => {
@@ -1055,15 +1071,16 @@ export function main() {
     describe("dependency injection", () => {
       it("should support bindings",
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-           tcb.overrideView(MyComp, new viewAnn.View({
-                template: `
+           tcb.overrideView(
+                  MyComp, new ViewMetadata({
+                    template: `
             <directive-providing-injectable >
               <directive-consuming-injectable #consuming>
               </directive-consuming-injectable>
             </directive-providing-injectable>
           `,
-                directives: [DirectiveProvidingInjectable, DirectiveConsumingInjectable]
-              }))
+                    directives: [DirectiveProvidingInjectable, DirectiveConsumingInjectable]
+                  }))
                .createAsync(MyComp)
                .then((rootTC) => {
                  var comp = rootTC.componentViewChildren[0].getLocal("consuming");
@@ -1075,13 +1092,13 @@ export function main() {
 
       it("should support viewBindings",
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-           tcb.overrideView(DirectiveProvidingInjectableInView, new viewAnn.View({
-                template: `
+           tcb.overrideView(DirectiveProvidingInjectableInView, new ViewMetadata({
+                              template: `
               <directive-consuming-injectable #consuming>
               </directive-consuming-injectable>
           `,
-                directives: [DirectiveConsumingInjectable]
-              }))
+                              directives: [DirectiveConsumingInjectable]
+                            }))
                .createAsync(DirectiveProvidingInjectableInView)
                .then((rootTC) => {
                  var comp = rootTC.componentViewChildren[0].getLocal("consuming");
@@ -1093,24 +1110,24 @@ export function main() {
 
       it("should support unbounded lookup",
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-           tcb.overrideView(MyComp, new viewAnn.View({
-                template: `
+           tcb.overrideView(MyComp, new ViewMetadata({
+                              template: `
             <directive-providing-injectable>
               <directive-containing-directive-consuming-an-injectable #dir>
               </directive-containing-directive-consuming-an-injectable>
             </directive-providing-injectable>
           `,
-                directives: [
-                  DirectiveProvidingInjectable,
-                  DirectiveContainingDirectiveConsumingAnInjectable
-                ]
-              }))
-               .overrideView(DirectiveContainingDirectiveConsumingAnInjectable, new viewAnn.View({
-                 template: `
+                              directives: [
+                                DirectiveProvidingInjectable,
+                                DirectiveContainingDirectiveConsumingAnInjectable
+                              ]
+                            }))
+               .overrideView(DirectiveContainingDirectiveConsumingAnInjectable, new ViewMetadata({
+                               template: `
             <directive-consuming-injectable-unbounded></directive-consuming-injectable-unbounded>
           `,
-                 directives: [DirectiveConsumingInjectableUnbounded]
-               }))
+                               directives: [DirectiveConsumingInjectableUnbounded]
+                             }))
 
                .createAsync(MyComp)
                .then((rootTC) => {
@@ -1123,8 +1140,8 @@ export function main() {
 
       it("should support the event-bus scenario",
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-           tcb.overrideView(MyComp, new viewAnn.View({
-                template: `
+           tcb.overrideView(MyComp, new ViewMetadata({
+                              template: `
             <grand-parent-providing-event-bus>
               <parent-providing-event-bus>
                 <child-consuming-event-bus>
@@ -1132,12 +1149,12 @@ export function main() {
               </parent-providing-event-bus>
             </grand-parent-providing-event-bus>
           `,
-                directives: [
-                  GrandParentProvidingEventBus,
-                  ParentProvidingEventBus,
-                  ChildConsumingEventBus
-                ]
-              }))
+                              directives: [
+                                GrandParentProvidingEventBus,
+                                ParentProvidingEventBus,
+                                ChildConsumingEventBus
+                              ]
+                            }))
                .createAsync(MyComp)
                .then((rootTC) => {
                  var gpComp = rootTC.componentViewChildren[0];
@@ -1159,16 +1176,17 @@ export function main() {
 
       it("should instantiate bindings lazily",
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-           tcb.overrideView(MyComp, new viewAnn.View({
-                template: `
+           tcb.overrideView(
+                  MyComp, new ViewMetadata({
+                    template: `
               <component-providing-logging-injectable #providing>
                 <directive-consuming-injectable *ng-if="ctxBoolProp">
                 </directive-consuming-injectable>
               </component-providing-logging-injectable>
           `,
-                directives:
-                    [DirectiveConsumingInjectable, ComponentProvidingLoggingInjectable, NgIf]
-              }))
+                    directives:
+                        [DirectiveConsumingInjectable, ComponentProvidingLoggingInjectable, NgIf]
+                  }))
                .createAsync(MyComp)
                .then((rootTC) => {
                  var providing = rootTC.componentViewChildren[0].getLocal("providing");
@@ -1187,11 +1205,11 @@ export function main() {
     describe("corner cases", () => {
       it('should remove script tags from templates',
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-           tcb.overrideView(MyComp, new viewAnn.View({
-                template: `
+           tcb.overrideView(MyComp, new ViewMetadata({
+                              template: `
             <script>alert("Ooops");</script>
             <div>before<script>alert("Ooops");</script><span>inside</span>after</div>`
-              }))
+                            }))
                .createAsync(MyComp)
                .then((rootTC) => {
                  expect(DOM.querySelectorAll(rootTC.nativeElement, 'script').length).toEqual(0);
@@ -1204,7 +1222,7 @@ export function main() {
       it('should report a meaningful error when a directive is missing annotation',
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
            tcb = tcb.overrideView(MyComp,
-                                  new viewAnn.View({directives: [SomeDirectiveMissingAnnotation]}));
+                                  new ViewMetadata({directives: [SomeDirectiveMissingAnnotation]}));
 
            PromiseWrapper.catchError(tcb.createAsync(MyComp), (e) => {
              expect(e.message).toEqual(
@@ -1227,7 +1245,7 @@ export function main() {
       it('should report a meaningful error when a directive is null',
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
 
-           tcb = tcb.overrideView(MyComp, new viewAnn.View({directives: [[null]]}));
+           tcb = tcb.overrideView(MyComp, new ViewMetadata({directives: [[null]]}));
 
            PromiseWrapper.catchError(tcb.createAsync(MyComp), (e) => {
              expect(e.message).toEqual(
@@ -1240,10 +1258,11 @@ export function main() {
       it('should provide an error context when an error happens in DI',
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
 
-           tcb = tcb.overrideView(MyComp, new viewAnn.View({
-             directives: [DirectiveThrowingAnError],
-             template: `<directive-throwing-error></<directive-throwing-error>`
-           }));
+           tcb =
+               tcb.overrideView(MyComp, new ViewMetadata({
+                                  directives: [DirectiveThrowingAnError],
+                                  template: `<directive-throwing-error></<directive-throwing-error>`
+                                }));
 
            PromiseWrapper.catchError(tcb.createAsync(MyComp), (e) => {
              var c = e.context;
@@ -1259,7 +1278,7 @@ export function main() {
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
 
            tcb = tcb.overrideView(
-               MyComp, new viewAnn.View({template: `<input [value]="one.two.three" #local>`}));
+               MyComp, new ViewMetadata({template: `<input [value]="one.two.three" #local>`}));
 
            tcb.createAsync(MyComp).then(rootTC => {
              try {
@@ -1282,7 +1301,7 @@ export function main() {
       it('should provide an error context when an error happens in change detection (text node)',
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
 
-           tcb = tcb.overrideView(MyComp, new viewAnn.View({template: `{{one.two.three}}`}));
+           tcb = tcb.overrideView(MyComp, new ViewMetadata({template: `{{one.two.three}}`}));
 
            tcb.createAsync(MyComp).then(rootTC => {
              try {
@@ -1302,10 +1321,11 @@ export function main() {
         it('should provide an error context when an error happens in an event handler',
            inject([TestComponentBuilder], fakeAsync((tcb: TestComponentBuilder) => {
 
-                    tcb = tcb.overrideView(MyComp, new viewAnn.View({
-                      template: `<span emitter listener (event)="throwError()" #local></span>`,
-                      directives: [DirectiveEmitingEvent, DirectiveListeningEvent]
-                    }));
+                    tcb = tcb.overrideView(
+                        MyComp, new ViewMetadata({
+                          template: `<span emitter listener (event)="throwError()" #local></span>`,
+                          directives: [DirectiveEmitingEvent, DirectiveListeningEvent]
+                        }));
 
                     var rootTC;
                     tcb.createAsync(MyComp).then(root => { rootTC = root; });
@@ -1337,7 +1357,7 @@ export function main() {
 
              var undefinedValue;
 
-             tcb = tcb.overrideView(MyComp, new viewAnn.View({directives: [undefinedValue]}));
+             tcb = tcb.overrideView(MyComp, new ViewMetadata({directives: [undefinedValue]}));
 
              PromiseWrapper.catchError(tcb.createAsync(MyComp), (e) => {
                expect(e.message).toEqual(
@@ -1352,7 +1372,7 @@ export function main() {
          inject([TestComponentBuilder, AsyncTestCompleter],
                 (tcb: TestComponentBuilder, async) => {
 
-                    tcb.overrideView(MyComp, new viewAnn.View({template: '{{a.b}}'}))
+                    tcb.overrideView(MyComp, new ViewMetadata({template: '{{a.b}}'}))
 
                         .createAsync(MyComp)
                         .then((rootTC) => {
@@ -1366,7 +1386,7 @@ export function main() {
              [TestComponentBuilder, AsyncTestCompleter],
              (tcb: TestComponentBuilder, async) => {
 
-                 tcb.overrideView(MyComp, new viewAnn.View({template: '<div [title]="a.b"></div>'}))
+                 tcb.overrideView(MyComp, new ViewMetadata({template: '<div [title]="a.b"></div>'}))
 
                      .createAsync(MyComp)
                      .then((rootTC) => {
@@ -1379,10 +1399,10 @@ export function main() {
          inject([TestComponentBuilder, AsyncTestCompleter],
                 (tcb: TestComponentBuilder, async) => {
 
-                    tcb.overrideView(MyComp, new viewAnn.View({
-                         template: '<child-cmp [title]="a.b"></child-cmp>',
-                         directives: [ChildComp]
-                       }))
+                    tcb.overrideView(MyComp, new ViewMetadata({
+                                       template: '<child-cmp [title]="a.b"></child-cmp>',
+                                       directives: [ChildComp]
+                                     }))
 
                         .createAsync(MyComp)
                         .then((rootTC) => {
@@ -1394,10 +1414,10 @@ export function main() {
 
     it('should support imperative views',
        inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-         tcb.overrideView(MyComp, new viewAnn.View({
-              template: '<simple-imp-cmp></simple-imp-cmp>',
-              directives: [SimpleImperativeViewComponent]
-            }))
+         tcb.overrideView(MyComp, new ViewMetadata({
+                            template: '<simple-imp-cmp></simple-imp-cmp>',
+                            directives: [SimpleImperativeViewComponent]
+                          }))
              .createAsync(MyComp)
              .then((rootTC) => {
                expect(rootTC.nativeElement).toHaveText('hello imp view');
@@ -1406,29 +1426,29 @@ export function main() {
        }));
 
     it('should support moving embedded views around',
-       inject([TestComponentBuilder, AsyncTestCompleter, ANCHOR_ELEMENT],
-              (tcb, async, anchorElement) => {
-                tcb.overrideView(MyComp, new viewAnn.View({
-                     template: '<div><div *some-impvp="ctxBoolProp">hello</div></div>',
-                     directives: [SomeImperativeViewport]
-                   }))
-                    .createAsync(MyComp)
-                    .then((rootTC) => {
-                      rootTC.detectChanges();
-                      expect(anchorElement).toHaveText('');
+       inject([TestComponentBuilder, AsyncTestCompleter, ANCHOR_ELEMENT], (tcb, async,
+                                                                           anchorElement) => {
+         tcb.overrideView(MyComp, new ViewMetadata({
+                            template: '<div><div *some-impvp="ctxBoolProp">hello</div></div>',
+                            directives: [SomeImperativeViewport]
+                          }))
+             .createAsync(MyComp)
+             .then((rootTC) => {
+               rootTC.detectChanges();
+               expect(anchorElement).toHaveText('');
 
-                      rootTC.componentInstance.ctxBoolProp = true;
-                      rootTC.detectChanges();
+               rootTC.componentInstance.ctxBoolProp = true;
+               rootTC.detectChanges();
 
-                      expect(anchorElement).toHaveText('hello');
+               expect(anchorElement).toHaveText('hello');
 
-                      rootTC.componentInstance.ctxBoolProp = false;
-                      rootTC.detectChanges();
-                      expect(rootTC.nativeElement).toHaveText('');
+               rootTC.componentInstance.ctxBoolProp = false;
+               rootTC.detectChanges();
+               expect(rootTC.nativeElement).toHaveText('');
 
-                      async.done();
-                    });
-              }));
+               async.done();
+             });
+       }));
 
     describe('Property bindings', () => {
       if (!IS_DART) {
@@ -1437,7 +1457,7 @@ export function main() {
                                                                async) => {
              tcb =
                  tcb.overrideView(MyComp,
-                                  new viewAnn.View({template: '<div unknown="{{ctxProp}}"></div>'}))
+                                  new ViewMetadata({template: '<div unknown="{{ctxProp}}"></div>'}))
 
                      PromiseWrapper.catchError(tcb.createAsync(MyComp), (e) => {
                        expect(e.message).toEqual(
@@ -1452,7 +1472,7 @@ export function main() {
                                                                async) => {
              tcb.overrideView(
                     MyComp,
-                    new viewAnn.View(
+                    new ViewMetadata(
                         {template: '<div my-dir [elprop]="ctxProp"></div>', directives: [MyDir]}))
                  .createAsync(MyComp)
                  .then((val) => { async.done(); });
@@ -1461,10 +1481,10 @@ export function main() {
 
       it('should not be created when there is a directive with the same property',
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-           tcb.overrideView(MyComp, new viewAnn.View({
-                template: '<span [title]="ctxProp"></span>',
-                directives: [DirectiveWithTitle]
-              }))
+           tcb.overrideView(MyComp, new ViewMetadata({
+                              template: '<span [title]="ctxProp"></span>',
+                              directives: [DirectiveWithTitle]
+                            }))
                .createAsync(MyComp)
                .then((rootTC) => {
                  rootTC.componentInstance.ctxProp = "TITLE";
@@ -1480,10 +1500,10 @@ export function main() {
 
       it('should work when a directive uses hostProperty to update the DOM element',
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-           tcb.overrideView(MyComp, new viewAnn.View({
-                template: '<span [title]="ctxProp"></span>',
-                directives: [DirectiveWithTitleAndHostProperty]
-              }))
+           tcb.overrideView(MyComp, new ViewMetadata({
+                              template: '<span [title]="ctxProp"></span>',
+                              directives: [DirectiveWithTitleAndHostProperty]
+                            }))
                .createAsync(MyComp)
                .then((rootTC) => {
                  rootTC.componentInstance.ctxProp = "TITLE";
@@ -1504,7 +1524,7 @@ export function main() {
         return inject(
             [TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
               tcb.overrideView(MyComp,
-                               new viewAnn.View({template: `<!--${mode}--><div>{{ctxProp}}</div>`}))
+                               new ViewMetadata({template: `<!--${mode}--><div>{{ctxProp}}</div>`}))
                   .createAsync(MyComp)
                   .then((rootTC) => {
                     rootTC.componentInstance.ctxProp = 'Hello World!';
@@ -1526,7 +1546,7 @@ export function main() {
     // - https://github.com/angular/angular/commit/81f3f32
     xdescribe('Missing directive checks', () => {
       function expectCompileError(tcb, inlineTpl, errMessage, done) {
-        tcb = tcb.overrideView(MyComp, new viewAnn.View({template: inlineTpl}));
+        tcb = tcb.overrideView(MyComp, new ViewMetadata({template: inlineTpl}));
         PromiseWrapper.then(
             tcb.createAsync(MyComp),
             (value) => {
diff --git a/modules/angular2/test/core/compiler/projection_integration_spec.ts b/modules/angular2/test/core/compiler/projection_integration_spec.ts
index 87164e46d7..b93fdc33b1 100644
--- a/modules/angular2/test/core/compiler/projection_integration_spec.ts
+++ b/modules/angular2/test/core/compiler/projection_integration_spec.ts
@@ -23,8 +23,6 @@ import {
 
 import {DOM} from 'angular2/src/dom/dom_adapter';
 
-import * as viewAnn from 'angular2/src/core/annotations_impl/view';
-
 import {
   Component,
   Directive,
@@ -43,12 +41,12 @@ export function main() {
   describe('projection', () => {
     it('should support simple components',
        inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-         tcb.overrideView(MainComp, new viewAnn.View({
-              template: '<simple>' +
-                            '<div>A</div>' +
-                            '</simple>',
-              directives: [Simple]
-            }))
+         tcb.overrideView(MainComp, new View({
+                            template: '<simple>' +
+                                          '<div>A</div>' +
+                                          '</simple>',
+                            directives: [Simple]
+                          }))
              .createAsync(MainComp)
              .then((main) => {
                expect(main.nativeElement).toHaveText('SIMPLE(A)');
@@ -58,12 +56,12 @@ export function main() {
 
     it('should support simple components with text interpolation as direct children',
        inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-         tcb.overrideView(MainComp, new viewAnn.View({
-              template: '{{\'START(\'}}<simple>' +
-                            '{{text}}' +
-                            '</simple>{{\')END\'}}',
-              directives: [Simple]
-            }))
+         tcb.overrideView(MainComp, new View({
+                            template: '{{\'START(\'}}<simple>' +
+                                          '{{text}}' +
+                                          '</simple>{{\')END\'}}',
+                            directives: [Simple]
+                          }))
              .createAsync(MainComp)
              .then((main) => {
 
@@ -78,11 +76,10 @@ export function main() {
        inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
          tcb.overrideView(
                 Simple,
-                new viewAnn.View(
+                new View(
                     {template: 'SIMPLE(<div><ng-content></ng-content></div>)', directives: []}))
-             .overrideView(
-                 MainComp,
-                 new viewAnn.View({template: '<simple>{{text}}</simple>', directives: [Simple]}))
+             .overrideView(MainComp,
+                           new View({template: '<simple>{{text}}</simple>', directives: [Simple]}))
              .createAsync(MainComp)
              .then((main) => {
 
@@ -96,13 +93,14 @@ export function main() {
 
     it('should support projecting text interpolation to a non bound element with other bound elements after it',
        inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-         tcb.overrideView(Simple, new viewAnn.View({
-              template: 'SIMPLE(<div><ng-content></ng-content></div><div [tab-index]="0">EL</div>)',
-              directives: []
-            }))
-             .overrideView(
-                 MainComp,
-                 new viewAnn.View({template: '<simple>{{text}}</simple>', directives: [Simple]}))
+         tcb.overrideView(
+                Simple, new View({
+                  template:
+                      'SIMPLE(<div><ng-content></ng-content></div><div [tab-index]="0">EL</div>)',
+                  directives: []
+                }))
+             .overrideView(MainComp,
+                           new View({template: '<simple>{{text}}</simple>', directives: [Simple]}))
              .createAsync(MainComp)
              .then((main) => {
 
@@ -115,8 +113,7 @@ export function main() {
 
     it('should not show the light dom even if there is no content tag',
        inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-         tcb.overrideView(MainComp,
-                          new viewAnn.View({template: '<empty>A</empty>', directives: [Empty]}))
+         tcb.overrideView(MainComp, new View({template: '<empty>A</empty>', directives: [Empty]}))
              .createAsync(MainComp)
              .then((main) => {
 
@@ -127,14 +124,14 @@ export function main() {
 
     it('should support multiple content tags',
        inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-         tcb.overrideView(MainComp, new viewAnn.View({
-              template: '<multiple-content-tags>' +
-                            '<div>B</div>' +
-                            '<div>C</div>' +
-                            '<div class="left">A</div>' +
-                            '</multiple-content-tags>',
-              directives: [MultipleContentTagsComponent]
-            }))
+         tcb.overrideView(MainComp, new View({
+                            template: '<multiple-content-tags>' +
+                                          '<div>B</div>' +
+                                          '<div>C</div>' +
+                                          '<div class="left">A</div>' +
+                                          '</multiple-content-tags>',
+                            directives: [MultipleContentTagsComponent]
+                          }))
              .createAsync(MainComp)
              .then((main) => {
 
@@ -145,13 +142,13 @@ export function main() {
 
     it('should redistribute only direct children',
        inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-         tcb.overrideView(MainComp, new viewAnn.View({
-              template: '<multiple-content-tags>' +
-                            '<div>B<div class="left">A</div></div>' +
-                            '<div>C</div>' +
-                            '</multiple-content-tags>',
-              directives: [MultipleContentTagsComponent]
-            }))
+         tcb.overrideView(MainComp, new View({
+                            template: '<multiple-content-tags>' +
+                                          '<div>B<div class="left">A</div></div>' +
+                                          '<div>C</div>' +
+                                          '</multiple-content-tags>',
+                            directives: [MultipleContentTagsComponent]
+                          }))
              .createAsync(MainComp)
              .then((main) => {
 
@@ -162,13 +159,13 @@ export function main() {
 
     it("should redistribute direct child viewcontainers when the light dom changes",
        inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-         tcb.overrideView(MainComp, new viewAnn.View({
-              template: '<multiple-content-tags>' +
-                            '<template manual class="left"><div>A1</div></template>' +
-                            '<div>B</div>' +
-                            '</multiple-content-tags>',
-              directives: [MultipleContentTagsComponent, ManualViewportDirective]
-            }))
+         tcb.overrideView(MainComp, new View({
+                            template: '<multiple-content-tags>' +
+                                          '<template manual class="left"><div>A1</div></template>' +
+                                          '<div>B</div>' +
+                                          '</multiple-content-tags>',
+                            directives: [MultipleContentTagsComponent, ManualViewportDirective]
+                          }))
              .createAsync(MainComp)
              .then((main) => {
 
@@ -188,13 +185,13 @@ export function main() {
 
     it("should support nested components",
        inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-         tcb.overrideView(MainComp, new viewAnn.View({
-              template: '<outer-with-indirect-nested>' +
-                            '<div>A</div>' +
-                            '<div>B</div>' +
-                            '</outer-with-indirect-nested>',
-              directives: [OuterWithIndirectNestedComponent]
-            }))
+         tcb.overrideView(MainComp, new View({
+                            template: '<outer-with-indirect-nested>' +
+                                          '<div>A</div>' +
+                                          '<div>B</div>' +
+                                          '</outer-with-indirect-nested>',
+                            directives: [OuterWithIndirectNestedComponent]
+                          }))
              .createAsync(MainComp)
              .then((main) => {
 
@@ -205,14 +202,14 @@ export function main() {
 
     it("should support nesting with content being direct child of a nested component",
        inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-         tcb.overrideView(MainComp, new viewAnn.View({
-              template: '<outer>' +
-                            '<template manual class="left"><div>A</div></template>' +
-                            '<div>B</div>' +
-                            '<div>C</div>' +
-                            '</outer>',
-              directives: [OuterComponent, ManualViewportDirective],
-            }))
+         tcb.overrideView(MainComp, new View({
+                            template: '<outer>' +
+                                          '<template manual class="left"><div>A</div></template>' +
+                                          '<div>B</div>' +
+                                          '<div>C</div>' +
+                                          '</outer>',
+                            directives: [OuterComponent, ManualViewportDirective],
+                          }))
              .createAsync(MainComp)
              .then((main) => {
 
@@ -229,14 +226,14 @@ export function main() {
 
     it('should redistribute when the shadow dom changes',
        inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-         tcb.overrideView(MainComp, new viewAnn.View({
-              template: '<conditional-content>' +
-                            '<div class="left">A</div>' +
-                            '<div>B</div>' +
-                            '<div>C</div>' +
-                            '</conditional-content>',
-              directives: [ConditionalContentComponent]
-            }))
+         tcb.overrideView(MainComp, new View({
+                            template: '<conditional-content>' +
+                                          '<div class="left">A</div>' +
+                                          '<div>B</div>' +
+                                          '<div>C</div>' +
+                                          '</conditional-content>',
+                            directives: [ConditionalContentComponent]
+                          }))
              .createAsync(MainComp)
              .then((main) => {
 
@@ -263,8 +260,7 @@ export function main() {
 
          tcb.overrideView(
                 MainComp,
-                new viewAnn.View(
-                    {template: '<simple string-prop="text"></simple>', directives: [Simple]}))
+                new View({template: '<simple string-prop="text"></simple>', directives: [Simple]}))
              .overrideTemplate(Simple, '<ng-content></ng-content><p>P,</p>{{stringProp}}')
              .createAsync(MainComp)
              .then((main) => {
@@ -284,8 +280,7 @@ export function main() {
 
          tcb.overrideView(
                 MainComp,
-                new viewAnn.View(
-                    {template: '<simple string-prop="text"></simple>', directives: [Simple]}))
+                new View({template: '<simple string-prop="text"></simple>', directives: [Simple]}))
              .overrideTemplate(Simple, '<style></style><p>P,</p>{{stringProp}}')
              .createAsync(MainComp)
              .then((main) => {
@@ -298,13 +293,13 @@ export function main() {
 
     it('should support moving non projected light dom around',
        inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-         tcb.overrideView(MainComp, new viewAnn.View({
-              template: '<empty>' +
-                            '  <template manual><div>A</div></template>' +
-                            '</empty>' +
-                            'START(<div project></div>)END',
-              directives: [Empty, ProjectDirective, ManualViewportDirective],
-            }))
+         tcb.overrideView(MainComp, new View({
+                            template: '<empty>' +
+                                          '  <template manual><div>A</div></template>' +
+                                          '</empty>' +
+                                          'START(<div project></div>)END',
+                            directives: [Empty, ProjectDirective, ManualViewportDirective],
+                          }))
              .createAsync(MainComp)
              .then((main) => {
 
@@ -323,11 +318,11 @@ export function main() {
 
     it('should support moving projected light dom around',
        inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-         tcb.overrideView(MainComp, new viewAnn.View({
-              template: '<simple><template manual><div>A</div></template></simple>' +
-                            'START(<div project></div>)END',
-              directives: [Simple, ProjectDirective, ManualViewportDirective],
-            }))
+         tcb.overrideView(MainComp, new View({
+                            template: '<simple><template manual><div>A</div></template></simple>' +
+                                          'START(<div project></div>)END',
+                            directives: [Simple, ProjectDirective, ManualViewportDirective],
+                          }))
              .createAsync(MainComp)
              .then((main) => {
 
@@ -346,15 +341,16 @@ export function main() {
 
     it('should support moving ng-content around',
        inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-         tcb.overrideView(MainComp, new viewAnn.View({
-              template: '<conditional-content>' +
-                            '<div class="left">A</div>' +
-                            '<div>B</div>' +
-                            '</conditional-content>' +
-                            'START(<div project></div>)END',
-              directives:
-                  [ConditionalContentComponent, ProjectDirective, ManualViewportDirective]
-            }))
+         tcb.overrideView(
+                MainComp, new View({
+                  template: '<conditional-content>' +
+                                '<div class="left">A</div>' +
+                                '<div>B</div>' +
+                                '</conditional-content>' +
+                                'START(<div project></div>)END',
+                  directives:
+                      [ConditionalContentComponent, ProjectDirective, ManualViewportDirective]
+                }))
              .createAsync(MainComp)
              .then((main) => {
 
@@ -382,8 +378,7 @@ export function main() {
     // the presence of ng-content elements!
     it('should still allow to implement a recursive trees',
        inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-         tcb.overrideView(MainComp,
-                          new viewAnn.View({template: '<tree></tree>', directives: [Tree]}))
+         tcb.overrideView(MainComp, new View({template: '<tree></tree>', directives: [Tree]}))
              .createAsync(MainComp)
              .then((main) => {
 
@@ -402,12 +397,12 @@ export function main() {
     if (DOM.supportsNativeShadowDOM()) {
       it('should support native content projection',
          inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-           tcb.overrideView(MainComp, new viewAnn.View({
-                template: '<simple-native>' +
-                              '<div>A</div>' +
-                              '</simple-native>',
-                directives: [SimpleNative]
-              }))
+           tcb.overrideView(MainComp, new View({
+                              template: '<simple-native>' +
+                                            '<div>A</div>' +
+                                            '</simple-native>',
+                              directives: [SimpleNative]
+                            }))
                .createAsync(MainComp)
                .then((main) => {
 
@@ -422,10 +417,10 @@ export function main() {
         it('should support nested conditionals that contain ng-contents',
            inject(
                [TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
-                 tcb.overrideView(MainComp, new viewAnn.View({
-                      template: `<conditional-text>a</conditional-text>`,
-                      directives: [ConditionalTextComponent]
-                    }))
+                 tcb.overrideView(MainComp, new View({
+                                    template: `<conditional-text>a</conditional-text>`,
+                                    directives: [ConditionalTextComponent]
+                                  }))
                      .createAsync(MainComp)
                      .then((main) => {
                        expect(main.nativeElement).toHaveText('MAIN()');
diff --git a/modules/angular2/test/core/compiler/proto_view_factory_spec.ts b/modules/angular2/test/core/compiler/proto_view_factory_spec.ts
index 14e9ac3d93..b302dfb8b0 100644
--- a/modules/angular2/test/core/compiler/proto_view_factory_spec.ts
+++ b/modules/angular2/test/core/compiler/proto_view_factory_spec.ts
@@ -29,11 +29,18 @@ import {
   createDirectiveVariableBindings,
   createVariableLocations
 } from 'angular2/src/core/compiler/proto_view_factory';
-import {Component, Directive} from 'angular2/annotations';
+import {Component, Directive} from 'angular2/metadata';
 import {Key} from 'angular2/di';
 import {DirectiveResolver} from 'angular2/src/core/compiler/directive_resolver';
 import {DirectiveBinding} from 'angular2/src/core/compiler/element_injector';
-import * as renderApi from 'angular2/src/render/api';
+import {
+  RenderElementBinder,
+  EventBinding,
+  RenderDirectiveMetadata,
+  ViewType,
+  ProtoViewDto,
+  DirectiveBinder
+} from 'angular2/src/render/api';
 
 export function main() {
   // TODO(tbosch): add missing tests
@@ -81,15 +88,15 @@ export function main() {
     describe("createDirectiveVariableBindings", () => {
       it("should calculate directive variable bindings", () => {
         var dvbs = createDirectiveVariableBindings(
-            new renderApi.ElementBinder({
+            new RenderElementBinder({
               variableBindings:
                   MapWrapper.createFromStringMap<string>({"exportName": "templateName"})
             }),
             [
               directiveBinding(
-                  {metadata: renderApi.DirectiveMetadata.create({exportAs: 'exportName'})}),
+                  {metadata: RenderDirectiveMetadata.create({exportAs: 'exportName'})}),
               directiveBinding(
-                  {metadata: renderApi.DirectiveMetadata.create({exportAs: 'otherName'})})
+                  {metadata: RenderDirectiveMetadata.create({exportAs: 'otherName'})})
             ]);
 
         expect(dvbs).toEqual(MapWrapper.createFromStringMap<number>({"templateName": 0}));
@@ -97,14 +104,14 @@ export function main() {
 
       it("should set exportAs to $implicit for component with exportAs = null", () => {
         var dvbs = createDirectiveVariableBindings(
-            new renderApi.ElementBinder({
+            new RenderElementBinder({
               variableBindings:
                   MapWrapper.createFromStringMap<string>({"$implicit": "templateName"})
             }),
             [
               directiveBinding({
-                metadata: renderApi.DirectiveMetadata.create(
-                    {exportAs: null, type: renderApi.DirectiveMetadata.COMPONENT_TYPE})
+                metadata: RenderDirectiveMetadata.create(
+                    {exportAs: null, type: RenderDirectiveMetadata.COMPONENT_TYPE})
               })
             ]);
 
@@ -114,13 +121,13 @@ export function main() {
       it("should throw we no directive exported with this name", () => {
         expect(() => {
           createDirectiveVariableBindings(
-              new renderApi.ElementBinder({
+              new RenderElementBinder({
                 variableBindings:
                     MapWrapper.createFromStringMap<string>({"someInvalidName": "templateName"})
               }),
               [
                 directiveBinding(
-                    {metadata: renderApi.DirectiveMetadata.create({exportAs: 'exportName'})})
+                    {metadata: RenderDirectiveMetadata.create({exportAs: 'exportName'})})
               ]);
         }).toThrowError(new RegExp("Cannot find directive with exportAs = 'someInvalidName'"));
       });
@@ -128,28 +135,26 @@ export function main() {
       it("should throw when binding to a name exported by two directives", () => {
         expect(() => {
           createDirectiveVariableBindings(
-              new renderApi.ElementBinder({
+              new RenderElementBinder({
                 variableBindings:
                     MapWrapper.createFromStringMap<string>({"exportName": "templateName"})
               }),
               [
                 directiveBinding(
-                    {metadata: renderApi.DirectiveMetadata.create({exportAs: 'exportName'})}),
+                    {metadata: RenderDirectiveMetadata.create({exportAs: 'exportName'})}),
                 directiveBinding(
-                    {metadata: renderApi.DirectiveMetadata.create({exportAs: 'exportName'})})
+                    {metadata: RenderDirectiveMetadata.create({exportAs: 'exportName'})})
               ]);
         }).toThrowError(new RegExp("More than one directive have exportAs = 'exportName'"));
       });
 
       it("should not throw when not binding to a name exported by two directives", () => {
         expect(() => {
-          createDirectiveVariableBindings(
-              new renderApi.ElementBinder({variableBindings: new Map()}), [
-                directiveBinding(
-                    {metadata: renderApi.DirectiveMetadata.create({exportAs: 'exportName'})}),
-                directiveBinding(
-                    {metadata: renderApi.DirectiveMetadata.create({exportAs: 'exportName'})})
-              ]);
+          createDirectiveVariableBindings(new RenderElementBinder({variableBindings: new Map()}), [
+            directiveBinding({metadata: RenderDirectiveMetadata.create({exportAs: 'exportName'})}),
+            directiveBinding(
+                {metadata: RenderDirectiveMetadata.create({exportAs: 'exportName'})})
+          ]);
         }).not.toThrow();
       });
     });
@@ -157,9 +162,9 @@ export function main() {
     describe('createVariableLocations', () => {
       it('should merge the names in the template for all ElementBinders', () => {
         expect(createVariableLocations([
-          new renderApi.ElementBinder(
+          new RenderElementBinder(
               {variableBindings: MapWrapper.createFromStringMap<string>({"x": "a"})}),
-          new renderApi.ElementBinder(
+          new RenderElementBinder(
               {variableBindings: MapWrapper.createFromStringMap<string>({"y": "b"})})
 
         ])).toEqual(MapWrapper.createFromStringMap<number>({'a': 0, 'b': 1}));
@@ -175,10 +180,10 @@ export function main() {
         it("should return template event records", () => {
           var rec = creator.getEventBindingRecords(
               [
-                new renderApi.ElementBinder(
-                    {eventBindings: [new renderApi.EventBinding("a", null)], directives: []}),
-                new renderApi.ElementBinder(
-                    {eventBindings: [new renderApi.EventBinding("b", null)], directives: []})
+                new RenderElementBinder(
+                    {eventBindings: [new EventBinding("a", null)], directives: []}),
+                new RenderElementBinder(
+                    {eventBindings: [new EventBinding("b", null)], directives: []})
               ],
               []);
 
@@ -191,17 +196,15 @@ export function main() {
         it('should return host event records', () => {
           var rec = creator.getEventBindingRecords(
               [
-                new renderApi.ElementBinder({
+                new RenderElementBinder({
                   eventBindings: [],
                   directives: [
-                    new renderApi.DirectiveBinder({
-                      directiveIndex: 0,
-                      eventBindings: [new renderApi.EventBinding("a", null)]
-                    })
+                    new DirectiveBinder(
+                        {directiveIndex: 0, eventBindings: [new EventBinding("a", null)]})
                   ]
                 })
               ],
-              [renderApi.DirectiveMetadata.create({id: 'some-id'})]);
+              [RenderDirectiveMetadata.create({id: 'some-id'})]);
 
           expect(rec.length).toEqual(1);
           expect(rec[0].eventName).toEqual("a");
@@ -216,10 +219,10 @@ function directiveBinding({metadata}: {metadata?: any} = {}) {
   return new DirectiveBinding(Key.get("dummy"), null, [], [], [], metadata);
 }
 
-function createRenderProtoView(elementBinders = null, type: renderApi.ViewType = null,
+function createRenderProtoView(elementBinders = null, type: ViewType = null,
                                variableBindings = null) {
   if (isBlank(type)) {
-    type = renderApi.ViewType.COMPONENT;
+    type = ViewType.COMPONENT;
   }
   if (isBlank(elementBinders)) {
     elementBinders = [];
@@ -227,7 +230,7 @@ function createRenderProtoView(elementBinders = null, type: renderApi.ViewType =
   if (isBlank(variableBindings)) {
     variableBindings = new Map();
   }
-  return new renderApi.ProtoViewDto({
+  return new ProtoViewDto({
     elementBinders: elementBinders,
     type: type,
     variableBindings: variableBindings,
@@ -237,12 +240,12 @@ function createRenderProtoView(elementBinders = null, type: renderApi.ViewType =
 }
 
 function createRenderComponentElementBinder(directiveIndex) {
-  return new renderApi.ElementBinder(
-      {directives: [new renderApi.DirectiveBinder({directiveIndex: directiveIndex})]});
+  return new RenderElementBinder(
+      {directives: [new DirectiveBinder({directiveIndex: directiveIndex})]});
 }
 
 function createRenderViewportElementBinder(nestedProtoView) {
-  return new renderApi.ElementBinder({nestedProtoView: nestedProtoView});
+  return new RenderElementBinder({nestedProtoView: nestedProtoView});
 }
 
 @proxy
diff --git a/modules/angular2/test/core/compiler/query_integration_spec.ts b/modules/angular2/test/core/compiler/query_integration_spec.ts
index 4335bdc932..ed7720b2e1 100644
--- a/modules/angular2/test/core/compiler/query_integration_spec.ts
+++ b/modules/angular2/test/core/compiler/query_integration_spec.ts
@@ -17,7 +17,7 @@ import {
 
 import {Injectable, Optional} from 'angular2/di';
 import {QueryList, TemplateRef} from 'angular2/core';
-import {Query, ViewQuery, Component, Directive, View} from 'angular2/annotations';
+import {Query, ViewQuery, Component, Directive, View} from 'angular2/metadata';
 
 import {NgIf, NgFor} from 'angular2/angular2';
 
diff --git a/modules/angular2/test/core/compiler/view_manager_utils_spec.ts b/modules/angular2/test/core/compiler/view_manager_utils_spec.ts
index e7a9531451..d00a8163f7 100644
--- a/modules/angular2/test/core/compiler/view_manager_utils_spec.ts
+++ b/modules/angular2/test/core/compiler/view_manager_utils_spec.ts
@@ -32,7 +32,7 @@ import {
   ProtoElementInjector
 } from 'angular2/src/core/compiler/element_injector';
 import {DirectiveResolver} from 'angular2/src/core/compiler/directive_resolver';
-import {Component} from 'angular2/annotations';
+import {Component} from 'angular2/metadata';
 import {AppViewManagerUtils} from 'angular2/src/core/compiler/view_manager_utils';
 import {
   RenderProtoViewMergeMapping,
diff --git a/modules/angular2/test/core/directive_lifecycle_integration_spec.ts b/modules/angular2/test/core/directive_lifecycle_integration_spec.ts
index 7d1884b352..f8056a5b64 100644
--- a/modules/angular2/test/core/directive_lifecycle_integration_spec.ts
+++ b/modules/angular2/test/core/directive_lifecycle_integration_spec.ts
@@ -13,7 +13,6 @@ import {
 } from 'angular2/test_lib';
 
 import {Directive, Component, View, LifecycleEvent} from 'angular2/angular2';
-import * as viewAnn from 'angular2/src/core/annotations_impl/view';
 
 export function main() {
   describe('directive lifecycle integration spec', () => {
@@ -22,7 +21,7 @@ export function main() {
        inject([TestComponentBuilder, AsyncTestCompleter], (tcb: TestComponentBuilder, async) => {
          tcb.overrideView(
                 MyComp,
-                new viewAnn.View(
+                new View(
                     {template: '<div [field]="123" lifecycle></div>', directives: [LifecycleDir]}))
              .createAsync(MyComp)
              .then((tc) => {
diff --git a/modules/angular2/test/core/forward_ref_integration_spec.ts b/modules/angular2/test/core/forward_ref_integration_spec.ts
index 72943edc16..353a6b5970 100644
--- a/modules/angular2/test/core/forward_ref_integration_spec.ts
+++ b/modules/angular2/test/core/forward_ref_integration_spec.ts
@@ -11,7 +11,7 @@ import {
   it,
   xit
 } from 'angular2/test_lib';
-import {Directive, Component, Query, View} from 'angular2/annotations';
+import {Directive, Component, Query, View} from 'angular2/metadata';
 import {QueryList, NgFor} from 'angular2/angular2';
 import {forwardRef, resolveForwardRef, bind, Inject} from 'angular2/di';
 import {Type} from 'angular2/src/facade/lang';
diff --git a/modules/angular2/test/core/annotations/decorators_spec.dart b/modules/angular2/test/core/metadata/decorators_spec.dart
similarity index 100%
rename from modules/angular2/test/core/annotations/decorators_spec.dart
rename to modules/angular2/test/core/metadata/decorators_spec.dart
diff --git a/modules/angular2/test/core/annotations/decorators_spec.ts b/modules/angular2/test/core/metadata/decorators_spec.ts
similarity index 100%
rename from modules/angular2/test/core/annotations/decorators_spec.ts
rename to modules/angular2/test/core/metadata/decorators_spec.ts
diff --git a/modules/angular2/test/core/pipes/pipe_binding_spec.ts b/modules/angular2/test/core/pipes/pipe_binding_spec.ts
index 612cbdae68..191a63f366 100644
--- a/modules/angular2/test/core/pipes/pipe_binding_spec.ts
+++ b/modules/angular2/test/core/pipes/pipe_binding_spec.ts
@@ -11,7 +11,7 @@ import {
 } from 'angular2/test_lib';
 
 import {PipeBinding} from 'angular2/src/core/pipes/pipe_binding';
-import {Pipe} from 'angular2/src/core/annotations_impl/annotations';
+import {Pipe} from 'angular2/metadata';
 
 class MyPipe {}
 
diff --git a/modules/angular2/test/core/pipes/pipes_spec.ts b/modules/angular2/test/core/pipes/pipes_spec.ts
index dfb3b1b983..e9792fcaea 100644
--- a/modules/angular2/test/core/pipes/pipes_spec.ts
+++ b/modules/angular2/test/core/pipes/pipes_spec.ts
@@ -14,7 +14,7 @@ import {PipeTransform} from 'angular2/change_detection';
 import {Injector, Inject, bind} from 'angular2/di';
 import {ProtoPipes, Pipes} from 'angular2/src/core/pipes/pipes';
 import {PipeBinding} from 'angular2/src/core/pipes/pipe_binding';
-import {Pipe} from 'angular2/src/core/annotations_impl/annotations';
+import {Pipe} from 'angular2/metadata';
 
 class PipeA implements PipeTransform {
   transform(a, b) {}
diff --git a/modules/angular2/test/debug/debug_element_spec.ts b/modules/angular2/test/debug/debug_element_spec.ts
index d0462c1b83..d4f20ce18c 100644
--- a/modules/angular2/test/debug/debug_element_spec.ts
+++ b/modules/angular2/test/debug/debug_element_spec.ts
@@ -27,7 +27,7 @@ import {
   Directive,
   Component,
   View,
-} from 'angular2/annotations';
+} from 'angular2/metadata';
 
 import {NgFor} from 'angular2/src/directives/ng_for';
 
diff --git a/modules/angular2/test/debug/debug_element_view_listener_spec.ts b/modules/angular2/test/debug/debug_element_view_listener_spec.ts
index 827ac5d83e..6d13619bc8 100644
--- a/modules/angular2/test/debug/debug_element_view_listener_spec.ts
+++ b/modules/angular2/test/debug/debug_element_view_listener_spec.ts
@@ -23,7 +23,7 @@ import {
   Directive,
   Component,
   View,
-} from 'angular2/annotations';
+} from 'angular2/metadata';
 import {IS_DART} from '../platform';
 
 @Component({selector: 'my-comp'})
diff --git a/modules/angular2/test/mock/view_resolver_mock_spec.ts b/modules/angular2/test/mock/view_resolver_mock_spec.ts
index 909881fdb2..b13a7e9e8d 100644
--- a/modules/angular2/test/mock/view_resolver_mock_spec.ts
+++ b/modules/angular2/test/mock/view_resolver_mock_spec.ts
@@ -16,8 +16,6 @@ import {Component, View} from 'angular2/angular2';
 
 import {isBlank} from 'angular2/src/facade/lang';
 
-import * as viewImpl from 'angular2/src/core/annotations_impl/view';
-
 export function main() {
   describe('MockViewResolver', () => {
     var viewResolver;
@@ -32,7 +30,7 @@ export function main() {
       });
 
       it('should allow overriding the @View', () => {
-        viewResolver.setView(SomeComponent, new viewImpl.View({template: 'overridden template'}));
+        viewResolver.setView(SomeComponent, new View({template: 'overridden template'}));
         var view = viewResolver.resolve(SomeComponent);
         expect(view.template).toEqual('overridden template');
         expect(isBlank(view.directives)).toBe(true);
@@ -42,7 +40,7 @@ export function main() {
       it('should not allow overriding a view after it has been resolved', () => {
         viewResolver.resolve(SomeComponent);
         expect(() => {
-          viewResolver.setView(SomeComponent, new viewImpl.View({template: 'overridden template'}));
+          viewResolver.setView(SomeComponent, new View({template: 'overridden template'}));
         })
             .toThrowError(
                 `The component ${stringify(SomeComponent)} has already been compiled, its configuration can not be changed`);
@@ -58,7 +56,7 @@ export function main() {
       });
 
       it('should allow overriding an overriden @View', () => {
-        viewResolver.setView(SomeComponent, new viewImpl.View({template: 'overridden template'}));
+        viewResolver.setView(SomeComponent, new View({template: 'overridden template'}));
         viewResolver.setInlineTemplate(SomeComponent, 'overridden template x 2');
         var view = viewResolver.resolve(SomeComponent);
         expect(view.template).toEqual('overridden template x 2');
@@ -82,7 +80,7 @@ export function main() {
       });
 
       it('should allow overriding a directive from an overriden @View', () => {
-        viewResolver.setView(SomeComponent, new viewImpl.View({directives: [SomeOtherDirective]}));
+        viewResolver.setView(SomeComponent, new View({directives: [SomeOtherDirective]}));
         viewResolver.overrideViewDirective(SomeComponent, SomeOtherDirective, SomeComponent);
         var view = viewResolver.resolve(SomeComponent);
         expect(view.directives.length).toEqual(1);
diff --git a/modules/angular2/test/render/api_spec.ts b/modules/angular2/test/render/api_spec.ts
index 44774ee08d..261c9602f3 100644
--- a/modules/angular2/test/render/api_spec.ts
+++ b/modules/angular2/test/render/api_spec.ts
@@ -1,4 +1,4 @@
-import {DirectiveMetadata} from 'angular2/src/render/api';
+import {RenderDirectiveMetadata} from 'angular2/src/render/api';
 
 import {MapWrapper} from 'angular2/src/facade/collection';
 import {ddescribe, describe, expect, it} from 'angular2/test_lib';
@@ -7,7 +7,7 @@ export function main() {
   describe('Metadata', () => {
     describe('host', () => {
       it('should parse host configuration', () => {
-        var md = DirectiveMetadata.create({
+        var md = RenderDirectiveMetadata.create({
           host: MapWrapper.createFromPairs([
             ['(event)', 'eventVal'],
             ['[prop]', 'propVal'],
diff --git a/modules/angular2/test/render/dom/compiler/compiler_common_tests.ts b/modules/angular2/test/render/dom/compiler/compiler_common_tests.ts
index 5956044ea0..9ade42faba 100644
--- a/modules/angular2/test/render/dom/compiler/compiler_common_tests.ts
+++ b/modules/angular2/test/render/dom/compiler/compiler_common_tests.ts
@@ -19,7 +19,7 @@ import {DomCompiler} from 'angular2/src/render/dom/compiler/compiler';
 import {
   ProtoViewDto,
   ViewDefinition,
-  DirectiveMetadata,
+  RenderDirectiveMetadata,
   ViewType,
   ViewEncapsulation
 } from 'angular2/src/render/api';
@@ -74,8 +74,8 @@ export function runCompilerCommonTests() {
              current.inheritedProtoView.bindVariable('b', 'a');
            });
 
-           var dirMetadata = DirectiveMetadata.create(
-               {id: 'id', selector: 'custom', type: DirectiveMetadata.COMPONENT_TYPE});
+           var dirMetadata = RenderDirectiveMetadata.create(
+               {id: 'id', selector: 'custom', type: RenderDirectiveMetadata.COMPONENT_TYPE});
            compiler.compileHost(dirMetadata)
                .then((protoView) => {
                  expect(DOM.tagName(DOM.firstChild(DOM.content(templateRoot(protoView))))
@@ -93,10 +93,10 @@ export function runCompilerCommonTests() {
              current.inheritedProtoView.bindVariable('b', 'a');
            });
 
-           var dirMetadata = DirectiveMetadata.create({
+           var dirMetadata = RenderDirectiveMetadata.create({
              id: 'id',
              selector: 'marquee.jazzy[size=huge]',
-             type: DirectiveMetadata.COMPONENT_TYPE
+             type: RenderDirectiveMetadata.COMPONENT_TYPE
            });
 
            compiler.compileHost(dirMetadata)
@@ -334,5 +334,5 @@ class FakeViewLoader extends ViewLoader {
   }
 }
 
-var someComponent = DirectiveMetadata.create(
-    {selector: 'some-comp', id: 'someComponent', type: DirectiveMetadata.COMPONENT_TYPE});
+var someComponent = RenderDirectiveMetadata.create(
+    {selector: 'some-comp', id: 'someComponent', type: RenderDirectiveMetadata.COMPONENT_TYPE});
diff --git a/modules/angular2/test/render/dom/compiler/directive_parser_spec.ts b/modules/angular2/test/render/dom/compiler/directive_parser_spec.ts
index 6b7d3669a0..a7b1533f00 100644
--- a/modules/angular2/test/render/dom/compiler/directive_parser_spec.ts
+++ b/modules/angular2/test/render/dom/compiler/directive_parser_spec.ts
@@ -4,7 +4,7 @@ import {ListWrapper, MapWrapper, StringMapWrapper} from 'angular2/src/facade/col
 import {DOM} from 'angular2/src/dom/dom_adapter';
 import {DirectiveParser} from 'angular2/src/render/dom/compiler/directive_parser';
 import {CompilePipeline} from 'angular2/src/render/dom/compiler/compile_pipeline';
-import {ViewDefinition, DirectiveMetadata, ViewType} from 'angular2/src/render/api';
+import {ViewDefinition, RenderDirectiveMetadata, ViewType} from 'angular2/src/render/api';
 import {Lexer, Parser} from 'angular2/src/change_detection/change_detection';
 import {ElementBinderBuilder} from 'angular2/src/render/dom/view/proto_view_builder';
 import {MockStep} from './pipeline_spec';
@@ -191,64 +191,64 @@ export function main() {
   });
 }
 
-var someComponent = DirectiveMetadata.create(
-    {selector: 'some-comp', id: 'someComponent', type: DirectiveMetadata.COMPONENT_TYPE});
+var someComponent = RenderDirectiveMetadata.create(
+    {selector: 'some-comp', id: 'someComponent', type: RenderDirectiveMetadata.COMPONENT_TYPE});
 
-var someComponentDup = DirectiveMetadata.create(
-    {selector: 'some-comp', id: 'someComponentDup', type: DirectiveMetadata.COMPONENT_TYPE});
+var someComponentDup = RenderDirectiveMetadata.create(
+    {selector: 'some-comp', id: 'someComponentDup', type: RenderDirectiveMetadata.COMPONENT_TYPE});
 
-var someComponent2 = DirectiveMetadata.create(
-    {selector: 'some-comp2', id: 'someComponent2', type: DirectiveMetadata.COMPONENT_TYPE});
+var someComponent2 = RenderDirectiveMetadata.create(
+    {selector: 'some-comp2', id: 'someComponent2', type: RenderDirectiveMetadata.COMPONENT_TYPE});
 
-var someDirective = DirectiveMetadata.create(
-    {selector: '[some-decor]', id: 'someDirective', type: DirectiveMetadata.DIRECTIVE_TYPE});
+var someDirective = RenderDirectiveMetadata.create(
+    {selector: '[some-decor]', id: 'someDirective', type: RenderDirectiveMetadata.DIRECTIVE_TYPE});
 
-var someDirectiveIgnoringChildren = DirectiveMetadata.create({
+var someDirectiveIgnoringChildren = RenderDirectiveMetadata.create({
   selector: '[some-decor-ignoring-children]',
   compileChildren: false,
-  type: DirectiveMetadata.DIRECTIVE_TYPE
+  type: RenderDirectiveMetadata.DIRECTIVE_TYPE
 
 });
 
-var decoratorWithMultipleAttrs = DirectiveMetadata.create({
+var decoratorWithMultipleAttrs = RenderDirectiveMetadata.create({
   selector: 'input[type=text][control]',
   id: 'decoratorWithMultipleAttrs',
-  type: DirectiveMetadata.DIRECTIVE_TYPE
+  type: RenderDirectiveMetadata.DIRECTIVE_TYPE
 });
 
-var someDirectiveWithProps = DirectiveMetadata.create({
+var someDirectiveWithProps = RenderDirectiveMetadata.create({
   selector: '[some-decor-props]',
   properties: ['dirProp: elProp'],
   readAttributes: ['some-attr']
 });
 
-var someDirectiveWithHostProperties = DirectiveMetadata.create({
+var someDirectiveWithHostProperties = RenderDirectiveMetadata.create({
   selector: '[some-decor-with-host-props]',
   host: MapWrapper.createFromStringMap<string>({'[hostProp]': 'dirProp'})
 });
 
-var someDirectiveWithInvalidHostProperties = DirectiveMetadata.create({
+var someDirectiveWithInvalidHostProperties = RenderDirectiveMetadata.create({
   selector: '[some-decor-with-invalid-host-props]',
   host: MapWrapper.createFromStringMap<string>({'[hostProp]': 'dirProp + dirProp2'})
 });
 
-var someDirectiveWithHostAttributes = DirectiveMetadata.create({
+var someDirectiveWithHostAttributes = RenderDirectiveMetadata.create({
   selector: '[some-decor-with-host-attrs]',
   host: MapWrapper.createFromStringMap<string>({'attr_name': 'attr_val', 'class': 'foo bar'})
 });
 
-var someDirectiveWithEvents = DirectiveMetadata.create({
+var someDirectiveWithEvents = RenderDirectiveMetadata.create({
   selector: '[some-decor-events]',
   host: MapWrapper.createFromStringMap<string>({'(click)': 'doIt()'})
 });
 
-var someDirectiveWithGlobalEvents = DirectiveMetadata.create({
+var someDirectiveWithGlobalEvents = RenderDirectiveMetadata.create({
   selector: '[some-decor-globalevents]',
   host: MapWrapper.createFromStringMap<string>({'(window:resize)': 'doItGlobal()'})
 });
 
-var componentWithNonElementSelector = DirectiveMetadata.create({
+var componentWithNonElementSelector = RenderDirectiveMetadata.create({
   id: 'componentWithNonElementSelector',
   selector: '[attr]',
-  type: DirectiveMetadata.COMPONENT_TYPE
+  type: RenderDirectiveMetadata.COMPONENT_TYPE
 });
diff --git a/modules/angular2/test/render/dom/convert_spec.ts b/modules/angular2/test/render/dom/convert_spec.ts
index 140e868c94..529d7701cf 100644
--- a/modules/angular2/test/render/dom/convert_spec.ts
+++ b/modules/angular2/test/render/dom/convert_spec.ts
@@ -1,12 +1,12 @@
 import {MapWrapper} from 'angular2/src/facade/collection';
-import {DirectiveMetadata} from 'angular2/src/render/api';
+import {RenderDirectiveMetadata} from 'angular2/src/render/api';
 import {directiveMetadataFromMap, directiveMetadataToMap} from 'angular2/src/render/dom/convert';
 import {ddescribe, describe, expect, it} from 'angular2/test_lib';
 
 export function main() {
   describe('convert', () => {
     it('directiveMetadataToMap', () => {
-      var someComponent = new DirectiveMetadata({
+      var someComponent = new RenderDirectiveMetadata({
         compileChildren: false,
         hostListeners: MapWrapper.createFromPairs([['LKey', 'LVal']]),
         hostProperties: MapWrapper.createFromPairs([['PKey', 'PVal']]),
@@ -16,7 +16,7 @@ export function main() {
         properties: ['propKey: propVal'],
         readAttributes: ['read1', 'read2'],
         selector: 'some-comp',
-        type: DirectiveMetadata.COMPONENT_TYPE,
+        type: RenderDirectiveMetadata.COMPONENT_TYPE,
         exportAs: 'aaa',
         callOnDestroy: true,
         callOnChange: true,
@@ -36,7 +36,7 @@ export function main() {
       expect(map.get('properties')).toEqual(['propKey: propVal']);
       expect(map.get('readAttributes')).toEqual(['read1', 'read2']);
       expect(map.get('selector')).toEqual('some-comp');
-      expect(map.get('type')).toEqual(DirectiveMetadata.COMPONENT_TYPE);
+      expect(map.get('type')).toEqual(RenderDirectiveMetadata.COMPONENT_TYPE);
       expect(map.get('callOnDestroy')).toEqual(true);
       expect(map.get('callOnCheck')).toEqual(true);
       expect(map.get('callOnChange')).toEqual(true);
@@ -58,7 +58,7 @@ export function main() {
         ['properties', ['propKey: propVal']],
         ['readAttributes', ['readTest1', 'readTest2']],
         ['selector', 'testSelector'],
-        ['type', DirectiveMetadata.DIRECTIVE_TYPE],
+        ['type', RenderDirectiveMetadata.DIRECTIVE_TYPE],
         ['exportAs', 'aaa'],
         ['callOnDestroy', true],
         ['callOnCheck', true],
@@ -78,7 +78,7 @@ export function main() {
       expect(meta.properties).toEqual(['propKey: propVal']);
       expect(meta.readAttributes).toEqual(['readTest1', 'readTest2']);
       expect(meta.selector).toEqual('testSelector');
-      expect(meta.type).toEqual(DirectiveMetadata.DIRECTIVE_TYPE);
+      expect(meta.type).toEqual(RenderDirectiveMetadata.DIRECTIVE_TYPE);
       expect(meta.exportAs).toEqual('aaa');
       expect(meta.callOnDestroy).toEqual(true);
       expect(meta.callOnCheck).toEqual(true);
diff --git a/modules/angular2/test/render/dom/dom_renderer_integration_spec.ts b/modules/angular2/test/render/dom/dom_renderer_integration_spec.ts
index 09e134b4e5..b280131eff 100644
--- a/modules/angular2/test/render/dom/dom_renderer_integration_spec.ts
+++ b/modules/angular2/test/render/dom/dom_renderer_integration_spec.ts
@@ -20,7 +20,7 @@ import {DomTestbed, TestRootView, elRef} from './dom_testbed';
 
 import {
   ViewDefinition,
-  DirectiveMetadata,
+  RenderDirectiveMetadata,
   RenderViewRef,
   ViewEncapsulation
 } from 'angular2/src/render/api';
@@ -342,5 +342,5 @@ export function main() {
   });
 }
 
-export var someComponent = DirectiveMetadata.create(
-    {id: 'someComponent', type: DirectiveMetadata.COMPONENT_TYPE, selector: 'some-comp'});
+export var someComponent = RenderDirectiveMetadata.create(
+    {id: 'someComponent', type: RenderDirectiveMetadata.COMPONENT_TYPE, selector: 'some-comp'});
diff --git a/modules/angular2/test/render/dom/dom_testbed.ts b/modules/angular2/test/render/dom/dom_testbed.ts
index 7d6a36979f..533951fb4a 100644
--- a/modules/angular2/test/render/dom/dom_testbed.ts
+++ b/modules/angular2/test/render/dom/dom_testbed.ts
@@ -14,7 +14,7 @@ import {
   ProtoViewDto,
   ViewDefinition,
   RenderEventDispatcher,
-  DirectiveMetadata,
+  RenderDirectiveMetadata,
   RenderElementRef,
   RenderProtoViewMergeMapping,
   RenderProtoViewRef
@@ -76,7 +76,8 @@ export class DomTestbed {
     DOM.appendChild(DOM.querySelector(document, 'body'), this.rootEl);
   }
 
-  compile(host: DirectiveMetadata, componentViews: ViewDefinition[]): Promise<ProtoViewDto[]> {
+  compile(host: RenderDirectiveMetadata,
+          componentViews: ViewDefinition[]): Promise<ProtoViewDto[]> {
     var promises = [this.compiler.compileHost(host)];
     componentViews.forEach(view => promises.push(this.compiler.compile(view)));
     return PromiseWrapper.all(promises);
@@ -87,7 +88,7 @@ export class DomTestbed {
         <ProtoViewDto>protoViews[0], ListWrapper.slice(protoViews, 1)));
   }
 
-  compileAndMerge(host: DirectiveMetadata,
+  compileAndMerge(host: RenderDirectiveMetadata,
                   componentViews: ViewDefinition[]): Promise<RenderProtoViewMergeMapping> {
     return this.compile(host, componentViews).then(protoViewDtos => this.merge(protoViewDtos));
   }
diff --git a/modules/angular2/test/render/dom/view/proto_view_merger_integration_spec.ts b/modules/angular2/test/render/dom/view/proto_view_merger_integration_spec.ts
index 15efab2920..1eb2629fea 100644
--- a/modules/angular2/test/render/dom/view/proto_view_merger_integration_spec.ts
+++ b/modules/angular2/test/render/dom/view/proto_view_merger_integration_spec.ts
@@ -21,7 +21,7 @@ import {DomTestbed} from '../dom_testbed';
 
 import {
   ViewDefinition,
-  DirectiveMetadata,
+  RenderDirectiveMetadata,
   RenderProtoViewMergeMapping,
   ViewEncapsulation,
   ViewType
@@ -301,8 +301,8 @@ function runAndAssert(hostElementName: string, componentTemplates: string[],
 }
 
 function rootDirective(hostElementName: string) {
-  return DirectiveMetadata.create(
-      {id: 'rootComp', type: DirectiveMetadata.COMPONENT_TYPE, selector: hostElementName});
+  return RenderDirectiveMetadata.create(
+      {id: 'rootComp', type: RenderDirectiveMetadata.COMPONENT_TYPE, selector: hostElementName});
 }
 
 function componentView(template: string,
@@ -335,9 +335,9 @@ function stringify(cloner: TemplateCloner, protoViewMergeMapping: RenderProtoVie
   return testView.fragments.map(nodes => nodes.map(node => stringifyElement(node)).join(''));
 }
 
-var aComp =
-    DirectiveMetadata.create({id: 'aComp', type: DirectiveMetadata.COMPONENT_TYPE, selector: 'a'});
-var bComp =
-    DirectiveMetadata.create({id: 'bComp', type: DirectiveMetadata.COMPONENT_TYPE, selector: 'b'});
-var cComp =
-    DirectiveMetadata.create({id: 'cComp', type: DirectiveMetadata.COMPONENT_TYPE, selector: 'c'});
+var aComp = RenderDirectiveMetadata.create(
+    {id: 'aComp', type: RenderDirectiveMetadata.COMPONENT_TYPE, selector: 'a'});
+var bComp = RenderDirectiveMetadata.create(
+    {id: 'bComp', type: RenderDirectiveMetadata.COMPONENT_TYPE, selector: 'b'});
+var cComp = RenderDirectiveMetadata.create(
+    {id: 'cComp', type: RenderDirectiveMetadata.COMPONENT_TYPE, selector: 'c'});
diff --git a/modules/angular2/test/router/outlet_spec.ts b/modules/angular2/test/router/outlet_spec.ts
index 7accf788e3..00f3adfd59 100644
--- a/modules/angular2/test/router/outlet_spec.ts
+++ b/modules/angular2/test/router/outlet_spec.ts
@@ -16,8 +16,7 @@ import {
 } from 'angular2/test_lib';
 
 import {Injector, bind} from 'angular2/di';
-import {Component, View} from 'angular2/src/core/annotations/decorators';
-import * as annotations from 'angular2/src/core/annotations_impl/view';
+import {Component, View} from 'angular2/metadata';
 import {CONST, NumberWrapper, isPresent} from 'angular2/src/facade/lang';
 import {
   Promise,
@@ -86,10 +85,10 @@ export function main() {
     }));
 
     function compile(template: string = "<router-outlet></router-outlet>") {
-      return tcb.overrideView(MyComp, new annotations.View({
-                  template: ('<div>' + template + '</div>'),
-                  directives: [RouterOutlet, RouterLink]
-                }))
+      return tcb.overrideView(MyComp, new View({
+                                template: ('<div>' + template + '</div>'),
+                                directives: [RouterOutlet, RouterLink]
+                              }))
           .createAsync(MyComp)
           .then((tc) => { rootTC = tc; });
     }
diff --git a/modules/angular2/test/router/route_config_spec.ts b/modules/angular2/test/router/route_config_spec.ts
index 91b8936360..3731cdba82 100644
--- a/modules/angular2/test/router/route_config_spec.ts
+++ b/modules/angular2/test/router/route_config_spec.ts
@@ -12,7 +12,7 @@ import {
 } from 'angular2/test_lib';
 
 import {bootstrap} from 'angular2/bootstrap';
-import {Component, Directive, View} from 'angular2/annotations';
+import {Component, Directive, View} from 'angular2/metadata';
 import {DOM} from 'angular2/src/dom/dom_adapter';
 import {bind} from 'angular2/di';
 import {DOCUMENT} from 'angular2/src/render/render';
diff --git a/modules/angular2/test/router/router_integration_spec.ts b/modules/angular2/test/router/router_integration_spec.ts
index 6ab99b1e81..95fbc4e10e 100644
--- a/modules/angular2/test/router/router_integration_spec.ts
+++ b/modules/angular2/test/router/router_integration_spec.ts
@@ -15,7 +15,7 @@ import {
 } from 'angular2/test_lib';
 
 import {bootstrap} from 'angular2/src/core/application';
-import {Component, Directive, View} from 'angular2/src/core/annotations/decorators';
+import {Component, Directive, View} from 'angular2/metadata';
 import {DOM} from 'angular2/src/dom/dom_adapter';
 import {bind} from 'angular2/di';
 import {DOCUMENT} from 'angular2/src/render/render';
diff --git a/modules/angular2/test/test_lib/test_component_builder_spec.ts b/modules/angular2/test/test_lib/test_component_builder_spec.ts
index 328ed25450..ba31db1d45 100644
--- a/modules/angular2/test/test_lib/test_component_builder_spec.ts
+++ b/modules/angular2/test/test_lib/test_component_builder_spec.ts
@@ -16,13 +16,7 @@ import {
 
 import {Injectable} from 'angular2/di';
 
-import {
-  Directive,
-  Component,
-  View,
-} from 'angular2/annotations';
-
-import * as viewAnn from 'angular2/src/core/annotations_impl/view';
+import {Directive, Component, View, ViewMetadata} from 'angular2/metadata';
 
 import {NgIf} from 'angular2/src/directives/ng_if';
 
@@ -98,7 +92,7 @@ export function main() {
        inject([TestComponentBuilder, AsyncTestCompleter], (tcb, async) => {
 
          tcb.overrideView(ChildComp,
-                          new viewAnn.View({template: '<span>Modified {{childBinding}}</span>'}))
+                          new ViewMetadata({template: '<span>Modified {{childBinding}}</span>'}))
              .createAsync(ChildComp)
              .then((rootTestComponent) => {
                rootTestComponent.detectChanges();
diff --git a/modules/angular2/test/transform/bind_generator/basic_bind_files/bar.ng_deps.dart b/modules/angular2/test/transform/bind_generator/basic_bind_files/bar.ng_deps.dart
index 75a6269812..bbb34f6ab8 100644
--- a/modules/angular2/test/transform/bind_generator/basic_bind_files/bar.ng_deps.dart
+++ b/modules/angular2/test/transform/bind_generator/basic_bind_files/bar.ng_deps.dart
@@ -1,7 +1,7 @@
 library bar.ng_deps.dart;
 
 import 'bar.dart';
-import 'package:angular2/src/core/annotations_impl/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 
 var _visited = false;
 void initReflector(reflector) {
diff --git a/modules/angular2/test/transform/bind_generator/basic_bind_files/expected/bar.ng_deps.dart b/modules/angular2/test/transform/bind_generator/basic_bind_files/expected/bar.ng_deps.dart
index 7bef603d7f..a885e16913 100644
--- a/modules/angular2/test/transform/bind_generator/basic_bind_files/expected/bar.ng_deps.dart
+++ b/modules/angular2/test/transform/bind_generator/basic_bind_files/expected/bar.ng_deps.dart
@@ -1,7 +1,7 @@
 library bar.ng_deps.dart;
 
 import 'bar.dart';
-import 'package:angular2/src/core/annotations_impl/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 
 var _visited = false;
 void initReflector(reflector) {
diff --git a/modules/angular2/test/transform/bind_generator/duplicate_bind_name_files/expected/soup.ng_deps.dart b/modules/angular2/test/transform/bind_generator/duplicate_bind_name_files/expected/soup.ng_deps.dart
index 56b37d6068..ab53e186cb 100644
--- a/modules/angular2/test/transform/bind_generator/duplicate_bind_name_files/expected/soup.ng_deps.dart
+++ b/modules/angular2/test/transform/bind_generator/duplicate_bind_name_files/expected/soup.ng_deps.dart
@@ -1,6 +1,6 @@
 library dinner.soup.ng_deps.dart;
 
-import 'package:angular2/src/core/annotations_impl/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 import 'soup.dart';
 
 var _visited = false;
diff --git a/modules/angular2/test/transform/bind_generator/duplicate_bind_name_files/soup.ng_deps.dart b/modules/angular2/test/transform/bind_generator/duplicate_bind_name_files/soup.ng_deps.dart
index f42fc9d540..cef43d1101 100644
--- a/modules/angular2/test/transform/bind_generator/duplicate_bind_name_files/soup.ng_deps.dart
+++ b/modules/angular2/test/transform/bind_generator/duplicate_bind_name_files/soup.ng_deps.dart
@@ -1,6 +1,6 @@
 library dinner.soup.ng_deps.dart;
 
-import 'package:angular2/src/core/annotations_impl/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 import 'soup.dart';
 
 var _visited = false;
diff --git a/modules/angular2/test/transform/bind_generator/events_files/bar.ng_deps.dart b/modules/angular2/test/transform/bind_generator/events_files/bar.ng_deps.dart
index ec672eb502..dcef288879 100644
--- a/modules/angular2/test/transform/bind_generator/events_files/bar.ng_deps.dart
+++ b/modules/angular2/test/transform/bind_generator/events_files/bar.ng_deps.dart
@@ -1,7 +1,7 @@
 library bar.ng_deps.dart;
 
 import 'bar.dart';
-import 'package:angular2/src/core/annotations_impl/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 
 var _visited = false;
 void initReflector(reflector) {
diff --git a/modules/angular2/test/transform/bind_generator/events_files/expected/bar.ng_deps.dart b/modules/angular2/test/transform/bind_generator/events_files/expected/bar.ng_deps.dart
index 60a2e348aa..3aafd4bd94 100644
--- a/modules/angular2/test/transform/bind_generator/events_files/expected/bar.ng_deps.dart
+++ b/modules/angular2/test/transform/bind_generator/events_files/expected/bar.ng_deps.dart
@@ -1,7 +1,7 @@
 library bar.ng_deps.dart;
 
 import 'bar.dart';
-import 'package:angular2/src/core/annotations_impl/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 
 var _visited = false;
 void initReflector(reflector) {
diff --git a/modules/angular2/test/transform/common/ng_meta_test.dart b/modules/angular2/test/transform/common/ng_meta_test.dart
index 04bc84c7af..701ab7a2a8 100644
--- a/modules/angular2/test/transform/common/ng_meta_test.dart
+++ b/modules/angular2/test/transform/common/ng_meta_test.dart
@@ -8,10 +8,10 @@ main() => allTests();
 
 void allTests() {
   var mockData = [
-    new DirectiveMetadata(id: 'm1'),
-    new DirectiveMetadata(id: 'm2'),
-    new DirectiveMetadata(id: 'm3'),
-    new DirectiveMetadata(id: 'm4')
+    new RenderDirectiveMetadata(id: 'm1'),
+    new RenderDirectiveMetadata(id: 'm2'),
+    new RenderDirectiveMetadata(id: 'm3'),
+    new RenderDirectiveMetadata(id: 'm4')
   ];
 
   it('should allow empty data.', () {
diff --git a/modules/angular2/test/transform/directive_linker/simple_export_files/bar.ng_deps.dart b/modules/angular2/test/transform/directive_linker/simple_export_files/bar.ng_deps.dart
index e3b6e9b546..6702aa4f65 100644
--- a/modules/angular2/test/transform/directive_linker/simple_export_files/bar.ng_deps.dart
+++ b/modules/angular2/test/transform/directive_linker/simple_export_files/bar.ng_deps.dart
@@ -3,7 +3,7 @@ library bar.ng_deps.dart;
 import 'bar.dart';
 export 'bar.dart';
 import 'package:angular2/src/reflection/reflection.dart' as _ngRef;
-import 'package:angular2/src/core/annotations_impl/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 export 'foo.dart';
 
 var _visited = false;
diff --git a/modules/angular2/test/transform/directive_linker/simple_export_files/expected/bar.ng_deps.dart b/modules/angular2/test/transform/directive_linker/simple_export_files/expected/bar.ng_deps.dart
index e264d8f618..f1b90531f3 100644
--- a/modules/angular2/test/transform/directive_linker/simple_export_files/expected/bar.ng_deps.dart
+++ b/modules/angular2/test/transform/directive_linker/simple_export_files/expected/bar.ng_deps.dart
@@ -3,7 +3,7 @@ library bar.ng_deps.dart;
 import 'bar.dart';
 export 'bar.dart';
 import 'package:angular2/src/reflection/reflection.dart' as _ngRef;
-import 'package:angular2/src/core/annotations_impl/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 export 'foo.dart';
 import 'foo.ng_deps.dart' as i0;
 
diff --git a/modules/angular2/test/transform/directive_linker/simple_export_files/expected/foo.ng_deps.dart b/modules/angular2/test/transform/directive_linker/simple_export_files/expected/foo.ng_deps.dart
index 03d243c3a7..644072db8f 100644
--- a/modules/angular2/test/transform/directive_linker/simple_export_files/expected/foo.ng_deps.dart
+++ b/modules/angular2/test/transform/directive_linker/simple_export_files/expected/foo.ng_deps.dart
@@ -3,7 +3,7 @@ library foo.ng_deps.dart;
 import 'foo.dart';
 export 'foo.dart';
 import 'package:angular2/src/reflection/reflection.dart' as _ngRef;
-import 'package:angular2/src/core/annotations_impl/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 
 var _visited = false;
 void initReflector() {
diff --git a/modules/angular2/test/transform/directive_linker/simple_export_files/foo.ng_deps.dart b/modules/angular2/test/transform/directive_linker/simple_export_files/foo.ng_deps.dart
index 03d243c3a7..644072db8f 100644
--- a/modules/angular2/test/transform/directive_linker/simple_export_files/foo.ng_deps.dart
+++ b/modules/angular2/test/transform/directive_linker/simple_export_files/foo.ng_deps.dart
@@ -3,7 +3,7 @@ library foo.ng_deps.dart;
 import 'foo.dart';
 export 'foo.dart';
 import 'package:angular2/src/reflection/reflection.dart' as _ngRef;
-import 'package:angular2/src/core/annotations_impl/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 
 var _visited = false;
 void initReflector() {
diff --git a/modules/angular2/test/transform/directive_linker/simple_files/bar.ng_deps.dart b/modules/angular2/test/transform/directive_linker/simple_files/bar.ng_deps.dart
index 21e9b029da..99c5f982ef 100644
--- a/modules/angular2/test/transform/directive_linker/simple_files/bar.ng_deps.dart
+++ b/modules/angular2/test/transform/directive_linker/simple_files/bar.ng_deps.dart
@@ -3,7 +3,7 @@ library bar.ng_deps.dart;
 import 'bar.dart';
 export 'bar.dart';
 import 'package:angular2/src/reflection/reflection.dart' as _ngRef;
-import 'package:angular2/src/core/annotations_impl/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 import 'foo.dart' as dep;
 
 var _visited = false;
diff --git a/modules/angular2/test/transform/directive_linker/simple_files/expected/bar.ng_deps.dart b/modules/angular2/test/transform/directive_linker/simple_files/expected/bar.ng_deps.dart
index d123689a7b..64501aa3a9 100644
--- a/modules/angular2/test/transform/directive_linker/simple_files/expected/bar.ng_deps.dart
+++ b/modules/angular2/test/transform/directive_linker/simple_files/expected/bar.ng_deps.dart
@@ -3,7 +3,7 @@ library bar.ng_deps.dart;
 import 'bar.dart';
 export 'bar.dart';
 import 'package:angular2/src/reflection/reflection.dart' as _ngRef;
-import 'package:angular2/src/core/annotations_impl/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 import 'foo.dart' as dep;
 import 'foo.ng_deps.dart' as i0;
 
diff --git a/modules/angular2/test/transform/directive_linker/simple_files/expected/foo.ng_deps.dart b/modules/angular2/test/transform/directive_linker/simple_files/expected/foo.ng_deps.dart
index 03d243c3a7..644072db8f 100644
--- a/modules/angular2/test/transform/directive_linker/simple_files/expected/foo.ng_deps.dart
+++ b/modules/angular2/test/transform/directive_linker/simple_files/expected/foo.ng_deps.dart
@@ -3,7 +3,7 @@ library foo.ng_deps.dart;
 import 'foo.dart';
 export 'foo.dart';
 import 'package:angular2/src/reflection/reflection.dart' as _ngRef;
-import 'package:angular2/src/core/annotations_impl/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 
 var _visited = false;
 void initReflector() {
diff --git a/modules/angular2/test/transform/directive_linker/simple_files/foo.ng_deps.dart b/modules/angular2/test/transform/directive_linker/simple_files/foo.ng_deps.dart
index 03d243c3a7..644072db8f 100644
--- a/modules/angular2/test/transform/directive_linker/simple_files/foo.ng_deps.dart
+++ b/modules/angular2/test/transform/directive_linker/simple_files/foo.ng_deps.dart
@@ -3,7 +3,7 @@ library foo.ng_deps.dart;
 import 'foo.dart';
 export 'foo.dart';
 import 'package:angular2/src/reflection/reflection.dart' as _ngRef;
-import 'package:angular2/src/core/annotations_impl/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 
 var _visited = false;
 void initReflector() {
diff --git a/modules/angular2/test/transform/directive_metadata_extractor/absolute_export_files/bar.ng_deps.dart b/modules/angular2/test/transform/directive_metadata_extractor/absolute_export_files/bar.ng_deps.dart
index 2864ec8e94..9a4a5d0cad 100644
--- a/modules/angular2/test/transform/directive_metadata_extractor/absolute_export_files/bar.ng_deps.dart
+++ b/modules/angular2/test/transform/directive_metadata_extractor/absolute_export_files/bar.ng_deps.dart
@@ -1,7 +1,7 @@
 library foo.ng_deps.dart;
 
 import 'bar.dart';
-import 'package:angular2/src/core/annotations/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 
 var _visited = false;
 void initReflector(reflector) {
diff --git a/modules/angular2/test/transform/directive_metadata_extractor/absolute_export_files/foo.ng_deps.dart b/modules/angular2/test/transform/directive_metadata_extractor/absolute_export_files/foo.ng_deps.dart
index 26f60e5cd1..f0b95aa00a 100644
--- a/modules/angular2/test/transform/directive_metadata_extractor/absolute_export_files/foo.ng_deps.dart
+++ b/modules/angular2/test/transform/directive_metadata_extractor/absolute_export_files/foo.ng_deps.dart
@@ -1,7 +1,7 @@
 library foo.ng_deps.dart;
 
 import 'foo.dart';
-import 'package:angular2/src/core/annotations/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 
 export 'package:bar/bar.dart';
 import 'package:bar/bar.ng_deps.dart' as i0;
diff --git a/modules/angular2/test/transform/directive_metadata_extractor/adjacent_strings_files/foo.ng_deps.dart b/modules/angular2/test/transform/directive_metadata_extractor/adjacent_strings_files/foo.ng_deps.dart
index 4fc8f431e0..8503402ed6 100644
--- a/modules/angular2/test/transform/directive_metadata_extractor/adjacent_strings_files/foo.ng_deps.dart
+++ b/modules/angular2/test/transform/directive_metadata_extractor/adjacent_strings_files/foo.ng_deps.dart
@@ -1,7 +1,7 @@
 library bar.ng_deps.dart;
 
 import 'foo.dart';
-import 'package:angular2/src/core/annotations/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 
 var _visited = false;
 void initReflector(reflector) {
diff --git a/modules/angular2/test/transform/directive_metadata_extractor/directive_aliases_files/bar.ng_deps.dart b/modules/angular2/test/transform/directive_metadata_extractor/directive_aliases_files/bar.ng_deps.dart
index 2864ec8e94..9a4a5d0cad 100644
--- a/modules/angular2/test/transform/directive_metadata_extractor/directive_aliases_files/bar.ng_deps.dart
+++ b/modules/angular2/test/transform/directive_metadata_extractor/directive_aliases_files/bar.ng_deps.dart
@@ -1,7 +1,7 @@
 library foo.ng_deps.dart;
 
 import 'bar.dart';
-import 'package:angular2/src/core/annotations/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 
 var _visited = false;
 void initReflector(reflector) {
diff --git a/modules/angular2/test/transform/directive_metadata_extractor/directive_aliases_files/foo.ng_deps.dart b/modules/angular2/test/transform/directive_metadata_extractor/directive_aliases_files/foo.ng_deps.dart
index 64c14be88d..542f008d16 100644
--- a/modules/angular2/test/transform/directive_metadata_extractor/directive_aliases_files/foo.ng_deps.dart
+++ b/modules/angular2/test/transform/directive_metadata_extractor/directive_aliases_files/foo.ng_deps.dart
@@ -1,7 +1,7 @@
 library foo.ng_deps.dart;
 
 import 'foo.dart';
-import 'package:angular2/src/core/annotations/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 
 export 'bar.dart';
 import 'bar.ng_deps.dart' as i0;
diff --git a/modules/angular2/test/transform/directive_metadata_extractor/export_files/bar.ng_deps.dart b/modules/angular2/test/transform/directive_metadata_extractor/export_files/bar.ng_deps.dart
index 2864ec8e94..9a4a5d0cad 100644
--- a/modules/angular2/test/transform/directive_metadata_extractor/export_files/bar.ng_deps.dart
+++ b/modules/angular2/test/transform/directive_metadata_extractor/export_files/bar.ng_deps.dart
@@ -1,7 +1,7 @@
 library foo.ng_deps.dart;
 
 import 'bar.dart';
-import 'package:angular2/src/core/annotations/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 
 var _visited = false;
 void initReflector(reflector) {
diff --git a/modules/angular2/test/transform/directive_metadata_extractor/export_files/foo.ng_deps.dart b/modules/angular2/test/transform/directive_metadata_extractor/export_files/foo.ng_deps.dart
index 64c14be88d..542f008d16 100644
--- a/modules/angular2/test/transform/directive_metadata_extractor/export_files/foo.ng_deps.dart
+++ b/modules/angular2/test/transform/directive_metadata_extractor/export_files/foo.ng_deps.dart
@@ -1,7 +1,7 @@
 library foo.ng_deps.dart;
 
 import 'foo.dart';
-import 'package:angular2/src/core/annotations/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 
 export 'bar.dart';
 import 'bar.ng_deps.dart' as i0;
diff --git a/modules/angular2/test/transform/directive_metadata_extractor/recursive_export_files/bar.ng_deps.dart b/modules/angular2/test/transform/directive_metadata_extractor/recursive_export_files/bar.ng_deps.dart
index ebed259302..0381a810ef 100644
--- a/modules/angular2/test/transform/directive_metadata_extractor/recursive_export_files/bar.ng_deps.dart
+++ b/modules/angular2/test/transform/directive_metadata_extractor/recursive_export_files/bar.ng_deps.dart
@@ -1,7 +1,7 @@
 library foo.ng_deps.dart;
 
 import 'bar.dart';
-import 'package:angular2/src/core/annotations/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 
 export 'baz.dart';
 import 'baz.ng_deps.dart' as i0;
diff --git a/modules/angular2/test/transform/directive_metadata_extractor/recursive_export_files/baz.ng_deps.dart b/modules/angular2/test/transform/directive_metadata_extractor/recursive_export_files/baz.ng_deps.dart
index 8d772fa715..87e09d238f 100644
--- a/modules/angular2/test/transform/directive_metadata_extractor/recursive_export_files/baz.ng_deps.dart
+++ b/modules/angular2/test/transform/directive_metadata_extractor/recursive_export_files/baz.ng_deps.dart
@@ -1,7 +1,7 @@
 library foo.ng_deps.dart;
 
 import 'baz.dart';
-import 'package:angular2/src/core/annotations/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 
 var _visited = false;
 void initReflector(reflector) {
diff --git a/modules/angular2/test/transform/directive_metadata_extractor/recursive_export_files/foo.ng_deps.dart b/modules/angular2/test/transform/directive_metadata_extractor/recursive_export_files/foo.ng_deps.dart
index 64c14be88d..542f008d16 100644
--- a/modules/angular2/test/transform/directive_metadata_extractor/recursive_export_files/foo.ng_deps.dart
+++ b/modules/angular2/test/transform/directive_metadata_extractor/recursive_export_files/foo.ng_deps.dart
@@ -1,7 +1,7 @@
 library foo.ng_deps.dart;
 
 import 'foo.dart';
-import 'package:angular2/src/core/annotations/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 
 export 'bar.dart';
 import 'bar.ng_deps.dart' as i0;
diff --git a/modules/angular2/test/transform/directive_metadata_extractor/simple_files/foo.ng_deps.dart b/modules/angular2/test/transform/directive_metadata_extractor/simple_files/foo.ng_deps.dart
index 0a585f4b4e..a69adeee64 100644
--- a/modules/angular2/test/transform/directive_metadata_extractor/simple_files/foo.ng_deps.dart
+++ b/modules/angular2/test/transform/directive_metadata_extractor/simple_files/foo.ng_deps.dart
@@ -1,7 +1,7 @@
 library bar.ng_deps.dart;
 
 import 'foo.dart';
-import 'package:angular2/src/core/annotations/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 
 var _visited = false;
 void initReflector(reflector) {
diff --git a/modules/angular2/test/transform/directive_processor/interface_chain_files/expected/soup.ng_deps.dart b/modules/angular2/test/transform/directive_processor/interface_chain_files/expected/soup.ng_deps.dart
index a1c6a556be..c6b9ea0a55 100644
--- a/modules/angular2/test/transform/directive_processor/interface_chain_files/expected/soup.ng_deps.dart
+++ b/modules/angular2/test/transform/directive_processor/interface_chain_files/expected/soup.ng_deps.dart
@@ -3,7 +3,7 @@ library dinner.soup.ng_deps.dart;
 import 'soup.dart';
 export 'soup.dart';
 import 'package:angular2/src/reflection/reflection.dart' as _ngRef;
-import 'package:angular2/src/core/annotations_impl/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 
 var _visited = false;
 void initReflector() {
diff --git a/modules/angular2/test/transform/directive_processor/interface_chain_files/soup.dart b/modules/angular2/test/transform/directive_processor/interface_chain_files/soup.dart
index 55de1a4cd4..8ad2ae135b 100644
--- a/modules/angular2/test/transform/directive_processor/interface_chain_files/soup.dart
+++ b/modules/angular2/test/transform/directive_processor/interface_chain_files/soup.dart
@@ -1,6 +1,6 @@
 library dinner.soup;
 
-import 'package:angular2/src/core/annotations_impl/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 
 @Component(selector: '[soup]')
 class ChangingSoupComponent implements PrimaryInterface {}
diff --git a/modules/angular2/test/transform/directive_processor/interface_lifecycle_files/expected/soup.ng_deps.dart b/modules/angular2/test/transform/directive_processor/interface_lifecycle_files/expected/soup.ng_deps.dart
index d8da46f484..66664dfcdb 100644
--- a/modules/angular2/test/transform/directive_processor/interface_lifecycle_files/expected/soup.ng_deps.dart
+++ b/modules/angular2/test/transform/directive_processor/interface_lifecycle_files/expected/soup.ng_deps.dart
@@ -3,7 +3,7 @@ library dinner.soup.ng_deps.dart;
 import 'soup.dart';
 export 'soup.dart';
 import 'package:angular2/src/reflection/reflection.dart' as _ngRef;
-import 'package:angular2/annotations.dart';
+import 'package:angular2/metadata.dart';
 
 var _visited = false;
 void initReflector() {
diff --git a/modules/angular2/test/transform/directive_processor/interface_lifecycle_files/soup.dart b/modules/angular2/test/transform/directive_processor/interface_lifecycle_files/soup.dart
index b0173c000b..015954f67a 100644
--- a/modules/angular2/test/transform/directive_processor/interface_lifecycle_files/soup.dart
+++ b/modules/angular2/test/transform/directive_processor/interface_lifecycle_files/soup.dart
@@ -1,6 +1,6 @@
 library dinner.soup;
 
-import 'package:angular2/annotations.dart';
+import 'package:angular2/metadata.dart';
 
 @Component(selector: '[soup]')
 class OnChangeSoupComponent implements OnChange {}
diff --git a/modules/angular2/test/transform/directive_processor/interfaces_files/expected/soup.ng_deps.dart b/modules/angular2/test/transform/directive_processor/interfaces_files/expected/soup.ng_deps.dart
index 349ba7862b..7f19cb2399 100644
--- a/modules/angular2/test/transform/directive_processor/interfaces_files/expected/soup.ng_deps.dart
+++ b/modules/angular2/test/transform/directive_processor/interfaces_files/expected/soup.ng_deps.dart
@@ -3,7 +3,7 @@ library dinner.soup.ng_deps.dart;
 import 'soup.dart';
 export 'soup.dart';
 import 'package:angular2/src/reflection/reflection.dart' as _ngRef;
-import 'package:angular2/src/core/annotations_impl/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 
 var _visited = false;
 void initReflector() {
diff --git a/modules/angular2/test/transform/directive_processor/interfaces_files/soup.dart b/modules/angular2/test/transform/directive_processor/interfaces_files/soup.dart
index cf7fc4d16c..dcbde8dd2c 100644
--- a/modules/angular2/test/transform/directive_processor/interfaces_files/soup.dart
+++ b/modules/angular2/test/transform/directive_processor/interfaces_files/soup.dart
@@ -1,6 +1,6 @@
 library dinner.soup;
 
-import 'package:angular2/src/core/annotations_impl/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 
 @Component(selector: '[soup]')
 class ChangingSoupComponent implements OnChange, AnotherInterface {}
diff --git a/modules/angular2/test/transform/directive_processor/multiple_interface_lifecycle_files/expected/soup.ng_deps.dart b/modules/angular2/test/transform/directive_processor/multiple_interface_lifecycle_files/expected/soup.ng_deps.dart
index 6843e7c17e..8c61d88628 100644
--- a/modules/angular2/test/transform/directive_processor/multiple_interface_lifecycle_files/expected/soup.ng_deps.dart
+++ b/modules/angular2/test/transform/directive_processor/multiple_interface_lifecycle_files/expected/soup.ng_deps.dart
@@ -3,7 +3,7 @@ library dinner.soup.ng_deps.dart;
 import 'soup.dart';
 export 'soup.dart';
 import 'package:angular2/src/reflection/reflection.dart' as _ngRef;
-import 'package:angular2/annotations.dart';
+import 'package:angular2/metadata.dart';
 
 var _visited = false;
 void initReflector() {
diff --git a/modules/angular2/test/transform/directive_processor/multiple_interface_lifecycle_files/soup.dart b/modules/angular2/test/transform/directive_processor/multiple_interface_lifecycle_files/soup.dart
index a4c3ed88a6..5ee1cc2d82 100644
--- a/modules/angular2/test/transform/directive_processor/multiple_interface_lifecycle_files/soup.dart
+++ b/modules/angular2/test/transform/directive_processor/multiple_interface_lifecycle_files/soup.dart
@@ -1,6 +1,6 @@
 library dinner.soup;
 
-import 'package:angular2/annotations.dart';
+import 'package:angular2/metadata.dart';
 
 @Component(selector: '[soup]')
 class MultiSoupComponent implements OnChange, OnDestroy, OnInit {}
diff --git a/modules/angular2/test/transform/directive_processor/multiple_part_files/expected/main.ng_deps.dart b/modules/angular2/test/transform/directive_processor/multiple_part_files/expected/main.ng_deps.dart
index 3e96886458..fb867afad4 100644
--- a/modules/angular2/test/transform/directive_processor/multiple_part_files/expected/main.ng_deps.dart
+++ b/modules/angular2/test/transform/directive_processor/multiple_part_files/expected/main.ng_deps.dart
@@ -3,7 +3,7 @@ library main.ng_deps.dart;
 import 'main.dart';
 export 'main.dart';
 import 'package:angular2/src/reflection/reflection.dart' as _ngRef;
-import 'package:angular2/src/core/annotations_impl/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 
 var _visited = false;
 void initReflector() {
diff --git a/modules/angular2/test/transform/directive_processor/multiple_part_files/main.dart b/modules/angular2/test/transform/directive_processor/multiple_part_files/main.dart
index 613c58d8f9..82a2a6390e 100644
--- a/modules/angular2/test/transform/directive_processor/multiple_part_files/main.dart
+++ b/modules/angular2/test/transform/directive_processor/multiple_part_files/main.dart
@@ -1,6 +1,6 @@
 library main;
 
-import 'package:angular2/src/core/annotations_impl/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 
 part 'part1.dart';
 part 'part2.dart';
diff --git a/modules/angular2/test/transform/directive_processor/parameter_metadata/expected/soup.ng_deps.dart b/modules/angular2/test/transform/directive_processor/parameter_metadata/expected/soup.ng_deps.dart
index a37cda3028..0425212175 100644
--- a/modules/angular2/test/transform/directive_processor/parameter_metadata/expected/soup.ng_deps.dart
+++ b/modules/angular2/test/transform/directive_processor/parameter_metadata/expected/soup.ng_deps.dart
@@ -3,7 +3,7 @@ library dinner.soup.ng_deps.dart;
 import 'soup.dart';
 export 'soup.dart';
 import 'package:angular2/src/reflection/reflection.dart' as _ngRef;
-import 'package:angular2/src/core/annotations_impl/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 
 var _visited = false;
 void initReflector() {
diff --git a/modules/angular2/test/transform/directive_processor/parameter_metadata/soup.dart b/modules/angular2/test/transform/directive_processor/parameter_metadata/soup.dart
index 3024a40ea3..8603449f21 100644
--- a/modules/angular2/test/transform/directive_processor/parameter_metadata/soup.dart
+++ b/modules/angular2/test/transform/directive_processor/parameter_metadata/soup.dart
@@ -1,6 +1,6 @@
 library dinner.soup;
 
-import 'package:angular2/src/core/annotations_impl/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 
 @Component(selector: '[soup]')
 class SoupComponent {
diff --git a/modules/angular2/test/transform/directive_processor/part_files/expected/main.ng_deps.dart b/modules/angular2/test/transform/directive_processor/part_files/expected/main.ng_deps.dart
index efe47617cf..c5d8a7c096 100644
--- a/modules/angular2/test/transform/directive_processor/part_files/expected/main.ng_deps.dart
+++ b/modules/angular2/test/transform/directive_processor/part_files/expected/main.ng_deps.dart
@@ -3,7 +3,7 @@ library main.ng_deps.dart;
 import 'main.dart';
 export 'main.dart';
 import 'package:angular2/src/reflection/reflection.dart' as _ngRef;
-import 'package:angular2/src/core/annotations_impl/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 
 var _visited = false;
 void initReflector() {
diff --git a/modules/angular2/test/transform/directive_processor/part_files/main.dart b/modules/angular2/test/transform/directive_processor/part_files/main.dart
index a8d23a7317..11d25cd684 100644
--- a/modules/angular2/test/transform/directive_processor/part_files/main.dart
+++ b/modules/angular2/test/transform/directive_processor/part_files/main.dart
@@ -1,6 +1,6 @@
 library main;
 
-import 'package:angular2/src/core/annotations_impl/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 
 part 'part.dart';
 
diff --git a/modules/angular2/test/transform/directive_processor/prefixed_interface_lifecycle_files/expected/soup.ng_deps.dart b/modules/angular2/test/transform/directive_processor/prefixed_interface_lifecycle_files/expected/soup.ng_deps.dart
index 914e941c64..f1bca12019 100644
--- a/modules/angular2/test/transform/directive_processor/prefixed_interface_lifecycle_files/expected/soup.ng_deps.dart
+++ b/modules/angular2/test/transform/directive_processor/prefixed_interface_lifecycle_files/expected/soup.ng_deps.dart
@@ -3,7 +3,7 @@ library dinner.soup.ng_deps.dart;
 import 'soup.dart';
 export 'soup.dart';
 import 'package:angular2/src/reflection/reflection.dart' as _ngRef;
-import 'package:angular2/annotations.dart' as prefix;
+import 'package:angular2/metadata.dart' as prefix;
 
 var _visited = false;
 void initReflector() {
diff --git a/modules/angular2/test/transform/directive_processor/prefixed_interface_lifecycle_files/soup.dart b/modules/angular2/test/transform/directive_processor/prefixed_interface_lifecycle_files/soup.dart
index 73f411a6b1..6680c150a2 100644
--- a/modules/angular2/test/transform/directive_processor/prefixed_interface_lifecycle_files/soup.dart
+++ b/modules/angular2/test/transform/directive_processor/prefixed_interface_lifecycle_files/soup.dart
@@ -1,6 +1,6 @@
 library dinner.soup;
 
-import 'package:angular2/annotations.dart' as prefix;
+import 'package:angular2/metadata.dart' as prefix;
 
 @prefix.Component(selector: '[soup]')
 class OnChangeSoupComponent implements prefix.OnChange {}
diff --git a/modules/angular2/test/transform/directive_processor/superclass_files/expected/soup.ng_deps.dart b/modules/angular2/test/transform/directive_processor/superclass_files/expected/soup.ng_deps.dart
index 1815f7f0ac..e24e6ae43d 100644
--- a/modules/angular2/test/transform/directive_processor/superclass_files/expected/soup.ng_deps.dart
+++ b/modules/angular2/test/transform/directive_processor/superclass_files/expected/soup.ng_deps.dart
@@ -3,7 +3,7 @@ library dinner.soup.ng_deps.dart;
 import 'soup.dart';
 export 'soup.dart';
 import 'package:angular2/src/reflection/reflection.dart' as _ngRef;
-import 'package:angular2/src/core/annotations_impl/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 
 var _visited = false;
 void initReflector() {
diff --git a/modules/angular2/test/transform/directive_processor/superclass_files/soup.dart b/modules/angular2/test/transform/directive_processor/superclass_files/soup.dart
index ff4a921e12..2ea09e3453 100644
--- a/modules/angular2/test/transform/directive_processor/superclass_files/soup.dart
+++ b/modules/angular2/test/transform/directive_processor/superclass_files/soup.dart
@@ -1,6 +1,6 @@
 library dinner.soup;
 
-import 'package:angular2/src/core/annotations_impl/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 
 @Component(selector: '[soup]')
 class ChangingSoupComponent extends Super {}
diff --git a/modules/angular2/test/transform/directive_processor/superclass_lifecycle_files/expected/soup.ng_deps.dart b/modules/angular2/test/transform/directive_processor/superclass_lifecycle_files/expected/soup.ng_deps.dart
index d0eb3f5328..66afb7c653 100644
--- a/modules/angular2/test/transform/directive_processor/superclass_lifecycle_files/expected/soup.ng_deps.dart
+++ b/modules/angular2/test/transform/directive_processor/superclass_lifecycle_files/expected/soup.ng_deps.dart
@@ -3,7 +3,7 @@ library dinner.soup.ng_deps.dart;
 import 'soup.dart';
 export 'soup.dart';
 import 'package:angular2/src/reflection/reflection.dart' as _ngRef;
-import 'package:angular2/annotations.dart';
+import 'package:angular2/metadata.dart';
 
 var _visited = false;
 void initReflector() {
diff --git a/modules/angular2/test/transform/directive_processor/superclass_lifecycle_files/soup.dart b/modules/angular2/test/transform/directive_processor/superclass_lifecycle_files/soup.dart
index 88449969ef..81ba9645d6 100644
--- a/modules/angular2/test/transform/directive_processor/superclass_lifecycle_files/soup.dart
+++ b/modules/angular2/test/transform/directive_processor/superclass_lifecycle_files/soup.dart
@@ -1,6 +1,6 @@
 library dinner.soup;
 
-import 'package:angular2/annotations.dart';
+import 'package:angular2/metadata.dart';
 
 @Component(selector: '[soup]')
 class OnChangeSoupComponent extends OnChange {}
diff --git a/modules/angular2/test/transform/integration/all_tests.dart b/modules/angular2/test/transform/integration/all_tests.dart
index 8e62cd519f..8ffae1be11 100644
--- a/modules/angular2/test/transform/integration/all_tests.dart
+++ b/modules/angular2/test/transform/integration/all_tests.dart
@@ -39,8 +39,8 @@ void allTests() {
    * every test.
    */
   var commonInputs = {
-    'angular2|lib/src/core/annotations_impl/annotations.dart':
-        '../../../lib/src/core/annotations_impl/annotations.dart',
+    'angular2|lib/src/core/metadata.dart':
+        '../../../lib/src/core/metadata.dart',
     'angular2|lib/src/core/application.dart': '../common/application.dart',
     'angular2|lib/src/reflection/reflection_capabilities.dart':
         '../common/reflection_capabilities.dart',
@@ -97,8 +97,7 @@ void allTests() {
     new IntegrationTestConfig('should preserve multiple annotations.', inputs: {
       'a|web/index.dart': 'two_annotations_files/index.dart',
       'a|web/bar.dart': 'two_annotations_files/bar.dart',
-      'angular2|lib/src/core/annotations_impl/view.dart':
-          '../../../lib/src/core/annotations_impl/view.dart'
+      'angular2|lib/src/core/metadata.dart': '../../../lib/src/core/metadata.dart'
     }, outputs: {
       'a|web/bar.ng_deps.dart':
           'two_annotations_files/expected/bar.ng_deps.dart'
diff --git a/modules/angular2/test/transform/integration/list_of_types_files/bar.dart b/modules/angular2/test/transform/integration/list_of_types_files/bar.dart
index 63c7c364a5..bc0ed87825 100644
--- a/modules/angular2/test/transform/integration/list_of_types_files/bar.dart
+++ b/modules/angular2/test/transform/integration/list_of_types_files/bar.dart
@@ -1,6 +1,6 @@
 library bar;
 
-import 'package:angular2/src/core/annotations_impl/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 import 'foo.dart';
 
 @Component(componentServices: const [MyContext])
diff --git a/modules/angular2/test/transform/integration/list_of_types_files/expected/bar.ng_deps.dart b/modules/angular2/test/transform/integration/list_of_types_files/expected/bar.ng_deps.dart
index de5fef1daf..45eaa03716 100644
--- a/modules/angular2/test/transform/integration/list_of_types_files/expected/bar.ng_deps.dart
+++ b/modules/angular2/test/transform/integration/list_of_types_files/expected/bar.ng_deps.dart
@@ -3,7 +3,7 @@ library bar.ng_deps.dart;
 import 'bar.dart';
 export 'bar.dart';
 import 'package:angular2/src/reflection/reflection.dart' as _ngRef;
-import 'package:angular2/src/core/annotations_impl/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 import 'foo.dart';
 
 var _visited = false;
diff --git a/modules/angular2/test/transform/integration/simple_annotation_files/bar.dart b/modules/angular2/test/transform/integration/simple_annotation_files/bar.dart
index c999b68a98..1750721413 100644
--- a/modules/angular2/test/transform/integration/simple_annotation_files/bar.dart
+++ b/modules/angular2/test/transform/integration/simple_annotation_files/bar.dart
@@ -1,6 +1,6 @@
 library bar;
 
-import 'package:angular2/src/core/annotations_impl/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 
 @Component(selector: '[soup]')
 class MyComponent {
diff --git a/modules/angular2/test/transform/integration/simple_annotation_files/expected/bar.ng_deps.dart b/modules/angular2/test/transform/integration/simple_annotation_files/expected/bar.ng_deps.dart
index e153d17ba4..ff61b24d8d 100644
--- a/modules/angular2/test/transform/integration/simple_annotation_files/expected/bar.ng_deps.dart
+++ b/modules/angular2/test/transform/integration/simple_annotation_files/expected/bar.ng_deps.dart
@@ -3,7 +3,7 @@ library bar.ng_deps.dart;
 import 'bar.dart';
 export 'bar.dart';
 import 'package:angular2/src/reflection/reflection.dart' as _ngRef;
-import 'package:angular2/src/core/annotations_impl/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 
 var _visited = false;
 void initReflector() {
diff --git a/modules/angular2/test/transform/integration/synthetic_ctor_files/bar.dart b/modules/angular2/test/transform/integration/synthetic_ctor_files/bar.dart
index 1efe10f6ad..c926a0f70b 100644
--- a/modules/angular2/test/transform/integration/synthetic_ctor_files/bar.dart
+++ b/modules/angular2/test/transform/integration/synthetic_ctor_files/bar.dart
@@ -1,6 +1,6 @@
 library bar;
 
-import 'package:angular2/src/core/annotations_impl/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 
 @Component(selector: '[soup]')
 class MyComponent {}
diff --git a/modules/angular2/test/transform/integration/synthetic_ctor_files/expected/bar.ng_deps.dart b/modules/angular2/test/transform/integration/synthetic_ctor_files/expected/bar.ng_deps.dart
index e153d17ba4..ff61b24d8d 100644
--- a/modules/angular2/test/transform/integration/synthetic_ctor_files/expected/bar.ng_deps.dart
+++ b/modules/angular2/test/transform/integration/synthetic_ctor_files/expected/bar.ng_deps.dart
@@ -3,7 +3,7 @@ library bar.ng_deps.dart;
 import 'bar.dart';
 export 'bar.dart';
 import 'package:angular2/src/reflection/reflection.dart' as _ngRef;
-import 'package:angular2/src/core/annotations_impl/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 
 var _visited = false;
 void initReflector() {
diff --git a/modules/angular2/test/transform/integration/two_annotations_files/bar.dart b/modules/angular2/test/transform/integration/two_annotations_files/bar.dart
index 85ae2eec85..e5079c3a1e 100644
--- a/modules/angular2/test/transform/integration/two_annotations_files/bar.dart
+++ b/modules/angular2/test/transform/integration/two_annotations_files/bar.dart
@@ -1,7 +1,6 @@
 library bar;
 
-import 'package:angular2/src/core/annotations_impl/annotations.dart';
-import 'package:angular2/src/core/annotations_impl/view.dart';
+import 'package:angular2/src/core/metadata.dart';
 
 @Component(selector: '[soup]')
 @View(template: 'Salad: {{myNum}} is awesome')
diff --git a/modules/angular2/test/transform/integration/two_annotations_files/expected/bar.ng_deps.dart b/modules/angular2/test/transform/integration/two_annotations_files/expected/bar.ng_deps.dart
index 1e63908547..bf8b4bd191 100644
--- a/modules/angular2/test/transform/integration/two_annotations_files/expected/bar.ng_deps.dart
+++ b/modules/angular2/test/transform/integration/two_annotations_files/expected/bar.ng_deps.dart
@@ -6,8 +6,7 @@ import 'package:angular2/src/change_detection/pregen_proto_change_detector.dart'
 import 'bar.dart';
 export 'bar.dart';
 import 'package:angular2/src/reflection/reflection.dart' as _ngRef;
-import 'package:angular2/src/core/annotations_impl/annotations.dart';
-import 'package:angular2/src/core/annotations_impl/view.dart';
+import 'package:angular2/src/core/metadata.dart';
 
 var _visited = false;
 void initReflector() {
diff --git a/modules/angular2/test/transform/integration/two_deps_files/bar.dart b/modules/angular2/test/transform/integration/two_deps_files/bar.dart
index bfbf1cc444..9c354b4e09 100644
--- a/modules/angular2/test/transform/integration/two_deps_files/bar.dart
+++ b/modules/angular2/test/transform/integration/two_deps_files/bar.dart
@@ -1,6 +1,6 @@
 library bar;
 
-import 'package:angular2/src/core/annotations_impl/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 import 'foo.dart' as prefix;
 
 @Component(selector: 'soup')
diff --git a/modules/angular2/test/transform/integration/two_deps_files/expected/bar.ng_deps.dart b/modules/angular2/test/transform/integration/two_deps_files/expected/bar.ng_deps.dart
index 6d99c1a3f9..89ac6d7fd6 100644
--- a/modules/angular2/test/transform/integration/two_deps_files/expected/bar.ng_deps.dart
+++ b/modules/angular2/test/transform/integration/two_deps_files/expected/bar.ng_deps.dart
@@ -3,7 +3,7 @@ library bar.ng_deps.dart;
 import 'bar.dart';
 export 'bar.dart';
 import 'package:angular2/src/reflection/reflection.dart' as _ngRef;
-import 'package:angular2/src/core/annotations_impl/annotations.dart';
+import 'package:angular2/src/core/metadata.dart';
 import 'foo.dart' as prefix;
 
 var _visited = false;
diff --git a/modules/angular2/test/web-workers/worker/renderer_spec.ts b/modules/angular2/test/web-workers/worker/renderer_spec.ts
index bed65f80f1..6f8f8ac2de 100644
--- a/modules/angular2/test/web-workers/worker/renderer_spec.ts
+++ b/modules/angular2/test/web-workers/worker/renderer_spec.ts
@@ -17,7 +17,7 @@ import {Serializer} from "angular2/src/web-workers/shared/serializer";
 import {isPresent, isBlank, BaseException, Type} from "angular2/src/facade/lang";
 import {MapWrapper, ListWrapper} from "angular2/src/facade/collection";
 import {
-  DirectiveMetadata,
+  RenderDirectiveMetadata,
   ProtoViewDto,
   RenderProtoViewRef,
   RenderViewWithFragments,
@@ -98,8 +98,8 @@ export function main() {
     it('should build the proto view', inject([AsyncTestCompleter], (async) => {
          var compiler: WebWorkerCompiler = createWorkerCompiler(workerSerializer, uiSerializer, tb);
 
-         var dirMetadata = DirectiveMetadata.create(
-             {id: 'id', selector: 'custom', type: DirectiveMetadata.COMPONENT_TYPE});
+         var dirMetadata = RenderDirectiveMetadata.create(
+             {id: 'id', selector: 'custom', type: RenderDirectiveMetadata.COMPONENT_TYPE});
          compiler.compileHost(dirMetadata)
              .then((protoView) => {
                expect(DOM.tagName(DOM.firstChild(DOM.content(
diff --git a/modules/benchmarks/src/compiler/compiler_benchmark.ts b/modules/benchmarks/src/compiler/compiler_benchmark.ts
index bda36b8961..f69bfc6109 100644
--- a/modules/benchmarks/src/compiler/compiler_benchmark.ts
+++ b/modules/benchmarks/src/compiler/compiler_benchmark.ts
@@ -13,7 +13,6 @@ import {Compiler, CompilerCache} from 'angular2/src/core/compiler/compiler';
 import {DirectiveResolver} from 'angular2/src/core/compiler/directive_resolver';
 import {PipeResolver} from 'angular2/src/core/compiler/pipe_resolver';
 
-import * as viewModule from 'angular2/src/core/annotations_impl/view';
 import {Component, Directive, View} from 'angular2/angular2';
 import {ViewResolver} from 'angular2/src/core/compiler/view_resolver';
 import {UrlResolver} from 'angular2/src/services/url_resolver';
@@ -122,10 +121,10 @@ class MultipleViewResolver extends ViewResolver {
     this._cache.set(component, ListWrapper.join(multiplier, ''));
   }
 
-  resolve(component: Type): viewModule.View {
+  resolve(component: Type): View {
     var view = super.resolve(component);
-    var myView = new viewModule.View(
-        {template:<string>this._cache.get(component), directives: view.directives});
+    var myView =
+        new View({template:<string>this._cache.get(component), directives: view.directives});
     return myView;
   }
 }
diff --git a/modules_dart/analyzer_plugin/lib/src/tasks.dart b/modules_dart/analyzer_plugin/lib/src/tasks.dart
index 2b9b963674..a495b713ee 100644
--- a/modules_dart/analyzer_plugin/lib/src/tasks.dart
+++ b/modules_dart/analyzer_plugin/lib/src/tasks.dart
@@ -8,11 +8,11 @@ import 'package:analyzer/task/model.dart';
 import 'package:angular2/src/render/api.dart';
 import 'package:angular2/src/transform/common/directive_metadata_reader.dart';
 
-/// The [DirectiveMetadata]s of a [LibrarySpecificUnit].
-final ListResultDescriptor<DirectiveMetadata> DIRECTIVES =
-    new ListResultDescriptor<DirectiveMetadata>('ANGULAR2_DIRECTIVES', null);
+/// The [RenderDirectiveMetadata]s of a [LibrarySpecificUnit].
+final ListResultDescriptor<RenderDirectiveMetadata> DIRECTIVES =
+    new ListResultDescriptor<RenderDirectiveMetadata>('ANGULAR2_DIRECTIVES', null);
 
-/// A task that builds [DirectiveMetadata]s for directive classes.
+/// A task that builds [RenderDirectiveMetadata]s for directive classes.
 class BuildUnitDirectivesTask extends SourceBasedAnalysisTask {
   static const String UNIT_INPUT = 'UNIT_INPUT';
 
@@ -29,10 +29,10 @@ class BuildUnitDirectivesTask extends SourceBasedAnalysisTask {
   @override
   void internalPerform() {
     CompilationUnit unit = getRequiredInput(UNIT_INPUT);
-    List<DirectiveMetadata> metaList = <DirectiveMetadata>[];
+    List<RenderDirectiveMetadata> metaList = <RenderDirectiveMetadata>[];
     for (CompilationUnitMember unitMember in unit.declarations) {
       if (unitMember is ClassDeclaration) {
-        DirectiveMetadata meta = readDirectiveMetadata(unitMember.metadata);
+        RenderDirectiveMetadata meta = readDirectiveMetadata(unitMember.metadata);
         if (meta != null) {
           metaList.add(meta);
         }
diff --git a/modules_dart/analyzer_plugin/test/tasks_test.server.spec.dart b/modules_dart/analyzer_plugin/test/tasks_test.server.spec.dart
index dc896f6712..82393ca9aa 100644
--- a/modules_dart/analyzer_plugin/test/tasks_test.server.spec.dart
+++ b/modules_dart/analyzer_plugin/test/tasks_test.server.spec.dart
@@ -34,7 +34,7 @@ class BuildUnitDirectivesTaskTest extends _AbstractDartTaskTest {
   void test_Component() {
     _addAngularSources();
     Source source = _newSource('/test.dart', r'''
-import '/angular2/annotations.dart';
+import '/angular2/metadata.dart';
 
 @Component(selector: 'comp-a')
 class ComponentA {
@@ -57,7 +57,7 @@ class ComponentB {
   void test_Directive() {
     _addAngularSources();
     Source source = _newSource('/test.dart', r'''
-import '/angular2/annotations.dart';
+import '/angular2/metadata.dart';
 
 @Directive(selector: 'deco-a')
 class ComponentA {
@@ -78,12 +78,12 @@ class ComponentB {
   }
 
   void _addAngularSources() {
-    _newSource('/angular2/annotations.dart', r'''
-library angular2.src.core.annotations.annotations;
+    _newSource('/angular2/metadata.dart', r'''
+library angular2.src.core.metadata;
 
 abstract class Directive {
   final String selector;
-  final dynamic properties; 
+  final dynamic properties;
   final dynamic hostListeners;
   final List lifecycle;
   const Directive({selector, properties, hostListeners, lifecycle})