@angular/core 16.0.0-next.2 → 16.0.0-next.4

package/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @license Angular v16.0.0-next.2
+ * @license Angular v16.0.0-next.4
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -187,13 +187,32 @@ export declare const ANIMATION_MODULE_TYPE: InjectionToken<"NoopAnimations" | "B
 export declare const APP_BOOTSTRAP_LISTENER: InjectionToken<((compRef: ComponentRef<any>) => void)[]>;
 
 /**
- * A [DI token](guide/glossary#di-token "DI token definition") representing a unique string ID, used
+ * A [DI token](guide/glossary#di-token "DI token definition") representing a string ID, used
  * primarily for prefixing application attributes and CSS styles when
  * {@link ViewEncapsulation#Emulated ViewEncapsulation.Emulated} is being used.
  *
- * BY default, the value is randomly generated and assigned to the application by Angular.
- * To provide a custom ID value, use a DI provider <!-- TODO: provider --> to configure
- * the root {@link Injector} that uses this token.
+ * The token is needed in cases when multiple applications are bootstrapped on a page
+ * (for example, using `bootstrapApplication` calls). In this case, ensure that those applications
+ * have different `APP_ID` value setup. For example:
+ *
+ * ```
+ * bootstrapApplication(ComponentA, {
+ *   providers: [
+ *     { provide: APP_ID, useValue: 'app-a' },
+ *     // ... other providers ...
+ *   ]
+ * });
+ *
+ * bootstrapApplication(ComponentB, {
+ *   providers: [
+ *     { provide: APP_ID, useValue: 'app-b' },
+ *     // ... other providers ...
+ *   ]
+ * });
+ * ```
+ *
+ * By default, when there is only one application bootstrapped, you don't need to provide the
+ * `APP_ID` token (the `ng` will be used as an app ID).
  *
  * @publicApi
  */
@@ -271,8 +290,6 @@ export declare const APP_ID: InjectionToken<string>;
  */
 export declare const APP_INITIALIZER: InjectionToken<readonly (() => Observable<unknown> | Promise<unknown> | void)[]>;
 
