angular-cn/tools/public_api_guard/public_api_spec.ts

import {publicApi} from 'ts-api-guardian';

// =================================================================================================
// =================================================================================================
// =========== S T O P   -  S T O P   -  S T O P   -  S T O P   -  S T O P   -  S T O P  ===========
// =================================================================================================
// =================================================================================================
//
// DO NOT EDIT THIS LIST OF PUBLIC APIS UNLESS YOU GET IT CLEARED BY: mhevery, vsavkin, or tbosch!
//
// =================================================================================================
// =================================================================================================

const CORE = [
  'AbstractProviderError',
  'AbstractProviderError.addKey(injector:ReflectiveInjector, key:ReflectiveKey):void',
  'AbstractProviderError.constructResolvingMessage:Function',
  'AbstractProviderError.constructor(injector:ReflectiveInjector, key:ReflectiveKey, constructResolvingMessage:Function)',
  'AbstractProviderError.context:any',
  'AbstractProviderError.injectors:ReflectiveInjector[]',
  'AbstractProviderError.keys:ReflectiveKey[]',
  'AbstractProviderError.message:string',
  'AfterContentChecked',
  'AfterContentChecked.ngAfterContentChecked():any',
  'AfterContentInit',
  'AfterContentInit.ngAfterContentInit():any',
  'AfterViewChecked',
  'AfterViewChecked.ngAfterViewChecked():any',
  'AfterViewInit',
  'AfterViewInit.ngAfterViewInit():any',
  'ApplicationRef',
  'ApplicationRef.bootstrap(componentFactory:ComponentFactory):ComponentRef',
  'ApplicationRef.componentTypes:Type[]',
  'ApplicationRef.dispose():void',
  'ApplicationRef.injector:Injector',
  'ApplicationRef.registerBootstrapListener(listener:(ref: ComponentRef) => void):void',
  'ApplicationRef.registerDisposeListener(dispose:() => void):void',
  'ApplicationRef.tick():void',
  'ApplicationRef.run(callback:Function):any',
  'ApplicationRef.waitForAsyncInitializers():Promise<any>',
  'ApplicationRef.zone:NgZone',
  'AttributeMetadataFactory',
  'AttributeMetadata',
  'AttributeMetadata.constructor(attributeName:string)',
  'AttributeMetadata.toString():string',
  'AttributeMetadata.token:AttributeMetadata',
  'Binding',
  'Binding.constructor(token:any, {toClass,toValue,toAlias,toFactory,deps,multi}:{toClass?:Type, toValue?:any, toAlias?:any, toFactory:Function, deps?:Object[], multi?:boolean})',
  'Binding.toAlias:any',
  'Binding.toClass:any',
  'Binding.toFactory:any',
  'Binding.toValue:any',
  'ChangeDetectionStrategy',
  'ChangeDetectionStrategy.CheckAlways',
  'ChangeDetectionStrategy.CheckOnce',
  'ChangeDetectionStrategy.Checked',
  'ChangeDetectionStrategy.Default',
  'ChangeDetectionStrategy.Detached',
  'ChangeDetectionStrategy.OnPush',
  'ChangeDetectorRef',
  'ChangeDetectorRef.checkNoChanges():void',
  'ChangeDetectorRef.detach():void',
  'ChangeDetectorRef.detectChanges():void',
  'ChangeDetectorRef.markForCheck():void',
  'ChangeDetectorRef.reattach():void',
  'Class(clsDef:ClassDefinition):ConcreteType',
  'ClassDefinition',
  'ClassDefinition.constructor:Function|any[]',
  'ClassDefinition.extends:Type',
  'CollectionChangeRecord',
  'CollectionChangeRecord.constructor(item:any, trackById:any)',
  'CollectionChangeRecord.currentIndex:number',
  'CollectionChangeRecord.previousIndex:number',
  'CollectionChangeRecord.toString():string',
  'ComponentResolver',
  'ComponentResolver.clearCache():any',
  'ComponentResolver.resolveComponent(componentType:Type):Promise<ComponentFactory>',
  'ComponentDecorator',
  'ComponentDecorator.View(obj:{templateUrl?:string, template?:string, directives?:Array<Type|any[]>, pipes?:Array<Type|any[]>, renderer?:string, styles?:string[], styleUrls?:string[]}):ViewDecorator',
  'ComponentMetadataFactory',
  'ComponentMetadata',
  'ComponentMetadata.changeDetection:ChangeDetectionStrategy',
  'ComponentMetadata.constructor({selector,inputs,outputs,properties,events,host,exportAs,moduleId,bindings,providers,viewBindings,viewProviders,changeDetection=ChangeDetectionStrategy.Default,queries,templateUrl,template,styleUrls,styles,directives,pipes,encapsulation}:{selector?:string, inputs?:string[], outputs?:string[], properties?:string[], events?:string[], host?:{[key:string]:string}, bindings?:any[], providers?:any[], exportAs?:string, moduleId?:string, viewBindings?:any[], viewProviders?:any[], queries?:{[key:string]:any}, changeDetection?:ChangeDetectionStrategy, templateUrl?:string, template?:string, styleUrls?:string[], styles?:string[], directives?:Array<Type|any[]>, pipes?:Array<Type|any[]>, encapsulation?:ViewEncapsulation})',
  'ComponentMetadata.directives:Array<Type|any[]>',
  'ComponentMetadata.encapsulation:ViewEncapsulation',
  'ComponentMetadata.moduleId:string',
  'ComponentMetadata.pipes:Array<Type|any[]>',
  'ComponentMetadata.styleUrls:string[]',
  'ComponentMetadata.styles:string[]',
  'ComponentMetadata.template:string',
  'ComponentMetadata.templateUrl:string',
  'ComponentMetadata.viewBindings:any[]',
  'ComponentMetadata.viewProviders:any[]',
  'ComponentRef',
  'ComponentRef.componentType:Type',
  'ComponentRef.injector:Injector',
  'ComponentRef.instance:any',
  'ComponentRef.location:ElementRef',
  'ComponentRef.destroy():void',
  'ComponentRef.hostView:ViewRef',
  'ComponentRef.onDestroy(callback:Function):void',
  'ComponentRef.changeDetectorRef:ChangeDetectorRef',
  'ConcreteType',
  'ContentChildMetadataFactory',
  'ContentChildMetadata',
  'ContentChildMetadata.constructor(_selector:Type|string, {read=null}:{read?:any})',
  'ContentChildrenMetadataFactory',
  'ContentChildrenMetadata',
  'ContentChildrenMetadata.constructor(_selector:Type|string, {descendants=false,read=null}:{descendants?:boolean, read?:any})',
  'CyclicDependencyError',
  'CyclicDependencyError.constructor(injector:ReflectiveInjector, key:ReflectiveKey)',
  'DebugNode',
  'DebugNode.componentInstance:any',
  'DebugNode.constructor(nativeNode:any, parent:DebugNode, _debugInfo:RenderDebugInfo)',
  'DebugNode.inject(token:any):any',
  'DebugNode.injector:Injector',
  'DebugNode.listeners:EventListener[]',
  'DebugNode.nativeNode:any',
  'DebugNode.parent:DebugElement',
  'DebugNode.providerTokens:any[]',
  'DebugNode.source:string',
  'DebugNode.context:any',
  'DebugNode.references:{[key:string]:any}',
  'DebugElement',
  'DebugElement.children:DebugElement[]',
  'DebugElement.nativeElement:any',
  'DebugElement.addChild(child:DebugNode):any',
  'DebugElement.attributes:{[key:string]:string}',
  'DebugElement.childNodes:DebugNode[]',
  'DebugElement.constructor(nativeNode:any, parent:any, _debugInfo:RenderDebugInfo)',
  'DebugElement.insertChildrenAfter(child:DebugNode, newChildren:DebugNode[]):any',
  'DebugElement.name:string',
  'DebugElement.properties:{[key:string]:string}',
  'DebugElement.query(predicate:Predicate<DebugElement>):DebugElement',
  'DebugElement.queryAll(predicate:Predicate<DebugElement>):DebugElement[]',
  'DebugElement.queryAllNodes(predicate:Predicate<DebugNode>):DebugNode[]',
  'DebugElement.removeChild(child:DebugNode):any',
  'DebugElement.triggerEventHandler(eventName:string, eventObj:any):any',
  'asNativeElements(debugEls:DebugElement[]):any',
  'ReflectiveDependency',
  'ReflectiveDependency.constructor(key:ReflectiveKey, optional:boolean, lowerBoundVisibility:any, upperBoundVisibility:any, properties:any[])',
  'ReflectiveDependency.fromKey(key:ReflectiveKey):ReflectiveDependency',
  'DependencyMetadata',
  'DependencyMetadata.token:any',
  'DirectiveDecorator',
  'DirectiveMetadataFactory',
  'DirectiveMetadata',
  'DirectiveMetadata.bindings:any[]',
  'DirectiveMetadata.constructor({selector,inputs,outputs,properties,events,host,bindings,providers,exportAs,queries}:{selector?:string, inputs?:string[], outputs?:string[], properties?:string[], events?:string[], host?:{[key:string]:string}, providers?:any[], bindings?:any[], exportAs?:string, queries?:{[key:string]:any}})',
  'DirectiveMetadata.events:string[]',
  'DirectiveMetadata.exportAs:string',
  'DirectiveMetadata.host:{[key:string]:string}',
  'DirectiveMetadata.inputs:string[]',
  'DirectiveMetadata.outputs:string[]',
  'DirectiveMetadata.properties:string[]',
  'DirectiveMetadata.providers:any[]',
  'DirectiveMetadata.queries:{[key:string]:any}',
  'DirectiveMetadata.selector:string',
  'DoCheck',
  'DoCheck.ngDoCheck():any',
  'DynamicComponentLoader',
  'DynamicComponentLoader.loadAsRoot(type:Type, overrideSelectorOrNode:string|any, injector:Injector, onDispose:() => void, projectableNodes:any[][]):Promise<ComponentRef>',
  'DynamicComponentLoader.loadNextToLocation(type:Type, location:ViewContainerRef, providers:ResolvedReflectiveProvider[], projectableNodes:any[][]):Promise<ComponentRef>',
  'ElementRef',
  'ElementRef.nativeElement:any',
  'ElementRef.constructor(nativeElement:any)',
  'EmbeddedViewRef<C>',
  'EmbeddedViewRef.context:C',
  'EmbeddedViewRef.rootNodes:any[]',
  'EmbeddedViewRef.destroy():any',
  'EventEmitter.constructor(isAsync:boolean)',
  'EventEmitter.emit(value:T):any',
  'EventEmitter.next(value:any):any',
  'EventEmitter.subscribe(generatorOrNext:any, error:any, complete:any):any',
  'EventEmitter<T>',
  'ExceptionHandler',
  'ExceptionHandler.call(exception:any, stackTrace:any, reason:string):void',
  'ExceptionHandler.constructor(_logger:any, _rethrowException:boolean)',
  'ExceptionHandler.exceptionToString(exception:any, stackTrace:any, reason:string):string',
  'ExpressionChangedAfterItHasBeenCheckedException',
  'ExpressionChangedAfterItHasBeenCheckedException.constructor(oldValue:any, currValue:any, context:any)',
  'ForwardRefFn',
  'GetTestability',
  'GetTestability.addToWindow(registry:TestabilityRegistry):void',
  'GetTestability.findTestabilityInTree(registry:TestabilityRegistry, elem:any, findInAncestors:boolean):Testability',
  'HostBindingMetadataFactory',
  'HostBindingMetadata',
  'HostBindingMetadata.constructor(hostPropertyName:string)',
  'HostMetadataFactory',
  'HostListenerMetadataFactory',
  'HostListenerMetadata',
  'HostListenerMetadata.constructor(eventName:string, args:string[])',
  'HostMetadata',
  'HostMetadata.toString():string',
  'ComponentFactory',
  'ComponentFactory.componentType:Type',
  'ComponentFactory.constructor(selector:string, _viewFactory:Function, _componentType:Type)',
  'ComponentFactory.create(injector:Injector, projectableNodes:any[][], rootSelectorOrNode:string|any):ComponentRef',
  'InjectMetadataFactory',
  'InjectMetadata',
  'InjectMetadata.constructor(token:any)',
  'InjectMetadata.toString():string',
  'InjectableMetadataFactory',
  'InjectableMetadata',
  'InjectableMetadata.constructor()',
  'Injector',
  'Injector.THROW_IF_NOT_FOUND:any',
  'Injector.get(token:any, notFoundValue:any):any',
  'ReflectiveInjector',
  'ReflectiveInjector.createChildFromResolved(providers:ResolvedReflectiveProvider[]):ReflectiveInjector',
  'ReflectiveInjector.debugContext():any',
  'ReflectiveInjector.fromResolvedBindings(providers:ResolvedReflectiveProvider[]):ReflectiveInjector',
  'ReflectiveInjector.fromResolvedProviders(providers:ResolvedReflectiveProvider[], parent:Injector):ReflectiveInjector',
  'ReflectiveInjector.get(token:any, notFoundValue:any):any',
  'ReflectiveInjector.instantiateResolved(provider:ResolvedReflectiveProvider):any',
  'ReflectiveInjector.parent:Injector',
  'ReflectiveInjector.resolve(providers:Array<Type|Provider|{[k:string]:any}|any[]>):ResolvedReflectiveProvider[]',
  'ReflectiveInjector.resolveAndCreate(providers:Array<Type|Provider|{[k:string]:any}|any[]>, parent:Injector):ReflectiveInjector',
  'ReflectiveInjector.resolveAndCreateChild(providers:Array<Type|Provider|{[k:string]:any}|any[]>):ReflectiveInjector',
  'ReflectiveInjector.resolveAndInstantiate(provider:Type|Provider):any',
  'InputMetadataFactory',
  'InputMetadata',
  'InputMetadata.constructor(bindingPropertyName:string)',
  'InstantiationError',
  'InstantiationError.addKey(injector:ReflectiveInjector, key:ReflectiveKey):void',
  'InstantiationError.causeKey:ReflectiveKey',
  'InstantiationError.constructor(injector:ReflectiveInjector, originalException:any, originalStack:any, key:ReflectiveKey)',
  'InstantiationError.context:any',
  'InstantiationError.injectors:ReflectiveInjector[]',
  'InstantiationError.keys:ReflectiveKey[]',
  'InstantiationError.wrapperMessage:string',
  'InvalidProviderError',
  'InvalidProviderError.constructor(provider:any)',
  'IterableDiffer',
  'IterableDiffer.diff(object:any):any',
  'IterableDiffer.onDestroy():any',
  'IterableDifferFactory',
  'IterableDifferFactory.create(cdRef:ChangeDetectorRef, trackByFn:TrackByFn):IterableDiffer',
  'IterableDifferFactory.supports(objects:any):boolean',
  'IterableDiffers',
  'IterableDiffers.constructor(factories:IterableDifferFactory[])',
  'IterableDiffers.create(factories:IterableDifferFactory[], parent:IterableDiffers):IterableDiffers',
  'IterableDiffers.extend(factories:IterableDifferFactory[]):Provider',
  'IterableDiffers.find(iterable:any):IterableDifferFactory',
  'ReflectiveKey',
  'ReflectiveKey.constructor(token:Object, id:number)',
  'ReflectiveKey.displayName:string',
  'ReflectiveKey.get(token:Object):ReflectiveKey',
  'ReflectiveKey.numberOfKeys:number',
  'KeyValueChangeRecord',
  'KeyValueChangeRecord.constructor(key:any)',
  'KeyValueChangeRecord.currentValue:any',
  'KeyValueChangeRecord.previousValue:any',
  'KeyValueChangeRecord.toString():string',
  'KeyValueDiffer',
  'KeyValueDiffer.diff(object:any):any',
  'KeyValueDiffer.onDestroy():any',
  'KeyValueDifferFactory',
  'KeyValueDifferFactory.create(cdRef:ChangeDetectorRef):KeyValueDiffer',
  'KeyValueDifferFactory.supports(objects:any):boolean',
  'KeyValueDiffers',
  'KeyValueDiffers.constructor(factories:KeyValueDifferFactory[])',
  'KeyValueDiffers.create(factories:KeyValueDifferFactory[], parent:KeyValueDiffers):KeyValueDiffers',
  'KeyValueDiffers.extend(factories:KeyValueDifferFactory[]):Provider',
  'KeyValueDiffers.find(kv:Object):KeyValueDifferFactory',
  'NgZone',
  'NgZone.constructor({enableLongStackTrace=false}:any)',
  'NgZone.assertInAngularZone():void',
  'NgZone.assertNotInAngularZone():void',
  'NgZone.isInAngularZone():boolean',
  'NgZone.hasPendingMacrotasks:boolean',
  'NgZone.hasPendingMicrotasks:boolean',
  'NgZone.onError:EventEmitter<any>',
  'NgZone.onStable:EventEmitter<any>',
  'NgZone.onMicrotaskEmpty:EventEmitter<any>',
  'NgZone.onUnstable:EventEmitter<any>',
  'NgZone.run(fn:() => any):any',
  'NgZone.runGuarded(fn:() => any):any',
  'NgZone.runOutsideAngular(fn:() => any):any',
  'NgZoneError',
  'NgZoneError.constructor(error:any, stackTrace:any)',
  'NoAnnotationError',
  'NoAnnotationError.constructor(typeOrFunc:any, params:any[][])',
  'NoProviderError',
  'NoProviderError.constructor(injector:ReflectiveInjector, key:ReflectiveKey)',
  'OnChanges',
  'OnChanges.ngOnChanges(changes:{[key:string]:SimpleChange}):any',
  'OnDestroy',
  'OnDestroy.ngOnDestroy():any',
  'OnInit',
  'OnInit.ngOnInit():any',
  'OpaqueToken',
  'OpaqueToken.constructor(_desc:string)',
  'OpaqueToken.toString():string',
  'OptionalMetadataFactory',
  'OptionalMetadata',
  'OptionalMetadata.toString():string',
  'OutOfBoundsError',
  'OutOfBoundsError.constructor(index:any)',
  'OutputMetadataFactory',
  'OutputMetadata',
  'OutputMetadata.constructor(bindingPropertyName:string)',
  'PipeMetadataFactory',
  'PipeMetadata',
  'PipeMetadata.constructor({name,pure}:{name:string, pure?:boolean})',
  'PipeMetadata.name:string',
  'PipeMetadata.pure:boolean',
  'PipeTransform',
  'PipeTransform.transform(value:any, args:any[]):any',
  'PlatformRef',
  'PlatformRef.dispose():void',
  'PlatformRef.injector:Injector',
  'PlatformRef.registerDisposeListener(dispose:() => void):void',
  'PlatformRef.disposed:boolean',
  'Provider',
  'Provider.constructor(token:any, {useClass,useValue,useExisting,useFactory,deps,multi}:{useClass?:Type, useValue?:any, useExisting?:any, useFactory?:Function, deps?:Object[], multi?:boolean})',
  'Provider.dependencies:Object[]',
  'Provider.multi:boolean',
  'Provider.token:any',
  'Provider.useClass:Type',
  'Provider.useExisting:any',
  'Provider.useFactory:Function',
  'Provider.useValue:any',
  'ProviderBuilder',
  'ProviderBuilder.constructor(token:any)',
  'ProviderBuilder.toAlias(aliasToken:any):Provider',
  'ProviderBuilder.toClass(type:Type):Provider',
  'ProviderBuilder.toFactory(factory:Function, dependencies:any[]):Provider',
  'ProviderBuilder.toValue(value:any):Provider',
  'QueryMetadataFactory',
  'QueryList.changes:Observable<any>',
  'QueryList.dirty:any',
  'QueryList.filter(fn:(item: T) => boolean):T[]',
  'QueryList.first:T',
  'QueryList.forEach(fn:(item: T) => void):void',
  'QueryList.last:T',
  'QueryList.length:number',
  'QueryList.map(fn:(item: T) => U):U[]',
  'QueryList.notifyOnChanges():void',
  'QueryList.reduce(fn:(acc: U, item: T) => U, init:U):U',
  'QueryList.reset(res:Array<T|any[]>):void',
  'QueryList.setDirty():any',
  'QueryList.toArray():T[]',
  'QueryList.toString():string',
  'QueryList<T>',
  'QueryMetadata',
  'QueryMetadata.constructor(_selector:Type|string, {descendants=false,first=false,read=null}:{descendants?:boolean, first?:boolean, read?:any})',
  'QueryMetadata.read:any',
  'QueryMetadata.descendants:boolean',
  'QueryMetadata.first:boolean',
  'QueryMetadata.isVarBindingQuery:boolean',
  'QueryMetadata.isViewQuery:boolean',
  'QueryMetadata.selector:any',
  'QueryMetadata.toString():string',
  'QueryMetadata.varBindings:string[]',
  'ReflectionInfo',
  'ReflectionInfo.constructor(annotations:any[], parameters:any[][], factory:Function, interfaces:any[], propMetadata:{[key:string]:any[]})',
  'Reflector',
  'Reflector.annotations(typeOrFunc:any):any[]',
  'Reflector.constructor(reflectionCapabilities:PlatformReflectionCapabilities)',
  'Reflector.factory(type:Type):Function',
  'Reflector.getter(name:string):GetterFn',
  'Reflector.importUri(type:Type):string',
  'Reflector.interfaces(type:Type):any[]',
  'Reflector.isReflectionEnabled():boolean',
  'Reflector.listUnusedKeys():any[]',
  'Reflector.method(name:string):MethodFn',
  'Reflector.parameters(typeOrFunc:any):any[][]',
  'Reflector.propMetadata(typeOrFunc:any):{[key:string]:any[]}',
  'Reflector.reflectionCapabilities:PlatformReflectionCapabilities',
  'Reflector.registerFunction(func:Function, funcInfo:ReflectionInfo):void',
  'Reflector.registerGetters(getters:{[key:string]:GetterFn}):void',
  'Reflector.registerMethods(methods:{[key:string]:MethodFn}):void',
  'Reflector.registerSetters(setters:{[key:string]:SetterFn}):void',
  'Reflector.registerType(type:Type, typeInfo:ReflectionInfo):void',
  'Reflector.setter(name:string):SetterFn',
  'Reflector.trackUsage():void',
  'RenderComponentType',
  'RenderComponentType.constructor(id:string, templateUrl:string, slotCount:number, encapsulation:ViewEncapsulation, styles:Array<string|any[]>)',
  'Renderer',
  'Renderer.attachViewAfter(node:any, viewRootNodes:any[]):void',
  'Renderer.createElement(parentElement:any, name:string, debugInfo:RenderDebugInfo):any',
  'Renderer.createTemplateAnchor(parentElement:any, debugInfo:RenderDebugInfo):any',
  'Renderer.createText(parentElement:any, value:string, debugInfo:RenderDebugInfo):any',
  'Renderer.createViewRoot(hostElement:any):any',
  'Renderer.destroyView(hostElement:any, viewAllNodes:any[]):void',
  'Renderer.detachView(viewRootNodes:any[]):void',
  'Renderer.invokeElementMethod(renderElement:any, methodName:string, args:any[]):any',
  'Renderer.listen(renderElement:any, name:string, callback:Function):Function',
  'Renderer.listenGlobal(target:string, name:string, callback:Function):Function',
  'Renderer.projectNodes(parentElement:any, nodes:any[]):void',
  'Renderer.selectRootElement(selectorOrNode:string|any, debugInfo:RenderDebugInfo):any',
  'Renderer.setBindingDebugInfo(renderElement:any, propertyName:string, propertyValue:string):void',
  'Renderer.setElementAttribute(renderElement:any, attributeName:string, attributeValue:string):void',
  'Renderer.setElementClass(renderElement:any, className:string, isAdd:boolean):any',
  'Renderer.setElementProperty(renderElement:any, propertyName:string, propertyValue:any):void',
  'Renderer.setElementStyle(renderElement:any, styleName:string, styleValue:string):any',
  'Renderer.setText(renderNode:any, text:string):any',
  'ResolvedReflectiveBinding',
  'ResolvedReflectiveFactory',
  'ResolvedReflectiveFactory.constructor(factory:Function, dependencies:ReflectiveDependency[])',
  'ResolvedReflectiveProvider',
  'ResolvedReflectiveProvider.key:ReflectiveKey',
  'ResolvedReflectiveProvider.multiProvider:boolean',
  'ResolvedReflectiveProvider.resolvedFactories:ResolvedReflectiveFactory[]',
  'RootRenderer',
  'RootRenderer.renderComponent(componentType:RenderComponentType):Renderer',
  'SelfMetadataFactory',
  'SelfMetadata',
  'SelfMetadata.toString():string',
  'SimpleChange',
  'SimpleChange.constructor(previousValue:any, currentValue:any)',
  'SimpleChange.isFirstChange():boolean',
  'SkipSelfMetadataFactory',
  'SkipSelfMetadata',
  'SkipSelfMetadata.toString():string',
  'TemplateRef<C>',
  'TemplateRef.elementRef:ElementRef',
  'TemplateRef.createEmbeddedView(context:C):EmbeddedViewRef<C>',
  'Testability',
  'Testability.constructor(_ngZone:NgZone)',
  'Testability.decreasePendingRequestCount():number',
  'Testability.findBindings(using:any, provider:string, exactMatch:boolean):any[]',
  'Testability.findProviders(using:any, provider:string, exactMatch:boolean):any[]',
  'Testability.getPendingRequestCount():number',
  'Testability.increasePendingRequestCount():number',
  'Testability.isStable():boolean',
  'Testability.whenStable(callback:Function):void',
  'TestabilityRegistry',
  'TestabilityRegistry.constructor()',
  'TestabilityRegistry.findTestabilityInTree(elem:Node, findInAncestors:boolean):Testability',
  'TestabilityRegistry.getAllTestabilities():Testability[]',
  'TestabilityRegistry.getAllRootElements():any[]',
  'TestabilityRegistry.getTestability(elem:any):Testability',
  'TestabilityRegistry.registerApplication(token:any, testability:Testability):any',
  'TrackByFn',
  'TypeDecorator',
  'TypeDecorator.Class(obj:ClassDefinition):ConcreteType',
  'TypeDecorator.annotations:any[]',
  'ViewChildMetadataFactory',
  'ViewChildMetadata',
  'ViewChildMetadata.constructor(_selector:Type|string, {read=null}:{read?:any})',
  'ViewChildrenMetadataFactory',
  'ViewChildrenMetadata',
  'ViewChildrenMetadata.constructor(_selector:Type|string, {read=null}:{read?:any})',
  'ViewContainerRef',
  'ViewContainerRef.clear():void',
  'ViewContainerRef.createEmbeddedView(templateRef:TemplateRef<any>, context:any, index:number):EmbeddedViewRef<any>',
  'ViewContainerRef.createComponent(componentFactory:ComponentFactory, index:number, injector:Injector, projectableNodes:any[][]):ComponentRef',
  'ViewContainerRef.detach(index:number):ViewRef',
  'ViewContainerRef.element:ElementRef',
  'ViewContainerRef.injector:Injector',
  'ViewContainerRef.parentInjector:Injector',
  'ViewContainerRef.get(index:number):ViewRef',
  'ViewContainerRef.indexOf(viewRef:ViewRef):number',
  'ViewContainerRef.insert(viewRef:ViewRef, index:number):ViewRef',
  'ViewContainerRef.length:number',
  'ViewContainerRef.remove(index:number):void',
  'ViewDecorator',
  'ViewDecorator.View(obj:{templateUrl?:string, template?:string, directives?:Array<Type|any[]>, pipes?:Array<Type|any[]>, renderer?:string, styles?:string[], styleUrls?:string[]}):ViewDecorator',
  'ViewEncapsulation',
  'ViewEncapsulation.Emulated',
  'ViewEncapsulation.Native',
  'ViewEncapsulation.None',
  'ViewMetadataFactory',
  'ViewMetadata',
  'ViewMetadata.constructor({templateUrl,template,directives,pipes,encapsulation,styles,styleUrls}:{templateUrl?:string, template?:string, directives?:Array<Type|any[]>, pipes?:Array<Type|any[]>, encapsulation?:ViewEncapsulation, styles?:string[], styleUrls?:string[]})',
  'ViewMetadata.directives:Array<Type|any[]>',
  'ViewMetadata.encapsulation:ViewEncapsulation',
  'ViewMetadata.pipes:Array<Type|any[]>',
  'ViewMetadata.styleUrls:string[]',
  'ViewMetadata.styles:string[]',
  'ViewMetadata.template:string',
  'ViewMetadata.templateUrl:string',
  'ViewQueryMetadata',
  'ViewQueryMetadata.constructor(_selector:Type|string, {descendants=false,first=false,read=null}:{descendants?:boolean, first?:boolean, read?:any})',
  'ViewQueryMetadata.isViewQuery:any',
  'ViewQueryMetadata.toString():string',
  'ViewRef',
  'ViewRef.destroyed:boolean',
  'ViewRef.onDestroy(callback:Function):any',
  'WrappedException',
  'WrappedException.constructor(_wrapperMessage:string, _originalException:any, _originalStack:any, _context:any)',
  'WrappedException.context:any',
  'WrappedException.message:string',
  'WrappedException.originalException:any',
  'WrappedException.originalStack:any',
  'WrappedException.toString():string',
  'WrappedException.wrapperMessage:string',
  'WrappedException.wrapperStack:any',
  'WrappedValue',
  'WrappedValue.constructor(wrapped:any)',
  'WrappedValue.wrap(value:any):WrappedValue',
  'bind(token:any):ProviderBuilder',
  'const APPLICATION_COMMON_PROVIDERS:Array<Type|{[k:string]:any}|any[]>',
  'const APP_ID:any',
  'const APP_INITIALIZER:any',
  'const PACKAGE_ROOT_URL:any',
  'const PLATFORM_COMMON_PROVIDERS:Array<any|Type|Provider|any[]>',
  'const PLATFORM_DIRECTIVES:OpaqueToken',
  'const PLATFORM_INITIALIZER:any',
  'const PLATFORM_PIPES:OpaqueToken',
  'createNgZone():NgZone',
  'enableProdMode():any',
  'forwardRef(forwardRefFn:ForwardRefFn):Type',
  'coreBootstrap(injector:Injector, componentFactory:ComponentFactory):ComponentRef',
  'coreLoadAndBootstrap(injector:Injector, componentType:Type):Promise<ComponentRef>',
  'assertPlatform(requiredToken:any):PlatformRef',
  'createPlatform(injector:Injector):PlatformRef',
  'disposePlatform():void',
  'getPlatform():PlatformRef',
  'provide(token:any, {useClass,useValue,useExisting,useFactory,deps,multi}:{useClass?:Type, useValue?:any, useExisting?:any, useFactory?:Function, deps?:Object[], multi?:boolean}):Provider',
  'resolveForwardRef(type:any):any',
  'setTestabilityGetter(getter:GetTestability):void',
  'var Attribute:AttributeMetadataFactory',
  'var Component:ComponentMetadataFactory',
  'var ContentChild:ContentChildMetadataFactory',
  'var ContentChildren:ContentChildrenMetadataFactory',
  'var Directive:DirectiveMetadataFactory',
  'var Host:HostMetadataFactory',
  'var HostBinding:HostBindingMetadataFactory',
  'var HostListener:HostListenerMetadataFactory',
  'var Inject:InjectMetadataFactory',
  'var Injectable:InjectableMetadataFactory',
  'var Input:InputMetadataFactory',
  'var Optional:OptionalMetadataFactory',
  'var Output:OutputMetadataFactory',
  'var Pipe:PipeMetadataFactory',
  'var Query:QueryMetadataFactory',
  'var Self:SelfMetadataFactory',
  'var SkipSelf:SkipSelfMetadataFactory',
  'var Type:any',
  'var ViewChild:ViewChildMetadataFactory',
  'var ViewChildren:ViewChildrenMetadataFactory',
  'var ViewQuery:QueryMetadataFactory',
  'var reflector:any'
];

