@angular-wave/angular.ts 0.17.0 → 0.19.0

package/@types/router/resolve/resolve-context.d.ts

@@ -19,8 +19,11 @@ export namespace resolvePolicies {
  * The ResolveContext closes over the [[PathNode]]s, and provides DI for the last node in the path.
  */
 export class ResolveContext {
-  constructor(_path: any);
-  _path: any;
+  /**
+   * @param {import("../resolve/resolve-context.js").PathNode[]} _path
+   */
+  constructor(_path: import("../resolve/resolve-context.js").PathNode[]);
+  _path: import("../path/path-node.js").PathNode[];
   /** Gets all the tokens found in the resolve context, de-duplicated */
   getTokens(): any;
   /**
@@ -28,34 +31,39 @@ export class ResolveContext {
    *
    * Gets the last Resolvable that matches the token in this context, or undefined.
    * Throws an error if it doesn't exist in the ResolveContext
+   * @param {string} token
+   * @return {Resolvable}
    */
-  getResolvable(token: any): any;
-  /** Returns the [[ResolvePolicy]] for the given [[Resolvable]] */
-  getPolicy(resolvable: any): any;
+  getResolvable(token: string): Resolvable;
   /**
-   * Returns a ResolveContext that includes a portion of this one
-   *
-   * Given a state, this method creates a new ResolveContext from this one.
-   * The new context starts at the first node (root) and stops at the node for the `state` parameter.
-   *
-   * #### Why
-   *
-   * When a transition is created, the nodes in the "To Path" are injected from a ResolveContext.
-   * A ResolveContext closes over a path of [[PathNode]]s and processes the resolvables.
-   * The "To State" can inject values from its own resolvables, as well as those from all its ancestor state's (node's).
-   * This method is used to create a narrower context when injecting ancestor nodes.
-   *
-   * @example
-   * `let ABCD = new ResolveContext([A, B, C, D]);`
-   *
-   * Given a path `[A, B, C, D]`, where `A`, `B`, `C` and `D` are nodes for states `a`, `b`, `c`, `d`:
-   * When injecting `D`, `D` should have access to all resolvables from `A`, `B`, `C`, `D`.
-   * However, `B` should only be able to access resolvables from `A`, `B`.
-   *
-   * When resolving for the `B` node, first take the full "To Path" Context `[A,B,C,D]` and limit to the subpath `[A,B]`.
-   * `let AB = ABCD.subcontext(a)`
+   * Returns the [[ResolvePolicy]] for the given [[Resolvable]]
+   * @param {Resolvable} resolvable
+   * @return {import("./interface.ts").ResolvePolicy}
    */
-  subContext(state: any): ResolveContext;
+  getPolicy(resolvable: Resolvable): import("./interface.ts").ResolvePolicy;
+  /**
+       * Returns a ResolveContext that includes a portion of this one
+       *
+       * Given a state, this method creates a new ResolveContext from this one.
+       * The new context starts at the first node (root) and stops at the node for the `state` parameter.
+       *
+       * #### Why
+       *
+       * When a transition is created, the nodes in the "To Path" are injected from a ResolveContext.
+       * A ResolveContext closes over a path of [[PathNode]]s and processes the resolvables.
+       * The "To State" can inject values from its own resolvables, as well as those from all its ancestor state's (node's).
+       * This method is used to create a narrower context when injecting ancestor nodes.
+       * @example `let ABCD = new ResolveContext([A, B, C, D]);`
+  
+      Given a path `[A, B, C, D]`, where `A`, `B`, `C` and `D` are nodes for states `a`, `b`, `c`, `d`:
+      When injecting `D`, `D` should have access to all resolvables from `A`, `B`, `C`, `D`.
+      However, `B` should only be able to access resolvables from `A`, `B`.
+  
+      When resolving for the `B` node, first take the full "To Path" Context `[A,B,C,D]` and limit to the subpath `[A,B]`.
+      `let AB = ABCD.subcontext(a)`
+       * @param {ng.BuiltStateDeclaration} state
+       */
+  subContext(state: ng.BuiltStateDeclaration): ResolveContext;
   /**
    * Adds Resolvables to the node that matches the state
    *
@@ -68,19 +76,28 @@ export class ResolveContext {
    *
    * Note: each resolvable's [[ResolvePolicy]] is merged with the state's policy, and the global default.
    *
-   * @param {Resolvable[]} newResolvables the new Resolvables
-   * @param state Used to find the node to put the resolvable on
+   * @param {Resolvable[] | import("./interface.ts").ResolvableLiteral[]} newResolvables the new Resolvables
+   * @param {ng.StateObject} state Used to find the node to put the resolvable on
    */
-  addResolvables(newResolvables: Resolvable[], state: any): void;
+  addResolvables(
+    newResolvables: Resolvable[] | import("./interface.ts").ResolvableLiteral[],
+    state: ng.StateObject,
+  ): void;
   /**
    * Returns a promise for an array of resolved path Element promises
    *
-   * @param {string} when
-   * @param trans
+   * @param {import("./interface.ts").PolicyWhen} when
+   * @param {ng.Transition} trans
    * @returns {Promise<any>|any}
    */
-  resolvePath(when: string, trans: any): Promise<any> | any;
-  findNode(resolvable: any): any;
+  resolvePath(
+    when: import("./interface.ts").PolicyWhen,
+    trans: ng.Transition,
+  ): Promise<any> | any;
+  /**
+   * @param {Resolvable} resolvable
+   */
+  findNode(resolvable: Resolvable): any;
   /**
    * Gets the async dependencies of a Resolvable
    *
@@ -90,4 +107,5 @@ export class ResolveContext {
    */
   getDependencies(resolvable: Resolvable): Resolvable[];
 }
+export type PathNode = import("../path/path-node.js").PathNode;
 import { Resolvable } from "./resolvable.js";

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

@@ -18,27 +18,25 @@ export class RouterProvider {
    */
   _lastStartedTransitionId: number;
   /**
-   * @type {Queue<import("./transition/transition.js").Transition>}
+   * @type {Queue<ng.Transition>}
    */
-  _transitionHistory: Queue<import("./transition/transition.js").Transition>;
+  _transitionHistory: Queue<ng.Transition>;
   /**
-   * @type {Queue<import("./transition/transition.js").Transition>}
+   * @type {Queue<ng.Transition>}
    */
-  _successfulTransitions: Queue<
-    import("./transition/transition.js").Transition
-  >;
+  _successfulTransitions: Queue<ng.Transition>;
   /**
-   * @type {import("./state/interface.ts").StateDeclaration|undefined}
+   * @type {ng.StateDeclaration|undefined}
    */
-  current: import("./state/interface.ts").StateDeclaration | undefined;
+  current: ng.StateDeclaration | undefined;
   /**
-   * @type {import("./state/state-object.js").StateObject|undefined}
+   * @type {ng.StateObject|undefined}
    */
-  $current: import("./state/state-object.js").StateObject | undefined;
+  $current: ng.StateObject | undefined;
   /**
-   * @type {import("./transition/transition.js").Transition|undefined}
+   * @type {ng.Transition|undefined}
    */
-  transition: import("./transition/transition.js").Transition | undefined;
+  transition: ng.Transition | undefined;
   $get: () => this;
 }
 /**

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

@@ -6,6 +6,7 @@ import { Transition } from "../transition/transition.js";
 import {
   TransitionStateHookFn,
   TransitionOptions,
+  HookResult,
 } from "../transition/interface.ts";
 import {
   ResolvePolicy,
@@ -26,11 +27,11 @@ export interface TargetStateDef {
   options?: TransitionOptions;
 }
 export type ResolveTypes = Resolvable | ResolvableLiteral | ProviderLike;
+export type RawViewConfig = ViewDeclaration | string;
 /**
  * Interface for declaring a view
  *
  * This interface defines the basic data that a normalized view declaration will have on it.
- * Add any additional fields that the framework requires to that interface.
  */
 export interface ViewDeclaration {
   /**
@@ -38,29 +39,22 @@ export interface ViewDeclaration {
    */
   $name?: string;
   /**
-   * The normalized address for the `ui-view` which this ViewConfig targets.
+   * The normalized address for the `ng-view` which this ViewConfig targets.
    *
-   * A ViewConfig targets a `ui-view` in the DOM (relative to the `uiViewContextAnchor`) which has
+   * A ViewConfig targets a `ng-view` in the DOM (relative to the `ngVIewContextAnchor`) which has
    * a specific name.
    * @example `header` or `$default`
    *
-   * The `uiViewName` can also target a _nested view_ by providing a dot-notation address
+   * The `ngVIewName` can also target a _nested view_ by providing a dot-notation address
    * @example `foo.bar` or `foo.$default.bar`
    */
-  $uiViewName?: string;
+  $ngViewName?: string;
   /**
-   * The normalized context anchor (state name) for the `uiViewName`
+   * The normalized context anchor (state name) for the `ngVIewName`
    *
-   * When targeting a `ui-view`, the `uiViewName` address is anchored to a context name (state name).
+   * When targeting a `ng-view`, the `ngVIewName` address is anchored to a context name (state name).
    */
-  $uiViewContextAnchor?: string;
-  /**
-   * A type identifier for the View
-   *
-   * This is used when loading prerequisites for the view, before it enters the DOM.  Different types of views
-   * may load differently (e.g., templateProvider+controllerProvider vs component class)
-   */
-  $type?: string;
+  $ngViewContextAnchor?: string;
   /**
    * The context that this view is declared within.
    */
@@ -188,7 +182,7 @@ export interface ViewDeclaration {
    * A property of [[StateDeclaration]] or [[ViewDeclaration]]:
    *
    * The controller function, or the name of a registered controller.  The controller function will be used
-   * to control the contents of the [[directives.uiView]] directive.
+   * to control the contents of the [[directives.ngVIew]] directive.
    *
    * If specified as a string, controllerAs can be declared here, i.e., "FooController as foo" instead of in
    * a separate [[controllerAs]] property.
@@ -247,7 +241,7 @@ export interface ViewDeclaration {
    * A property of [[StateDeclaration]] or [[ViewDeclaration]]:
    *
    * HTML template as a string, or a function which returns an html template as a string.
-   * This template will be used to render the corresponding [[directives.uiView]] directive.
+   * This template will be used to render the corresponding [[directives.ngVIew]] directive.
    *
    * This property takes precedence over templateUrl.
    *
@@ -255,7 +249,7 @@ export interface ViewDeclaration {
    *
    * #### Example:
    * ```js
-   * template: "<h1>inline template definition</h1><div ui-view></div>"
+   * template: "<h1>inline template definition</h1><div ng-view></div>"
    * ```
    *
    * #### Example:
@@ -272,7 +266,7 @@ export interface ViewDeclaration {
    * A property of [[StateDeclaration]] or [[ViewDeclaration]]:
    *
    * A path or a function that returns a path to an html template.
-   * The template will be fetched and used to render the corresponding [[directives.uiView]] directive.
+   * The template will be fetched and used to render the corresponding [[directives.ngVIew]] directive.
    *
    * If `templateUrl` is a function, it will be called with the Transition parameters as the first argument.
    *
@@ -295,7 +289,7 @@ export interface ViewDeclaration {
    * A property of [[StateDeclaration]] or [[ViewDeclaration]]:
    *
    * Injected function which returns the HTML template.
-   * The template will be used to render the corresponding [[directives.uiView]] directive.
+   * The template will be used to render the corresponding [[directives.ngVIew]] directive.
    *
    * #### Example:
    * ```js
@@ -324,8 +318,6 @@ export type RedirectToResult =
 /**
  * The StateDeclaration object is used to define a state or nested state.
  *
- * Note: Each implementation of UI-Router (for a specific framework)
- * extends this interface as necessary.
  *
  * #### Example:
  * ```js
@@ -387,6 +379,131 @@ export interface StateDeclaration {
    * ```
    */
   parent?: string | StateDeclaration;
+  /**
+   * Resolve - a mechanism to asynchronously fetch data, participating in the Transition lifecycle
+   *
+   * The `resolve:` property defines data (or other dependencies) to be fetched asynchronously when the state is being entered.
+   * After the data is fetched, it may be used in views, transition hooks or other resolves that belong to this state.
+   * The data may also be used in any views or resolves that belong to nested states.
+   *
+   * ### As an array
+   *
+   * Each array element should be a [[ResolvableLiteral]] object.
+   *
+   * #### Example:
+   * The `user` resolve injects the current `Transition` and the `UserService` (using its token, which is a string).
+   * The [[ResolvableLiteral.resolvePolicy]] sets how the resolve is processed.
+   * The `user` data, fetched asynchronously, can then be used in a view.
+   * ```js
+   * var state = {
+   *   name: 'user',
+   *   url: '/user/:userId
+   *   resolve: [
+   *     {
+   *       token: 'user',
+   *       policy: { when: 'EAGER' },
+   *       deps: ['UserService', Transition],
+   *       resolveFn: (userSvc, trans) => userSvc.fetchUser(trans.params().userId) },
+   *     }
+   *   ]
+   * }
+   * ```
+   *
+   * Note: an Angular 2 style [`useFactory` provider literal](https://angular.io/docs/ts/latest/cookbook/dependency-injection.html#!#provide)
+   * may also be used.  See [[ProviderLike]].
+   * #### Example:
+   * ```
+   * resolve: [
+   *   { provide: 'token', useFactory: (http) => http.get('/'), deps: [ Http ] },
+   * ]
+   * ```
+   *
+   * ### As an object
+   *
+   * The `resolve` property may be an object where:
+   * - Each key (string) is the name of the dependency.
+   * - Each value (function) is an injectable function which returns the dependency, or a promise for the dependency.
+   *
+   * This style is based on AngularTS injectable functions, but can be used with any UI-Router implementation.
+   * If your code will be minified, the function should be ["annotated" in the AngularTS manner](https://docs.angularjs.org/guide/di#dependency-annotation).
+   *
+   * #### AngularTS Example:
+   * ```js
+   * resolve: {
+   *   // If you inject `myStateDependency` into a controller, you'll get "abc"
+   *   myStateDependency: function() {
+   *     return "abc";
+   *   },
+   *   // Dependencies are annotated in "Inline Array Annotation"
+   *   myAsyncData: ['$http', '$transition$' function($http, $transition$) {
+   *     // Return a promise (async) for the data
+   *     return $http.get("/foos/" + $transition$.params().foo);
+   *   }]
+   * }
+   * ```
+   *
+   * Note: You cannot specify a policy for each Resolvable, nor can you use non-string
+   * tokens when using the object style `resolve:` block.
+   *
+   * ### Lifecycle
+   *
+   * Since a resolve function can return a promise, the router will delay entering the state until the promises are ready.
+   * If any of the promises are rejected, the Transition is aborted with an Error.
+   *
+   * By default, resolves for a state are fetched just before that state is entered.
+   * Note that only states which are being *entered* during the `Transition` have their resolves fetched.
+   * States that are "retained" do not have their resolves re-fetched.
+   *
+   * If you are currently in a parent state `parent` and are transitioning to a child state `parent.child`, the
+   * previously resolved data for state `parent` can be injected into `parent.child` without delay.
+   *
+   * Any resolved data for `parent.child` is retained until `parent.child` is exited, e.g., by transitioning back to the `parent` state.
+   *
+   * Because of this scoping and lifecycle, resolves are a great place to fetch your application's primary data.
+   *
+   * ### Injecting resolves into other things
+   *
+   * During a transition, Resolve data can be injected into:
+   *
+   * - Views (the components which fill a `ng-view` tag)
+   * - Transition Hooks
+   * - Other resolves (a resolve may depend on asynchronous data from a different resolve)
+   *
+   * ### Injecting other things into resolves
+   *
+   * Resolve functions usually have dependencies on some other API(s).
+   * The dependencies are usually declared and injected into the resolve function.
+   * A common pattern is to inject a custom service such as `UserService`.
+   * The resolve then delegates to a service method, such as `UserService.list()`;
+   *
+   * #### Special injectable tokens
+   *
+   * - `UIRouter`: The [[UIRouter]] instance which has references to all the UI-Router services.
+   * - `Transition`: The current [[Transition]] object; information and API about the current transition, such as
+   *    "to" and "from" State Parameters and transition options.
+   * - `'$transition$'`: A string alias for the `Transition` injectable
+   * - `'$state$'`: For `onEnter`/`onExit`/`onRetain`, the state being entered/exited/retained.
+   * - Other resolve tokens: A resolve can depend on another resolve, either from the same state, or from any parent state.
+   *
+   * #### Example:
+   * ```js
+   * // Injecting a resolve into another resolve
+   * resolve: [
+   *   // Define a resolve 'allusers' which delegates to the UserService.list()
+   *   // which returns a promise (async) for all the users
+   *   { provide: 'allusers', useFactory: (UserService) => UserService.list(), deps: [UserService] },
+   *
+   *   // Define a resolve 'user' which depends on the allusers resolve.
+   *   // This resolve function is not called until 'allusers' is ready.
+   *   { provide: 'user', (allusers, trans) => _.find(allusers, trans.params().userId, deps: ['allusers', Transition] }
+   * }
+   * ```
+   */
+  resolve?:
+    | ResolveTypes[]
+    | {
+        [key: string]: Injectable<any>;
+      };
   /**
    * Sets the resolve policy defaults for all resolves on this state
    *
@@ -455,16 +572,16 @@ export interface StateDeclaration {
   /**
    * Named views
    *
-   * An optional object which defines multiple views, or explicitly targets specific named ui-views.
+   * An optional object which defines multiple views, or explicitly targets specific named ng-views.
    *
    * - What is a view urlConfig
-   * - What is a ui-view
+   * - What is a ng-view
    * - Shorthand controller/template
    * - Incompatible with ^
    *
    *  Examples:
    *
-   *  Targets three named ui-views in the parent state's template
+   *  Targets three named ng-views in the parent state's template
    *
    * #### Example:
    * ```js
@@ -484,8 +601,8 @@ export interface StateDeclaration {
    *
    * @example
    * ```js
-   * // Targets named ui-view="header" from ancestor state 'top''s template, and
-   * // named `ui-view="body" from parent state's template.
+   * // Targets named ng-view="header" from ancestor state 'top''s template, and
+   * // named `ng-view="body" from parent state's template.
    * views: {
    *   'header@top': {
    *     controller: "msgHeaderCtrl",
@@ -497,9 +614,7 @@ export interface StateDeclaration {
    * }
    * ```
    */
-  views?: {
-    [key: string]: ViewDeclaration;
-  };
+  views?: Record<string, RawViewConfig>;
   /**
    * An inherited property to store state data
    *
@@ -825,7 +940,7 @@ export type BuiltStateDeclaration = StateDeclaration & {
   /** Computed parameters of this state */
   params?: Record<string, any>;
   /** Optional parent state */
-  parent?: BuiltStateDeclaration | null;
+  parent?: StateDeclaration | null;
   /** Optional inherited data */
   data?: any;
   _stateObjectCache?: {
@@ -876,3 +991,51 @@ export type _StateDeclaration =
   | {
       new (): StateDeclaration;
     };
+/**
+ * The signature for the callback function provided to [[StateRegistry.onStatesChanged]].
+ *
+ * This callback receives two parameters:
+ *
+ * @param event a string; either "registered" or "deregistered"
+ * @param states the list of [[StateDeclaration]]s that were registered (or deregistered).
+ */
+export type StateRegistryListener = (
+  event: "registered" | "deregistered",
+  states: StateDeclaration[],
+) => void;
+/**
+ * A function that builds the final value for a specific field on a [[StateObject]].
+ *
+ * A series of builder functions for a given field are chained together.
+ * The final value returned from the chain of builders is applied to the built [[StateObject]].
+ * Builder functions should call the [[parent]] function either first or last depending on the desired composition behavior.
+ *
+ * @param state the _partially built_ [[StateObject]]. The [[StateDeclaration]] can be inspected via [[StateObject.self]]
+ * @param parent the previous builder function in the series.
+ */
+export type BuilderFunction = (
+  state: ng.StateObject & ng.BuiltStateDeclaration,
+  parent?: BuilderFunction,
+) => any;
+export type OnInvalidCallback = (
+  toState?: TargetState,
+  fromState?: TargetState,
+  injector?: ng.InjectorService,
+) => HookResult;
+export type LazyLoadFn = (
+  transition: Transition,
+  state: StateDeclaration,
+) => Promise<LazyLoadResult>;
+export interface Builders {
+  [key: string]: BuilderFunction[];
+  name: BuilderFunction[];
+  parent: BuilderFunction[];
+  data: BuilderFunction[];
+  url: BuilderFunction[];
+  navigable: BuilderFunction[];
+  params: BuilderFunction[];
+  views: BuilderFunction[];
+  path: BuilderFunction[];
+  includes: BuilderFunction[];
+  resolvables: BuilderFunction[];
+}

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

@@ -39,9 +39,11 @@
  *   { provide: "myBazResolve", useFactory: function(dep) { dep.fetchSomethingAsPromise() }, deps: [ "DependencyName" ] }
  * ]
  * @param {ng.StateObject & ng.StateDeclaration} state
+ * @param {boolean | undefined} strictDi
  */
 export function resolvablesBuilder(
   state: ng.StateObject & ng.StateDeclaration,
+  strictDi: boolean | undefined,
 ): any[];
 /**
  * A internal global service
@@ -65,38 +67,36 @@ export class StateBuilder {
     urlService: ng.UrlService,
   );
   _matcher: import("./state-matcher.js").StateMatcher;
-  _$injector: any;
-  _builders: {
-    name: ((state: any) => any)[];
-    self: (typeof selfBuilder)[];
-    parent: ((
-      state: any,
-    ) =>
-      | import("./state-object.js").StateObject
-      | import("./interface.ts").BuiltStateDeclaration)[];
-    data: (typeof dataBuilder)[];
-    url: ((stateObject: any) => any)[];
-    navigable: ((state: any) => any)[];
-    params: ((state: any) => any)[];
-    views: any[];
-    path: (typeof pathBuilder)[];
-    includes: (typeof includesBuilder)[];
-    resolvables: (typeof resolvablesBuilder)[];
-  };
-  builder(name: any, fn: any): any;
+  /** @type {ng.InjectorService | undefined} */
+  _$injector: ng.InjectorService | undefined;
+  /** @type {Builders} */
+  _builders: Builders;
+  /**
+   * @param {string} name
+   * @param {*} fn
+   * @returns {BuilderFunction | BuilderFunction[] | null | undefined}
+   */
+  builder(
+    name: string,
+    fn: any,
+  ): BuilderFunction | BuilderFunction[] | null | undefined;
   /**
    * Builds all of the properties on an essentially blank State object, returning a State object which has all its
    * properties and API built.
    *
-   * @param state an uninitialized State object
-   * @returns the built State object
+   * @param {ng.StateObject} state an uninitialized State object
+   * @returns {ng.StateObject | null} the built State object
+   */
+  build(state: ng.StateObject): ng.StateObject | null;
+  /**
+   *
+   * @param {ng.StateObject} state
+   * @returns {string}
    */
-  build(state: any): any;
-  parentName(state: any): any;
-  name(state: any): any;
+  parentName(state: ng.StateObject): string;
+  /** @param {ng.StateObject} state*/
+  name(state: ng.StateObject): string;
 }
-declare function selfBuilder(state: any): any;
-declare function dataBuilder(state: any): any;
-declare function pathBuilder(state: any): any;
-declare function includesBuilder(state: any): any;
-export {};
+export type BuilderFunction = import("./interface.js").BuilderFunction;
+export type Builders = import("./interface.js").Builders;
+export type UrlMatcher = import("../url/url-matcher.js").UrlMatcher;

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

@@ -1,15 +1,33 @@
+/** @typedef {import("./state-object.js").StateObject} StateObject */
+/** @typedef {import("./interface.ts").StateOrName} StateOrName */
+/** @typedef {import("./interface.ts").StateStore} StateStore */
 export class StateMatcher {
-  /** @param {import("./interface.ts").StateStore} states */
-  constructor(states: import("./interface.ts").StateStore);
-  /** @type {import("./interface.ts").StateStore} */
-  _states: import("./interface.ts").StateStore;
-  isRelative(stateName: any): boolean;
+  /** @param {StateStore} states */
+  constructor(states: StateStore);
+  /** @type {StateStore} */
+  _states: StateStore;
+  /**
+   * @param {string} stateName
+   */
+  isRelative(stateName: string): boolean;
+  /**
+   * @param {StateOrName} stateOrName
+   * @param {StateOrName | undefined} [base]
+   * @returns {StateObject | undefined}
+   */
   find(
-    stateOrName: any,
-    base: any,
+    stateOrName: StateOrName,
+    base?: StateOrName | undefined,
     matchGlob?: boolean,
-  ):
-    | import("./state-object.js").StateObject
-    | import("./interface.ts").BuiltStateDeclaration;
-  resolvePath(name: any, base: any): string;
+  ): StateObject | undefined;
+  /**
+   * `
+   * @param {string} name
+   * @param {StateOrName} base
+   * @returns {string}
+   */
+  resolvePath(name: string, base: StateOrName): string;
 }
+export type StateObject = import("./state-object.js").StateObject;
+export type StateOrName = import("./interface.ts").StateOrName;
+export type StateStore = import("./interface.ts").StateStore;