@angular/core 15.2.1 → 15.2.3

package/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @license Angular v15.2.1
+ * @license Angular v15.2.3
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -1235,6 +1235,101 @@ declare interface ComponentDefFeature {
     ngInherit?: true;
 }
 
+declare interface ComponentDefinition<T> extends Omit<DirectiveDefinition<T>, 'features'> {
+    /**
+     * The number of nodes, local refs, and pipes in this component template.
+     *
+     * Used to calculate the length of this component's LView array, so we
+     * can pre-fill the array and set the binding start index.
+     */
+    decls: number;
+    /**
+     * The number of bindings in this component template (including pure fn bindings).
+     *
+     * Used to calculate the length of this component's LView array, so we
+     * can pre-fill the array and set the host binding start index.
+     */
+    vars: number;
+    /**
+     * Template function use for rendering DOM.
+     *
+     * This function has following structure.
+     *
+     * ```
+     * function Template<T>(ctx:T, creationMode: boolean) {
+     *   if (creationMode) {
+     *     // Contains creation mode instructions.
+     *   }
+     *   // Contains binding update instructions
+     * }
+     * ```
+     *
+     * Common instructions are:
+     * Creation mode instructions:
+     *  - `elementStart`, `elementEnd`
+     *  - `text`
+     *  - `container`
+     *  - `listener`
+     *
+     * Binding update instructions:
+     * - `bind`
+     * - `elementAttribute`
+     * - `elementProperty`
+     * - `elementClass`
+     * - `elementStyle`
+     *
+     */
+    template: ComponentTemplate<T>;
+    /**
+     * Constants for the nodes in the component's view.
+     * Includes attribute arrays, local definition arrays etc.
+     */
+    consts?: TConstantsOrFactory;
+    /**
+     * An array of `ngContent[selector]` values that were found in the template.
+     */
+    ngContentSelectors?: string[];
+    /**
+     * A list of optional features to apply.
+     *
+     * See: {@link NgOnChangesFeature}, {@link ProvidersFeature}
+     */
+    features?: ComponentDefFeature[];
+    /**
+     * Defines template and style encapsulation options available for Component's {@link Component}.
+     */
+    encapsulation?: ViewEncapsulation;
+    /**
+     * Defines arbitrary developer-defined data to be stored on a renderer instance.
+     * This is useful for renderers that delegate to other renderers.
+     *
+     * see: animation
+     */
+    data?: {
+        [kind: string]: any;
+    };
+    /**
+     * A set of styles that the component needs to be present for component to render correctly.
+     */
+    styles?: string[];
+    /**
+     * The strategy that the default change detector uses to detect changes.
+     * When set, takes effect the next time change detection is triggered.
+     */
+    changeDetection?: ChangeDetectionStrategy;
+    /**
+     * Registry of directives, components, and pipes that may be found in this component's view.
+     *
+     * This property is either an array of types or a function that returns the array of types. This
+     * function may be necessary to support forward declarations.
+     */
+    dependencies?: TypeOrFactory<DependencyTypeList>;
+    /**
+     * The set of schemas that declare elements to be allowed in the component's template.
+     */
+    schemas?: SchemaMetadata[] | null;
+}
+
 /**
  * Base class for a factory that can create a component dynamically.
  * Instantiate a factory for a given type of component with `resolveComponentFactory()`.
@@ -2469,6 +2564,141 @@ declare interface DirectiveDefFeature {
     ngInherit?: true;
 }
 
+declare interface DirectiveDefinition<T> {
+    /**
+     * Directive type, needed to configure the injector.
+     */
+    type: Type<T>;
+    /** The selectors that will be used to match nodes to this directive. */
+    selectors?: ɵCssSelectorList;
+    /**
+     * A map of input names.
+     *
+     * The format is in: `{[actualPropertyName: string]:(string|[string, string])}`.
+     *
+     * Given:
+     * ```
+     * class MyComponent {
+     *   @Input()
+     *   publicInput1: string;
+     *
+     *   @Input('publicInput2')
+     *   declaredInput2: string;
+     * }
+     * ```
+     *
+     * is described as:
+     * ```
+     * {
+     *   publicInput1: 'publicInput1',
+     *   declaredInput2: ['declaredInput2', 'publicInput2'],
+     * }
+     * ```
+     *
+     * Which the minifier may translate to:
+     * ```
+     * {
+     *   minifiedPublicInput1: 'publicInput1',
+     *   minifiedDeclaredInput2: [ 'publicInput2', 'declaredInput2'],
+     * }
+     * ```
+     *
+     * This allows the render to re-construct the minified, public, and declared names
+     * of properties.
+     *
+     * NOTE:
+     *  - Because declared and public name are usually same we only generate the array
+     *    `['declared', 'public']` format when they differ.
+     *  - The reason why this API and `outputs` API is not the same is that `NgOnChanges` has
+     *    inconsistent behavior in that it uses declared names rather than minified or public. For
+     *    this reason `NgOnChanges` will be deprecated and removed in future version and this
+     *    API will be simplified to be consistent with `output`.
+     */
+    inputs?: {
+        [P in keyof T]?: string | [string, string];
+    };
+    /**
+     * A map of output names.
+     *
+     * The format is in: `{[actualPropertyName: string]:string}`.
+     *
+     * Which the minifier may translate to: `{[minifiedPropertyName: string]:string}`.
+     *
+     * This allows the render to re-construct the minified and non-minified names
+     * of properties.
+     */
+    outputs?: {
+        [P in keyof T]?: string;
+    };
+    /**
+     * A list of optional features to apply.
+     *
+     * See: {@link NgOnChangesFeature}, {@link ProvidersFeature}, {@link InheritDefinitionFeature}
+     */
+    features?: DirectiveDefFeature[];
+    /**
+     * Function executed by the parent template to allow child directive to apply host bindings.
+     */
+    hostBindings?: HostBindingsFunction<T>;
+    /**
+     * The number of bindings in this directive `hostBindings` (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.
+     */
+    hostVars?: number;
+    /**
+     * Assign static attribute values to a host element.
+     *
+     * This property will assign static attribute values as well as class and style
+     * values to a host element. Since attribute values can consist of different types of values,
+     * the `hostAttrs` array must include the values in the following format:
+     *
+     * attrs = [
+     *   // static attributes (like `title`, `name`, `id`...)
+     *   attr1, value1, attr2, value,
+     *
+     *   // a single namespace value (like `x:id`)
+     *   NAMESPACE_MARKER, namespaceUri1, name1, value1,
+     *
+     *   // another single namespace value (like `x:name`)
+     *   NAMESPACE_MARKER, namespaceUri2, name2, value2,
+     *
+     *   // a series of CSS classes that will be applied to the element (no spaces)
+     *   CLASSES_MARKER, class1, class2, class3,
+     *
+     *   // a series of CSS styles (property + value) that will be applied to the element
+     *   STYLES_MARKER, prop1, value1, prop2, value2
+     * ]
+     *
+     * All non-class and non-style attributes must be defined at the start of the list
+     * first before all class and style values are set. When there is a change in value
+     * type (like when classes and styles are introduced) a marker must be used to separate
+     * the entries. The marker values themselves are set via entries found in the
+     * [AttributeMarker] enum.
+     */
+    hostAttrs?: TAttributes;
+    /**
+     * Function to create instances of content queries associated with a given directive.
+     */
+    contentQueries?: ContentQueriesFunction<T>;
+    /**
+     * Additional set of instructions specific to view query processing. This could be seen as a
+     * set of instructions to be inserted into the template function.
+     */
+    viewQuery?: ViewQueriesFunction<T> | null;
+    /**
+     * Defines the name that can be used in the template to assign this directive to a variable.
+     *
+     * See: {@link Directive.exportAs}
+     */
+    exportAs?: string[];
+    /**
+     * Whether this directive/component is standalone.
+     */
+    standalone?: boolean;
+}
+
 declare type DirectiveDefList = (ɵDirectiveDef<any> | ɵComponentDef<any>)[];
 
 /**
@@ -5054,6 +5284,12 @@ export declare interface ModuleWithProviders<T> {
 
 declare const MOVED_VIEWS = 9;
 
+declare type Mutable<T extends {
+    [x: string]: any;
+}, K extends string> = {
+    [P in K]: T[P];
+};
+
 declare const NATIVE = 7;
 
 declare const NEXT = 4;
@@ -7482,7 +7718,7 @@ declare interface TContainerNode extends TNode {
      * - They are dynamically created
      */
     parent: TElementNode | TElementContainerNode | null;
