@angular-wave/angular.ts 0.17.0 → 0.19.0

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

@@ -1,14 +1,18 @@
-export namespace defaultTransOpts {
-  let location: boolean;
-  let relative: any;
-  let inherit: boolean;
-  let notify: boolean;
-  let reload: boolean;
-  let supercede: boolean;
-  let custom: {};
-  function current(): any;
-  let source: string;
-}
+/** @typedef {import("./interface.ts").DeregisterFn} DeregisterFn */
+/** @typedef {import("./interface.ts").HookFn} HookFn */
+/** @typedef {import("./interface.ts").HookMatchCriteria} HookMatchCriteria */
+/** @typedef {import("./interface.ts").HookRegOptions} HookRegOptions */
+/** @typedef {import("./interface.ts").PathTypes} PathTypes */
+/** @typedef {import("./interface.ts").RegisteredHooks} RegisteredHooks */
+/**
+ * The default [[Transition]] options.
+ *
+ * Include this object when applying custom defaults:
+ * let reloadOpts = { reload: true, notify: true }
+ * let options = defaults(theirOpts, customDefaults, defaultOptions);
+ * @type {import("./interface.ts").TransitionOptions}
+ */
+export const defaultTransOpts: import("./interface.ts").TransitionOptions;
 /**
  * This class provides services related to Transitions.
  *
@@ -33,25 +37,31 @@ export class TransitionProvider {
     $exceptionHandler: ng.ExceptionHandlerProvider,
   );
   _transitionCount: number;
-  /** The transition hook types, such as `onEnter`, `onStart`, etc */
-  _eventTypes: any[];
+  /**
+   * The transition hook types, such as `onEnter`, `onStart`, etc
+   * @type {TransitionEventType[]}
+   */
+  _eventTypes: TransitionEventType[];
   /** @internal The registered transition hooks */
-  _registeredHooks: {};
+  /** @type {RegisteredHooks} */
+  _registeredHooks: RegisteredHooks;
   /** The  paths on a criteria object */
-  _criteriaPaths: {};
+  /** @type {PathTypes} */
+  _criteriaPaths: PathTypes;
   globals: import("../router.js").RouterProvider;
   $view: import("../view/view.js").ViewService;
-  _deregisterHookFns: {};
+  /** @type {Record<string, DeregisterFn | undefined>} */
+  _deregisterHookFns: Record<string, DeregisterFn | undefined>;
   /** @type {ng.ExceptionHandlerService} */
   _exceptionHandler: ng.ExceptionHandlerService;
   $get: (
     | string
     | ((
-        stateService: any,
-        urlService: any,
-        stateRegistry: any,
-        viewService: any,
-      ) => this)
+        stateService: ng.StateService,
+        urlService: ng.UrlService,
+        stateRegistry: ng.StateRegistryService,
+        viewService: ng.ViewService,
+      ) => TransitionProvider)
   )[];
   /**
    * Registers a [[TransitionHookFn]], called *while a transition is being constructed*.
@@ -87,16 +97,31 @@ export class TransitionProvider {
    * @param targetState the target state (destination)
    * @returns a Transition
    */
-  create(fromPath: any, targetState: any): Transition;
+  /**
+   * @param {import("../path/path-node.js").PathNode[]} fromPath
+   * @param {import("../state/target-state.js").TargetState} targetState
+   */
+  create(
+    fromPath: import("../path/path-node.js").PathNode[],
+    targetState: import("../state/target-state.js").TargetState,
+  ): Transition;
   _defineCoreEvents(): void;
   _defineCorePaths(): void;
+  /**
+   * @param {string} name
+   * @param {number} hookPhase
+   * @param {number} hookOrder
+   * @param {any} criteriaMatchPath
+   */
   _defineEvent(
-    name: any,
-    hookPhase: any,
-    hookOrder: any,
+    name: string,
+    hookPhase: number,
+    hookOrder: number,
     criteriaMatchPath: any,
     reverseSort?: boolean,
-    getResultHandler?: (hook: any) => (result: any) => any,
+    getResultHandler?: (
+      hook: TransitionHook,
+    ) => (result: import("./transition-hook.js").HookResult) => Promise<any>,
     getErrorHandler?: () => (error: any) => Promise<never>,
     synchronous?: boolean,
   ): void;
