@angular/core
Version:
Angular - the core framework
368 lines • 31.4 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @license
* Copyright Google Inc. All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
/** @enum {number} */
const RenderFlags = {
/* Whether to run the creation block (e.g. create elements and directives) */
Create: 1,
/* Whether to run the update block (e.g. refresh bindings) */
Update: 2,
};
export { RenderFlags };
/**
* A subclass of `Type` which has a static `ngComponentDef`:`ComponentDef` field making it
* consumable for rendering.
* @record
* @template T
*/
export function ComponentType() { }
if (false) {
/** @type {?} */
ComponentType.prototype.ngComponentDef;
}
/**
* A subclass of `Type` which has a static `ngDirectiveDef`:`DirectiveDef` field making it
* consumable for rendering.
* @record
* @template T
*/
export function DirectiveType() { }
if (false) {
/** @type {?} */
DirectiveType.prototype.ngDirectiveDef;
}
/** @enum {number} */
const DirectiveDefFlags = {
ContentQuery: 2,
};
export { DirectiveDefFlags };
/**
* A subclass of `Type` which has a static `ngPipeDef`:`PipeDef` field making it
* consumable for rendering.
* @record
* @template T
*/
export function PipeType() { }
if (false) {
/** @type {?} */
PipeType.prototype.ngPipeDef;
}
/**
* Runtime information for classes that are inherited by components or directives
* that aren't defined as components or directives.
*
* This is an internal data structure used by the renderer to determine what inputs
* and outputs should be inherited.
*
* See: {\@link defineBase}
*
* \@codeGenApi
* @record
* @template T
*/
export function ɵɵBaseDef() { }
if (false) {
/**
* A dictionary mapping the inputs' minified property names to their public API names, which
* are their aliases if any, or their original unminified property names
* (as in `\@Input('alias') propertyName: any;`).
* @type {?}
*/
ɵɵBaseDef.prototype.inputs;
/**
* @deprecated This is only here because `NgOnChanges` incorrectly uses declared name instead of
* public or minified name.
* @type {?}
*/
ɵɵBaseDef.prototype.declaredInputs;
/**
* A dictionary mapping the outputs' minified property names to their public API names, which
* are their aliases if any, or their original unminified property names
* (as in `\@Output('alias') propertyName: any;`).
* @type {?}
*/
ɵɵBaseDef.prototype.outputs;
/**
* Function to create and refresh content queries associated with a given directive.
* @type {?}
*/
ɵɵBaseDef.prototype.contentQueries;
/**
* Query-related instructions for a directive. Note that while directives don't have a
* view and as such view queries won't necessarily do anything, there might be
* components that extend the directive.
* @type {?}
*/
ɵɵBaseDef.prototype.viewQuery;
/**
* Refreshes host bindings on the associated directive.
* @type {?}
*/
ɵɵBaseDef.prototype.hostBindings;
}
/**
* Runtime link information for Directives.
*
* This is internal data structure used by the render to link
* directives into templates.
*
* NOTE: Always use `defineDirective` function to create this object,
* never create the object directly since the shape of this object
* can change between versions.
*
* @param Selector type metadata specifying the selector of the directive or component
*
* See: {\@link defineDirective}
* @record
* @template T
*/
export function DirectiveDef() { }
if (false) {
/**
* Token representing the directive. Used by DI.
* @type {?}
*/
DirectiveDef.prototype.type;
/**
* Function that resolves providers and publishes them into the DI system.
* @type {?}
*/
DirectiveDef.prototype.providersResolver;
/**
* The selectors that will be used to match nodes to this directive.
* @type {?}
*/
DirectiveDef.prototype.selectors;
/**
* Name under which the directive is exported (for use with local references in template)
* @type {?}
*/
DirectiveDef.prototype.exportAs;
/**
* Factory function used to create a new directive instance.
* @type {?}
*/
DirectiveDef.prototype.factory;
/** @type {?} */
DirectiveDef.prototype.onChanges;
/** @type {?} */
DirectiveDef.prototype.onInit;
/** @type {?} */
DirectiveDef.prototype.doCheck;
/** @type {?} */
DirectiveDef.prototype.afterContentInit;
/** @type {?} */
DirectiveDef.prototype.afterContentChecked;
/** @type {?} */
DirectiveDef.prototype.afterViewInit;
/** @type {?} */
DirectiveDef.prototype.afterViewChecked;
/** @type {?} */
DirectiveDef.prototype.onDestroy;
/**
* The features applied to this directive
* @type {?}
*/
DirectiveDef.prototype.features;
/** @type {?} */
DirectiveDef.prototype.setInput;
}
/**
* Runtime link information for Components.
*
* This is internal data structure used by the render to link
* components into templates.
*
* NOTE: Always use `defineComponent` function to create this object,
* never create the object directly since the shape of this object
* can change between versions.
*
* See: {\@link defineComponent}
* @record
* @template T
*/
export function ComponentDef() { }
if (false) {
/**
* Runtime unique component ID.
* @type {?}
*/
ComponentDef.prototype.id;
/**
* The View template of the component.
* @type {?}
*/
ComponentDef.prototype.template;
/**
* An array of `ngContent[selector]` values that were found in the template.
* @type {?|undefined}
*/
ComponentDef.prototype.ngContentSelectors;
/**
* A set of styles that the component needs to be present for component to render correctly.
* @type {?}
*/
ComponentDef.prototype.styles;
/**
* The number of nodes, local refs, and pipes in this component template.
*
* Used to calculate the length of the component's LView array, so we
* can pre-fill the array and set the binding start index.
* @type {?}
*/
ComponentDef.prototype.consts;
/**
* The number of bindings in this component template (including pure fn bindings).
*
* Used to calculate the length of the component's LView array, so we
* can pre-fill the array and set the host binding start index.
* @type {?}
*/
ComponentDef.prototype.vars;
/**
* Query-related instructions for a component.
* @type {?}
*/
ComponentDef.prototype.viewQuery;
/**
* The view encapsulation type, which determines how styles are applied to
* DOM elements. One of
* - `Emulated` (default): Emulate native scoping of styles.
* - `Native`: Use the native encapsulation mechanism of the renderer.
* - `ShadowDom`: Use modern [ShadowDOM](https://w3c.github.io/webcomponents/spec/shadow/) and
* create a ShadowRoot for component's host element.
* - `None`: Do not provide any template or style encapsulation.
* @type {?}
*/
ComponentDef.prototype.encapsulation;
/**
* Defines arbitrary developer-defined data to be stored on a renderer instance.
* This is useful for renderers that delegate to other renderers.
* @type {?}
*/
ComponentDef.prototype.data;
/**
* Whether or not this component's ChangeDetectionStrategy is OnPush
* @type {?}
*/
ComponentDef.prototype.onPush;
/**
* 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
* `DirectiveDef`s. The function is necessary to be able to support forward declarations.
* @type {?}
*/
ComponentDef.prototype.directiveDefs;
/**
* Registry of pipes that may be found in this view.
*
* The property is either an array of `PipeDefs`s or a function which returns the array of
* `PipeDefs`s. The function is necessary to be able to support forward declarations.
* @type {?}
*/
ComponentDef.prototype.pipeDefs;
/**
* The set of schemas that declare elements to be allowed in the component's template.
* @type {?}
*/
ComponentDef.prototype.schemas;
/**
* Ivy runtime uses this place to store the computed tView for the component. This gets filled on
* the first run of component.
* @type {?}
*/
ComponentDef.prototype.tView;
/**
* Used to store the result of `noSideEffects` function so that it is not removed by closure
* compiler. The property should never be read.
* @type {?|undefined}
*/
ComponentDef.prototype._;
}
/**
* Runtime link information for Pipes.
*
* This is internal data structure used by the renderer to link
* pipes into templates.
*
* NOTE: Always use `definePipe` function to create this object,
* never create the object directly since the shape of this object
* can change between versions.
*
* See: {\@link definePipe}
* @record
* @template T
*/
export function PipeDef() { }
if (false) {
/**
* Pipe name.
*
* Used to resolve pipe in templates.
* @type {?}
*/
PipeDef.prototype.name;
/**
* Factory function used to create a new pipe instance.
* @type {?}
*/
PipeDef.prototype.factory;
/**
* Whether or not the pipe is pure.
*
* Pure pipes result only depends on the pipe input and not on internal
* state of the pipe.
* @type {?}
*/
PipeDef.prototype.pure;
/** @type {?} */
PipeDef.prototype.onDestroy;
}
/**
* @record
*/
export function DirectiveDefFeature() { }
if (false) {
/**
* Marks a feature as something that {\@link InheritDefinitionFeature} will execute
* during inheritance.
*
* NOTE: DO NOT SET IN ROOT OF MODULE! Doing so will result in tree-shakers/bundlers
* identifying the change as a side effect, and the feature will be included in
* every bundle.
* @type {?|undefined}
*/
DirectiveDefFeature.prototype.ngInherit;
/* Skipping unhandled member: <T>(directiveDef: DirectiveDef<T>): void;*/
}
/**
* @record
*/
export function ComponentDefFeature() { }
if (false) {
/**
* Marks a feature as something that {\@link InheritDefinitionFeature} will execute
* during inheritance.
*
* NOTE: DO NOT SET IN ROOT OF MODULE! Doing so will result in tree-shakers/bundlers
* identifying the change as a side effect, and the feature will be included in
* every bundle.
* @type {?|undefined}
*/
ComponentDefFeature.prototype.ngInherit;
/* Skipping unhandled member: <T>(componentDef: ComponentDef<T>): void;*/
}
// Note: This hack is necessary so we don't erroneously get a circular dependency
// failure based on types.
/** @type {?} */
export const unusedValueExportToPlacateAjd = 1;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"definition.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/interfaces/definition.ts"],"names":[],"mappings":";;;;;;;;;;;;;IA6DE,6EAA6E;IAC7E,SAAa;IAEb,6DAA6D;IAC7D,SAAa;;;;;;;;;AAOf,mCAA4E;;;IAAxB,uCAAsB;;;;;;;;AAM1E,mCAA4E;;;IAAxB,uCAAsB;;;;IAErC,eAAmB;;;;;;;;;AAMxD,8BAAkE;;;IAAnB,6BAAiB;;;;;;;;;;;;;;;AAoBhE,+BAqCC;;;;;;;;IA/BC,2BAA0C;;;;;;IAM1C,mCAAkD;;;;;;;IAOlD,4BAA2C;;;;;IAK3C,mCAA+C;;;;;;;IAO/C,8BAAuC;;;;;IAKvC,iCAA2C;;;;;;;;;;;;;;;;;;AAiB7C,kCAyCC;;;;;;IAvCC,4BAAc;;;;;IAGd,yCAEoB;;;;;IAGpB,iCAAoC;;;;;IAKpC,gCAAiC;;;;;IAKjC,+BAAsB;;IAGtB,iCAA6B;;IAC7B,8BAA0B;;IAC1B,+BAA2B;;IAC3B,wCAAoC;;IACpC,2CAAuC;;IACvC,qCAAiC;;IACjC,wCAAoC;;IACpC,iCAA6B;;;;;IAK7B,gCAA8C;;IAE9C,gCAG4C;;;;;;;;;;;;;;;;AAsB9C,kCA+FC;;;;;;IA3FC,0BAAoB;;;;;IAKpB,gCAAwC;;;;;IAKxC,0CAAuC;;;;;IAKvC,8BAA0B;;;;;;;;IAS1B,8BAAwB;;;;;;;;IAQxB,4BAAsB;;;;;IAKtB,iCAAuC;;;;;;;;;;;IAWvC,qCAA0C;;;;;;IAM1C,4BAAqC;;;;;IAGrC,8BAAyB;;;;;;;;IAQzB,qCAA8C;;;;;;;;IAQ9C,gCAAoC;;;;;IAKpC,+BAA+B;;;;;;IAM/B,6BAAkB;;;;;;IAMlB,yBAAmB;;;;;;;;;;;;;;;;AAerB,6BAuBC;;;;;;;;IAjBC,uBAAsB;;;;;IAKtB,0BAAsB;;;;;;;;IAQtB,uBAAuB;;IAGvB,4BAA6B;;;;;AAQ/B,yCAWC;;;;;;;;;;;IADC,wCAAiB;;;;;;AAGnB,yCAWC;;;;;;;;;;;IADC,wCAAiB;;;;;;AAuCnB,MAAM,OAAO,6BAA6B,GAAG,CAAC","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {SchemaMetadata, ViewEncapsulation} from '../../core';\nimport {ProcessProvidersFunction} from '../../di/interface/provider';\nimport {Type} from '../../interface/type';\nimport {CssSelectorList} from './projection';\nimport {TView} from './view';\n\n\n/**\n * Definition of what a template rendering function should look like for a component.\n */\nexport type ComponentTemplate<T> = {\n  // Note: the ctx parameter is typed as T|U, as using only U would prevent a template with\n  // e.g. ctx: {} from being assigned to ComponentTemplate<any> as TypeScript won't infer U = any\n  // in that scenario. By including T this incompatibility is resolved.\n  <U extends T>(rf: RenderFlags, ctx: T | U): void;\n};\n\n/**\n * Definition of what a view queries function should look like.\n */\nexport type ViewQueriesFunction<T> = <U extends T>(rf: RenderFlags, ctx: U) => void;\n\n/**\n * Definition of what a content queries function should look like.\n */\nexport type ContentQueriesFunction<T> =\n    <U extends T>(rf: RenderFlags, ctx: U, directiveIndex: number) => void;\n\n/**\n * Definition of what a factory function should look like.\n */\nexport type FactoryFn<T> = {\n  /**\n   * Subclasses without an explicit constructor call through to the factory of their base\n   * definition, providing it with their own constructor to instantiate.\n   */\n  <U extends T>(t: Type<U>): U;\n\n  /**\n   * If no constructor to instantiate is provided, an instance of type T itself is created.\n   */\n  (t?: undefined): T;\n};\n\n/**\n * Flags passed into template functions to determine which blocks (i.e. creation, update)\n * should be executed.\n *\n * Typically, a template runs both the creation block and the update block on initialization and\n * subsequent runs only execute the update block. However, dynamically created views require that\n * the creation block be executed separately from the update block (for backwards compat).\n */\nexport const enum RenderFlags {\n  /* Whether to run the creation block (e.g. create elements and directives) */\n  Create = 0b01,\n\n  /* Whether to run the update block (e.g. refresh bindings) */\n  Update = 0b10\n}\n\n/**\n * A subclass of `Type` which has a static `ngComponentDef`:`ComponentDef` field making it\n * consumable for rendering.\n */\nexport interface ComponentType<T> extends Type<T> { ngComponentDef: never; }\n\n/**\n * A subclass of `Type` which has a static `ngDirectiveDef`:`DirectiveDef` field making it\n * consumable for rendering.\n */\nexport interface DirectiveType<T> extends Type<T> { ngDirectiveDef: never; }\n\nexport const enum DirectiveDefFlags {ContentQuery = 0b10}\n\n/**\n * A subclass of `Type` which has a static `ngPipeDef`:`PipeDef` field making it\n * consumable for rendering.\n */\nexport interface PipeType<T> extends Type<T> { ngPipeDef: never; }\n\n/**\n * @codeGenApi\n */\nexport type ɵɵDirectiveDefWithMeta<\n    T, Selector extends string, ExportAs extends string[], InputMap extends{[key: string]: string},\n    OutputMap extends{[key: string]: string}, QueryFields extends string[]> = DirectiveDef<T>;\n\n/**\n * Runtime information for classes that are inherited by components or directives\n * that aren't defined as components or directives.\n *\n * This is an internal data structure used by the renderer to determine what inputs\n * and outputs should be inherited.\n *\n * See: {@link defineBase}\n *\n * @codeGenApi\n */\nexport interface ɵɵBaseDef<T> {\n  /**\n   * A dictionary mapping the inputs' minified property names to their public API names, which\n   * are their aliases if any, or their original unminified property names\n   * (as in `@Input('alias') propertyName: any;`).\n   */\n  readonly inputs: {[P in keyof T]: string};\n\n  /**\n   * @deprecated This is only here because `NgOnChanges` incorrectly uses declared name instead of\n   * public or minified name.\n   */\n  readonly declaredInputs: {[P in keyof T]: string};\n\n  /**\n   * A dictionary mapping the outputs' minified property names to their public API names, which\n   * are their aliases if any, or their original unminified property names\n   * (as in `@Output('alias') propertyName: any;`).\n   */\n  readonly outputs: {[P in keyof T]: string};\n\n  /**\n   * Function to create and refresh content queries associated with a given directive.\n   */\n  contentQueries: ContentQueriesFunction<T>|null;\n\n  /**\n   * Query-related instructions for a directive. Note that while directives don't have a\n   * view and as such view queries won't necessarily do anything, there might be\n   * components that extend the directive.\n   */\n  viewQuery: ViewQueriesFunction<T>|null;\n\n  /**\n   * Refreshes host bindings on the associated directive.\n   */\n  hostBindings: HostBindingsFunction<T>|null;\n}\n\n/**\n * Runtime link information for Directives.\n *\n * This is internal data structure used by the render to link\n * directives into templates.\n *\n * NOTE: Always use `defineDirective` function to create this object,\n * never create the object directly since the shape of this object\n * can change between versions.\n *\n * @param Selector type metadata specifying the selector of the directive or component\n *\n * See: {@link defineDirective}\n */\nexport interface DirectiveDef<T> extends ɵɵBaseDef<T> {\n  /** Token representing the directive. Used by DI. */\n  type: Type<T>;\n\n  /** Function that resolves providers and publishes them into the DI system. */\n  providersResolver:\n      (<U extends T>(def: DirectiveDef<U>, processProvidersFn?: ProcessProvidersFunction) =>\n           void)|null;\n\n  /** The selectors that will be used to match nodes to this directive. */\n  readonly selectors: CssSelectorList;\n\n  /**\n   * Name under which the directive is exported (for use with local references in template)\n   */\n  readonly exportAs: string[]|null;\n\n  /**\n   * Factory function used to create a new directive instance.\n   */\n  factory: FactoryFn<T>;\n\n  /* The following are lifecycle hooks for this component */\n  onChanges: (() => void)|null;\n  onInit: (() => void)|null;\n  doCheck: (() => void)|null;\n  afterContentInit: (() => void)|null;\n  afterContentChecked: (() => void)|null;\n  afterViewInit: (() => void)|null;\n  afterViewChecked: (() => void)|null;\n  onDestroy: (() => void)|null;\n\n  /**\n   * The features applied to this directive\n   */\n  readonly features: DirectiveDefFeature[]|null;\n\n  setInput:\n      (<U extends T>(\n           this: DirectiveDef<U>, instance: U, value: any, publicName: string,\n           privateName: string) => void)|null;\n}\n\n/**\n * @codeGenApi\n */\nexport type ɵɵComponentDefWithMeta<\n    T, Selector extends String, ExportAs extends string[], InputMap extends{[key: string]: string},\n    OutputMap extends{[key: string]: string}, QueryFields extends string[]> = ComponentDef<T>;\n\n/**\n * Runtime link information for Components.\n *\n * This is internal data structure used by the render to link\n * components into templates.\n *\n * NOTE: Always use `defineComponent` function to create this object,\n * never create the object directly since the shape of this object\n * can change between versions.\n *\n * See: {@link defineComponent}\n */\nexport interface ComponentDef<T> extends DirectiveDef<T> {\n  /**\n   * Runtime unique component ID.\n   */\n  readonly id: string;\n\n  /**\n   * The View template of the component.\n   */\n  readonly template: ComponentTemplate<T>;\n\n  /**\n   * An array of `ngContent[selector]` values that were found in the template.\n   */\n  readonly ngContentSelectors?: string[];\n\n  /**\n   * A set of styles that the component needs to be present for component to render correctly.\n   */\n  readonly styles: string[];\n\n  /**\n   * The number of nodes, local refs, and pipes in this component template.\n   *\n   * Used to calculate the length of the component's LView array, so we\n   * can pre-fill the array and set the binding start index.\n   */\n  // TODO(kara): remove queries from this count\n  readonly consts: number;\n\n  /**\n   * The number of bindings in this component template (including pure fn bindings).\n   *\n   * Used to calculate the length of the component's LView array, so we\n   * can pre-fill the array and set the host binding start index.\n   */\n  readonly vars: number;\n\n  /**\n   * Query-related instructions for a component.\n   */\n  viewQuery: ViewQueriesFunction<T>|null;\n\n  /**\n   * The view encapsulation type, which determines how styles are applied to\n   * DOM elements. One of\n   * - `Emulated` (default): Emulate native scoping of styles.\n   * - `Native`: Use the native encapsulation mechanism of the renderer.\n   * - `ShadowDom`: Use modern [ShadowDOM](https://w3c.github.io/webcomponents/spec/shadow/) and\n   *   create a ShadowRoot for component's host element.\n   * - `None`: Do not provide any template or style encapsulation.\n   */\n  readonly encapsulation: ViewEncapsulation;\n\n  /**\n   * Defines arbitrary developer-defined data to be stored on a renderer instance.\n   * This is useful for renderers that delegate to other renderers.\n   */\n  readonly data: {[kind: string]: any};\n\n  /** Whether or not this component's ChangeDetectionStrategy is OnPush */\n  readonly onPush: boolean;\n\n  /**\n   * Registry of directives and components that may be found in this view.\n   *\n   * The property is either an array of `DirectiveDef`s or a function which returns the array of\n   * `DirectiveDef`s. The function is necessary to be able to support forward declarations.\n   */\n  directiveDefs: DirectiveDefListOrFactory|null;\n\n  /**\n   * Registry of pipes that may be found in this view.\n   *\n   * The property is either an array of `PipeDefs`s or a function which returns the array of\n   * `PipeDefs`s. The function is necessary to be able to support forward declarations.\n   */\n  pipeDefs: PipeDefListOrFactory|null;\n\n  /**\n   * The set of schemas that declare elements to be allowed in the component's template.\n   */\n  schemas: SchemaMetadata[]|null;\n\n  /**\n   * Ivy runtime uses this place to store the computed tView for the component. This gets filled on\n   * the first run of component.\n   */\n  tView: TView|null;\n\n  /**\n   * Used to store the result of `noSideEffects` function so that it is not removed by closure\n   * compiler. The property should never be read.\n   */\n  readonly _?: never;\n}\n\n/**\n * Runtime link information for Pipes.\n *\n * This is internal data structure used by the renderer to link\n * pipes into templates.\n *\n * NOTE: Always use `definePipe` function to create this object,\n * never create the object directly since the shape of this object\n * can change between versions.\n *\n * See: {@link definePipe}\n */\nexport interface PipeDef<T> {\n  /**\n   * Pipe name.\n   *\n   * Used to resolve pipe in templates.\n   */\n  readonly name: string;\n\n  /**\n   * Factory function used to create a new pipe instance.\n   */\n  factory: FactoryFn<T>;\n\n  /**\n   * Whether or not the pipe is pure.\n   *\n   * Pure pipes result only depends on the pipe input and not on internal\n   * state of the pipe.\n   */\n  readonly pure: boolean;\n\n  /* The following are lifecycle hooks for this pipe */\n  onDestroy: (() => void)|null;\n}\n\n/**\n * @codeGenApi\n */\nexport type ɵɵPipeDefWithMeta<T, Name extends string> = PipeDef<T>;\n\nexport interface DirectiveDefFeature {\n  <T>(directiveDef: DirectiveDef<T>): void;\n  /**\n   * Marks a feature as something that {@link InheritDefinitionFeature} will execute\n   * during inheritance.\n   *\n   * NOTE: DO NOT SET IN ROOT OF MODULE! Doing so will result in tree-shakers/bundlers\n   * identifying the change as a side effect, and the feature will be included in\n   * every bundle.\n   */\n  ngInherit?: true;\n}\n\nexport interface ComponentDefFeature {\n  <T>(componentDef: ComponentDef<T>): void;\n  /**\n   * Marks a feature as something that {@link InheritDefinitionFeature} will execute\n   * during inheritance.\n   *\n   * NOTE: DO NOT SET IN ROOT OF MODULE! Doing so will result in tree-shakers/bundlers\n   * identifying the change as a side effect, and the feature will be included in\n   * every bundle.\n   */\n  ngInherit?: true;\n}\n\n\n/**\n * Type used for directiveDefs on component definition.\n *\n * The function is necessary to be able to support forward declarations.\n */\nexport type DirectiveDefListOrFactory = (() => DirectiveDefList) | DirectiveDefList;\n\nexport type DirectiveDefList = (DirectiveDef<any>| ComponentDef<any>)[];\n\nexport type DirectiveTypesOrFactory = (() => DirectiveTypeList) | DirectiveTypeList;\n\nexport type DirectiveTypeList =\n    (DirectiveDef<any>| ComponentDef<any>|\n     Type<any>/* Type as workaround for: Microsoft/TypeScript/issues/4881 */)[];\n\nexport type HostBindingsFunction<T> =\n    <U extends T>(rf: RenderFlags, ctx: U, elementIndex: number) => void;\n\n/**\n * Type used for PipeDefs on component definition.\n *\n * The function is necessary to be able to support forward declarations.\n */\nexport type PipeDefListOrFactory = (() => PipeDefList) | PipeDefList;\n\nexport type PipeDefList = PipeDef<any>[];\n\nexport type PipeTypesOrFactory = (() => DirectiveTypeList) | DirectiveTypeList;\n\nexport type PipeTypeList =\n    (PipeDef<any>| Type<any>/* Type as workaround for: Microsoft/TypeScript/issues/4881 */)[];\n\n\n// Note: This hack is necessary so we don't erroneously get a circular dependency\n// failure based on types.\nexport const unusedValueExportToPlacateAjd = 1;\n"]}