@angular-wave/angular.ts 0.9.9 → 0.11.0

package/@types/angular.d.ts

@@ -1,16 +1,32 @@
 export class Angular {
   $cache: Map<number, import("./interface.ts").ExpandoStore>;
-  /** @type {import('./services/pubsub/pubsub.js').PubSub} */
-  $eventBus: import("./services/pubsub/pubsub.js").PubSub;
+  /** @type {ng.PubSubService} */
+  $eventBus: ng.PubSubService;
   /**
    * @type {string} `version` from `package.json`
    */
   version: string;
   /** @type {!Array<string|any>} */
   bootsrappedModules: Array<string | any>;
-  getController: typeof getController;
-  getInjector: typeof getInjector;
-  getScope: typeof getScope;
+  /**
+   * Gets the controller instance for a given element, if exists. Defaults to "ngControllerController"
+   *
+   * @type {(element: Element, name: string?) => ng.Scope|undefined}
+   */
+  getController: (
+    element: Element,
+    name: string | null,
+  ) => ng.Scope | undefined;
+  /**
+   * Return instance of InjectorService attached to element
+   * @type {(Element) => ng.InjectorService}
+   */
+  getInjector: (Element: any) => ng.InjectorService;
+  /**
+   * Gets scope for a given element.
+   * @type {(Element) => *}
+   */
+  getScope: (Element: any) => any;
   errorHandlingConfig: typeof errorHandlingConfig;
   $t: Readonly<Record<string, string>>;
   /**
@@ -61,7 +77,7 @@ export class Angular {
     modules?: Array<string | any>,
     config?: import("./interface.ts").AngularBootstrapConfig,
   ): import("./core/di/internal-injector.js").InjectorService;
-  $injector: import("./core/di/internal-injector.js").InjectorService;
+  $injector: import("./interface.ts").InjectorService;
   /**
    * @param {any[]} modules
    * @param {boolean?} strictDi
@@ -118,18 +134,15 @@ 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 {import("./interface.js").Injectable<any>} [configFn] Optional configuration function for the module that gets
+   * @param {import("./interface.ts").Injectable<any>} [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?: import("./interface.js").Injectable<any>,
+    configFn?: import("./interface.ts").Injectable<any>,
   ): 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";
 import { NgModule } from "./core/di/ng-module.js";

package/@types/animations/animate-css-driver.d.ts

@@ -8,7 +8,6 @@ export class AnimateCssDriverProvider {
     | string
     | ((
         $animateCss: any,
-        $$AnimateRunner: typeof import("./animate-runner.js").AnimateRunner,
         $rootElement: Element,
       ) => (animationDetails: any) => any)
   )[];

package/@types/animations/animate-css.d.ts

@@ -3,7 +3,6 @@ export class AnimateCssProvider {
   $get: (
     | string
     | ((
-        $$AnimateRunner: any,
         $$animateCache: any,
         $$rAFScheduler: any,
       ) => (

package/@types/animations/animate-js-driver.d.ts

@@ -1,13 +1,7 @@
 export function AnimateJsDriverProvider($$animationProvider: any): void;
 export class AnimateJsDriverProvider {
   constructor($$animationProvider: any);
-  $get: (
-    | string
-    | ((
-        $$animateJs: any,
-        $$AnimateRunner: any,
-      ) => (animationDetails: any) => any)
-  )[];
+  $get: (string | (($$animateJs: any) => (animationDetails: any) => any))[];
 }
 export namespace AnimateJsDriverProvider {
   let $inject: string[];

package/@types/animations/animate-js.d.ts

@@ -3,10 +3,7 @@ export class AnimateJsProvider {
   constructor($animateProvider: any);
   $get: (
     | string
-    | ((
-        $injector: any,
-        $$AnimateRunner: any,
-      ) => (
+    | (($injector: ng.InjectorService) => (
         element: any,
         event: any,
         classes: any,

package/@types/animations/animate-queue.d.ts

@@ -9,17 +9,15 @@ export class AnimateQueueProvider {
   $get: (
     | string
     | ((
-        $rootScope: import("../core/scope/scope.js").Scope,
-        $injector: import("../core/di/internal-injector.js").InjectorService,
+        $rootScope: ng.RootScopeService,
+        $injector: ng.InjectorService,
         $$animation: any,
-        $$AnimateRunner: any,
         $templateRequest: any,
       ) => {
         on(event: any, container: any, callback: any): void;
         off(event: any, container: any, callback: any, ...args: any[]): void;
         pin(element: any, parentElement: any): void;
         push(element: any, event: any, options: any, domOperation: any): any;
-        enabled(element: any, bool: any, ...args: any[]): any;
       })
   )[];
 }

package/@types/animations/animate-swap.d.ts

@@ -1,9 +1,7 @@
 /**
- * @returns {import('../interface.ts').Directive}
+ * @returns {ng.Directive}
  */
-export function ngAnimateSwapDirective(
-  $animate: any,
-): import("../interface.ts").Directive;
+export function ngAnimateSwapDirective($animate: any): ng.Directive;
 export namespace ngAnimateSwapDirective {
   let $inject: string[];
 }

package/@types/animations/animate.d.ts

@@ -1,10 +1,8 @@
-/** @param {import('../interface.ts').Provider} $provide */
-export function AnimateProvider(
-  $provide: import("../interface.ts").Provider,
-): void;
+/** @param {ng.ProvideService} $provide */
+export function AnimateProvider($provide: ng.ProvideService): void;
 export class AnimateProvider {
-  /** @param {import('../interface.ts').Provider} $provide */
-  constructor($provide: import("../interface.ts").Provider);
+  /** @param {ng.ProvideService} $provide */
+  constructor($provide: ng.ProvideService);
   $$registeredAnimations: any;
   /**
    * Registers a new injectable animation factory function. The factory function produces the
@@ -218,7 +216,7 @@ export class AnimateProvider {
        * Note that this does not cancel the underlying operation, e.g. the setting of classes or
        * adding the element to the DOM.
        *
-       * @param {import('./animate-runner.js').AnimateRunner} runner An animation runner returned by an $animate function.
+       * @param {import('./runner/animate-runner.js').AnimateRunner} runner An animation runner returned by an $animate function.
        *
        * @example
         <example module="animationExample" deps="angular-animate.js" animations="true" name="animate-cancel">
@@ -282,7 +280,9 @@ export class AnimateProvider {
           </file>
         </example>
        */
-        cancel(runner: import("./animate-runner.js").AnimateRunner): void;
+        cancel(
+          runner: import("./runner/animate-runner.js").AnimateRunner,
+        ): void;
         /**
          * Inserts the element into the DOM either after the `after` element (if provided) or
          * as the first child within the `parent` element and then triggers an animation.
@@ -291,16 +291,16 @@ export class AnimateProvider {
          *
          * @param {Element} element - the element which will be inserted into the DOM
          * @param {Element} parent - the parent element which will append the element as a child (so long as the after element is not present)
-         * @param {Element} after - after the sibling element after which the element will be appended
+         * @param {Element} [after] - after the sibling element after which the element will be appended
          * @param {AnimationOptions} [options] - an optional collection of options/styles that will be applied to the element.
-         * @returns {import('./animate-runner.js').AnimateRunner} the animation runner
+         * @returns {import('./runner/animate-runner.js').AnimateRunner} the animation runner
          */
         enter(
           element: Element,
           parent: Element,
-          after: Element,
+          after?: Element,
           options?: AnimationOptions,
-        ): import("./animate-runner.js").AnimateRunner;
+        ): import("./runner/animate-runner.js").AnimateRunner;
         /**
          * Inserts (moves) the element into its new position in the DOM either after
          * the `after` element (if provided) or as the first child within the `parent` element
@@ -311,14 +311,14 @@ export class AnimateProvider {
          * @param {Element} parent - the parent element which will append the element as a child (so long as the after element is not present)
          * @param {Element} after - after the sibling element after which the element will be appended
          * @param {AnimationOptions} [options] - an optional collection of options/styles that will be applied to the element.
-         * @returns {import('./animate-runner.js').AnimateRunner} the animation runner
+         * @returns {import('./runner/animate-runner.js').AnimateRunner} the animation runner
          */
         move(
           element: Element,
           parent: Element,
           after: Element,
           options?: AnimationOptions,
-        ): import("./animate-runner.js").AnimateRunner;
+        ): import("./runner/animate-runner.js").AnimateRunner;
         /**
          * Triggers an animation and then removes the element from the DOM.
          * When the function is called a promise is returned that will be resolved during the next
@@ -326,12 +326,12 @@ export class AnimateProvider {
          *
          * @param {Element} element the element which will be removed from the DOM
          * @param {AnimationOptions} [options] an optional collection of options/styles that will be applied to the element.
-         * @returns {import('./animate-runner.js').AnimateRunner} the animation runner
+         * @returns {import('./runner/animate-runner.js').AnimateRunner} the animation runner
          */
         leave(
           element: Element,
           options?: AnimationOptions,
-        ): import("./animate-runner.js").AnimateRunner;
+        ): import("./runner/animate-runner.js").AnimateRunner;
         /**
          * Triggers an addClass animation surrounding the addition of the provided CSS class(es). Upon
          * execution, the addClass operation will only be handled after the next digest and it will not trigger an
@@ -343,13 +343,13 @@ export class AnimateProvider {
          * @param {Element} element the element which the CSS classes will be applied to
          * @param {string} className the CSS class(es) that will be added (multiple classes are separated via spaces)
          * @param {AnimationOptions} [options] an optional collection of options/styles that will be applied to the element.
-         * @return {import('./animate-runner.js').AnimateRunner}} animationRunner the animation runner
+         * @return {import('./runner/animate-runner.js').AnimateRunner}} animationRunner the animation runner
          */
         addClass(
           element: Element,
           className: string,
           options?: AnimationOptions,
-        ): import("./animate-runner.js").AnimateRunner;
+        ): import("./runner/animate-runner.js").AnimateRunner;
         /**
          * Triggers a removeClass animation surrounding the removal of the provided CSS class(es). Upon
          * execution, the removeClass operation will only be handled after the next digest and it will not trigger an
@@ -361,13 +361,13 @@ export class AnimateProvider {
          * @param {Element} element the element which the CSS classes will be applied to
          * @param {string} className the CSS class(es) that will be removed (multiple classes are separated via spaces)
          * @param {AnimationOptions} [options] an optional collection of options/styles that will be applied to the element.         *
-         * @return {import('./animate-runner.js').AnimateRunner} animationRunner the animation runner
+         * @return {import('./runner/animate-runner.js').AnimateRunner} animationRunner the animation runner
          */
         removeClass(
           element: Element,
           className: string,
           options?: AnimationOptions,
-        ): import("./animate-runner.js").AnimateRunner;
+        ): import("./runner/animate-runner.js").AnimateRunner;
         /**
          * Performs both the addition and removal of a CSS classes on an element and (during the process)
          * triggers an animation surrounding the class addition/removal. Much like `$animate.addClass` and
@@ -381,14 +381,14 @@ export class AnimateProvider {
          * @param {string} remove the CSS class(es) that will be removed (multiple classes are separated via spaces)
          * @param {object=} options an optional collection of options/styles that will be applied to the element.
          *
-         * @return {import('./animate-runner.js').AnimateRunner} the animation runner
+         * @return {import('./runner/animate-runner.js').AnimateRunner} the animation runner
          */
         setClass(
           element: Element,
           add: string,
           remove: string,
           options?: object | undefined,
-        ): import("./animate-runner.js").AnimateRunner;
+        ): import("./runner/animate-runner.js").AnimateRunner;
         /**
          * Performs an inline animation on the element which applies the provided to and from CSS styles to the element.
          * If any detected CSS transition, keyframe or JavaScript matches the provided className value, then the animation will take
@@ -408,7 +408,7 @@ export class AnimateProvider {
          *   }
          * });
          * ```
-         *  @return {import('./animate-runner.js').AnimateRunner} the animation runner
+         *  @return {import('./runner/animate-runner.js').AnimateRunner} the animation runner
          */
         animate(
           element: any,
@@ -416,7 +416,7 @@ export class AnimateProvider {
           to: any,
           className: any,
           options: any,
-        ): import("./animate-runner.js").AnimateRunner;
+        ): import("./runner/animate-runner.js").AnimateRunner;
       })
   )[];
 }

