Improve angular type

Author: tolyo

@types/angular.d.ts

@@ -1,20 +1,19 @@
 export class Angular {
-  _$cache: Map<number, import("./interface.ts").ExpandoStore>;
+  /** @private @type {!Array<string|any>} */
+  private _bootsrappedModules;
   /** @public @type {ng.PubSubService} */
   public $eventBus: ng.PubSubService;
   /**
    * @public
    * @type {string} `version` from `package.json`
    */
   public version: string;
-  /** @type {!Array<string|any>} */
-  _bootsrappedModules: Array<string | any>;
   /**
    * Gets the controller instance for a given element, if exists. Defaults to "ngControllerController"
    *
-   * @type {(element: Element, name?: string) => ng.Scope|undefined}
+   * @type {typeof getController}
    */
-  getController: (element: Element, name?: string) => ng.Scope | undefined;
+  getController: typeof getController;
   /**
    * Return instance of InjectorService attached to element
    * @type {typeof getInjector}
@@ -25,8 +24,10 @@ export class Angular {
    *  @type {typeof getScope}
    */
   getScope: typeof getScope;
+  /** @type {typeof errorHandlingConfig} */
   errorHandlingConfig: typeof errorHandlingConfig;
-  $t: Readonly<Record<string, string>>;
+  /** @type {ng.InjectionTokens} */
+  $t: ng.InjectionTokens;
   /**
    *
    * The `angular.module` is a global place for creating, registering and retrieving AngularTS
@@ -158,6 +159,7 @@ export class Angular {
 export type ModuleRegistry = {
   [x: string]: NgModule;
 };
+import { getController } from "./shared/dom.js";
 import { getInjector } from "./shared/dom.js";
 import { getScope } from "./shared/dom.js";
 import { errorHandlingConfig } from "./shared/utils.js";

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

@@ -1,5 +1,5 @@
-export function nextId(): number;
 /**
+ * @private
  * Creates a deep proxy for the target object, intercepting property changes
  * and recursively applying proxies to nested objects.
  *
@@ -16,8 +16,6 @@ export function createScope(target?: any, context?: Scope): Scope;
  * @returns {boolean}
  */
 export function isNonScope(target: any): boolean;
-export const $postUpdateQueue: any[];
-export let rootScope: any;
 export class RootScopeProvider {
   rootScope: Scope;
   $get: (

@types/injection-tokens.d.ts

@@ -11,8 +11,8 @@ export function provider(services: string[]): string[];
  * ```js
  *
  * myDirective.$inject = [
- *   angular.$t._animate,
- *   angular.$t._templateRequest,
+ *   angular.$t.$animate,
+ *   angular.$t.$templateRequest,
  * ];
  *
  * function myDirective($animate, $templateRequest) { ... }

@types/interface.d.ts

@@ -1,6 +1,52 @@
 import { Attributes } from "./core/compile/attributes.js";
 import { Scope } from "./core/scope/scope.js";
 import { NgModelController } from "./directive/model/model.js";
+export declare const PublicInjectionTokens: {
+  readonly $attrs: "$attrs";
+  readonly $scope: "$scope";
+  readonly $element: "$element";
+  readonly $anchorScroll: "$anchorScroll";
+  readonly $animate: "$animate";
+  readonly $animateCss: "$animateCss";
+  readonly $aria: "$aria";
+  readonly $compile: "$compile";
+  readonly $cookie: "$cookie";
+  readonly $controller: "$controller";
+  readonly $document: "$document";
+  readonly $eventBus: "$eventBus";
+  readonly $exceptionHandler: "$exceptionHandler";
+  readonly $filter: "$filter";
+  readonly $http: "$http";
+  readonly $httpParamSerializer: "$httpParamSerializer";
+  readonly $interpolate: "$interpolate";
+  readonly $location: "$location";
+  readonly $log: "$log";
+  readonly $viewScroll: "$viewScroll";
+  readonly $parse: "$parse";
+  readonly $rest: "$rest";
+  readonly $rootScope: "$rootScope";
+  readonly $rootElement: "$rootElement";
+  readonly $router: "$router";
+  readonly $sce: "$sce";
+  readonly $sceDelegate: "$sceDelegate";
+  readonly $state: "$state";
+  readonly $stateRegistry: "$stateRegistry";
+  readonly $sse: "$sse";
+  readonly $templateCache: "$templateCache";
+  readonly $templateFactory: "$templateFactory";
+  readonly $templateRequest: "$templateRequest";
+  readonly $transitions: "$transitions";
+  readonly $urlConfig: "$urlConfig";
+  readonly $url: "$url";
+  readonly $view: "$view";
+  readonly $window: "$window";
+  readonly $provide: "$provide";
+  readonly $injector: "$injector";
+  readonly $compileProvider: "$compileProvider";
+  readonly $animateProvider: "$animateProvider";
+  readonly $filterProvider: "$filterProvider";
+  readonly $controllerProvider: "$controllerProvider";
+};
 /**
  * Configuration options for the AngularTS bootstrap process.
  *

@types/namespace.d.ts

@@ -48,6 +48,7 @@ import {
   ControllerConstructor as TControllerConstructor,
   Injectable as TInjectable,
   Expression as TExpression,
+  PublicInjectionTokens,
 } from "./interface.ts";
 import {
   SseService as TSseService,
@@ -200,5 +201,6 @@ declare global {
     type StateObject = TStateObject;
     type AnchorScrollFunction = TAnchorScrollFunction;
     type AnchorScrollObject = TAnchorScrollObject;
+    type InjectionTokens = typeof PublicInjectionTokens;
   }
 }

@types/services/cookie/cookie.d.ts

@@ -28,7 +28,7 @@ export class CookieService {
   );
   /** @private @type {ng.CookieOptions} */
   private _defaults;
-  /** @private */
+  /** @private @type {ng.ExceptionHandlerService} */
   private _$exceptionHandler;
   /**
    * Retrieves a raw cookie value.

@types/services/pubsub/pubsub.d.ts

@@ -72,6 +72,7 @@ export class PubSub {
    */
   publish(topic: string, ...args: any[]): boolean;
 }
+/** @private */
 export const EventBus: PubSub;
 /**
  * /**

@types/shared/validate.d.ts

@@ -31,6 +31,19 @@ export function validateArray(arg: any, name: string): any;
  * @throws {TypeError} If the value does not satisfy the validator.
  */
 export function validateIsString(arg: any, name: string): any;
+/**
+ * @template T
+ * @param {unknown} arg - The value to validate.
+ * @param {new (...args: any[]) => T} type - The constructor to check against.
+ * @param {string} name - Parameter name (included in error message).
+ * @returns {T} The validated instance.
+ * @throws {TypeError} If the value is not an instance of the specified type.
+ */
+export function validateInstanceOf<T>(
+  arg: unknown,
+  type: new (...args: any[]) => T,
+  name: string,
+): T;
 export const BADARG: "badarg";
 export const BADARGKEY: "badarg: key";
 export const BADARGVALUE: "badarg: value";