@@ -115,13 +140,144 @@ export class TransitionProvider {
    * Another example: the `to` path in [[HookMatchCriteria]] is a TRANSITION scoped path.
    * It was defined by calling `defineTreeChangesCriterion('to', TransitionHookScope.TRANSITION)`
    * Only the tail of the `to` path is checked against the criteria and returned as part of the match.
-   *
    * @internal
+   * @param {string} name
+   * @param {number} hookScope
+   */
+  _definePathType(name: string, hookScope: number): void;
+  _getPathTypes(): import("./interface.ts").PathTypes;
+  /**
+   * @param {string} hookName
+   * @returns {import("./hook-registry.js").RegisteredHook[]}
+   */
+  getHooks(hookName: string): import("./hook-registry.js").RegisteredHook[];
+  /**
+   * Registers a hook by event name.
+   * @param {string} eventName
+   * @param {HookMatchCriteria} matchCriteria
+   * @param {HookFn} callback
+   * @param {HookRegOptions} [options]
+   * @returns {DeregisterFn}
+   */
+  on(
+    eventName: string,
+    matchCriteria: HookMatchCriteria,
+    callback: HookFn,
+    options?: HookRegOptions,
+  ): DeregisterFn;
+  /**
+   * @param {HookMatchCriteria} matchCriteria
+   * @param {HookFn} callback
+   * @param {HookRegOptions} [options]
+   * @returns {DeregisterFn}
+   */
+  onCreate(
+    matchCriteria: HookMatchCriteria,
+    callback: HookFn,
+    options?: HookRegOptions,
+  ): DeregisterFn;
+  /**
+   * @param {HookMatchCriteria} matchCriteria
+   * @param {HookFn} callback
+   * @param {HookRegOptions} [options]
+   * @returns {DeregisterFn}
+   */
+  onBefore(
+    matchCriteria: HookMatchCriteria,
+    callback: HookFn,
+    options?: HookRegOptions,
+  ): DeregisterFn;
+  /**
+   * @param {HookMatchCriteria} matchCriteria
+   * @param {HookFn} callback
+   * @param {HookRegOptions} [options]
+   * @returns {DeregisterFn}
+   */
+  onStart(
+    matchCriteria: HookMatchCriteria,
+    callback: HookFn,
+    options?: HookRegOptions,
+  ): DeregisterFn;
+  /**
+   * @param {HookMatchCriteria} matchCriteria
+   * @param {HookFn} callback
+   * @param {HookRegOptions} [options]
+   * @returns {DeregisterFn}
+   */
+  onEnter(
+    matchCriteria: HookMatchCriteria,
+    callback: HookFn,
+    options?: HookRegOptions,
+  ): DeregisterFn;
+  /**
+   * @param {HookMatchCriteria} matchCriteria
+   * @param {HookFn} callback
+   * @param {HookRegOptions} [options]
+   * @returns {DeregisterFn}
+   */
+  onRetain(
+    matchCriteria: HookMatchCriteria,
+    callback: HookFn,
+    options?: HookRegOptions,
+  ): DeregisterFn;
+  /**
+   * @param {HookMatchCriteria} matchCriteria
+   * @param {HookFn} callback
+   * @param {HookRegOptions} [options]
+   * @returns {DeregisterFn}
+   */
+  onExit(
+    matchCriteria: HookMatchCriteria,
+    callback: HookFn,
+    options?: HookRegOptions,
+  ): DeregisterFn;
+  /**
+   * @param {HookMatchCriteria} matchCriteria
+   * @param {HookFn} callback
+   * @param {HookRegOptions} [options]
+   * @returns {DeregisterFn}
+   */
+  onFinish(
+    matchCriteria: HookMatchCriteria,
+    callback: HookFn,
+    options?: HookRegOptions,
+  ): DeregisterFn;
+  /**
+   * @param {HookMatchCriteria} matchCriteria
+   * @param {HookFn} callback
+   * @param {HookRegOptions} [options]
+   * @returns {DeregisterFn}
+   */
+  onSuccess(
+    matchCriteria: HookMatchCriteria,
+    callback: HookFn,
+    options?: HookRegOptions,
+  ): DeregisterFn;
+  /**
+   * @param {HookMatchCriteria} matchCriteria
+   * @param {HookFn} callback
+   * @param {HookRegOptions} [options]
+   * @returns {DeregisterFn}
+   */
+  onError(
+    matchCriteria: HookMatchCriteria,
+    callback: HookFn,
+    options?: HookRegOptions,
+  ): DeregisterFn;
+  /**
+   * @param {string} eventName
+   * @returns {TransitionEventType}
    */
-  _definePathType(name: any, hookScope: any): void;
-  _getPathTypes(): {};
-  getHooks(hookName: any): any;
+  _getEventType(eventName: string): TransitionEventType;
   _registerCoreTransitionHooks(): void;
 }
