private _deserializeRenderProtoViewMergeMapping(obj: StringMap<string, any>):
     RenderProtoViewMergeMapping {
   return new RenderProtoViewMergeMapping(
       this._protoViewStore.deserialize(obj['mergedProtoViewRef']), obj['fragmentCount'],
       obj['mappedElementIndices'], obj['mappedElementCount'], obj['mappedTextIndices'],
       obj['hostElementIndicesByViewIndex'], obj['nestedViewCountByViewIndex']);
 }

 private _deserializeProtoViewDto(obj: StringMap<string, any>): ProtoViewDto {
   return new ProtoViewDto({
     render: this._protoViewStore.deserialize(obj["render"]),
     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)),
     transitiveNgContentCount: obj['transitiveNgContentCount']
   });
 }

 private _serializeProtoViewDto(view: ProtoViewDto): Object {
   return {
     'render': this._protoViewStore.serialize(view.render),
     'elementBinders': this.serialize(view.elementBinders, RenderElementBinder),
     'variableBindings': this.mapToObject(view.variableBindings),
     'type': serializeEnum(view.type),
     'textBindings': this.serialize(view.textBindings, ASTWithSource),
     'transitiveNgContentCount': view.transitiveNgContentCount
   };
 }

 private _serializeRenderProtoViewMergeMapping(mapping: RenderProtoViewMergeMapping): Object {
   return {
     'mergedProtoViewRef': this._protoViewStore.serialize(mapping.mergedProtoViewRef),
     'fragmentCount': mapping.fragmentCount,
     'mappedElementIndices': mapping.mappedElementIndices,
     'mappedElementCount': mapping.mappedElementCount,
     'mappedTextIndices': mapping.mappedTextIndices,
     'hostElementIndicesByViewIndex': mapping.hostElementIndicesByViewIndex,
     'nestedViewCountByViewIndex': mapping.nestedViewCountByViewIndex
   };
 }

  deserialize(map: any, type: Type, data?: any): any {
    if (!isPresent(map)) {
      return null;
    }
    if (isArray(map)) {
      var obj: List<any> = new List<any>();
      ListWrapper.forEach(map, (val) => { obj.push(this.deserialize(val, type, data)); });
      return obj;
    }
    if (type == PRIMITIVE) {
      return map;
    }

    if (type == ViewDefinition) {
      return this._deserializeViewDefinition(map);
    } else if (type == DirectiveBinder) {
      return this._deserializeDirectiveBinder(map);
    } else if (type == ProtoViewDto) {
      return this._deserializeProtoViewDto(map);
    } else if (type == RenderDirectiveMetadata) {
      return this._deserializeDirectiveMetadata(map);
    } else if (type == RenderElementBinder) {
      return this._deserializeElementBinder(map);
    } else if (type == ASTWithSource) {
      return this._deserializeASTWithSource(map, data);
    } else if (type == RenderProtoViewRef) {
      return this._protoViewStore.deserialize(map);
    } else if (type == RenderProtoViewMergeMapping) {
      return this._deserializeRenderProtoViewMergeMapping(map);
    } else if (type == RenderViewRef) {
      return this._renderViewStore.deserializeRenderViewRef(map);
    } else if (type == RenderFragmentRef) {
      return this._renderViewStore.deserializeRenderFragmentRef(map);
    } else if (type == WebWorkerElementRef) {
      return this._deserializeWorkerElementRef(map);
    } else if (type == EventBinding) {
      return this._deserializeEventBinding(map);
    } else if (type == ElementPropertyBinding) {
      return this._deserializeElementPropertyBinding(map);
    } else {
      throw new BaseException("No deserializer for " + type.toString());
    }
  }

 private _createProtoView(componentTemplateId: string, cmds: RenderTemplateCmd[],
                          refIndex: number) {
   var protoViewRef = this._renderer.createProtoView(componentTemplateId, cmds);
   this._renderProtoViewRefStore.store(protoViewRef, refIndex);
 }