-    tViews: TView | TView[] | null;
+    tView: TView | null;
     projection: null;
     value: null;
 }
@@ -7522,7 +7758,7 @@ declare interface TElementContainerNode extends TNode {
     index: number;
     child: TElementNode | TTextNode | TContainerNode | TElementContainerNode | TProjectionNode | null;
     parent: TElementNode | TElementContainerNode | null;
-    tViews: null;
+    tView: null;
     projection: null;
 }
 
@@ -7537,7 +7773,7 @@ declare interface TElementNode extends TNode {
      * retrieved using viewData[HOST_NODE]).
      */
     parent: TElementNode | TElementContainerNode | null;
-    tViews: null;
+    tView: null;
     /**
      * If this is a component TNode with projection, this will be an array of projected
      * TNodes or native nodes (see TNode.projection for more info). If it's a regular element node
@@ -7975,26 +8211,14 @@ declare interface TNode {
      */
     outputs: PropertyAliases | null;
     /**
-     * The TView or TViews attached to this node.
-     *
-     * If this TNode corresponds to an LContainer with inline views, the container will
-     * need to store separate static data for each of its view blocks (TView[]). Otherwise,
-     * nodes in inline views with the same index as nodes in their parent views will overwrite
-     * each other, as they are in the same template.
-     *
-     * Each index in this array corresponds to the static data for a certain
-     * view. So if you had V(0) and V(1) in a container, you might have:
-     *
-     * [
-     *   [{tagName: 'div', attrs: ...}, null],     // V(0) TView
-     *   [{tagName: 'button', attrs ...}, null]    // V(1) TView
+     * The TView attached to this node.
      *
      * If this TNode corresponds to an LContainer with a template (e.g. structural
      * directive), the template's TView will be stored here.
      *
-     * If this TNode corresponds to an element, tViews will be null .
+     * If this TNode corresponds to an element, tView will be `null`.
      */