package/@types/animations/animation.d.ts

@@ -6,9 +6,9 @@ export class AnimationProvider {
     | ((
         $rootScope: ng.RootScopeService,
         $injector: any,
-        $$AnimateRunner: any,
         $$rAFScheduler: any,
         $$animateCache: any,
-      ) => (element: any, event: any, options: any) => any)
+      ) => (element: any, event: any, options: any) => AnimateRunner)
   )[];
 }
+import { AnimateRunner } from "./runner/animate-runner.js";

package/@types/animations/interface.d.ts

@@ -15,3 +15,15 @@ export type RafScheduler = {
    */
   waitUntilQuiet(fn: () => void): void;
 };
+export interface AnimationHost {
+  /** Pause animation. */
+  pause?: () => void;
+  /** Resume animation. */
+  resume?: () => void;
+  /** End animation. */
+  end?: () => void;
+  /** Cancel animation. */
+  cancel?: () => void;
+  /** Report animation progress. */
+  progress?: (...args: any[]) => void;
+}

package/@types/animations/raf-scheduler.d.ts

@@ -1,6 +1,6 @@
 /**
- * @typedef {import('./interface.js').RafScheduler} RafScheduler
- * @typedef {import('../interface.js').ServiceProvider} ServiceProvider
+ * @typedef {import('./interface.ts').RafScheduler} RafScheduler
+ * @typedef {import('../interface.ts').ServiceProvider} ServiceProvider
  */
 /**
  * Service provider that creates a requestAnimationFrame-based scheduler.
@@ -33,5 +33,5 @@ export class RafSchedulerProvider {
    */
   $get(): RafScheduler;
 }
