@angular/core 17.3.0 → 17.3.2

package/esm2022/src/authoring/input/input.mjs

@@ -17,29 +17,52 @@ export function inputRequiredFunction(opts) {
     return createInputSignal(REQUIRED_UNSET_VALUE, opts);
 }
 /**
- * The `input` function allows declaration of inputs in directives and
- * components.
+ * The `input` function allows declaration of Angular inputs in directives
+ * and components.
  *
- * Initializes an input with an initial value. If no explicit value
- * is specified, Angular will use `undefined`.
+ * There are two variants of inputs that can be declared:
  *
- * Consider using `input.required` for inputs that don't need an
- * initial value.
+ *   1. **Optional inputs** with an initial value.
+ *   2. **Required inputs** that consumers need to set.
+ *
+ * By default, the `input` function will declare optional inputs that
+ * always have an initial value. Required inputs can be declared
+ * using the `input.required()` function.
+ *
+ * Inputs are signals. The values of an input are exposed as a `Signal`.
+ * The signal always holds the latest value of the input that is bound
+ * from the parent.
  *
  * @usageNotes
- * Initialize an input in your directive or component by declaring a
- * class field and initializing it with the `input()` function.
+ * To use signal-based inputs, import `input` from `@angular/core`.
+ *
+ * ```
+ * import {input} from '@angular/core`;
+ * ```
+ *
+ * Inside your component, introduce a new class member and initialize
+ * it with a call to `input` or `input.required`.
  *
  * ```ts
- * @Directive({..})
- * export class MyDir {
- *   firstName = input<string>();            // string|undefined
- *   lastName = input.required<string>();    // string
- *   age = input(0);                         // number
+ * @Component({
+ *   ...
+ * })
+ * export class UserProfileComponent {
+ *   firstName = input<string>();             // Signal<string|undefined>
+ *   lastName  = input.required<string>();    // Signal<string>
+ *   age       = input(0)                     // Signal<number>
  * }
  * ```
  *
+ * Inside your component template, you can display values of the inputs
+ * by calling the signal.
+ *
+ * ```html
+ * <span>{{firstName()}}</span>
+ * ```
+ *
  * @developerPreview
+ * @initializerApiFunction
  */
 export const input = (() => {
     // Note: This may be considered a side-effect, but nothing will depend on
@@ -48,4 +71,4 @@ export const input = (() => {
     inputFunction.required = inputRequiredFunction;
     return inputFunction;
 })();
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5wdXQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb3JlL3NyYy9hdXRob3JpbmcvaW5wdXQvaW5wdXQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsT0FBTyxFQUFDLHdCQUF3QixFQUFDLE1BQU0sVUFBVSxDQUFDO0FBRWxELE9BQU8sRUFBQyxpQkFBaUIsRUFBK0csTUFBTSxnQkFBZ0IsQ0FBQztBQUMvSixPQUFPLEVBQUMsb0JBQW9CLEVBQUMsTUFBTSxxQkFBcUIsQ0FBQztBQUV6RCxNQUFNLFVBQVUsYUFBYSxDQUN6QixZQUFvQixFQUNwQixJQUFrQztJQUNwQyxTQUFTLElBQUksd0JBQXdCLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDN0MsT0FBTyxpQkFBaUIsQ0FBQyxZQUFZLEVBQUUsSUFBSSxDQUFDLENBQUM7QUFDL0MsQ0FBQztBQUVELE1BQU0sVUFBVSxxQkFBcUIsQ0FBZ0IsSUFBa0M7SUFFckYsU0FBUyxJQUFJLHdCQUF3QixDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQzdDLE9BQU8saUJBQWlCLENBQUMsb0JBQTZCLEVBQUUsSUFBSSxDQUFDLENBQUM7QUFDaEUsQ0FBQztBQXdERDs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBd0JHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sS0FBSyxHQUFrQixDQUFDLEdBQUcsRUFBRTtJQUN4Qyx5RUFBeUU7SUFDekUsMkVBQTJFO0lBQzNFLDZFQUE2RTtJQUM1RSxhQUFxQixDQUFDLFFBQVEsR0FBRyxxQkFBcUIsQ0FBQztJQUN4RCxPQUFPLGFBQWdGLENBQUM7QUFDMUYsQ0FBQyxDQUFDLEVBQUUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5pbXBvcnQge2Fzc2VydEluSW5qZWN0aW9uQ29udGV4dH0gZnJvbSAnLi4vLi4vZGknO1xuXG5pbXBvcnQge2NyZWF0ZUlucHV0U2lnbmFsLCBJbnB1dE9wdGlvbnMsIElucHV0T3B0aW9uc1dpdGhvdXRUcmFuc2Zvcm0sIElucHV0T3B0aW9uc1dpdGhUcmFuc2Zvcm0sIElucHV0U2lnbmFsLCBJbnB1dFNpZ25hbFdpdGhUcmFuc2Zvcm19IGZyb20gJy4vaW5wdXRfc2lnbmFsJztcbmltcG9ydCB7UkVRVUlSRURfVU5TRVRfVkFMVUV9IGZyb20gJy4vaW5wdXRfc2lnbmFsX25vZGUnO1xuXG5leHBvcnQgZnVuY3Rpb24gaW5wdXRGdW5jdGlvbjxSZWFkVCwgV3JpdGVUPihcbiAgICBpbml0aWFsVmFsdWU/OiBSZWFkVCxcbiAgICBvcHRzPzogSW5wdXRPcHRpb25zPFJlYWRULCBXcml0ZVQ+KTogSW5wdXRTaWduYWxXaXRoVHJhbnNmb3JtPFJlYWRUfHVuZGVmaW5lZCwgV3JpdGVUPiB7XG4gIG5nRGV2TW9kZSAmJiBhc3NlcnRJbkluamVjdGlvbkNvbnRleHQoaW5wdXQpO1xuICByZXR1cm4gY3JlYXRlSW5wdXRTaWduYWwoaW5pdGlhbFZhbHVlLCBvcHRzKTtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGlucHV0UmVxdWlyZWRGdW5jdGlvbjxSZWFkVCwgV3JpdGVUPihvcHRzPzogSW5wdXRPcHRpb25zPFJlYWRULCBXcml0ZVQ+KTpcbiAgICBJbnB1dFNpZ25hbFdpdGhUcmFuc2Zvcm08UmVhZFQsIFdyaXRlVD4ge1xuICBuZ0Rldk1vZGUgJiYgYXNzZXJ0SW5JbmplY3Rpb25Db250ZXh0KGlucHV0KTtcbiAgcmV0dXJuIGNyZWF0ZUlucHV0U2lnbmFsKFJFUVVJUkVEX1VOU0VUX1ZBTFVFIGFzIG5ldmVyLCBvcHRzKTtcbn1cblxuLyoqXG4gKiBUaGUgYGlucHV0YCBmdW5jdGlvbiBhbGxvd3MgZGVjbGFyYXRpb24gb2YgaW5wdXRzIGluIGRpcmVjdGl2ZXMgYW5kXG4gKiBjb21wb25lbnRzLlxuICpcbiAqIFRoZSBmdW5jdGlvbiBleHBvc2VzIGFuIEFQSSBmb3IgYWxzbyBkZWNsYXJpbmcgcmVxdWlyZWQgaW5wdXRzIHZpYSB0aGVcbiAqIGBpbnB1dC5yZXF1aXJlZGAgZnVuY3Rpb24uXG4gKlxuICogQHVzYWdlTm90ZXNcbiAqIEluaXRpYWxpemUgYW4gaW5wdXQgaW4geW91ciBkaXJlY3RpdmUgb3IgY29tcG9uZW50IGJ5IGRlY2xhcmluZyBhXG4gKiBjbGFzcyBmaWVsZCBhbmQgaW5pdGlhbGl6aW5nIGl0IHdpdGggdGhlIGBpbnB1dCgpYCBvciBgaW5wdXQucmVxdWlyZWQoKWBcbiAqIGZ1bmN0aW9uLlxuICpcbiAqIGBgYHRzXG4gKiBARGlyZWN0aXZlKHsuLn0pXG4gKiBleHBvcnQgY2xhc3MgTXlEaXIge1xuICogICBmaXJzdE5hbWUgPSBpbnB1dDxzdHJpbmc+KCk7ICAgICAgICAgICAgLy8gc3RyaW5nfHVuZGVmaW5lZFxuICogICBsYXN0TmFtZSA9IGlucHV0LnJlcXVpcmVkPHN0cmluZz4oKTsgICAgLy8gc3RyaW5nXG4gKiAgIGFnZSA9IGlucHV0KDApOyAgICAgICAgICAgICAgICAgICAgICAgICAvLyBudW1iZXJcbiAqIH1cbiAqIGBgYFxuICpcbiAqIEBkZXZlbG9wZXJQcmV2aWV3XG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgSW5wdXRGdW5jdGlvbiB7XG4gIC8qKlxuICAgKiBJbml0aWFsaXplcyBhbiBpbnB1dCB3aXRoIGFuIGluaXRpYWwgdmFsdWUuIElmIG5vIGV4cGxpY2l0IHZhbHVlXG4gICAqIGlzIHNwZWNpZmllZCwgQW5ndWxhciB3aWxsIHVzZSBgdW5kZWZpbmVkYC5cbiAgICpcbiAgICogQ29uc2lkZXIgdXNpbmcgYGlucHV0LnJlcXVpcmVkYCBmb3IgaW5wdXRzIHRoYXQgZG9uJ3QgbmVlZCBhblxuICAgKiBpbml0aWFsIHZhbHVlLlxuICAgKlxuICAgKiBAZGV2ZWxvcGVyUHJldmlld1xuICAgKi9cbiAgPFJlYWRUPigpOiBJbnB1dFNpZ25hbDxSZWFkVHx1bmRlZmluZWQ+O1xuICA8UmVhZFQ+KGluaXRpYWxWYWx1ZTogUmVhZFQsIG9wdHM/OiBJbnB1dE9wdGlvbnNXaXRob3V0VHJhbnNmb3JtPFJlYWRUPik6IElucHV0U2lnbmFsPFJlYWRUPjtcbiAgPFJlYWRULCBXcml0ZVQ+KGluaXRpYWxWYWx1ZTogUmVhZFQsIG9wdHM6IElucHV0T3B0aW9uc1dpdGhUcmFuc2Zvcm08UmVhZFQsIFdyaXRlVD4pOlxuICAgICAgSW5wdXRTaWduYWxXaXRoVHJhbnNmb3JtPFJlYWRULCBXcml0ZVQ+O1xuXG4gIC8qKlxuICAgKiBJbml0aWFsaXplcyBhIHJlcXVpcmVkIGlucHV0LlxuICAgKlxuICAgKiBVc2VycyBvZiB5b3VyIGRpcmVjdGl2ZS9jb21wb25lbnQgbmVlZCB0byBiaW5kIHRvIHRoaXNcbiAgICogaW5wdXQuIElmIHVuc2V0LCBhIGNvbXBpbGUgdGltZSBlcnJvciB3aWxsIGJlIHJlcG9ydGVkLlxuICAgKlxuICAgKiBAZGV2ZWxvcGVyUHJldmlld1xuICAgKi9cbiAgcmVxdWlyZWQ6IHtcbiAgICA8UmVhZFQ+KG9wdHM/OiBJbnB1dE9wdGlvbnNXaXRob3V0VHJhbnNmb3JtPFJlYWRUPik6IElucHV0U2lnbmFsPFJlYWRUPjtcblxuICAgIDxSZWFkVCwgV3JpdGVUPihvcHRzOiBJbnB1dE9wdGlvbnNXaXRoVHJhbnNmb3JtPFJlYWRULCBXcml0ZVQ+KTpcbiAgICAgICAgSW5wdXRTaWduYWxXaXRoVHJhbnNmb3JtPFJlYWRULCBXcml0ZVQ+O1xuICB9O1xufVxuXG4vKipcbiAqIFRoZSBgaW5wdXRgIGZ1bmN0aW9uIGFsbG93cyBkZWNsYXJhdGlvbiBvZiBpbnB1dHMgaW4gZGlyZWN0aXZlcyBhbmRcbiAqIGNvbXBvbmVudHMuXG4gKlxuICogSW5pdGlhbGl6ZXMgYW4gaW5wdXQgd2l0aCBhbiBpbml0aWFsIHZhbHVlLiBJZiBubyBleHBsaWNpdCB2YWx1ZVxuICogaXMgc3BlY2lmaWVkLCBBbmd1bGFyIHdpbGwgdXNlIGB1bmRlZmluZWRgLlxuICpcbiAqIENvbnNpZGVyIHVzaW5nIGBpbnB1dC5yZXF1aXJlZGAgZm9yIGlucHV0cyB0aGF0IGRvbid0IG5lZWQgYW5cbiAqIGluaXRpYWwgdmFsdWUuXG4gKlxuICogQHVzYWdlTm90ZXNcbiAqIEluaXRpYWxpemUgYW4gaW5wdXQgaW4geW91ciBkaXJlY3RpdmUgb3IgY29tcG9uZW50IGJ5IGRlY2xhcmluZyBhXG4gKiBjbGFzcyBmaWVsZCBhbmQgaW5pdGlhbGl6aW5nIGl0IHdpdGggdGhlIGBpbnB1dCgpYCBmdW5jdGlvbi5cbiAqXG4gKiBgYGB0c1xuICogQERpcmVjdGl2ZSh7Li59KVxuICogZXhwb3J0IGNsYXNzIE15RGlyIHtcbiAqICAgZmlyc3ROYW1lID0gaW5wdXQ8c3RyaW5nPigpOyAgICAgICAgICAgIC8vIHN0cmluZ3x1bmRlZmluZWRcbiAqICAgbGFzdE5hbWUgPSBpbnB1dC5yZXF1aXJlZDxzdHJpbmc+KCk7ICAgIC8vIHN0cmluZ1xuICogICBhZ2UgPSBpbnB1dCgwKTsgICAgICAgICAgICAgICAgICAgICAgICAgLy8gbnVtYmVyXG4gKiB9XG4gKiBgYGBcbiAqXG4gKiBAZGV2ZWxvcGVyUHJldmlld1xuICovXG5leHBvcnQgY29uc3QgaW5wdXQ6IElucHV0RnVuY3Rpb24gPSAoKCkgPT4ge1xuICAvLyBOb3RlOiBUaGlzIG1heSBiZSBjb25zaWRlcmVkIGEgc2lkZS1lZmZlY3QsIGJ1dCBub3RoaW5nIHdpbGwgZGVwZW5kIG9uXG4gIC8vIHRoaXMgYXNzaWdubWVudCwgdW5sZXNzIHRoaXMgYGlucHV0YCBjb25zdGFudCBleHBvcnQgaXMgYWNjZXNzZWQuIEl0J3MgYVxuICAvLyBzZWxmLWNvbnRhaW5lZCBzaWRlIGVmZmVjdCB0aGF0IGlzIGxvY2FsIHRvIHRoZSB1c2VyIGZhY2luZ2BpbnB1dGAgZXhwb3J0LlxuICAoaW5wdXRGdW5jdGlvbiBhcyBhbnkpLnJlcXVpcmVkID0gaW5wdXRSZXF1aXJlZEZ1bmN0aW9uO1xuICByZXR1cm4gaW5wdXRGdW5jdGlvbiBhcyAodHlwZW9mIGlucHV0RnVuY3Rpb24me3JlcXVpcmVkOiB0eXBlb2YgaW5wdXRSZXF1aXJlZEZ1bmN0aW9ufSk7XG59KSgpO1xuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/authoring/input/input_signal.mjs

@@ -37,4 +37,4 @@ export function createInputSignal(initialValue, options) {
     }
     return inputValueFn;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/authoring/input/input_signal_node.mjs

@@ -19,4 +19,4 @@ export const INPUT_SIGNAL_NODE = /* @__PURE__ */ (() => {
         }
     };
 })();
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/authoring/input/input_type_checking.mjs

