Test and type fixes

Author: Anatoly Ostrovsky

@types/angular.d.ts

@@ -124,14 +124,14 @@ export class Angular {
    * @param {string} name The name of the module to create or retrieve.
    * @param {Array.<string>} [requires] If specified then new module is being created. If
    *        unspecified then the module is being retrieved for further configuration.
-   * @param {Array<any>|Function} [configFn] Optional configuration function for the module that gets
+   * @param {import("./interface.js").Injectable} [configFn] Optional configuration function for the module that gets
    *        passed to {@link NgModule.config NgModule.config()}.
    * @returns {NgModule} A newly registered module.
    */
   module(
     name: string,
     requires?: Array<string>,
-    configFn?: Array<any> | Function,
+    configFn?: import("./interface.js").Injectable,
   ): NgModule;
 }
 /**

@types/core/di/ng-module.d.ts

@@ -22,9 +22,13 @@ export class NgModule {
   /**
    * @param {string} name - Name of the module
    * @param {Array<string>} requires - List of modules which the injector will load before the current module
-   * @param {Function} [configFn]
+   * @param {import("../../interface.js").Injectable} [configFn]
    */
-  constructor(name: string, requires: Array<string>, configFn?: Function);
+  constructor(
+    name: string,
+    requires: Array<string>,
+    configFn?: import("../../interface.js").Injectable,
+  );
   /**
    * Name of the current module.
    * @type {string}
@@ -42,8 +46,8 @@ export class NgModule {
   invokeQueue: Array<Array<any>>;
   /** @type {!Array<Array<*>>} */
   configBlocks: Array<Array<any>>;
-  /** @type {!Array.<Function>} */
-  runBlocks: Array<Function>;
+  /** @type {!Array.<import("../../interface.js").Injectable>} */
+  runBlocks: Array<import("../../interface.js").Injectable>;
   /**
    * @param {string} name
    * @param {any} object
@@ -58,62 +62,94 @@ export class NgModule {
   constant(name: string, object: any): NgModule;
   /**
    *
-   * @param {Function} configFn
+   * @param {import("../../interface.js").Injectable} configFn
    * @returns {NgModule}
    */
-  config(configFn: Function): NgModule;
+  config(configFn: import("../../interface.js").Injectable): NgModule;
   /**
-   * @param {Function} block
+   * @param {import("../../interface.js").Injectable} block
    * @returns {NgModule}
    */
-  run(block: Function): NgModule;
+  run(block: import("../../interface.js").Injectable): NgModule;
   /**
    * @param {string} name
-   * @param {*} options
+   * @param {import("../../interface.js").Injectable} options
    * @returns {NgModule}
    */
-  component(name: string, options: any): NgModule;
+  component(
+    name: string,
+    options: import("../../interface.js").Injectable,
+  ): NgModule;
   /**
    * @param {string} name
-   * @param {*} providerFunction
+   * @param {import("../../interface.js").Injectable} providerFunction
    * @returns {NgModule}
    */
-  factory(name: string, providerFunction: any): NgModule;
+  factory(
+    name: string,
+    providerFunction: import("../../interface.js").Injectable,
+  ): NgModule;
   /**
    * @param {string} name
-   * @param {*} serviceFunction
+   * @param {import("../../interface.js").Injectable} serviceFunction
    * @returns {NgModule}
    */
-  service(name: string, serviceFunction: any): NgModule;
+  service(
+    name: string,
+    serviceFunction: import("../../interface.js").Injectable,
+  ): NgModule;
   /**
    * @param {string} name
-   * @param {*} providerType
+   * @param {import("../../interface.js").Injectable} providerType
    * @returns {NgModule}
    */
-  provider(name: string, providerType: any): NgModule;
+  provider(
+    name: string,
+    providerType: import("../../interface.js").Injectable,
+  ): NgModule;
   /**
    * @param {string} name
-   * @param {*} decorFn
+   * @param {import("../../interface.js").Injectable} decorFn
    * @returns {NgModule}
    */
-  decorator(name: string, decorFn: any): NgModule;
+  decorator(
+    name: string,
+    decorFn: import("../../interface.js").Injectable,
+  ): NgModule;
   /**
    * @param {string} name
-   * @param {*} directiveFactory
+   * @param {import("../../interface.js").Injectable} directiveFactory
    * @returns {NgModule}
    */
-  directive(name: string, directiveFactory: any): NgModule;
+  directive(
+    name: string,
+    directiveFactory: import("../../interface.js").Injectable,
+  ): NgModule;
   /**
    * @param {string} name
-   * @param {*} animationFactory
+   * @param {import("../../interface.js").Injectable} animationFactory
    * @returns {NgModule}
    */
-  animation(name: string, animationFactory: any): NgModule;
-  filter(name: any, filterFn: any): this;
+  animation(
+    name: string,
+    animationFactory: import("../../interface.js").Injectable,
+  ): NgModule;
   /**
    * @param {string} name
-   * @param {*} ctlFn
+   * @param {import("../../interface.js").Injectable} filterFn
+   * @return {NgModule}
+   */
+  filter(
+    name: string,
+    filterFn: import("../../interface.js").Injectable,
+  ): NgModule;
+  /**
+   * @param {string} name
+   * @param {import("../../interface.js").Injectable} ctlFn
    * @returns {NgModule}
    */