-    tViews: TView | TView[] | null;
+    tView: TView | null;
     /**
      * The next sibling node. Necessary so we can propagate through the root nodes of a view
      * to insert them or remove them from the DOM.
@@ -8295,7 +8519,7 @@ declare interface TProjectionNode extends TNode {
      * retrieved using LView.node).
      */
     parent: TElementNode | TElementContainerNode | null;
-    tViews: null;
+    tView: null;
     /** Index of the projection node. (See TNode.projection for more info.) */
     projection: number;
     value: null;
@@ -8686,7 +8910,7 @@ declare interface TTextNode extends TNode {
      * retrieved using LView.node).
      */
     parent: TElementNode | TElementContainerNode | null;
-    tViews: null;
+    tView: null;
     projection: null;
 }
 
@@ -9712,43 +9936,6 @@ export declare const enum ɵBypassType {
     Style = "Style"
 }
 
-/**
- * Defines the possible states of the default change detector.
- * @see `ChangeDetectorRef`
- */
-export declare enum ɵChangeDetectorStatus {
-    /**
-     * A state in which, after calling `detectChanges()`, the change detector
-     * state becomes `Checked`, and must be explicitly invoked or reactivated.
-     */
-    CheckOnce = 0,
-    /**
-     * A state in which change detection is skipped until the change detector mode
-     * becomes `CheckOnce`.
-     */
-    Checked = 1,
-    /**
-     * A state in which change detection continues automatically until explicitly
-     * deactivated.
-     */
-    CheckAlways = 2,
-    /**
-     * A state in which a change detector sub tree is not a part of the main tree and
-     * should be skipped.
-     */
-    Detached = 3,
-    /**
-     * Indicates that the change detector encountered an error checking a binding
-     * or calling a directive lifecycle method and is now in an inconsistent state. Change
-     * detectors in this state do not detect changes.
-     */
-    Errored = 4,
-    /**
-     * Indicates that the change detector has been destroyed.
-     */
-    Destroyed = 5
-}
-
 export declare function ɵclearResolutionOfComponentResourcesQueue(): Map<Type<any>, Component>;
 
 