const COMMON = [
  'AbstractControl',
  'AbstractControl.constructor(validator:ValidatorFn, asyncValidator:AsyncValidatorFn)',
  'AbstractControl.dirty:boolean',
  'AbstractControl.errors:{[key:string]:any}',
  'AbstractControl.find(path:Array<string|number>|string):AbstractControl',
  'AbstractControl.getError(errorCode:string, path:string[]):any',
  'AbstractControl.hasError(errorCode:string, path:string[]):boolean',
  'AbstractControl.markAsDirty({onlySelf}:{onlySelf?:boolean}):void',
  'AbstractControl.markAsPending({onlySelf}:{onlySelf?:boolean}):void',
  'AbstractControl.markAsTouched():void',
  'AbstractControl.pending:boolean',
  'AbstractControl.pristine:boolean',
  'AbstractControl.setErrors(errors:{[key:string]:any}, {emitEvent}:{emitEvent?:boolean}):void',
  'AbstractControl.setParent(parent:ControlGroup|ControlArray):void',
  'AbstractControl.status:string',
  'AbstractControl.statusChanges:Observable<any>',
  'AbstractControl.touched:boolean',
  'AbstractControl.untouched:boolean',
  'AbstractControl.updateValueAndValidity({onlySelf,emitEvent}:{onlySelf?:boolean, emitEvent?:boolean}):void',
  'AbstractControl.valid:boolean',
  'AbstractControl.value:any',
  'AbstractControl.root:AbstractControl',
  'AbstractControl.valueChanges:Observable<any>',
  'AbstractControlDirective',
  'AbstractControlDirective.control:AbstractControl',
  'AbstractControlDirective.dirty:boolean',
  'AbstractControlDirective.errors:{[key:string]:any}',
  'AbstractControlDirective.path:string[]',
  'AbstractControlDirective.pristine:boolean',
  'AbstractControlDirective.touched:boolean',
  'AbstractControlDirective.untouched:boolean',
  'AbstractControlDirective.valid:boolean',
  'AbstractControlDirective.value:any',
  'AsyncPipe',
  'AsyncPipe.constructor(_ref:ChangeDetectorRef)',
  'AsyncPipe.ngOnDestroy():void',
  'AsyncPipe.transform(obj:Observable<any>|Promise<any>|EventEmitter<any>):any',
  'CheckboxControlValueAccessor',
  'CheckboxControlValueAccessor.constructor(_renderer:Renderer, _elementRef:ElementRef)',
  'CheckboxControlValueAccessor.onChange:any',
  'CheckboxControlValueAccessor.onTouched:any',
  'CheckboxControlValueAccessor.registerOnChange(fn:(_: any) => {}):void',
  'CheckboxControlValueAccessor.registerOnTouched(fn:() => {}):void',
  'CheckboxControlValueAccessor.writeValue(value:any):void',
  'Control',
  'Control.constructor(value:any, validator:ValidatorFn, asyncValidator:AsyncValidatorFn)',
  'Control.registerOnChange(fn:Function):void',
  'Control.updateValue(value:any, {onlySelf,emitEvent,emitModelToViewChange}:{onlySelf?:boolean, emitEvent?:boolean, emitModelToViewChange?:boolean}):void',
  'ControlArray',
  'ControlArray.at(index:number):AbstractControl',
  'ControlArray.constructor(controls:AbstractControl[], validator:ValidatorFn, asyncValidator:AsyncValidatorFn)',
  'ControlArray.insert(index:number, control:AbstractControl):void',
  'ControlArray.length:number',
  'ControlArray.push(control:AbstractControl):void',
  'ControlArray.removeAt(index:number):void',
  'ControlContainer',
  'ControlContainer.formDirective:Form',
  'ControlContainer.name:string',
  'ControlContainer.path:string[]',
  'ControlGroup',
  'ControlGroup.addControl(name:string, control:AbstractControl):void',
  'ControlGroup.constructor(controls:{[key:string]:AbstractControl}, optionals:{[key:string]:boolean}, validator:ValidatorFn, asyncValidator:AsyncValidatorFn)',
  'ControlGroup.contains(controlName:string):boolean',
  'ControlGroup.exclude(controlName:string):void',
  'ControlGroup.include(controlName:string):void',
  'ControlGroup.removeControl(name:string):void',
  'ControlValueAccessor',
  'ControlValueAccessor.registerOnChange(fn:any):void',
  'ControlValueAccessor.registerOnTouched(fn:any):void',
  'ControlValueAccessor.writeValue(obj:any):void',
  'CurrencyPipe',
  'CurrencyPipe.transform(value:any, currencyCode:string, symbolDisplay:boolean, digits:string):string',
  'DatePipe',
  'DatePipe.supports(obj:any):boolean',
  'DatePipe.transform(value:any, pattern:string):string',
  'DecimalPipe',
  'DecimalPipe.transform(value:any, digits:string):string',
  'DefaultValueAccessor',
  'DefaultValueAccessor.constructor(_renderer:Renderer, _elementRef:ElementRef)',
  'DefaultValueAccessor.onChange:any',
  'DefaultValueAccessor.onTouched:any',
  'DefaultValueAccessor.registerOnChange(fn:(_: any) => void):void',
  'DefaultValueAccessor.registerOnTouched(fn:() => void):void',
  'DefaultValueAccessor.writeValue(value:any):void',
  'Form',
  'Form.addControl(dir:NgControl):void',
  'Form.addControlGroup(dir:NgControlGroup):void',
  'Form.getControl(dir:NgControl):Control',
  'Form.getControlGroup(dir:NgControlGroup):ControlGroup',
  'Form.removeControl(dir:NgControl):void',
  'Form.removeControlGroup(dir:NgControlGroup):void',
  'Form.updateModel(dir:NgControl, value:any):void',
  'FormBuilder',
  'FormBuilder.array(controlsConfig:any[], validator:ValidatorFn, asyncValidator:AsyncValidatorFn):ControlArray',
  'FormBuilder.control(value:Object, validator:ValidatorFn, asyncValidator:AsyncValidatorFn):Control',
  'FormBuilder.group(controlsConfig:{[key:string]:any}, extra:{[key:string]:any}):ControlGroup',
  'I18nPluralPipe',
  'I18nPluralPipe.transform(value:number, pluralMap:{[count:string]:string}):string',
  'I18nSelectPipe',
  'I18nSelectPipe.transform(value:string, mapping:{[key:string]:string}):string',
  'JsonPipe',
  'JsonPipe.transform(value:any):string',
  'LowerCasePipe',
  'LowerCasePipe.transform(value:string):string',
  'MaxLengthValidator',
  'MaxLengthValidator.constructor(maxLength:string)',
  'MaxLengthValidator.validate(c:AbstractControl):{[key:string]:any}',
  'MinLengthValidator',
  'MinLengthValidator.constructor(minLength:string)',
  'MinLengthValidator.validate(c:AbstractControl):{[key:string]:any}',
  'NgClass',
  'NgClass.constructor(_iterableDiffers:IterableDiffers, _keyValueDiffers:KeyValueDiffers, _ngEl:ElementRef, _renderer:Renderer)',
  'NgClass.initialClasses=(v:string)',
  'NgClass.ngDoCheck():void',
  'NgClass.ngOnDestroy():void',
  'NgClass.rawClass=(v:string|string[]|Set<string>|{[key:string]:any})',
  'NgControl',
  'NgControl.asyncValidator:AsyncValidatorFn',
  'NgControl.name:string',
  'NgControl.validator:ValidatorFn',
  'NgControl.valueAccessor:ControlValueAccessor',
  'NgControl.viewToModelUpdate(newValue:any):void',
  'NgControlGroup',
  'NgControlGroup.asyncValidator:AsyncValidatorFn',
  'NgControlGroup.constructor(parent:ControlContainer, _validators:any[], _asyncValidators:any[])',
  'NgControlGroup.control:ControlGroup',
  'NgControlGroup.formDirective:Form',
  'NgControlGroup.ngOnDestroy():void',
  'NgControlGroup.ngOnInit():void',
  'NgControlGroup.path:string[]',
  'NgControlGroup.validator:ValidatorFn',
  'NgControlName',
  'NgControlName.asyncValidator:AsyncValidatorFn',
  'NgControlName.constructor(_parent:ControlContainer, _validators:any[], _asyncValidators:any[], valueAccessors:ControlValueAccessor[])',
  'NgControlName.control:Control',
  'NgControlName.formDirective:any',
  'NgControlName.model:any',
  'NgControlName.ngOnChanges(changes:{[key:string]:SimpleChange}):any',
  'NgControlName.ngOnDestroy():void',
  'NgControlName.path:string[]',
  'NgControlName.update:any',
  'NgControlName.validator:ValidatorFn',
  'NgControlName.viewModel:any',
  'NgControlName.viewToModelUpdate(newValue:any):void',
  'NgControlStatus',
  'NgControlStatus.constructor(cd:NgControl)',
  'NgControlStatus.ngClassDirty:boolean',
  'NgControlStatus.ngClassInvalid:boolean',
  'NgControlStatus.ngClassPristine:boolean',
  'NgControlStatus.ngClassTouched:boolean',
  'NgControlStatus.ngClassUntouched:boolean',
  'NgControlStatus.ngClassValid:boolean',
  'NgFor',
  'NgFor.constructor(_viewContainer:ViewContainerRef, _templateRef:TemplateRef<NgForRow>, _iterableDiffers:IterableDiffers, _cdr:ChangeDetectorRef)',
  'NgFor.ngDoCheck():any',
  'NgFor.ngForOf=(value:any)',
  'NgFor.ngForTemplate=(value:TemplateRef<NgForRow>)',
  'NgFor.ngForTrackBy=(value:TrackByFn)',
  'NgForm',
  'NgForm.addControl(dir:NgControl):void',
  'NgForm.addControlGroup(dir:NgControlGroup):void',
  'NgForm.constructor(validators:any[], asyncValidators:any[])',
  'NgForm.control:ControlGroup',
  'NgForm.controls:{[key:string]:AbstractControl}',
  'NgForm.form:ControlGroup',
  'NgForm.formDirective:Form',
  'NgForm.getControl(dir:NgControl):Control',
  'NgForm.getControlGroup(dir:NgControlGroup):ControlGroup',
  'NgForm.ngSubmit:any',
  'NgForm.onSubmit():boolean',
  'NgForm.path:string[]',
  'NgForm.removeControl(dir:NgControl):void',
  'NgForm.removeControlGroup(dir:NgControlGroup):void',
  'NgForm.updateModel(dir:NgControl, value:any):void',
  'NgFormControl',
  'NgFormControl.asyncValidator:AsyncValidatorFn',
  'NgFormControl.constructor(_validators:any[], _asyncValidators:any[], valueAccessors:ControlValueAccessor[])',
  'NgFormControl.control:Control',
  'NgFormControl.form:Control',
  'NgFormControl.model:any',
  'NgFormControl.ngOnChanges(changes:{[key:string]:SimpleChange}):void',
  'NgFormControl.path:string[]',
  'NgFormControl.update:any',
  'NgFormControl.validator:ValidatorFn',
  'NgFormControl.viewModel:any',
  'NgFormControl.viewToModelUpdate(newValue:any):void',
  'NgFormModel',
  'NgFormModel.addControl(dir:NgControl):void',
  'NgFormModel.addControlGroup(dir:NgControlGroup):any',
  'NgFormModel.constructor(_validators:any[], _asyncValidators:any[])',
  'NgFormModel.control:ControlGroup',
  'NgFormModel.directives:NgControl[]',
  'NgFormModel.form:ControlGroup',
  'NgFormModel.formDirective:Form',
  'NgFormModel.getControl(dir:NgControl):Control',
  'NgFormModel.getControlGroup(dir:NgControlGroup):ControlGroup',
  'NgFormModel.ngOnChanges(changes:{[key:string]:SimpleChange}):void',
  'NgFormModel.ngSubmit:any',
  'NgFormModel.onSubmit():boolean',
  'NgFormModel.path:string[]',
  'NgFormModel.removeControl(dir:NgControl):void',
  'NgFormModel.removeControlGroup(dir:NgControlGroup):any',
  'NgFormModel.updateModel(dir:NgControl, value:any):void',
  'NgIf',
  'NgIf.constructor(_viewContainer:ViewContainerRef, _templateRef:TemplateRef<Object>)',
  'NgIf.ngIf=(newCondition:any)',
  'NgTemplateOutlet',
  'NgTemplateOutlet.constructor(_viewContainerRef:ViewContainerRef)',
  'NgTemplateOutlet.ngTemplateOutlet=(templateRef:TemplateRef<Object>)',
  'NgLocalization',
  'NgLocalization.getPluralCategory(value:any):string',
  'NgModel',
  'NgModel.asyncValidator:AsyncValidatorFn',
  'NgModel.constructor(_validators:any[], _asyncValidators:any[], valueAccessors:ControlValueAccessor[])',
  'NgModel.control:Control',
  'NgModel.model:any',
  'NgModel.ngOnChanges(changes:{[key:string]:SimpleChange}):any',
  'NgModel.path:string[]',
  'NgModel.update:any',
  'NgModel.validator:ValidatorFn',
  'NgModel.viewModel:any',
  'NgModel.viewToModelUpdate(newValue:any):void',
  'NgPlural',
  'NgPlural.cases:QueryList<NgPluralCase>',
  'NgPlural.constructor(_localization:NgLocalization)',
  'NgPlural.ngAfterContentInit():any',
  'NgPluralCase.constructor(value:string, template:TemplateRef<Object>, viewContainer:ViewContainerRef)',
  'NgPlural.ngPlural=(value:number)',
  'NgPluralCase',
  'NgSelectOption',
  'NgSelectOption.constructor(_element:ElementRef, _renderer:Renderer, _select:SelectControlValueAccessor)',
  'NgSelectOption.id:string',
  'NgSelectOption.ngOnDestroy():any',
  'NgSelectOption.ngValue=(value:any)',
  'NgSelectOption.value=(value:any)',
  'NgStyle',
  'NgStyle.constructor(_differs:KeyValueDiffers, _ngEl:ElementRef, _renderer:Renderer)',
  'NgStyle.ngDoCheck():any',
  'NgStyle.rawStyle=(v:{[key:string]:string})',
  'NgSwitch',
  'NgSwitch.ngSwitch=(value:any)',
  'NgSwitchDefault',
  'NgSwitchDefault.constructor(viewContainer:ViewContainerRef, templateRef:TemplateRef<Object>, sswitch:NgSwitch)',
  'NgSwitchWhen',
  'NgSwitchWhen.constructor(viewContainer:ViewContainerRef, templateRef:TemplateRef<Object>, ngSwitch:NgSwitch)',
  'NgSwitchWhen.ngSwitchWhen=(value:any)',
  'NumberPipe',
  'PatternValidator',
  'PatternValidator.constructor(pattern:string)',
  'PatternValidator.validate(c:AbstractControl):{[key:string]:any}',
  'PercentPipe',
  'PercentPipe.transform(value:any, digits:string):string',
  'ReplacePipe',
  'ReplacePipe.transform(value:any, pattern:string|RegExp, replacement:Function|string):any',
  'RequiredValidator',
  'SelectControlValueAccessor',
  'SelectControlValueAccessor.constructor(_renderer:Renderer, _elementRef:ElementRef)',
  'SelectControlValueAccessor.onChange:any',
  'SelectControlValueAccessor.onTouched:any',
  'SelectControlValueAccessor.registerOnChange(fn:(value: any) => any):void',
  'SelectControlValueAccessor.registerOnTouched(fn:() => any):void',
  'SelectControlValueAccessor.value:any',
  'SelectControlValueAccessor.writeValue(value:any):void',
  'SlicePipe',
  'SlicePipe.transform(value:any, start:number, end:number):any',
  'UpperCasePipe',
  'UpperCasePipe.transform(value:string):string',
  'Validator',
  'Validator.validate(c:AbstractControl):{[key:string]:any}',
  'Validators',
  'Validators.compose(validators:ValidatorFn[]):ValidatorFn',
  'Validators.composeAsync(validators:AsyncValidatorFn[]):AsyncValidatorFn',
  'Validators.maxLength(maxLength:number):ValidatorFn',
  'Validators.minLength(minLength:number):ValidatorFn',
  'Validators.nullValidator(c:AbstractControl):{[key:string]:boolean}',
  'Validators.pattern(pattern:string):ValidatorFn',
  'Validators.required(control:AbstractControl):{[key:string]:boolean}',
  'RadioButtonState',
  'RadioButtonState.constructor(checked:boolean, value:string)',
  'const COMMON_DIRECTIVES:Type[][]',
  'const COMMON_PIPES:any',
  'const CORE_DIRECTIVES:Type[]',
  'const FORM_BINDINGS:any',
  'const FORM_DIRECTIVES:Type[]',
  'const FORM_PROVIDERS:Type[]',
  'const NG_ASYNC_VALIDATORS:OpaqueToken',
  'const NG_VALIDATORS:OpaqueToken',
  'const NG_VALUE_ACCESSOR:OpaqueToken',
  'var workaround_empty_observable_list_diff:any'
];