@@ -6,4 +6,4 @@
  * found in the LICENSE file at https://angular.io/license
  */
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5wdXRfdHlwZV9jaGVja2luZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvcmUvc3JjL2F1dGhvcmluZy9pbnB1dC9pbnB1dF90eXBlX2NoZWNraW5nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5pbXBvcnQge0lucHV0U2lnbmFsV2l0aFRyYW5zZm9ybX0gZnJvbSAnLi9pbnB1dF9zaWduYWwnO1xuXG4vKiogUmV0cmlldmVzIHRoZSBgV3JpdGVUYCBvZiBhbiBgSW5wdXRTaWduYWxgIGFuZCBgSW5wdXRTaWduYWxXaXRoVHJhbnNmb3JtYC4gKi9cbmV4cG9ydCB0eXBlIMm1VW53cmFwSW5wdXRTaWduYWxXcml0ZVR5cGU8RmllbGQ+ID1cbiAgICBGaWVsZCBleHRlbmRzIElucHV0U2lnbmFsV2l0aFRyYW5zZm9ybTxhbnksIGluZmVyIFdyaXRlVD4/IFdyaXRlVCA6IG5ldmVyO1xuXG4vKipcbiAqIFVud3JhcHMgYWxsIGBJbnB1dFNpZ25hbGAvYElucHV0U2lnbmFsV2l0aFRyYW5zZm9ybWAgY2xhc3MgZmllbGRzIG9mXG4gKiB0aGUgZ2l2ZW4gZGlyZWN0aXZlLlxuICovXG5leHBvcnQgdHlwZSDJtVVud3JhcERpcmVjdGl2ZVNpZ25hbElucHV0czxEaXIsIEZpZWxkcyBleHRlbmRzIGtleW9mIERpcj4gPSB7XG4gIFtQIGluIEZpZWxkc106IMm1VW53cmFwSW5wdXRTaWduYWxXcml0ZVR5cGU8RGlyW1BdPlxufTtcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5wdXRfdHlwZV9jaGVja2luZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvcmUvc3JjL2F1dGhvcmluZy9pbnB1dC9pbnB1dF90eXBlX2NoZWNraW5nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5pbXBvcnQge0lucHV0U2lnbmFsV2l0aFRyYW5zZm9ybX0gZnJvbSAnLi9pbnB1dF9zaWduYWwnO1xuXG4vKiogUmV0cmlldmVzIHRoZSB3cml0ZSB0eXBlIG9mIGFuIGBJbnB1dFNpZ25hbGAgYW5kIGBJbnB1dFNpZ25hbFdpdGhUcmFuc2Zvcm1gLiAqL1xuZXhwb3J0IHR5cGUgybVVbndyYXBJbnB1dFNpZ25hbFdyaXRlVHlwZTxGaWVsZD4gPVxuICAgIEZpZWxkIGV4dGVuZHMgSW5wdXRTaWduYWxXaXRoVHJhbnNmb3JtPGFueSwgaW5mZXIgV3JpdGVUPj8gV3JpdGVUIDogbmV2ZXI7XG5cbi8qKlxuICogVW53cmFwcyBhbGwgYElucHV0U2lnbmFsYC9gSW5wdXRTaWduYWxXaXRoVHJhbnNmb3JtYCBjbGFzcyBmaWVsZHMgb2ZcbiAqIHRoZSBnaXZlbiBkaXJlY3RpdmUuXG4gKi9cbmV4cG9ydCB0eXBlIMm1VW53cmFwRGlyZWN0aXZlU2lnbmFsSW5wdXRzPERpciwgRmllbGRzIGV4dGVuZHMga2V5b2YgRGlyPiA9IHtcbiAgW1AgaW4gRmllbGRzXTogybVVbndyYXBJbnB1dFNpZ25hbFdyaXRlVHlwZTxEaXJbUF0+XG59O1xuIl19