@@ -10283,21 +10470,10 @@ export declare interface ɵInternalEnvironmentProviders extends EnvironmentProvi
 
 export declare function ɵisBoundToModule<C>(cf: ComponentFactory<C>): boolean;
 
-/**
- * Reports whether a given strategy is currently the default for change detection.
- * @param changeDetectionStrategy The strategy to check.
- * @returns True if the given strategy is the current default, false otherwise.
- * @see `ChangeDetectorStatus`
- * @see `ChangeDetectorRef`
- */
-export declare function ɵisDefaultChangeDetectionStrategy(changeDetectionStrategy: ChangeDetectionStrategy): boolean;
-
 export declare function ɵisEnvironmentProviders(value: Provider | EnvironmentProviders | ɵInternalEnvironmentProviders): value is ɵInternalEnvironmentProviders;
 
 export declare function ɵisInjectable(type: any): boolean;
 
-export declare function ɵisListLikeIterable(obj: any): boolean;
-
 export declare function ɵisNgModule<T>(value: Type<T>): value is Type<T> & {
     ɵmod: ɵNgModuleDef<T>;
 };
@@ -10323,8 +10499,6 @@ export declare function ɵisPromise<T = any>(obj: any): obj is Promise<T>;
  */
 export declare function ɵisSubscribable(obj: any | Subscribable<any>): obj is Subscribable<any>;
 
-export declare const ɵivyEnabled = true;
-
 /**
  * The internal view context which is specific to a given DOM element, directive or
  * component instance. Each value in here (besides the LView and element node details)
@@ -11894,7 +12068,7 @@ export declare function ɵɵCopyDefinitionFeature(definition: ɵDirectiveDef<any
  *
  * # Example
  * ```
- * class MyDirective {
+ * class MyComponent {
  *   // Generated by Angular Template Compiler
  *   // [Symbol] syntax will not be supported by TypeScript until v2.7
  *   static ɵcmp = defineComponent({
@@ -11904,230 +12078,7 @@ export declare function ɵɵCopyDefinitionFeature(definition: ɵDirectiveDef<any
  * ```
  * @codeGenApi
  */