-declare function _appIdRandomProviderFactory(): string;
-
 /**
  * Set of config options available during the application bootstrap operation.
  *
@@ -319,7 +336,6 @@ export declare class ApplicationModule {
  * A reference to an Angular application running on a page.
  *
  * @usageNotes
- *
  * {@a is-stable-examples}
  * ### isStable examples and caveats
  *
@@ -409,14 +425,10 @@ export declare class ApplicationModule {
  * @publicApi
  */
 export declare class ApplicationRef {
-    private _zone;
-    private _injector;
-    private _exceptionHandler;
     private _runningTick;
-    private _stable;
-    private _onMicrotaskEmptySubscription;
     private _destroyed;
     private _destroyListeners;
+    private readonly internalErrorHandler;
     /**
      * Indicates whether this instance was destroyed.
      */
@@ -432,10 +444,9 @@ export declare class ApplicationRef {
     readonly components: ComponentRef<any>[];
     /**
      * Returns an Observable that indicates when the application is stable or unstable.
-     *
-     * @see  [Usage notes](#is-stable-examples) for examples and caveats when using this API.
      */
     readonly isStable: Observable<boolean>;
+    private readonly _injector;
     /**
      * The `EnvironmentInjector` used to create this application.
      */
@@ -802,6 +813,9 @@ export declare abstract class ChangeDetectorRef {
     abstract reattach(): void;
 }
 
+declare interface ChangeDetectorRefInterface extends ChangeDetectorRef {
+}
+
 declare const CHILD_HEAD = 13;
 
 declare const CHILD_TAIL = 14;
@@ -1245,6 +1259,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()`.
@@ -1482,77 +1591,7 @@ export declare interface ConstructorSansProvider {
     deps?: any[];
 }
 
-/**
- * Represents a reader that can depend on reactive values (`Producer`s) and receive
- * notifications when those values change.
- *
- * `Consumer`s do not wrap the reads they consume themselves, but rather can be set
- * as the active reader via `setActiveConsumer`.
- *
- * The set of dependencies of a `Consumer` is dynamic. Implementers expose a
- * monotonically increasing `trackingVersion` counter, which increments whenever
- * the `Consumer` is about to re-run any reactive reads it needs and establish a
- * new set of dependencies as a result.
- *
- * `Producer`s store the last `trackingVersion` they've seen from `Consumer`s which
- * have read them. This allows a `Producer` to identify whether its record of the
- * dependency is current or stale, by comparing the `Consumer`'s `trackingVersion`
- * to the version at which the dependency was established.
- */
-declare interface Consumer {
-    /**
-     * Numeric identifier of this `Producer`.
-     *
-     * May also be used to satisfy the interface for `Producer`.
-     */
-    readonly id: ConsumerId;
-    /**
-     * A `WeakRef` to this `Consumer` instance.
-     *
-     * An implementer provides this as a cached value to avoid the need to instantiate
-     * multiple `WeakRef` instances for the same `Consumer`.
-     *
-     * May also be used to satisfy the interface for `Producer`.
-     */
-    readonly ref: WeakRef<Consumer>;
-    /**
-     * A map of `Edge`s to `Producer` dependencies, keyed by the `ProducerId`.
-     *
-     * Used to poll `Producer`s to determine if the `Consumer` has really updated
-     * or not.
-     */
-    readonly producers: Map<ProducerId, Edge>;
-    /**
-     * Monotonically increasing counter representing a version of this `Consumer`'s
-     * dependencies.
-     */
-    readonly trackingVersion: number;
-    /**
-     * Called when a `Producer` dependency of this `Consumer` indicates it may
-     * have a new value.
-     *
-     * Notification alone does not mean the `Producer` has definitely produced a
-     * semantically different value, only that it _may_ have changed. Before a
-     * `Consumer` re-runs any computations or side effects, it should use the
-     * `consumerPollValueStatus` method to poll the `Producer`s on which it depends
-     * and determine if any of them have actually updated.
-     */
-    notify(): void;
-}
-
-/**
- * Identifier for a `Consumer`, which is a branded `number`.
- *
- * Note that `ProducerId` and `ConsumerId` are assigned from the same sequence, so the same `number`
- * will never be used for both.
- *
- * Branding provides additional type safety by ensuring that `ProducerId` and `ConsumerId` are
- * mutually unassignable without a cast. Since several `Map`s are keyed by these IDs, this prevents
- * `ConsumerId`s from being inadvertently used to look up `Producer`s or vice versa.
- */
-declare type ConsumerId = number & {
-    __consumer: true;
-};
+declare const CONTAINERS = "c";
 
 /**
  * Type of the ContentChild metadata.
@@ -1866,6 +1905,15 @@ export declare function createPlatform(injector: Injector): PlatformRef;
  */
 export declare function createPlatformFactory(parentPlatformFactory: ((extraProviders?: StaticProvider[]) => PlatformRef) | null, name: string, providers?: StaticProvider[]): (extraProviders?: StaticProvider[]) => PlatformRef;
 
+/**
+ * Token used to configure the [Content Security Policy](https://web.dev/strict-csp/) nonce that
+ * Angular will apply when inserting inline styles. If not provided, Angular will look up its value
+ * from the `ngCspNonce` attribute of the application root node.
+ *
+ * @publicApi
+ */
+export declare const CSP_NONCE: InjectionToken<string | null>;
+
 
 /**
  * Expresses a single CSS Selector.
@@ -2184,17 +2232,17 @@ export declare class DefaultIterableDiffer<V> implements IterableDiffer<V>, Iter
  */
 export declare const defineInjectable: typeof ɵɵdefineInjectable;
 
+declare const DEHYDRATED_VIEWS = 10;
+
 /**
- * Represents a hydration-related element container structure
- * at runtime, which includes a reference to a first node in
- * a DOM segment that corresponds to a given element container.
+ * An object that contains hydration-related information serialized
+ * on the server, as well as the necessary references to segments of
+ * the DOM, to facilitate the hydration process for a given view
+ * inside a view container (either an embedded view or a view created
+ * for a component).
  */
-declare interface DehydratedElementContainer {
-    /**
-     * A reference to the first child in a DOM segment associated
-     * with a first child in a given <ng-container>.
-     */
-    firstChild: RNode | null;
+declare interface DehydratedContainerView extends DehydratedView {
+    data: Readonly<SerializedContainerView>;
 }
 
 /**
@@ -2214,14 +2262,24 @@ declare interface DehydratedView {
      */
     firstChild: RNode | null;
     /**
-     * Collection of <ng-container>s in a given view,
-     * used as a set of pointers to first children in each
-     * <ng-container>, so that those pointers are reused by
-     * subsequent instructions.
+     * Stores references to first nodes in DOM segments that
+     * represent either an <ng-container> or a view container.
      */
-    ngContainers?: {
-        [index: number]: DehydratedElementContainer;
+    segmentHeads?: {
+        [index: number]: RNode | null;
     };
+    /**
+     * An instance of a Set that represents nodes disconnected from
+     * the DOM tree at the serialization time, but otherwise present
+     * in the internal data structures.
+     *
+     * The Set is based on the `SerializedView[DISCONNECTED_NODES]` data
+     * and is needed to have constant-time lookups.
+     *
+     * If the value is `null`, it means that there were no disconnected
+     * nodes detected in this view at serialization time.
+     */
+    disconnectedNodes?: Set<number> | null;
 }
 
 declare type DependencyTypeList = (ɵDirectiveType<any> | ɵComponentType<any> | PipeType<any> | Type<any>)[];
@@ -2260,12 +2318,27 @@ export declare function destroyPlatform(): void;
  * The scope of this destruction depends on where `DestroyRef` is injected. If `DestroyRef`
  * is injected in a component or directive, the callbacks run when that component or
  * directive is destroyed. Otherwise the callbacks run when a corresponding injector is destroyed.
+ *
+ * @publicApi
  */
 export declare abstract class DestroyRef {
     /**
-     * Registers a destroy callback in a given lifecycle scope.
+     * Registers a destroy callback in a given lifecycle scope.  Returns a cleanup function that can
+     * be invoked to unregister the callback.
+     *
+     * @usageNotes
+     * ### Example
+     * ```typescript
+     * const destroyRef = inject(DestroyRef);
+     *
+     * // register a destroy callback
+     * const unregisterFn = destroyRef.onDestroy(() => doSomethingOnDestroy());
+     *
+     * // stop the destroy callback from executing if needed
+     * unregisterFn();
+     * ```
      */
-    abstract onDestroy(callback: () => void): void;
+    abstract onDestroy(callback: () => void): () => void;
 }
 
 /**
@@ -2307,13 +2380,19 @@ export declare interface Directive {
      * Enumerates the set of data-bound input properties for a directive
      *
      * Angular automatically updates input properties during change detection.
-     * The `inputs` property defines a set of `directiveProperty` to `bindingProperty`
-     * configuration:
+     * The `inputs` property accepts either strings or object literals that configure the directive
+     * properties that should be exposed as inputs.
      *
-     * - `directiveProperty` specifies the component property where the value is written.
-     * - `bindingProperty` specifies the DOM property where the value is read from.
+     * When an object literal is passed in, the `name` property indicates which property on the
+     * class the input should write to, while the `alias` determines the name under
+     * which the input will be available in template bindings. The `required` property indicates that
+     * the input is required which will trigger a compile-time error if it isn't passed in when the
+     * directive is used.
      *
-     * When `bindingProperty` is not provided, it is assumed to be equal to `directiveProperty`.
+     * When a string is passed into the `inputs` array, it can have a format of `'name'` or
+     * `'name: alias'` where `name` is the property on the class that the directive should write
+     * to, while the `alias` determines the name under which the input will be available in
+     * template bindings. String-based input definitions are assumed to be optional.
      *
      * @usageNotes
      *
@@ -2322,7 +2401,7 @@ export declare interface Directive {
      * ```typescript
      * @Component({
      *   selector: 'bank-account',
-     *   inputs: ['bankName', 'id: account-id'],
+     *   inputs: ['bankName', {name: 'id', alias: 'account-id'}],
      *   template: `
      *     Bank Name: {{bankName}}
      *     Account Id: {{id}}
@@ -2335,18 +2414,22 @@ export declare interface Directive {
      * ```
      *
      */
-    inputs?: string[];
+    inputs?: ({
+        name: string;
+        alias?: string;
+        required?: boolean;
+    } | string)[];
     /**
      * Enumerates the set of event-bound output properties.
      *
      * When an output property emits an event, an event handler attached to that event
      * in the template is invoked.
      *
-     * The `outputs` property defines a set of `directiveProperty` to `bindingProperty`
+     * The `outputs` property defines a set of `directiveProperty` to `alias`
      * configuration:
      *
      * - `directiveProperty` specifies the component property that emits events.
-     * - `bindingProperty` specifies the DOM property the event handler is attached to.
+     * - `alias` specifies the DOM property the event handler is attached to.
      *
      * @usageNotes
      *
@@ -2612,126 +2695,215 @@ declare interface DirectiveDefFeature {
     ngInherit?: true;
 }
 
-declare type DirectiveDefList = (ɵDirectiveDef<any> | ɵComponentDef<any>)[];
-
-/**
- * Type used for directiveDefs on component definition.
- *
- * The function is necessary to be able to support forward declarations.
- */
-declare type DirectiveDefListOrFactory = (() => DirectiveDefList) | DirectiveDefList;
-
-/**
- * @description
- * Hook for manual bootstrapping of the application instead of using `bootstrap` array in @NgModule
- * annotation. This hook is invoked only when the `bootstrap` array is empty or not provided.
- *
- * Reference to the current application is provided as a parameter.
- *
- * See ["Bootstrapping"](guide/bootstrapping) and ["Entry components"](guide/entry-components).
- *
- * @usageNotes
- * The example below uses `ApplicationRef.bootstrap()` to render the
- * `AppComponent` on the page.
- *
- * ```typescript
- * class AppModule implements DoBootstrap {
- *   ngDoBootstrap(appRef: ApplicationRef) {
- *     appRef.bootstrap(AppComponent); // Or some other component
- *   }
- * }
- * ```
- *
- * @publicApi
- */
-export declare interface DoBootstrap {
-    ngDoBootstrap(appRef: ApplicationRef): void;
-}
-
-/**
- * A lifecycle hook that invokes a custom change-detection function for a directive,
- * in addition to the check performed by the default change-detector.
- *
- * The default change-detection algorithm looks for differences by comparing
- * bound-property values by reference across change detection runs. You can use this
- * hook to check for and respond to changes by some other means.
- *
- * When the default change detector detects changes, it invokes `ngOnChanges()` if supplied,
- * regardless of whether you perform additional change detection.
- * Typically, you should not use both `DoCheck` and `OnChanges` to respond to
- * changes on the same input.
- *
- * @see `OnChanges`
- * @see [Lifecycle hooks guide](guide/lifecycle-hooks)
- *
- * @usageNotes
- * The following snippet shows how a component can implement this interface
- * to invoke it own change-detection cycle.
- *
- * {@example core/ts/metadata/lifecycle_hooks_spec.ts region='DoCheck'}
- *
- * For a more complete example and discussion, see
- * [Defining custom change detection](guide/lifecycle-hooks#defining-custom-change-detection).
- *
- * @publicApi
- */
-export declare interface DoCheck {
-    /**
-     * A callback method that performs change-detection, invoked
-     * after the default change-detector runs.
-     * See `KeyValueDiffers` and `IterableDiffers` for implementing
-     * custom change checking for collections.
-     *
-     */
-    ngDoCheck(): void;
-}
-
-/**
- * A bidirectional edge in the producer-consumer dependency graph.
- */
-declare interface Edge {
+declare interface DirectiveDefinition<T> {
     /**
-     * Weakly held reference to the `Consumer` side of this edge.
-     */
-    readonly consumerRef: WeakRef<Consumer>;
-    /**
-     * Weakly held reference to the `Producer` side of this edge.
+     * Directive type, needed to configure the injector.
      */
-    readonly producerRef: WeakRef<Producer>;
+    type: Type<T>;
+    /** The selectors that will be used to match nodes to this directive. */
+    selectors?: ɵCssSelectorList;
     /**
-     * `trackingVersion` of the `Consumer` at which this dependency edge was last observed.
+     * A map of input names.
      *
-     * If this doesn't match the `Consumer`'s current `trackingVersion`, then this dependency record
-     * is stale, and needs to be cleaned up.
-     */
-    atTrackingVersion: number;
-    /**
-     * `valueVersion` of the `Producer` at the time this dependency was last accessed.
+     * The format is in: `{[actualPropertyName: string]:(string|[string, string])}`.
      *
-     * This is used by `consumerPollValueStatus` to determine whether a `Consumer`'s dependencies have
-     * semantically changed.
-     */
-    seenValueVersion: number;
-}
-
-/**
- * A global reactive effect, which can be manually scheduled or destroyed.
- *
- * @developerPreview
- */
-export declare interface Effect {
+     * 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];
+    };
     /**
-     * Schedule the effect for manual execution, if it's not already.
+     * 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.
      */
-    schedule(): void;
+    outputs?: {
+        [P in keyof T]?: string;
+    };
     /**
-     * Shut down the effect, removing it from any upcoming scheduled executions.
+     * A list of optional features to apply.
+     *
+     * See: {@link NgOnChangesFeature}, {@link ProvidersFeature}, {@link InheritDefinitionFeature}
      */
-    destroy(): void;
+    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>)[];
+
+/**
+ * Type used for directiveDefs on component definition.
+ *
+ * The function is necessary to be able to support forward declarations.
+ */
+declare type DirectiveDefListOrFactory = (() => DirectiveDefList) | DirectiveDefList;
+
+declare const DISCONNECTED_NODES = "d";
+
+/**
+ * @description
+ * Hook for manual bootstrapping of the application instead of using `bootstrap` array in @NgModule
+ * annotation. This hook is invoked only when the `bootstrap` array is empty or not provided.
+ *
+ * Reference to the current application is provided as a parameter.
+ *
+ * See ["Bootstrapping"](guide/bootstrapping) and ["Entry components"](guide/entry-components).
+ *
+ * @usageNotes
+ * The example below uses `ApplicationRef.bootstrap()` to render the
+ * `AppComponent` on the page.
+ *
+ * ```typescript
+ * class AppModule implements DoBootstrap {
+ *   ngDoBootstrap(appRef: ApplicationRef) {
+ *     appRef.bootstrap(AppComponent); // Or some other component
+ *   }
+ * }
+ * ```
+ *
+ * @publicApi
+ */
+export declare interface DoBootstrap {
+    ngDoBootstrap(appRef: ApplicationRef): void;
+}
+
+/**
+ * A lifecycle hook that invokes a custom change-detection function for a directive,
+ * in addition to the check performed by the default change-detector.
+ *
+ * The default change-detection algorithm looks for differences by comparing
+ * bound-property values by reference across change detection runs. You can use this
+ * hook to check for and respond to changes by some other means.
+ *
+ * When the default change detector detects changes, it invokes `ngOnChanges()` if supplied,
+ * regardless of whether you perform additional change detection.
+ * Typically, you should not use both `DoCheck` and `OnChanges` to respond to
+ * changes on the same input.
+ *
+ * @see `OnChanges`
+ * @see [Lifecycle hooks guide](guide/lifecycle-hooks)
+ *
+ * @usageNotes
+ * The following snippet shows how a component can implement this interface
+ * to invoke it own change-detection cycle.
+ *
+ * {@example core/ts/metadata/lifecycle_hooks_spec.ts region='DoCheck'}
+ *
+ * For a more complete example and discussion, see
+ * [Defining custom change detection](guide/lifecycle-hooks#defining-custom-change-detection).
+ *
+ * @publicApi
+ */
+export declare interface DoCheck {
     /**
-     * Direct access to the effect's `Consumer` for advanced use cases.
+     * A callback method that performs change-detection, invoked
+     * after the default change-detector runs.
+     * See `KeyValueDiffers` and `IterableDiffers` for implementing
+     * custom change checking for collections.
+     *
      */
-    readonly consumer: Consumer;
+    ngDoCheck(): void;
 }
 
 /**
@@ -2739,8 +2911,25 @@ export declare interface Effect {
  *
  * @developerPreview
  */
-export declare function effect(effectFn: () => void): Effect;
+export declare function effect(effectFn: () => void): EffectRef;
+
+
+/**
+ * A global reactive effect, which can be manually destroyed.
+ *
+ * @developerPreview
+ */
+export declare interface EffectRef {
+    /**
+     * Shut down the effect, removing it from any upcoming scheduled executions.
+     */
+    destroy(): void;
+}
 
+/**
+ * Keys within serialized view data structure to represent various
+ * parts. See the `SerializedView` interface below for additional information.
+ */
 declare const ELEMENT_CONTAINERS = "e";
 
 /**
@@ -2928,6 +3117,7 @@ export declare abstract class EnvironmentInjector implements Injector {
      *
      * @param fn the closure to be run in the context of this injector
      * @returns the return value of the function, if any
+     * @deprecated use the standalone function `runInInjectionContext` instead
      */
     abstract runInContext<ReturnT>(fn: () => ReturnT): ReturnT;
     abstract destroy(): void;
@@ -4360,7 +4550,11 @@ export declare interface Input {
     /**
      * The name of the DOM property to which the input property is bound.
      */
-    bindingPropertyName?: string;
+    alias?: string;
+    /**
+     * Whether the input is required for the directive to function.
+     */
+    required?: boolean;
 }
 
 /**
@@ -4418,8 +4612,8 @@ export declare interface InputDecorator {
      *
      * @see [Input and Output properties](guide/inputs-outputs)
      */
-    (bindingPropertyName?: string): any;
-    new (bindingPropertyName?: string): any;
+    (arg?: string | Input): any;
+    new (arg?: string | Input): any;
 }
 
 /**
@@ -4808,7 +5002,7 @@ declare interface LContainer extends Array<any> {
      */
     [T_HOST]: TNode;
     /** The comment element that serves as an anchor for this LContainer. */
-    readonly [NATIVE]: RComment;
+    [NATIVE]: RComment;
     /**
      * Array of `ViewRef`s used by any `ViewContainerRef`s that point to this container.
      *
@@ -4818,6 +5012,17 @@ declare interface LContainer extends Array<any> {
      * doing so creates circular dependency.
      */
     [VIEW_REFS]: unknown[] | null;
+    /**
+     * Array of dehydrated views within this container.
+     *
+     * This information is used during the hydration process on the client.
+     * The hydration logic tries to find a matching dehydrated view, "claim" it
+     * and use this information to do further matching. After that, this "claimed"
+     * view is removed from the list. The remaining "unclaimed" views are
+     * "garbage-collected" later on, i.e. removed from the DOM once the hydration
+     * logic finishes.
+     */
+    [DEHYDRATED_VIEWS]: DehydratedContainerView[] | null;
 }
 
 /**
@@ -5281,6 +5486,14 @@ export declare interface ModuleWithProviders<T> {
 
 declare const MOVED_VIEWS = 9;
 
+declare const MULTIPLIER = "x";
+
+declare type Mutable<T extends {
+    [x: string]: any;
+}, K extends string> = {
+    [P in K]: T[P];
+};
+
 declare const NATIVE = 7;
 
 declare const NEXT = 4;
@@ -5731,6 +5944,10 @@ export declare class NgZone {
  */
 export declare const NO_ERRORS_SCHEMA: SchemaMetadata;
 
+declare const NODES = "n";
+
+declare const NUM_ROOT_NODES = "r";
+
 declare const ON_DESTROY_HOOKS = 22;
 
 /**
@@ -5869,7 +6086,7 @@ export declare interface Output {
     /**
      * The name of the DOM property to which the output property is bound.
      */
-    bindingPropertyName?: string;
+    alias?: string;
 }
 
 /**
@@ -5900,8 +6117,8 @@ export declare interface OutputDecorator {
      * @see [Input and Output properties](guide/inputs-outputs)
      *
      */
