@angular-wave/angular.ts 0.14.3 → 0.15.1

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

@@ -14,7 +14,9 @@ import {
 } from "../resolve/interface.ts";
 import { Resolvable } from "../resolve/resolvable.js";
 import { TargetState } from "./target-state.js";
+import { Glob } from "../glob/glob.js";
 export type StateOrName = string | StateDeclaration | StateObject;
+export type StateStore = Record<string, StateObject | BuiltStateDeclaration>;
 export interface TransitionPromise extends Promise<StateObject> {
   transition: Transition;
 }
@@ -352,7 +354,7 @@ export interface StateDeclaration {
    * Note: [State] objects require unique names.
    * The name is used like an id.
    */
-  name?: string;
+  name: string;
   /**
    * Abstract state indicator
    *
@@ -385,131 +387,6 @@ 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 `ui-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
    *
@@ -928,6 +805,33 @@ export interface StateDeclaration {
    */
   reloadOnSearch?: boolean;
 }
+/**
+ * Represents a fully built StateObject, after registration in the StateRegistry
+ * and application of all StateBuilder decorators.
+ */
+export type BuiltStateDeclaration = StateDeclaration & {
+  /** Reference to the original StateDeclaration */
+  self: StateDeclaration;
+  /** Array of Resolvables built from the resolve / resolvePolicy */
+  resolvables: Resolvable[];
+  /** Full path from root down to this state */
+  path: BuiltStateDeclaration[];
+  /** Fast lookup of included states for $state.includes() */
+  includes: Record<string, boolean>;
+  /** Closest ancestor state that has a URL (navigable) */
+  navigable?: BuiltStateDeclaration | null;
+  /** URL object built from url / parent / root */
+  url?: any;
+  /** Computed parameters of this state */
+  params?: Record<string, any>;
+  /** Optional parent state */
+  parent?: BuiltStateDeclaration | null;
+  /** Optional inherited data */
+  data?: any;
+  _stateObjectCache?: {
+    nameGlob: Glob;
+  } | null;
+};
 /**
  * The return type of a [[StateDeclaration.lazyLoad]] function
  *

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

@@ -38,8 +38,11 @@
  *   new Resolvable("myBarResolve", function(dep) { return dep.fetchSomethingAsPromise() }, [ "DependencyName" ]),
  *   { provide: "myBazResolve", useFactory: function(dep) { dep.fetchSomethingAsPromise() }, deps: [ "DependencyName" ] }
  * ]
+ * @param {ng.StateObject & ng.StateDeclaration} state
  */
-export function resolvablesBuilder(state: any): any[];
+export function resolvablesBuilder(
+  state: ng.StateObject & ng.StateDeclaration,
+): any[];
 /**
  * A internal global service
  *
@@ -55,18 +58,22 @@ export function resolvablesBuilder(state: any): any[];
 export class StateBuilder {
   /**
    * @param {import('./state-matcher.js').StateMatcher} matcher
-   * @param urlService
+   * @param {ng.UrlService} urlService
    */
   constructor(
     matcher: import("./state-matcher.js").StateMatcher,
-    urlService: any,
+    urlService: ng.UrlService,
   );