-  controller(name: string, ctlFn: any): NgModule;
+  controller(
+    name: string,
+    ctlFn: import("../../interface.js").Injectable,
+  ): NgModule;
 }

@types/interface.d.ts

@@ -36,13 +36,13 @@ export type ExpandoStore = {
  * ```
  */
 export type AnnotatedFactory = [...string[], (...args: any[]) => any];
+export type InjectableFactory = (...args: any[]) => any;
 /**
  * A factory that can be either a standalone function or a dependency-annotated array.
  *
  * The array form is used to support minification-safe dependency injection.
  * See {@link AnnotatedFactory}.
  */
-export type InjectableFactory = (...args: any[]) => any;
 export type Injectable = AnnotatedFactory | InjectableFactory;
 /**
  * An object that defines how a service is constructed.

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

@@ -27,15 +27,15 @@ export namespace $StateRefDynamicDirective {
 }
 /**
  * @param {*} $state
- * @param {import('../globals.js').Router} $router
+ * @param {import('../router.js').Router} $router
  * @param {*} $interpolate
  * @param {*} $stateRegistry
  * @param {*} $transitions
  * @returns {import("../../interface.ts").Directive}
  */
 export function $StateRefActiveDirective(
   $state: any,
-  $router: import("../globals.js").Router,
+  $router: import("../router.js").Router,
   $interpolate: any,
   $stateRegistry: any,
   $transitions: any,

@types/router/params/param-type.d.ts

@@ -25,7 +25,6 @@ export class ParamType {
   /**
    * @param def  A configuration object which contains the custom type definition.  The object's
    *        properties will override the default methods and/or pattern in `ParamType`'s public interface.
-   * @returns a new ParamType object
    */
   constructor(def: any);
   pattern: RegExp;

@types/router/globals.d.ts renamed to @types/router/router.d.ts

@@ -10,13 +10,13 @@ export class StateRegistryProvider {
   /**
    * @param urlService
    * @param stateService
-   * @param {import('../globals.js').Router} globals
+   * @param {import('../router.js').Router} globals
    * @param viewService
    */
   constructor(
     urlService: any,
     stateService: any,
-    globals: import("../globals.js").Router,
+    globals: import("../router.js").Router,
     viewService: any,
   );
   states: {};

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

@@ -7,10 +7,10 @@ export class StateProvider {
   static $inject: string[];
   /**
    *
-   * @param {import('../globals.js').Router} globals
+   * @param {import('../router.js').Router} globals
    * @param {*} transitionService
    */
-  constructor(globals: import("../globals.js").Router, transitionService: any);
+  constructor(globals: import("../router.js").Router, transitionService: any);
   /**
    * The latest successful state parameters
    *
@@ -31,7 +31,7 @@ export class StateProvider {
   get $current(): import("./state-object.js").StateObject;
   stateRegistry: any;
   urlService: any;
-  globals: import("../globals.js").Router;
+  globals: import("../router.js").Router;
   transitionService: any;
   invalidCallbacks: any[];
   _defaultErrorHandler: ($error$: any) => never;

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

@@ -23,18 +23,18 @@ export namespace defaultTransOpts {
 export class TransitionProvider {
   static $inject: string[];
   /**
-   * @param {import('../globals.js').Router} globals
+   * @param {import('../router.js').Router} globals
    * @param viewService
    */
-  constructor(globals: import("../globals.js").Router, viewService: any);
+  constructor(globals: import("../router.js").Router, viewService: any);
   _transitionCount: number;
   /** The transition hook types, such as `onEnter`, `onStart`, etc */
   _eventTypes: any[];
   /** @internal The registered transition hooks */
   _registeredHooks: {};
   /** The  paths on a criteria object */
   _criteriaPaths: {};
-  globals: import("../globals.js").Router;
+  globals: import("../router.js").Router;
   $view: any;
   _deregisterHookFns: {};
   _pluginapi: any;

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

@@ -18,18 +18,18 @@ export class Transition implements IHookRegistry {
    *        encapsulates the "from state".
    * @param {import('../state/target-state.js').TargetState} targetState The target state and parameters being transitioned to (also, the transition options)
    * @param {import('../transition/transition-service.js').TransitionProvider} transitionService The [[TransitionService]] instance
-   * @param {import('../globals.js').Router} globals
+   * @param {import('../router.js').Router} globals
    */
   constructor(
     fromPath: Array<import("../path/path-node.js").PathNode>,
     targetState: import("../state/target-state.js").TargetState,
     transitionService: import("../transition/transition-service.js").TransitionProvider,
-    globals: import("../globals.js").Router,
+    globals: import("../router.js").Router,
   );
   /**
-   * @type {import('../globals.js').Router}
+   * @type {import('../router.js').Router}
    */
-  globals: import("../globals.js").Router;
+  globals: import("../router.js").Router;
   transitionService: import("../transition/transition-service.js").TransitionProvider;
   _deferred: any;
   /**