package/esm2022/src/authoring/model/model.mjs

@@ -17,31 +17,51 @@ export function modelRequiredFunction() {
     return createModelSignal(REQUIRED_UNSET_VALUE);
 }
 /**
- * `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.
+ * `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`.
+ * @usageNotes
  *
- * Consider using `model.required` for models that don't need an
- * initial value.
+ * To use `model()`, import the function from `@angular/core`.
  *
- * @usageNotes
- * Initialize a model in your directive or component by declaring a
- * class field and initializing it with the `model()` or `model.required()`
- * function.
+ * ```
+ * import {model} from '@angular/core`;
+ * ```
+ *
+ * Inside your component, introduce a new class member and initialize
+ * it with a call to `model` or `model.required`.
  *
  * ```ts
- * @Directive({..})
+ * @Directive({
+ *   ...
+ * })
  * export class MyDir {
- *   firstName = model<string>();            // string|undefined
- *   lastName = model.required<string>();    // string
- *   age = model(0);                         // number
+ *   firstName = model<string>();            // ModelSignal<string|undefined>
+ *   lastName  = model.required<string>();   // ModelSignal<string>
+ *   age       = model(0);                   // ModelSignal<number>
+ * }
+ * ```
+ *
+ * Inside your component template, you can display the value of a `model`
+ * by calling the signal.
+ *
+ * ```html
+ * <span>{{firstName()}}</span>
+ * ```
+ *
+ * Updating the `model` is equivalent to updating a writable signal.
+ *
+ * ```ts
+ * updateName(newFirstName: string): void {
+ *   this.firstName.set(newFirstName);
  * }
  * ```
  *
  * @developerPreview
+ * @initializerApiFunction
  */
 export const model = (() => {
     // Note: This may be considered a side-effect, but nothing will depend on
@@ -50,4 +70,4 @@ export const model = (() => {
     modelFunction.required = modelRequiredFunction;
     return modelFunction;
 })();
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/authoring/output/output.mjs

@@ -8,28 +8,50 @@
 import { assertInInjectionContext } from '../../di';
 import { OutputEmitterRef } from './output_emitter_ref';
 /**
- * The `output` function allows declaration of outputs in directives and
- * components.
+ * The `output` function allows declaration of Angular outputs in
+ * directives and components.
  *
- * Initializes an output that can emit values to consumers of your
- * directive/component.
+ * You can use outputs to emit values to parent directives and component.
+ * Parents can subscribe to changes via:
+ *
+ * - template event bindings. For example, `(myOutput)="doSomething($event)"`
+ * - programmatic subscription by using `OutputRef#subscribe`.
  *
  * @usageNotes
- * Initialize an output in your directive by declaring a
- * class field and initializing it with the `output()` function.
+ *
+ * To use `output()`, import the function from `@angular/core`.
+ *
+ * ```
+ * import {output} from '@angular/core`;
+ * ```
+ *
+ * Inside your component, introduce a new class member and initialize
+ * it with a call to `output`.
  *
  * ```ts
- * @Directive({..})
+ * @Directive({
+ *   ...
+ * })
  * export class MyDir {
- *   nameChange = output<string>();     // OutputEmitterRef<string>
- *   onClick = output();                // OutputEmitterRef<void>
+ *   nameChange = output<string>();    // OutputEmitterRef<string>
+ *   onClick    = output();            // OutputEmitterRef<void>
+ * }
+ * ```
+ *
+ * You can emit values to consumers of your directive, by using
+ * the `emit` method from `OutputEmitterRef`.
+ *
+ * ```ts
+ * updateName(newName: string): void {
+ *   this.nameChange.emit(newName);
  * }
  * ```
  *
  * @developerPreview
+ * @initializerApiFunction {"showTypesInSignaturePreview": true}
  */
 export function output(opts) {
     ngDevMode && assertInInjectionContext(output);
     return new OutputEmitterRef();
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/authoring/queries.mjs

@@ -35,6 +35,7 @@ function viewChildRequiredFn(locator, opts) {
  * ```
  *
  * @developerPreview
+ * @initializerApiFunction
  */
 export const viewChild = (() => {
     // Note: This may be considered a side-effect, but nothing will depend on
@@ -59,6 +60,9 @@ export const viewChild = (() => {
  *   divEls = viewChildren<ElementRef>('el');   // Signal<ReadonlyArray<ElementRef>>
  * }
  * ```
+ *
+ * @initializerApiFunction
+ * @developerPreview
  */
 export function viewChildren(locator, opts) {
     ngDevMode && assertInInjectionContext(viewChildren);
@@ -89,6 +93,9 @@ function contentChildRequiredFn(locator, opts) {
  *   headerRequired = contentChild.required(MyHeader);            // Signal<MyHeader>
  * }
  * ```
+ *
+ * @initializerApiFunction
+ * @developerPreview
  */
 export const contentChild = (() => {
     // Note: This may be considered a side-effect, but nothing will depend on
@@ -113,8 +120,11 @@ export const contentChild = (() => {
  *   headerEl = contentChildren<ElementRef>('h');   // Signal<ReadonlyArray<ElementRef>>
  * }
  * ```
+ *
+ * @initializerApiFunction
+ * @developerPreview
  */
 export function contentChildren(locator, opts) {
     return createMultiResultQuerySignalFn();
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"queries.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/authoring/queries.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,wBAAwB,EAAC,MAAM,OAAO,CAAC;AAE/C,OAAO,EAAC,8BAA8B,EAAE,uCAAuC,EAAE,uCAAuC,EAAC,MAAM,2BAA2B,CAAC;AAG3J,SAAS,WAAW,CAChB,OAAuC,EACvC,IAAoC;IACtC,SAAS,IAAI,wBAAwB,CAAC,SAAS,CAAC,CAAC;IACjD,OAAO,uCAAuC,EAAS,CAAC;AAC1D,CAAC;AAED,SAAS,mBAAmB,CACxB,OAAuC,EAAE,IAAoC;IAC/E,SAAS,IAAI,wBAAwB,CAAC,SAAS,CAAC,CAAC;IACjD,OAAO,uCAAuC,EAAS,CAAC;AAC1D,CAAC;AAkCD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,MAAM,SAAS,GAAsB,CAAC,GAAG,EAAE;IAChD,yEAAyE;IACzE,+EAA+E;IAC/E,kFAAkF;IACjF,WAAmB,CAAC,QAAQ,GAAG,mBAAmB,CAAC;IACpD,OAAO,WAA0E,CAAC;AACpF,CAAC,CAAC,EAAE,CAAC;AAQL;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,YAAY,CACxB,OAAuC,EACvC,IAAoC;IACtC,SAAS,IAAI,wBAAwB,CAAC,YAAY,CAAC,CAAC;IACpD,OAAO,8BAA8B,EAAS,CAAC;AACjD,CAAC;AAED,MAAM,UAAU,cAAc,CAC1B,OAAuC,EACvC,IAA2D;IAC7D,SAAS,IAAI,wBAAwB,CAAC,YAAY,CAAC,CAAC;IACpD,OAAO,uCAAuC,EAAS,CAAC;AAC1D,CAAC;AAED,SAAS,sBAAsB,CAC3B,OAAuC,EACvC,IAA2D;IAC7D,SAAS,IAAI,wBAAwB,CAAC,eAAe,CAAC,CAAC;IACvD,OAAO,uCAAuC,EAAS,CAAC;AAC1D,CAAC;AA2CD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,YAAY,GAAyB,CAAC,GAAG,EAAE;IACtD,yEAAyE;IACzE,+EAA+E;IAC/E,kFAAkF;IACjF,cAAsB,CAAC,QAAQ,GAAG,sBAAsB,CAAC;IAC1D,OAAO,cAAmF,CAAC;AAC7F,CAAC,CAAC,EAAE,CAAC;AAUL;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,eAAe,CAC3B,OAAuC,EACvC,IAA2D;IAC7D,OAAO,8BAA8B,EAAS,CAAC;AACjD,CAAC","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {assertInInjectionContext} from '../di';\nimport {ProviderToken} from '../di/provider_token';\nimport {createMultiResultQuerySignalFn, createSingleResultOptionalQuerySignalFn, createSingleResultRequiredQuerySignalFn} from '../render3/query_reactive';\nimport {Signal} from '../render3/reactivity/api';\n\nfunction viewChildFn<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts?: {read?: ProviderToken<ReadT>}): Signal<ReadT|undefined> {\n  ngDevMode && assertInInjectionContext(viewChild);\n  return createSingleResultOptionalQuerySignalFn<ReadT>();\n}\n\nfunction viewChildRequiredFn<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string, opts?: {read?: ProviderToken<ReadT>}): Signal<ReadT> {\n  ngDevMode && assertInInjectionContext(viewChild);\n  return createSingleResultRequiredQuerySignalFn<ReadT>();\n}\n\n/**\n * Type of the `viewChild` function. The viewChild function creates a singular view query.\n *\n * It is a special function that also provides access to required query results via the `.required`\n * property.\n *\n * @developerPreview\n */\nexport interface ViewChildFunction {\n  /**\n   * Initializes a view child query. Consider using `viewChild.required` for queries that should\n   * always match.\n   *\n   * @developerPreview\n   */\n  <LocatorT>(locator: ProviderToken<LocatorT>|string): Signal<LocatorT|undefined>;\n  <LocatorT, ReadT>(locator: ProviderToken<LocatorT>|string, opts: {read: ProviderToken<ReadT>}):\n      Signal<ReadT|undefined>;\n\n  /**\n   * Initializes a view child query that is expected to always match an element.\n   *\n   * @developerPreview\n   */\n  required: {\n    <LocatorT>(locator: ProviderToken<LocatorT>|string): Signal<LocatorT>;\n\n    <LocatorT, ReadT>(locator: ProviderToken<LocatorT>|string, opts: {read: ProviderToken<ReadT>}):\n        Signal<ReadT>;\n  };\n}\n\n/**\n * Initializes a view child query.\n *\n * Consider using `viewChild.required` for queries that should always match.\n *\n * @usageNotes\n * Create a child query in your component by declaring a\n * class field and initializing it with the `viewChild()` function.\n *\n * ```ts\n * @Component({template: '<div #el></div><my-component #cmp />'})\n * export class TestComponent {\n *   divEl = viewChild<ElementRef>('el');                   // Signal<ElementRef|undefined>\n *   divElRequired = viewChild.required<ElementRef>('el');  // Signal<ElementRef>\n *   cmp = viewChild(MyComponent);                          // Signal<MyComponent|undefined>\n *   cmpRequired = viewChild.required(MyComponent);         // Signal<MyComponent>\n * }\n * ```\n *\n * @developerPreview\n */\nexport const viewChild: ViewChildFunction = (() => {\n  // Note: This may be considered a side-effect, but nothing will depend on\n  // this assignment, unless this `viewChild` constant export is accessed. It's a\n  // self-contained side effect that is local to the user facing `viewChild` export.\n  (viewChildFn as any).required = viewChildRequiredFn;\n  return viewChildFn as (typeof viewChildFn&{required: typeof viewChildRequiredFn});\n})();\n\nexport function viewChildren<LocatorT>(locator: ProviderToken<LocatorT>|\n                                       string): Signal<ReadonlyArray<LocatorT>>;\nexport function viewChildren<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts: {read: ProviderToken<ReadT>}): Signal<ReadonlyArray<ReadT>>;\n\n/**\n * Initializes a view children query.\n *\n * Query results are represented as a signal of a read-only collection containing all matched\n * elements.\n *\n * @usageNotes\n * Create a children query in your component by declaring a\n * class field and initializing it with the `viewChildren()` function.\n *\n * ```ts\n * @Component({...})\n * export class TestComponent {\n *   divEls = viewChildren<ElementRef>('el');   // Signal<ReadonlyArray<ElementRef>>\n * }\n * ```\n */\nexport function viewChildren<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts?: {read?: ProviderToken<ReadT>}): Signal<ReadonlyArray<ReadT>> {\n  ngDevMode && assertInInjectionContext(viewChildren);\n  return createMultiResultQuerySignalFn<ReadT>();\n}\n\nexport function contentChildFn<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts?: {descendants?: boolean, read?: ProviderToken<ReadT>}): Signal<ReadT|undefined> {\n  ngDevMode && assertInInjectionContext(contentChild);\n  return createSingleResultOptionalQuerySignalFn<ReadT>();\n}\n\nfunction contentChildRequiredFn<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts?: {descendants?: boolean, read?: ProviderToken<ReadT>}): Signal<ReadT> {\n  ngDevMode && assertInInjectionContext(contentChildren);\n  return createSingleResultRequiredQuerySignalFn<ReadT>();\n}\n\n/**\n * Type of the `contentChild` function.\n *\n * The contentChild function creates a singular content query. It is a special function that also\n * provides access to required query results via the `.required` property.\n *\n * @developerPreview\n */\nexport interface ContentChildFunction {\n  /**\n   * Initializes a content child query.\n   *\n   * Consider using `contentChild.required` for queries that should always match.\n   * @developerPreview\n   */\n  <LocatorT>(locator: ProviderToken<LocatorT>|string, opts?: {\n    descendants?: boolean,\n    read?: undefined\n  }): Signal<LocatorT|undefined>;\n\n  <LocatorT, ReadT>(locator: ProviderToken<LocatorT>|string, opts: {\n    descendants?: boolean, read: ProviderToken<ReadT>\n  }): Signal<ReadT|undefined>;\n\n  /**\n   * Initializes a content child query that is always expected to match.\n   *\n   * @developerPreview\n   */\n  required: {\n    <LocatorT>(locator: ProviderToken<LocatorT>|string, opts?: {\n      descendants?: boolean,\n      read?: undefined,\n    }): Signal<LocatorT>;\n\n    <LocatorT, ReadT>(\n        locator: ProviderToken<LocatorT>|string,\n        opts: {descendants?: boolean, read: ProviderToken<ReadT>}): Signal<ReadT>;\n  };\n}\n\n/**\n * Initializes a content child query. Consider using `contentChild.required` for queries that should\n * always match.\n *\n * @usageNotes\n * Create a child query in your component by declaring a\n * class field and initializing it with the `contentChild()` function.\n *\n * ```ts\n * @Component({...})\n * export class TestComponent {\n *   headerEl = contentChild<ElementRef>('h');                    // Signal<ElementRef|undefined>\n *   headerElElRequired = contentChild.required<ElementRef>('h'); // Signal<ElementRef>\n *   header = contentChild(MyHeader);                             // Signal<MyHeader|undefined>\n *   headerRequired = contentChild.required(MyHeader);            // Signal<MyHeader>\n * }\n * ```\n */\nexport const contentChild: ContentChildFunction = (() => {\n  // Note: This may be considered a side-effect, but nothing will depend on\n  // this assignment, unless this `viewChild` constant export is accessed. It's a\n  // self-contained side effect that is local to the user facing `viewChild` export.\n  (contentChildFn as any).required = contentChildRequiredFn;\n  return contentChildFn as (typeof contentChildFn&{required: typeof contentChildRequiredFn});\n})();\n\n\nexport function contentChildren<LocatorT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts?: {descendants?: boolean, read?: undefined}): Signal<ReadonlyArray<LocatorT>>;\nexport function contentChildren<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts: {descendants?: boolean, read: ProviderToken<ReadT>}): Signal<ReadonlyArray<ReadT>>;\n\n/**\n * Initializes a content children query.\n *\n * Query results are represented as a signal of a read-only collection containing all matched\n * elements.\n *\n * @usageNotes\n * Create a children query in your component by declaring a\n * class field and initializing it with the `contentChildren()` function.\n *\n * ```ts\n * @Component({...})\n * export class TestComponent {\n *   headerEl = contentChildren<ElementRef>('h');   // Signal<ReadonlyArray<ElementRef>>\n * }\n * ```\n */\nexport function contentChildren<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts?: {descendants?: boolean, read?: ProviderToken<ReadT>}): Signal<ReadonlyArray<ReadT>> {\n  return createMultiResultQuerySignalFn<ReadT>();\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"queries.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/authoring/queries.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,wBAAwB,EAAC,MAAM,OAAO,CAAC;AAE/C,OAAO,EAAC,8BAA8B,EAAE,uCAAuC,EAAE,uCAAuC,EAAC,MAAM,2BAA2B,CAAC;AAG3J,SAAS,WAAW,CAChB,OAAuC,EACvC,IAAoC;IACtC,SAAS,IAAI,wBAAwB,CAAC,SAAS,CAAC,CAAC;IACjD,OAAO,uCAAuC,EAAS,CAAC;AAC1D,CAAC;AAED,SAAS,mBAAmB,CACxB,OAAuC,EAAE,IAAoC;IAC/E,SAAS,IAAI,wBAAwB,CAAC,SAAS,CAAC,CAAC;IACjD,OAAO,uCAAuC,EAAS,CAAC;AAC1D,CAAC;AAmCD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,MAAM,SAAS,GAAsB,CAAC,GAAG,EAAE;IAChD,yEAAyE;IACzE,+EAA+E;IAC/E,kFAAkF;IACjF,WAAmB,CAAC,QAAQ,GAAG,mBAAmB,CAAC;IACpD,OAAO,WAA0E,CAAC;AACpF,CAAC,CAAC,EAAE,CAAC;AAQL;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,YAAY,CACxB,OAAuC,EACvC,IAAoC;IACtC,SAAS,IAAI,wBAAwB,CAAC,YAAY,CAAC,CAAC;IACpD,OAAO,8BAA8B,EAAS,CAAC;AACjD,CAAC;AAED,MAAM,UAAU,cAAc,CAC1B,OAAuC,EACvC,IAA2D;IAC7D,SAAS,IAAI,wBAAwB,CAAC,YAAY,CAAC,CAAC;IACpD,OAAO,uCAAuC,EAAS,CAAC;AAC1D,CAAC;AAED,SAAS,sBAAsB,CAC3B,OAAuC,EACvC,IAA2D;IAC7D,SAAS,IAAI,wBAAwB,CAAC,eAAe,CAAC,CAAC;IACvD,OAAO,uCAAuC,EAAS,CAAC;AAC1D,CAAC;AA0CD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,MAAM,YAAY,GAAyB,CAAC,GAAG,EAAE;IACtD,yEAAyE;IACzE,+EAA+E;IAC/E,kFAAkF;IACjF,cAAsB,CAAC,QAAQ,GAAG,sBAAsB,CAAC;IAC1D,OAAO,cAAmF,CAAC;AAC7F,CAAC,CAAC,EAAE,CAAC;AAUL;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,eAAe,CAC3B,OAAuC,EACvC,IAA2D;IAC7D,OAAO,8BAA8B,EAAS,CAAC;AACjD,CAAC","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {assertInInjectionContext} from '../di';\nimport {ProviderToken} from '../di/provider_token';\nimport {createMultiResultQuerySignalFn, createSingleResultOptionalQuerySignalFn, createSingleResultRequiredQuerySignalFn} from '../render3/query_reactive';\nimport {Signal} from '../render3/reactivity/api';\n\nfunction viewChildFn<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts?: {read?: ProviderToken<ReadT>}): Signal<ReadT|undefined> {\n  ngDevMode && assertInInjectionContext(viewChild);\n  return createSingleResultOptionalQuerySignalFn<ReadT>();\n}\n\nfunction viewChildRequiredFn<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string, opts?: {read?: ProviderToken<ReadT>}): Signal<ReadT> {\n  ngDevMode && assertInInjectionContext(viewChild);\n  return createSingleResultRequiredQuerySignalFn<ReadT>();\n}\n\n/**\n * Type of the `viewChild` function. The viewChild function creates a singular view query.\n *\n * It is a special function that also provides access to required query results via the `.required`\n * property.\n *\n * @developerPreview\n * @docsPrivate Ignored because `viewChild` is the canonical API entry.\n */\nexport interface ViewChildFunction {\n  /**\n   * Initializes a view child query. Consider using `viewChild.required` for queries that should\n   * always match.\n   *\n   * @developerPreview\n   */\n  <LocatorT>(locator: ProviderToken<LocatorT>|string): Signal<LocatorT|undefined>;\n  <LocatorT, ReadT>(locator: ProviderToken<LocatorT>|string, opts: {read: ProviderToken<ReadT>}):\n      Signal<ReadT|undefined>;\n\n  /**\n   * Initializes a view child query that is expected to always match an element.\n   *\n   * @developerPreview\n   */\n  required: {\n    <LocatorT>(locator: ProviderToken<LocatorT>|string): Signal<LocatorT>;\n\n    <LocatorT, ReadT>(locator: ProviderToken<LocatorT>|string, opts: {read: ProviderToken<ReadT>}):\n        Signal<ReadT>;\n  };\n}\n\n/**\n * Initializes a view child query.\n *\n * Consider using `viewChild.required` for queries that should always match.\n *\n * @usageNotes\n * Create a child query in your component by declaring a\n * class field and initializing it with the `viewChild()` function.\n *\n * ```ts\n * @Component({template: '<div #el></div><my-component #cmp />'})\n * export class TestComponent {\n *   divEl = viewChild<ElementRef>('el');                   // Signal<ElementRef|undefined>\n *   divElRequired = viewChild.required<ElementRef>('el');  // Signal<ElementRef>\n *   cmp = viewChild(MyComponent);                          // Signal<MyComponent|undefined>\n *   cmpRequired = viewChild.required(MyComponent);         // Signal<MyComponent>\n * }\n * ```\n *\n * @developerPreview\n * @initializerApiFunction\n */\nexport const viewChild: ViewChildFunction = (() => {\n  // Note: This may be considered a side-effect, but nothing will depend on\n  // this assignment, unless this `viewChild` constant export is accessed. It's a\n  // self-contained side effect that is local to the user facing `viewChild` export.\n  (viewChildFn as any).required = viewChildRequiredFn;\n  return viewChildFn as (typeof viewChildFn&{required: typeof viewChildRequiredFn});\n})();\n\nexport function viewChildren<LocatorT>(locator: ProviderToken<LocatorT>|\n                                       string): Signal<ReadonlyArray<LocatorT>>;\nexport function viewChildren<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts: {read: ProviderToken<ReadT>}): Signal<ReadonlyArray<ReadT>>;\n\n/**\n * Initializes a view children query.\n *\n * Query results are represented as a signal of a read-only collection containing all matched\n * elements.\n *\n * @usageNotes\n * Create a children query in your component by declaring a\n * class field and initializing it with the `viewChildren()` function.\n *\n * ```ts\n * @Component({...})\n * export class TestComponent {\n *   divEls = viewChildren<ElementRef>('el');   // Signal<ReadonlyArray<ElementRef>>\n * }\n * ```\n *\n * @initializerApiFunction\n * @developerPreview\n */\nexport function viewChildren<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts?: {read?: ProviderToken<ReadT>}): Signal<ReadonlyArray<ReadT>> {\n  ngDevMode && assertInInjectionContext(viewChildren);\n  return createMultiResultQuerySignalFn<ReadT>();\n}\n\nexport function contentChildFn<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts?: {descendants?: boolean, read?: ProviderToken<ReadT>}): Signal<ReadT|undefined> {\n  ngDevMode && assertInInjectionContext(contentChild);\n  return createSingleResultOptionalQuerySignalFn<ReadT>();\n}\n\nfunction contentChildRequiredFn<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts?: {descendants?: boolean, read?: ProviderToken<ReadT>}): Signal<ReadT> {\n  ngDevMode && assertInInjectionContext(contentChildren);\n  return createSingleResultRequiredQuerySignalFn<ReadT>();\n}\n\n/**\n * Type of the `contentChild` function.\n *\n * The contentChild function creates a singular content query. It is a special function that also\n * provides access to required query results via the `.required` property.\n *\n * @developerPreview\n * @docsPrivate Ignored because `contentChild` is the canonical API entry.\n */\nexport interface ContentChildFunction {\n  /**\n   * Initializes a content child query.\n   *\n   * Consider using `contentChild.required` for queries that should always match.\n   * @developerPreview\n   */\n  <LocatorT>(locator: ProviderToken<LocatorT>|string, opts?: {\n    descendants?: boolean,\n    read?: undefined\n  }): Signal<LocatorT|undefined>;\n\n  <LocatorT, ReadT>(locator: ProviderToken<LocatorT>|string, opts: {\n    descendants?: boolean, read: ProviderToken<ReadT>\n  }): Signal<ReadT|undefined>;\n\n  /**\n   * Initializes a content child query that is always expected to match.\n   */\n  required: {\n    <LocatorT>(locator: ProviderToken<LocatorT>|string, opts?: {\n      descendants?: boolean,\n      read?: undefined,\n    }): Signal<LocatorT>;\n\n    <LocatorT, ReadT>(\n        locator: ProviderToken<LocatorT>|string,\n        opts: {descendants?: boolean, read: ProviderToken<ReadT>}): Signal<ReadT>;\n  };\n}\n\n/**\n * Initializes a content child query. Consider using `contentChild.required` for queries that should\n * always match.\n *\n * @usageNotes\n * Create a child query in your component by declaring a\n * class field and initializing it with the `contentChild()` function.\n *\n * ```ts\n * @Component({...})\n * export class TestComponent {\n *   headerEl = contentChild<ElementRef>('h');                    // Signal<ElementRef|undefined>\n *   headerElElRequired = contentChild.required<ElementRef>('h'); // Signal<ElementRef>\n *   header = contentChild(MyHeader);                             // Signal<MyHeader|undefined>\n *   headerRequired = contentChild.required(MyHeader);            // Signal<MyHeader>\n * }\n * ```\n *\n * @initializerApiFunction\n * @developerPreview\n */\nexport const contentChild: ContentChildFunction = (() => {\n  // Note: This may be considered a side-effect, but nothing will depend on\n  // this assignment, unless this `viewChild` constant export is accessed. It's a\n  // self-contained side effect that is local to the user facing `viewChild` export.\n  (contentChildFn as any).required = contentChildRequiredFn;\n  return contentChildFn as (typeof contentChildFn&{required: typeof contentChildRequiredFn});\n})();\n\n\nexport function contentChildren<LocatorT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts?: {descendants?: boolean, read?: undefined}): Signal<ReadonlyArray<LocatorT>>;\nexport function contentChildren<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts: {descendants?: boolean, read: ProviderToken<ReadT>}): Signal<ReadonlyArray<ReadT>>;\n\n/**\n * Initializes a content children query.\n *\n * Query results are represented as a signal of a read-only collection containing all matched\n * elements.\n *\n * @usageNotes\n * Create a children query in your component by declaring a\n * class field and initializing it with the `contentChildren()` function.\n *\n * ```ts\n * @Component({...})\n * export class TestComponent {\n *   headerEl = contentChildren<ElementRef>('h');   // Signal<ReadonlyArray<ElementRef>>\n * }\n * ```\n *\n * @initializerApiFunction\n * @developerPreview\n */\nexport function contentChildren<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts?: {descendants?: boolean, read?: ProviderToken<ReadT>}): Signal<ReadonlyArray<ReadT>> {\n  return createMultiResultQuerySignalFn<ReadT>();\n}\n"]}