-export declare function ɵɵdefineComponent<T>(componentDefinition: {
-    /**
-     * Directive type, needed to configure the injector.
-     */
-    type: Type<T>;
-    /** The selectors that will be used to match nodes to this component. */
-    selectors?: ɵCssSelectorList;
-    /**
-     * The number of nodes, local refs, and pipes in this component template.
-     *
-     * Used to calculate the length of this component's LView array, so we
-     * can pre-fill the array and set the binding start index.
-     */
-    decls: number;
-    /**
-     * The number of bindings in this component template (including pure fn bindings).
-     *
-     * Used to calculate the length of this component's LView array, so we
-     * can pre-fill the array and set the host binding start index.
-     */
-    vars: number;
-    /**
-     * A map of input names.
-     *
-     * The format is in: `{[actualPropertyName: string]:(string|[string, string])}`.
-     *
-     * Given:
-     * ```
-     * class MyComponent {
-     *   @Input()
-     *   publicInput1: string;
-     *
-     *   @Input('publicInput2')
-     *   declaredInput2: string;
-     * }
-     * ```
-     *
-     * is described as:
-     * ```
-     * {
-     *   publicInput1: 'publicInput1',
-     *   declaredInput2: ['publicInput2', 'declaredInput2'],
-     * }
-     * ```
-     *
-     * Which the minifier may translate to:
-     * ```
-     * {
-     *   minifiedPublicInput1: 'publicInput1',
-     *   minifiedDeclaredInput2: ['publicInput2', 'declaredInput2'],
-     * }
-     * ```
-     *
-     * This allows the render to re-construct the minified, public, and declared names
-     * of properties.
-     *
-     * NOTE:
-     *  - Because declared and public name are usually same we only generate the array
-     *    `['public', 'declared']` format when they differ.
-     *  - The reason why this API and `outputs` API is not the same is that `NgOnChanges` has
-     *    inconsistent behavior in that it uses declared names rather than minified or public. For
-     *    this reason `NgOnChanges` will be deprecated and removed in future version and this
-     *    API will be simplified to be consistent with `output`.
-     */
-    inputs?: {
-        [P in keyof T]?: string | [string, string];
-    };
-    /**
-     * A map of output names.
-     *
-     * The format is in: `{[actualPropertyName: string]:string}`.
-     *
-     * Which the minifier may translate to: `{[minifiedPropertyName: string]:string}`.
-     *
-     * This allows the render to re-construct the minified and non-minified names
-     * of properties.
-     */
-    outputs?: {
-        [P in keyof T]?: string;
-    };
-    /**
-     * Function executed by the parent template to allow child directive to apply host bindings.
-     */
-    hostBindings?: HostBindingsFunction<T>;
-    /**
-     * The number of bindings in this directive `hostBindings` (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.
-     */
-    hostVars?: number;
-    /**
-     * Assign static attribute values to a host element.
-     *
-     * This property will assign static attribute values as well as class and style
-     * values to a host element. Since attribute values can consist of different types of values, the
-     * `hostAttrs` array must include the values in the following format:
-     *
-     * attrs = [
-     *   // static attributes (like `title`, `name`, `id`...)
-     *   attr1, value1, attr2, value,
-     *
-     *   // a single namespace value (like `x:id`)
-     *   NAMESPACE_MARKER, namespaceUri1, name1, value1,
-     *
-     *   // another single namespace value (like `x:name`)
-     *   NAMESPACE_MARKER, namespaceUri2, name2, value2,
-     *
-     *   // a series of CSS classes that will be applied to the element (no spaces)
-     *   CLASSES_MARKER, class1, class2, class3,
-     *
-     *   // a series of CSS styles (property + value) that will be applied to the element
-     *   STYLES_MARKER, prop1, value1, prop2, value2
-     * ]
-     *
-     * All non-class and non-style attributes must be defined at the start of the list
-     * first before all class and style values are set. When there is a change in value
-     * type (like when classes and styles are introduced) a marker must be used to separate
-     * the entries. The marker values themselves are set via entries found in the
-     * [AttributeMarker] enum.
-     */
-    hostAttrs?: TAttributes;
-    /**
-     * Function to create instances of content queries associated with a given directive.
-     */
-    contentQueries?: ContentQueriesFunction<T>;
-    /**
-     * Defines the name that can be used in the template to assign this directive to a variable.
-     *
-     * See: {@link Directive.exportAs}
-     */
-    exportAs?: string[];
-    /**
-     * Template function use for rendering DOM.
-     *
-     * This function has following structure.
-     *
-     * ```
-     * function Template<T>(ctx:T, creationMode: boolean) {
-     *   if (creationMode) {
-     *     // Contains creation mode instructions.
-     *   }
-     *   // Contains binding update instructions
-     * }
-     * ```
-     *
-     * Common instructions are:
-     * Creation mode instructions:
-     *  - `elementStart`, `elementEnd`
-     *  - `text`
-     *  - `container`
-     *  - `listener`
-     *
-     * Binding update instructions:
-     * - `bind`
-     * - `elementAttribute`
-     * - `elementProperty`
-     * - `elementClass`
-     * - `elementStyle`
-     *
-     */
-    template: ComponentTemplate<T>;
-    /**
-     * Constants for the nodes in the component's view.
-     * Includes attribute arrays, local definition arrays etc.
-     */
-    consts?: TConstantsOrFactory;
-    /**
-     * An array of `ngContent[selector]` values that were found in the template.
-     */
-    ngContentSelectors?: string[];
-    /**
-     * Additional set of instructions specific to view query processing. This could be seen as a
-     * set of instruction to be inserted into the template function.
-     *
-     * Query-related instructions need to be pulled out to a specific function as a timing of
-     * execution is different as compared to all other instructions (after change detection hooks but
-     * before view hooks).
-     */
-    viewQuery?: ViewQueriesFunction<T> | null;
-    /**
-     * A list of optional features to apply.
-     *
-     * See: {@link NgOnChangesFeature}, {@link ProvidersFeature}
-     */
-    features?: ComponentDefFeature[];
-    /**
-     * Defines template and style encapsulation options available for Component's {@link Component}.
-     */
-    encapsulation?: ViewEncapsulation;
-    /**
-     * Defines arbitrary developer-defined data to be stored on a renderer instance.
-     * This is useful for renderers that delegate to other renderers.
-     *
-     * see: animation
-     */
-    data?: {
-        [kind: string]: any;
-    };
-    /**
-     * A set of styles that the component needs to be present for component to render correctly.
-     */
-    styles?: string[];
-    /**
-     * The strategy that the default change detector uses to detect changes.
-     * When set, takes effect the next time change detection is triggered.
-     */
-    changeDetection?: ChangeDetectionStrategy;
-    /**
-     * Registry of directives, components, and pipes that may be found in this component's view.
-     *
-     * This property is either an array of types or a function that returns the array of types. This
-     * function may be necessary to support forward declarations.
-     */
-    dependencies?: TypeOrFactory<DependencyTypeList>;
-    /**
-     * The set of schemas that declare elements to be allowed in the component's template.
-     */
-    schemas?: SchemaMetadata[] | null;
-    /**
-     * Whether this directive/component is standalone.
-     */
-    standalone?: boolean;
-}): unknown;
+export declare function ɵɵdefineComponent<T>(componentDefinition: ComponentDefinition<T>): Mutable<ɵComponentDef<any>, keyof ɵComponentDef<any>>;
 
 /**
  * Create a directive definition object.
@@ -12145,132 +12096,7 @@ export declare function ɵɵdefineComponent<T>(componentDefinition: {
  *
  * @codeGenApi
  */