-    (bindingPropertyName?: string): any;
-    new (bindingPropertyName?: string): any;
+    (alias?: string): any;
+    new (alias?: string): any;
 }
 
 /**
@@ -6163,74 +6380,6 @@ declare const enum PreOrderHookFlags {
  */
 declare type ProcessProvidersFunction = (providers: Provider[]) => Provider[];
 
-/**
- * Represents a value that can be read reactively, and can notify readers (`Consumer`s)
- * when it changes.
- *
- * Producers maintain a weak reference to any `Consumer`s which may depend on the
- * producer's value.
- *
- * Implementers of `Producer` expose a monotonic `valueVersion` counter, and are responsible
- * for incrementing this version when their value semantically changes. Some Producers may
- * produce this value lazily and thus at times need to be polled for potential updates to
- * their value (and by extension their `valueVersion`). This is accomplished via the
- * `checkForChangedValue` method for Producers, which should perform whatever calculations
- * are necessary to ensure `valueVersion` is up to date.
- *
- * `Producer`s support two operations:
- *   * `producerNotifyConsumers`
- *   * `producerAccessed`
- */
-declare interface Producer {
-    /**
-     * Numeric identifier of this `Producer`.
-     *
-     * May also be used to satisfy the interface for `Consumer`.
-     */
-    readonly id: ProducerId;
-    /**
-     * A `WeakRef` to this `Producer` instance.
-     *
-     * An implementer provides this as a cached value to avoid the need to instantiate
-     * multiple `WeakRef` instances for the same `Producer`.
-     *
-     * May also be used to satisfy the interface for `Consumer`.
-     */
-    readonly ref: WeakRef<Producer>;
-    /**
-     * A map of dependency `Edge`s to `Consumer`s, keyed by the `ConsumerId`.
-     *
-     * Used when the produced value changes to notify interested `Consumer`s.
-     */
-    readonly consumers: Map<ConsumerId, Edge>;
-    /**
-     * Monotonically increasing counter which increases when the value of this `Producer`
-     * semantically changes.
-     */
-    readonly valueVersion: number;
-    /**
-     * Ensure that `valueVersion` is up to date for the `Producer`'s value.
-     *
-     * Some `Producer`s may produce values lazily, and thus require polling before their
-     * `valueVersion` can be compared with the version captured during a previous read.
-     */
-    checkForChangedValue(): void;
-}
-
-/**
- * Identifier for a `Producer`, which is a branded `number`.
- *
- * Note that `ProducerId` and `ConsumerId` are assigned from the same sequence, so the same `number`
- * will never be used for both.
- *
- * Branding provides additional type safety by ensuring that `ProducerId` and `ConsumerId` are
- * mutually unassignable without a cast. Since several `Map`s are keyed by these IDs, this prevents
- * `ProducerId`s from being inadvertently used to look up `Consumer`s or vice versa.
- */
-declare type ProducerId = number & {
-    __producer: true;
-};
-
 /**
  * List of slots for a projection. A slot can be either based on a parsed CSS selector
  * which will be used to determine nodes which are projected into that slot.
@@ -6629,17 +6778,18 @@ declare class R3Injector extends EnvironmentInjector {
      * hook was found.
      */
     destroy(): void;
