@angular-wave/angular.ts 0.9.8 → 0.10.0

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

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

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

@@ -1,10 +1,8 @@
 /**
- * @param {import("../../services/pubsub/pubsub.js").PubSub} $eventBus
- * @returns {import("../../interface.ts").Directive}
+ * @param {ng.PubSubService} $eventBus
+ * @returns {ng.Directive}
  */
-export function ngChannelDirective(
-  $eventBus: import("../../services/pubsub/pubsub.js").PubSub,
-): import("../../interface.ts").Directive;
+export function ngChannelDirective($eventBus: ng.PubSubService): ng.Directive;
 export namespace ngChannelDirective {
   let $inject: string[];
 }

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

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

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

@@ -12,6 +12,22 @@ export function createEventDirective(
   directiveName: string,
   eventName: string,
 ): ng.Directive;
+/**
+ *
+ * @param {ng.ParseService} $parse
+ * @param {ng.ExceptionHandlerService} $exceptionHandler
+ * @param {ng.WindowService} $window
+ * @param {string} directiveName
+ * @param {string} eventName
+ * @returns {ng.Directive}
+ */
+export function createWindowEventDirective(
+  $parse: ng.ParseService,
+  $exceptionHandler: ng.ExceptionHandlerService,
+  $window: ng.WindowService,
+  directiveName: string,
+  eventName: string,
+): ng.Directive;
 /**
  * @type {Record<string, ng.DirectiveFactory>}
  */

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

@@ -1,29 +1,12 @@
-/**
- * @typedef {"click" | "change" | "submit"} EventType
- */
 /**
  * Selects DOM event to listen for based on the element type.
  *
  * @param {Element} element - The DOM element to inspect.
- * @returns {EventType} The name of the event to listen for.
- */
-export function getEventNameForElement(element: Element): EventType;
-/**
- * Handles DOM manipulation based on a swap strategy and server-rendered HTML.
- *
- * @param {string} html - The HTML string returned from the server.
- * @param {import("./interface.ts").SwapModeType} swap
- * @param {Element} target - The target DOM element to apply the swap to.
- * @param {ng.Scope} scope
- * @param {ng.CompileService} $compile
+ * @returns {"click" | "change" | "submit"} The name of the event to listen for.
  */
-export function handleSwapResponse(
-  html: string,
-  swap: import("./interface.ts").SwapModeType,
-  target: Element,
-  scope: ng.Scope,
-  $compile: ng.CompileService,
-): void;
+export function getEventNameForElement(
+  element: Element,
+): "click" | "change" | "submit";
 /**
  * Creates an HTTP directive factory that supports GET, DELETE, POST, PUT.
  *
@@ -45,4 +28,3 @@ export const ngPostDirective: ng.DirectiveFactory;
 export const ngPutDirective: ng.DirectiveFactory;
 /** @type {ng.DirectiveFactory} */
 export const ngSseDirective: ng.DirectiveFactory;
-export type EventType = "click" | "change" | "submit";

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

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

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

@@ -4,23 +4,23 @@
  * @param {import("../../services/anchor-scroll/anchor-scroll.js").AnchorScrollFunction} $anchorScroll
  * @param {*} $animate
  * @param {import('../../services/exception/interface.ts').ErrorHandler} $exceptionHandler