const COMPILER = [
  'AttrAst',
  'AttrAst.constructor(name:string, value:string, sourceSpan:ParseSourceSpan)',
  'AttrAst.visit(visitor:TemplateAstVisitor, context:any):any',
  'BoundDirectivePropertyAst',
  'BoundDirectivePropertyAst.constructor(directiveName:string, templateName:string, value:AST, sourceSpan:ParseSourceSpan)',
  'BoundDirectivePropertyAst.visit(visitor:TemplateAstVisitor, context:any):any',
  'BoundElementPropertyAst',
  'BoundElementPropertyAst.constructor(name:string, type:PropertyBindingType, value:AST, unit:string, sourceSpan:ParseSourceSpan)',
  'BoundElementPropertyAst.visit(visitor:TemplateAstVisitor, context:any):any',
  'BoundEventAst',
  'BoundEventAst.constructor(name:string, target:string, handler:AST, sourceSpan:ParseSourceSpan)',
  'BoundEventAst.fullName:any',
  'BoundEventAst.visit(visitor:TemplateAstVisitor, context:any):any',
  'BoundTextAst',
  'BoundTextAst.constructor(value:AST, ngContentIndex:number, sourceSpan:ParseSourceSpan)',
  'BoundTextAst.visit(visitor:TemplateAstVisitor, context:any):any',
  'DirectiveAst',
  'DirectiveAst.constructor(directive:CompileDirectiveMetadata, inputs:BoundDirectivePropertyAst[], hostProperties:BoundElementPropertyAst[], hostEvents:BoundEventAst[], sourceSpan:ParseSourceSpan)',
  'DirectiveAst.visit(visitor:TemplateAstVisitor, context:any):any',
  'ElementAst',
  'ElementAst.constructor(name:string, attrs:AttrAst[], inputs:BoundElementPropertyAst[], outputs:BoundEventAst[], references:ReferenceAst[], directives:DirectiveAst[], providers:ProviderAst[], hasViewContainer:boolean, children:TemplateAst[], ngContentIndex:number, sourceSpan:ParseSourceSpan)',
  'ElementAst.visit(visitor:TemplateAstVisitor, context:any):any',
  'EmbeddedTemplateAst',
  'EmbeddedTemplateAst.constructor(attrs:AttrAst[], outputs:BoundEventAst[], references:ReferenceAst[], variables:VariableAst[], directives:DirectiveAst[], providers:ProviderAst[], hasViewContainer:boolean, children:TemplateAst[], ngContentIndex:number, sourceSpan:ParseSourceSpan)',
  'EmbeddedTemplateAst.visit(visitor:TemplateAstVisitor, context:any):any',
  'NgContentAst',
  'NgContentAst.constructor(index:number, ngContentIndex:number, sourceSpan:ParseSourceSpan)',
  'NgContentAst.visit(visitor:TemplateAstVisitor, context:any):any',
  'PropertyBindingType',
  'PropertyBindingType.Attribute',
  'PropertyBindingType.Class',
  'PropertyBindingType.Property',
  'PropertyBindingType.Style',
  'TemplateAst',
  'TemplateAst.sourceSpan:ParseSourceSpan',
  'TemplateAst.visit(visitor:TemplateAstVisitor, context:any):any',
  'TemplateAstVisitor',
  'TemplateAstVisitor.visitAttr(ast:AttrAst, context:any):any',
  'TemplateAstVisitor.visitBoundText(ast:BoundTextAst, context:any):any',
  'TemplateAstVisitor.visitDirective(ast:DirectiveAst, context:any):any',
  'TemplateAstVisitor.visitDirectiveProperty(ast:BoundDirectivePropertyAst, context:any):any',
  'TemplateAstVisitor.visitElement(ast:ElementAst, context:any):any',
  'TemplateAstVisitor.visitElementProperty(ast:BoundElementPropertyAst, context:any):any',
  'TemplateAstVisitor.visitEmbeddedTemplate(ast:EmbeddedTemplateAst, context:any):any',
  'TemplateAstVisitor.visitEvent(ast:BoundEventAst, context:any):any',
  'TemplateAstVisitor.visitNgContent(ast:NgContentAst, context:any):any',
  'TemplateAstVisitor.visitText(ast:TextAst, context:any):any',
  'TemplateAstVisitor.visitVariable(ast:VariableAst, context:any):any',
  'TextAst',
  'TextAst.constructor(value:string, ngContentIndex:number, sourceSpan:ParseSourceSpan)',
  'TextAst.visit(visitor:TemplateAstVisitor, context:any):any',
  'UrlResolver',
  'UrlResolver.constructor(_packagePrefix:string)',
  'UrlResolver.resolve(baseUrl:string, url:string):string',
  'VariableAst',
  'VariableAst.constructor(name:string, value:string, sourceSpan:ParseSourceSpan)',
  'VariableAst.visit(visitor:TemplateAstVisitor, context:any):any',
  'ReferenceAst',
  'ReferenceAst.constructor(name:string, value:CompileTokenMetadata, sourceSpan:ParseSourceSpan)',
  'ReferenceAst.visit(visitor:TemplateAstVisitor, context:any):any',
  'TemplateAstVisitor.visitReference(ast:ReferenceAst, context:any):any',
  'XHR',
  'XHR.get(url:string):Promise<string>',
  'const COMPILER_PROVIDERS:Array<any|Type|{[k:string]:any}|any[]>',
  'const PLATFORM_DIRECTIVES:OpaqueToken',
  'const PLATFORM_PIPES:OpaqueToken',
  'const TEMPLATE_TRANSFORMS:any',
  'templateVisitAll(visitor:TemplateAstVisitor, asts:TemplateAst[], context:any):any[]',
  'var DEFAULT_PACKAGE_URL_PROVIDER:any',
  'CompileDiDependencyMetadata',
  'CompileDiDependencyMetadata.constructor({isAttribute,isSelf,isHost,isSkipSelf,isOptional,isValue,query,viewQuery,token,value}:{isAttribute?:boolean, isSelf?:boolean, isHost?:boolean, isSkipSelf?:boolean, isOptional?:boolean, isValue?:boolean, query?:CompileQueryMetadata, viewQuery?:CompileQueryMetadata, token?:CompileTokenMetadata, value?:any})',
  'CompileDiDependencyMetadata.fromJson(data:{[key:string]:any}):CompileDiDependencyMetadata',
  'CompileDiDependencyMetadata.isAttribute:boolean',
  'CompileDiDependencyMetadata.isHost:boolean',
  'CompileDiDependencyMetadata.isOptional:boolean',
  'CompileDiDependencyMetadata.isSelf:boolean',
  'CompileDiDependencyMetadata.isSkipSelf:boolean',
  'CompileDiDependencyMetadata.query:CompileQueryMetadata',
  'CompileDiDependencyMetadata.toJson():{[key:string]:any}',
  'CompileDiDependencyMetadata.token:CompileTokenMetadata',
  'CompileDiDependencyMetadata.viewQuery:CompileQueryMetadata',
  'CompileDiDependencyMetadata.isValue:boolean',
  'CompileDiDependencyMetadata.value:any',
  'CompileDirectiveMetadata.constructor({type,isComponent,selector,exportAs,changeDetection,inputs,outputs,hostListeners,hostProperties,hostAttributes,lifecycleHooks,providers,viewProviders,queries,viewQueries,template}:{type?:CompileTypeMetadata, isComponent?:boolean, selector?:string, exportAs?:string, changeDetection?:ChangeDetectionStrategy, inputs?:{[key:string]:string}, outputs?:{[key:string]:string}, hostListeners?:{[key:string]:string}, hostProperties?:{[key:string]:string}, hostAttributes?:{[key:string]:string}, lifecycleHooks?:LifecycleHooks[], providers?:Array<CompileProviderMetadata|CompileTypeMetadata|CompileIdentifierMetadata|any[]>, viewProviders?:Array<CompileProviderMetadata|CompileTypeMetadata|CompileIdentifierMetadata|any[]>, queries?:CompileQueryMetadata[], viewQueries?:CompileQueryMetadata[], template?:CompileTemplateMetadata})',
  'CompileDirectiveMetadata.create({type,isComponent,selector,exportAs,changeDetection,inputs,outputs,host,lifecycleHooks,providers,viewProviders,queries,viewQueries,template}:{type?:CompileTypeMetadata, isComponent?:boolean, selector?:string, exportAs?:string, changeDetection?:ChangeDetectionStrategy, inputs?:string[], outputs?:string[], host?:{[key:string]:string}, lifecycleHooks?:LifecycleHooks[], providers?:Array<CompileProviderMetadata|CompileTypeMetadata|CompileIdentifierMetadata|any[]>, viewProviders?:Array<CompileProviderMetadata|CompileTypeMetadata|CompileIdentifierMetadata|any[]>, queries?:CompileQueryMetadata[], viewQueries?:CompileQueryMetadata[], template?:CompileTemplateMetadata}):CompileDirectiveMetadata',
  'CompileDirectiveMetadata.providers:CompileProviderMetadata[]',
  'CompileDirectiveMetadata.viewProviders:CompileProviderMetadata[]',
  'CompileFactoryMetadata',
  'CompileFactoryMetadata.constructor({runtime,name,moduleUrl,prefix,diDeps,value}:{runtime?:Function, name?:string, prefix?:string, moduleUrl?:string, value?:boolean, diDeps?:CompileDiDependencyMetadata[]})',
  'CompileFactoryMetadata.diDeps:CompileDiDependencyMetadata[]',
  'CompileFactoryMetadata.fromJson(data:{[key:string]:any}):CompileFactoryMetadata',
  'CompileFactoryMetadata.identifier:CompileIdentifierMetadata',
  'CompileFactoryMetadata.moduleUrl:string',
  'CompileFactoryMetadata.name:string',
  'CompileFactoryMetadata.prefix:string',
  'CompileFactoryMetadata.runtime:Function',
  'CompileFactoryMetadata.toJson():{[key:string]:any}',
  'CompileFactoryMetadata.value:any',
  'CompileIdentifierMetadata',
  'CompileIdentifierMetadata.constructor({runtime,name,moduleUrl,prefix,value}:{runtime?:any, name?:string, moduleUrl?:string, prefix?:string, value?:any})',
  'CompileIdentifierMetadata.fromJson(data:{[key:string]:any}):CompileIdentifierMetadata',
  'CompileIdentifierMetadata.identifier:CompileIdentifierMetadata',
  'CompileIdentifierMetadata.moduleUrl:string',
  'CompileIdentifierMetadata.name:string',
  'CompileIdentifierMetadata.prefix:string',
  'CompileIdentifierMetadata.runtime:any',
  'CompileIdentifierMetadata.toJson():{[key:string]:any}',
  'CompileIdentifierMetadata.value:any',
  'CompileMetadataWithIdentifier',
  'CompileMetadataWithIdentifier.identifier:CompileIdentifierMetadata',
  'CompileMetadataWithIdentifier.toJson():{[key:string]:any}',
  'CompileMetadataWithType',
  'CompileMetadataWithType.identifier:CompileIdentifierMetadata',
  'CompileMetadataWithType.toJson():{[key:string]:any}',
  'CompileMetadataWithType.type:CompileTypeMetadata',
  'CompilePipeMetadata',
  'CompilePipeMetadata.constructor({type,name,pure,lifecycleHooks}:{type?:CompileTypeMetadata, name?:string, pure?:boolean, lifecycleHooks?:LifecycleHooks[]})',
  'CompilePipeMetadata.fromJson(data:{[key:string]:any}):CompilePipeMetadata',
  'CompilePipeMetadata.identifier:CompileIdentifierMetadata',
  'CompilePipeMetadata.lifecycleHooks:LifecycleHooks[]',
  'CompilePipeMetadata.name:string',
  'CompilePipeMetadata.pure:boolean',
  'CompilePipeMetadata.toJson():{[key:string]:any}',
  'CompilePipeMetadata.type:CompileTypeMetadata',
  'CompileProviderMetadata',
  'CompileProviderMetadata.constructor({token,useClass,useValue,useExisting,useFactory,deps,multi}:{token?:CompileTokenMetadata, useClass?:CompileTypeMetadata, useValue?:any, useExisting?:CompileTokenMetadata, useFactory?:CompileFactoryMetadata, deps?:CompileDiDependencyMetadata[], multi?:boolean})',
  'CompileProviderMetadata.deps:CompileDiDependencyMetadata[]',
  'CompileProviderMetadata.fromJson(data:{[key:string]:any}):CompileProviderMetadata',
  'CompileProviderMetadata.multi:boolean',
  'CompileProviderMetadata.toJson():{[key:string]:any}',
  'CompileProviderMetadata.token:CompileTokenMetadata',
  'CompileProviderMetadata.useClass:CompileTypeMetadata',
  'CompileProviderMetadata.useExisting:CompileTokenMetadata',
  'CompileProviderMetadata.useFactory:CompileFactoryMetadata',
  'CompileProviderMetadata.useValue:any',
  'CompileQueryMetadata',
  'CompileQueryMetadata.constructor({selectors,descendants,first,propertyName,read}:{selectors?:Array<CompileTokenMetadata>, descendants?:boolean, first?:boolean, propertyName?:string, read?:CompileTokenMetadata})',
  'CompileQueryMetadata.read:CompileTokenMetadata',
  'CompileQueryMetadata.descendants:boolean',
  'CompileQueryMetadata.first:boolean',
  'CompileQueryMetadata.fromJson(data:{[key:string]:any}):CompileQueryMetadata',
  'CompileQueryMetadata.propertyName:string',
  'CompileQueryMetadata.selectors:Array<CompileTokenMetadata>',
  'CompileQueryMetadata.toJson():{[key:string]:any}',
  'CompileTokenMetadata',
  'CompileTokenMetadata.assetCacheKey:any',
  'CompileTokenMetadata.constructor({value,identifier,identifierIsInstance}:{value?:any, identifier?:CompileIdentifierMetadata, identifierIsInstance?:boolean})',
  'CompileTokenMetadata.equalsTo(token2:CompileTokenMetadata):boolean',
  'CompileTokenMetadata.fromJson(data:{[key:string]:any}):CompileTokenMetadata',
  'CompileTokenMetadata.identifier:CompileIdentifierMetadata',
  'CompileTokenMetadata.identifierIsInstance:boolean',
  'CompileTokenMetadata.name:string',
  'CompileTokenMetadata.runtimeCacheKey:any',
  'CompileTokenMetadata.toJson():{[key:string]:any}',
  'CompileTokenMetadata.value:any',
  'CompileTypeMetadata.constructor({runtime,name,moduleUrl,prefix,isHost,value,diDeps}:{runtime?:Type, name?:string, moduleUrl?:string, prefix?:string, isHost?:boolean, value?:any, diDeps?:CompileDiDependencyMetadata[]})',
  'CompileTypeMetadata.value:any',
  'CompilerConfig',
  'CompilerConfig.constructor(genDebugInfo:boolean, logBindingUpdate:boolean, useJit:boolean, renderTypes:RenderTypes)',
  'CompilerConfig.renderTypes:RenderTypes',
  'RenderTypes',
  'RenderTypes.renderComment:CompileIdentifierMetadata',
  'RenderTypes.renderElement:CompileIdentifierMetadata',
  'RenderTypes.renderEvent:CompileIdentifierMetadata',
  'RenderTypes.renderNode:CompileIdentifierMetadata',
  'RenderTypes.renderText:CompileIdentifierMetadata',
  'RenderTypes.renderer:CompileIdentifierMetadata',
  'DirectiveResolver',
  'DirectiveResolver.constructor(_reflector:ReflectorReader)',
  'DirectiveResolver.resolve(type:Type):DirectiveMetadata',
  'NormalizedComponentWithViewDirectives',
  'NormalizedComponentWithViewDirectives.constructor(component:CompileDirectiveMetadata, directives:CompileDirectiveMetadata[], pipes:CompilePipeMetadata[])',
  'OfflineCompiler',
  'OfflineCompiler.compileStylesheet(stylesheetUrl:string, cssText:string):SourceModule[]',
  'OfflineCompiler.compileTemplates(components:NormalizedComponentWithViewDirectives[]):SourceModule',
  'OfflineCompiler.constructor(_directiveNormalizer:DirectiveNormalizer, _templateParser:TemplateParser, _styleCompiler:StyleCompiler, _viewCompiler:ViewCompiler, _outputEmitter:OutputEmitter)',
  'OfflineCompiler.normalizeDirectiveMetadata(directive:CompileDirectiveMetadata):Promise<CompileDirectiveMetadata>',
  'PipeResolver',
  'PipeResolver.constructor(_reflector:ReflectorReader)',
  'PipeResolver.resolve(type:Type):PipeMetadata',
  'CompileDirectiveMetadata',
  'CompileDirectiveMetadata.changeDetection:ChangeDetectionStrategy',
  'CompileDirectiveMetadata.exportAs:string',
  'CompileDirectiveMetadata.fromJson(data:{[key:string]:any}):CompileDirectiveMetadata',
  'CompileDirectiveMetadata.hostAttributes:{[key:string]:string}',
  'CompileDirectiveMetadata.hostListeners:{[key:string]:string}',
  'CompileDirectiveMetadata.hostProperties:{[key:string]:string}',
  'CompileDirectiveMetadata.identifier:CompileIdentifierMetadata',
  'CompileDirectiveMetadata.inputs:{[key:string]:string}',
  'CompileDirectiveMetadata.isComponent:boolean',
  'CompileDirectiveMetadata.lifecycleHooks:LifecycleHooks[]',
  'CompileDirectiveMetadata.outputs:{[key:string]:string}',
  'CompileDirectiveMetadata.queries:CompileQueryMetadata[]',
  'CompileDirectiveMetadata.selector:string',
  'CompileDirectiveMetadata.template:CompileTemplateMetadata',
  'CompileDirectiveMetadata.toJson():{[key:string]:any}',
  'CompileDirectiveMetadata.type:CompileTypeMetadata',
  'CompileDirectiveMetadata.viewQueries:CompileQueryMetadata[]',
  'CompileTemplateMetadata',
  'CompileTemplateMetadata.constructor({encapsulation,template,templateUrl,styles,styleUrls,ngContentSelectors,baseUrl}:{encapsulation?:ViewEncapsulation, template?:string, templateUrl?:string, styles?:string[], styleUrls?:string[], ngContentSelectors?:string[], baseUrl?:string})',
  'CompileTemplateMetadata.encapsulation:ViewEncapsulation',
  'CompileTemplateMetadata.fromJson(data:{[key:string]:any}):CompileTemplateMetadata',
  'CompileTemplateMetadata.ngContentSelectors:string[]',
  'CompileTemplateMetadata.styleUrls:string[]',
  'CompileTemplateMetadata.styles:string[]',
  'CompileTemplateMetadata.template:string',
  'CompileTemplateMetadata.templateUrl:string',
  'CompileTemplateMetadata.toJson():{[key:string]:any}',
  'CompileTemplateMetadata.baseUrl:string',
  'CompileTypeMetadata',
  'CompileTypeMetadata.diDeps:CompileDiDependencyMetadata[]',
  'CompileTypeMetadata.fromJson(data:{[key:string]:any}):CompileTypeMetadata',
  'CompileTypeMetadata.identifier:CompileIdentifierMetadata',
  'CompileTypeMetadata.isHost:boolean',
  'CompileTypeMetadata.moduleUrl:string',
  'CompileTypeMetadata.name:string',
  'CompileTypeMetadata.prefix:string',
  'CompileTypeMetadata.runtime:Type',
  'CompileTypeMetadata.toJson():{[key:string]:any}',
  'CompileTypeMetadata.type:CompileTypeMetadata',
  'ProviderAst',
  'ProviderAst.constructor(token:CompileTokenMetadata, multiProvider:boolean, eager:boolean, providers:CompileProviderMetadata[], providerType:ProviderAstType, sourceSpan:ParseSourceSpan)',
  'ProviderAst.visit(visitor:TemplateAstVisitor, context:any):any',
  'ProviderAstType',
  'ProviderAstType.Builtin',
  'ProviderAstType.Component',
  'ProviderAstType.Directive',
  'ProviderAstType.PrivateService',
  'ProviderAstType.PublicService',
  'SourceModule',
  'SourceModule.constructor(moduleUrl:string, source:string)',
  'ViewResolver',
  'ViewResolver.constructor(_reflector:ReflectorReader)',
  'ViewResolver.resolve(component:Type):ViewMetadata',
  'createOfflineCompileUrlResolver():UrlResolver'
];

