@angular-wave/angular.ts 0.14.3 → 0.15.0

package/@types/angular.d.ts

@@ -1,35 +1,35 @@
 export class Angular {
-  /** @public */
-  public $cache: Map<number, import("./interface.ts").ExpandoStore>;
+  /** @private @type {!Array<string|any>} */
+  private _bootsrappedModules;
   /** @public @type {ng.PubSubService} */
   public $eventBus: ng.PubSubService;
+  /** @public @type {ng.InjectorService} */
+  public $injector: ng.InjectorService;
   /**
+   * @public
    * @type {string} `version` from `package.json`
    */
-  version: string;
-  /** @type {!Array<string|any>} */
-  bootsrappedModules: Array<string | any>;
+  public version: string;
   /**
    * 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 | null,
-  ) => ng.Scope | undefined;
+  getController: typeof getController;
   /**
    * Return instance of InjectorService attached to element
-   * @type {(Element) => ng.InjectorService}
+   * @type {typeof getInjector}
    */
-  getInjector: (Element: any) => ng.InjectorService;
+  getInjector: typeof getInjector;
   /**
    * Gets scope for a given element.
-   * @type {(Element) => ng.Scope}
+   *  @type {typeof getScope}
    */
-  getScope: (Element: any) => ng.Scope;
+  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
@@ -131,16 +131,12 @@ export class Angular {
     config?: import("./interface.ts").AngularBootstrapConfig,
   ): ng.InjectorService;
   $rootScope: ng.Scope;
-  $injector: import("./interface.ts").InjectorService;
   /**
    * @param {any[]} modules
-   * @param {boolean?} strictDi
-   * @returns {import("./core/di/internal-injector.js").InjectorService}
+   * @param {boolean} [strictDi]
+   * @returns {ng.InjectorService}
    */
-  injector(
-    modules: any[],
-    strictDi: boolean | null,
-  ): import("./core/di/internal-injector.js").InjectorService;
+  injector(modules: any[], strictDi?: boolean): ng.InjectorService;
   /**
    * @param {Element|Document} element
    */
@@ -154,9 +150,15 @@ export class Angular {
    * or defined on `$scope` injectable.
    *
    * @param {string} name
-   * @returns {ProxyHandler<ng.Scope>|undefined}
+   * @returns {Proxy<ng.Scope>|undefined}
    */
-  getScopeByName(name: string): ProxyHandler<ng.Scope> | undefined;
+  getScopeByName(name: string): ProxyConstructor | undefined;
 }
+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";
 import { NgModule } from "./core/di/ng-module/ng-module.js";

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

@@ -44,7 +44,51 @@ export function animateCache(): {
    */
   put(key: string, value: any, isValid: boolean): void;
 };
-export function AnimateCacheProvider(): void;
 export class AnimateCacheProvider {
-  $get: (typeof animateCache)[];
+  $get(): {
+    /**
+     * Generates a unique cache key based on the node's parent and other parameters.
+     * @param {HTMLElement} node - The DOM node to generate the cache key for.
+     * @param {string} method - The animation method being applied.
+     * @param {string} [addClass] - Class to add during the animation.
+     * @param {string} [removeClass] - Class to remove during the animation.
+     * @returns {string} - The generated cache key.
+     */
+    cacheKey(
+      node: HTMLElement,
+      method: string,
+      addClass?: string,
+      removeClass?: string,
+    ): string;
+    /**
+     * Checks if a cached animation without a duration exists.
+     * @param {string} key - The cache key to check.
+     * @returns {boolean} - True if an invalid animation is cached, false otherwise.
+     */
+    containsCachedAnimationWithoutDuration(key: string): boolean;
+    /**
+     * Clears the cache.
+     * @returns {void}
+     */
+    flush(): void;
+    /**
+     * Gets the count of a specific cache entry.
+     * @param {string} key - The cache key to count.
+     * @returns {number} - The count of the cache entry.
+     */
+    count(key: string): number;
+    /**
+     * Retrieves a value associated with a specific cache key.
+     * @param {string} key - The cache key to retrieve.
+     * @returns {any} - The value associated with the cache key.
+     */
+    get(key: string): any;
+    /**
+     * Adds or updates a cache entry.
+     * @param {string} key - The cache key to add or update.
+     * @param {any} value - The value to store.
+     * @param {boolean} isValid - Whether the cache entry is valid.
+     */
+    put(key: string, value: any, isValid: boolean): void;
+  };
 }

package/@types/animations/animate-children-directive.d.ts

@@ -1,10 +1,10 @@
 /**
- * @param {*} $interpolate
- * @returns {import("../interface.ts").Directive}
+ * @param {ng.InterpolateService} $interpolate
+ * @returns {ng.Directive}
  */
 export function $$AnimateChildrenDirective(
-  $interpolate: any,
-): import("../interface.ts").Directive;
+  $interpolate: ng.InterpolateService,
+): ng.Directive;
 export namespace $$AnimateChildrenDirective {
   let $inject: string[];
 }

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