-    onDestroy(callback: () => void): void;
+    onDestroy(callback: () => void): () => void;
     runInContext<ReturnT>(fn: () => ReturnT): ReturnT;
     get<T>(token: ProviderToken<T>, notFoundValue?: any, flags?: InjectFlags | InjectOptions): T;
     toString(): string;
-    private assertNotDestroyed;
+    assertNotDestroyed(): void;
     /**
      * Process a `SingleProvider` and add it.
      */
     private processProvider;
     private hydrate;
     private injectableDefInScope;
+    private removeOnDestroy;
 }
 
 declare interface RComment extends RNode {
@@ -7418,6 +7568,20 @@ declare interface RText extends RNode {
     textContent: string | null;
 }
 
+/**
+ * Runs the given function in the context of the given `Injector`.
+ *
+ * Within the function's stack frame, `inject` can be used to inject dependencies from the given
+ * `Injector`. Note that `inject` is only usable synchronously, and cannot be used in any
+ * asynchronous callbacks or after any `await` points.
+ *
+ * @param injector the injector which will satisfy calls to `inject` while `fn` is executing
+ * @param fn the closure to be run in the context of `injector`
+ * @returns the return value of the function, if any
+ * @publicApi
+ */
+export declare function runInInjectionContext<ReturnT>(injector: Injector, fn: () => ReturnT): ReturnT;
+
 
 /**
  * The list of error codes used in runtime code of the `core` package.
@@ -7456,12 +7620,18 @@ declare const enum RuntimeErrorCode {
     HOST_DIRECTIVE_CONFLICTING_ALIAS = 312,
     MULTIPLE_PLATFORMS = 400,
     PLATFORM_NOT_FOUND = 401,
-    ERROR_HANDLER_NOT_FOUND = 402,
+    MISSING_REQUIRED_INJECTABLE_IN_BOOTSTRAP = 402,
     BOOTSTRAP_COMPONENTS_NOT_FOUND = -403,
     PLATFORM_ALREADY_DESTROYED = 404,
     ASYNC_INITIALIZERS_STILL_RUNNING = 405,
     APPLICATION_REF_ALREADY_DESTROYED = 406,
     RENDERER_NOT_FOUND = 407,
+    HYDRATION_NODE_MISMATCH = 500,
+    HYDRATION_MISSING_SIBLINGS = 501,
+    HYDRATION_MISSING_NODE = 502,
+    UNSUPPORTED_PROJECTION_DOM_NODES = 503,
+    INVALID_SKIP_HYDRATION_HOST = 504,
+    HYDRATION_I18N_NOT_YET_SUPPORTED = 518,
     INVALID_I18N_STRUCTURE = 700,
     MISSING_LOCALE_DATA = 701,
     IMPORT_PROVIDERS_FROM_STANDALONE = 800,
@@ -7588,8 +7758,36 @@ export declare interface SelfDecorator {
 }
 
 /**
- * Represents element containers within this view, stored as key-value pairs
- * where key is an index of a container in an LView (also used in the
+ * Serialized data structure that contains relevant hydration
+ * annotation information about a view that is a part of a
+ * ViewContainer collection.
+ */
+declare interface SerializedContainerView extends SerializedView {
+    /**
+     * Unique id that represents a TView that was used to create
+     * a given instance of a view:
+     *  - TViewType.Embedded: a unique id generated during serialization on the server
+     *  - TViewType.Component: an id generated based on component properties
+     *                        (see `getComponentId` function for details)
+     */
+    [TEMPLATE_ID]: string;
+    /**
+     * Number of root nodes that belong to this view.
+     * This information is needed to effectively traverse the DOM tree
+     * and identify segments that belong to different views.
+     */
+    [NUM_ROOT_NODES]: number;
+    /**
+     * Number of times this view is repeated.
+     * This is used to avoid serializing and sending the same hydration
+     * information about similar views (for example, produced by *ngFor).
+     */
+    [MULTIPLIER]?: number;
+}
+
+/**
+ * Represents element containers within this view, stored as key-value pairs
+ * where key is an index of a container in an LView (also used in the
  * `elementContainerStart` instruction), the value is the number of root nodes
  * in this container. This information is needed to locate an anchor comment
  * node that goes after all container nodes.
@@ -7608,6 +7806,36 @@ declare interface SerializedView {
      * Serialized information about <ng-container>s.
      */
     [ELEMENT_CONTAINERS]?: SerializedElementContainers;
+    /**
+     * Serialized information about templates.
+     * Key-value pairs where a key is an index of the corresponding
+     * `template` instruction and the value is a unique id that can
+     * be used during hydration to identify that template.
+     */
+    [TEMPLATES]?: Record<number, string>;
+    /**
+     * Serialized information about view containers.
+     * Key-value pairs where a key is an index of the corresponding
+     * LContainer entry within an LView, and the value is a list
+     * of serialized information about views within this container.
+     */
+    [CONTAINERS]?: Record<number, SerializedContainerView[]>;
+    /**
+     * Serialized information about nodes in a template.
+     * Key-value pairs where a key is an index of the corresponding
+     * DOM node in an LView and the value is a path that describes
+     * the location of this node (as a set of navigation instructions).
+     */
+    [NODES]?: Record<number, string>;
+    /**
+     * A list of ids which represents a set of nodes disconnected
+     * from the DOM tree at the serialization time, but otherwise
+     * present in the internal data structures.
+     *
+     * This information is used to avoid triggering the hydration
+     * logic for such nodes and instead use a regular "creation mode".
+     */
+    [DISCONNECTED_NODES]?: number[];
 }
 
 /**
@@ -7922,6 +8150,8 @@ declare interface TElementNode extends TNode {
     value: string;
 }
 
+declare const TEMPLATE_ID = "i";
+
 /**
  * Represents an embedded template that can be used to instantiate embedded views.
  * To instantiate embedded views based on a template, use the `ViewContainerRef`
@@ -7963,6 +8193,8 @@ export declare abstract class TemplateRef<C> {
     abstract createEmbeddedView(context: C, injector?: Injector): EmbeddedViewRef<C>;
 }
 
+declare const TEMPLATES = "t";
+
 /**
  * The Testability service provides testing hooks that can be accessed from
  * the browser.
@@ -9277,6 +9509,13 @@ declare interface TView {
      * view. This means that the view is likely corrupted and we should try to recover it.
      */
     incompleteFirstPass: boolean;