const INSTRUMENTATION = [
  'WtfScopeFn',
  'var wtfCreateScope:(signature: string, flags?: any) => impl.WtfScopeFn',
  'var wtfEndTimeRange:(range: any) => void',
  'var wtfLeave:<T>(scope: any, returnValue?: T) => T',
  'var wtfStartTimeRange:(rangeType: string, action: string) => any'
];

const UPGRADE = [
  'UpgradeAdapter',
  'UpgradeAdapter.addProvider(provider:Type|Provider|any[]):void',
  'UpgradeAdapter.bootstrap(element:Element, modules:any[], config:IAngularBootstrapConfig):UpgradeAdapterRef',
  'UpgradeAdapter.downgradeNg2Component(type:Type):Function',
  'UpgradeAdapter.downgradeNg2Provider(token:any):Function',
  'UpgradeAdapter.upgradeNg1Component(name:string):Type',
  'UpgradeAdapter.upgradeNg1Provider(name:string, options:{asToken:any}):any',
  'UpgradeAdapterRef',
  'UpgradeAdapterRef.dispose():any',
  'UpgradeAdapterRef.ng1Injector:IInjectorService',
  'UpgradeAdapterRef.ng1RootScope:IRootScopeService',
  'UpgradeAdapterRef.ng2ApplicationRef:ApplicationRef',
  'UpgradeAdapterRef.ng2Injector:Injector',
  'UpgradeAdapterRef.ready(fn:(upgradeAdapterRef?: UpgradeAdapterRef) => void):any'
];