-  matcher: import("./state-matcher.js").StateMatcher;
-  $injector: any;
-  builders: {
+  _matcher: import("./state-matcher.js").StateMatcher;
+  _$injector: any;
+  _builders: {
     name: ((state: any) => any)[];
     self: (typeof selfBuilder)[];
-    parent: ((state: any) => any)[];
+    parent: ((
+      state: any,
+    ) =>
+      | import("./state-object.js").StateObject
+      | import("./interface.ts").BuiltStateDeclaration)[];
     data: (typeof dataBuilder)[];
     url: ((stateObject: any) => any)[];
     navigable: ((state: any) => any)[];

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

@@ -1,7 +1,15 @@
 export class StateMatcher {
-  constructor(_states: any);
-  _states: any;
+  /** @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;
-  find(stateOrName: any, base: any, matchGlob?: boolean): any;
+  find(
+    stateOrName: any,
+    base: any,
+    matchGlob?: boolean,
+  ):
+    | import("./state-object.js").StateObject
+    | import("./interface.ts").BuiltStateDeclaration;
   resolvePath(name: any, base: any): string;
 }

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

@@ -1,4 +1,3 @@
-/** @typedef {import('./interface.ts').StateDeclaration} StateDeclaration */
 /**
  * Internal representation of a ng-router state.
  *
@@ -8,9 +7,9 @@
  *
  * This class prototypally inherits from the corresponding [[StateDeclaration]].
  * Each of its own properties (i.e., `hasOwnProperty`) are built using builders from the [[StateBuilder]].
- * @implements {StateDeclaration}
+ * @implements {ng.StateDeclaration}
  */
-export class StateObject implements StateDeclaration {
+export class StateObject implements ng.StateDeclaration {
   /**
    * @param {import('./interface.ts').StateDeclaration} config
    */
@@ -24,10 +23,10 @@ export class StateObject implements StateDeclaration {
   includes: any;
   $$state: () => this;
   /**
-   * @type {import('./interface.ts').StateDeclaration}
+   * @type {ng.StateDeclaration|ng.BuiltStateDeclaration}
    */
-  self: import("./interface.ts").StateDeclaration;
-  __stateObjectCache: {
+  self: ng.StateDeclaration | ng.BuiltStateDeclaration;
+  _stateObjectCache: {
     nameGlob: Glob;
   };
   /**
@@ -79,5 +78,4 @@ export namespace StateObject {
   /** Predicate which returns true if the object is an internal [[StateObject]] object */
   function isState(obj: any): boolean;
 }
-export type StateDeclaration = import("./interface.ts").StateDeclaration;
 import { Glob } from "../glob/glob.js";

package/@types/router/state/state-queue-manager.d.ts

@@ -1,21 +1,22 @@
 export class StateQueueManager {
   /**
    * @param {import("./state-registry.js").StateRegistryProvider} stateRegistry
-   * @param {*} urlServiceRules
-   * @param {*} states
+   * @param {import("../url/url-rules.js").UrlRules} urlServiceRules
+   * @param {import("./interface.ts").StateStore} states
    * @param {*} builder
    * @param {*} listeners
    */
   constructor(
     stateRegistry: import("./state-registry.js").StateRegistryProvider,
-    urlServiceRules: any,
-    states: any,
+    urlServiceRules: import("../url/url-rules.js").UrlRules,
+    states: import("./interface.ts").StateStore,
     builder: any,
     listeners: any,
   );
   stateRegistry: import("./state-registry.js").StateRegistryProvider;
-  urlServiceRules: any;
-  states: any;
+  /** @type {import("../url/url-rules.js").UrlRules} */
+  urlServiceRules: import("../url/url-rules.js").UrlRules;
+  states: import("./interface.ts").StateStore;
   builder: any;
   listeners: any;
   /**
@@ -23,7 +24,12 @@ export class StateQueueManager {
    */
   queue: Array<StateObject>;
   register(stateDecl: any): StateObject;
-  flush(): any;
-  attachRoute(state: any): void;
+  flush(): import("./interface.ts").StateStore;
+  /**
+   *
+   * @param {ng.StateDeclaration} state
+   * @returns {() => void} a function that deregisters the rule
+   */
+  attachRoute(state: ng.StateDeclaration): () => void;
 }
 import { StateObject } from "./state-object.js";

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

@@ -8,20 +8,21 @@
 export class StateRegistryProvider {
   static $inject: string[];
   /**
-   * @param urlService
-   * @param stateService
-   * @param {import('../router.js').Router} globals
-   * @param viewService
+   * @param {ng.UrlService} urlService
+   * @param {ng.StateService} stateService
+   * @param {ng.RouterService} globals
+   * @param {ng.ViewService} viewService
    */
   constructor(
-    urlService: any,
-    stateService: any,
-    globals: import("../router.js").Router,
-    viewService: any,
+    urlService: ng.UrlService,
+    stateService: ng.StateService,
+    globals: ng.RouterService,
+    viewService: ng.ViewService,
   );
-  states: {};
-  urlService: any;
-  urlServiceRules: any;
+  /** @type {import("./interface.ts").StateStore} */
+  states: import("./interface.ts").StateStore;
+  urlService: import("../url/url-service.js").UrlService;
+  urlServiceRules: import("../url/url-rules.js").UrlRules;
   $injector: any;
   listeners: any[];
   matcher: StateMatcher;
@@ -110,7 +111,20 @@ export class StateRegistryProvider {
    * @returns {import('./state-object').StateObject[]} a list of removed states
    */
   deregister(stateOrName: any): any[];
-  get(stateOrName: any, base: any, ...args: any[]): any;
+  /**
+   * @return {ng.BuiltStateDeclaration[]}
+   */
+  getAll(): ng.BuiltStateDeclaration[];
+  get(
+    stateOrName: any,
+    base: any,
+    ...args: any[]
+  ):
+    | import("./interface.ts").StateDeclaration
+    | (
+        | import("./interface.ts").StateDeclaration
+        | import("./interface.ts").BuiltStateDeclaration
+      )[];
   /**
    * Registers a [[BuilderFunction]] for a specific [[StateObject]] property (e.g., `parent`, `url`, or `path`).
    * More than one BuilderFunction can be registered for a given property.

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

@@ -7,14 +7,14 @@ export class StateProvider {
   static $inject: string[];
   /**
    *
-   * @param {import('../router.js').Router} globals
-   * @param {*} transitionService
-   * @param {import('../../core/di/internal-injector.js').InjectorService} $injector
+   * @param {ng.RouterProvider} globals
+   * @param {ng.TransitionProvider} transitionService
+   * @param {ng.ExceptionHandlerProvider} exceptionHandlerProvider
    */
   constructor(
-    globals: import("../router.js").Router,
-    transitionService: any,
-    $injector: import("../../core/di/internal-injector.js").InjectorService,
+    globals: ng.RouterProvider,
+    transitionService: ng.TransitionProvider,
+    exceptionHandlerProvider: ng.ExceptionHandlerProvider,
   );
   /**
    * The latest successful state parameters
@@ -34,14 +34,26 @@ export class StateProvider {
    * @deprecated This is a passthrough through to [[Router.$current]]
    */
   get $current(): import("./state-object.js").StateObject;
+  /**
+   * @type {ng.RouterProvider}
+   */
+  globals: ng.RouterProvider;
+  /**
+   * @type {ng.TransitionProvider}
+   */
+  transitionService: ng.TransitionProvider;
   stateRegistry: any;
-  urlService: any;
-  globals: import("../router.js").Router;
-  transitionService: any;
-  $injector: import("../../core/di/internal-injector.js").InjectorService;
+  /** @type {ng.UrlService} */
+  urlService: ng.UrlService;
+  /** @type {ng.InjectorService} */
+  $injector: ng.InjectorService;
   invalidCallbacks: any[];
-  _defaultErrorHandler: ($error$: any) => never;
-  $get: () => this;
+  /** @type {ng.ExceptionHandlerService} */
+  _defaultErrorHandler: ng.ExceptionHandlerService;
+  $get: (
+    | string
+    | (($injector: ng.InjectorService, $url: any) => StateProvider)
+  )[];
   /**
    * Decorates states when they are registered
    *

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

@@ -19,9 +19,9 @@ export class TemplateFactoryProvider {
       ) => this)
   )[];
   $templateRequest: any;
-  $http: import("../interface.ts").HttpService;
+  $http: import("../services/http/interface.ts").HttpService;
   $templateCache: ng.TemplateCacheService;
-  $injector: import("../interface.ts").InjectorService;
+  $injector: import("../core/di/internal-injector.js").InjectorService;
   /**
    * Forces the provider to use $http service directly
    * @param {boolean} value

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

@@ -16,12 +16,22 @@ export function matchState(
   criterion: any,
   transition: any,
 ): boolean;
-/** Return a registration function of the requested type. */
+/**
+ * Return a registration function of the requested type.
+ * @param {ng.TransitionProvider| import("./transition.js").Transition} hookSource
+ * @param {ng.TransitionProvider} transitionService
+ * @param {import("./transition-event-type.js").TransitionEventType} eventType
+ * @returns {( matchObject: any, callback: Function, options?: Record<string, any> ) => () => void }
+ */
 export function makeEvent(
-  registry: any,
-  transitionService: any,
-  eventType: any,
-): (matchObject: any, callback: any, options?: {}) => any;
+  hookSource: ng.TransitionProvider | import("./transition.js").Transition,
+  transitionService: ng.TransitionProvider,
+  eventType: import("./transition-event-type.js").TransitionEventType,
+): (
+  matchObject: any,
+  callback: Function,
+  options?: Record<string, any>,
+) => () => void;
 /**
  * The registration data for a registered transition hook
  */

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

@@ -168,11 +168,11 @@ export type IHookRegistration = (
  *
  * #### See:
  *
- * - [[IHookRegistry.onBefore]]
- * - [[IHookRegistry.onStart]]
- * - [[IHookRegistry.onFinish]]
- * - [[IHookRegistry.onSuccess]]
- * - [[IHookRegistry.onError]]
+ * - [[HookRegistry.onBefore]]
+ * - [[HookRegistry.onStart]]
+ * - [[HookRegistry.onFinish]]
+ * - [[HookRegistry.onSuccess]]
+ * - [[HookRegistry.onError]]
  *
  * @param transition the current [[Transition]]
  * @param injector (for ng1 or ng2 only) the injector service
@@ -196,9 +196,9 @@ export interface TransitionHookFn {
  *
  * #### See also:
  *
- * - [[IHookRegistry.onExit]]
- * - [[IHookRegistry.onRetain]]
- * - [[IHookRegistry.onEnter]]
+ * - [[HookRegistry.onExit]]
+ * - [[HookRegistry.onRetain]]
+ * - [[HookRegistry.onEnter]]
  *
  * #### Example:
  * ```js
@@ -287,7 +287,7 @@ export interface HookRegOptions {
  * [[TransitionService]] and also the [[Transition]] object itself implement this interface.
  * Note: the Transition object only allows hooks to be registered before the Transition is started.
  */
-export interface IHookRegistry {
+export interface HookRegistry {
   /**
    * Registers a [[TransitionHookFn]], called *before a transition starts*.
    *

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

@@ -53,11 +53,20 @@ export class TransitionHook {
    * Run all TransitionHooks, ignoring their return value.
    */
   static runAllHooks(hooks: any): void;
+  /**
+   *
+   * @param {*} transition
+   * @param {*} stateContext
+   * @param {*} registeredHook
+   * @param {*} options
+   * @param {ng.ExceptionHandlerService} exceptionHandler
+   */
   constructor(
     transition: any,
     stateContext: any,
     registeredHook: any,
     options: any,
+    exceptionHandler: ng.ExceptionHandlerService,
   );
   transition: any;
   stateContext: any;
@@ -65,6 +74,8 @@ export class TransitionHook {
   options: any;
   isSuperseded: () => boolean;
   type: any;
+  /** @type {ng.ExceptionHandlerService} */
+  _exceptionHandler: ng.ExceptionHandlerService;
   logError(err: any): void;
   invokeHook(): any;
   /**

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

@@ -23,10 +23,15 @@ export namespace defaultTransOpts {
 export class TransitionProvider {
   static $inject: string[];
   /**
-   * @param {import('../router.js').Router} globals
-   * @param viewService
+   * @param {ng.RouterService} globals
+   * @param {ng.ViewService} viewService
+   * @param {ng.ExceptionHandlerProvider} $exceptionHandler
    */
-  constructor(globals: import("../router.js").Router, viewService: any);
+  constructor(
+    globals: ng.RouterService,
+    viewService: ng.ViewService,
+    $exceptionHandler: ng.ExceptionHandlerProvider,
+  );
   _transitionCount: number;
   /** The transition hook types, such as `onEnter`, `onStart`, etc */
   _eventTypes: any[];
@@ -34,9 +39,11 @@ export class TransitionProvider {
   _registeredHooks: {};
   /** The  paths on a criteria object */
   _criteriaPaths: {};
-  globals: import("../router.js").Router;
-  $view: any;
+  globals: import("../router.js").RouterProvider;
+  $view: import("../view/view.js").ViewService;
   _deregisterHookFns: {};
+  /** @type {ng.ExceptionHandlerService} */
+  _$exceptionHandler: ng.ExceptionHandlerService;
   $get: (
     | string
     | ((

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

@@ -5,9 +5,9 @@
  *
  * This object contains all contextual information about the to/from states, parameters, resolves.
  * It has information about all states being entered and exited as a result of the transition.
- * @implements {IHookRegistry}
+ * @implements {HookRegistry}
  */
-export class Transition implements IHookRegistry {
+export class Transition implements HookRegistry {
   /**
    * Creates a new Transition object.
    *
@@ -16,21 +16,23 @@ export class Transition implements IHookRegistry {
    * @param {Array<import('../path/path-node.js').PathNode>} fromPath The path of [[PathNode]]s from which the transition is leaving.  The last node in the `fromPath`
    *        encapsulates the "from state".
    * @param {import('../state/target-state.js').TargetState} targetState The target state and parameters being transitioned to (also, the transition options)
-   * @param {import('../transition/transition-service.js').TransitionProvider} transitionService The [[TransitionService]] instance
-   * @param {import('../router.js').Router} globals
+   * @param {ng.TransitionProvider} transitionService The [[TransitionService]] instance
+   * @param {ng.RouterService} globals
    */
   constructor(
     fromPath: Array<import("../path/path-node.js").PathNode>,
     targetState: import("../state/target-state.js").TargetState,
-    transitionService: import("../transition/transition-service.js").TransitionProvider,
-    globals: import("../router.js").Router,
+    transitionService: ng.TransitionProvider,
+    globals: ng.RouterService,
   );
   /**
-   * @type {import('../router.js').Router}
+   * @type {import('../router.js').RouterProvider}
    */
-  globals: import("../router.js").Router;
-  transitionService: import("../transition/transition-service.js").TransitionProvider;
-  _deferred: any;
+  _globals: import("../router.js").RouterProvider;
+  /** @type {ng.TransitionProvider} */
+  _transitionProvider: ng.TransitionProvider;
+  /** @type {PromiseWithResolvers<any>} */
+  _deferred: PromiseWithResolvers<any>;
   /**
    * This promise is resolved or rejected based on the outcome of the Transition.
    *
@@ -77,7 +79,9 @@ export class Transition implements IHookRegistry {
    *
    * @returns The state declaration object for the Transition's ("from state").
    */
-  from(): import("../state/interface.ts").StateDeclaration;
+  from():
+    | import("../state/interface.ts").StateDeclaration
+    | import("../state/interface.ts").BuiltStateDeclaration;
   /**
    * Returns the "to state"
    *
@@ -85,7 +89,9 @@ export class Transition implements IHookRegistry {
    *
    * @returns The state declaration object for the Transition's target state ("to state").
    */
-  to(): import("../state/interface.ts").StateDeclaration;
+  to():
+    | import("../state/interface.ts").StateDeclaration
+    | import("../state/interface.ts").BuiltStateDeclaration;
   /**
    * Gets the Target State
    *
@@ -280,7 +286,7 @@ export class Transition implements IHookRegistry {
    * @returns true if the Transition is ignored.
    */
   ignored(): boolean;
-  _ignoredReason(): "SameAsCurrent" | "SameAsPending";
+  _ignoredReason(): "SameAsPending" | "SameAsCurrent";
   /**
    * Runs the transition
    *
@@ -326,5 +332,5 @@ export class Transition implements IHookRegistry {
 export namespace Transition {
   export { Transition as diToken };
 }
-export type IHookRegistry = import("./interface.ts").IHookRegistry;
+export type HookRegistry = import("./interface.ts").HookRegistry;
 import { HookBuilder } from "./hook-builder.js";