@angular-wave/angular.ts 0.18.0 → 0.19.0

package/@types/namespace.d.ts

@@ -21,6 +21,11 @@ import {
   HttpParamSerializer as THttpParamSerializer,
   HttpProviderDefaults as THttpProviderDefaults,
   RequestShortcutConfig as TRequestShortcutConfig,
+  HttpResponseStatus as THttpResponseStatus,
+  HttpMethod as THttpMethod,
+  RequestConfig as TRequestConfig,
+  HttpPromise as THttpPromise,
+  HttpResponse as THttpResponse,
 } from "./services/http/interface.ts";
 import { HttpParamSerializerProvider as THttpParamSerializerProvider } from "./services/http/http.js";
 import {
@@ -29,7 +34,10 @@ import {
   FilterFn as TFilterFn,
 } from "./filters/interface.ts";
 import { FilterProvider as TFilterProvider } from "./core/filter/filter.js";
-import { InterpolateService as TInterpolateService } from "./core/interpolate/interface.ts";
+import {
+  InterpolateService as TInterpolateService,
+  InterpolationFunction as TInterpolationFunction,
+} from "./core/interpolate/interface.ts";
 import { InterpolateProvider as TInterpolateProvider } from "./core/interpolate/interpolate.js";
 import {
   SceProvider as TSceProvider,
@@ -53,6 +61,7 @@ import {
   Injectable as TInjectable,
   Expression as TExpression,
   PublicInjectionTokens,
+  InvocationDetail as TInvocationDetail,
 } from "./interface.ts";
 import {
   SseService as TSseService,
@@ -81,6 +90,7 @@ import { Location as TLocationService } from "./services/location/location.js";
 import {
   AnimateService as TAnimateService,
   AnimationOptions as TAnimationOptions,
+  AnimateCssService as TAnimateCssService,
 } from "./animations/interface.ts";
 import {
   StorageBackend as TStorageBackend,
@@ -111,7 +121,6 @@ import {
 } from "./router/state/interface.ts";
 import { StateObject as TStateObject } from "./router/state/state-object.js";
 import { StateRegistryProvider as TStateRegistryProvider } from "./router/state/state-registry.js";
-import { HookRegistry } from "./router/transition/interface.ts";
 import {
   SceService as TSceService,
   SceDelegateService as TSceDelegateService,
@@ -121,6 +130,11 @@ import {
   WebSocketService as TWebSocketService,
 } from "./services/websocket/interface.ts";
 import { AnimateRunner as TAnimateRunner } from "./animations/runner/animate-runner.js";
+import { Transition as TTransition } from "./router/transition/transition.js";
+import { TemplateFactoryProvider as TTemplateFactoryProvider } from "./router/template-factory.js";
+import { TransitionService as TTransitionService } from "./router/transition/interface.ts";
+import { UrlConfigProvider as TUrlConfigProvider } from "./router/url/url-config.js";
+import { AriaService as TAriaService } from "./directive/aria/interface.ts";
 declare global {
   interface Function {
     $inject?: readonly string[] | undefined;
@@ -131,22 +145,22 @@ declare global {
   }
   export namespace ng {
     type Angular = TAngular;
-    type Attributes = TAttributes & Record<string, string>;
-    type Directive<TController = any> = TDirective<TController>;
-    type DirectiveFactory = TDirectiveFactory;
     type AnnotatedDirectiveFactory = TAnnotatedDirectiveFactory;
+    type Attributes = TAttributes & Record<string, string>;
+    type BoundTranscludeFn = TBoundTranscludeFn;
     type Component = TComponent & Record<string, any>;
+    type CompositeLinkFn = TCompositeLinkFn;
     type Controller = TController;
-    type Scope = TScope & Record<string, any>;
+    type Directive<TController = any> = TDirective<TController>;
+    type DirectiveFactory = TDirectiveFactory;
+    type LinkFnMapping = TLinkFnMapping;
     type NgModule = TNgModule;
-    type PubSubProvider = TPubSubProvider;
-    type CompositeLinkFn = TCompositeLinkFn;
-    type PublicLinkFn = TPublicLinkFn;
     type NodeLinkFn = TNodeLinkFn;
     type NodeLinkFnCtx = TNodeLinkFnCtx;
+    type PublicLinkFn = TPublicLinkFn;
+    type PubSubProvider = TPubSubProvider;
+    type Scope = TScope & Record<string, any>;
     type TranscludeFn = TTranscludeFn;
-    type BoundTranscludeFn = TBoundTranscludeFn;
-    type LinkFnMapping = TLinkFnMapping;
     type AnchorScrollProvider = TAnchorScrollProvider;
     type AnimateProvider = TAnimateProvider;
     type FilterProvider = TFilterProvider;
@@ -154,13 +168,18 @@ declare global {
     type HttpParamSerializerProvider = THttpParamSerializerProvider;
     type InterpolateProvider = TInterpolateProvider;
     type LocationProvider = TLocationProvider;
-    type SceProvider = TSceProvider;
     type SceDelegateProvider = TSceDelegateProvider;
+    type SceProvider = TSceProvider;
     type TransitionProvider = TTransitionProvider;
+    type TransitionService = TTransitionService;
     type RouterProvider = TRouterProvider;
+    type TemplateFactoryProvider = TTemplateFactoryProvider;
+    type UrlConfigProvider = TUrlConfigProvider;
     type AnchorScrollService = TAnchorScrollService;
     type AnimateService = TAnimateService;
+    type AnimateCssService = TAnimateCssService;
     type AnimateRunner = TAnimateRunner;
+    type AriaService = TAriaService;
     type CompileService = TCompileFn;
     type ControllerService = TControllerService;
     type CookieService = TCookieService;
@@ -170,8 +189,8 @@ declare global {
     type FilterService = TFilterService;
     type HttpParamSerializerSerService = THttpParamSerializer;
     type HttpService = THttpService;
-    type InterpolateService = TInterpolateService;
     type InjectorService = TInjectorService;
+    type InterpolateService = TInterpolateService;
     type LocationService = TLocationService;
     type LogService = TLogService;
     type ParseService = TParseService;
@@ -186,49 +205,56 @@ declare global {
     type SceDelegateService = TSceDelegateService;
     type SseService = TSseService;
     type SseConfig = TSseConfig;
-    type TransitionService = TransitionProvider & HookRegistry;
     type TemplateCacheService = Map<string, string>;
     type TemplateRequestService = TTemplateRequestService;
     type UrlService = TUrlService;
     type ViewService = TViewService;
+    type AngularService = Angular;
+    type AnnotatedFactory<T extends (...args: any[]) => any> =
+      TAnnotatedFactory<T>;
     type AnimationOptions = TAnimationOptions;
-    type ErrorHandlingConfig = TErrorHandlingConfig;
-    type ListenerFn = TListenerFn;
-    type Listener = TListener;
+    type BuiltStateDeclaration = TBuiltStateDeclaration;
+    type ControllerConstructor = TControllerConstructor;
+    type CookieOptions = TCookieOptions;
+    type CookieStoreOptions = TCookieStoreOptions;
     type DocumentService = Document;
-    type WindowService = Window;
-    type AngularService = Angular;
-    type WorkerConfig = TWorkerConfig;
-    type WorkerConnection = TWorkerConnection;
+    type EntityClass<T> = TEntityClass<T>;
+    type ErrorHandlingConfig = TErrorHandlingConfig;
+    type Expression = TExpression;
+    type HttpMethod = THttpMethod;
+    type HttpPromise<T> = THttpPromise<T>;
+    type HttpProviderDefaults = THttpProviderDefaults;
+    type HttpResponse<T> = THttpResponse<T>;
+    type HttpResponseStatus = THttpResponseStatus;
     type Injectable<
       T extends
         | ((...args: any[]) => any)
         | (abstract new (...args: any[]) => any),
     > = TInjectable<T>;
-    type AnnotatedFactory<T extends (...args: any[]) => any> =
-      TAnnotatedFactory<T>;
+    type InjectionTokens = typeof PublicInjectionTokens;
+    type InterpolationFunction = TInterpolationFunction;
+    type InvocationDetail = TInvocationDetail;
+    type Listener = TListener;
+    type ListenerFn = TListenerFn;
+    type NgModelController = TNgModelController;
+    type ProviderCache = TProviderCache;
+    type RequestConfig = TRequestConfig;
+    type RequestShortcutConfig = TRequestShortcutConfig;
+    type RestDefinition<T> = TRestDefinition<T>;
+    type RestService<T, ID> = TRestService<T, ID>;
+    type ScopeEvent = TScopeEvent;
+    type ServiceProvider = TServiceProvider;
+    type StateDeclaration = TStateDeclaration;
+    type StateObject = TStateObject & Record<string, any>;
     type StorageBackend = TStorageBackend;
     type StorageType = TStorageType;
     type StreamConnectionConfig = TStreamConnectionConfig;
-    type CookieOptions = TCookieOptions;
-    type ControllerConstructor = TControllerConstructor;
-    type CookieStoreOptions = TCookieStoreOptions;
-    type RestService<T, ID> = TRestService<T, ID>;
-    type RestDefinition<T> = TRestDefinition<T>;
-    type EntityClass<T> = TEntityClass<T>;
-    type ServiceProvider = TServiceProvider;
-    type Expression = TExpression;
-    type NgModelController = TNgModelController;
+    type Transition = TTransition;
     type Validator = TValidator;
-    type StateDeclaration = TStateDeclaration;
-    type BuiltStateDeclaration = TBuiltStateDeclaration;
-    type StateObject = TStateObject;
-    type InjectionTokens = typeof PublicInjectionTokens;
-    type ScopeEvent = TScopeEvent;
-    type RequestShortcutConfig = TRequestShortcutConfig;
-    type HttpProviderDefaults = THttpProviderDefaults;
-    type ProviderCache = TProviderCache;
     type WebSocketConfig = TWebSocketConfig;
     type WebSocketService = TWebSocketService;
+    type WindowService = Window;
+    type WorkerConfig = TWorkerConfig;
+    type WorkerConnection = TWorkerConnection;
   }
 }

package/@types/router/common/trace.d.ts

@@ -1,59 +1,164 @@
-export type Category = number;
-export namespace Category {
-  let _RESOLVE: number;
-  let _TRANSITION: number;
-  let _HOOK: number;
-  let _UIVIEW: number;
-  let _VIEWCONFIG: number;
-}
+/**
+ * Trace categories Enum
+ *
+ * Enable or disable a category using [[Trace.enable]] or [[Trace.disable]]
+ *
+ * `trace.enable(Category.TRANSITION)`
+ *
+ * These can also be provided using a matching string, or position ordinal
+ *
+ * `trace.enable("TRANSITION")`
+ *
+ * `trace.enable(1)`
+ */
+/**
+ * @type {Record<string, string>}
+ */
+export const Category: Record<string, string>;
 /**
  * Prints ng-router Transition trace information to the console.
  */
 export class Trace {
-  _enabled: {};
+  /** @type {Record<string, boolean> } */
+  _enabled: Record<string, boolean>;
   approximateDigests: number;
   $logger: any;
-  _set(enabled: any, categories: any): void;
-  enable(...categories: any[]): void;
-  disable(...categories: any[]): void;
+  /**
+   * @param {boolean} enabled
+   * @param {string[]} categories
+   */
+  _set(enabled: boolean, categories: string[]): void;
+  /**
+   * @param {string[]} categories
+   */
+  enable(...categories: string[]): void;
+  /**
+   * @param {string[]} categories
+   */
+  disable(...categories: string[]): void;
   /**
    * Retrieves the enabled stateus of a [[Category]]
    *
    * ```js
    * trace.enabled("VIEWCONFIG"); // true or false
    * ```
-   *
-   * @returns boolean true if the category is enabled
+   * @param {string} category
+   * @returns {boolean} true if the category is enabled
    */
-  enabled(category: any): boolean;
-  /** @internal called by ng-router code */
-  traceTransitionStart(trans: any): void;
-  /** @internal called by ng-router code */
-  traceTransitionIgnored(trans: any): void;
-  /** @internal called by ng-router code */
-  traceHookInvocation(step: any, trans: any, options: any): void;
-  /** @internal called by ng-router code */
-  traceHookResult(hookResult: any, trans: any): void;
-  /** @internal called by ng-router code */
-  traceResolvePath(path: any, when: any, trans: any): void;
-  /** @internal called by ng-router code */
-  traceResolvableResolved(resolvable: any, trans: any): void;
-  /** @internal called by ng-router code */
-  traceError(reason: any, trans: any): void;
-  /** @internal called by ng-router code */
-  traceSuccess(finalState: any, trans: any): void;
-  /** @internal called by ng-router code */
-  traceUIViewEvent(event: any, viewData: any, extra?: string): void;
-  /** @internal called by ng-router code */
-  traceUIViewConfigUpdated(viewData: any, context: any): void;
-  /** @internal called by ng-router code */
-  traceUIViewFill(viewData: any, html: any): void;
-  /** @internal called by ng-router code */
-  traceViewSync(pairs: any): void;
-  /** @internal called by ng-router code */
-  traceViewServiceEvent(event: any, viewConfig: any): void;
+  enabled(category: string): boolean;
+  /**
+   * @internal called by ng-router code
+   * @param {ng.Transition} trans
+   */
+  traceTransitionStart(trans: ng.Transition): void;
+  /**
+   * @internal called by ng-router code
+   * @param {ng.Transition} trans
+   */
+  traceTransitionIgnored(trans: ng.Transition): void;
+  /**
+   * @internal called by ng-router code
+   * @param {import("../transition/transition-hook.js").TransitionHook} step
+   * @param {ng.Transition} trans
+   * @param {import("../transition/interface.ts").TransitionHookOptions} options
+   */
+  traceHookInvocation(
+    step: import("../transition/transition-hook.js").TransitionHook,
+    trans: ng.Transition,
+    options: import("../transition/interface.ts").TransitionHookOptions,
+  ): void;
   /** @internal called by ng-router code */
-  traceViewServiceUIViewEvent(event: any, viewData: any): void;
+  /**
+   * @param {HookResult} hookResult
+   * @param {ng.Transition} trans
+   */
+  traceHookResult(hookResult: HookResult, trans: ng.Transition): void;
+  /**
+   * @internal called by ng-router code
+   * @param {import("../path/path-node.js").PathNode[]} path
+   * @param {import("../resolve/interface.ts").PolicyWhen} when
+   * @param {ng.Transition} trans
+   */
+  traceResolvePath(
+    path: import("../path/path-node.js").PathNode[],
+    when: import("../resolve/interface.ts").PolicyWhen,
+    trans: ng.Transition,
+  ): void;
+  /**
+   * @internal called by ng-router code
+   * @param {import("../resolve/resolvable.js").Resolvable} resolvable
+   * @param {ng.Transition} trans
+   */
+  traceResolvableResolved(
+    resolvable: import("../resolve/resolvable.js").Resolvable,
+    trans: ng.Transition,
+  ): void;
+  /**
+   * @internal called by ng-router code
+   * @param {any} reason
+   * @param {ng.Transition} trans
+   */
+  traceError(reason: any, trans: ng.Transition): void;
+  /**
+   * @internal called by ng-router code
+   * @param {import("../state/state-object.js").StateObject} finalState
+   * @param {ng.Transition} trans
+   */
+  traceSuccess(
+    finalState: import("../state/state-object.js").StateObject,
+    trans: ng.Transition,
+  ): void;
+  /**
+   * @internal called by ng-router code
+   * @param {string} event
+   * @param {import("../view/interface.ts").ActiveUIView} viewData
+   */
+  traceUIViewEvent(
+    event: string,
+    viewData: import("../view/interface.ts").ActiveUIView,
+    extra?: string,
+  ): void;
+  /**
+   * @internal called by ng-router code
+   * @param {import("../view/interface.ts").ActiveUIView} viewData
+   * @param {import("../view/interface.ts").ViewContext | undefined} context
+   */
+  traceUIViewConfigUpdated(
+    viewData: import("../view/interface.ts").ActiveUIView,
+    context: import("../view/interface.ts").ViewContext | undefined,
+  ): void;
+  /**
+   * @internal called by ng-router code
+   * @param {import("../view/interface.ts").ActiveUIView} viewData
+   * @param {string} html
+   */
+  traceUIViewFill(
+    viewData: import("../view/interface.ts").ActiveUIView,
+    html: string,
+  ): void;
+  /**
+   * @internal called by ng-router code
+   * @param {import("../view/interface.ts").ViewTuple[]} pairs
+   */
+  traceViewSync(pairs: import("../view/interface.ts").ViewTuple[]): void;
+  /**
+   * @internal called by ng-router code
+   * @param {string} event
+   * @param {import("../view/view.js").ViewConfig} viewConfig
+   */
+  traceViewServiceEvent(
+    event: string,
+    viewConfig: import("../view/view.js").ViewConfig,
+  ): void;
+  /**
+   * @internal called by ng-router code
+   * @param {string} event
+   * @param {import("../view/interface.ts").ActiveUIView} viewData
+   */
+  traceViewServiceUIViewEvent(
+    event: string,
+    viewData: import("../view/interface.ts").ActiveUIView,
+  ): void;
 }
 /**
  * The [[Trace]] singleton
@@ -65,3 +170,6 @@ export class Trace {
  * ```
  */
 export const trace: Trace;
+export type HookResult = import("../transition/interface.ts").HookResult;
+export type TransitionHook =
+  import("../transition/transition-hook.js").TransitionHook;

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

@@ -31,16 +31,16 @@ export namespace $StateRefDynamicDirective {
  * @param {ng.StateService} $state
  * @param {ng.RouterService} $router
  * @param {ng.InterpolateService} $interpolate
- * @param {*} $stateRegistry
- * @param {*} $transitions
+ * @param {ng.StateRegistryService} $stateRegistry
+ * @param {ng.TransitionService} $transitions
  * @returns {ng.Directive}
  */
 export function $StateRefActiveDirective(
   $state: ng.StateService,
   $router: ng.RouterService,
   $interpolate: ng.InterpolateService,
-  $stateRegistry: any,
-  $transitions: any,
+  $stateRegistry: ng.StateRegistryService,
+  $transitions: ng.TransitionService,
 ): ng.Directive;
 export namespace $StateRefActiveDirective {
   let $inject_2: string[];

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

@@ -18,16 +18,13 @@ export namespace $ViewDirective {
  * @param {ng.CompileService} $compile
  * @param {ng.ControllerService} $controller
  * @param {ng.TransitionService} $transitions
- * @returns
+ * @return {ng.Directive}
  */
 export function $ViewDirectiveFill(
   $compile: ng.CompileService,
   $controller: ng.ControllerService,
   $transitions: ng.TransitionService,
-): {
-  priority: number;
-  compile(tElement: any): (scope: any, $element: any) => void;
-};
+): ng.Directive;
 export namespace $ViewDirectiveFill {
   let $inject_1: string[];
   export { $inject_1 as $inject };

package/@types/router/hooks/core-resolvables.d.ts

@@ -1,2 +1,11 @@
-export function registerAddCoreResolvables(transitionService: any): void;
-export function treeChangesCleanup(trans: any): void;
+/**
+ * @param {ng.TransitionService} transitionService
+ */
+export function registerAddCoreResolvables(
+  transitionService: ng.TransitionService,
+): import("../transition/interface.ts").DeregisterFn;
+/**
+ *
+ * @param {ng.Transition} trans
+ */
+export function treeChangesCleanup(trans: ng.Transition): void;

package/@types/router/hooks/ignored-transition.d.ts

@@ -1 +1,3 @@
-export function registerIgnoredTransitionHook(transitionService: any): any;
+export function registerIgnoredTransitionHook(
+  transitionService: ng.TransitionService,
+): import("../transition/interface.ts").DeregisterFn;

package/@types/router/hooks/invalid-transition.d.ts

@@ -1 +1,3 @@
-export function registerInvalidTransitionHook(transitionService: any): any;
+export function registerInvalidTransitionHook(
+  transitionService: ng.TransitionService,
+): import("../transition/interface.ts").DeregisterFn;

package/@types/router/hooks/lazy-load.d.ts

@@ -21,22 +21,26 @@
  * ```
  *
  * See [[StateDeclaration.lazyLoad]]
+ * @param {ng.TransitionService} transitionService
+ * @param {ng.StateService} [stateService]
+ * @param {ng.UrlService} [urlService]
+ * @param {ng.StateRegistryService | undefined} [stateRegistry]
  */
 export function registerLazyLoadHook(
-  transitionService: any,
-  stateService: any,
-  urlService: any,
-  stateRegistry: any,
-): any;
+  transitionService: ng.TransitionService,
+  stateService?: ng.StateService,
+  urlService?: ng.UrlService,
+  stateRegistry?: ng.StateRegistryService | undefined,
+): import("../transition/interface.ts").DeregisterFn;
 /**
  * Invokes a state's lazy load function
- *
- * @param transition a Transition context
- * @param state the state to lazy load
- * @returns A promise for the lazy load result
+ * @param {ng.Transition} transition a Transition context
+ * @param {import("../state/interface.ts").StateDeclaration} state the state to lazy load
+ * @param {ng.StateRegistryService | undefined} [stateRegistry]
+ * @return {Promise<import("../state/interface.ts").LazyLoadResult | undefined>} a promise for the lazy load result
  */
 export function lazyLoadState(
-  transition: any,
-  state: any,
-  stateRegistry: any,
-): any;
+  transition: ng.Transition,
+  state: import("../state/interface.ts").StateDeclaration,
+  stateRegistry?: ng.StateRegistryService | undefined,
+): Promise<import("../state/interface.ts").LazyLoadResult | undefined>;

package/@types/router/hooks/on-enter-exit-retain.d.ts

@@ -1,3 +1,9 @@
-export function registerOnExitHook(transitionService: any): any;
-export function registerOnRetainHook(transitionService: any): any;
-export function registerOnEnterHook(transitionService: any): any;
+export function registerOnExitHook(
+  transitionService: ng.TransitionService,
+): import("../transition/interface.ts").DeregisterFn;
+export function registerOnRetainHook(
+  transitionService: ng.TransitionService,
+): import("../transition/interface.ts").DeregisterFn;
+export function registerOnEnterHook(
+  transitionService: ng.TransitionService,
+): import("../transition/interface.ts").DeregisterFn;

package/@types/router/hooks/redirect-to.d.ts

@@ -1,4 +1,4 @@
 export function registerRedirectToHook(
-  transitionService: any,
-  stateService: any,
-): void;
+  transitionService: ng.TransitionService,
+  stateService: ng.StateService,
+): import("../transition/interface.ts").DeregisterFn;

package/@types/router/hooks/resolve.d.ts

@@ -1,4 +1,12 @@
+/** @typedef  {import("../transition/interface.ts").TreeChanges} TreeChanges */
 export const RESOLVE_HOOK_PRIORITY: 1000;
-export function registerEagerResolvePath(transitionService: any): any;
-export function registerLazyResolveState(transitionService: any): any;
-export function registerResolveRemaining(transitionService: any): any;
+export function registerEagerResolvePath(
+  transitionService: ng.TransitionService,
+): import("../transition/interface.ts").DeregisterFn;
+export function registerLazyResolveState(
+  transitionService: ng.TransitionService,
+): import("../transition/interface.ts").DeregisterFn;
+export function registerResolveRemaining(
+  transitionService: ng.TransitionService,
+): import("../transition/interface.ts").DeregisterFn;
+export type TreeChanges = import("../transition/interface.ts").TreeChanges;

package/@types/router/hooks/views.d.ts

@@ -1,5 +1,7 @@
-export function registerLoadEnteringViews(transitionService: any): any;
+export function registerLoadEnteringViews(
+  transitionService: ng.TransitionService,
+): import("../transition/interface.ts").DeregisterFn;
 export function registerActivateViews(
-  transitionService: any,
-  viewService: any,
-): void;
+  transitionService: ng.TransitionService,
+  viewService: ng.ViewService,
+): import("../transition/interface.ts").DeregisterFn;

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

@@ -24,7 +24,7 @@ export interface RawParams {
  * #### Example:
  * ```js
  * var mystate = {
- *   template: '<div ui-view/>',
+ *   template: '<div ng-view/>',
  *   controller: function() {}
  *   url: '/mystate/:start?{count:int}',
  *   params: {
@@ -306,6 +306,7 @@ export interface ParamDeclaration {
    * Default: `true`
    */
   inherit?: boolean;
+  _fn?: any;
 }
 /**
  * String replacement
@@ -328,7 +329,7 @@ export interface Replace {
    *
    * Used instead of the [[from]] value.
    */
-  to: string;
+  to: string | undefined;
 }
 /**
  * Describes a custom [[ParamType]]

package/@types/router/params/param-factory.d.ts

@@ -1,3 +1,4 @@
+/** @typedef {import("./param-type.js").ParamType} ParamType */
 export class ParamFactory {
   /**
    * @param {import("../url/url-config.js").UrlConfigProvider} urlServiceConfig
@@ -9,8 +10,28 @@ export class ParamFactory {
    * @type {import("../url/url-config.js").UrlConfigProvider}
    */
   urlServiceConfig: import("../url/url-config.js").UrlConfigProvider;
-  fromConfig(id: any, type: any, state: any): Param;
-  fromPath(id: any, type: any, state: any): Param;
-  fromSearch(id: any, type: any, state: any): Param;
+  /**
+   * @param {string} id
+   * @param {ParamType | null} type
+   * @param {ng.StateDeclaration} state
+   */
+  fromConfig(
+    id: string,
+    type: ParamType | null,
+    state: ng.StateDeclaration,
+  ): Param;
+  /**
+   * @param {string} id
+   * @param {ParamType} type
+   * @param {ng.StateDeclaration} state
+   */
+  fromPath(id: string, type: ParamType, state: ng.StateDeclaration): Param;
+  /**
+   * @param {string} id
+   * @param {ParamType} type
+   * @param {ng.StateDeclaration} state
+   */
+  fromSearch(id: string, type: ParamType, state: ng.StateDeclaration): Param;
 }
+export type ParamType = import("./param-type.js").ParamType;
 import { Param } from "./param.js";