const BROWSER = [
  'BrowserDomAdapter',
  'BrowserDomAdapter.addClass(element:any, className:string):any',
  'BrowserDomAdapter.adoptNode(node:Node):any',
  'BrowserDomAdapter.appendChild(el:any, node:any):any',
  'BrowserDomAdapter.attrToPropMap:any',
  'BrowserDomAdapter.attributeMap(element:any):Map<string, string>',
  'BrowserDomAdapter.cancelAnimationFrame(id:number):any',
  'BrowserDomAdapter.childNodes(el:any):Node[]',
  'BrowserDomAdapter.childNodesAsList(el:any):any[]',
  'BrowserDomAdapter.classList(element:any):any[]',
  'BrowserDomAdapter.clearNodes(el:any):any',
  'BrowserDomAdapter.clone(node:Node):Node',
  'BrowserDomAdapter.content(node:Node):Node',
  'BrowserDomAdapter.createComment(text:string):Comment',
  'BrowserDomAdapter.createElement(tagName:any, doc:any):HTMLElement',
  'BrowserDomAdapter.createElementNS(ns:any, tagName:any, doc:any):Element',
  'BrowserDomAdapter.createEvent(eventType:any):Event',
  'BrowserDomAdapter.createHtmlDocument():HTMLDocument',
  'BrowserDomAdapter.createMouseEvent(eventType:string):MouseEvent',
  'BrowserDomAdapter.createScriptTag(attrName:string, attrValue:string, doc:any):HTMLScriptElement',
  'BrowserDomAdapter.createShadowRoot(el:HTMLElement):DocumentFragment',
  'BrowserDomAdapter.createStyleElement(css:string, doc:any):HTMLStyleElement',
  'BrowserDomAdapter.createTemplate(html:any):HTMLElement',
  'BrowserDomAdapter.createTextNode(text:string, doc:any):Text',
  'BrowserDomAdapter.defaultDoc():HTMLDocument',
  'BrowserDomAdapter.dispatchEvent(el:any, evt:any):any',
  'BrowserDomAdapter.elementMatches(n:any, selector:string):boolean',
  'BrowserDomAdapter.firstChild(el:any):Node',
  'BrowserDomAdapter.getAttribute(element:any, attribute:string):string',
  'BrowserDomAdapter.getAttributeNS(element:any, ns:string, name:string):string',
  'BrowserDomAdapter.getBaseHref():string',
  'BrowserDomAdapter.getBoundingClientRect(el:any):any',
  'BrowserDomAdapter.getChecked(el:any):boolean',
  'BrowserDomAdapter.getComputedStyle(element:any):any',
  'BrowserDomAdapter.getData(element:any, name:string):string',
  'BrowserDomAdapter.getElementsByClassName(element:any, name:string):HTMLElement[]',
  'BrowserDomAdapter.getElementsByTagName(element:any, name:string):HTMLElement[]',
  'BrowserDomAdapter.getEventKey(event:any):string',
  'BrowserDomAdapter.getGlobalEventTarget(target:string):EventTarget',
  'BrowserDomAdapter.getHistory():History',
  'BrowserDomAdapter.getHost(el:HTMLElement):HTMLElement',
  'BrowserDomAdapter.getHref(el:Element):string',
  'BrowserDomAdapter.getInnerHTML(el:any):string',
  'BrowserDomAdapter.getLocation():Location',
  'BrowserDomAdapter.getOuterHTML(el:any):string',
  'BrowserDomAdapter.getProperty(el:any, name:string):any',
  'BrowserDomAdapter.getShadowRoot(el:HTMLElement):DocumentFragment',
  'BrowserDomAdapter.getStyle(element:any, stylename:string):string',
  'BrowserDomAdapter.getText(el:any):string',
  'BrowserDomAdapter.getTitle():string',
  'BrowserDomAdapter.getUserAgent():string',
  'BrowserDomAdapter.getValue(el:any):string',
  'BrowserDomAdapter.hasAttribute(element:any, attribute:string):boolean',
  'BrowserDomAdapter.hasAttributeNS(element:any, ns:string, attribute:string):boolean',
  'BrowserDomAdapter.hasClass(element:any, className:string):boolean',
  'BrowserDomAdapter.hasProperty(element:any, name:string):boolean',
  'BrowserDomAdapter.hasShadowRoot(node:any):boolean',
  'BrowserDomAdapter.hasStyle(element:any, styleName:string, styleValue:string):boolean',
  'BrowserDomAdapter.importIntoDoc(node:Node):any',
  'BrowserDomAdapter.insertAfter(el:any, node:any):any',
  'BrowserDomAdapter.insertAllBefore(el:any, nodes:any):any',
  'BrowserDomAdapter.insertBefore(el:any, node:any):any',
  'BrowserDomAdapter.invoke(el:any, methodName:string, args:any[]):any',
  'BrowserDomAdapter.isCommentNode(node:Node):boolean',
  'BrowserDomAdapter.isElementNode(node:Node):boolean',
  'BrowserDomAdapter.isPrevented(evt:Event):boolean',
  'BrowserDomAdapter.isShadowRoot(node:any):boolean',
  'BrowserDomAdapter.isTemplateElement(el:any):boolean',
  'BrowserDomAdapter.isTextNode(node:Node):boolean',
  'BrowserDomAdapter.log(error:any):any',
  'BrowserDomAdapter.logError(error:any):any',
  'BrowserDomAdapter.logGroup(error:any):any',
  'BrowserDomAdapter.logGroupEnd():any',
  'BrowserDomAdapter.makeCurrent():any',
  'BrowserDomAdapter.nextSibling(el:any):Node',
  'BrowserDomAdapter.nodeName(node:Node):string',
  'BrowserDomAdapter.nodeValue(node:Node):string',
  'BrowserDomAdapter.on(el:any, evt:any, listener:any):any',
  'BrowserDomAdapter.onAndCancel(el:any, evt:any, listener:any):Function',
  'BrowserDomAdapter.parentElement(el:any):Node',
  'BrowserDomAdapter.parse(templateHtml:string):any',
  'BrowserDomAdapter.performanceNow():number',
  'BrowserDomAdapter.preventDefault(evt:Event):any',
  'BrowserDomAdapter.query(selector:string):any',
  'BrowserDomAdapter.querySelector(el:any, selector:string):HTMLElement',
  'BrowserDomAdapter.querySelectorAll(el:any, selector:string):any[]',
  'BrowserDomAdapter.remove(node:any):Node',
  'BrowserDomAdapter.removeAttribute(element:any, attribute:string):any',
  'BrowserDomAdapter.removeAttributeNS(element:any, ns:string, name:string):any',
  'BrowserDomAdapter.removeChild(el:any, node:any):any',
  'BrowserDomAdapter.removeClass(element:any, className:string):any',
  'BrowserDomAdapter.removeStyle(element:any, stylename:string):any',
  'BrowserDomAdapter.replaceChild(el:Node, newChild:any, oldChild:any):any',
  'BrowserDomAdapter.requestAnimationFrame(callback:any):number',
  'BrowserDomAdapter.resetBaseElement():void',
  'BrowserDomAdapter.setAttribute(element:any, name:string, value:string):any',
  'BrowserDomAdapter.setAttributeNS(element:any, ns:string, name:string, value:string):any',
  'BrowserDomAdapter.setChecked(el:any, value:boolean):any',
  'BrowserDomAdapter.setData(element:any, name:string, value:string):any',
  'BrowserDomAdapter.setGlobalVar(path:string, value:any):any',
  'BrowserDomAdapter.setInnerHTML(el:any, value:any):any',
  'BrowserDomAdapter.setProperty(el:any, name:string, value:any):any',
  'BrowserDomAdapter.setStyle(element:any, styleName:string, styleValue:string):any',
  'BrowserDomAdapter.setText(el:any, value:string):any',
  'BrowserDomAdapter.setTitle(newTitle:string):any',
  'BrowserDomAdapter.setValue(el:any, value:string):any',
  'BrowserDomAdapter.tagName(element:any):string',
  'BrowserDomAdapter.templateAwareRoot(el:any):any',
  'BrowserDomAdapter.type(node:HTMLInputElement):string',
  'By',
  'By.all():Predicate<DebugElement>',
  'By.css(selector:string):Predicate<DebugElement>',
  'By.directive(type:Type):Predicate<DebugElement>',
  'Title',
  'Title.getTitle():string',
  'Title.setTitle(newTitle:string):any',
  'bootstrapStatic(appComponentType:Type, customProviders:Array<any>, initReflector:Function):Promise<ComponentRef>',
  'const BROWSER_APP_PROVIDERS:Array<any>',
  'const BROWSER_PROVIDERS:Array<any>',
  'const ELEMENT_PROBE_PROVIDERS:any[]',
  'const ELEMENT_PROBE_PROVIDERS_PROD_MODE:any[]',
  'disableDebugTools():void',
  'enableDebugTools(ref:ComponentRef):void',
  'inspectNativeElement(element:any):DebugNode',
  'browserStaticPlatform():PlatformRef'
];

