Test fixes

Author: Anatoly Ostrovsky

@types/core/compile/attributes.d.ts

@@ -1,6 +1,3 @@
-/**
- * @extends {Record<string, any>}
- */
 export class Attributes {
   static $nonscope: boolean;
   /**
@@ -16,7 +13,7 @@ export class Attributes {
    *    - Used when cloning attributes for directive linking / child scopes.
    *    - Performs a shallow copy of all properties from the source Attributes object,
    *      including `$attr`, normalized attribute values, and internal fields
-   *      (e.g. `$$observers`).
+   *      (e.g. `_observers`).
    *    - `$attr` is intentionally **not reinitialized** in this case, because the
    *      source object already contains the correct normalized → DOM attribute mapping.
    *
@@ -33,14 +30,18 @@ export class Attributes {
     nodeRef?: import("../../shared/noderef.js").NodeRef,
     attributesToCopy?: any & Record<string, any>,
   );
-  _$animate: import("../../animations/interface.ts").AnimateService;
-  _$exceptionHandler: import("../../services/exception/interface.ts").ExceptionHandler;
-  _$sce: import("../../services/sce/interface.ts").SCEService;
+  /** @type {ng.AnimateService} */
+  _animate: ng.AnimateService;
+  /** @type {ng.ExceptionHandlerService} */
+  _exceptionHandler: ng.ExceptionHandlerService;
+  /** @type {ng.SCEService} */
+  _sce: ng.SCEService;
   /**
    * A map of DOM element attribute names to the normalized name. This is needed
    * to do reverse lookup from normalized name back to actual name.
+   * @type {Record<string, string>}
    */
-  $attr: {};
+  $attr: Record<string, string>;
   /** @type {import("../../shared/noderef.js").NodeRef | undefined} */
   _nodeRef: import("../../shared/noderef.js").NodeRef | undefined;
   /** @ignore @returns {Node|Element} */
@@ -109,8 +110,23 @@ export class Attributes {
     * @returns {Function} Returns a deregistration function for this observer.
     */
   $observe<T>(key: string, fn: (value?: T) => any): Function;
-  $$observers: any;
-  setSpecialAttr(element: any, attrName: any, value: any): void;
+  _observers: any;
+  /**
+   * Sets a special (non-standard) attribute on an element.
+   *
+   * Used for attribute names that cannot be set via `setAttribute`
+   * (e.g. names not starting with a letter like `(click)`).
+   *
+   * @param {Element} element
+   * @param {string} attrName
+   * @param {string | null} value
+   * @returns {void}
+   */
+  setSpecialAttr(
+    element: Element,
+    attrName: string,
+    value: string | null,
+  ): void;
   /**
    *
    * @param {unknown} value

@types/core/compile/compile.d.ts

@@ -113,7 +113,7 @@ export class CompileProvider {
    *
    * @param {string} elementName The element name or '*' to match any element.
    * @param {string} propertyName The DOM property name.
-   * @param {string} ctx The {@link _$sce} security context in which this value is safe for use, e.g. `$sce.URL`
+   * @param {string} ctx The {@link _sce} security context in which this value is safe for use, e.g. `$sce.URL`
    * @returns {object} `this` for chaining
    */
   addPropertySecurityContext: (

@types/core/parse/interface.d.ts

@@ -24,7 +24,6 @@ export interface CompiledExpressionProps {
   _watchDelegate?: (
     scope: Scope,
     listener: Function,
-    equalityCheck: boolean,
     expression: CompiledExpression | string | ((scope: Scope) => any),
   ) => any;
   /** Expression inputs; may be an array or a function. */

@types/core/parse/parse.d.ts

@@ -1,7 +1,6 @@
 export function constantWatchDelegate(
   scope: any,
   listener: any,
-  objectEquality: any,
   parsedExpression: any,
 ): any;
 export class ParseProvider {

@types/core/scope/interface.d.ts

@@ -1,5 +1,6 @@
 import type { CompiledExpression } from "../parse/interface.ts";
 export type ListenerFn = (newValue?: any, originalTarget?: object) => void;
+export type NonScope = string[] | boolean | undefined;
 export interface Listener {
   originalTarget: any;
   listenerFn: ListenerFn;

@types/core/scope/scope.d.ts

@@ -3,20 +3,24 @@
  * Creates a deep proxy for the target object, intercepting property changes
  * and recursively applying proxies to nested objects.
  *
- * @param {Object} target - The object to be wrapped in a proxy.
+ * @param {Object & {$nonscope?: import("./interface.ts").NonScope} & Record<string, any>} target - The object to be wrapped in a proxy.
  * @param {Scope} [context] - The context for the handler, used to track listeners.
  * @returns {Scope|Object} - A proxy that intercepts operations on the target object,
  *                                     or the original value if the target is not an object.
  */
-export function createScope(target?: any, context?: Scope): Scope | any;
+export function createScope(
+  target?: any & {
+    $nonscope?: import("./interface.ts").NonScope;
+  } & Record<string, any>,
+  context?: Scope,
+): Scope | any;
 /**
- * @ignore
  * Checks if a target should be excluded from scope observability
  * @param {any} target
  * @returns {boolean}
  */
 export function isNonScope(target: any): boolean;
-/** @ignore @type {Function[]}*/
+/** @ignore @type {Function[]} */
 export const $postUpdateQueue: Function[];
 export class RootScopeProvider {
   rootScope: any;

@types/directive/form/form.d.ts

@@ -101,13 +101,13 @@ export class FormController {
   $invalid: boolean;
   $submitted: boolean;
   /** @type {FormController|Object} */
-  $$parentForm: FormController | any;
+  _parentForm: FormController | any;
   _element: Element;
-  $$animate: import("../../animations/interface.ts").AnimateService;
+  _animate: import("../../animations/interface.ts").AnimateService;
   $error: {};
-  $$success: {};
+  _success: {};
   $pending: any;
-  $$classCache: {};
+  _classCache: {};
   $target: {};
   /**
    * Rollback all form controls pending updates to the `$modelValue`.

@types/directive/model-options/model-options.d.ts

@@ -27,7 +27,6 @@ export type ModelOptionsConfig = {
   updateOnDefault?: boolean;
 };
 /**
- *
  * A container for the options set by the {@link ngModelOptions} directive
  */
 declare class ModelOptions {

@types/namespace.d.ts

@@ -128,6 +128,7 @@ import {
 declare global {
   interface Function {
     $inject?: readonly string[] | undefined;
+    $nonscope?: readonly string[] | boolean | undefined;
   }
   interface Window {
     angular: TAngular;

@types/router/state/state-service.d.ts

@@ -1,3 +1,4 @@
+export function silentRejection<E = unknown>(error: E): Promise<never>;
 /**
  * Provides services related to ng-router states.
  *