+export type DeregisterFn = import("./interface.ts").DeregisterFn;
+export type HookFn = import("./interface.ts").HookFn;
+export type HookMatchCriteria = import("./interface.ts").HookMatchCriteria;
+export type HookRegOptions = import("./interface.ts").HookRegOptions;
+export type PathTypes = import("./interface.ts").PathTypes;
+export type RegisteredHooks = import("./interface.ts").RegisteredHooks;
+import { TransitionEventType } from "./transition-event-type.js";
 import { Transition } from "./transition.js";
+import { TransitionHook } from "./transition-hook.js";
 import { TransitionHookPhase } from "./transition-hook.js";

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

@@ -5,7 +5,6 @@
  *
  * 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.
- * @extends {HookRegistry}
  */
 export class Transition {
   /**
@@ -13,24 +12,23 @@ export class Transition {
    *
    * If the target state is not valid, an error is thrown.
    *
-   * @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`
+   * @param {Array<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 {ng.TransitionProvider} transitionService The [[TransitionService]] instance
+   * @param {TargetState} targetState The target state and parameters being transitioned to (also, the transition options)
+   * @param {import("./transition-service.js").TransitionProvider} transitionService
    * @param {ng.RouterService} globals
    */
   constructor(
-    fromPath: Array<import("../path/path-node.js").PathNode>,
-    targetState: import("../state/target-state.js").TargetState,
-    transitionService: ng.TransitionProvider,
+    fromPath: Array<PathNode>,
+    targetState: TargetState,
+    transitionService: import("./transition-service.js").TransitionProvider,
     globals: ng.RouterService,
   );
   /**
    * @type {import('../router.js').RouterProvider}
    */
   _globals: import("../router.js").RouterProvider;
-  /** @type {ng.TransitionProvider} */
-  _transitionProvider: ng.TransitionProvider;
+  _transitionService: import("./transition-service.js").TransitionProvider;
   /** @type {PromiseWithResolvers<any>} */
   _deferred: PromiseWithResolvers<any>;
   /**
@@ -40,71 +38,169 @@ export class Transition {
    * When the transition is unsuccessful, the promise is rejected with the [[Rejection]] or javascript error
    */
   promise: any;
-  /** @internal Holds the hook registration functions such as those passed to Transition.onStart() */
-  _registeredHooks: {};
+  /** @type {RegisteredHooks} Holds the hook registration functions such as those passed to Transition.onStart() */
+  _registeredHooks: RegisteredHooks;
+  /** @type {HookBuilder} */
   _hookBuilder: HookBuilder;
   /** Checks if this transition is currently active/running. */
+  /** @type {() => boolean} */
   isActive: () => boolean;
   _targetState: import("../state/target-state.js").TargetState;
   _options: any;
   $id: number;
-  _treeChanges: import("./interface.ts").TreeChanges;
-  onStart: any;
-  onBefore: any;
-  onSuccess: any;
-  onEnter: any;
-  onRetain: any;
-  onExit: any;
-  onFinish: any;
-  onError: any;
-  /**
-   * Creates the transition-level hook registration functions
-   * (which can then be used to register hooks)
-   */
-  createTransitionHookRegFns(): void;
-  getHooks(hookName: any): any;
+  /** @type {TreeChanges} */
+  _treeChanges: TreeChanges;
+  /**
+   * @param {string} hookName
+   * @returns {RegisteredHook[]}
+   */
+  getHooks(hookName: string): RegisteredHook[];
+  /**
+   * Registers a hook by event name.
+   * @param {string} eventName
+   * @param {HookMatchCriteria} matchCriteria
+   * @param {HookFn} callback
+   * @param {HookRegOptions} [options]
+   * @returns {DeregisterFn}
+   */
+  on(
+    eventName: string,
+    matchCriteria: HookMatchCriteria,
+    callback: HookFn,
+    options?: HookRegOptions,
+  ): DeregisterFn;
+  /**
+   * @param {HookMatchCriteria} matchCriteria
+   * @param {HookFn} callback
+   * @param {HookRegOptions} [options]
+   * @returns {DeregisterFn}
+   */
+  onBefore(
+    matchCriteria: HookMatchCriteria,
+    callback: HookFn,
+    options?: HookRegOptions,
+  ): DeregisterFn;
+  /**
+   * @param {HookMatchCriteria} matchCriteria
+   * @param {HookFn} callback
+   * @param {HookRegOptions} [options]
+   * @returns {DeregisterFn}
+   */
+  onStart(
+    matchCriteria: HookMatchCriteria,
+    callback: HookFn,
+    options?: HookRegOptions,
+  ): DeregisterFn;
+  /**
+   * @param {HookMatchCriteria} matchCriteria
+   * @param {HookFn} callback
+   * @param {HookRegOptions} [options]
+   * @returns {DeregisterFn}
+   */
+  onEnter(
+    matchCriteria: HookMatchCriteria,
+    callback: HookFn,
+    options?: HookRegOptions,
+  ): DeregisterFn;
+  /**
+   * @param {HookMatchCriteria} matchCriteria
+   * @param {HookFn} callback
+   * @param {HookRegOptions} [options]
+   * @returns {DeregisterFn}
+   */
+  onRetain(
+    matchCriteria: HookMatchCriteria,
+    callback: HookFn,
+    options?: HookRegOptions,
+  ): DeregisterFn;
+  /**
+   * @param {HookMatchCriteria} matchCriteria
+   * @param {HookFn} callback
+   * @param {HookRegOptions} [options]
+   * @returns {DeregisterFn}
+   */
+  onExit(
+    matchCriteria: HookMatchCriteria,
+    callback: HookFn,
+    options?: HookRegOptions,
+  ): DeregisterFn;
+  /**
+   * @param {HookMatchCriteria} matchCriteria
+   * @param {HookFn} callback
+   * @param {HookRegOptions} [options]
+   * @returns {DeregisterFn}
+   */
+  onFinish(
+    matchCriteria: HookMatchCriteria,
+    callback: HookFn,
+    options?: HookRegOptions,
+  ): DeregisterFn;
+  /**
+   * @param {HookMatchCriteria} matchCriteria
+   * @param {HookFn} callback
+   * @param {HookRegOptions} [options]
+   * @returns {DeregisterFn}
+   */
+  onSuccess(
+    matchCriteria: HookMatchCriteria,
+    callback: HookFn,
+    options?: HookRegOptions,
+  ): DeregisterFn;
+  /**
+   * @param {HookMatchCriteria} matchCriteria
+   * @param {HookFn} callback
+   * @param {HookRegOptions} [options]
+   * @returns {DeregisterFn}
+   */
+  onError(
+    matchCriteria: HookMatchCriteria,
+    callback: HookFn,
+    options?: HookRegOptions,
+  ): DeregisterFn;
+  /**
+   * @param {string} eventName
+   * @returns {import("./transition-event-type.js").TransitionEventType}
+   */
+  _getEventType(
+    eventName: string,
+  ): import("./transition-event-type.js").TransitionEventType;
   applyViewConfigs(): void;
   /**
-   * @returns {import('../state/state-object.js').StateObject} the internal from [State] object
+   * @returns {StateObject} the internal from [State] object
    */
-  $from(): import("../state/state-object.js").StateObject;
+  $from(): StateObject;
   /**
-   * @returns {import('../state/state-object.js').StateObject} the internal to [State] object
+   * @returns {StateObject} the internal to [State] object
    */
-  $to(): import("../state/state-object.js").StateObject;
+  $to(): StateObject;
   /**
    * Returns the "from state"
    *
    * Returns the state that the transition is coming *from*.
    *
-   * @returns The state declaration object for the Transition's ("from state").
+   * @returns {StateDeclaration} The state declaration object for the Transition's ("from state").
    */
-  from():
-    | import("../state/interface.ts").StateDeclaration
-    | import("../state/interface.ts").BuiltStateDeclaration;
+  from(): StateDeclaration;
   /**
    * Returns the "to state"
    *
    * Returns the state that the transition is going *to*.
    *
-   * @returns The state declaration object for the Transition's target state ("to state").
+   * @returns {StateDeclaration} The state declaration object for the Transition's target state ("to state").
    */
-  to():
-    | import("../state/interface.ts").StateDeclaration
-    | import("../state/interface.ts").BuiltStateDeclaration;
+  to(): StateDeclaration;
   /**
    * Gets the Target State
    *
    * A transition's [[TargetState]] encapsulates the [[to]] state, the [[params]], and the [[options]] as a single object.
    *
-   * @returns the [[TargetState]] of this Transition
+   * @returns {TargetState} the [[TargetState]] of this Transition
    */
-  targetState(): import("../state/target-state.js").TargetState;
+  targetState(): TargetState;
   /**
-   * Determines whether two transitions are equivalent.
-   * @deprecated
+   * @param {string} pathname
+   * @returns {any}
    */
-  is(compare: any): any;
   params(pathname?: string): any;
   /**
    * Gets all available resolve tokens (keys)
@@ -165,10 +261,15 @@ export class Transition {
    * });
    * ```
    *
-   * @param resolvable a [[ResolvableLiteral]] object (or a [[Resolvable]])
-   * @param state the state in the "to path" which should receive the new resolve (otherwise, the root state)
+   * @param {Resolvable | import("../resolve/interface.ts").ResolvableLiteral} resolvable a [[ResolvableLiteral]] object (or a [[Resolvable]])
+   * @param {import("../state/interface.ts").StateOrName} state the state in the "to path" which should receive the new resolve (otherwise, the root state)
    */
-  addResolvable(resolvable: any, state: any): void;
+  addResolvable(
+    resolvable:
+      | Resolvable
+      | import("../resolve/interface.ts").ResolvableLiteral,
+    state: import("../state/interface.ts").StateOrName,
+  ): void;
   /**
    * Gets the transition from which this transition was redirected.
    *
@@ -184,9 +285,9 @@ export class Transition {
    * });
    * ```
    *
-   * @returns The previous Transition, or null if this Transition is not the result of a redirection
+   * @returns {Transition} The previous Transition, or null if this Transition is not the result of a redirection
    */
-  redirectedFrom(): any;
+  redirectedFrom(): Transition;
   /**
    * Gets the original transition in a redirect chain
    *
@@ -211,34 +312,34 @@ export class Transition {
    * });
    * ```
    *
-   * @returns The original Transition that started a redirect chain
+   * @returns {Transition} The original Transition that started a redirect chain
    */
-  originalTransition(): any;
+  originalTransition(): Transition;
   /**
    * Get the transition options
    *
-   * @returns the options for this Transition.
+   * @returns {import("./interface.ts").TransitionOptions} the options for this Transition.
    */
-  options(): any;
+  options(): import("./interface.ts").TransitionOptions;
   /**
    * Gets the states being entered.
    *
    * @returns an array of states that will be entered during this transition.
    */
-  entering(): any;
+  entering(): import("../state/interface.ts").StateDeclaration[];
   /**
    * Gets the states being exited.
    *
-   * @returns an array of states that will be exited during this transition.
+   * @returns {import("../state/interface.ts").StateDeclaration[]} an array of states that will be exited during this transition.
    */
-  exiting(): any;
+  exiting(): import("../state/interface.ts").StateDeclaration[];
   /**
    * Gets the states being retained.
    *
-   * @returns an array of states that are already entered from a previous Transition, that will not be
+   * @returns {import("../state/interface.ts").StateDeclaration[]} an array of states that are already entered from a previous Transition, that will not be
    *    exited during this Transition
    */
-  retained(): any;
+  retained(): import("../state/interface.ts").StateDeclaration[];
   /**
    * Get the [[ViewConfig]]s associated with this Transition
    *
@@ -247,13 +348,29 @@ export class Transition {
    *
    * @param pathname the name of the path to fetch views for:
    *   (`'to'`, `'from'`, `'entering'`, `'exiting'`, `'retained'`)
-   * @param state If provided, only returns the `ViewConfig`s for a single state in the path
+   * @param {ng.StateObject} [state] If provided, only returns the `ViewConfig`s for a single state in the path
    *
-   * @returns a list of ViewConfig objects for the given path.
+   * @returns {import("../state/views.js").ViewConfig[]} a list of ViewConfig objects for the given path.
+   */
+  views(
+    pathname?: string,
+    state?: ng.StateObject,
+  ): import("../state/views.js").ViewConfig[];
+  /**
+   * Return the transition's tree changes
+   *
+   * A transition goes from one state/parameters to another state/parameters.
+   * During a transition, states are entered and/or exited.
+   *
+   * This function returns various branches (paths) which represent the changes to the
+   * active state tree that are caused by the transition.
+   *
+   * @param {string} [pathname] The name of the tree changes path to get:
+   *   (`'to'`, `'from'`, `'entering'`, `'exiting'`, `'retained'`)
+   * @returns {import('../path/path-node.js').PathNode[] | import("./interface.ts").TreeChanges}
    */
-  views(pathname: string, state: any): any;
   treeChanges(
-    pathname: any,
+    pathname?: string,
   ):
     | import("../path/path-node.js").PathNode[]
     | import("./interface.ts").TreeChanges;
@@ -263,11 +380,11 @@ export class Transition {
    * This transition can be returned from a [[TransitionService]] hook to
    * redirect a transition to a new state and/or set of parameters.
    *
-   * @internal
+   * @param {TargetState} targetState the new target state for the redirected transition
    *
-   * @returns Returns a new [[Transition]] instance.
+   * @returns {Transition} Returns a new [[Transition]] instance.
    */
-  redirect(targetState: any): Transition;
+  redirect(targetState: TargetState): Transition;
   /** @internal If a transition doesn't exit/enter any states, returns any [[Param]] whose value changed */
   _changedParams(): any;
   /**
@@ -275,9 +392,9 @@ export class Transition {
    *
    * A transition is dynamic if no states are entered nor exited, but at least one dynamic parameter has changed.
    *
-   * @returns true if the Transition is dynamic
+   * @returns {boolean} true if the Transition is dynamic
    */
-  dynamic(): any;
+  dynamic(): boolean;
   /**
    * Returns true if the transition is ignored.
    *
@@ -294,11 +411,11 @@ export class Transition {
    *
    * @internal
    *
-   * @returns {Promise} a promise for a successful transition.
+   * @returns {Promise<any>} a promise for a successful transition.
    */
   run(): Promise<any>;
   success: boolean;
-  _error: any;
+  _error: Rejection;
   /**
    * Checks if the Transition is valid
    *
@@ -321,7 +438,7 @@ export class Transition {
    *
    * @returns a transition rejection explaining why the transition is invalid, or the reason the transition failed.
    */
-  error(): any;
+  error(): Rejection;
   /**
    * A string representation of the Transition
    *
@@ -332,5 +449,19 @@ export class Transition {
 export namespace Transition {
   export { Transition as diToken };
 }
-export type HookRegistry = import("./interface.ts").HookRegistry;
+export type DeregisterFn = import("./interface.ts").DeregisterFn;
+export type HookFn = import("./interface.ts").HookFn;
+export type HookMatchCriteria = import("./interface.ts").HookMatchCriteria;
+export type HookRegOptions = import("./interface.ts").HookRegOptions;
+export type BuiltStateDeclaration =
+  import("../state/interface.ts").BuiltStateDeclaration;
+export type RegisteredHooks = import("./interface.ts").RegisteredHooks;
+export type RegisteredHook = import("./hook-registry.js").RegisteredHook;
+export type TargetState = import("../state/target-state.js").TargetState;
+export type TreeChanges = import("../transition/interface.ts").TreeChanges;
+export type PathNode = import("../path/path-node.js").PathNode;
+export type StateObject = import("../state/state-object.js").StateObject;
+export type StateDeclaration = import("../state/interface.ts").StateDeclaration;
 import { HookBuilder } from "./hook-builder.js";
+import { Resolvable } from "../resolve/resolvable.js";
+import { Rejection } from "./reject-factory.js";