@angular/core 17.1.0-next.5 → 17.1.0-rc.0

package/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @license Angular v17.1.0-next.5
+ * @license Angular v17.1.0-rc.0
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -9,6 +9,7 @@ import { BehaviorSubject } from 'rxjs';
 import { Observable } from 'rxjs';
 import { ReactiveNode } from '@angular/core/primitives/signals';
 import { SIGNAL } from '@angular/core/primitives/signals';
+import { SignalNode } from '@angular/core/primitives/signals';
 import { Subject } from 'rxjs';
 import { Subscribable } from 'rxjs';
 import { Subscription } from 'rxjs';
@@ -642,6 +643,7 @@ export declare class ApplicationRef {
     private _destroyed;
     private _destroyListeners;
     private readonly internalErrorHandler;
+    private readonly afterRenderEffectManager;
     /**
      * Indicates whether this instance was destroyed.
      */
@@ -787,6 +789,18 @@ export declare class ApplicationRef {
     static ɵprov: i0.ɵɵInjectableDeclaration<ApplicationRef>;
 }
 
+
+/**
+ * Marks a component for check (in case of OnPush components) and synchronously
+ * performs change detection on the application this component belongs to.
+ *
+ * @param component Component to {@link ChangeDetectorRef#markForCheck mark for check}.
+ *
+ * @publicApi
+ * @globalApi ng
+ */
+declare function applyChanges(component: {}): void;
+
 /**
  * @publicApi
  */
@@ -3040,6 +3054,18 @@ export declare interface Directive {
  */
 export declare const Directive: DirectiveDecorator;
 
+/**
+ * Partial metadata for a given directive instance.
+ * This information might be useful for debugging purposes or tooling.
+ * Currently only `inputs` and `outputs` metadata is available.
+ *
+ * @publicApi
+ */
+declare interface DirectiveDebugMetadata {
+    inputs: Record<string, string>;
+    outputs: Record<string, string>;
+}
+
 /**
  * Type of the Directive decorator / constructor function.
  * @publicApi
@@ -3151,63 +3177,8 @@ declare interface DirectiveDefinition<T> {
     selectors?: ɵCssSelectorList;
     /**
      * A map of input names.
-     *
-     * The format is in: `{[actualPropertyName: string]:(string|[string, string, Function])}`.
-     *
-     * Given:
-     * ```
-     * class MyComponent {
-     *   @Input()
-     *   publicInput1: string;
-     *
-     *   @Input('publicInput2')
-     *   declaredInput2: string;
-     *
-     *   @Input({transform: (value: boolean) => value ? 1 : 0})
-     *   transformedInput3: number;
-     * }
-     * ```
-     *
-     * is described as:
-     * ```
-     * {
-     *   publicInput1: 'publicInput1',
-     *   declaredInput2: ['declaredInput2', 'publicInput2'],
-     *   transformedInput3: [
-     *     'transformedInput3',
-     *     'transformedInput3',
-     *     (value: boolean) => value ? 1 : 0
-     *   ]
-     * }
-     * ```
-     *
-     * Which the minifier may translate to:
-     * ```
-     * {
-     *   minifiedPublicInput1: 'publicInput1',
-     *   minifiedDeclaredInput2: [ 'publicInput2', 'declaredInput2'],
-     *   minifiedTransformedInput3: [
-     *     'transformedInput3',
-     *     'transformedInput3',
-     *     (value: boolean) => value ? 1 : 0
-     *   ]
-     * }
-     * ```
-     *
-     * 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, InputTransformFunction?];
-    };
+    inputs?: DirectiveInputs<T>;
     /**
      * A map of output names.
      *
@@ -3303,6 +3274,75 @@ declare type DirectiveDefList = (ɵDirectiveDef<any> | ɵComponentDef<any>)[];
  */
 declare type DirectiveDefListOrFactory = (() => DirectiveDefList) | DirectiveDefList;
 
+/**
+ * Map of inputs for a given directive/component.
+ *
+ * Given:
+ * ```
+ * class MyComponent {
+ *   @Input()
+ *   publicInput1: string;
+ *
+ *   @Input('publicInput2')
+ *   declaredInput2: string;
+ *
+ *   @Input({transform: (value: boolean) => value ? 1 : 0})
+ *   transformedInput3: number;
+ *
+ *   signalInput = input(3);
+ * }
+ * ```
+ *
+ * is described as:
+ * ```
+ * {
+ *   publicInput1: 'publicInput1',
+ *   declaredInput2: [InputFlags.None, 'declaredInput2', 'publicInput2'],
+ *   transformedInput3: [
+ *     InputFlags.None,
+ *     'transformedInput3',
+ *     'transformedInput3',
+ *     (value: boolean) => value ? 1 : 0
+ *   ],
+ *   signalInput: [InputFlags.SignalBased, "signalInput"],
+ * }
+ * ```
+ *
+ * Which the minifier may translate to:
+ * ```
+ * {
+ *   minifiedPublicInput1: 'publicInput1',
+ *   minifiedDeclaredInput2: [InputFlags.None, 'publicInput2', 'declaredInput2'],
+ *   minifiedTransformedInput3: [
+ *     InputFlags.None,
+ *     'transformedInput3',
+ *     'transformedInput3',
+ *     (value: boolean) => value ? 1 : 0
+ *   ],
+ *   minifiedSignalInput: [InputFlags.SignalBased, "signalInput"],
+ * }
+ * ```
+ *
+ * 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, or there is a transform.
+ *  - 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`.
+ */
+declare type DirectiveInputs<T> = {
+    [P in keyof T]?: string | [
+    flags: ɵɵInputFlags,
+    publicName: string,
+    declaredName?: string,
+    transform?: InputTransformFunction
+    ];
+};
+
 declare const DISCONNECTED_NODES = "d";
 
 /**
@@ -3910,6 +3950,49 @@ export declare interface ForwardRefFn {
     (): any;
 }
 
+/**
+ * Retrieves the component instance associated with a given DOM element.
+ *
+ * @usageNotes
+ * Given the following DOM structure:
+ *
+ * ```html
+ * <app-root>
+ *   <div>
+ *     <child-comp></child-comp>
+ *   </div>
+ * </app-root>
+ * ```
+ *
+ * Calling `getComponent` on `<child-comp>` will return the instance of `ChildComponent`
+ * associated with this DOM element.
+ *
+ * Calling the function on `<app-root>` will return the `MyApp` instance.
+ *
+ *
+ * @param element DOM element from which the component should be retrieved.
+ * @returns Component instance associated with the element or `null` if there
+ *    is no component associated with it.
+ *
+ * @publicApi
+ * @globalApi ng
+ */
+declare function getComponent<T>(element: Element): T | null;
+
+/**
+ * If inside an embedded view (e.g. `*ngIf` or `*ngFor`), retrieves the context of the embedded
+ * view that the element is part of. Otherwise retrieves the instance of the component whose view
+ * owns the element (in this case, the result is the same as calling `getOwningComponent`).
+ *
+ * @param element Element for which to get the surrounding component instance.
+ * @returns Instance of the component that is around the element or null if the element isn't
+ *    inside any component.
+ *
+ * @publicApi
+ * @globalApi ng
+ */
+declare function getContext<T extends {}>(element: Element): T | null;
+
 /**
  * @publicApi
  */
@@ -3917,6 +4000,115 @@ declare function getDebugNode(nativeNode: any): DebugNode | null;
 export { getDebugNode }
 export { getDebugNode as ɵgetDebugNode }
 
+/**
+ * Discovers the dependencies of an injectable instance. Provides DI information about each
+ * dependency that the injectable was instantiated with, including where they were provided from.
+ *
+ * @param injector An injector instance
+ * @param token a DI token that was constructed by the given injector instance
+ * @returns an object that contains the created instance of token as well as all of the dependencies
+ * that it was instantiated with OR undefined if the token was not created within the given
+ * injector.
+ */
+declare function getDependenciesFromInjectable<T>(injector: Injector, token: Type<T> | InjectionToken<T>): {
+    instance: T;
+    dependencies: Omit<InjectedService, 'injectedIn'>[];
+} | undefined;
+
+/**
+ * Returns the debug (partial) metadata for a particular directive or component instance.
+ * The function accepts an instance of a directive or component and returns the corresponding
+ * metadata.
+ *
+ * @param directiveOrComponentInstance Instance of a directive or component
+ * @returns metadata of the passed directive or component
+ *
+ * @publicApi
+ * @globalApi ng
+ */
+declare function getDirectiveMetadata(directiveOrComponentInstance: any): ɵComponentDebugMetadata | DirectiveDebugMetadata | null;
+
+/**
+ * Retrieves an `Injector` associated with an element, component or directive instance.
+ *
+ * @param elementOrDir DOM element, component or directive instance for which to
+ *    retrieve the injector.
+ * @returns Injector associated with the element, component or directive instance.
+ *
+ * @publicApi
+ * @globalApi ng
+ */
+declare function getInjector(elementOrDir: Element | {}): Injector;
+
+/**
+ *
+ * Given an injector, this function will return
+ * an object containing the type and source of the injector.
+ *
+ * |              | type        | source                                                      |
+ * |--------------|-------------|-------------------------------------------------------------|
+ * | NodeInjector | element     | DOM element that created this injector                      |
+ * | R3Injector   | environment | `injector.source`                                           |
+ * | NullInjector | null        | null                                                        |
+ *
+ * @param injector the Injector to get metadata for
+ * @returns an object containing the type and source of the given injector. If the injector metadata
+ *     cannot be determined, returns null.
+ */
+declare function getInjectorMetadata(injector: Injector): {
+    type: 'element';
+    source: RElement;
+} | {
+    type: 'environment';
+    source: string | null;
+} | {
+    type: 'null';
+    source: null;
+} | null;
+
+/**
+ * Gets the providers configured on an injector.
+ *
+ * @param injector the injector to lookup the providers of
+ * @returns ProviderRecord[] an array of objects representing the providers of the given injector
+ */
+declare function getInjectorProviders(injector: Injector): ɵProviderRecord[];
+
+declare function getInjectorResolutionPath(injector: Injector): Injector[];
+
+/**
+ * Retrieves a list of event listeners associated with a DOM element. The list does include host
+ * listeners, but it does not include event listeners defined outside of the Angular context
+ * (e.g. through `addEventListener`).
+ *
+ * @usageNotes
+ * Given the following DOM structure:
+ *
+ * ```html
+ * <app-root>
+ *   <div (click)="doSomething()"></div>
+ * </app-root>
+ * ```
+ *
+ * Calling `getListeners` on `<div>` will return an object that looks as follows:
+ *
+ * ```ts
+ * {
+ *   name: 'click',
+ *   element: <div>,
+ *   callback: () => doSomething(),
+ *   useCapture: false
+ * }
+ * ```
+ *
+ * @param element Element for which the DOM listeners should be retrieved.
+ * @returns Array of event listeners on the DOM element.
+ *
+ * @publicApi
+ * @globalApi ng
+ */
+declare function getListeners(element: Element): Listener[];
+
 /**
  * Returns the NgModuleFactory with the given id (specified using [@NgModule.id
  * field](api/core/NgModule#id)), if it exists and has been loaded. Factories for NgModules that do
@@ -3934,6 +4126,23 @@ export declare function getModuleFactory(id: string): NgModuleFactory<any>;
  */
 export declare function getNgModuleById<T>(id: string): Type<T>;
 
+/**
+ * Retrieves the component instance whose view contains the DOM element.
+ *
+ * For example, if `<child-comp>` is used in the template of `<app-comp>`
+ * (i.e. a `ViewChild` of `<app-comp>`), calling `getOwningComponent` on `<child-comp>`
+ * would return `<app-comp>`.
+ *
+ * @param elementOrDir DOM element, component or directive instance
+ *    for which to retrieve the root components.
+ * @returns Component instance whose view owns the DOM element or null if the element is not
+ *    part of a component view.
+ *
+ * @publicApi
+ * @globalApi ng
+ */
+declare function getOwningComponent<T>(elementOrDir: Element | {}): T | null;
+
 /**
  * Returns the current platform.
  *
@@ -3941,6 +4150,19 @@ export declare function getNgModuleById<T>(id: string): Type<T>;
  */
 export declare function getPlatform(): PlatformRef | null;
 
+/**
+ * Retrieves all root components associated with a DOM element, directive or component instance.
+ * Root components are those which have been bootstrapped by Angular.
+ *
+ * @param elementOrDir DOM element, component or directive instance
+ *    for which to retrieve the root components.
+ * @returns Root components associated with the target object.
+ *
+ * @publicApi
+ * @globalApi ng
+ */
+declare function getRootComponents(elementOrDir: Element | {}): {}[];
+
 /**
  * Adapter interface for retrieving the `Testability` service associated for a
  * particular context.
@@ -3952,6 +4174,12 @@ export declare interface GetTestability {
     findTestabilityInTree(registry: TestabilityRegistry, elem: any, findInAncestors: boolean): Testability | null;
 }
 
+/**
+ * This value reflects the property on the window where the dev
+ * tools are patched (window.ng).
+ * */
+declare const GLOBAL_PUBLISH_EXPANDO_KEY = "ng";
+
 /**
  * The goal here is to make sure that the browser DOM API is the Renderer.
  * We do this by defining a subset of DOM API to be the renderer and then
@@ -3964,6 +4192,29 @@ declare type GlobalTargetName = 'document' | 'window' | 'body';
 
 declare type GlobalTargetResolver = (element: any) => EventTarget;
 
+declare const globalUtilsFunctions: {
+    /**
+     * Warning: functions that start with `ɵ` are considered *INTERNAL* and should not be relied upon
+     * in application's code. The contract of those functions might be changed in any release and/or a
+     * function can be removed completely.
+     */
+    ɵgetDependenciesFromInjectable: typeof getDependenciesFromInjectable;
+    ɵgetInjectorProviders: typeof getInjectorProviders;
+    ɵgetInjectorResolutionPath: typeof getInjectorResolutionPath;
+    ɵgetInjectorMetadata: typeof getInjectorMetadata;
+    ɵsetProfiler: (profiler: ɵProfiler | null) => void;
+    getDirectiveMetadata: typeof getDirectiveMetadata;
+    getComponent: typeof getComponent;
+    getContext: typeof getContext;
+    getListeners: typeof getListeners;
+    getOwningComponent: typeof getOwningComponent;
+    getHostElement: typeof ɵgetHostElement;
+    getInjector: typeof getInjector;
+    getRootComponents: typeof getRootComponents;
+    getDirectives: typeof ɵgetDirectives;
+    applyChanges: typeof applyChanges;
+};
+
 /**
  * Array of hooks that should be executed for a view and their directive indices.
  *
@@ -4621,11 +4872,12 @@ declare type InitialInputData = (InitialInputs | null)[];
  *
  * i+0: attribute name
  * i+1: minified/internal input name
- * i+2: initial value
+ * i+2: input flags
+ * i+3: initial value
  *
  * e.g. ['role-min', 'minified-input', 'button']
  */
-declare type InitialInputs = string[];
+declare type InitialInputs = (string | ɵɵInputFlags)[];
 
 /**
  * Type of the Inject metadata.
@@ -4816,6 +5068,36 @@ export declare interface InjectDecorator {
     new (token: any): Inject;
 }
 
+/**
+ * An object that contains information a service that has been injected within an
+ * InjectorProfilerContext
+ */
+declare interface InjectedService {
+    /**
+     * DI token of the Service that is injected
+     */
+    token?: Type<unknown> | InjectionToken<unknown>;
+    /**
+     * Value of the injected service
+     */
+    value: unknown;
+    /**
+     * Flags that this service was injected with
+     */
+    flags?: InternalInjectFlags | InjectFlags | InjectOptions;
+    /**
+     * Injector that this service was provided in.
+     */
+    providedIn?: Injector;
+    /**
+     * In NodeInjectors, the LView and TNode that serviced this injection.
+     */
+    injectedIn?: {
+        lView: LView;
+        tNode: TNode;
+    };
+}
+
 /**
  * Injection flags for DI.
  *
@@ -5087,6 +5369,33 @@ export declare interface Input {
  */
 export declare const Input: InputDecorator;
 
+/**
+ * The `input` function allows declaration of inputs in directives and
+ * components.
+ *
+ * Initializes an input with an initial value. If no explicit value
+ * is specified, Angular will use `undefined`.
+ *
+ * Consider using `input.required` for inputs that don't need an
+ * initial value.
+ *
+ * @usageNotes
+ * Initialize an input in your directive or component by declaring a
+ * class field and initializing it with the `input()` function.
+ *
+ * ```ts
+ * @Directive({..})
+ * export class MyDir {
+ *   firstName = input<string>();            // string|undefined
+ *   lastName = input.required<string>();    // string
+ *   age = input(0);                         // number
+ * }
+ * ```
+ *
+ * @developerPreview
+ */
+export declare const input: InputFunction;
+
 /**
  * @publicApi
  */
@@ -5146,17 +5455,128 @@ export declare interface InputDecorator {
     new (arg?: string | Input): any;
 }
 
+/**
+ * The `input` function allows declaration of inputs in directives and
+ * components.
+ *
+ * The function exposes an API for also declaring required inputs via the
+ * `input.required` function.
+ *
+ * @usageNotes
+ * Initialize an input in your directive or component by declaring a
+ * class field and initializing it with the `input()` or `input.required()`
+ * function.
+ *
+ * ```ts
+ * @Directive({..})
+ * export class MyDir {
+ *   firstName = input<string>();            // string|undefined
+ *   lastName = input.required<string>();    // string
+ *   age = input(0);                         // number
+ * }
+ * ```
+ *
+ * @developerPreview
+ */
+export declare interface InputFunction {
+    /**
+     * Initializes an input with an initial value. If no explicit value
+     * is specified, Angular will use `undefined`.
+     *
+     * Consider using `input.required` for inputs that don't need an
+     * initial value.
+     *
+     * @developerPreview
+     */
+    <ReadT>(): InputSignal<ReadT | undefined>;
+    <ReadT>(initialValue: ReadT, opts?: InputOptionsWithoutTransform<ReadT>): InputSignal<ReadT>;
+    <ReadT, WriteT>(initialValue: ReadT, opts: InputOptionsWithTransform<ReadT, WriteT>): InputSignal<ReadT, WriteT>;
+    /**
+     * Initializes a required input.
+     *
+     * Users of your directive/component need to bind to this
+     * input. If unset, a compile time error will be reported.
+     *
+     * @developerPreview
+     */
+    required: {
+        <ReadT>(opts?: InputOptionsWithoutTransform<ReadT>): InputSignal<ReadT>;
+        <ReadT, WriteT>(opts: InputOptionsWithTransform<ReadT, WriteT>): InputSignal<ReadT, WriteT>;
+    };
+}
+
+/**
+ * @developerPreview
+ *
+ * Options for signal inputs.
+ */
+export declare interface InputOptions<ReadT, WriteT> {
+    /** Optional public name for the input. By default, the class field name is used. */
+    alias?: string;
+    /**
+     * Optional transform that runs whenever a new value is bound. Can be used to
+     * transform the input value before the input is updated.
+     *
+     * The transform function can widen the type of the input. For example, consider
+     * an input for `disabled`. In practice, as the component author, you want to only
+     * deal with a boolean, but users may want to bind a string if they just use the
+     * attribute form to bind to the input via `<my-dir input>`. A transform can then
+     * handle such string values and convert them to `boolean`. See: {@link booleanAttribute}.
+     */
+    transform?: (v: WriteT) => ReadT;
+}
+
+/**
+ * Signal input options without the transform option.
+ *
+ * @developerPreview
+ */
+export declare type InputOptionsWithoutTransform<ReadT> = Omit<InputOptions<ReadT, ReadT>, 'transform'> & {
+    transform?: undefined;
+};
+
+/**
+ * Signal input options with the transform option required.
+ *
+ * @developerPreview
+ */
+export declare type InputOptionsWithTransform<ReadT, WriteT> = Required<Pick<InputOptions<ReadT, WriteT>, 'transform'>> & InputOptions<ReadT, WriteT>;
+
 /**
  * `InputSignal` is represents a special `Signal` for a directive/component input.
  *
  * An input signal is similar to a non-writable signal except that it also
  * carries additional type-information for transforms, and that Angular internally
  * updates the signal whenever a new value is bound.
+ *
+ * @developerPreview
  */
-export declare type InputSignal<ReadT, WriteT = ReadT> = Signal<ReadT> & {
+export declare interface InputSignal<ReadT, WriteT = ReadT> extends Signal<ReadT> {
+    [SIGNAL]: InputSignalNode<ReadT, WriteT>;
     [ɵINPUT_SIGNAL_BRAND_READ_TYPE]: ReadT;
     [ɵINPUT_SIGNAL_BRAND_WRITE_TYPE]: WriteT;
-};
+}
+
+/**
+ * Reactive node type for an input signal. An input signal extends a signal.
+ * There are special properties to enable transforms and required inputs.
+ */
+declare interface InputSignalNode<ReadT, WriteT> extends SignalNode<ReadT | typeof REQUIRED_UNSET_VALUE> {
+    /**
+     * User-configured transform that will run whenever a new value is applied
+     * to the input signal node.
+     */
+    transformFn: ((value: WriteT) => ReadT) | undefined;
+    /**
+     * Applies a new value to the input signal. Expects transforms to be run
+     * manually before.
+     *
+     * This function is called by the framework runtime code whenever a binding
+     * changes. The value can in practice be anything at runtime, but for typing
+     * purposes we assume it's a valid `ReadT` value. Type-checking will enforce that.
+     */
+    applyValueToInputSignal<ReadT, WriteT>(node: InputSignalNode<ReadT, WriteT>, value: ReadT): void;
+}
 
 /** Function that can be used to transform incoming input values. */
 declare type InputTransformFunction = (value: any) => any;
@@ -5178,6 +5598,37 @@ declare interface InternalAfterNextRenderOptions {
     injector?: Injector;
 }
 
+/**
+ * This enum is an exact copy of the `InjectFlags` enum above, but the difference is that this is a
+ * const enum, so actual enum values would be inlined in generated code. The `InjectFlags` enum can
+ * be turned into a const enum when ViewEngine is removed (see TODO at the `InjectFlags` enum
+ * above). The benefit of inlining is that we can use these flags at the top level without affecting
+ * tree-shaking (see "no-toplevel-property-access" tslint rule for more info).
+ * Keep this enum in sync with `InjectFlags` enum above.
+ */
+declare const enum InternalInjectFlags {
+    /** Check self and check parent injector if needed */
+    Default = 0,
+    /**
+     * Specifies that an injector should retrieve a dependency from any injector until reaching the
+     * host element of the current component. (Only used with Element Injector)
+     */
+    Host = 1,
+    /** Don't ascend to ancestors of the node requesting injection. */
+    Self = 2,
+    /** Skip the node that is requesting injection. */
+    SkipSelf = 4,
+    /** Inject `defaultValue` instead if token not found. */
+    Optional = 8,
+    /**
+     * This token is being injected into a pipe.
+     *
+     * This flag is intentionally not in the public facing `InjectFlags` because it is only added by
+     * the compiler and is not a developer applicable flag.
+     */
+    ForPipe = 16
+}
+
 declare interface InternalNgModuleRef<T> extends NgModuleRef<T> {
     _bootstrapComponents: Type<any>[];
 }
@@ -5571,16 +6022,30 @@ declare enum LContainerFlags {
      *
      * This flag, once set, is never unset for the `LContainer`.
      */
-    HasTransplantedViews = 2,
-    /**
-     * Indicates that this LContainer has a view underneath it that needs to be refreshed during
-     * change detection.
-     */
-    HasChildViewsToRefresh = 4
+    HasTransplantedViews = 2
 }
 
 declare type LegacyInputPartialMapping = string | [bindingPropertyName: string, classPropertyName: string, transformFunction?: Function];
 
+/**
+ * Event listener configuration returned from `getListeners`.
+ * @publicApi
+ */
+declare interface Listener {
+    /** Name of the event listener. */
+    name: string;
+    /** Element that the listener is bound to. */
+    element: Element;
+    /** Callback that is invoked when the event is triggered. */
+    callback: (value: any) => any;
+    /** Whether the listener is using event capturing. */
+    useCapture: boolean;
+    /**
+     * Type of the listener (e.g. a native DOM event or a custom @Output).
+     */
+    type: 'dom' | 'output';
+}
+
 /**
  * Provide this token to set the locale of your application.
  * It is used for i18n extraction, by i18n pipes (DatePipe, I18nPluralPipe, CurrencyPipe,
@@ -6625,6 +7090,39 @@ export declare interface NgZoneOptions {
  */
 export declare const NO_ERRORS_SCHEMA: SchemaMetadata;
 
+/**
+ * Store the runtime input for all directives applied to a node.
+ *
+ * This allows efficiently setting the same input on a directive that
+ * might apply to multiple directives.
+ *
+ * i+0: directive instance index
+ * i+1: privateName
+ * i+2: input flags
+ *
+ * e.g.
+ * ```
+ * {
+ *   "publicName": [0, 'change-minified', <bit-input-flags>]
+ * }
+ * ```
+ */
+declare type NodeInputBindings = Record<string, (number | string | ɵɵInputFlags)[]>;
+
+/**
+ * Store the runtime output names for all the directives.
+ *
+ * i+0: directive instance index
+ * i+1: privateName
+ *
+ * e.g.
+ * ```
+ * {
+ *   "publicName": [0, 'change-minified']
+ * }
+ */
+declare type NodeOutputBindings = Record<string, (number | string)[]>;
+
 declare const NODES = "n";
 
 declare const NUM_ROOT_NODES = "r";
@@ -7087,30 +7585,6 @@ declare type ProcessProvidersFunction = (providers: Provider[]) => Provider[];
  */
 declare type ProjectionSlots = (ɵCssSelectorList | '*')[];
 
-/**
- * This mapping is necessary so we can set input properties and output listeners
- * properly at runtime when property names are minified or aliased.
- *
- * Key: unminified / public input or output name
- * Value: array containing minified / internal name and related directive index
- *
- * The value must be an array to support inputs and outputs with the same name
- * on the same node.
- */
-declare type PropertyAliases = {
-    [key: string]: PropertyAliasValue;
-};
-
-/**
- * Store the runtime input or output names for all the directives.
- *
- * i+0: directive instance index
- * i+1: privateName
- *
- * e.g. [0, 'change-minified']
- */
-declare type PropertyAliasValue = (number | string)[];
-
 /**
  * Describes how the `Injector` should be configured.
  * @see ["Dependency Injection Guide"](guide/dependency-injection).
@@ -7903,6 +8377,8 @@ export declare interface RendererType2 {
     };
 }
 
+declare const REQUIRED_UNSET_VALUE: unique symbol;
+
 /**
  * Lazily retrieves the reference value from a forwardRef.
  *
@@ -8249,6 +8725,11 @@ export declare interface SimpleChanges {
     [propName: string]: SimpleChange;
 }
 
+/**
+ * Internal type for a single provider in a deep provider array.
+ */
+declare type SingleProvider = TypeProvider | ValueProvider | ClassProvider | ConstructorProvider | ExistingProvider | FactoryProvider | StaticClassProvider;
+
 /**
  * Type of the `SkipSelf` metadata.
  *
@@ -8973,12 +9454,12 @@ declare interface TNode {
      * Input data for all directives on this node. `null` means that there are no directives with
      * inputs on this node.
      */
-    inputs: PropertyAliases | null;
+    inputs: NodeInputBindings | null;
     /**
      * Output data for all directives on this node. `null` means that there are no directives with
      * outputs on this node.
      */
-    outputs: PropertyAliases | null;
+    outputs: NodeOutputBindings | null;
     /**
      * The TView attached to this node.
      *
@@ -10622,17 +11103,10 @@ export declare function ɵ_sanitizeUrl(url: string): string;
  * Delegates to an optional `AfterRenderCallbackHandler` for implementation.
  */
 export declare class ɵAfterRenderEventManager {
-    private renderDepth;
     /**
-     * Mark the beginning of a render operation (i.e. CD cycle).
-     * Throws if called while executing callbacks.
+     * Executes callbacks. Returns `true` if any callbacks executed.
      */
-    begin(): void;
-    /**
-     * Mark the end of a render operation. Callbacks will be
-     * executed if there are no more pending operations.
-     */
-    end(): void;
+    execute(): boolean;
     ngOnDestroy(): void;
     /** @nocollapse */
     static ɵprov: unknown;
@@ -10917,6 +11391,22 @@ export declare function ɵcompileNgModuleFactory<M>(injector: Injector, options:
 
 export declare function ɵcompilePipe(type: Type<any>, meta: Pipe): void;
 
+/**
+ * Partial metadata for a given component instance.
+ * This information might be useful for debugging purposes or tooling.
+ * Currently the following fields are available:
+ *  - inputs
+ *  - outputs
+ *  - encapsulation
+ *  - changeDetection
+ *
+ * @publicApi
+ */
+export declare interface ɵComponentDebugMetadata extends DirectiveDebugMetadata {
+    encapsulation: ViewEncapsulation;
+    changeDetection: ChangeDetectionStrategy;
+}
+
 /**
  * Runtime link information for Components.
  *
@@ -11192,12 +11682,11 @@ export declare function ɵdevModeEqual(a: any, b: any): boolean;
  */
 export declare interface ɵDirectiveDef<T> {
     /**
-     * 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;`).
+     * A dictionary mapping the inputs' public name to their minified property names
+     * (along with flags if there are any).
      */
     readonly inputs: {
-        [P in keyof T]: string;
+        [P in keyof T]?: string | [minifiedName: string, flags: ɵɵInputFlags];
     };
     /**
      * A dictionary mapping the private names of inputs to their transformation functions.
@@ -11215,22 +11704,20 @@ export declare interface ɵDirectiveDef<T> {
      * used to do further processing after the `inputs` have been inverted.
      */
     readonly inputConfig: {
-        [classPropertyName: string]: string | [string, string, InputTransformFunction?];
+        [P in keyof T]?: string | [ɵɵInputFlags, string, string?, InputTransformFunction?];
     };
     /**
      * @deprecated This is only here because `NgOnChanges` incorrectly uses declared name instead of
      * public or minified name.
      */
-    readonly declaredInputs: {
-        [P in keyof T]: string;
-    };
+    readonly declaredInputs: Record<string, string>;
     /**
      * 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;`).
      */
     readonly outputs: {
-        [P in keyof T]: string;
+        [P in keyof T]?: string;
     };
     /**
      * Function to create and refresh content queries associated with a given directive.
@@ -11328,7 +11815,7 @@ export declare interface ɵDirectiveDef<T> {
     findHostDirectiveDefs: ((currentDef: ɵDirectiveDef<unknown>, matchedDefs: ɵDirectiveDef<unknown>[], hostDirectiveDefs: HostDirectiveDefs) => void) | null;
     /** Additional directives to be applied whenever the directive has been matched. */
     hostDirectives: HostDirectiveDef[] | null;
-    setInput: (<U extends T>(this: ɵDirectiveDef<U>, instance: U, value: any, publicName: string, privateName: string) => void) | null;
+    setInput: (<U extends T>(this: ɵDirectiveDef<U>, instance: U, inputSignalNode: null | InputSignalNode<unknown, unknown>, value: any, publicName: string, privateName: string) => void) | null;
 }
 
 /**
@@ -11511,6 +11998,13 @@ export declare function ɵgetUnknownPropertyStrictMode(): boolean;
 
 export declare const ɵglobal: any;
 
+/**
+ * Default debug tools available under `window.ng`.
+ */
+export declare type ɵGlobalDevModeUtils = {
+    [GLOBAL_PUBLISH_EXPANDO_KEY]: typeof globalUtilsFunctions;
+};
+
 /**
  * Injection token that configures the image optimized image functionality.
  * See {@link ImageConfig} for additional information about parameters that
@@ -11571,116 +12065,10 @@ export declare interface ɵInjectorProfilerContext {
     token: Type<unknown> | null;
 }
 
-/**
- * Initializes an input with an initial value. If no explicit value
- * is specified, Angular will use `undefined`.
- *
- * Consider using `input.required` for inputs that don't need an
- * initial value.
- *
- * @usageNotes
- * Initialize an input in your directive or component by declaring a
- * class field and initializing it with the `input()` function.
- *
- * ```ts
- * @Directive({..})
- * export class MyDir {
- *   firstName = input<string>();            // string|undefined
- *   lastName = input.required<string>();    // string
- *   age = input(0);                         // number
- * }
- * ```
- */
-export declare const ɵinput: ɵInputFunction;
-
 declare const ɵINPUT_SIGNAL_BRAND_READ_TYPE: unique symbol;
 
 export declare const ɵINPUT_SIGNAL_BRAND_WRITE_TYPE: unique symbol;
 
-/**
- * Type of the `input` function.
- *
- * The input function is a special function that also provides access to
- * required inputs via the `.required` property.
- */
-export declare type ɵInputFunction = typeof ɵinputFunctionForApiGuard & {
-    required: typeof ɵinputFunctionRequiredForApiGuard;
-};
-
-/**
- * Initializes an input with an initial value. If no explicit value
- * is specified, Angular will use `undefined`.
- *
- * Consider using `input.required` for inputs that don't need an
- * initial value.
- *
- * @usageNotes
- * Initialize an input in your directive or component by declaring a
- * class field and initializing it with the `input()` function.
- *
- * ```ts
- * @Directive({..})
- * export class MyDir {
- *   firstName = input<string>();            // string|undefined
- *   lastName = input.required<string>();    // string
- *   age = input(0);                         // number
- * }
- * ```
- */
-export declare function ɵinputFunctionForApiGuard<ReadT>(): InputSignal<ReadT | undefined>;
-
-export declare function ɵinputFunctionForApiGuard<ReadT>(initialValue: ReadT, opts?: ɵInputOptionsWithoutTransform<ReadT>): InputSignal<ReadT>;
-
-export declare function ɵinputFunctionForApiGuard<ReadT, WriteT>(initialValue: ReadT, opts: ɵInputOptionsWithTransform<ReadT, WriteT>): InputSignal<ReadT, WriteT>;
-
-/**
- * Initializes a required input. Users of your directive/component,
- * need to bind to this input, otherwise they will see errors.
- * *
- * @usageNotes
- * Initialize an input in your directive or component by declaring a
- * class field and initializing it with the `input()` function.
- *
- * ```ts
- * @Directive({..})
- * export class MyDir {
- *   firstName = input<string>();            // string|undefined
- *   lastName = input.required<string>();    // string
- *   age = input(0);                         // number
- * }
- * ```
- */
-export declare function ɵinputFunctionRequiredForApiGuard<ReadT>(opts?: ɵInputOptionsWithoutTransform<ReadT>): InputSignal<ReadT>;
-
-export declare function ɵinputFunctionRequiredForApiGuard<ReadT, WriteT>(opts: ɵInputOptionsWithTransform<ReadT, WriteT>): InputSignal<ReadT, WriteT>;
-
-/**
- * Options for signal inputs.
- */
-export declare interface ɵInputOptions<ReadT, WriteT> {
-    /** Optional public name for the input. By default, the class field name is used. */
-    alias?: string;
-    /**
-     * Optional transform that runs whenever a new value is bound. Can be used to
-     * transform the input value before the input is updated.
-     *
-     * The transform function can widen the type of the input. For example, consider
-     * an input for `disabled`. In practice, as the component author, you want to only
-     * deal with a boolean, but users may want to bind a string if they just use the
-     * attribute form to bind to the input via `<my-dir input>`. A transform can then
-     * handle such string values and convert them to `boolean`. See: {@link booleanAttribute}.
-     */
-    transform?: (v: WriteT) => ReadT;
-}
-
-/** Signal input options without the transform option. */
-export declare type ɵInputOptionsWithoutTransform<ReadT> = Omit<ɵInputOptions<ReadT, ReadT>, 'transform'> & {
-    transform?: undefined;
-};
-
-/** Signal input options with the transform option required. */
-export declare type ɵInputOptionsWithTransform<ReadT, WriteT> = Required<Pick<ɵInputOptions<ReadT, WriteT>, 'transform'>> & ɵInputOptions<ReadT, WriteT>;
-
 /**
  * Register a callback to run once before any userspace `afterRender` or
  * `afterNextRender` callbacks.
@@ -12117,18 +12505,30 @@ export declare const enum ɵProfilerEvent {
 }
 
 /**
- * Publishes a collection of default debug tools onto`window.ng`.
+ * An object that contains information about a provider that has been configured
  *
- * These functions are available globally when Angular is in development
- * mode and are automatically stripped away from prod mode is on.
+ * TODO: rename to indicate that it is a debug structure eg. ProviderDebugInfo.
  */
-export declare function ɵpublishDefaultGlobalUtils(): void;
+export declare interface ɵProviderRecord {
+    /**
+     * DI token that this provider is configuring
+     */
+    token: Type<unknown> | InjectionToken<unknown>;
+    /**
+     * Determines if provider is configured as view provider.
+     */
+    isViewProvider: boolean;
+    /**
+     * The raw provider associated with this ProviderRecord.
+     */
+    provider: SingleProvider;
+    /**
+     * The path of DI containers that were followed to import this provider
+     */
+    importPath?: Type<unknown>[];
+}
 
-/**
- * Publishes the given function to `window.ng` so that it can be
- * used from the browser console when an application is not in production.
- */
-export declare function ɵpublishGlobalUtil(name: string, fn: Function): void;
+export declare function ɵprovideZonelessChangeDetection(): EnvironmentProviders;
 
 export declare class ɵReflectionCapabilities implements PlatformReflectionCapabilities {
     private _reflect;
@@ -12333,7 +12733,6 @@ export declare class ɵRuntimeError<T extends number = ɵRuntimeErrorCode> exten
 export declare const enum ɵRuntimeErrorCode {
     EXPRESSION_CHANGED_AFTER_CHECKED = -100,
     RECURSIVE_APPLICATION_REF_TICK = 101,
-    RECURSIVE_APPLICATION_RENDER = 102,
     INFINITE_CHANGE_DETECTION = 103,
     CYCLIC_DI_DEPENDENCY = -200,
     PROVIDER_NOT_FOUND = -201,
@@ -12396,6 +12795,7 @@ export declare const enum ɵRuntimeErrorCode {
     VIEW_ALREADY_DESTROYED = 911,
     COMPONENT_ID_COLLISION = -912,
     IMAGE_PERFORMANCE_WARNING = -913,
+    REQUIRED_INPUT_NO_VALUE = -950,
     RUNTIME_DEPS_INVALID_IMPORTED_TYPE = 1000,
     RUNTIME_DEPS_ORPHAN_COMPONENT = 1001
 }
@@ -12920,7 +13320,7 @@ export declare class ɵZoneAwareQueueingScheduler implements ɵEffectScheduler,
  *
  * @codeGenApi
  */
-export declare function ɵɵadvance(delta: number): void;
+export declare function ɵɵadvance(delta?: number): void;
 
 /**
  * Updates the value of or removes a bound attribute on an Element.
@@ -14311,6 +14711,13 @@ export declare interface ɵɵInjectorDef<T> {
     imports: (InjectorType<any> | InjectorTypeWithProviders<any>)[];
 }
 
+/** Flags describing an input for a directive. */
+export declare enum ɵɵInputFlags {
+    None = 0,
+    SignalBased = 1,
+    HasDecoratorInputTransform = 2
+}
+
 /**
  * Decorates the directive definition with support for input transform functions.
  *
@@ -14319,7 +14726,7 @@ export declare interface ɵɵInjectorDef<T> {
  *
  * @codeGenApi
  */
-export declare function ɵɵInputTransformsFeature(definition: ɵDirectiveDef<unknown>): void;
+export declare function ɵɵInputTransformsFeature<T>(definition: ɵDirectiveDef<T>): void;
 
 /**
  * Throws an error indicating that a factory function could not be generated by the compiler for a