@angular-wave/angular.ts 0.9.2 → 0.9.4

package/@types/angular.d.ts

@@ -1,9 +1,3 @@
-/**
- * Configuration option for AngularTS bootstrap process.
- *
- * @typedef {Object} AngularBootstrapConfig
- * @property {boolean} [strictDi] - Disable automatic function annotation for the application. This is meant to assist in finding bugs which break minified code. Defaults to `false`.
- */
 export class Angular {
   $cache: Map<number, import("./interface.ts").ExpandoStore>;
   /** @type {import('./services/pubsub/pubsub.js').PubSub} */
@@ -59,13 +53,13 @@ export class Angular {
    *     Each item in the array should be the name of a predefined module or a (DI annotated)
    *     function that will be invoked by the injector as a `config` block.
    *     See: {@link angular.module modules}
-   * @param {AngularBootstrapConfig} [config]
+   * @param {import("./interface.ts").AngularBootstrapConfig} [config]
    * @returns {import('./core/di/internal-injector.js').InjectorService} The created injector instance for this application.
    */
   bootstrap(
     element: string | Element | Document,
     modules?: Array<string | any>,
-    config?: AngularBootstrapConfig,
+    config?: import("./interface.ts").AngularBootstrapConfig,
   ): import("./core/di/internal-injector.js").InjectorService;
   $injector: import("./core/di/internal-injector.js").InjectorService;
   /**
@@ -124,25 +118,16 @@ 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} [configFn] Optional configuration function for the module that gets
+   * @param {import("./interface.js").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,
+    configFn?: import("./interface.js").Injectable<any>,
   ): NgModule;
 }
-/**
- * Configuration option for AngularTS bootstrap process.
- */
-export type AngularBootstrapConfig = {
-  /**
-   * - Disable automatic function annotation for the application. This is meant to assist in finding bugs which break minified code. Defaults to `false`.
-   */
-  strictDi?: boolean;
-};
 import { getController } from "./shared/dom.js";
 import { getInjector } from "./shared/dom.js";
 import { getScope } from "./shared/dom.js";

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

@@ -38,12 +38,12 @@ export class AnimateProvider {
    * ```
    *
    * @param {string} name The name of the animation (this is what the class-based CSS value will be compared to).
-   * @param {import("../interface.ts").Injectable} factory The factory function that will be executed to return the animation
+   * @param {import("../interface.ts").Injectable<any>} factory The factory function that will be executed to return the animation
    *                           object.
    */
   register: (
     name: string,
-    factory: import("../interface.ts").Injectable,
+    factory: import("../interface.ts").Injectable<any>,
   ) => void;
   /**
    * Sets and/or returns the custom filter function that is used to "filter" animations, i.e.

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

@@ -4,7 +4,7 @@ export class AnimationProvider {
   $get: (
     | string
     | ((
-        $rootScope: any,
+        $rootScope: ng.RootScopeService,
         $injector: any,
         $$AnimateRunner: any,
         $$rAFScheduler: any,

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

@@ -21,7 +21,7 @@ export class Attributes implements Record<string, any> {
   );
   $rootScope: import("../scope/scope.js").Scope;
   $animate: any;
-  $exceptionHandler: import("../../services/exception/interface.ts").Interface;
+  $exceptionHandler: import("../../services/exception/interface.ts").ErrorHandler;
   $sce: any;
   $attr: {};
   /** @type {import("../../shared/noderef.js").NodeRef} */

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

@@ -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").ComponentOptions} options Component definition object (a simplified
+   * @param {import("../../interface.js").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").ComponentOptions,
+    options: import("../../interface.js").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,
-      ) => Function)
+      ) => import("./interface.js").ControllerService)
   )[];
   /**
    * Adds an identifier to the controller instance in the given locals' scope.

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

@@ -0,0 +1,6 @@
+export type ControllerService = (
+  expression: string | Function | any[],
+  locals?: Record<string, any>,
+  later?: boolean,
+  ident?: string,
+) => object | (() => object);

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} [configFn]
+   * @param {import("../../interface.js").Injectable<any>} [configFn]
    */
   constructor(
     name: string,
     requires: Array<string>,
-    configFn?: import("../../interface.js").Injectable,
+    configFn?: import("../../interface.js").Injectable<any>,
   );
   /**
    * Name of the current module.
@@ -46,8 +46,9 @@ export class NgModule {
   invokeQueue: Array<Array<any>>;
   /** @type {!Array<Array<*>>} */
   configBlocks: Array<Array<any>>;
-  /** @type {!Array.<import("../../interface.js").Injectable>} */
-  runBlocks: Array<import("../../interface.js").Injectable>;
+  /** @type {!Array.<import("../../interface.js").Injectable<any>>} */
+  runBlocks: Array<import("../../interface.js").Injectable<any>>;
+  services: any[];
   /**
    * @param {string} name
    * @param {any} object
@@ -62,94 +63,94 @@ export class NgModule {
   constant(name: string, object: any): NgModule;
   /**
    *
-   * @param {import("../../interface.js").Injectable} configFn
+   * @param {import("../../interface.ts").Injectable<any>} configFn
    * @returns {NgModule}
    */
-  config(configFn: import("../../interface.js").Injectable): NgModule;
+  config(configFn: import("../../interface.ts").Injectable<any>): NgModule;
   /**
-   * @param {import("../../interface.js").Injectable} block
+   * @param {import("../../interface.ts").Injectable<any>} block
    * @returns {NgModule}
    */
-  run(block: import("../../interface.js").Injectable): NgModule;
+  run(block: import("../../interface.ts").Injectable<any>): NgModule;
   /**
    * @param {string} name
-   * @param {import("../../interface.js").ComponentOptions} options
+   * @param {import("../../interface.ts").Component} options
    * @returns {NgModule}
    */
   component(
     name: string,
-    options: import("../../interface.js").ComponentOptions,
+    options: import("../../interface.ts").Component,
   ): NgModule;
   /**
    * @param {string} name
-   * @param {import("../../interface.js").Injectable} providerFunction
+   * @param {import("../../interface.ts").Injectable<any>} providerFunction
    * @returns {NgModule}
    */
   factory(
     name: string,
-    providerFunction: import("../../interface.js").Injectable,
+    providerFunction: import("../../interface.ts").Injectable<any>,
   ): NgModule;
   /**
    * @param {string} name
-   * @param {import("../../interface.js").Injectable} serviceFunction
+   * @param {import("../../interface.ts").Injectable<any>} serviceFunction
    * @returns {NgModule}
    */
   service(
     name: string,
-    serviceFunction: import("../../interface.js").Injectable,
+    serviceFunction: import("../../interface.ts").Injectable<any>,
   ): NgModule;
   /**
    * @param {string} name
-   * @param {import("../../interface.js").Injectable} providerType
+   * @param {import("../../interface.ts").Injectable<any>} providerType
    * @returns {NgModule}
    */
   provider(
     name: string,
-    providerType: import("../../interface.js").Injectable,
+    providerType: import("../../interface.ts").Injectable<any>,
   ): NgModule;
   /**
    * @param {string} name
-   * @param {import("../../interface.js").Injectable} decorFn
+   * @param {import("../../interface.js").Injectable<any>} decorFn
    * @returns {NgModule}
    */
   decorator(
     name: string,
-    decorFn: import("../../interface.js").Injectable,
+    decorFn: import("../../interface.js").Injectable<any>,
   ): NgModule;
   /**
    * @param {string} name
-   * @param {import("../../interface.js").Injectable} directiveFactory
+   * @param {import("../../interface.js").Injectable<any>} directiveFactory
    * @returns {NgModule}
    */
   directive(
     name: string,
-    directiveFactory: import("../../interface.js").Injectable,
+    directiveFactory: import("../../interface.js").Injectable<any>,
   ): NgModule;
   /**
    * @param {string} name
-   * @param {import("../../interface.js").Injectable} animationFactory
+   * @param {import("../../interface.js").Injectable<any>} animationFactory
    * @returns {NgModule}
    */
   animation(
     name: string,
-    animationFactory: import("../../interface.js").Injectable,
+    animationFactory: import("../../interface.js").Injectable<any>,
   ): NgModule;
   /**
    * @param {string} name
-   * @param {import("../../interface.js").Injectable} filterFn
+   * @param {import("../../interface.js").Injectable<any>} filterFn
    * @return {NgModule}
    */
   filter(
     name: string,
-    filterFn: import("../../interface.js").Injectable,
+    filterFn: import("../../interface.js").Injectable<any>,
   ): NgModule;
   /**
    * @param {string} name
-   * @param {import("../../interface.js").Injectable} ctlFn
+   * @param {import("../../interface.js").Injectable<any>} ctlFn
    * @returns {NgModule}
    */
   controller(
     name: string,
-    ctlFn: import("../../interface.js").Injectable,
+    ctlFn: import("../../interface.js").Injectable<any>,
   ): NgModule;
 }

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

@@ -6,18 +6,18 @@ export class FilterProvider {
   constructor($provide: import("../../interface.ts").Provider);
   $provide: import("../../interface.ts").Provider;
   /**
-   * @param {string|Record<string, import('../../interface.ts').FilterFactory>} name
-   * @param {import('../../interface.ts').FilterFactory} [factory]
+   * @param {string|Record<string, ng.FilterFn>} name
+   * @param {ng.FilterService} [factory]
    * @return {import('../../interface.ts').Provider}
    */
   register(
-    name: string | Record<string, import("../../interface.ts").FilterFactory>,
-    factory?: import("../../interface.ts").FilterFactory,
+    name: string | Record<string, ng.FilterFn>,
+    factory?: ng.FilterService,
   ): import("../../interface.ts").Provider;
   $get: (
     | string
     | ((
         $injector: import("../../core/di/internal-injector.js").InjectorService,
-      ) => import("../../interface.ts").FilterFn)
+      ) => ng.FilterService)
   )[];
 }

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

@@ -0,0 +1,13 @@
+export interface InterpolationFunction {
+  (context: any): string;
+}
+export interface InterpolateService {
+  (
+    text: string,
+    mustHaveExpression?: boolean,
+    trustedContext?: string,
+    allOrNothing?: boolean,
+  ): InterpolationFunction | undefined;
+  endSymbol(): string;
+  startSymbol(): string;
+}

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

@@ -21,18 +21,6 @@ export class InterpolateProvider {
   endSymbol: string;
   $get: (
     | string
-    | ((
-        $parse: import("../parse/interface.ts").ParseService,
-        $sce: any,
-      ) => {
-        (
-          text: string,
-          mustHaveExpression?: boolean | undefined,
-          trustedContext?: string | undefined,
-          allOrNothing?: boolean | undefined,
-        ): Function;
-        startSymbol(): string;
-        endSymbol(): string;
-      })
+    | (($parse: ng.ParseService, $sce: any) => ng.InterpolateService)
   )[];
 }

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

@@ -208,7 +208,10 @@ export class Scope {
    * @returns {any}
    */
   $broadcast(name: string, ...args: any[]): any;
-  $postUpdate(fn: any): void;
+  /**
+   * @param {Function} fn
+   */
+  $postUpdate(fn: Function): void;
   $destroy(): void;
   /**
    * Searches the scope instance

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

@@ -12,35 +12,35 @@ 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 {import("./interface.ts").SwapModeType} swap
  * @param {Element} target - The target DOM element to apply the swap to.
- * @param {import('../../core/scope/scope.js').Scope} scope
- * @param {import('../../core/compile/compile.js').CompileFn} $compile
+ * @param {ng.Scope} scope
+ * @param {ng.CompileService} $compile
  */
 export function handleSwapResponse(
   html: string,
-  swap: import("../../interface.ts").SwapModeType,
+  swap: import("./interface.ts").SwapModeType,
   target: Element,
-  scope: import("../../core/scope/scope.js").Scope,
-  $compile: import("../../core/compile/compile.js").CompileFn,
+  scope: ng.Scope,
+  $compile: ng.CompileService,
 ): void;
 /**
  * Creates an HTTP directive factory that supports GET, DELETE, POST, PUT.
  *
  * @param {"get" | "delete" | "post" | "put"} method - HTTP method to use.
  * @param {string} attrName - Attribute name containing the URL.
- * @returns {import('../../interface.ts').DirectiveFactory}
+ * @returns {ng.DirectiveFactory}
  */
 export function createHttpDirective(
   method: "get" | "delete" | "post" | "put",
   attrName: string,
-): import("../../interface.ts").DirectiveFactory;
-/** @type {import('../../interface.ts').DirectiveFactory} */
-export const ngGetDirective: import("../../interface.ts").DirectiveFactory;
-/** @type {import('../../interface.ts').DirectiveFactory} */
-export const ngDeleteDirective: import("../../interface.ts").DirectiveFactory;
-/** @type {import('../../interface.ts').DirectiveFactory} */
-export const ngPostDirective: import("../../interface.ts").DirectiveFactory;
-/** @type {import('../../interface.ts').DirectiveFactory} */
-export const ngPutDirective: import("../../interface.ts").DirectiveFactory;
+): ng.DirectiveFactory;
+/** @type {ng.DirectiveFactory} */
+export const ngGetDirective: ng.DirectiveFactory;
+/** @type {ng.DirectiveFactory} */
+export const ngDeleteDirective: ng.DirectiveFactory;
+/** @type {ng.DirectiveFactory} */
+export const ngPostDirective: ng.DirectiveFactory;
+/** @type {ng.DirectiveFactory} */
+export const ngPutDirective: ng.DirectiveFactory;
 export type EventType = "click" | "change" | "submit";

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

@@ -0,0 +1,27 @@
+/**
+ * Possible values for `data-swap` attribute
+ */
+export declare const SwapMode: {
+  /** (default) Replaces the contents inside the element */
+  readonly innerHTML: "innerHTML";
+  /** Replaces the entire element, including the tag itself */
+  readonly outerHTML: "outerHTML";
+  /** Inserts plain text (without parsing HTML) */
+  readonly textContent: "textContent";
+  /** Inserts HTML immediately before the element itself */
+  readonly beforebegin: "beforebegin";
+  /** Inserts HTML inside the element, before its first child */
+  readonly afterbegin: "afterbegin";
+  /** Inserts HTML inside the element, after its last child */
+  readonly beforeend: "beforeend";
+  /** Inserts HTML immediately after the element itself */
+  readonly afterend: "afterend";
+  /** Removes the element entirely */
+  readonly delete: "delete";
+  /** Performs no insertion (no-op) */
+  readonly none: "none";
+};
+/**
+ * Union type representing all possible DOM insertion modes.
+ */
+export type SwapModeType = keyof typeof SwapMode;

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

@@ -1,16 +1,16 @@
 /**
  *
  * @param {*} $templateRequest
- * @param {import("../../services/anchor-scroll.js").AnchorScrollFunction} $anchorScroll
+ * @param {import("../../services/anchor-scroll/anchor-scroll.js").AnchorScrollFunction} $anchorScroll
  * @param {*} $animate
- * @param {import('../../services/exception/interface.ts').Interface} $exceptionHandler
+ * @param {import('../../services/exception/interface.ts').ErrorHandler} $exceptionHandler
  * @returns {import('../../interface.js').Directive}
  */
 export function ngIncludeDirective(
   $templateRequest: any,
-  $anchorScroll: import("../../services/anchor-scroll.js").AnchorScrollFunction,
+  $anchorScroll: import("../../services/anchor-scroll/anchor-scroll.js").AnchorScrollFunction,
   $animate: any,
-  $exceptionHandler: import("../../services/exception/interface.ts").Interface,
+  $exceptionHandler: import("../../services/exception/interface.ts").ErrorHandler,
 ): import("../../interface.js").Directive;
 export namespace ngIncludeDirective {
   let $inject: string[];

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

@@ -0,0 +1,12 @@
+/**
+ * @param {ng.LogService} $log
+ * @param {ng.InjectorService} $injector
+ * @returns {import('interface.ts').Directive}
+ */
+export function ngInjectDirective(
+  $log: ng.LogService,
+  $injector: ng.InjectorService,
+): any;
+export namespace ngInjectDirective {
+  let $inject: string[];
+}

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

@@ -141,7 +141,7 @@ export class NgModelController {
   $$element: Element;
   $$animate: any;
   $$parse: import("../../core/parse/interface.ts").ParseService;
-  $$exceptionHandler: import("../../services/exception/interface.ts").Interface;
+  $$exceptionHandler: import("../../services/exception/interface.ts").ErrorHandler;
   $$hasNativeValidators: boolean;
   $$classCache: {};
   $$eventRemovers: Set<any>;

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

@@ -1,9 +1,9 @@
 /**
- * @param {import('../../services/template-cache/interface.ts').TemplateCache} $templateCache
+ * @param {ng.TemplateCacheService} $templateCache
  * @returns {import('../../interface.ts').Directive}
  */
 export function scriptDirective(
-  $templateCache: import("../../services/template-cache/interface.ts").TemplateCache,
+  $templateCache: ng.TemplateCacheService,
 ): import("../../interface.ts").Directive;
 export namespace scriptDirective {
   let $inject: string[];

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

@@ -1,11 +1,11 @@
 /**
- * @param {import('../../core/parse/interface.ts').ParseService} $parse
- * @param {import('../../services/log/interface.ts').LogService} $log
+ * @param {ng.ParseService} $parse
+ * @param {ng.LogService} $log
  * @returns {import('interface.ts').Directive}
  */
 export function ngSetterDirective(
-  $parse: import("../../core/parse/interface.ts").ParseService,
-  $log: import("../../services/log/interface.ts").LogService,
+  $parse: ng.ParseService,
+  $log: ng.LogService,
 ): any;
 export namespace ngSetterDirective {
   let $inject: string[];

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

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

package/@types/filters/filters.d.ts

@@ -33,6 +33,6 @@ export function formatNumber(
   fractionSize: any,
 ): string;
 /**
- * @returns {import('../interface.ts').FilterFn}
+ * @returns {ng.FilterFn}
  */
-export function jsonFilter(): import("../interface.ts").FilterFn;
+export function jsonFilter(): ng.FilterFn;

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

@@ -0,0 +1,8 @@
+/**
+ * A filter function takes an input and optional arguments, and returns a transformed value.
+ */
+export type FilterFn = (input: any, ...args: any[]) => any;
+/**
+ * A filter factory function that returns a FilterFn.
+ */
+export type FilterFactory = (...args: any[]) => FilterFn;

package/@types/filters/limit-to.d.ts

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

package/@types/filters/order-by.d.ts

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

package/@types/index.d.ts

@@ -1,2 +1,85 @@
-export const angular: Angular;
+import {
+  AnchorScrollProvider,
+  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";
+export * from "./services/http/interface.ts";
+export * from "./services/log/interface.ts";
+export * from "./services/log/log.js";
+export * from "./services/location/interface.ts";
+export * from "./services/location/location.js";
+export * from "./services/pubsub/pubsub.js";
+export * from "./services/template-cache/template-cache.js";
+export * from "./index.js";
 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 {
+  HttpParamSerializer,
+  HttpService as THttpService,
+  LogService as TLogService,
+} from "./interface.ts";
+import { ParseService as TParseService } from "./core/parse/interface.ts";
+import { TemplateRequestService as TTemplateRequestService } from "./services/template-request/interface.ts";
+import { HttpParamSerializerProvider } from "./services/http/http.js";
+import { FilterFactory, 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 {
+  Directive as TDirective,
+  DirectiveFactory as TDirectiveFactory,
+  Component as TComponent,
+  Controller as TController,
+} from "./interface.ts";
+import { StateProvider } from "./router/state/state-service.js";
+declare global {
+  interface Function {
+    $inject?: readonly string[] | undefined;
+  }
+  namespace ng {
+    type Angular = InstanceType<typeof Angular>;
+    type Attributes = InstanceType<typeof Attributes>;
+    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 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 AnchorScrollService = TAnchorScrollService;
+    type CompileService = CompileFn;
+    type ControllerService = TControllerService;
+    type ExceptionHandlerService = ErrorHandler;
+    type FilterService = FilterFactory;
+    type HttpParamSerializerSerService = HttpParamSerializer;
+    type HttpService = THttpService;
+    type InterpolateService = TInterpolateService;
+    type InjectorService = InstanceType<typeof InjectorService>;
+    type LogService = TLogService;
+    type ParseService = TParseService;
+    type PubSubService = InstanceType<typeof PubSub>;
+    type RootElementService = Element;
+    type RootScopeService = InstanceType<typeof Scope>;
+    type StateService = InstanceType<typeof StateProvider>;
+    type TemplateCacheService = InstanceType<typeof Map<string, string>>;
+    type TemplateRequestService = TTemplateRequestService;
+    type ErrorHandlingConfig = TErrorHandlingConfig;
+    type WindowService = Window;
+    type DocumentService = Document;
+  }
+}