refactor(ivy): make return value of define(Component|Directive|Pipe|Injector|Injectable) private (#23371)

Ivy definition looks something like this:

```
class MyService {
  static ngInjectableDef = defineInjectable({
    …
  });
}
```

Here the argument to `defineInjectable` is well known public contract which needs
to be honored in backward compatible way between versions. The type of the
return value of `defineInjectable` on the other hand is private and can change
shape drastically between versions without effecting backwards compatibility of
libraries publish to NPM. To our users it is effectively an `OpaqueToken`.

By prefixing the type with `ɵ` we are communicating the the outside world that
the value is not public API and is subject to change without backward compatibility.

PR Close #23371

modules/benchmarks/src/largetable/render3/table.ts

@@ -7,7 +7,7 @@
  */
 
 import {ɵC as C, ɵE as E, ɵRenderFlags as RenderFlags, ɵT as T, ɵV as V, ɵb as b, ɵcR as cR, ɵcr as cr, ɵdefineComponent as defineComponent, ɵdetectChanges as detectChanges, ɵe as e, ɵsn as sn, ɵt as t, ɵv as v} from '@angular/core';
-import {ComponentDef} from '@angular/core/src/render3/interfaces/definition';
+import {ɵComponentDef} from '@angular/core/src/render3/interfaces/definition';
 
 import {TableCell, buildTable, emptyTable} from '../util';
 
@@ -15,7 +15,7 @@ export class LargeTableComponent {
   data: TableCell[][] = emptyTable;
 
   /** @nocollapse */
-  static ngComponentDef: ComponentDef<LargeTableComponent> = defineComponent({
+  static ngComponentDef: ɵComponentDef<LargeTableComponent> = defineComponent({
     type: LargeTableComponent,
     selectors: [['largetable']],
     template: function(rf: RenderFlags, ctx: LargeTableComponent) {

modules/benchmarks/src/tree/render3/tree.ts

@@ -7,7 +7,7 @@
  */
 
 import {ɵC as C, ɵE as E, ɵRenderFlags as RenderFlags, ɵT as T, ɵV as V, ɵb as b, ɵcR as cR, ɵcr as cr, ɵdefineComponent as defineComponent, ɵdetectChanges as _detectChanges, ɵe as e, ɵi1 as i1, ɵp as p, ɵsn as sn, ɵt as t, ɵv as v} from '@angular/core';
-import {ComponentDef} from '@angular/core/src/render3/interfaces/definition';
+import {ɵComponentDef} from '@angular/core/src/render3/interfaces/definition';
 
 import {TreeNode, buildTree, emptyTree} from '../util';
 
@@ -35,7 +35,7 @@ export class TreeComponent {
   data: TreeNode = emptyTree;
 
   /** @nocollapse */
-  static ngComponentDef: ComponentDef<TreeComponent> = defineComponent({
+  static ngComponentDef: ɵComponentDef<TreeComponent> = defineComponent({
     type: TreeComponent,
     selectors: [['tree']],
     template: function(rf: RenderFlags, ctx: TreeComponent) {
@@ -95,7 +95,7 @@ export class TreeFunction {
   data: TreeNode = emptyTree;
 
   /** @nocollapse */
-  static ngComponentDef: ComponentDef<TreeFunction> = defineComponent({
+  static ngComponentDef: ɵComponentDef<TreeFunction> = defineComponent({
     type: TreeFunction,
     selectors: [['tree']],
     template: function(rf: RenderFlags, ctx: TreeFunction) {

packages/compiler-cli/test/ngc_spec.ts

@@ -2151,7 +2151,7 @@ describe('ngc transformer command-line', () => {
       });
     });
 
-    it('compiles a basic InjectableDef', () => {
+    it('compiles a basic ɵInjectableDef', () => {
       const source = compileService(`
         import {Injectable} from '@angular/core';
         import {Module} from './module';
@@ -2187,7 +2187,7 @@ describe('ngc transformer command-line', () => {
          expect(source).toMatch(/\/\*\* @nocollapse \*\/ Service\.ngInjectableDef =/);
        });
 
-    it('compiles a useValue InjectableDef', () => {
+    it('compiles a useValue ɵInjectableDef', () => {
       const source = compileService(`
         import {Injectable} from '@angular/core';
         import {Module} from './module';
@@ -2203,7 +2203,7 @@ describe('ngc transformer command-line', () => {
       expect(source).toMatch(/ngInjectableDef.*return CONST_SERVICE/);
     });
 
-    it('compiles a useExisting InjectableDef', () => {
+    it('compiles a useExisting ɵInjectableDef', () => {
       const source = compileService(`
         import {Injectable} from '@angular/core';
         import {Module} from './module';
@@ -2220,7 +2220,7 @@ describe('ngc transformer command-line', () => {
       expect(source).toMatch(/ngInjectableDef.*return ..\.inject\(Existing\)/);
     });
 
-    it('compiles a useFactory InjectableDef with optional dep', () => {
+    it('compiles a useFactory ɵInjectableDef with optional dep', () => {
       const source = compileService(`
         import {Injectable, Optional} from '@angular/core';
         import {Module} from './module';
@@ -2240,7 +2240,7 @@ describe('ngc transformer command-line', () => {
       expect(source).toMatch(/ngInjectableDef.*return ..\(..\.inject\(Existing, 8\)/);
     });
 
-    it('compiles a useFactory InjectableDef with skip-self dep', () => {
+    it('compiles a useFactory ɵInjectableDef with skip-self dep', () => {
       const source = compileService(`
         import {Injectable, SkipSelf} from '@angular/core';
         import {Module} from './module';

packages/core/src/change_detection/differs/iterable_differs.ts

@@ -6,12 +6,13 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {InjectableDef, defineInjectable} from '../../di/defs';
+import {defineInjectable, ɵInjectableDef} from '../../di/defs';
 import {Optional, SkipSelf} from '../../di/metadata';
 import {StaticProvider} from '../../di/provider';
 import {DefaultIterableDifferFactory} from '../differs/default_iterable_differ';
 
 
+
 /**
  * A type describing supported iterable types.
  *
@@ -137,7 +138,7 @@ export interface IterableDifferFactory {
  *
  */
 export class IterableDiffers {
-  static ngInjectableDef: InjectableDef<IterableDiffers> = defineInjectable({
+  static ngInjectableDef: ɵInjectableDef<IterableDiffers> = defineInjectable({
     providedIn: 'root',
     factory: () => new IterableDiffers([new DefaultIterableDifferFactory()])
   });

packages/core/src/core_render3_private_export.ts

@@ -75,9 +75,9 @@ export {
   st as ɵst,
   ld as ɵld,
   Pp as ɵPp,
-  ComponentDef as ɵComponentDef,
+  ɵComponentDef,
-  DirectiveDef as ɵDirectiveDef,
+  ɵDirectiveDef,
-  PipeDef as ɵPipeDef,
+  ɵPipeDef,
   whenRendered as ɵwhenRendered,
 } from './render3/index';
 export {

packages/core/src/di/defs.ts

@@ -17,14 +17,15 @@ import {ClassProvider, ClassSansProvider, ConstructorProvider, ConstructorSansPr
  * requesting injection of other types if necessary.
  *
  * Optionally, a `providedIn` parameter specifies that the given type belongs to a particular
- * `InjectorDef`, `NgModule`, or a special scope (e.g. `'root'`). A value of `null` indicates
+ * `ɵInjectorDef`, `NgModule`, or a special scope (e.g. `'root'`). A value of `null` indicates
  * that the injectable does not belong to any scope.
  *
- * This type is typically generated by the Angular compiler, but can be hand-written if needed.
+ * NOTE: This is a semi public API, and there are no guaranties that the shape of this API will
+ * remain consistent between version. Use with caution.
  *
  * @experimental
  */
-export interface InjectableDef<T> {
+export interface ɵInjectableDef<T> {
   /**
    * Specifies that the given type belongs to a particular injector:
    * - `InjectorType` such as `NgModule`,
@@ -50,13 +51,13 @@ export interface InjectableDef<T> {
  * Information about the providers to be included in an `Injector` as well as how the given type
  * which carries the information should be created by the DI system.
  *
- * An `InjectorDef` can import other types which have `InjectorDefs`, forming a deep nested
+ * An `ɵInjectorDef` can import other types which have `InjectorDefs`, forming a deep nested
  * structure of providers with a defined priority (identically to how `NgModule`s also have
  * an import/dependency structure).
  *
  * @experimental
  */
-export interface InjectorDef<T> {
+export interface ɵInjectorDef<T> {
   factory: () => T;
 
   // TODO(alxhub): Narrow down the type here once decorators properly change the return type of the
@@ -68,29 +69,29 @@ export interface InjectorDef<T> {
 }
 
 /**
- * A `Type` which has an `InjectableDef` static field.
+ * A `Type` which has an `ɵInjectableDef` static field.
  *
  * `InjectableDefType`s contain their own Dependency Injection metadata and are usable in an
- * `InjectorDef`-based `StaticInjector.
+ * `ɵInjectorDef`-based `StaticInjector.
  *
  * @experimental
  */
-export interface InjectableType<T> extends Type<T> { ngInjectableDef: InjectableDef<T>; }
+export interface InjectableType<T> extends Type<T> { ngInjectableDef: ɵInjectableDef<T>; }
 
 /**
- * A type which has an `InjectorDef` static field.
+ * A type which has an `ɵInjectorDef` static field.
  *
  * `InjectorDefTypes` can be used to configure a `StaticInjector`.
  *
  * @experimental
  */
-export interface InjectorType<T> extends Type<T> { ngInjectorDef: InjectorDef<T>; }
+export interface InjectorType<T> extends Type<T> { ngInjectorDef: ɵInjectorDef<T>; }
 
 /**
- * Describes the `InjectorDef` equivalent of a `ModuleWithProviders`, an `InjectorDefType` with an
+ * Describes the `ɵInjectorDef` equivalent of a `ModuleWithProviders`, an `InjectorDefType` with an
  * associated array of providers.
  *
- * Objects of this type can be listed in the imports section of an `InjectorDef`.
+ * Objects of this type can be listed in the imports section of an `ɵInjectorDef`.
  *
  * @experimental
  */
@@ -102,7 +103,7 @@ export interface InjectorTypeWithProviders<T> {
 
 
 /**
- * Construct an `InjectableDef` which defines how a token will be constructed by the DI system, and
+ * Construct an `ɵInjectableDef` which defines how a token will be constructed by the DI system, and
  * in which injectors (if any) it will be available.
  *
  * This should be assigned to a static `ngInjectableDef` field on a type, which will then be an
@@ -120,7 +121,7 @@ export interface InjectorTypeWithProviders<T> {
 export function defineInjectable<T>(opts: {
   providedIn?: Type<any>| 'root' | 'any' | null,
   factory: () => T,
-}): InjectableDef<T> {
+}): ɵInjectableDef<T> {
   return {
     providedIn: opts.providedIn as any || null,
     factory: opts.factory,
@@ -129,7 +130,7 @@ export function defineInjectable<T>(opts: {
 }
 
 /**
- * Construct an `InjectorDef` which configures an injector.
+ * Construct an `ɵInjectorDef` which configures an injector.
  *
  * This should be assigned to a static `ngInjectorDef` field on a type, which will then be an
  * `InjectorType`.
@@ -149,7 +150,7 @@ export function defineInjectable<T>(opts: {
  * @experimental
  */
 export function defineInjector(options: {factory: () => any, providers?: any[], imports?: any[]}):
-    InjectorDef<any> {
+    ɵInjectorDef<any> {
   return {
     factory: options.factory,
     providers: options.providers || [],

packages/core/src/di/injectable.ts

@@ -11,7 +11,7 @@ import {Type} from '../type';
 import {makeDecorator, makeParamDecorator} from '../util/decorators';
 import {getClosureSafeProperty} from '../util/property';
 
-import {InjectableDef, InjectableType, defineInjectable} from './defs';
+import {InjectableType, defineInjectable, ɵInjectableDef} from './defs';
 import {inject, injectArgs} from './injector';
 import {ClassSansProvider, ConstructorProvider, ConstructorSansProvider, ExistingProvider, ExistingSansProvider, FactoryProvider, FactorySansProvider, StaticClassProvider, StaticClassSansProvider, ValueProvider, ValueSansProvider} from './provider';
 
@@ -134,4 +134,4 @@ export const Injectable: InjectableDecorator = makeDecorator(
  *
  * @experimental
  */
-export interface InjectableType<T> extends Type<T> { ngInjectableDef: InjectableDef<T>; }
+export interface InjectableType<T> extends Type<T> { ngInjectableDef: ɵInjectableDef<T>; }

packages/core/src/di/injection_token.ts

@@ -8,7 +8,8 @@
 
 import {Type} from '../type';
 
-import {InjectableDef, defineInjectable} from './defs';
+import {defineInjectable, ɵInjectableDef} from './defs';
+
 
 /**
  * Creates a token that can be used in a DI Provider.
@@ -52,7 +53,7 @@ export class InjectionToken<T> {
   /** @internal */
   readonly ngMetadataName = 'InjectionToken';
 
-  readonly ngInjectableDef: InjectableDef<T>|undefined;
+  readonly ngInjectableDef: ɵInjectableDef<T>|undefined;
 
   constructor(protected _desc: string, options?: {
     providedIn?: Type<any>| 'root' | null,
@@ -72,5 +73,5 @@ export class InjectionToken<T> {
 }
 
 export interface InjectableDefToken<T> extends InjectionToken<T> {
-  ngInjectableDef: InjectableDef<T>;
+  ngInjectableDef: ɵInjectableDef<T>;
 }

packages/core/src/di/injector.ts

@@ -9,7 +9,7 @@
 import {Type} from '../type';
 import {stringify} from '../util';
 
-import {InjectableDef, defineInjectable} from './defs';
+import {defineInjectable, ɵInjectableDef} from './defs';
 import {resolveForwardRef} from './forward_ref';
 import {InjectionToken} from './injection_token';
 import {Inject, Optional, Self, SkipSelf} from './metadata';
@@ -462,7 +462,7 @@ export function inject<T>(token: Type<T>| InjectionToken<T>, flags = InjectFlags
   if (_currentInjector === undefined) {
     throw new Error(`inject() must be called from an injection context`);
   } else if (_currentInjector === null) {
-    const injectableDef: InjectableDef<T> = (token as any).ngInjectableDef;
+    const injectableDef: ɵInjectableDef<T> = (token as any).ngInjectableDef;
     if (injectableDef && injectableDef.providedIn == 'root') {
       return injectableDef.value === undefined ? injectableDef.value = injectableDef.factory() :
                                                  injectableDef.value;

packages/core/src/di/r3_injector.ts

@@ -10,7 +10,7 @@ import {OnDestroy} from '../metadata/lifecycle_hooks';
 import {Type} from '../type';
 import {stringify} from '../util';
 
-import {InjectableDef, InjectableType, InjectorDef, InjectorType, InjectorTypeWithProviders} from './defs';
+import {InjectableType, InjectorType, InjectorTypeWithProviders, ɵInjectableDef, ɵInjectorDef} from './defs';
 import {resolveForwardRef} from './forward_ref';
 import {InjectableDefToken, InjectionToken} from './injection_token';
 import {INJECTOR, InjectFlags, Injector, NullInjector, THROW_IF_NOT_FOUND, USE_VALUE, inject, injectArgs, setCurrentInjector} from './injector';
@@ -200,7 +200,7 @@ export class R3Injector {
     // read, so care is taken to only do the read once.
 
     // First attempt to read the ngInjectorDef.
-    let def = (defOrWrappedDef as InjectorType<any>).ngInjectorDef as(InjectorDef<any>| undefined);
+    let def = (defOrWrappedDef as InjectorType<any>).ngInjectorDef as(ɵInjectorDef<any>| undefined);
 
     // If that's not present, then attempt to read ngModule from the InjectorDefTypeWithProviders.
     const ngModule =
@@ -219,7 +219,7 @@ export class R3Injector {
         EMPTY_ARRAY;
 
     // Finally, if defOrWrappedType was an `InjectorDefTypeWithProviders`, then the actual
-    // `InjectorDef` is on its `ngModule`.
+    // `ɵInjectorDef` is on its `ngModule`.
     if (ngModule !== undefined) {
       def = ngModule.ngInjectorDef;
     }
@@ -314,7 +314,7 @@ export class R3Injector {
     return record.value as T;
   }
 
-  private injectableDefInScope(def: InjectableDef<any>): boolean {
+  private injectableDefInScope(def: ɵInjectableDef<any>): boolean {
     if (!def.providedIn) {
       return false;
     } else if (typeof def.providedIn === 'string') {

packages/core/src/metadata/ng_module.ts

@@ -6,13 +6,14 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {InjectorDef, InjectorType, defineInjector} from '../di/defs';
+import {InjectorType, defineInjector, ɵInjectorDef} from '../di/defs';
 import {convertInjectableProviderToFactory} from '../di/injectable';
 import {Provider} from '../di/provider';
 import {Type} from '../type';
 import {TypeDecorator, makeDecorator} from '../util/decorators';
 
 
+
 /**
  * A wrapper around a module that also includes the providers.
  *

packages/core/src/render3/component.ts

@@ -15,7 +15,7 @@ import {ComponentRef as viewEngine_ComponentRef} from '../linker/component_facto
 import {assertComponentType, assertNotNull} from './assert';
 import {queueInitHooks, queueLifecycleHooks} from './hooks';
 import {CLEAN_PROMISE, ROOT_DIRECTIVE_INDICES, _getComponentHostLElementNode, baseDirectiveCreate, createLView, createTView, detectChangesInternal, enterView, executeInitAndContentHooks, getRootView, hostElement, initChangeDetectorIfExisting, leaveView, locateHostElement, setHostBindings} from './instructions';
-import {ComponentDef, ComponentType} from './interfaces/definition';
+import {ComponentType, ɵComponentDef} from './interfaces/definition';
 import {LElementNode, TNodeFlags} from './interfaces/node';
 import {RElement, RendererFactory3, domRendererFactory3} from './interfaces/renderer';
 import {LView, LViewFlags, RootContext} from './interfaces/view';
@@ -51,7 +51,7 @@ export interface CreateComponentOptions {
    * features list because there's no way of knowing when the component will be used as
    * a root component.
    */
-  hostFeatures?: (<T>(component: T, componentDef: ComponentDef<T>) => void)[];
+  hostFeatures?: (<T>(component: T, componentDef: ɵComponentDef<T>) => void)[];
 
   /**
    * A function which is used to schedule change detection work in the future.
@@ -120,7 +120,7 @@ export function renderComponent<T>(
     opts: CreateComponentOptions = {}): T {
   ngDevMode && assertComponentType(componentType);
   const rendererFactory = opts.rendererFactory || domRendererFactory3;
-  const componentDef = (componentType as ComponentType<T>).ngComponentDef as ComponentDef<T>;
+  const componentDef = (componentType as ComponentType<T>).ngComponentDef as ɵComponentDef<T>;
   if (componentDef.type != componentType) componentDef.type = componentType;
   let component: T;
   // The first index of the first selector is the tag name.
@@ -177,7 +177,7 @@ export function renderComponent<T>(
  * renderComponent(AppComponent, {features: [RootLifecycleHooks]});
  * ```
  */
-export function LifecycleHooksFeature(component: any, def: ComponentDef<any>): void {
+export function LifecycleHooksFeature(component: any, def: ɵComponentDef<any>): void {
   const elementNode = _getComponentHostLElementNode(component);
 
   // Root component is always created at dir index 0

packages/core/src/render3/definition.ts

@@ -16,7 +16,7 @@ import {Type} from '../type';
 import {resolveRendererType2} from '../view/util';
 
 import {diPublic} from './di';
-import {ComponentDef, ComponentDefFeature, ComponentTemplate, ComponentType, DirectiveDef, DirectiveDefFeature, DirectiveDefListOrFactory, DirectiveType, DirectiveTypesOrFactory, PipeDef, PipeType, PipeTypesOrFactory} from './interfaces/definition';
+import {ComponentDefFeature, ComponentTemplate, ComponentType, DirectiveDefFeature, DirectiveDefListOrFactory, DirectiveType, DirectiveTypesOrFactory, PipeType, PipeTypesOrFactory, ɵComponentDef, ɵDirectiveDef, ɵPipeDef} from './interfaces/definition';
 import {CssSelectorList, SelectorFlags} from './interfaces/projection';
 
 
@@ -150,8 +150,8 @@ export function defineComponent<T>(componentDefinition: {
   /**
    * Registry of directives and components that may be found in this component's view.
    *
-   * The property is either an array of `DirectiveDef`s or a function which returns the array of
+   * The property is either an array of `ɵDirectiveDef`s or a function which returns the array of
-   * `DirectiveDef`s. The function is necessary to be able to support forward declarations.
+   * `ɵDirectiveDef`s. The function is necessary to be able to support forward declarations.
    */
   directives?: DirectiveTypesOrFactory | null;
 
@@ -162,11 +162,11 @@ export function defineComponent<T>(componentDefinition: {
    * `PipeDefs`s. The function is necessary to be able to support forward declarations.
    */
   pipes?: PipeTypesOrFactory | null;
-}): ComponentDef<T> {
+}): ɵComponentDef<T> {
   const type = componentDefinition.type;
   const pipeTypes = componentDefinition.pipes !;
   const directiveTypes = componentDefinition.directives !;
-  const def = <ComponentDef<any>>{
+  const def = <ɵComponentDef<any>>{
     type: type,
     diPublic: null,
     factory: componentDefinition.factory,
@@ -200,7 +200,7 @@ export function defineComponent<T>(componentDefinition: {
 }
 
 export function extractDirectiveDef(type: DirectiveType<any>& ComponentType<any>):
-    DirectiveDef<any>|ComponentDef<any> {
+    ɵDirectiveDef<any>|ɵComponentDef<any> {
   const def = type.ngComponentDef || type.ngDirectiveDef;
   if (ngDevMode && !def) {
     throw new Error(`'${type.name}' is neither 'ComponentType' or 'DirectiveType'.`);
@@ -208,7 +208,7 @@ export function extractDirectiveDef(type: DirectiveType<any>& ComponentType<any>
   return def;
 }
 
-export function extractPipeDef(type: PipeType<any>): PipeDef<any> {
+export function extractPipeDef(type: PipeType<any>): ɵPipeDef<any> {
   const def = type.ngPipeDef;
   if (ngDevMode && !def) {
     throw new Error(`'${type.name}' is not a 'PipeType'.`);
@@ -250,7 +250,7 @@ type OnChangesExpando = OnChanges & {
  */
 export function NgOnChangesFeature(inputPropertyNames?: {[key: string]: string}):
     DirectiveDefFeature {
-  return function(definition: DirectiveDef<any>): void {
+  return function(definition: ɵDirectiveDef<any>): void {
     const inputs = definition.inputs;
     const proto = definition.type.prototype;
     // Place where we will store SimpleChanges if there is a change
@@ -306,7 +306,7 @@ export function NgOnChangesFeature(inputPropertyNames?: {[key: string]: string})
 }
 
 
-export function PublicFeature<T>(definition: DirectiveDef<T>) {
+export function PublicFeature<T>(definition: ɵDirectiveDef<T>) {
   definition.diPublic = diPublic;
 }
 
@@ -400,7 +400,7 @@ export const defineDirective = defineComponent as any as<T>(directiveDefinition:
    * See: {@link Directive.exportAs}
    */
   exportAs?: string;
-}) => DirectiveDef<T>;
+}) => ɵDirectiveDef<T>;
 
 /**
  * Create a pipe definition object.
@@ -428,8 +428,8 @@ export function definePipe<T>(pipeDef: {
 
   /** Whether the pipe is pure. */
   pure?: boolean
-}): PipeDef<T> {
+}): ɵPipeDef<T> {
-  return <PipeDef<T>>{
+  return <ɵPipeDef<T>>{
     name: pipeDef.name,
     n: pipeDef.factory,
     pure: pipeDef.pure !== false,

packages/core/src/render3/di.ts

@@ -20,7 +20,7 @@ import {Type} from '../type';
 
 import {assertGreaterThan, assertLessThan, assertNotNull} from './assert';
 import {addToViewTree, assertPreviousIsParent, createLContainer, createLNodeObject, getDirectiveInstance, getPreviousOrParentNode, getRenderer, isComponent, renderEmbeddedTemplate, resolveDirective} from './instructions';
-import {ComponentTemplate, DirectiveDef, DirectiveDefList, PipeDefList} from './interfaces/definition';
+import {ComponentTemplate, DirectiveDefList, PipeDefList, ɵDirectiveDef} from './interfaces/definition';
 import {LInjector} from './interfaces/injector';
 import {LContainerNode, LElementNode, LNode, LNodeType, LViewNode, TNodeFlags} from './interfaces/node';
 import {QueryReadType} from './interfaces/query';
@@ -139,7 +139,7 @@ export function getOrCreateNodeInjectorForNode(node: LElementNode | LContainerNo
  * @param di The node injector in which a directive will be added
  * @param def The definition of the directive to be made public
  */
-export function diPublicInInjector(di: LInjector, def: DirectiveDef<any>): void {
+export function diPublicInInjector(di: LInjector, def: ɵDirectiveDef<any>): void {
   bloomAdd(di, def.type);
 }
 
@@ -148,7 +148,7 @@ export function diPublicInInjector(di: LInjector, def: DirectiveDef<any>): void
  *
  * @param def The definition of the directive to be made public
  */
-export function diPublic(def: DirectiveDef<any>): void {
+export function diPublic(def: ɵDirectiveDef<any>): void {
   diPublicInInjector(getOrCreateNodeInjector(), def);
 }
 
@@ -371,7 +371,7 @@ export function getOrCreateInjectable<T>(di: LInjector, token: Type<T>, flags?:
         for (let i = start; i < end; i++) {
           // Get the definition for the directive at this index and, if it is injectable (diPublic),
           // and matches the given token, return the directive instance.
-          const directiveDef = defs[i] as DirectiveDef<any>;
+          const directiveDef = defs[i] as ɵDirectiveDef<any>;
           if (directiveDef.type === token && directiveDef.diPublic) {
             return getDirectiveInstance(node.view.directives ![i]);
           }
@@ -400,7 +400,7 @@ function searchMatchesQueuedForCreation<T>(node: LNode, token: any): T|null {
   const matches = node.view.tView.currentMatches;
   if (matches) {
     for (let i = 0; i < matches.length; i += 2) {
-      const def = matches[i] as DirectiveDef<any>;
+      const def = matches[i] as ɵDirectiveDef<any>;
       if (def.type === token) {
         return resolveDirective(def, i + 1, matches, node.view.tView);
       }

packages/core/src/render3/hooks.ts

@@ -7,7 +7,7 @@
  */
 
 import {assertEqual} from './assert';
-import {DirectiveDef} from './interfaces/definition';
+import {ɵDirectiveDef} from './interfaces/definition';
 import {TNodeFlags} from './interfaces/node';
 import {HookData, LView, LifecycleStage, TView} from './interfaces/view';
 
@@ -52,7 +52,7 @@ export function queueLifecycleHooks(flags: number, currentView: LView): void {
     // directiveCreate) so we can preserve the current hook order. Content, view, and destroy
     // hooks for projected components and directives must be called *before* their hosts.
     for (let i = start; i < end; i++) {
-      const def: DirectiveDef<any> = tView.directives ![i];
+      const def: ɵDirectiveDef<any> = tView.directives ![i];
       queueContentHooks(def, tView, i);
       queueViewHooks(def, tView, i);
       queueDestroyHooks(def, tView, i);
@@ -61,7 +61,7 @@ export function queueLifecycleHooks(flags: number, currentView: LView): void {
 }
 
 /** Queues afterContentInit and afterContentChecked hooks on TView */
-function queueContentHooks(def: DirectiveDef<any>, tView: TView, i: number): void {
+function queueContentHooks(def: ɵDirectiveDef<any>, tView: TView, i: number): void {
   if (def.afterContentInit) {
     (tView.contentHooks || (tView.contentHooks = [])).push(i, def.afterContentInit);
   }
@@ -73,7 +73,7 @@ function queueContentHooks(def: DirectiveDef<any>, tView: TView, i: number): voi
 }
 
 /** Queues afterViewInit and afterViewChecked hooks on TView */
-function queueViewHooks(def: DirectiveDef<any>, tView: TView, i: number): void {
+function queueViewHooks(def: ɵDirectiveDef<any>, tView: TView, i: number): void {
   if (def.afterViewInit) {
     (tView.viewHooks || (tView.viewHooks = [])).push(i, def.afterViewInit);
   }
@@ -85,7 +85,7 @@ function queueViewHooks(def: DirectiveDef<any>, tView: TView, i: number): void {
 }
 
 /** Queues onDestroy hooks on TView */
-function queueDestroyHooks(def: DirectiveDef<any>, tView: TView, i: number): void {
+function queueDestroyHooks(def: ɵDirectiveDef<any>, tView: TView, i: number): void {
   if (def.onDestroy != null) {
     (tView.destroyHooks || (tView.destroyHooks = [])).push(i, def.onDestroy);
   }

packages/core/src/render3/index.ts

@@ -8,7 +8,7 @@
 
 import {LifecycleHooksFeature, createComponentRef, getHostElement, getRenderedText, renderComponent, whenRendered} from './component';
 import {NgOnChangesFeature, PublicFeature, defineComponent, defineDirective, definePipe} from './definition';
-import {ComponentDef, ComponentTemplate, ComponentType, DirectiveDef, DirectiveDefFlags, DirectiveType, PipeDef} from './interfaces/definition';
+import {ComponentTemplate, ComponentType, DirectiveDefFlags, DirectiveType, ɵComponentDef, ɵDirectiveDef, ɵPipeDef} from './interfaces/definition';
 
 export {QUERY_READ_CONTAINER_REF, QUERY_READ_ELEMENT_REF, QUERY_READ_FROM_NODE, QUERY_READ_TEMPLATE_REF, directiveInject, injectAttribute, injectChangeDetectorRef, injectElementRef, injectTemplateRef, injectViewContainerRef} from './di';
 export {RenderFlags} from './interfaces/definition';
@@ -103,15 +103,15 @@ export {
 // clang-format on
 
 export {
-  ComponentDef,
+  ɵComponentDef,
   ComponentTemplate,
   ComponentType,
-  DirectiveDef,
+  ɵDirectiveDef,
   DirectiveDefFlags,
   DirectiveType,
   NgOnChangesFeature,
   PublicFeature,
-  PipeDef,
+  ɵPipeDef,
   LifecycleHooksFeature,
   defineComponent,
   defineDirective,

packages/core/src/render3/instructions.ts

@@ -19,7 +19,7 @@ import {LContainerNode, LElementNode, LNode, LNodeType, TNodeFlags, LProjectionN
 import {assertNodeType} from './node_assert';
 import {appendChild, insertChild, insertView, appendProjectedNode, removeView, canInsertNativeNode, createTextNode} from './node_manipulation';
 import {isNodeMatchingSelectorList, matchingSelectorIndex} from './node_selector_matcher';
-import {ComponentDef, ComponentTemplate, ComponentType, DirectiveDef, DirectiveDefList, DirectiveDefListOrFactory, DirectiveType, PipeDef, PipeDefList, PipeDefListOrFactory, RenderFlags} from './interfaces/definition';
+import {ɵComponentDef, ComponentTemplate, ComponentType, ɵDirectiveDef, DirectiveDefList, DirectiveDefListOrFactory, DirectiveType, ɵPipeDef, PipeDefList, PipeDefListOrFactory, RenderFlags} from './interfaces/definition';
 import {RElement, RText, Renderer3, RendererFactory3, ProceduralRenderer3, ObjectOrientedRenderer3, RendererStyleFlags3, isProceduralRenderer} from './interfaces/renderer';
 import {isDifferent, stringify} from './util';
 import {executeHooks, queueLifecycleHooks, queueInitHooks, executeInitHooks} from './hooks';
@@ -255,7 +255,7 @@ export function setHostBindings(bindings: number[] | null): void {
     const defs = currentView.tView.directives !;
     for (let i = 0; i < bindings.length; i += 2) {
       const dirIndex = bindings[i];
-      const def = defs[dirIndex] as DirectiveDef<any>;
+      const def = defs[dirIndex] as ɵDirectiveDef<any>;
       def.hostBindings && def.hostBindings(dirIndex, bindings[i + 1]);
     }
   }
@@ -578,7 +578,7 @@ function cacheMatchingDirectivesForNode(
   const matches = tView.currentMatches = findDirectiveMatches(tNode);
   if (matches) {
     for (let i = 0; i < matches.length; i += 2) {
-      const def = matches[i] as DirectiveDef<any>;
+      const def = matches[i] as ɵDirectiveDef<any>;
       const valueIndex = i + 1;
       resolveDirective(def, valueIndex, matches, tView);
       saveNameToExportMap(matches[valueIndex] as number, def, exportsMap);
@@ -595,7 +595,7 @@ function findDirectiveMatches(tNode: TNode): CurrentMatchesList|null {
     for (let i = 0; i < registry.length; i++) {
       const def = registry[i];
       if (isNodeMatchingSelectorList(tNode, def.selectors !)) {
-        if ((def as ComponentDef<any>).template) {
+        if ((def as ɵComponentDef<any>).template) {
           if (tNode.flags & TNodeFlags.isComponent) throwMultipleComponentError(tNode);
           tNode.flags = TNodeFlags.isComponent;
         }
@@ -608,7 +608,7 @@ function findDirectiveMatches(tNode: TNode): CurrentMatchesList|null {
 }
 
 export function resolveDirective(
-    def: DirectiveDef<any>, valueIndex: number, matches: CurrentMatchesList, tView: TView): any {
+    def: ɵDirectiveDef<any>, valueIndex: number, matches: CurrentMatchesList, tView: TView): any {
   if (matches[valueIndex] === null) {
     matches[valueIndex] = CIRCULAR;
     const instance = def.factory();
@@ -663,7 +663,7 @@ function instantiateDirectivesDirectly() {
     const tDirectives = currentView.tView.directives !;
 
     for (let i = start; i < end; i++) {
-      const def: DirectiveDef<any> = tDirectives[i];
+      const def: ɵDirectiveDef<any> = tDirectives[i];
       directiveCreate(i, def.factory(), def);
     }
   }
@@ -691,11 +691,11 @@ function cacheMatchingLocalNames(
  * to their directive instances.
  */
 function saveNameToExportMap(
-    index: number, def: DirectiveDef<any>| ComponentDef<any>,
+    index: number, def: ɵDirectiveDef<any>| ɵComponentDef<any>,
     exportsMap: {[key: string]: number} | null) {
   if (exportsMap) {
     if (def.exportAs) exportsMap[def.exportAs] = index;
-    if ((def as ComponentDef<any>).template) exportsMap[''] = index;
+    if ((def as ɵComponentDef<any>).template) exportsMap[''] = index;
   }
 }
 
@@ -801,12 +801,12 @@ export function locateHostElement(
  * Creates the host LNode.
  *
  * @param rNode Render host element.
- * @param def ComponentDef
+ * @param def ɵComponentDef
  *
  * @returns LElementNode created
  */
 export function hostElement(
-    tag: string, rNode: RElement | null, def: ComponentDef<any>): LElementNode {
+    tag: string, rNode: RElement | null, def: ɵComponentDef<any>): LElementNode {
   resetApplicationState();
   const node = createLNode(
       0, LNodeType.Element, rNode,
@@ -1013,7 +1013,7 @@ function generatePropertyAliases(
     const defs = currentView.tView.directives !;
 
     for (let i = start; i < end; i++) {
-      const directiveDef = defs[i] as DirectiveDef<any>;
+      const directiveDef = defs[i] as ɵDirectiveDef<any>;
       const propertyAliasMap: {[publicName: string]: string} =
           isInput ? directiveDef.inputs : directiveDef.outputs;
       for (let publicName in propertyAliasMap) {
@@ -1203,18 +1203,18 @@ export function textBinding<T>(index: number, value: T | NO_CHANGE): void {
  *       be retrieved before they are created in which case the value will be null.
  *
  * @param directive The directive instance.
- * @param directiveDef DirectiveDef object which contains information about the template.
+ * @param directiveDef ɵDirectiveDef object which contains information about the template.
  */
 export function directiveCreate<T>(
-    index: number, directive: T, directiveDef: DirectiveDef<T>| ComponentDef<T>): T {
+    index: number, directive: T, directiveDef: ɵDirectiveDef<T>| ɵComponentDef<T>): T {
   const instance = baseDirectiveCreate(index, directive, directiveDef);
 
   ngDevMode && assertNotNull(previousOrParentNode.tNode, 'previousOrParentNode.tNode');
   const tNode = previousOrParentNode.tNode;
 
-  const isComponent = (directiveDef as ComponentDef<T>).template;
+  const isComponent = (directiveDef as ɵComponentDef<T>).template;
   if (isComponent) {
-    addComponentLogic(index, directive, directiveDef as ComponentDef<T>);
+    addComponentLogic(index, directive, directiveDef as ɵComponentDef<T>);
   }
 
   if (firstTemplatePass) {
@@ -1232,7 +1232,7 @@ export function directiveCreate<T>(
   return instance;
 }
 
-function addComponentLogic<T>(index: number, instance: T, def: ComponentDef<T>): void {
+function addComponentLogic<T>(index: number, instance: T, def: ɵComponentDef<T>): void {
   const tView = getOrCreateTView(def.template, def.directiveDefs, def.pipeDefs);
 
   // Only component views should be added to the view tree directly. Embedded views are
@@ -1258,7 +1258,7 @@ function addComponentLogic<T>(index: number, instance: T, def: ComponentDef<T>):
  * current Angular. Example: local refs and inputs on root component.
  */
 export function baseDirectiveCreate<T>(
-    index: number, directive: T, directiveDef: DirectiveDef<T>| ComponentDef<T>): T {
+    index: number, directive: T, directiveDef: ɵDirectiveDef<T>| ɵComponentDef<T>): T {
   ngDevMode &&
       assertEqual(
           currentView.bindingStartIndex, -1, 'directives should be created before any bindings');
@@ -1631,7 +1631,7 @@ export function componentRefresh<T>(directiveIndex: number, elementIndex: number
   // Only attached CheckAlways components or attached, dirty OnPush components should be checked
   if (viewAttached(hostView) && hostView.flags & (LViewFlags.CheckAlways | LViewFlags.Dirty)) {
     ngDevMode && assertDataInRange(directiveIndex, directives !);
-    const def = currentView.tView.directives ![directiveIndex] as ComponentDef<T>;
+    const def = currentView.tView.directives ![directiveIndex] as ɵComponentDef<T>;
 
     detectChangesInternal(
         hostView, element, def, getDirectiveInstance(directives ![directiveIndex]));
@@ -1943,7 +1943,7 @@ export function detectChanges<T>(component: T): void {
   const hostNode = _getComponentHostLElementNode(component);
   ngDevMode && assertNotNull(hostNode.data, 'Component host node should be attached to an LView');
   const componentIndex = hostNode.tNode !.flags >> TNodeFlags.DirectiveStartingIndexShift;
-  const def = hostNode.view.tView.directives ![componentIndex] as ComponentDef<T>;
+  const def = hostNode.view.tView.directives ![componentIndex] as ɵComponentDef<T>;
   detectChangesInternal(hostNode.data as LView, hostNode, def, component);
 }
 
@@ -1965,7 +1965,7 @@ export function checkNoChanges<T>(component: T): void {
 
 /** Checks the view of the component provided. Does not gate on dirty checks or execute doCheck. */
 export function detectChangesInternal<T>(
-    hostView: LView, hostNode: LElementNode, def: ComponentDef<T>, component: T) {
+    hostView: LView, hostNode: LElementNode, def: ɵComponentDef<T>, component: T) {
   const oldView = enterView(hostView, hostNode);
   const template = def.template;
 

packages/core/src/render3/interfaces/definition.ts

@@ -35,24 +35,24 @@ export const enum RenderFlags {
 }
 
 /**
- * A subclass of `Type` which has a static `ngComponentDef`:`ComponentDef` field making it
+ * A subclass of `Type` which has a static `ngComponentDef`:`ɵComponentDef` field making it
  * consumable for rendering.
  */
-export interface ComponentType<T> extends Type<T> { ngComponentDef: ComponentDef<T>; }
+export interface ComponentType<T> extends Type<T> { ngComponentDef: ɵComponentDef<T>; }
 
 /**
- * A subclass of `Type` which has a static `ngDirectiveDef`:`DirectiveDef` field making it
+ * A subclass of `Type` which has a static `ngDirectiveDef`:`ɵDirectiveDef` field making it
  * consumable for rendering.
  */
-export interface DirectiveType<T> extends Type<T> { ngDirectiveDef: DirectiveDef<T>; }
+export interface DirectiveType<T> extends Type<T> { ngDirectiveDef: ɵDirectiveDef<T>; }
 
 export const enum DirectiveDefFlags {ContentQuery = 0b10}
 
 /**
- * A subclass of `Type` which has a static `ngPipeDef`:`PipeDef` field making it
+ * A subclass of `Type` which has a static `ngPipeDef`:`ɵPipeDef` field making it
  * consumable for rendering.
  */
-export interface PipeType<T> extends Type<T> { ngPipeDef: PipeDef<T>; }
+export interface PipeType<T> extends Type<T> { ngPipeDef: ɵPipeDef<T>; }
 
 /**
  * Runtime link information for Directives.
@@ -65,13 +65,18 @@ export interface PipeType<T> extends Type<T> { ngPipeDef: PipeDef<T>; }
  * can change between versions.
  *
  * See: {@link defineDirective}
+ *
+ * NOTE: This is a semi public API, and there are no guaranties that the shape of this API will
+ * remain consistent between version. Use with caution.
+ *
+ * @experimental
  */
-export interface DirectiveDef<T> {
+export interface ɵDirectiveDef<T> {
   /** Token representing the directive. Used by DI. */
   type: Type<T>;
 
   /** Function that makes a directive public to the DI system. */
-  diPublic: ((def: DirectiveDef<any>) => void)|null;
+  diPublic: ((def: ɵDirectiveDef<any>) => void)|null;
 
   /** The selectors that will be used to match nodes to this directive. */
   selectors: CssSelectorList;
@@ -135,8 +140,13 @@ export interface DirectiveDef<T> {
  * can change between versions.
  *
  * See: {@link defineComponent}
+ *
+ * NOTE: This is a semi public API, and there are no guaranties that the shape of this API will
+ * remain consistent between version. Use with caution.
+ *
+ * @experimental
  */
-export interface ComponentDef<T> extends DirectiveDef<T> {
+export interface ɵComponentDef<T> extends ɵDirectiveDef<T> {
   /**
    * The View template of the component.
    *
@@ -169,8 +179,8 @@ export interface ComponentDef<T> extends DirectiveDef<T> {
   /**
    * Registry of directives and components that may be found in this view.
    *
-   * The property is either an array of `DirectiveDef`s or a function which returns the array of
+   * The property is either an array of `ɵDirectiveDef`s or a function which returns the array of
-   * `DirectiveDef`s. The function is necessary to be able to support forward declarations.
+   * `ɵDirectiveDef`s. The function is necessary to be able to support forward declarations.
    */
   directiveDefs: DirectiveDefListOrFactory|null;
 
@@ -194,8 +204,13 @@ export interface ComponentDef<T> extends DirectiveDef<T> {
  * can change between versions.
  *
  * See: {@link definePipe}
+ *
+ * NOTE: This is a semi public API, and there are no guaranties that the shape of this API will
+ * remain consistent between version. Use with caution.
+ *
+ * @experimental
  */
-export interface PipeDef<T> {
+export interface ɵPipeDef<T> {
   /**
    * Pipe name.
    *
@@ -223,8 +238,8 @@ export interface PipeDef<T> {
   onDestroy: (() => void)|null;
 }
 
-export type DirectiveDefFeature = <T>(directiveDef: DirectiveDef<T>) => void;
+export type DirectiveDefFeature = <T>(directiveDef: ɵDirectiveDef<T>) => void;
-export type ComponentDefFeature = <T>(componentDef: ComponentDef<T>) => void;
+export type ComponentDefFeature = <T>(componentDef: ɵComponentDef<T>) => void;
 
 /**
  * Type used for directiveDefs on component definition.
@@ -233,12 +248,12 @@ export type ComponentDefFeature = <T>(componentDef: ComponentDef<T>) => void;
  */
 export type DirectiveDefListOrFactory = (() => DirectiveDefList) | DirectiveDefList;
 
-export type DirectiveDefList = (DirectiveDef<any>| ComponentDef<any>)[];
+export type DirectiveDefList = (ɵDirectiveDef<any>| ɵComponentDef<any>)[];
 
 export type DirectiveTypesOrFactory = (() => DirectiveTypeList) | DirectiveTypeList;
 
 export type DirectiveTypeList =
-    (DirectiveDef<any>| ComponentDef<any>|
+    (ɵDirectiveDef<any>| ɵComponentDef<any>|
      Type<any>/* Type as workaround for: Microsoft/TypeScript/issues/4881 */)[];
 
 /**
@@ -248,12 +263,12 @@ export type DirectiveTypeList =
  */
 export type PipeDefListOrFactory = (() => PipeDefList) | PipeDefList;
 
-export type PipeDefList = PipeDef<any>[];
+export type PipeDefList = ɵPipeDef<any>[];
 
 export type PipeTypesOrFactory = (() => DirectiveTypeList) | DirectiveTypeList;
 
 export type PipeTypeList =
-    (PipeDef<any>| Type<any>/* Type as workaround for: Microsoft/TypeScript/issues/4881 */)[];
+    (ɵPipeDef<any>| Type<any>/* Type as workaround for: Microsoft/TypeScript/issues/4881 */)[];
 
 
 // Note: This hack is necessary so we don't erroneously get a circular dependency

packages/core/src/render3/interfaces/view.ts

@@ -8,7 +8,7 @@
 
 import {Injector} from '../../di/injector';
 import {LContainer} from './container';
-import {ComponentTemplate, DirectiveDef, DirectiveDefList, PipeDef, PipeDefList} from './definition';
+import {ComponentTemplate, DirectiveDefList, PipeDefList, ɵDirectiveDef, ɵPipeDef} from './definition';
 import {LElementNode, LViewNode, TNode} from './node';
 import {LQueries} from './query';
 import {Renderer3} from './renderer';
@@ -428,10 +428,10 @@ export const enum LifecycleStage {
  * as its pipe instance in the data array. Any nodes that do not have static
  * data store a null value in tData to avoid a sparse array.
  */
-export type TData = (TNode | PipeDef<any>| null)[];
+export type TData = (TNode | ɵPipeDef<any>| null)[];
 
 /** Type for TView.currentMatches */
-export type CurrentMatchesList = [DirectiveDef<any>, (string | number | null)];
+export type CurrentMatchesList = [ɵDirectiveDef<any>, (string | number | null)];
 
 // Note: This hack is necessary so we don't erroneously get a circular dependency
 // failure based on types.

packages/core/src/render3/pipe.ts

@@ -9,9 +9,10 @@
 import {PipeTransform} from '../change_detection/pipe_transform';
 
 import {getTView, load, store} from './instructions';
-import {PipeDef, PipeDefList} from './interfaces/definition';
+import {PipeDefList, ɵPipeDef} from './interfaces/definition';
 import {pureFunction1, pureFunction2, pureFunction3, pureFunction4, pureFunctionV} from './pure_function';
 
+
 /**
  * Create a pipe.
  *
@@ -21,7 +22,7 @@ import {pureFunction1, pureFunction2, pureFunction3, pureFunction4, pureFunction
  */
 export function pipe(index: number, pipeName: string): any {
   const tView = getTView();
-  let pipeDef: PipeDef<any>;
+  let pipeDef: ɵPipeDef<any>;
 
   if (tView.firstTemplatePass) {
     pipeDef = getPipeDef(pipeName, tView.pipeRegistry);
@@ -30,7 +31,7 @@ export function pipe(index: number, pipeName: string): any {
       (tView.pipeDestroyHooks || (tView.pipeDestroyHooks = [])).push(index, pipeDef.onDestroy);
     }
   } else {
-    pipeDef = tView.data[index] as PipeDef<any>;
+    pipeDef = tView.data[index] as ɵPipeDef<any>;
   }
 
   const pipeInstance = pipeDef.n();
@@ -44,9 +45,9 @@ export function pipe(index: number, pipeName: string): any {
  *
  * @param name Name of pipe to resolve
  * @param registry Full list of available pipes
- * @returns Matching PipeDef
+ * @returns Matching ɵPipeDef
  */
-function getPipeDef(name: string, registry: PipeDefList | null): PipeDef<any> {
+function getPipeDef(name: string, registry: PipeDefList | null): ɵPipeDef<any> {
   if (registry) {
     for (let i = 0; i < registry.length; i++) {
       const pipeDef = registry[i];
@@ -140,5 +141,5 @@ export function pipeBindV(index: number, values: any[]): any {
 }
 
 function isPure(index: number): boolean {
-  return (<PipeDef<any>>getTView().data[index]).pure;
+  return (<ɵPipeDef<any>>getTView().data[index]).pure;
 }

packages/core/src/render3/query.ts

@@ -18,7 +18,7 @@ import {getSymbolIterator} from '../util';
 import {assertEqual, assertNotNull} from './assert';
 import {ReadFromInjectorFn, getOrCreateNodeInjectorForNode} from './di';
 import {assertPreviousIsParent, getCurrentQueries, store} from './instructions';
-import {DirectiveDef, unusedValueExportToPlacateAjd as unused1} from './interfaces/definition';
+import {unusedValueExportToPlacateAjd as unused1, ɵDirectiveDef} from './interfaces/definition';
 import {LInjector, unusedValueExportToPlacateAjd as unused2} from './interfaces/injector';
 import {LContainerNode, LElementNode, LNode, TNode, TNodeFlags, unusedValueExportToPlacateAjd as unused3} from './interfaces/node';
 import {LQueries, QueryReadType, unusedValueExportToPlacateAjd as unused4} from './interfaces/query';
@@ -200,7 +200,7 @@ function getIdxOfMatchingDirective(node: LNode, type: Type<any>): number|null {
   const start = flags >> TNodeFlags.DirectiveStartingIndexShift;
   const end = start + count;
   for (let i = start; i < end; i++) {
-    const def = defs[i] as DirectiveDef<any>;
+    const def = defs[i] as ɵDirectiveDef<any>;
     if (def.type === type && def.diPublic) {
       return i;
     }

packages/core/src/view/ng_module.ts

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {InjectableDef} from '../di/defs';
+import {ɵInjectableDef} from '../di/defs';
 import {resolveForwardRef} from '../di/forward_ref';
 import {INJECTOR, InjectFlags, Injector, setCurrentInjector} from '../di/injector';
 import {APP_ROOT} from '../di/scope';
@@ -102,7 +102,7 @@ export function resolveNgModuleDep(
       }
       return providerInstance === UNDEFINED_VALUE ? undefined : providerInstance;
     } else if (depDef.token.ngInjectableDef && targetsModule(data, depDef.token.ngInjectableDef)) {
-      const injectableDef = depDef.token.ngInjectableDef as InjectableDef<any>;
+      const injectableDef = depDef.token.ngInjectableDef as ɵInjectableDef<any>;
       const key = tokenKey;
       const index = data._providers.length;
       data._def.providersByKey[depDef.tokenKey] = {
@@ -126,7 +126,7 @@ function moduleTransitivelyPresent(ngModule: NgModuleData, scope: any): boolean
   return ngModule._def.modules.indexOf(scope) > -1;
 }
 
-function targetsModule(ngModule: NgModuleData, def: InjectableDef<any>): boolean {
+function targetsModule(ngModule: NgModuleData, def: ɵInjectableDef<any>): boolean {
   return def.providedIn != null && (moduleTransitivelyPresent(ngModule, def.providedIn) ||
                                     def.providedIn === 'root' && ngModule._def.isRoot);
 }

packages/core/test/bundling/injection/usage.ts

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {InjectableDef, Injector, InjectorDef, createInjector, defineInjectable, defineInjector} from '@angular/core';
+import {Injector, createInjector, defineInjectable, defineInjector, ɵInjectableDef, ɵInjectorDef} from '@angular/core';
 
 export class RootService {
   static ngInjectableDef = defineInjectable({

packages/core/test/bundling/todo/index.ts

@@ -7,7 +7,7 @@
  */
 
 import {CommonModule, NgForOf, NgIf} from '@angular/common';
-import {ChangeDetectionStrategy, Component, EventEmitter, InjectFlags, Injectable, Input, IterableDiffers, NgModule, Output, createInjector, defineInjector, inject, ɵComponentDef as ComponentDef, ɵComponentType as ComponentType, ɵDirectiveDef as DirectiveDef, ɵDirectiveType as DirectiveType, ɵNgOnChangesFeature as NgOnChangesFeature, ɵdefaultIterableDiffers as defaultIterableDiffers, ɵdefineDirective as defineDirective, ɵdirectiveInject as directiveInject, ɵinjectTemplateRef as injectTemplateRef, ɵinjectViewContainerRef as injectViewContainerRef, ɵmarkDirty as markDirty, ɵrenderComponent as renderComponent} from '@angular/core';
+import {ChangeDetectionStrategy, Component, EventEmitter, InjectFlags, Injectable, Input, IterableDiffers, NgModule, Output, createInjector, defineInjector, inject, ɵComponentDef, ɵComponentType as ComponentType, ɵDirectiveDef, ɵDirectiveType as DirectiveType, ɵNgOnChangesFeature as NgOnChangesFeature, ɵdefaultIterableDiffers as defaultIterableDiffers, ɵdefineDirective as defineDirective, ɵdirectiveInject as directiveInject, ɵinjectTemplateRef as injectTemplateRef, ɵinjectViewContainerRef as injectViewContainerRef, ɵmarkDirty as markDirty, ɵrenderComponent as renderComponent} from '@angular/core';
 
 
 export class Todo {

packages/core/test/di/r3_injector_spec.ts

@@ -11,7 +11,7 @@ import {InjectionToken} from '../../src/di/injection_token';
 import {INJECTOR, Injector, inject} from '../../src/di/injector';
 import {R3Injector, createInjector} from '../../src/di/r3_injector';
 
-describe('InjectorDef-based createInjector()', () => {
+describe('ɵInjectorDef-based createInjector()', () => {
   class CircularA {
     static ngInjectableDef = defineInjectable({
       providedIn: null,

packages/core/test/render3/compiler_canonical/back_patch_types_specs.ts

@@ -6,13 +6,13 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {Component, ContentChild, Directive, Injectable, Injector, InjectorDef, Input, NgModule, NgModuleFactory, NgModuleRef, OnDestroy, Optional, Pipe, PipeTransform, QueryList, SimpleChanges, TemplateRef, Type, ViewChild, ViewContainerRef, defineInjector} from '../../../src/core';
+import {Component, ContentChild, Directive, Injectable, Injector, Input, NgModule, NgModuleFactory, NgModuleRef, OnDestroy, Optional, Pipe, PipeTransform, QueryList, SimpleChanges, TemplateRef, Type, ViewChild, ViewContainerRef, defineInjector, ɵInjectorDef} from '../../../src/core';
 import * as r3 from '../../../src/render3/index';
 
 const details_elided = {
   type: Object,
 } as any;
-export type $ComponentDef$ = any;
+export type $ɵComponentDef$ = any;
 
 ///////////
 // Lib A - Compiled pre-Ivy
@@ -52,7 +52,7 @@ const node_modules_libA_module_metadata = {
 @Component({})
 export class LibBComponent {
   // COMPILER GENERATED
-  static ngComponentDef: $ComponentDef$ = r3.defineComponent(details_elided);
+  static ngComponentDef: $ɵComponentDef$ = r3.defineComponent(details_elided);
 }
 
 @NgModule({declarations: [LibAComponent], imports: []})
@@ -84,7 +84,7 @@ const node_modules_libB_module_metadata = {
 @Component({})
 export class AppComponent {
   // COMPILER GENERATED
-  static ngComponentDef: $ComponentDef$ = r3.defineComponent(details_elided);
+  static ngComponentDef: $ɵComponentDef$ = r3.defineComponent(details_elided);
 }
 
 @NgModule({declarations: [LibAComponent], imports: []})

packages/core/test/render3/compiler_canonical/injection_spec.ts

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {Attribute, ChangeDetectionStrategy, ChangeDetectorRef, Component, ContentChild, ContentChildren, Directive, HostBinding, HostListener, INJECTOR, Inject, InjectFlags, Injectable, InjectableDef, Injector, InjectorDef, Input, NgModule, OnDestroy, Optional, Pipe, PipeTransform, QueryList, SimpleChanges, SkipSelf, TemplateRef, ViewChild, ViewChildren, ViewContainerRef, defineInjectable, defineInjector, inject} from '../../../src/core';
+import {Attribute, ChangeDetectionStrategy, ChangeDetectorRef, Component, ContentChild, ContentChildren, Directive, HostBinding, HostListener, INJECTOR, Inject, InjectFlags, Injectable, Injector, Input, NgModule, OnDestroy, Optional, Pipe, PipeTransform, QueryList, SimpleChanges, SkipSelf, TemplateRef, ViewChild, ViewChildren, ViewContainerRef, defineInjectable, defineInjector, inject, ɵInjectableDef, ɵInjectorDef} from '../../../src/core';
 import * as $r3$ from '../../../src/core_render3_private_export';
 import {renderComponent, toHtml} from '../render_util';
 

packages/core/test/render3/compiler_canonical/patch_types_spec.ts

@@ -6,10 +6,11 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {Component, ContentChild, Directive, Injectable, InjectableDef, InjectorDef, Input, NgModule, OnDestroy, Optional, Pipe, PipeTransform, QueryList, SimpleChanges, TemplateRef, Type, ViewChild, ViewContainerRef, defineInjectable, defineInjector} from '../../../src/core';
+import {Component, ContentChild, Directive, Injectable, Input, NgModule, OnDestroy, Optional, Pipe, PipeTransform, QueryList, SimpleChanges, TemplateRef, Type, ViewChild, ViewContainerRef, defineInjectable, defineInjector, ɵInjectableDef, ɵInjectorDef} from '../../../src/core';
 import * as r3 from '../../../src/render3/index';
 
 
+
 /**
  * GOALS:
  * - Patch types in tree shakable way

packages/core/test/render3/compiler_canonical/small_app_spec.ts

@@ -7,7 +7,7 @@
  */
 
 import {NgForOf, NgForOfContext} from '@angular/common';
-import {Component, ContentChild, Directive, EventEmitter, Injectable, InjectableDef, InjectorDef, Input, NgModule, OnDestroy, Optional, Output, Pipe, PipeTransform, QueryList, SimpleChanges, TemplateRef, Type, ViewChild, ViewContainerRef, defineInjectable, defineInjector} from '@angular/core';
+import {Component, ContentChild, Directive, EventEmitter, Injectable, Input, NgModule, OnDestroy, Optional, Output, Pipe, PipeTransform, QueryList, SimpleChanges, TemplateRef, Type, ViewChild, ViewContainerRef, defineInjectable, defineInjector, ɵInjectableDef, ɵInjectorDef} from '@angular/core';
 import {withBody} from '@angular/core/testing';
 
 import * as r3 from '../../../src/render3/index';

packages/core/test/render3/render_util.ts

@@ -11,9 +11,9 @@ import {stringifyElement} from '@angular/platform-browser/testing/src/browser_ut
 import {Injector} from '../../src/di/injector';
 import {CreateComponentOptions} from '../../src/render3/component';
 import {extractDirectiveDef, extractPipeDef} from '../../src/render3/definition';
-import {ComponentDef, ComponentTemplate, ComponentType, DirectiveDef, DirectiveType, PublicFeature, RenderFlags, defineComponent, defineDirective, renderComponent as _renderComponent, tick} from '../../src/render3/index';
+import {ComponentTemplate, ComponentType, DirectiveType, PublicFeature, RenderFlags, defineComponent, defineDirective, renderComponent as _renderComponent, tick, ɵComponentDef, ɵDirectiveDef} from '../../src/render3/index';
 import {NG_HOST_SYMBOL, renderTemplate} from '../../src/render3/instructions';
-import {DirectiveDefList, DirectiveDefListOrFactory, DirectiveTypesOrFactory, PipeDef, PipeDefList, PipeDefListOrFactory, PipeTypesOrFactory} from '../../src/render3/interfaces/definition';
+import {DirectiveDefList, DirectiveDefListOrFactory, DirectiveTypesOrFactory, PipeDefList, PipeDefListOrFactory, PipeTypesOrFactory, ɵPipeDef} from '../../src/render3/interfaces/definition';
 import {LElementNode} from '../../src/render3/interfaces/node';
 import {RElement, RText, Renderer3, RendererFactory3, domRendererFactory3} from '../../src/render3/interfaces/renderer';
 import {Type} from '../../src/type';
@@ -171,13 +171,13 @@ export function renderToHtml(
 
 function toDefs(
     types: DirectiveTypesOrFactory | undefined | null,
-    mapFn: (type: Type<any>) => DirectiveDef<any>): DirectiveDefList|null;
+    mapFn: (type: Type<any>) => ɵDirectiveDef<any>): DirectiveDefList|null;
 function toDefs(
     types: PipeTypesOrFactory | undefined | null,
-    mapFn: (type: Type<any>) => PipeDef<any>): PipeDefList|null;
+    mapFn: (type: Type<any>) => ɵPipeDef<any>): PipeDefList|null;
 function toDefs(
     types: PipeTypesOrFactory | DirectiveTypesOrFactory | undefined | null,
-    mapFn: (type: Type<any>) => PipeDef<any>| DirectiveDef<any>): any {
+    mapFn: (type: Type<any>) => ɵPipeDef<any>| ɵDirectiveDef<any>): any {
   if (!types) return null;
   if (typeof types == 'function') {
     types = types();

packages/core/test/view/ng_module_spec.ts

@@ -7,7 +7,7 @@
  */
 
 import {NgModuleRef} from '@angular/core';
-import {InjectableDef, defineInjectable} from '@angular/core/src/di/defs';
+import {defineInjectable, ɵInjectableDef} from '@angular/core/src/di/defs';
 import {INJECTOR, InjectFlags, Injector, inject} from '@angular/core/src/di/injector';
 import {makePropDecorator} from '@angular/core/src/util/decorators';
 import {NgModuleDefinition, NgModuleProviderDef, NodeFlags} from '@angular/core/src/view';
@@ -24,14 +24,14 @@ class MyChildModule {}
 class NotMyModule {}
 
 class Bar {
-  static ngInjectableDef: InjectableDef<Bar> = defineInjectable({
+  static ngInjectableDef: ɵInjectableDef<Bar> = defineInjectable({
     factory: () => new Bar(),
     providedIn: MyModule,
   });
 }
 
 class Baz {
-  static ngInjectableDef: InjectableDef<Baz> = defineInjectable({
+  static ngInjectableDef: ɵInjectableDef<Baz> = defineInjectable({
     factory: () => new Baz(),
     providedIn: NotMyModule,
   });
@@ -40,7 +40,7 @@ class Baz {
 class HasNormalDep {
   constructor(public foo: Foo) {}
 
-  static ngInjectableDef: InjectableDef<HasNormalDep> = defineInjectable({
+  static ngInjectableDef: ɵInjectableDef<HasNormalDep> = defineInjectable({
     factory: () => new HasNormalDep(inject(Foo)),
     providedIn: MyModule,
   });
@@ -49,7 +49,7 @@ class HasNormalDep {
 class HasDefinedDep {
   constructor(public bar: Bar) {}
 
-  static ngInjectableDef: InjectableDef<HasDefinedDep> = defineInjectable({
+  static ngInjectableDef: ɵInjectableDef<HasDefinedDep> = defineInjectable({
     factory: () => new HasDefinedDep(inject(Bar)),
     providedIn: MyModule,
   });
@@ -58,14 +58,14 @@ class HasDefinedDep {
 class HasOptionalDep {
   constructor(public baz: Baz|null) {}
 
-  static ngInjectableDef: InjectableDef<HasOptionalDep> = defineInjectable({
+  static ngInjectableDef: ɵInjectableDef<HasOptionalDep> = defineInjectable({
     factory: () => new HasOptionalDep(inject(Baz, InjectFlags.Optional)),
     providedIn: MyModule,
   });
 }
 
 class ChildDep {
-  static ngInjectableDef: InjectableDef<ChildDep> = defineInjectable({
+  static ngInjectableDef: ɵInjectableDef<ChildDep> = defineInjectable({
     factory: () => new ChildDep(),
     providedIn: MyChildModule,
   });
@@ -73,7 +73,7 @@ class ChildDep {
 
 class FromChildWithOptionalDep {
   constructor(public baz: Baz|null) {}
-  static ngInjectableDef: InjectableDef<FromChildWithOptionalDep> = defineInjectable({
+  static ngInjectableDef: ɵInjectableDef<FromChildWithOptionalDep> = defineInjectable({
     factory: () => new FromChildWithOptionalDep(inject(Baz, InjectFlags.Default)),
     providedIn: MyChildModule,
   });
@@ -81,7 +81,7 @@ class FromChildWithOptionalDep {
 
 class FromChildWithSkipSelfDep {
   constructor(public depFromParent: ChildDep|null, public depFromChild: Bar|null) {}
-  static ngInjectableDef: InjectableDef<FromChildWithSkipSelfDep> = defineInjectable({
+  static ngInjectableDef: ɵInjectableDef<FromChildWithSkipSelfDep> = defineInjectable({
     factory: () => new FromChildWithSkipSelfDep(
                  inject(ChildDep, InjectFlags.SkipSelf|InjectFlags.Optional),
                  inject(Bar, InjectFlags.Self|InjectFlags.Optional)),
@@ -119,10 +119,10 @@ describe('NgModuleRef_ injector', () => {
   it('injects a provided value',
      () => { expect(ref.injector.get(Foo) instanceof Foo).toBeTruthy(); });
 
-  it('injects an InjectableDef value',
+  it('injects an ɵInjectableDef value',
      () => { expect(ref.injector.get(Bar) instanceof Bar).toBeTruthy(); });
 
-  it('caches InjectableDef values',
+  it('caches ɵInjectableDef values',
      () => { expect(ref.injector.get(Bar)).toBe(ref.injector.get(Bar)); });
 
   it('injects provided deps properly', () => {

tools/public_api_guard/core/core.d.ts

@@ -244,14 +244,14 @@ export declare class DefaultIterableDiffer<V> implements IterableDiffer<V>, Iter
 export declare function defineInjectable<T>(opts: {
     providedIn?: Type<any> | 'root' | 'any' | null;
     factory: () => T;
-}): InjectableDef<T>;
+}): ɵInjectableDef<T>;
 
 /** @experimental */
 export declare function defineInjector(options: {
     factory: () => any;
     providers?: any[];
     imports?: any[];
-}): InjectorDef<any>;
+}): ɵInjectorDef<any>;
 
 /** @experimental */
 export declare function destroyPlatform(): void;
@@ -354,19 +354,12 @@ export interface InjectableDecorator {
     } & InjectableProvider): Injectable;
 }
 
-/** @experimental */
-export interface InjectableDef<T> {
-    factory: () => T;
-    providedIn: InjectorType<any> | 'root' | 'any' | null;
-    value: T | undefined;
-}
-
 /** @experimental */
 export declare type InjectableProvider = ValueSansProvider | ExistingSansProvider | StaticClassSansProvider | ConstructorSansProvider | FactorySansProvider | ClassSansProvider;
 
 /** @experimental */
 export interface InjectableType<T> extends Type<T> {
-    ngInjectableDef: InjectableDef<T>;
+    ngInjectableDef: ɵInjectableDef<T>;
 }
 
 export interface InjectDecorator {
@@ -384,7 +377,7 @@ export declare const enum InjectFlags {
 
 export declare class InjectionToken<T> {
     protected _desc: string;
-    readonly ngInjectableDef: InjectableDef<T> | undefined;
+    readonly ngInjectableDef: ɵInjectableDef<T> | undefined;
     constructor(_desc: string, options?: {
         providedIn?: Type<any> | 'root' | null;
         factory: () => T;
@@ -397,7 +390,7 @@ export declare abstract class Injector {
     /** @deprecated */ abstract get(token: any, notFoundValue?: any): any;
     static NULL: Injector;
     static THROW_IF_NOT_FOUND: Object;
-    static ngInjectableDef: InjectableDef<Injector>;
+    static ngInjectableDef: ɵInjectableDef<Injector>;
     /** @deprecated */ static create(providers: StaticProvider[], parent?: Injector): Injector;
     static create(options: {
         providers: StaticProvider[];
@@ -409,16 +402,9 @@ export declare abstract class Injector {
 /** @experimental */
 export declare const INJECTOR: InjectionToken<Injector>;
 
-/** @experimental */
-export interface InjectorDef<T> {
-    factory: () => T;
-    imports: (InjectorType<any> | InjectorTypeWithProviders<any>)[];
-    providers: (Type<any> | ValueProvider | ExistingProvider | FactoryProvider | ConstructorProvider | StaticClassProvider | ClassProvider | any[])[];
-}
-
 /** @experimental */
 export interface InjectorType<T> extends Type<T> {
-    ngInjectorDef: InjectorDef<T>;
+    ngInjectorDef: ɵInjectorDef<T>;
 }
 
 /** @experimental */
@@ -462,7 +448,7 @@ export declare class IterableDiffers {
     /** @deprecated */ factories: IterableDifferFactory[];
     constructor(factories: IterableDifferFactory[]);
     find(iterable: any): IterableDifferFactory;
-    static ngInjectableDef: InjectableDef<IterableDiffers>;
+    static ngInjectableDef: ɵInjectableDef<IterableDiffers>;
     static create(factories: IterableDifferFactory[], parent?: IterableDiffers): IterableDiffers;
     static extend(factories: IterableDifferFactory[]): StaticProvider;
 }