-export type RafScheduler = import("./interface.js").RafScheduler;
-export type ServiceProvider = import("../interface.js").ServiceProvider;
+export type RafScheduler = import("./interface.ts").RafScheduler;
+export type ServiceProvider = import("../interface.ts").ServiceProvider;

package/@types/animations/runner/animate-runner.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Schedule a callback to run on the next animation frame.
+ * Multiple calls within the same frame are batched together.
+ *
+ * @param {VoidFunction} fn - The callback to execute.
+ */
+export function schedule(fn: VoidFunction): void;
+/**
+ * Represents an asynchronous animation operation.
+ * Provides both callback-based and promise-based completion APIs.
+ */
+export class AnimateRunner {
+  /**
+   * Run an array of animation runners in sequence.
+   * Each runner waits for the previous one to complete.
+   *
+   * @param {AnimateRunner[]} runners - Runners to execute in order.
+   * @param {(ok: boolean) => void} callback - Invoked when all complete or one fails.
+   */
+  static chain(runners: AnimateRunner[], callback: (ok: boolean) => void): void;
+  /**
+   * Waits for all animation runners to complete before invoking the callback.
+   *
+   * @param {AnimateRunner[]} runners - Active runners to wait for.
+   * @param {(ok: boolean) => void} callback - Called when all runners complete.
+   */
+  static all(runners: AnimateRunner[], callback: (ok: boolean) => void): void;
+  /**
+   * @param {import("../interface.ts").AnimationHost} [host] - Optional animation host.
+   */
+  constructor(host?: import("../interface.ts").AnimationHost);
+  /** @type {import("../interface.ts").AnimationHost} */
+  host: import("../interface.ts").AnimationHost;
+  /** @type {Array<(ok: boolean) => void>} */
+  _doneCallbacks: Array<(ok: boolean) => void>;
+  /** @type {RunnerState} */
+  _state: RunnerState;
+  /** @type {Promise<void>|null} */
+  _promise: Promise<void> | null;
+  /** @type {(fn: VoidFunction) => void} */
+  _schedule: (fn: VoidFunction) => void;
+  /**
+   * Sets or updates the animation host.
+   * @param {import("../interface.ts").AnimationHost} host - The host object.
+   */
+  setHost(host: import("../interface.ts").AnimationHost): void;
+  /**
+   * Registers a callback to be called once the animation completes.
+   * If the animation is already complete, it's called immediately.
+   *
+   * @param {(ok: boolean) => void} fn - Completion callback.
+   */
+  done(fn: (ok: boolean) => void): void;
+  /**
+   * Notifies the host of animation progress.
+   * @param {...any} args - Progress arguments.
+   */
+  progress(...args: any[]): void;
+  /** Pauses the animation, if supported by the host. */
+  pause(): void;
+  /** Resumes the animation, if supported by the host. */
+  resume(): void;
+  /** Ends the animation successfully. */
+  end(): void;
+  /** Cancels the animation. */
+  cancel(): void;
+  /**
+   * Marks the animation as complete on the next animation frame.
+   * @param {boolean} [status=true] - True if successful, false if canceled.
+   */
+  complete(status?: boolean): void;
+  /**
+   * Returns a promise that resolves or rejects when the animation completes.
+   * @returns {Promise<void>} Promise resolved on success or rejected on cancel.
+   */
+  getPromise(): Promise<void>;
+  /** @inheritdoc */
+  then(onFulfilled: any, onRejected: any): Promise<void>;
+  /** @inheritdoc */
+  catch(onRejected: any): Promise<void>;
+  /** @inheritdoc */
+  finally(onFinally: any): Promise<void>;
+  /**
+   * Completes the animation and invokes all done callbacks.
+   * @private
+   * @param {boolean} status - True if completed successfully, false if canceled.
+   */
+  private _finish;
+}
+/**
+ * Internal runner states.
+ */
+type RunnerState = number;
+declare namespace RunnerState {
+  let INITIAL: number;
+  let PENDING: number;
+  let DONE: number;
+}
+export {};