- * @returns {import('../../interface.js').Directive}
+ * @returns {import('../../interface.ts').Directive}
  */
 export function ngIncludeDirective(
   $templateRequest: any,
   $anchorScroll: import("../../services/anchor-scroll/anchor-scroll.js").AnchorScrollFunction,
   $animate: any,
   $exceptionHandler: import("../../services/exception/interface.ts").ErrorHandler,
-): import("../../interface.js").Directive;
+): import("../../interface.ts").Directive;
 export namespace ngIncludeDirective {
   let $inject: string[];
 }
 /**
- * @param {import("../../core/compile/compile.js").CompileFn} $compile
+ * @param {ng.CompileService} $compile
  * @returns {import("../../interface.ts").Directive}
  */
 export function ngIncludeFillContentDirective(
-  $compile: import("../../core/compile/compile.js").CompileFn,
+  $compile: ng.CompileService,
 ): import("../../interface.ts").Directive;
 export namespace ngIncludeFillContentDirective {
   let $inject_1: string[];

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

@@ -20,13 +20,13 @@ export namespace ngMessagesIncludeDirective {
 }
 export const ngMessageDirective: (
   any: any,
-) => import("../../interface.js").Directive;
+) => import("../../interface.ts").Directive;
 export const ngMessageExpDirective: (
   any: any,
-) => import("../../interface.js").Directive;
+) => import("../../interface.ts").Directive;
 export const ngMessageDefaultDirective: (
   any: any,
-) => import("../../interface.js").Directive;
+) => import("../../interface.ts").Directive;
 declare class NgMessageCtrl {
   /**
    * @param {Element} $element

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

@@ -1,9 +1,6 @@
 /**
  * @param {string} source - the name of the attribute to be observed
  * @param {string} prop - the scope property to be updated with attribute value
- * @returns {import("../../interface.ts").Directive}
+ * @returns {ng.Directive}
  */
-export function ngObserveDirective(
-  source: string,
-  prop: string,
-): import("../../interface.ts").Directive;
+export function ngObserveDirective(source: string, prop: string): ng.Directive;

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

@@ -1,11 +1,11 @@
 /**
  *
- * @param {import("../../core/compile/compile.js").CompileFn} $compile
+ * @param {ng.CompileService} $compile
  * @param {import("../../core/parse/interface.ts").ParseService} $parse
  * @returns {import("../../interface.ts").Directive}
  */
 export function ngOptionsDirective(
-  $compile: import("../../core/compile/compile.js").CompileFn,
+  $compile: ng.CompileService,
   $parse: import("../../core/parse/interface.ts").ParseService,
 ): import("../../interface.ts").Directive;
 export namespace ngOptionsDirective {

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

@@ -1,10 +1,10 @@
 /**
- * @param {import("../../core/compile/compile.js").CompileFn} $compile
- * @returns {import("../../interface.ts").Directive}
+ * @param {ng.CompileService} $compile
+ * @returns {ng.Directive}
  */
 export function ngTranscludeDirective(
-  $compile: import("../../core/compile/compile.js").CompileFn,
-): import("../../interface.ts").Directive;
+  $compile: ng.CompileService,
+): ng.Directive;
 export namespace ngTranscludeDirective {
   let $inject: string[];
 }

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

@@ -0,0 +1,4 @@
+/**
+ * @returns {ng.Directive}
+ */
+export function ngViewportDirective(): ng.Directive;

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

@@ -0,0 +1,15 @@
+/**
+ * ngWorker directive factory
+ * Usage: <div ng-worker="workerName" data-params="{{ expression }}" data-on-result="callback($result)"></div>
+ */
+export function ngWorkerDirective(
+  $worker: any,
+  $parse: any,
+  $log: any,
+): {
+  restrict: string;
+  link(scope: any, element: any, attrs: any): void;
+};
+export namespace ngWorkerDirective {
+  let $inject: string[];
+}

package/@types/interface.d.ts

@@ -256,7 +256,7 @@ export interface DirectivePrePost {
 export type DirectiveLinkFn = (
   scope: Scope,
   element: HTMLElement,
-  attrs: Attributes,
+  attrs: Attributes & Record<string, any>,
   controller?: TController,
   transclude?: (...args: any[]) => any,
 ) => void;
@@ -264,17 +264,18 @@ export type DirectiveLinkFn = (
  * A compile function used to prepare directives before linking.
  */
 export type DirectiveCompileFn = (
-  templateElement: HTMLElement,
-  templateAttributes: Attributes,
-  transclude: (...args: any[]) => any,
+  templateElement?: HTMLElement,
+  templateAttributes?: Attributes & Record<string, any>,
+  transclude?: (...args: any[]) => any,
 ) => void | DirectiveLinkFn | DirectivePrePost;
 /**
  * Defines the structure of an AngularTS directive.
+ * @typedef {Object} Directive
  */
 export interface Directive {
   /** Optional name (usually inferred) */
   name?: string;
-  /** Restrict option: 'A' and/or 'E'. Defaults to 'EA' */
+  /** Restrict option: 'A' and/or 'E'. Defaults to 'EA' if not defined */
   restrict?: string;
   /** Compile function for the directive */
   compile?: DirectiveCompileFn;

package/@types/namespace.d.ts

@@ -1,82 +1,111 @@
 export { angular } from "./index.js";
+import { Angular as TAngular } from "./angular.js";
+import { Attributes as TAttributes } from "./core/compile/attributes.js";
+import { Scope as TScope } from "./core/scope/scope.js";
+import { NgModule as TNgModule } from "./core/di/ng-module.js";
+import { InjectorService as TInjectorService } from "./core/di/internal-injector.js";
 import {
-  AnchorScrollProvider,
+  AnchorScrollProvider as TAnchorScrollProvider,
   AnchorScrollService as TAnchorScrollService,
 } from "./services/anchor-scroll/anchor-scroll.js";
 import { ControllerService as TControllerService } from "./core/controller/interface.ts";
-import { ErrorHandler } from "./services/exception/interface.ts";
-import { Angular } from "./angular.js";
-import { Attributes } from "./core/compile/attributes.js";
-import { Scope } from "./core/scope/scope.js";
-import { NgModule } from "./core/di/ng-module.js";
-import { PubSubProvider, PubSub } from "./services/pubsub/pubsub.js";
-import type { ErrorHandlingConfig as TErrorHandlingConfig } from "./shared/interface.ts";
-import { InjectorService } from "./core/di/internal-injector.js";
-import { CompileFn } from "./core/compile/compile.js";
+import { ErrorHandler as TErrorHandler } from "./services/exception/interface.ts";
 import { ParseService as TParseService } from "./core/parse/interface.ts";
 import { TemplateRequestService as TTemplateRequestService } from "./services/template-request/interface.ts";
-import { HttpParamSerializer } from "./services/http/interface.ts";
-import { HttpParamSerializerProvider } from "./services/http/http.js";
-import { FilterFactory, FilterFn as TFilterFn } from "./filters/interface.ts";
+import { HttpParamSerializer as THttpParamSerializer } from "./services/http/interface.ts";
+import { HttpParamSerializerProvider as THttpParamSerializerProvider } from "./services/http/http.js";
+import {
+  FilterFactory as TFilterFactory,
+  FilterFn as TFilterFn,
+} from "./filters/interface.ts";
 import { InterpolateService as TInterpolateService } from "./core/interpolate/interface.ts";
-import { InterpolateProvider } from "./core/interpolate/interpolate.js";
-import { SceDelegateProvider, SceProvider } from "./services/sce/sce.js";
+import { InterpolateProvider as TInterpolateProvider } from "./core/interpolate/interpolate.js";
+import {
+  SceProvider as TSceProvider,
+  SceDelegateProvider as TSceDelegateProvider,
+} from "./services/sce/sce.js";
+import { StateProvider as TStateProvider } from "./router/state/state-service.js";
+import { HttpService as THttpService } from "./services/http/interface.ts";
+import { LogService as TLogService } from "./services/log/interface.ts";
+import {
+  PubSubProvider as TPubSubProvider,
+  PubSub as TPubSub,
+} from "./services/pubsub/pubsub.js";
 import {
   Directive as TDirective,
   DirectiveFactory as TDirectiveFactory,
   Component as TComponent,
   Controller as TController,
 } from "./interface.ts";
-import { StateProvider } from "./router/state/state-service.js";
-import { HttpService as THttpService } from "./services/http/interface.ts";
-import { LogService as TLogService } from "./services/log/interface.ts";
 import {
   SseService as TSseService,
   SseConfig as TSseConfig,
 } from "./services/sse/interface.ts";
+import type { ErrorHandlingConfig as TErrorHandlingConfig } from "./shared/interface.ts";
+import {
+  BoundTranscludeFn as TBoundTranscludeFn,
+  CompileFn as TCompileFn,
+  PublicLinkFn as TPublicLinkFn,
+  NodeLinkFnCtx as TNodeLinkFnCtx,
+  NodeLinkFn as TNodeLinkFn,
+  TranscludeFn as TTranscludeFn,
+  LinkFnMapping as TLinkFnMapping,
+  CompositeLinkFn as TCompositeLinkFn,
+} from "./core/compile/inteface.ts";
+import {
+  WorkerConnection as TWorkerConnection,
+  WorkerConfig as TWorkerConfig,
+} from "./services/worker/interface.ts";
 declare global {
   interface Function {
     $inject?: readonly string[] | undefined;
   }
-  namespace ng {
-    type Angular = InstanceType<typeof Angular>;
-    type Attributes = InstanceType<typeof Attributes>;
+  export namespace ng {
+    type Angular = TAngular;
+    type Attributes = TAttributes & Record<string, any>;
     type Directive = TDirective;
     type DirectiveFactory = TDirectiveFactory;
     type Component = TComponent;
     type Controller = TController;
-    type Scope = InstanceType<typeof Scope>;
-    type NgModule = InstanceType<typeof NgModule>;
-    type PubSubProvider = InstanceType<typeof PubSubProvider>;
+    type Scope = TScope;
+    type NgModule = TNgModule;
+    type PubSubProvider = TPubSubProvider;
     type FilterFn = TFilterFn;
-    type AnchorScrollProvider = InstanceType<typeof AnchorScrollProvider>;
-    type InterpolateProvider = InstanceType<typeof InterpolateProvider>;
-    type HttpParamSerializerProvider = InstanceType<
-      typeof HttpParamSerializerProvider
-    >;
-    type SceProvider = InstanceType<typeof SceProvider>;
-    type SceDelegateProvider = InstanceType<typeof SceDelegateProvider>;
+    type CompositeLinkFn = TCompositeLinkFn;
+    type PublicLinkFn = TPublicLinkFn;
+    type NodeLinkFn = TNodeLinkFn;
+    type NodeLinkFnCtx = TNodeLinkFnCtx;
+    type TranscludeFn = TTranscludeFn;
+    type BoundTranscludeFn = TBoundTranscludeFn;
+    type LinkFnMapping = TLinkFnMapping;
+    type AnchorScrollProvider = TAnchorScrollProvider;
+    type InterpolateProvider = TInterpolateProvider;
+    type HttpParamSerializerProvider = THttpParamSerializerProvider;
+    type SceProvider = TSceProvider;
+    type SceDelegateProvider = TSceDelegateProvider;
     type AnchorScrollService = TAnchorScrollService;
-    type CompileService = CompileFn;
+    type CompileService = TCompileFn;
     type ControllerService = TControllerService;
-    type ExceptionHandlerService = ErrorHandler;
-    type FilterService = FilterFactory;
-    type HttpParamSerializerSerService = HttpParamSerializer;
+    type ExceptionHandlerService = TErrorHandler;
+    type FilterService = TFilterFactory;
+    type HttpParamSerializerSerService = THttpParamSerializer;
     type HttpService = THttpService;
     type InterpolateService = TInterpolateService;
-    type InjectorService = InstanceType<typeof InjectorService>;
+    type InjectorService = TInjectorService;
     type LogService = TLogService;
     type ParseService = TParseService;
-    type PubSubService = InstanceType<typeof PubSub>;
+    type PubSubService = TPubSub;
     type RootElementService = Element;
-    type RootScopeService = InstanceType<typeof Scope>;
-    type StateService = InstanceType<typeof StateProvider>;
+    type RootScopeService = TScope;
+    type StateService = TStateProvider;
     type SseService = TSseService;
     type SseConfig = TSseConfig;
-    type TemplateCacheService = InstanceType<typeof Map<string, string>>;
+    type TemplateCacheService = Map<string, string>;
     type TemplateRequestService = TTemplateRequestService;
     type ErrorHandlingConfig = TErrorHandlingConfig;
     type WindowService = Window;
     type DocumentService = Document;
+    type WorkerConfig = TWorkerConfig;
+    type WorkerConnection = TWorkerConnection;
   }
 }

package/@types/router/directives/view-directive.d.ts

@@ -134,5 +134,5 @@ export namespace $ViewDirectiveFill {
  * });
  * ```
  */
-/** @type {import("../../interface.js").AnnotatedDirectiveFactory} */
-export let ngView: import("../../interface.js").AnnotatedDirectiveFactory;
+/** @type {import("../../interface.ts").AnnotatedDirectiveFactory} */
+export let ngView: import("../../interface.ts").AnnotatedDirectiveFactory;

package/@types/router/path/path-utils.d.ts

@@ -37,13 +37,13 @@ export class PathUtils {
    * @param {PathNode[]} fromPath
    * @param {PathNode[]} toPath
    * @param {boolean} [reloadState]
-   * @returns {import("../transition/interface.js").TreeChanges}
+   * @returns {import("../transition/interface.ts").TreeChanges}
    */
   static treeChanges(
     fromPath: PathNode[],
     toPath: PathNode[],
     reloadState?: boolean,
-  ): import("../transition/interface.js").TreeChanges;
+  ): import("../transition/interface.ts").TreeChanges;
   /**
    * Returns a new path which is: the subpath of the first path which matches the second path.
    *

package/@types/router/state/state-object.d.ts

@@ -1,4 +1,4 @@
-/** @typedef {import('./interface.js').StateDeclaration} StateDeclaration */
+/** @typedef {import('./interface.ts').StateDeclaration} StateDeclaration */
 /**
  * Internal representation of a ng-router state.
  *
@@ -12,9 +12,9 @@
  */
 export class StateObject implements StateDeclaration {
   /**
-   * @param {import('./interface.js').StateDeclaration} config
+   * @param {import('./interface.ts').StateDeclaration} config
    */
-  constructor(config: import("./interface.js").StateDeclaration);
+  constructor(config: import("./interface.ts").StateDeclaration);
   name: any;
   navigable: any;
   /** @type {?StateObject} */
@@ -24,9 +24,9 @@ export class StateObject implements StateDeclaration {
   includes: any;
   $$state: () => this;
   /**
-   * @type {import('./interface.js').StateDeclaration}
+   * @type {import('./interface.ts').StateDeclaration}
    */
-  self: import("./interface.js").StateDeclaration;
+  self: import("./interface.ts").StateDeclaration;
   __stateObjectCache: {
     nameGlob: Glob;
   };
@@ -79,5 +79,5 @@ export namespace StateObject {
   /** Predicate which returns true if the object is an internal [[StateObject]] object */
   function isState(obj: any): boolean;
 }
-export type StateDeclaration = import("./interface.js").StateDeclaration;
+export type StateDeclaration = import("./interface.ts").StateDeclaration;
 import { Glob } from "../glob/glob.js";

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

@@ -27,7 +27,7 @@ export class StateProvider {
    *
    * @deprecated This is a passthrough through to [[Router.current]]
    */
-  get current(): import("./interface.js").StateDeclaration;
+  get current(): import("./interface.ts").StateDeclaration;
   /**
    * The current [[StateObject]] (an internal API)
    *
@@ -134,9 +134,9 @@ export class StateProvider {
   decorator(name: string, func: object): object;
   /**
    *
-   * @param {import("./interface.js").StateDeclaration} definition
+   * @param {import("./interface.ts").StateDeclaration} definition
    */
-  state(definition: import("./interface.js").StateDeclaration): this;
+  state(definition: import("./interface.ts").StateDeclaration): this;
   /**
    * Handler for when [[transitionTo]] is called with an invalid state.
    *

package/@types/router/template-factory.d.ts

@@ -20,7 +20,7 @@ export class TemplateFactoryProvider {
   )[];
   $templateRequest: any;
   $http: import("../interface.ts").HttpService;
-  $templateCache: Map<string, string>;
+  $templateCache: ng.TemplateCacheService;
   $injector: import("../core/di/internal-injector.js").InjectorService;
   /**
    * Forces the provider to use $http service directly

package/@types/router/transition/hook-builder.d.ts

@@ -45,4 +45,4 @@ export class HookBuilder {
    */
   getMatchingHooks(hookType: any, treeChanges: any, transition: any): any;
 }
-import { TransitionHookPhase } from "./interface.js";
+import { TransitionHookPhase } from "./transition-hook.js";

package/@types/router/transition/interface.d.ts

@@ -5,6 +5,7 @@ import { StateObject } from "../state/state-object.js";
 import { PathNode } from "../path/path-node.js";
 import { TargetState } from "../state/target-state.js";
 import { RegisteredHook } from "./hook-registry.js";
+import { TransitionHookScope } from "./transition-hook.js";
 /**
  * The TransitionOptions object can be used to change the behavior of a transition.
  *
@@ -866,15 +867,3 @@ export interface PathType {
  * Or, `true` to always match
  */
 export type HookMatchCriterion = string | IStateMatch | boolean;
-declare enum TransitionHookPhase {
-  CREATE = 0,
-  BEFORE = 1,
-  RUN = 2,
-  SUCCESS = 3,
-  ERROR = 4,
-}
-declare enum TransitionHookScope {
-  TRANSITION = 0,
-  STATE = 1,
-}
-export { TransitionHookPhase, TransitionHookScope };

package/@types/router/transition/transition-hook.d.ts

@@ -1,3 +1,34 @@
+/**
+ * Enum representing the different phases of a transition hook.
+ */
+export type TransitionHookPhase = number;
+/**
+ * Enum representing the different phases of a transition hook.
+ *
+ * @readonly
+ * @enum {number}
+ */
+export const TransitionHookPhase: Readonly<{
+  CREATE: 0;
+  BEFORE: 1;
+  RUN: 2;
+  SUCCESS: 3;
+  ERROR: 4;
+}>;
+/**
+ * Enum representing the scope in which a transition hook operates.
+ */
+export type TransitionHookScope = number;
+/**
+ * Enum representing the scope in which a transition hook operates.
+ *
+ * @readonly
+ * @enum {number}
+ */
+export const TransitionHookScope: Readonly<{
+  TRANSITION: 0;
+  STATE: 1;
+}>;
 export class TransitionHook {
   /**
    * Chains together an array of TransitionHooks.

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

@@ -117,4 +117,4 @@ export class TransitionProvider {
   _registerCoreTransitionHooks(): void;
 }
 import { Transition } from "./transition.js";
-import { TransitionHookPhase } from "./interface.js";
+import { TransitionHookPhase } from "./transition-hook.js";

package/@types/router/transition/transition.d.ts

@@ -47,7 +47,7 @@ export class Transition implements IHookRegistry {
   _targetState: import("../state/target-state.js").TargetState;
   _options: any;
   $id: number;
-  _treeChanges: import("./interface.js").TreeChanges;
+  _treeChanges: import("./interface.ts").TreeChanges;
   onStart: any;
   onBefore: any;
   onSuccess: any;
@@ -251,7 +251,7 @@ export class Transition implements IHookRegistry {
     pathname: any,
   ):
     | import("../path/path-node.js").PathNode[]
-    | import("./interface.js").TreeChanges;
+    | import("./interface.ts").TreeChanges;
   /**
    * Creates a new transition that is a redirection of the current one.
    *

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

@@ -1,4 +1,4 @@
-/** @typedef {import('../../interface.js').ServiceProvider} ServiceProvider
+/** @typedef {import('../../interface.ts').ServiceProvider} ServiceProvider
 
 /**
  * Configurable provider for an injectable event bus
@@ -182,4 +182,4 @@ export const EventBus: PubSub;
  * /**
  * Configurable provider for an injectable event bus
  */
-export type ServiceProvider = import("../../interface.js").ServiceProvider;
+export type ServiceProvider = import("../../interface.ts").ServiceProvider;