describe('public API', () => {
  it("should check core.ts", () => { checkPublicApi("modules/angular2/core.ts", CORE); });
  it("should check common.ts", () => { checkPublicApi("modules/angular2/common.ts", COMMON); });
  it("should check compiler.ts",
     () => { checkPublicApi("modules/angular2/compiler.ts", COMPILER); });
  it("should check instrumentation.ts",
     () => { checkPublicApi("modules/angular2/instrumentation.ts", INSTRUMENTATION); });
  it("should check upgrade.ts", () => { checkPublicApi("modules/angular2/upgrade.ts", UPGRADE); });
  it("should check browser.ts",
     () => { checkPublicApi("modules/angular2/platform/browser_static.ts", BROWSER); });
});

function checkPublicApi(file: string, expected: string[]) {
  const sortedActual = publicApi(file).sort();
  const sortedExpected = expected.sort();
  const missing = sortedActual.filter((i) => sortedExpected.indexOf(i) < 0);
  const extra = sortedExpected.filter((i) => sortedActual.indexOf(i) < 0);

  if (missing.length > 0) {
    console.log("Missing:");
    missing.forEach((m) => console.log(m));
  }

  if (extra.length > 0) {
    console.log("Extra:");
    extra.forEach((m) => console.log(m));
  }

  expect(missing.map(s => `+${s}`).concat(extra.map(s => `-${s}`))).toEqual([]);
}