package/@types/animations/shared.d.ts

@@ -24,8 +24,36 @@ export function applyAnimationClassesFactory(): (
 ) => void;
 export function prepareAnimationOptions(options: any): any;
 export function applyAnimationStyles(element: any, options: any): void;
-export function applyAnimationFromStyles(element: any, options: any): void;
-export function applyAnimationToStyles(element: any, options: any): void;
+/**
+ * Applies initial animation styles to a DOM element.
+ *
+ * This function sets the element's inline styles using the properties
+ * defined in `options.from`, then clears the property to prevent reuse.
+ *
+ * @param {HTMLElement} element - The target DOM element to apply styles to.
+ * @param {{ from?: Partial<CSSStyleDeclaration> | null }} options - options containing a `from` object with CSS property–value pairs.
+ */
+export function applyAnimationFromStyles(
+  element: HTMLElement,
+  options: {
+    from?: Partial<CSSStyleDeclaration> | null;
+  },
+): void;
+/**
+ * Applies final animation styles to a DOM element.
+ *
+ * This function sets the element's inline styles using the properties
+ * defined in `options.to`, then clears the property to prevent reuse.
+ *
+ * @param {HTMLElement} element - The target DOM element to apply styles to.
+ * @param {{ to?: Partial<CSSStyleDeclaration> | null }} options - options containing a `from` object with CSS property–value pairs.
+ */
+export function applyAnimationToStyles(
+  element: HTMLElement,
+  options: {
+    to?: Partial<CSSStyleDeclaration> | null;
+  },
+): void;
 export function mergeAnimationDetails(
   element: any,
   oldAnimation: any,

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

@@ -1,20 +1,17 @@
-/**
- * @implements {Record<string, any>}
- */
-export class Attributes implements Record<string, any> {
+export class Attributes {
   static $nonscope: boolean;
   /**
-   * @param {import('../scope/scope.js').Scope} $rootScope
+   * @param {ng.Scope} $rootScope
    * @param {*} $animate
-   * @param {import("../../services/exception/exception-handler.js").ErrorHandler} $exceptionHandler
+   * @param {ng.ExceptionHandlerService} $exceptionHandler
    * @param {*} $sce
    * @param {import("../../shared/noderef.js").NodeRef} [nodeRef]
    * @param {Object} [attributesToCopy]
    */
   constructor(
-    $rootScope: import("../scope/scope.js").Scope,
+    $rootScope: ng.Scope,
     $animate: any,
-    $exceptionHandler: import("../../services/exception/exception-handler.js").ErrorHandler,
+    $exceptionHandler: ng.ExceptionHandlerService,
     $sce: any,
     nodeRef?: import("../../shared/noderef.js").NodeRef,
     attributesToCopy?: any,

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

@@ -2,11 +2,11 @@ export const DirectiveSuffix: "Directive";
 export class CompileProvider {
   static $inject: string[];
   /**
-   * @param {import('../../interface.js').Provider} $provide
+   * @param {import('../../interface.ts').Provider} $provide
    * @param {import('../sanitize/sanitize-uri.js').SanitizeUriProvider} $$sanitizeUriProvider
    */
   constructor(
-    $provide: import("../../interface.js").Provider,
+    $provide: import("../../interface.ts").Provider,
     $$sanitizeUriProvider: import("../sanitize/sanitize-uri.js").SanitizeUriProvider,
   );
   /**
@@ -26,7 +26,7 @@ export class CompileProvider {
   /**
    * @param {string|Object} name Name of the component in camelCase (i.e. `myComp` which will match `<my-comp>`),
    *    or an object map of components where the keys are the names and the values are the component definition objects.
-   * @param {import("../../interface.js").Component} options Component definition object (a simplified
+   * @param {import("../../interface.ts").Component} options Component definition object (a simplified
    *    {directive definition object}),
    *    with the following properties (all optional):
    *
@@ -69,7 +69,7 @@ export class CompileProvider {
    */
   component: (
     name: string | any,
-    options: import("../../interface.js").Component,
+    options: import("../../interface.ts").Component,
   ) => CompileProvider;
   /**
    * Retrieves or overrides the default regular expression that is used for determining trusted safe

package/@types/core/controller/controller.d.ts

@@ -35,7 +35,7 @@ export class ControllerProvider {
     | string
     | ((
         $injector: import("../../core/di/internal-injector.js").InjectorService,
-      ) => import("./interface.js").ControllerService)
+      ) => import("./interface.ts").ControllerService)
   )[];
   /**
    * Adds an identifier to the controller instance in the given locals' scope.

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

@@ -22,12 +22,12 @@ 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 {import("../../interface.js").Injectable<any>} [configFn]
+   * @param {import("../../interface.ts").Injectable<any>} [configFn]
    */
   constructor(
     name: string,
     requires: Array<string>,
-    configFn?: import("../../interface.js").Injectable<any>,
+    configFn?: import("../../interface.ts").Injectable<any>,
   );
   /**
    * Name of the current module.
@@ -46,8 +46,8 @@ export class NgModule {
   invokeQueue: Array<Array<any>>;
   /** @type {!Array<Array<*>>} */
   configBlocks: Array<Array<any>>;
-  /** @type {!Array.<import("../../interface.js").Injectable<any>>} */
-  runBlocks: Array<import("../../interface.js").Injectable<any>>;
+  /** @type {!Array.<import("../../interface.ts").Injectable<any>>} */
+  runBlocks: Array<import("../../interface.ts").Injectable<any>>;
   services: any[];
   /**
    * @param {string} name
@@ -110,47 +110,47 @@ export class NgModule {
   ): NgModule;
   /**
    * @param {string} name
-   * @param {import("../../interface.js").Injectable<any>} decorFn
+   * @param {import("../../interface.ts").Injectable<any>} decorFn
    * @returns {NgModule}
    */
   decorator(
     name: string,
-    decorFn: import("../../interface.js").Injectable<any>,
+    decorFn: import("../../interface.ts").Injectable<any>,
   ): NgModule;
   /**
    * @param {string} name
-   * @param {import("../../interface.js").Injectable<any>} directiveFactory
+   * @param {import("../../interface.ts").Injectable<any>} directiveFactory
    * @returns {NgModule}
    */
   directive(
     name: string,
-    directiveFactory: import("../../interface.js").Injectable<any>,
+    directiveFactory: import("../../interface.ts").Injectable<any>,
   ): NgModule;
   /**
    * @param {string} name
-   * @param {import("../../interface.js").Injectable<any>} animationFactory
+   * @param {import("../../interface.ts").Injectable<any>} animationFactory
    * @returns {NgModule}
    */
   animation(
     name: string,
-    animationFactory: import("../../interface.js").Injectable<any>,
+    animationFactory: import("../../interface.ts").Injectable<any>,
   ): NgModule;
   /**
    * @param {string} name
-   * @param {import("../../interface.js").Injectable<any>} filterFn
+   * @param {import("../../interface.ts").Injectable<any>} filterFn
    * @return {NgModule}
    */
   filter(
     name: string,
-    filterFn: import("../../interface.js").Injectable<any>,
+    filterFn: import("../../interface.ts").Injectable<any>,
   ): NgModule;
   /**
    * @param {string} name
-   * @param {import("../../interface.js").Injectable<any>} ctlFn
+   * @param {import("../../interface.ts").Injectable<any>} ctlFn
    * @returns {NgModule}
    */
   controller(
     name: string,
-    ctlFn: import("../../interface.js").Injectable<any>,
+    ctlFn: import("../../interface.ts").Injectable<any>,
   ): NgModule;
 }

package/@types/core/filter/filter.d.ts

@@ -1,9 +1,9 @@
 export class FilterProvider {
   static $inject: string[];
   /**
-   * @param {import('../../interface.ts').Provider} $provide
+   * @param {ng.ProvideService} $provide
    */
-  constructor($provide: import("../../interface.ts").Provider);
+  constructor($provide: ng.ProvideService);
   $provide: import("../../interface.ts").Provider;
   /**
    * @param {string|Record<string, ng.FilterFn>} name