+    /**
+     * Unique id of this TView for hydration purposes:
+     * - TViewType.Embedded: a unique id generated during serialization on the server
+     * - TViewType.Component: an id generated based on component properties
+     *                        (see `getComponentId` function for details)
+     */
+    ssrId: string | null;
 }
 
 /**
@@ -9815,9 +10054,6 @@ declare enum ViewEncapsulation_2 {
     ShadowDom = 3
 }
 
-declare interface viewEngine_ChangeDetectorRef_interface extends ChangeDetectorRef {
-}
-
 /**
  * Definition of what a view queries function should look like.
  */
@@ -9864,8 +10100,6 @@ declare interface WeakRef<T extends object> {
     deref(): T | undefined;
 }
 
-declare const WeakRef: WeakRefCtor;
-
 declare interface WeakRefCtor {
     new <T extends object>(value: T): WeakRef<T>;
 }
@@ -9906,16 +10140,6 @@ export declare function ɵallowSanitizationBypassAndThrow(value: any, type: ɵBy
  */
 export declare function ɵannotateForHydration(appRef: ApplicationRef, doc: Document): void;
 
-/**
- * Providers that generate a random `APP_ID_TOKEN`.
- * @publicApi
- */
-export declare const ɵAPP_ID_RANDOM_PROVIDER: {
-    provide: InjectionToken<string>;
-    useFactory: typeof _appIdRandomProviderFactory;
-    deps: any[];
-};
-
 /**
  * A set of marker values to be used in the attributes arrays. These markers indicate that some
  * items are not regular attributes and the processing should be adapted accordingly.
@@ -10498,13 +10722,6 @@ export declare function ɵflushModuleScopingQueueAsMuchAsPossible(): void;
  */
 export declare function ɵformatRuntimeError<T extends number = RuntimeErrorCode>(code: T, message: null | false | string): string;
 
-/**
- * The following getter methods retrieve the definition from the type. Currently the retrieval
- * honors inheritance, but in the future we may change the rule to require that definitions are
- * explicit. This would require some sort of migration strategy.
- */
-export declare function ɵgetComponentDef<T>(type: any): ɵComponentDef<T> | null;
-
 /**
  * Retrieves directive instances associated with a given DOM node. Does not include
  * component instances.
@@ -10896,9 +11113,9 @@ export declare const ɵNO_CHANGE: ɵNO_CHANGE;
  * to framework to perform rendering.
  */
 export declare class ɵNoopNgZone implements NgZone {
-    readonly hasPendingMicrotasks: boolean;
-    readonly hasPendingMacrotasks: boolean;
-    readonly isStable: boolean;
+    readonly hasPendingMicrotasks = false;
+    readonly hasPendingMacrotasks = false;
+    readonly isStable = true;
     readonly onUnstable: EventEmitter<any>;
     readonly onMicrotaskEmpty: EventEmitter<any>;
     readonly onStable: EventEmitter<any>;
@@ -11069,6 +11286,8 @@ export declare const enum ɵProfilerEvent {
  */
 export declare function ɵprovideHydrationSupport(): EnvironmentProviders;
 
+export declare function ɵprovideNgZoneChangeDetection(ngZone: NgZone): StaticProvider[];
+
 /**
  * Publishes a collection of default debug tools onto`window.ng`.
  *
@@ -11166,7 +11385,7 @@ export declare class ɵRender3NgModuleRef<T> extends NgModuleRef<T> implements I
     instance: T;
     destroyCbs: (() => void)[] | null;
     readonly componentFactoryResolver: ComponentFactoryResolver_2;
-    constructor(ngModuleType: Type<T>, _parent: Injector | null);
+    constructor(ngModuleType: Type<T>, _parent: Injector | null, additionalProviders: StaticProvider[]);
     get injector(): EnvironmentInjector;
     destroy(): void;
     onDestroy(callback: () => void): void;
@@ -11302,6 +11521,11 @@ export declare interface ɵSafeValue {
  */
 export declare function ɵsetAllowDuplicateNgModuleIdsForTest(allowDuplicates: boolean): void;
 
+/**
+ * Use an alternate implementation of `WeakRef` if a platform implementation isn't available.
+ */
+export declare function ɵsetAlternateWeakRefImpl(impl: WeakRefCtor): void;
+
 /**
  * Adds decorator, constructor, and property metadata to a given type via static metadata fields
  * on the type.
@@ -11458,7 +11682,7 @@ export declare function ɵunwrapSafeValue(value: ɵSafeValue): string;
 
 export declare function ɵunwrapSafeValue<T>(value: T): T;
 
-export declare class ɵViewRef<T> implements EmbeddedViewRef<T>, InternalViewRef, viewEngine_ChangeDetectorRef_interface {
+export declare class ɵViewRef<T> implements EmbeddedViewRef<T>, InternalViewRef, ChangeDetectorRefInterface {
     /**
      * This represents the `LView` associated with the point where `ChangeDetectorRef` was
      * requested.
@@ -12329,7 +12553,10 @@ export declare function ɵɵclassProp(className: string, value: boolean | undefi
  * @publicApi
  */
 export declare type ɵɵComponentDeclaration<T, Selector extends String, ExportAs extends string[], InputMap extends {
-    [key: string]: string;
+    [key: string]: string | {
+        alias: string | null;
+        required: boolean;
+    };
 }, OutputMap extends {
     [key: string]: string;
 }, QueryFields extends string[], NgContentSelectors extends string[], IsStandalone extends boolean = false, HostDirectives = never> = unknown;
@@ -12372,7 +12599,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({
@@ -12382,230 +12609,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.
@@ -12623,132 +12627,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
@@ -12852,7 +12731,10 @@ export declare function ɵɵdefinePipe<T>(pipeDef: {
  * @publicApi
  */
 export declare type ɵɵDirectiveDeclaration<T, Selector extends string, ExportAs extends string[], InputMap extends {
-    [key: string]: string;
+    [key: string]: string | {
+        alias: string | null;
+        required: boolean;
+    };
 }, OutputMap extends {
     [key: string]: string;
 }, QueryFields extends string[], NgContentSelectors extends never = never, IsStandalone extends boolean = false, HostDirectives = never> = unknown;