@angular-wave/angular.ts 0.18.0 → 0.19.0

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

@@ -25,16 +25,12 @@ export class StateProvider {
   get params(): import("../params/state-params.js").StateParams;
   /**
    * The current [[StateDeclaration]]
-   *
-   * @deprecated This is a passthrough through to [[Router.current]]
    */
   get current(): import("./interface.ts").StateDeclaration;
   /**
    * The current [[StateObject]] (an internal API)
-   *
-   * @deprecated This is a passthrough through to [[Router.$current]]
    */
-  get $current(): import("./state-object.js").StateObject;
+  get $current(): ng.StateObject;
   /**
    * @type {ng.RouterProvider}
    */
@@ -43,17 +39,23 @@ export class StateProvider {
    * @type {ng.TransitionProvider}
    */
   transitionService: ng.TransitionProvider;
-  stateRegistry: any;
-  /** @type {ng.UrlService} */
-  urlService: ng.UrlService;
-  /** @type {ng.InjectorService} */
-  $injector: ng.InjectorService;
-  invalidCallbacks: any[];
+  /**
+   * @type {StateRegistryProvider | undefined}
+   */
+  stateRegistry: StateRegistryProvider | undefined;
+  /** @type {ng.UrlService | undefined } */
+  urlService: ng.UrlService | undefined;
+  /** @type {ng.InjectorService | undefined } */
+  $injector: ng.InjectorService | undefined;
+  /**
+   * @type {import("./interface.ts").OnInvalidCallback[]}
+   */
+  invalidCallbacks: import("./interface.ts").OnInvalidCallback[];
   /** @type {ng.ExceptionHandlerService} */
   _defaultErrorHandler: ng.ExceptionHandlerService;
   $get: (
     | string
-    | (($injector: ng.InjectorService, $url: any) => StateProvider)
+    | (($injector: ng.InjectorService, $url: ng.UrlService) => StateProvider)
   )[];
   /**
    * Decorates states when they are registered
@@ -136,7 +138,7 @@ export class StateProvider {
    * ```
    *
    * @param {string} name The name of the builder function to decorate.
-   * @param {object} func A function that is responsible for decorating the original
+   * @param {import("./interface.ts").BuilderFunction} func A function that is responsible for decorating the original
    * builder function. The function receives two parameters:
    *
    *   - `{object}` - state - The state urlConfig object.
@@ -144,7 +146,10 @@ export class StateProvider {
    *
    * @return {object} $stateProvider - $stateProvider instance
    */
-  decorator(name: string, func: object): object;
+  decorator(
+    name: string,
+    func: import("./interface.ts").BuilderFunction,
+  ): object;
   /**
    *
    * @param {import("./interface.ts").StateDeclaration} definition
@@ -158,10 +163,14 @@ export class StateProvider {
    * The results of the callbacks are wrapped in Promise.resolve(), so the callbacks may return promises.
    *
    * If a callback returns an TargetState, then it is used as arguments to $state.transitionTo() and the result returned.
-   *
    * @internal
+   * @param {PathNode[]} fromPath
+   * @param {TargetState} toState
    */
-  _handleInvalidTargetState(fromPath: any, toState: any): any;
+  _handleInvalidTargetState(
+    fromPath: PathNode[],
+    toState: TargetState,
+  ): Promise<any>;
   /**
    * Registers an Invalid State handler
    *
@@ -179,14 +188,14 @@ export class StateProvider {
    * });
    * ```
    *
-   * @param {function} callback invoked when the toState is invalid
+   * @param {import("./interface.ts").OnInvalidCallback} callback invoked when the toState is invalid
    *   This function receives the (invalid) toState, the fromState, and an injector.
    *   The function may optionally return a [[TargetState]] or a Promise for a TargetState.
    *   If one is returned, it is treated as a redirect.
    *
    * @returns a function which deregisters the callback
    */
-  onInvalid(callback: Function): any;
+  onInvalid(callback: import("./interface.ts").OnInvalidCallback): () => void;
   /**
    * Reloads the current state
    *
@@ -212,7 +221,7 @@ export class StateProvider {
    * });
    * ```
    *
-   * @param reloadState A state name or a state object.
+   * @param {string | StateDeclaration | StateObject} [reloadState] A state name or a state object.
    *    If present, this state and all its children will be reloaded, but ancestors will not reload.
    *
    * #### Example:
@@ -231,7 +240,9 @@ export class StateProvider {
    *
    * @returns A promise representing the state of the new transition. See [[StateService.go]]
    */
-  reload(reloadState: any): any;
+  reload(
+    reloadState?: string | StateDeclaration | StateObject,
+  ): Promise<any> | import("./interface.ts").TransitionPromise;
   /**
    * Transition to a different state and/or parameters
    *
@@ -254,7 +265,7 @@ export class StateProvider {
    * });
    * ```
    *
-   * @param to Absolute state name, state object, or relative state path (relative to current state).
+   * @param {StateOrName} to Absolute state name, state object, or relative state path (relative to current state).
    *
    * Some examples:
    *
@@ -263,24 +274,34 @@ export class StateProvider {
    * - `$state.go('^.sibling')` - if current state is `home.child`, will go to the `home.sibling` state
    * - `$state.go('.child.grandchild')` - if current state is home, will go to the `home.child.grandchild` state
    *
-   * @param params A map of the parameters that will be sent to the state, will populate $stateParams.
+   * @param {*} [params] A map of the parameters that will be sent to the state, will populate $stateParams.
    *
    *    Any parameters that are not specified will be inherited from current parameter values (because of `inherit: true`).
    *    This allows, for example, going to a sibling state that shares parameters defined by a parent state.
    *
-   * @param options Transition options
+   * @param {*} [options] Transition options
    *
-   * @returns {promise} A promise representing the state of the new transition.
+   * @returns {Promise<any>} A promise representing the state of the new transition.
    */
-  go(to: any, params: any, options: any): Promise<any>;
+  go(to: StateOrName, params?: any, options?: any): Promise<any>;
   /**
    * Creates a [[TargetState]]
    *
    * This is a factory method for creating a TargetState
    *
    * This may be returned from a Transition Hook to redirect a transition, for example.
+   * @param {string | import("./interface.ts").StateDeclaration | import("./state-object.js").StateObject} identifier
+   * @param {{}} params
+   * @param {any} [options]
    */
-  target(identifier: any, params: any, options?: {}): TargetState;
+  target(
+    identifier:
+      | string
+      | import("./interface.ts").StateDeclaration
+      | import("./state-object.js").StateObject,
+    params: {},
+    options?: any,
+  ): TargetState;
   getCurrentPath(): PathNode[];
   /**
    * Low-level method for transitioning to a new state.
@@ -298,85 +319,97 @@ export class StateProvider {
    * });
    * ```
    *
-   * @param to State name or state object.
-   * @param toParams A map of the parameters that will be sent to the state,
+   * @param {StateOrName} to State name or state object.
+   * @param {RawParams} toParams A map of the parameters that will be sent to the state,
    *      will populate $stateParams.
-   * @param options Transition options
+   * @param {TransitionOptions} options Transition options
    *
-   * @returns A promise representing the state of the new transition. See [[go]]
+   * @returns {TransitionPromise | Promise<any>} A promise representing the state of the new transition. See [[go]]
    */
-  transitionTo(to: any, toParams?: {}, options?: {}): any;
+  transitionTo(
+    to: StateOrName,
+    toParams?: RawParams,
+    options?: TransitionOptions,
+  ): TransitionPromise | Promise<any>;
   /**
-   * Checks if the current state *is* the provided state
-   *
-   * Similar to [[includes]] but only checks for the full state name.
-   * If params is supplied then it will be tested for strict equality against the current
-   * active params object, so all params must match with none missing and no extras.
-   *
-   * #### Example:
-   * ```js
-   * $state.$current.name = 'contacts.details.item';
-   *
-   * // absolute name
-   * $state.is('contact.details.item'); // returns true
-   * $state.is(contactDetailItemStateObject); // returns true
-   * ```
-   *
-   * // relative name (. and ^), typically from a template
-   * // E.g. from the 'contacts.details' template
-   * ```html
-   * <div ng-class="{highlighted: $state.is('.item')}">Item</div>
-   * ```
-   *
-   * @param stateOrName The state name (absolute or relative) or state object you'd like to check.
-   * @param params A param object, e.g. `{sectionId: section.id}`, that you'd like
-   * to test against the current active state.
-   * @param options An options object. The options are:
-   *   - `relative`: If `stateOrName` is a relative state name and `options.relative` is set, .is will
-   *     test relative to `options.relative` state (or name).
-   *
-   * @returns Returns true if it is the state.
-   */
-  is(stateOrName: any, params: any, options: any): boolean;
+       * Checks if the current state *is* the provided state
+       *
+       * Similar to [[includes]] but only checks for the full state name.
+       * If params is supplied then it will be tested for strict equality against the current
+       * active params object, so all params must match with none missing and no extras.
+       *
+       * #### Example:
+       * ```js
+       * $state.$current.name = 'contacts.details.item';
+       *
+       * // absolute name
+       * $state.is('contact.details.item'); // returns true
+       * $state.is(contactDetailItemStateObject); // returns true
+       * ```
+       *
+       * // relative name (. and ^), typically from a template
+       * // E.g. from the 'contacts.details' template
+       * ```html
+       * <div ng-class="{highlighted: $state.is('.item')}">Item</div>
+       * ```
+       * @param {import("./state-matcher.js").StateOrName} stateOrName The state name (absolute or relative) or state object you'd like to check.
+       * @param {import("../params/interface.ts").RawParams} [params] A param object, e.g. `{sectionId: section.id}`, that you'd like
+      to test against the current active state.
+       * @param {{ relative: import("./state-matcher.js").StateOrName | undefined; } | undefined} [options] An options object. The options are:
+      - `relative`: If `stateOrName` is a relative state name and `options.relative` is set, .is will
+      test relative to `options.relative` state (or name).
+       * @returns {boolean | undefined} Returns true if it is the state.
+       */
+  is(
+    stateOrName: import("./state-matcher.js").StateOrName,
+    params?: import("../params/interface.ts").RawParams,
+    options?:
+      | {
+          relative: import("./state-matcher.js").StateOrName | undefined;
+        }
+      | undefined,
+  ): boolean | undefined;
   /**
-   * Checks if the current state *includes* the provided state
-   *
-   * A method to determine if the current active state is equal to or is the child of the
-   * state stateName. If any params are passed then they will be tested for a match as well.
-   * Not all the parameters need to be passed, just the ones you'd like to test for equality.
-   *
-   * #### Example when `$state.$current.name === 'contacts.details.item'`
-   * ```js
-   * // Using partial names
-   * $state.includes("contacts"); // returns true
-   * $state.includes("contacts.details"); // returns true
-   * $state.includes("contacts.details.item"); // returns true
-   * $state.includes("contacts.list"); // returns false
-   * $state.includes("about"); // returns false
-   * ```
-   *
-   * #### Glob Examples when `* $state.$current.name === 'contacts.details.item.url'`:
-   * ```js
-   * $state.includes("*.details.*.*"); // returns true
-   * $state.includes("*.details.**"); // returns true
-   * $state.includes("**.item.**"); // returns true
-   * $state.includes("*.details.item.url"); // returns true
-   * $state.includes("*.details.*.url"); // returns true
-   * $state.includes("*.details.*"); // returns false
-   * $state.includes("item.**"); // returns false
-   * ```
-   *
-   * @param stateOrName A partial name, relative name, glob pattern,
-   *   or state object to be searched for within the current state name.
-   * @param params A param object, e.g. `{sectionId: section.id}`,
-   *   that you'd like to test against the current active state.
-   * @param options An options object. The options are:
-   *   - `relative`: If `stateOrName` is a relative state name and `options.relative` is set, .is will
-   *     test relative to `options.relative` state (or name).
-   *
-   * @returns {boolean} Returns true if it does include the state
-   */
-  includes(stateOrName: any, params: any, options: any): boolean;
+       * Checks if the current state *includes* the provided state
+       *
+       * A method to determine if the current active state is equal to or is the child of the
+       * state stateName. If any params are passed then they will be tested for a match as well.
+       * Not all the parameters need to be passed, just the ones you'd like to test for equality.
+       *
+       * #### Example when `$state.$current.name === 'contacts.details.item'`
+       * ```js
+       * // Using partial names
+       * $state.includes("contacts"); // returns true
+       * $state.includes("contacts.details"); // returns true
+       * $state.includes("contacts.details.item"); // returns true
+       * $state.includes("contacts.list"); // returns false
+       * $state.includes("about"); // returns false
+       * ```
+       *
+       * #### Glob Examples when `* $state.$current.name === 'contacts.details.item.url'`:
+       * ```js
+       * $state.includes("*.details.*.*"); // returns true
+       * $state.includes("*.details.**"); // returns true
+       * $state.includes("**.item.**"); // returns true
+       * $state.includes("*.details.item.url"); // returns true
+       * $state.includes("*.details.*.url"); // returns true
+       * $state.includes("*.details.*"); // returns false
+       * $state.includes("item.**"); // returns false
+       * ```
+       * @param {StateOrName} stateOrName A partial name, relative name, glob pattern,
+      or state object to be searched for within the current state name.
+       * @param {RawParams} [params] A param object, e.g. `{sectionId: section.id}`,
+      that you'd like to test against the current active state.
+       * @param {TransitionOptions} [options] An options object. The options are:
+      - `relative`: If `stateOrName` is a relative state name and `options.relative` is set, .is will
+      test relative to `options.relative` state (or name).
+       * @returns {boolean | undefined} Returns true if it does include the state
+       */
+  includes(
+    stateOrName: StateOrName,
+    params?: RawParams,
+    options?: TransitionOptions,
+  ): boolean | undefined;
   /**
    * Generates a URL for a state and parameters
    *
@@ -386,14 +419,16 @@ export class StateProvider {
    * ```js
    * expect($state.href("about.person", { person: "bob" })).toEqual("/about/bob");
    * ```
-   *
-   * @param stateOrName The state name or state object you'd like to generate a url from.
-   * @param params An object of parameter values to fill the state's required parameters.
-   * @param options Options object. The options are:
-   *
-   * @returns {string} compiled state url
+   * @param {import("./state-matcher.js").StateOrName} stateOrName The state name or state object you'd like to generate a url from.
+   * @param {import("../params/interface.ts").RawParams} params An object of parameter values to fill the state's required parameters.
+   * @param {import("./interface.ts").HrefOptions} [options] Options object. The options are:
+   * @returns {string | null} compiled state url
    */
-  href(stateOrName: any, params: any, options: any): string;
+  href(
+    stateOrName: import("./state-matcher.js").StateOrName,
+    params: import("../params/interface.ts").RawParams,
+    options?: import("./interface.ts").HrefOptions,
+  ): string | null;
   /**
    * Sets or gets the default [[transitionTo]] error handler.
    *
@@ -414,25 +449,49 @@ export class StateProvider {
    *   // Do not log transitionTo errors
    * });
    * ```
-   *
-   * @param handler a global error handler function
+   * @param {import("../../docs.ts").ExceptionHandler | undefined} [handler] a global error handler function
    * @returns the current global error handler
    */
-  defaultErrorHandler(handler: any): any;
-  get(stateOrName: any, base: any, ...args: any[]): any;
+  defaultErrorHandler(
+    handler?: import("../../docs.ts").ExceptionHandler | undefined,
+  ): import("../../docs.ts").ExceptionHandler;
   /**
-   * Lazy loads a state
-   *
-   * Explicitly runs a state's [[StateDeclaration.lazyLoad]] function.
-   *
-   * @param stateOrName the state that should be lazy loaded
-   * @param transition the optional Transition context to use (if the lazyLoad function requires an injector, etc)
-   * Note: If no transition is provided, a noop transition is created using the from the current state to the current state.
-   * This noop transition is not actually run.
-   *
-   * @returns a promise to lazy load
+   * @param {import("./interface.ts").StateOrName} stateOrName
+   * @param {undefined} [base]
    */
-  lazyLoad(stateOrName: any, transition: any): any;
+  get(
+    stateOrName: import("./interface.ts").StateOrName,
+    base?: undefined,
+    ...args: any[]
+  ):
+    | import("./interface.ts").StateDeclaration
+    | import("./interface.ts").StateDeclaration[];
+  /**
+       * Lazy loads a state
+       *
+       * Explicitly runs a state's [[StateDeclaration.lazyLoad]] function.
+       * @param {import("./interface.ts").StateOrName} stateOrName the state that should be lazy loaded
+       * @param {ng.Transition} transition the optional Transition context to use (if the lazyLoad function requires an injector, etc)
+      Note: If no transition is provided, a noop transition is created using the from the current state to the current state.
+      This noop transition is not actually run.
+       * @returns a promise to lazy load
+       */
+  lazyLoad(
+    stateOrName: import("./interface.ts").StateOrName,
+    transition: ng.Transition,
+  ): Promise<import("./interface.ts").LazyLoadResult>;
 }
-import { TargetState } from "./target-state.js";
+export type StateRegistryProvider =
+  import("./state-registry.js").StateRegistryProvider;
+export type StateDeclaration = import("./interface.ts").StateDeclaration;
+export type StateObject = import("./state-object.js").StateObject;
+export type StateOrName = import("./state-matcher.js").StateOrName;
+export type Transition = import("../transition/transition.js").Transition;
+export type TransitionPromise = import("./interface.ts").TransitionPromise;
+export type TransitionOptions =
+  import("../transition/interface.ts").TransitionOptions;
+export type RawParams = import("../params/interface.ts").RawParams;
+export type OnInvalidCallback = import("./interface.ts").OnInvalidCallback;
+export type HookResult = import("../transition/transition-hook.js").HookResult;
 import { PathNode } from "../path/path-node.js";
+import { TargetState } from "./target-state.js";

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

@@ -34,37 +34,37 @@ export class TargetState {
    * Note: Do not construct a `TargetState` manually.
    * To create a `TargetState`, use the [[StateService.target]] factory method.
    *
-   * @param _stateRegistry The StateRegistry to use to look up the _definition
-   * @param _identifier An identifier for a state.
+   * @param {import("./state-service.js").StateRegistryProvider} _stateRegistry The StateRegistry to use to look up the _definition
+   * @param {import("./interface.js").StateOrName} _identifier An identifier for a state.
    *    Either a fully-qualified state name, or the object used to define the state.
-   * @param _params Parameters for the target state
-   * @param _options Transition options.
+   * @param {import("../params/interface.js").RawParams} _params Parameters for the target state
+   * @param {import("../transition/interface.js").TransitionOptions} _options Transition options.
    *
    * @internal
    */
   constructor(
-    _stateRegistry: any,
-    _identifier: any,
-    _params: any,
-    _options: any,
+    _stateRegistry: import("./state-service.js").StateRegistryProvider,
+    _identifier: import("./interface.js").StateOrName,
+    _params: import("../params/interface.js").RawParams,
+    _options: import("../transition/interface.js").TransitionOptions,
   );
-  _stateRegistry: any;
-  _identifier: any;
-  _params: any;
-  _options: any;
-  _definition: any;
+  _stateRegistry: import("./state-registry.js").StateRegistryProvider;
+  _identifier: import("./interface.js").StateOrName;
+  _params: import("../params/interface.js").RawParams;
+  _options: import("../transition/interface.js").TransitionOptions;
+  _definition: import("./state-object.js").StateObject;
   /** The name of the state this object targets */
-  name(): any;
+  name(): import("./interface.js").StateOrName;
   /** The identifier used when creating this TargetState */
-  identifier(): any;
+  identifier(): import("./interface.js").StateOrName;
   /** The target parameter values */
-  params(): any;
+  params(): import("../params/interface.js").RawParams;
   /** The internal state object (if it was found) */
-  $state(): any;
+  $state(): import("./state-object.js").StateObject;
   /** The internal state declaration (if it was found) */
-  state(): any;
+  state(): import("./interface.js").StateDeclaration;
   /** The target options */
-  options(): any;
+  options(): import("../transition/interface.js").TransitionOptions;
   /** True if the target state was found */
   exists(): boolean;
   /** True if the object is valid */
@@ -76,25 +76,34 @@ export class TargetState {
    * Returns a copy of this TargetState which targets a different state.
    * The new TargetState has the same parameter values and transition options.
    *
-   * @param state The new state that should be targeted
+   * @param {import("./interface.js").StateOrName} state The new state that should be targeted
+   * @returns {TargetState} A new TargetState instance which targets the desired state
    */
-  withState(state: any): TargetState;
+  withState(state: import("./interface.js").StateOrName): TargetState;
   /**
    * Returns a copy of this TargetState, using the specified parameter values.
    *
-   * @param params the new parameter values to use
-   * @param replace When false (default) the new parameter values will be merged with the current values.
+   * @param {import("../params/interface.js").RawParams} params the new parameter values to use
+   * @param {boolean} replace When false (default) the new parameter values will be merged with the current values.
    *                When true the parameter values will be used instead of the current values.
+   * @returns {TargetState} A new TargetState instance which targets the same state with the desired parameters
    */
-  withParams(params: any, replace?: boolean): TargetState;
+  withParams(
+    params: import("../params/interface.js").RawParams,
+    replace?: boolean,
+  ): TargetState;
   /**
    * Returns a copy of this TargetState, using the specified Transition Options.
    *
-   * @param options the new options to use
-   * @param replace When false (default) the new options will be merged with the current options.
+   * @param {import("../transition/interface.js").TransitionOptions} options the new options to use
+   * @param {boolean} replace When false (default) the new options will be merged with the current options.
    *                When true the options will be used instead of the current options.
+   * @returns {TargetState} A new TargetState instance which targets the same state with the desired options
    */
-  withOptions(options: any, replace?: boolean): TargetState;
+  withOptions(
+    options: import("../transition/interface.js").TransitionOptions,
+    replace?: boolean,
+  ): TargetState;
 }
 export namespace TargetState {
   /** Returns true if the object has a state property that might be a state or state name */

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

@@ -1,4 +1,10 @@
-export function getViewConfigFactory(): (path: any, view: any) => ViewConfig;
+/**
+ * @return {(path: import("../path/path-node.js").PathNode[], view: import("./interface.ts").ViewDeclaration) => ViewConfig}
+ */
+export function getViewConfigFactory(): (
+  path: import("../path/path-node.js").PathNode[],
+  view: import("./interface.ts").ViewDeclaration,
+) => ViewConfig;
 /**
  * This is a [[StateBuilder.builder]] function for angular1 `views`.
  *
@@ -7,23 +13,25 @@ export function getViewConfigFactory(): (path: any, view: any) => ViewConfig;
  *
  * If no `views: {}` property exists on the [[StateDeclaration]], then it creates the `views` object
  * and applies the state-level configuration to a view named `$default`.
- *
+ * @param {ng.StateObject & Record<string, any>} state
  */
-export function ng1ViewsBuilder(state: any): {};
+export function ng1ViewsBuilder(
+  state: ng.StateObject & Record<string, any>,
+): Record<string, any>;
 export class ViewConfig {
   /**
    * Normalizes a view's name from a state.views configuration block.
    *
-   * This should be used by a framework implementation to calculate the values for
+   * This calculates the values for
    * [[_ViewDeclaration.$ngViewName]] and [[_ViewDeclaration.$ngViewContextAnchor]].
    *
-   * @param context the context object (state declaration) that the view belongs to
-   * @param rawViewName the name of the view, as declared in the [[StateDeclaration.views]]
+   * @param {import("./state-service.js").StateObject} context the context object (state declaration) that the view belongs to
+   * @param {string} rawViewName the name of the view, as declared in the [[StateDeclaration.views]]
    *
    * @returns the normalized ngViewName and ngViewContextAnchor that the view targets
    */
   static normalizeUIViewTarget(
-    context: any,
+    context: import("./state-service.js").StateObject,
     rawViewName?: string,
   ): {
     ngViewName: string;
@@ -31,28 +39,49 @@ export class ViewConfig {
   };
   /**
    * @param {Array<import('../path/path-node.js').PathNode>} path
-   * @param viewDecl
+   * @param {import("./interface.ts").ViewDeclaration} viewDecl
    * @param {import('../template-factory.js').TemplateFactoryProvider} factory
    */
   constructor(
     path: Array<import("../path/path-node.js").PathNode>,
-    viewDecl: any,
+    viewDecl: import("./interface.ts").ViewDeclaration,
     factory: import("../template-factory.js").TemplateFactoryProvider,
   );
-  path: import("../path/path-node.js").PathNode[];
-  viewDecl: any;
+  $id: number;
+  /**
+   * @type {Array<import('../path/path-node.js').PathNode>}
+   */
+  path: Array<import("../path/path-node.js").PathNode>;
+  /**
+   * @type {import("./interface.ts").ViewDeclaration}
+   */
+  viewDecl: import("./interface.ts").ViewDeclaration;
+  /**
+   * @type {import('../template-factory.js').TemplateFactoryProvider}
+   */
   factory: import("../template-factory.js").TemplateFactoryProvider;
-  component: any;
-  template: any;
-  /** @type {Number} */ $id: number;
+  /**
+   * @type {string | undefined}
+   */
+  component: string | undefined;
+  /**
+   * @type {string | undefined}
+   */
+  template: string | undefined;
+  /** @type {boolean} */
   loaded: boolean;
-  getTemplate: (ngView: any, context: any) => any;
-  load(): Promise<this>;
+  getTemplate: (ngView: any, context: ResolveContext) => string;
+  /**
+   *
+   * @returns {Promise<ViewConfig>}
+   */
+  load(): Promise<ViewConfig>;
   controller: any;
   /**
    * Gets the controller for a view configuration.
-   *
-   * @returns {Function|Promise.<Function>} Returns a controller, or a promise that resolves to a controller.
+   * @returns {Function | Promise<Function>} Returns a controller, or a promise that resolves to a controller.
+   * @param {ResolveContext} context
    */
-  getController(context: any): Function | Promise<Function>;
+  getController(context: ResolveContext): Function | Promise<Function>;
 }
+import { ResolveContext } from "../resolve/resolve-context.js";