@angular/core 17.2.0-next.0 → 17.2.0-rc.0

package/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @license Angular v17.2.0-next.0
+ * @license Angular v17.2.0-rc.0
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -332,7 +332,7 @@ export declare interface AfterViewInit {
 }
 
 /**
- * A [DI token](guide/glossary#di-token "DI token definition") that indicates which animations
+ * A [DI token](api/core/InjectionToken) that indicates which animations
  * module has been loaded.
  * @publicApi
  */
@@ -756,6 +756,8 @@ export declare class ApplicationRef {
      * detection pass during which all change detection must complete.
      */
     tick(): void;
+    private detectChangesInAttachedViews;
+    private detectChangesInView;
     /**
      * Attaches a view so that it will be dirty checked.
      * The view will be automatically detached when it is destroyed.
@@ -1879,6 +1881,26 @@ export declare type ContentChild = Query;
  */
 export declare const ContentChild: ContentChildDecorator;
 
+/**
+ * Initializes a content child query. Consider using `contentChild.required` for queries that should
+ * always match.
+ *
+ * @usageNotes
+ * Create a child query in your component by declaring a
+ * class field and initializing it with the `contentChild()` function.
+ *
+ * ```ts
+ * @Component({...})
+ * export class TestComponent {
+ *   headerEl = contentChild<ElementRef>('h');                    // Signal<ElementRef|undefined>
+ *   headerElElRequired = contentChild.required<ElementRef>('h'); // Signal<ElementRef>
+ *   header = contentChild(MyHeader);                             // Signal<MyHeader|undefined>
+ *   headerRequired = contentChild.required(MyHeader);            // Signal<MyHeader>
+ * }
+ * ```
+ */
+export declare const contentChild: ContentChildFunction;
+
 /**
  * Type of the ContentChild decorator / constructor function.
  *
@@ -1956,6 +1978,46 @@ export declare interface ContentChildDecorator {
     }): ContentChild;
 }
 
+/**
+ * Type of the `contentChild` function.
+ *
+ * The contentChild function creates a singular content query. It is a special function that also
+ * provides access to required query results via the `.required` property.
+ *
+ * @developerPreview
+ */
+export declare interface ContentChildFunction {
+    /**
+     * Initializes a content child query.
+     *
+     * Consider using `contentChild.required` for queries that should always match.
+     * @developerPreview
+     */
+    <LocatorT>(locator: ProviderToken<LocatorT> | string, opts?: {
+        descendants?: boolean;
+        read?: undefined;
+    }): Signal<LocatorT | undefined>;
+    <LocatorT, ReadT>(locator: ProviderToken<LocatorT> | string, opts: {
+        descendants?: boolean;
+        read: ProviderToken<ReadT>;
+    }): Signal<ReadT | undefined>;
+    /**
+     * Initializes a content child query that is always expected to match.
+     *
+     * @developerPreview
+     */
+    required: {
+        <LocatorT>(locator: ProviderToken<LocatorT> | string, opts?: {
+            descendants?: boolean;
+            read?: undefined;
+        }): Signal<LocatorT>;
+        <LocatorT, ReadT>(locator: ProviderToken<LocatorT> | string, opts: {
+            descendants?: boolean;
+            read: ProviderToken<ReadT>;
+        }): Signal<ReadT>;
+    };
+}
+
 /**
  * Type of the ContentChildren metadata.
  *
@@ -1974,6 +2036,16 @@ export declare type ContentChildren = Query;
  */
 export declare const ContentChildren: ContentChildrenDecorator;
 
+export declare function contentChildren<LocatorT>(locator: ProviderToken<LocatorT> | string, opts?: {
+    descendants?: boolean;
+    read?: undefined;
+}): Signal<ReadonlyArray<LocatorT>>;
+
+export declare function contentChildren<LocatorT, ReadT>(locator: ProviderToken<LocatorT> | string, opts: {
+    descendants?: boolean;
+    read: ProviderToken<ReadT>;
+}): Signal<ReadonlyArray<ReadT>>;
+
 /**
  * Type of the ContentChildren decorator / constructor function.
  *
@@ -3327,9 +3399,7 @@ declare type DirectiveDefListOrFactory = (() => DirectiveDefList) | DirectiveDef
  *  - 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`.
+ *    inconsistent behavior in that it uses declared names rather than minified or public.
  */
 declare type DirectiveInputs<T> = {
     [P in keyof T]?: string | [
@@ -3925,7 +3995,7 @@ declare const FLAGS = 2;
 export declare function forwardRef(forwardRefFn: ForwardRefFn): Type<any>;
 
 /**
- * An interface that a function passed into {@link forwardRef} has to implement.
+ * An interface that a function passed into `forwardRef` has to implement.
  *
  * @usageNotes
  * ### Example
@@ -4545,6 +4615,18 @@ export declare interface HostListenerDecorator {
 
 declare const HYDRATION = 6;
 
+declare const HYDRATION_INFO_KEY = "__ngDebugHydrationInfo__";
+
+/**
+ * Internal type that represents a claimed node.
+ * Only used in dev mode.
+ */
+declare enum HydrationStatus {
+    Hydrated = "hydrated",
+    Skipped = "skipped",
+    Mismatched = "mismatched"
+}
+
 declare namespace i0 {
     export {
         ɵɵinject,
@@ -5211,10 +5293,10 @@ export declare const INJECTOR: InjectionToken<Injector>;
 
 /**
  * Concrete injectors implement this interface. Injectors are configured
- * with [providers](guide/glossary#provider) that associate
- * dependencies of various types with [injection tokens](guide/glossary#di-token).
+ * with [providers](guide/dependency-injection-providers) that associate
+ * dependencies of various types with [injection tokens](guide/dependency-injection-providers).
  *
- * @see ["DI Providers"](guide/dependency-injection-providers).
+ * @see [DI Providers](guide/dependency-injection-providers).
  * @see {@link StaticProvider}
  *
  * @usageNotes
@@ -5478,7 +5560,7 @@ export declare interface InputFunction {
      */
     <ReadT>(): InputSignal<ReadT | undefined>;
     <ReadT>(initialValue: ReadT, opts?: InputOptionsWithoutTransform<ReadT>): InputSignal<ReadT>;
-    <ReadT, WriteT>(initialValue: ReadT, opts: InputOptionsWithTransform<ReadT, WriteT>): InputSignal<ReadT, WriteT>;
+    <ReadT, WriteT>(initialValue: ReadT, opts: InputOptionsWithTransform<ReadT, WriteT>): InputSignalWithTransform<ReadT, WriteT>;
     /**
      * Initializes a required input.
      *
@@ -5489,7 +5571,7 @@ export declare interface InputFunction {
      */
     required: {
         <ReadT>(opts?: InputOptionsWithoutTransform<ReadT>): InputSignal<ReadT>;
-        <ReadT, WriteT>(opts: InputOptionsWithTransform<ReadT, WriteT>): InputSignal<ReadT, WriteT>;
+        <ReadT, WriteT>(opts: InputOptionsWithTransform<ReadT, WriteT>): InputSignalWithTransform<ReadT, WriteT>;
     };
 }
 
@@ -5531,18 +5613,17 @@ export declare type InputOptionsWithoutTransform<ReadT> = Omit<InputOptions<Read
 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.
+ * `InputSignal` 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.
  *
+ * @see {@link InputOptionsWithTransform} for inputs with transforms.
+ *
  * @developerPreview
  */
-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;
+export declare interface InputSignal<ReadT> extends InputSignalWithTransform<ReadT, ReadT> {
 }
 
 /**
@@ -5566,6 +5647,36 @@ declare interface InputSignalNode<ReadT, WriteT> extends SignalNode<ReadT | type
     applyValueToInputSignal<ReadT, WriteT>(node: InputSignalNode<ReadT, WriteT>, value: ReadT): void;
 }
 
+/**
+ * `InputSignalWithTransform` represents a special `Signal` for a
+ * directive/component input with a `transform` function.
+ *
+ * Signal inputs with transforms capture an extra generic for their transform write
+ * type. Transforms can expand the accepted bound values for an input while ensuring
+ * value retrievals of the signal input are still matching the generic input type.
+ *
+ * ```ts
+ * class MyDir {
+ *   disabled = input(false, {
+ *     transform: (v: string|boolean) => convertToBoolean(v),
+ *   }); // InputSignalWithTransform<boolean, string|boolean>
+ *
+ *   click() {
+ *     this.disabled() // always returns a `boolean`.
+ *   }
+ * }
+ * ```
+ *
+ * @see {@link InputSignal} for additional information.
+ *
+ * @developerPreview
+ */
+export declare interface InputSignalWithTransform<ReadT, WriteT> extends Signal<ReadT> {
+    [SIGNAL]: InputSignalNode<ReadT, WriteT>;
+    [ɵINPUT_SIGNAL_BRAND_READ_TYPE]: ReadT;
+    [ɵINPUT_SIGNAL_BRAND_WRITE_TYPE]: WriteT;
+}
+
 /** Function that can be used to transform incoming input values. */
 declare type InputTransformFunction = (value: any) => any;
 
@@ -6092,6 +6203,14 @@ declare interface LQueries {
      * @param tView
      */
     detachView(tView: TView): void;
+    /**
+     * A method called when a view finishes its creation pass. As a result all impacted
+     * `LQuery` objects (and associated `QueryList`) are marked as dirty. This additional dirty
+     * marking gives us a precise point in time where we can collect results for a given view in an
+     * atomic way.
+     * @param tView
+     */
+    finishViewCreation(tView: TView): void;
 }
 
 /**
@@ -6515,6 +6634,118 @@ export declare enum MissingTranslationStrategy {
     Ignore = 2
 }
 
+/**
+ * `model` declares a writeable signal that is exposed as an input/output pair on the containing
+ * directive. The input name is taken either from the class member or from the `alias` option.
+ * The output name is generated by taking the input name and appending `Change`.
+ *
+ * Initializes a model with an initial value. If no explicit value
+ * is specified, Angular will use `undefined`.
+ *
+ * Consider using `model.required` for models that don't need an
+ * initial value.
+ *
+ * @usageNotes
+ * Initialize a model in your directive or component by declaring a
+ * class field and initializing it with the `model()` or `model.required()`
+ * function.
+ *
+ * ```ts
+ * @Directive({..})
+ * export class MyDir {
+ *   firstName = model<string>();            // string|undefined
+ *   lastName = model.required<string>();    // string
+ *   age = model(0);                         // number
+ * }
+ * ```
+ *
+ * @developerPreview
+ */
+export declare const model: ModelFunction;
+
+/**
+ * `model` declares a writeable signal that is exposed as an input/output pair on the containing
+ * directive. The input name is taken either from the class member or from the `alias` option.
+ * The output name is generated by taking the input name and appending `Change`.
+ *
+ * The function exposes an API for also declaring required models via the
+ * `model.required` function.
+ *
+ * @usageNotes
+ * Initialize a model in your directive or component by declaring a
+ * class field and initializing it with the `model()` or `model.required()`
+ * function.
+ *
+ * ```ts
+ * @Directive({..})
+ * export class MyDir {
+ *   firstName = model<string>();            // string|undefined
+ *   lastName = model.required<string>();    // string
+ *   age = model(0);                         // number
+ * }
+ * ```
+ *
+ * @developerPreview
+ */
+export declare interface ModelFunction {
+    /**
+     * Initializes a model with an initial value. If no explicit value
+     * is specified, Angular will use `undefined`.
+     *
+     * Consider using `model.required` for models that don't need an
+     * initial value.
+     *
+     * @developerPreview
+     */
+    <T>(): ModelSignal<T | undefined>;
+    <T>(initialValue: T, opts?: ModelOptions): ModelSignal<T>;
+    /**
+     * Initializes a required model.
+     *
+     * Users of your directive/component need to bind to the input side of the model.
+     * If unset, a compile time error will be reported.
+     *
+     * @developerPreview
+     */
+    required<T>(opts?: ModelOptions): ModelSignal<T>;
+}
+
+/**
+ * @developerPreview
+ *
+ * Options for model signals.
+ */
+export declare interface ModelOptions {
+    /**
+     * Optional public name of the input side of the model. The output side will have the same
+     * name as the input, but suffixed with `Change`. By default, the class field name is used.
+     */
+    alias?: string;
+}
+
+/**
+ * `ModelSignal` represents a special `Signal` for a directive/component model field.
+ *
+ * A model signal is a writeable signal that can be exposed as an output.
+ * Whenever its value is updated, it emits to the output.
+ *
+ * @developerPreview
+ */
+export declare interface ModelSignal<T> extends WritableSignal<T> {
+    [SIGNAL]: ModelSignalNode<T>;
+    [ɵINPUT_SIGNAL_BRAND_READ_TYPE]: T;
+    [ɵINPUT_SIGNAL_BRAND_WRITE_TYPE]: T;
+}
+
+/**
+ * Reactive node type for a model signal. Model signals extend
+ * signals by adding the ability to track subscriptions and to be required.
+ */
+declare interface ModelSignalNode<T> extends SignalNode<T> {
+    /** Used by the runtime to write a value to the signal input. */
+    applyValueToInputSignal: (node: ModelSignalNode<T>, value: T) => void;
+}
+
 /**
  * Combination of NgModuleFactory and ComponentFactories.
  *
@@ -7713,6 +7944,7 @@ declare const enum QueryFlags {
 export declare class QueryList<T> implements Iterable<T> {
     private _emitDistinctChangesOnly;
     readonly dirty = true;
+    private _onDirty?;
     private _results;
     private _changesDetected;
     private _changes;
@@ -10620,6 +10852,29 @@ export declare type ViewChild = Query;
  */
 export declare const ViewChild: ViewChildDecorator;
 
+/**
+ * Initializes a view child query.
+ *
+ * Consider using `viewChild.required` for queries that should always match.
+ *
+ * @usageNotes
+ * Create a child query in your component by declaring a
+ * class field and initializing it with the `viewChild()` function.
+ *
+ * ```ts
+ * @Component({template: '<div #el></div><my-component #cmp />'})
+ * export class TestComponent {
+ *   divEl = viewChild<ElementRef>('el');                   // Signal<ElementRef|undefined>
+ *   divElRequired = viewChild.required<ElementRef>('el');  // Signal<ElementRef>
+ *   cmp = viewChild(MyComponent);                          // Signal<MyComponent|undefined>
+ *   cmpRequired = viewChild.required(MyComponent);         // Signal<MyComponent>
+ * }
+ * ```
+ *
+ * @developerPreview
+ */
+export declare const viewChild: ViewChildFunction;
+
 /**
  * Type of the ViewChild decorator / constructor function.
  *
@@ -10673,6 +10928,8 @@ export declare interface ViewChildDecorator {
      *
      * @usageNotes
      *
+     * ### Example 1
+     *
      * {@example core/di/ts/viewChild/view_child_example.ts region='Component'}
      *
      * ### Example 2
@@ -10691,6 +10948,38 @@ export declare interface ViewChildDecorator {
     }): ViewChild;
 }
 
+/**
+ * Type of the `viewChild` function. The viewChild function creates a singular view query.
+ *
+ * It is a special function that also provides access to required query results via the `.required`
+ * property.
+ *
+ * @developerPreview
+ */
+export declare interface ViewChildFunction {
+    /**
+     * Initializes a view child query. Consider using `viewChild.required` for queries that should
+     * always match.
+     *
+     * @developerPreview
+     */
+    <LocatorT>(locator: ProviderToken<LocatorT> | string): Signal<LocatorT | undefined>;
+    <LocatorT, ReadT>(locator: ProviderToken<LocatorT> | string, opts: {
+        read: ProviderToken<ReadT>;
+    }): Signal<ReadT | undefined>;
+    /**
+     * Initializes a view child query that is expected to always match an element.
+     *
+     * @developerPreview
+     */
+    required: {
+        <LocatorT>(locator: ProviderToken<LocatorT> | string): Signal<LocatorT>;
+        <LocatorT, ReadT>(locator: ProviderToken<LocatorT> | string, opts: {
+            read: ProviderToken<ReadT>;
+        }): Signal<ReadT>;
+    };
+}
+
 /**
  * Type of the ViewChildren metadata.
  *
@@ -10706,6 +10995,12 @@ export declare type ViewChildren = Query;
  */
 export declare const ViewChildren: ViewChildrenDecorator;
 
+export declare function viewChildren<LocatorT>(locator: ProviderToken<LocatorT> | string): Signal<ReadonlyArray<LocatorT>>;
+
+export declare function viewChildren<LocatorT, ReadT>(locator: ProviderToken<LocatorT> | string, opts: {
+    read: ProviderToken<ReadT>;
+}): Signal<ReadonlyArray<ReadT>>;
+
 /**
  * Type of the ViewChildren decorator / constructor function.
  *
@@ -11057,10 +11352,14 @@ declare interface ViewRefTracker {
     detachView(viewRef: ViewRef): void;
 }
 
+/** Symbol used distinguish `WritableSignal` from other non-writable signals and functions. */
+declare const WRITABLE_SIGNAL: unique symbol;
+
 /**
  * A `Signal` with a value that can be mutated via a setter interface.
  */
 export declare interface WritableSignal<T> extends Signal<T> {
+    [WRITABLE_SIGNAL]: T;
     /**
      * Directly set the signal to a new value, and notify any dependents.
      */
@@ -11095,7 +11394,7 @@ export declare class ɵAfterRenderEventManager {
     /**
      * Executes callbacks. Returns `true` if any callbacks executed.
      */
-    execute(): boolean;
+    execute(): void;
     ngOnDestroy(): void;
     /** @nocollapse */
     static ɵprov: unknown;
@@ -11139,6 +11438,7 @@ export declare const enum ɵAnimationRendererType {
  */
 export declare function ɵannotateForHydration(appRef: ApplicationRef, doc: Document): void;
 
+
 /**
  * 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.
@@ -11573,9 +11873,11 @@ export declare const ɵDEFER_BLOCK_CONFIG: InjectionToken<ɵDeferBlockConfig>;
 
 /**
  * **INTERNAL**, avoid referencing it in application code.
- *
+ * *
  * Injector token that allows to provide `DeferBlockDependencyInterceptor` class
  * implementation.
+ *
+ * This token is only injected in devMode
  */
 export declare const ɵDEFER_BLOCK_DEPENDENCY_INTERCEPTOR: InjectionToken<ɵDeferBlockDependencyInterceptor>;
 
@@ -11999,6 +12301,18 @@ export declare type ɵGlobalDevModeUtils = {
     [GLOBAL_PUBLISH_EXPANDO_KEY]: typeof globalUtilsFunctions;
 };
 
+export declare type ɵHydratedNode = {
+    [HYDRATION_INFO_KEY]?: ɵHydrationInfo;
+};
+
+export declare type ɵHydrationInfo = {
+    status: HydrationStatus.Hydrated | HydrationStatus.Skipped;
+} | {
+    status: HydrationStatus.Mismatched;
+    actualNodeDetails: string | null;
+    expectedNodeDetails: string | null;
+};
+
 /**
  * Injection token that configures the image optimized image functionality.
  * See {@link ImageConfig} for additional information about parameters that
@@ -12027,6 +12341,7 @@ export declare const ɵIMAGE_CONFIG_DEFAULTS: ɵImageConfig;
  */
 export declare type ɵImageConfig = {
     breakpoints?: number[];
+    placeholderResolution?: number;
     disableImageSizeWarning?: boolean;
     disableImageLazyLoadWarning?: boolean;
 };
@@ -12365,6 +12680,56 @@ export declare function ɵnoSideEffects<T>(fn: () => T): T;
 
 export declare const ɵNOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR: {};
 
+/**
+ * The `outputs` function allows declaration of outputs in directives and
+ * components.
+ *
+ * Initializes an output that can emit values to consumers of your
+ * directive/component.
+ *
+ * @usageNotes
+ * Initialize an output in your directive by declaring a
+ * class field and initializing it with the `output()` function.
+ *
+ * ```ts
+ * @Directive({..})
+ * export class MyDir {
+ *   nameChange = output<string>();     // OutputEmitter<string>
+ *   onClick = output();                // OutputEmitter<void>
+ * }
+ * ```
+ *
+ * @developerPreview
+ */
+export declare function ɵoutput<T = void>(opts?: ɵOutputOptions): ɵOutputEmitter<T>;
+
+
+/**
+ * An `OutputEmitter` is created by the `output()` function and can be
+ * used to emit values to consumers of your directive or component.
+ *
+ * Consumers of your directive/component can bind to the output and
+ * subscribe to changes via the bound event syntax. For example:
+ *
+ * ```html
+ * <my-comp (valueChange)="processNewValue($event)" />
+ * ```
+ *
+ * @developerPreview
+ */
+export declare interface ɵOutputEmitter<T> {
+    emit(value: T): void;
+}
+
+/**
+ * Options for declaring an output.
+ *
+ * @developerPreview
+ */
+export declare interface ɵOutputOptions {
+    alias?: string;
+}
+
 /**
  * Patch the definition of a component with directives and pipes from the compilation scope of
  * a given module.
@@ -12524,6 +12889,8 @@ export declare interface ɵProviderRecord {
 
 export declare function ɵprovideZonelessChangeDetection(): EnvironmentProviders;
 
+export declare function ɵreadHydrationInfo(node: RNode): ɵHydrationInfo | null;
+
 export declare class ɵReflectionCapabilities implements PlatformReflectionCapabilities {
     private _reflect;
     constructor(reflect?: any);
@@ -12790,6 +13157,8 @@ export declare const enum ɵRuntimeErrorCode {
     COMPONENT_ID_COLLISION = -912,
     IMAGE_PERFORMANCE_WARNING = -913,
     REQUIRED_INPUT_NO_VALUE = -950,
+    REQUIRED_QUERY_NO_VALUE = -951,
+    REQUIRED_MODEL_NO_VALUE = -952,
     RUNTIME_DEPS_INVALID_IMPORTED_TYPE = 1000,
     RUNTIME_DEPS_ORPHAN_COMPONENT = 1001
 }
@@ -12970,7 +13339,7 @@ export declare function ɵtriggerResourceLoading(tDetails: TDeferBlockDetails, l
  *
  * @param string
  * @param maxLength of the output string
- * @returns elispsed string with ... in the middle
+ * @returns ellipsed string with ... in the middle
  */
 export declare function ɵtruncateMiddle(str: string, maxLength?: number): string;
 
@@ -12979,18 +13348,29 @@ export declare function ɵtruncateMiddle(str: string, maxLength?: number): strin
  */
 export declare function ɵunregisterLocaleData(): void;
 
-/** Unwraps all `InputSignal` class fields of the given directive. */
+/**
+ * Unwraps all `InputSignal`/`InputSignalWithTransform` class fields of
+ * the given directive.
+ */
 export declare type ɵUnwrapDirectiveSignalInputs<Dir, Fields extends keyof Dir> = {
     [P in Fields]: ɵUnwrapInputSignalWriteType<Dir[P]>;
 };
 
-/** Retrieves the `WriteT` of an `InputSignal`. */
-declare type ɵUnwrapInputSignalWriteType<Field> = Field extends InputSignal<unknown, infer WriteT> ? WriteT : never;
+/** Retrieves the `WriteT` of an `InputSignal` and `InputSignalWithTransform`. */
+declare type ɵUnwrapInputSignalWriteType<Field> = Field extends InputSignalWithTransform<unknown, infer WriteT> ? WriteT : never;
 
 export declare function ɵunwrapSafeValue(value: ɵSafeValue): string;
 
 export declare function ɵunwrapSafeValue<T>(value: T): T;
 
+/**
+ * Utility function used during template type checking to extract the value from a `WritableSignal`.
+ * @codeGenApi
+ */
+export declare function ɵunwrapWritableSignal<T>(value: T | {
+    [WRITABLE_SIGNAL]: T;
+}): T;
+
 /**
  * Indicates whether to use the runtime dependency tracker for scope calculation in JIT compilation.
  * The value "false" means the old code path based on patching scope info into the types will be
@@ -13008,7 +13388,7 @@ export declare class ɵViewRef<T> implements EmbeddedViewRef<T>, ChangeDetectorR
      * This may be different from `_lView` if the `_cdRefInjectingView` is an embedded view.
      */
     private _cdRefInjectingView?;
-    private readonly notifyErrorHandler;
+    readonly notifyErrorHandler: boolean;
     private _appRef;
     private _attachedToViewContainer;
     get rootNodes(): any[];
@@ -13968,7 +14348,18 @@ export declare function ɵɵconditional<T>(containerIndex: number, matchingTempl
  */
 export declare function ɵɵcontentQuery<T>(directiveIndex: number, predicate: ProviderToken<unknown> | string | string[], flags: QueryFlags, read?: any): void;
 
-export declare function ɵɵcontentQuerySignal(): void;
+/**
+ * Creates a new content query and binds it to a signal created by an authoring function.
+ *
+ * @param directiveIndex Current directive index
+ * @param target The target signal to which the query should be bound
+ * @param predicate The type for which the query will search
+ * @param flags Flags associated with the query
+ * @param read What to save in the query
+ *
+ * @codeGenApi
+ */
+export declare function ɵɵcontentQuerySignal<T>(directiveIndex: number, target: Signal<T>, predicate: ProviderToken<unknown> | string[], flags: QueryFlags, read?: any): void;
 
 /**
  * Copies the fields not handled by the `ɵɵInheritDefinitionFeature` from the supertype of a
@@ -14687,6 +15078,7 @@ export declare interface ɵɵInjectorDef<T> {
     imports: (InjectorType<any> | InjectorTypeWithProviders<any>)[];
 }
 
+
 /** Flags describing an input for a directive. */
 export declare enum ɵɵInputFlags {
     None = 0,
@@ -15620,7 +16012,19 @@ export declare function ɵɵpureFunction8(slotOffset: number, pureFn: (v1: any,
  */
 export declare function ɵɵpureFunctionV(slotOffset: number, pureFn: (...v: any[]) => any, exps: any[], thisArg?: any): any;
 
-export declare function ɵɵqueryAdvance(_count?: number): void;
+/**
+ * Advances the current query index by a specified offset.
+ *
+ * Adjusting the current query index is necessary in cases where a given directive has a mix of
+ * zone-based and signal-based queries. The signal-based queries don't require tracking of the
+ * current index (those are refreshed on demand and not during change detection) so this instruction
+ * is only necessary for backward-compatibility.
+ *
+ * @param index offset to apply to the current query index (defaults to 1)
+ *
+ * @codeGenApi
+ */
+export declare function ɵɵqueryAdvance(indexOffset?: number): void;
 
 /**
  * Refreshes a query by combining matches from all active views and removing matches from deleted
@@ -16863,6 +17267,41 @@ export declare function ɵɵtrustConstantHtml(html: TemplateStringsArray): Trust
  */
 export declare function ɵɵtrustConstantResourceUrl(url: TemplateStringsArray): TrustedScriptURL | string;
 
+/**
+ * Function used inside two-way listeners to conditionally set the value of the bound expression.
+ *
+ * @param target Field on which to set the value.
+ * @param value Value to be set to the field.
+ *
+ * @codeGenApi
+ */
+export declare function ɵɵtwoWayBindingSet<T>(target: unknown, value: T): boolean;
+
+/**
+ * Adds an event listener that updates a two-way binding to the current node.
+ *
+ * @param eventName Name of the event.
+ * @param listenerFn The function to be called when event emits.
+ *
+ * @codeGenApi
+ */
+export declare function ɵɵtwoWayListener(eventName: string, listenerFn: (e?: any) => any): typeof ɵɵtwoWayListener;
+
+/**
+ * Update a two-way bound property on a selected element.
+ *
+ * Operates on the element selected by index via the {@link select} instruction.
+ *
+ * @param propName Name of property.
+ * @param value New value to write.
+ * @param sanitizer An optional function used to sanitize the value.
+ * @returns This function returns itself so that it may be chained
+ * (e.g. `twoWayProperty('name', ctx.name)('title', ctx.title)`)
+ *
+ * @codeGenApi
+ */
+export declare function ɵɵtwoWayProperty<T>(propName: string, value: T | WritableSignal<T>, sanitizer?: SanitizerFn | null): typeof ɵɵtwoWayProperty;
+
 
 /**
  * Validation function invoked at runtime for each binding that might potentially
@@ -16876,7 +17315,7 @@ export declare function ɵɵtrustConstantResourceUrl(url: TemplateStringsArray):
 export declare function ɵɵvalidateIframeAttribute(attrValue: any, tagName: string, attrName: string): any;
 
 /**
- * Creates new QueryList, stores the reference in LView and returns QueryList.
+ * Creates a new view query by initializing internal data structures.
  *
  * @param predicate The type for which the query will search
  * @param flags Flags associated with the query
@@ -16886,6 +17325,17 @@ export declare function ɵɵvalidateIframeAttribute(attrValue: any, tagName: str
  */
 export declare function ɵɵviewQuery<T>(predicate: ProviderToken<unknown> | string | string[], flags: QueryFlags, read?: any): void;
 
-export declare function ɵɵviewQuerySignal(): void;
+/**
+ * Creates a new view query by initializing internal data structures and binding a new query to the
+ * target signal.
+ *
+ * @param target The target signal to assign the query results to.
+ * @param predicate The type or label that should match a given query
+ * @param flags Flags associated with the query
+ * @param read What to save in the query
+ *
+ * @codeGenApi
+ */
+export declare function ɵɵviewQuerySignal(target: Signal<unknown>, predicate: ProviderToken<unknown> | string[], flags: QueryFlags, read?: ProviderToken<unknown>): void;
 
 export { }