-export declare const ɵɵdefineDirective: <T>(directiveDefinition: {
-    /**
-     * Directive type, needed to configure the injector.
-     */
-    type: Type<T>;
-    /** The selectors that will be used to match nodes to this directive. */
-    selectors?: ɵCssSelectorList | undefined;
-    /**
-     * A map of input names.
-     *
-     * The format is in: `{[actualPropertyName: string]:(string|[string, string])}`.
-     *
-     * Given:
-     * ```
-     * class MyComponent {
-     *   @Input()
-     *   publicInput1: string;
-     *
-     *   @Input('publicInput2')
-     *   declaredInput2: string;
-     * }
-     * ```
-     *
-     * is described as:
-     * ```
-     * {
-     *   publicInput1: 'publicInput1',
-     *   declaredInput2: ['declaredInput2', 'publicInput2'],
-     * }
-     * ```
-     *
-     * Which the minifier may translate to:
-     * ```
-     * {
-     *   minifiedPublicInput1: 'publicInput1',
-     *   minifiedDeclaredInput2: [ 'publicInput2', 'declaredInput2'],
-     * }
-     * ```
-     *
-     * This allows the render to re-construct the minified, public, and declared names
-     * of properties.
-     *
-     * NOTE:
-     *  - Because declared and public name are usually same we only generate the array
-     *    `['declared', 'public']` format when they differ.
-     *  - The reason why this API and `outputs` API is not the same is that `NgOnChanges` has
-     *    inconsistent behavior in that it uses declared names rather than minified or public. For
-     *    this reason `NgOnChanges` will be deprecated and removed in future version and this
-     *    API will be simplified to be consistent with `output`.
-     */
-    inputs?: { [P in keyof T]?: string | [string, string] | undefined; } | undefined;
-    /**
-     * A map of output names.
-     *
-     * The format is in: `{[actualPropertyName: string]:string}`.
-     *
-     * Which the minifier may translate to: `{[minifiedPropertyName: string]:string}`.
-     *
-     * This allows the render to re-construct the minified and non-minified names
-     * of properties.
-     */
-    outputs?: { [P_1 in keyof T]?: string | undefined; } | undefined;
-    /**
-     * A list of optional features to apply.
-     *
-     * See: {@link NgOnChangesFeature}, {@link ProvidersFeature}, {@link InheritDefinitionFeature}
-     */
-    features?: DirectiveDefFeature[] | undefined;
-    /**
-     * Function executed by the parent template to allow child directive to apply host bindings.
-     */
-    hostBindings?: HostBindingsFunction<T> | undefined;
-    /**
-     * The number of bindings in this directive `hostBindings` (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.
-     */
-    hostVars?: number | undefined;
-    /**
-     * Assign static attribute values to a host element.
-     *
-     * This property will assign static attribute values as well as class and style
-     * values to a host element. Since attribute values can consist of different types of values,
-     * the `hostAttrs` array must include the values in the following format:
-     *
-     * attrs = [
-     *   // static attributes (like `title`, `name`, `id`...)
-     *   attr1, value1, attr2, value,
-     *
-     *   // a single namespace value (like `x:id`)
-     *   NAMESPACE_MARKER, namespaceUri1, name1, value1,
-     *
-     *   // another single namespace value (like `x:name`)
-     *   NAMESPACE_MARKER, namespaceUri2, name2, value2,
-     *
-     *   // a series of CSS classes that will be applied to the element (no spaces)
-     *   CLASSES_MARKER, class1, class2, class3,
-     *
-     *   // a series of CSS styles (property + value) that will be applied to the element
-     *   STYLES_MARKER, prop1, value1, prop2, value2
-     * ]
-     *
-     * All non-class and non-style attributes must be defined at the start of the list
-     * first before all class and style values are set. When there is a change in value
-     * type (like when classes and styles are introduced) a marker must be used to separate
-     * the entries. The marker values themselves are set via entries found in the
-     * [AttributeMarker] enum.
-     */
-    hostAttrs?: TAttributes | undefined;
-    /**
-     * Function to create instances of content queries associated with a given directive.
-     */
-    contentQueries?: ContentQueriesFunction<T> | undefined;
-    /**
-     * Additional set of instructions specific to view query processing. This could be seen as a
-     * set of instructions to be inserted into the template function.
-     */
-    viewQuery?: ViewQueriesFunction<T> | null | undefined;
-    /**
-     * Defines the name that can be used in the template to assign this directive to a variable.
-     *
-     * See: {@link Directive.exportAs}
-     */
-    exportAs?: string[] | undefined;
-}) => never;
+export declare function ɵɵdefineDirective<T>(directiveDefinition: DirectiveDefinition<T>): Mutable<ɵDirectiveDef<any>, keyof ɵDirectiveDef<any>>;
 
 /**
  * Construct an injectable definition which defines how a token will be constructed by the DI