@@ -3,16 +3,7 @@ export class AnimateJsProvider {
   constructor($animateProvider: any);
   $get: (
     | string
-    | (($injector: ng.InjectorService) => (
-        element: any,
-        event: any,
-        classes: any,
-        options: any,
-      ) => {
-        $$willAnimate: boolean;
-        end(): any;
-        start(): any;
-      })
+    | (($injector: ng.InjectorService) => import("./interface.ts").AnimateJsFn)
   )[];
 }
 export namespace AnimateJsProvider {

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

@@ -93,7 +93,12 @@ export class AnimateProvider {
    * @return {RegExp} The current CSS className expression value. If null then there is no expression value
    */
   classNameFilter: (expression?: RegExp | undefined, ...args: any[]) => RegExp;
-  $get: any[];
+  $get: (
+    | string
+    | ((
+        $$animateQueue: import("./queue/interface.ts").AnimateQueueService,
+      ) => ng.AnimateService)
+  )[];
 }
 export namespace AnimateProvider {
   let $inject: string[];

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

@@ -98,4 +98,19 @@ export interface AnimationOptions {
   removeClass?: string;
   to?: Record<string, string | number>;
   tempClasses: string | string[];
+  /** Optional DOM operation callback executed before animation */
+  domOperation?: () => void;
+}
+export interface AnimateJsRunner {
+  $$willAnimate: true;
+  start: () => AnimateRunner;
+  end: () => AnimateRunner;
+}
+export interface AnimateJsFn {
+  (
+    element: HTMLElement,
+    event: string,
+    classes?: string | null,
+    options?: AnimationOptions,
+  ): AnimateJsRunner;
 }

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

@@ -1,95 +1,116 @@
-/**
- * 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.
+   * Executes a list of runners sequentially.
+   * Each must complete before the next starts.
    *
-   * @param {AnimateRunner[]} runners - Runners to execute in order.
-   * @param {(ok: boolean) => void} callback - Invoked when all complete or one fails.
+   * @param {AnimateRunner[]} runners
+   * @param {(ok: boolean) => void} callback
    */
   static _chain(
     runners: AnimateRunner[],
     callback: (ok: boolean) => void,
   ): void;
   /**
-   * Waits for all animation runners to complete before invoking the callback.
+   * Waits until all runners complete.
    *
-   * @param {AnimateRunner[]} runners - Active runners to wait for.
-   * @param {(ok: boolean) => void} callback - Called when all runners complete.
+   * @param {AnimateRunner[]} runners
+   * @param {(ok: boolean) => void} callback
    */
   static _all(runners: AnimateRunner[], callback: (ok: boolean) => void): void;
   /**
-   * @param {import("../interface.ts").AnimationHost} [host] - Optional animation host.
+   * @param {AnimationHost} [host] - Optional animation host callbacks.
+   * @param {boolean} [jsAnimation=false]
+   *        If true: use RAF/timer ticks.
+   *        If false: use batched CSS animation ticks.
    */
-  constructor(host?: import("../interface.ts").AnimationHost);
-  /** @type {import("../interface.ts").AnimationHost} */
-  _host: import("../interface.ts").AnimationHost;
+  constructor(host?: AnimationHost, jsAnimation?: boolean);
+  /** @type {AnimationHost} */
+  _host: 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.
+   * Deferred promise used by .then/.catch/.finally.
+   * @type {Promise<void>|null}
+   * @private
+   */
+  private _promise;
+  _tick: (fn: any) => void;
+  /**
+   * Sets or replaces the current host.
+   * @param {AnimationHost} host
    */
-  setHost(host: import("../interface.ts").AnimationHost): void;
+  setHost(host: AnimationHost): void;
   /**
-   * Registers a callback to be called once the animation completes.
-   * If the animation is already complete, it's called immediately.
+   * Register a completion callback.
+   * Fires immediately if animation is already done.
    *
-   * @param {(ok: boolean) => void} fn - Completion callback.
+   * @param {(ok: boolean) => void} fn
    */
   done(fn: (ok: boolean) => void): void;
   /**
-   * Notifies the host of animation progress.
-   * @param {...any} args - Progress arguments.
+   * Reports progress to host.
+   * @param {...any} args
    */
   progress(...args: any[]): void;
-  /** Pauses the animation, if supported by the host. */
+  /** Pause underlying animation (if supported). */
   pause(): void;
-  /** Resumes the animation, if supported by the host. */
+  /** Resume underlying animation (if supported). */
   resume(): void;
-  /** Ends the animation successfully. */
+  /**
+   * Ends the animation successfully.
+   * Equivalent to user choosing to finish it immediately.
+   */
   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.
+   * Cancels the animation.
    */
-  complete(status?: boolean): void;
+  cancel(): void;
   /**
-   * Returns a promise that resolves or rejects when the animation completes.
-   * @returns {Promise<void>} Promise resolved on success or rejected on cancel.
+   * Schedule animation completion.
+   *
+   * @param {boolean} [status=true]
    */
-  getPromise(): Promise<void>;
-  /** @inheritdoc */
-  then(onFulfilled: any, onRejected: any): Promise<void>;
-  /** @inheritdoc */
-  catch(onRejected: any): Promise<void>;
-  /** @inheritdoc */
-  finally(onFinally: any): Promise<void>;
+  complete(status?: boolean): void;
   /**
    * Completes the animation and invokes all done callbacks.
+   * @param {boolean} status
    * @private
-   * @param {boolean} status - True if completed successfully, false if canceled.
    */
   private _finish;
+  /**
+   * Returns an internal promise that resolves on success,
+   * and rejects on cancel.
+   *
+   * @returns {Promise<void>}
+   */
+  getPromise(): Promise<void>;
+  /**
+   * Standard "thenable" interface
+   * @template T
+   * @param {(value: void) => T|Promise<T>} onFulfilled
+   * @param {(reason: any) => any} [onRejected]
+   * @returns {Promise<T>}
+   */
+  then<T>(
+    onFulfilled: (value: void) => T | Promise<T>,
+    onRejected?: (reason: any) => any,
+  ): Promise<T>;
+  /**
+   * Standard promise catcher.
+   * @param {(reason: any) => any} onRejected
+   * @returns {Promise<void>}
+   */
+  catch(onRejected: (reason: any) => any): Promise<void>;
+  /**
+   * Standard promise finally.
+   * @param {() => any} onFinally
+   * @returns {Promise<void>}
+   */
+  finally(onFinally: () => any): Promise<void>;
 }
+export type AnimationHost = import("../interface.ts").AnimationHost;
 /**
  * Internal runner states.
  */

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

@@ -83,20 +83,4 @@ export const ACTIVE_CLASS_SUFFIX: "-active";
 export const PREPARE_CLASS_SUFFIX: "-prepare";
 export const NG_ANIMATE_CLASSNAME: "ng-animate";
 export const NG_ANIMATE_CHILDREN_DATA: "$$ngAnimateChildren";
-export let CSS_PREFIX: string;
-export let TRANSITION_PROP: any;
-export let TRANSITIONEND_EVENT: any;
-export let ANIMATION_PROP: any;
-export let ANIMATIONEND_EVENT: any;
-export const DURATION_KEY: "Duration";
-export const PROPERTY_KEY: number;
-export const DELAY_KEY: "Delay";
-export const TIMING_KEY: "TimingFunction";
-export const ANIMATION_ITERATION_COUNT_KEY: "IterationCount";
-export const ANIMATION_PLAYSTATE_KEY: "PlayState";
-export const SAFE_FAST_FORWARD_DURATION_VALUE: 9999;
-export const ANIMATION_DELAY_PROP: string;
-export const ANIMATION_DURATION_PROP: string;
-export const TRANSITION_DELAY_PROP: string;
-export const TRANSITION_DURATION_PROP: string;
 export const ngMinErr: (arg0: string, ...arg1: any[]) => Error;

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

@@ -14,8 +14,8 @@ export class Attributes {
     nodeRef?: import("../../shared/noderef.js").NodeRef,
     attributesToCopy?: any,
   );
-  _$animate: import("../../interface.ts").AnimateService;
-  _$exceptionHandler: import("../../interface.ts").ExceptionHandler;
+  _$animate: import("../../animations/interface.ts").AnimateService;
+  _$exceptionHandler: import("../../services/exception/interface.ts").ExceptionHandler;
   _$sce: any;
   $attr: {};
   /** @type {import("../../shared/noderef.js").NodeRef} */
@@ -59,14 +59,14 @@ export class Attributes {
    * Set a normalized attribute on the element in a way such that all directives
    * can share the attribute. This function properly handles boolean attributes.
    * @param {string} key Normalized key. (ie ngAttribute)
-   * @param {string|boolean} value The value to set. If `null` attribute will be deleted.
+   * @param {string|boolean|null} value The value to set. If `null` attribute will be deleted.
    * @param {boolean=} writeAttr If false, does not write the value to DOM element attribute.
    *     Defaults to true.
    * @param {string=} attrName Optional none normalized name. Defaults to key.
    */
   $set(
     key: string,
-    value: string | boolean,
+    value: string | boolean | null,
     writeAttr?: boolean | undefined,
     attrName?: string | undefined,
   ): void;
@@ -87,7 +87,13 @@ export class Attributes {
   $observe(key: string, fn: any): () => any;
   $$observers: any;
   setSpecialAttr(element: any, attrName: any, value: any): void;
-  sanitizeSrcset(value: any, invokeType: any): any;
-  srcset: any;
+  /**
+   *
+   * @param {unknown} value
+   * @param {string} invokeType
+   * @returns {unknown}
+   */
+  sanitizeSrcset(value: unknown, invokeType: string): unknown;
+  srcset: unknown;
 }
 import { directiveNormalize } from "../../shared/utils.js";

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

@@ -125,7 +125,7 @@ export class CompileProvider {
     | string
     | ((
         $injector: ng.InjectorService,
-        $interpolate: any,
+        $interpolate: ng.InterpolateService,
         $exceptionHandler: ng.ExceptionHandlerService,
         $templateRequest: ng.TemplateRequestService,
         $parse: ng.ParseService,

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

@@ -1,4 +1,4 @@
-export function identifierForController(controller: any, ident: any): any;
+export function identifierForController(controller: any, ident: any): string;
 /**
  * The {@link ng.$controller $controller service} is used by AngularTS to create new
  * controllers.

package/@types/core/interpolate/interface.d.ts

@@ -1,4 +1,5 @@
 export interface InterpolationFunction {
+  expressions: any[];
   (context: any): string;
 }
 export interface InterpolateService {

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

@@ -41,7 +41,7 @@ export interface CompiledExpressionProps {
  * Evaluates the compiled expression.
  */
 export type CompiledExpressionFunction = (
-  context?: Scope,
+  context?: Scope | typeof Proxy<Scope>,
   locals?: object,
   assign?: any,
 ) => any;

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

@@ -10,13 +10,15 @@ export class ASTInterpreter {
    * @param {function(any):any} $filter
    */
   constructor($filter: (arg0: any) => any);
-  $filter: (arg0: any) => any;
+  _$filter: (arg0: any) => any;
   /**
    * Compiles the AST into a function.
-   * @param {import("./ast/ast").ASTNode} ast - The AST to compile.
+   * @param {import("./ast/ast.js").ASTNode} ast - The AST to compile.
    * @returns {import("./interface.ts").CompiledExpression}
    */
-  compile(ast: any): import("./interface.ts").CompiledExpression;
+  compile(
+    ast: import("./ast/ast.js").ASTNode,
+  ): import("./interface.ts").CompiledExpression;
   /**
    * Unary plus operation.
    * @param {function} argument - The argument function.

package/@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,12 +16,8 @@ export function createScope(target?: any, context?: Scope): Scope;
  * @returns {boolean}
  */
 export function isNonScope(target: any): boolean;
-/**
- * Decorator for excluding objects from scope observability
- */
-export const NONSCOPE: "$nonscope";
-export const $postUpdateQueue: any[];
-export let rootScope: any;
+/** @ignore @type {Function[]}*/
+export const $postUpdateQueue: Function[];
 export class RootScopeProvider {
   rootScope: Scope;
   $get: (
@@ -53,7 +49,7 @@ export class Scope {
   $$listeners: Map<string, Function[]>;
   /** @type {Map<string, Array<import('./interface.ts').Listener>>} Watch listeners from other proxies */
   foreignListeners: Map<string, Array<import("./interface.ts").Listener>>;
-  /** @type {Set<ProxyConstructor>} */
+  /** @type {Set<Proxy<ng.Scope>>} */
   foreignProxies: Set<ProxyConstructor>;
   /** @type {WeakMap<Object, Array<string>>} */
   objectListeners: WeakMap<any, Array<string>>;
@@ -65,8 +61,8 @@ export class Scope {
       fn: Function;
     }
   >;
-  /** Current proxy being operated on */
-  $proxy: any;
+  /** @type {Proxy<Scope>} Current proxy being operated on */
+  $proxy: ProxyConstructor;
   /** @type {Scope} The actual proxy */
   $handler: Scope;
   /** @type {*} Current target being called on */
@@ -100,7 +96,7 @@ export class Scope {
    * @param {Object} target - The target object.
    * @param {string} property - The name of the property being set.
    * @param {*} value - The new value being assigned to the property.
-   * @param {Proxy} proxy - The proxy intercepting property access
+   * @param {Proxy<Scope>} proxy - The proxy intercepting property access
    * @returns {boolean} - Returns true to indicate success of the operation.
    */
   set(
@@ -116,7 +112,7 @@ export class Scope {
    *
    * @param {Object} target - The target object.
    * @param {string|number|symbol} property - The name of the property being accessed.
-   * @param {Proxy} proxy - The proxy object being invoked
+   * @param {Proxy<Scope>} proxy - The proxy object being invoked
    * @returns {*} - The value of the property or a method if accessing `watch` or `sync`.
    */
   get(
@@ -182,6 +178,10 @@ export class Scope {
    * @returns {Scope|undefined}
    */
   $getById(id: string | number): Scope | undefined;
-  $searchByName(name: any): any;
+  /**
+   * @param {string} name
+   * @returns {ng.Scope|undefined}
+   */
+  $searchByName(name: string): ng.Scope | undefined;
   #private;
 }

package/@types/directive/attrs/attrs.d.ts

@@ -1,8 +1,5 @@
 export const REGEX_STRING_REGEXP: RegExp;
 /**
- * @type {Record<string, import("../../interface.ts").DirectiveFactory>}
+ * @type {Record<string, ng.DirectiveFactory>}
  */
-export const ngAttributeAliasDirectives: Record<
-  string,
-  import("../../interface.ts").DirectiveFactory
->;
+export const ngAttributeAliasDirectives: Record<string, ng.DirectiveFactory>;

package/@types/directive/class/class.d.ts

@@ -1,3 +1,3 @@
-export const ngClassDirective: ng.DirectiveFactory;
-export const ngClassOddDirective: ng.DirectiveFactory;
-export const ngClassEvenDirective: ng.DirectiveFactory;
+export const ngClassDirective: import("../../interface.ts").DirectiveFactory;
+export const ngClassOddDirective: import("../../interface.ts").DirectiveFactory;
+export const ngClassEvenDirective: import("../../interface.ts").DirectiveFactory;

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

@@ -1,4 +1,4 @@
 /**
- * @returns {import("../../interface.ts").Directive}
+ * @returns {ng.Directive}
  */
-export function ngControllerDirective(): import("../../interface.ts").Directive;
+export function ngControllerDirective(): ng.Directive;

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

@@ -78,17 +78,17 @@ export class FormController {
    * @param {ng.Attributes} $attrs
    * @param {ng.Scope} $scope
    * @param {ng.AnimateService} $animate
-   * @param {*} $interpolate
+   * @param {ng.InterpolateService} $interpolate
    */
   constructor(
     $element: Element,
     $attrs: ng.Attributes,
     $scope: ng.Scope,
     $animate: ng.AnimateService,
-    $interpolate: any,
+    $interpolate: ng.InterpolateService,
   );
   $$controls: any[];
-  $name: any;
+  $name: string;
   /**
    * @property {boolean} $dirty True if user has already interacted with the form.
    */
@@ -103,7 +103,7 @@ export class FormController {
   /** @type {FormController|Object} */
   $$parentForm: FormController | any;
   $$element: Element;
-  $$animate: import("../../interface.ts").AnimateService;
+  $$animate: import("../../animations/interface.ts").AnimateService;
   $error: {};
   $$success: {};
   $pending: any;

package/@types/directive/include/include.d.ts

@@ -1,14 +1,14 @@
 /**
  *
  * @param {ng.TemplateRequestService} $templateRequest
- * @param {import("../../services/anchor-scroll/anchor-scroll.js").AnchorScrollFunction} $anchorScroll
+ * @param {ng.AnchorScrollService} $anchorScroll
  * @param {ng.AnimateService} $animate
  * @param {ng.ExceptionHandlerService} $exceptionHandler
  * @returns {ng.Directive}
  */
 export function ngIncludeDirective(
   $templateRequest: ng.TemplateRequestService,
-  $anchorScroll: import("../../services/anchor-scroll/anchor-scroll.js").AnchorScrollFunction,
+  $anchorScroll: ng.AnchorScrollService,
   $animate: ng.AnimateService,
   $exceptionHandler: ng.ExceptionHandlerService,
 ): ng.Directive;
@@ -17,11 +17,11 @@ export namespace ngIncludeDirective {
 }
 /**
  * @param {ng.CompileService} $compile
- * @returns {import("../../interface.ts").Directive}
+ * @returns {ng.Directive}
  */
 export function ngIncludeFillContentDirective(
   $compile: ng.CompileService,
-): import("../../interface.ts").Directive;
+): ng.Directive;
 export namespace ngIncludeFillContentDirective {
   let $inject_1: string[];
   export { $inject_1 as $inject };