@angular-wave/angular.ts 0.10.0 → 0.12.0

package/@types/directive/form/form.d.ts

@@ -75,16 +75,16 @@ export class FormController {
   static $inject: string[];
   /**
    * @param {Element} $element
-   * @param {import("../../core/compile/attributes.js").Attributes} $attrs
-   * @param {import("../../core/scope/scope.js").Scope} $scope
-   * @param {*} $animate
+   * @param {ng.Attributes} $attrs
+   * @param {ng.Scope} $scope
+   * @param {ng.AnimateService} $animate
    * @param {*} $interpolate
    */
   constructor(
     $element: Element,
-    $attrs: import("../../core/compile/attributes.js").Attributes,
-    $scope: import("../../core/scope/scope.js").Scope,
-    $animate: any,
+    $attrs: ng.Attributes,
+    $scope: ng.Scope,
+    $animate: ng.AnimateService,
     $interpolate: any,
   );
   $$controls: any[];
@@ -103,7 +103,7 @@ export class FormController {
   /** @type {FormController|Object} */
   $$parentForm: FormController | any;
   $$element: Element;
-  $$animate: any;
+  $$animate: import("../../interface.ts").AnimateService;
   $error: {};
   $$success: {};
   $pending: any;

package/@types/directive/if/if.d.ts

@@ -1,8 +1,8 @@
 /**
- * @param {*}  $animate
+ * @param {ng.AnimateService} $animate
  * @returns {ng.Directive}
  */
-export function ngIfDirective($animate: any): ng.Directive;
+export function ngIfDirective($animate: ng.AnimateService): ng.Directive;
 export namespace ngIfDirective {
   let $inject: string[];
 }

package/@types/directive/include/include.d.ts

@@ -1,15 +1,15 @@
 /**
  *
- * @param {*} $templateRequest
+ * @param {ng.TemplateRequestService} $templateRequest
  * @param {import("../../services/anchor-scroll/anchor-scroll.js").AnchorScrollFunction} $anchorScroll
- * @param {*} $animate
+ * @param {ng.AnimateService} $animate
  * @param {import('../../services/exception/interface.ts').ErrorHandler} $exceptionHandler
  * @returns {import('../../interface.ts').Directive}
  */
 export function ngIncludeDirective(
-  $templateRequest: any,
+  $templateRequest: ng.TemplateRequestService,
   $anchorScroll: import("../../services/anchor-scroll/anchor-scroll.js").AnchorScrollFunction,
-  $animate: any,
+  $animate: ng.AnimateService,
   $exceptionHandler: import("../../services/exception/interface.ts").ErrorHandler,
 ): import("../../interface.ts").Directive;
 export namespace ngIncludeDirective {

package/@types/directive/inject/inject.d.ts

@@ -1,12 +1,12 @@
 /**
  * @param {ng.LogService} $log
  * @param {ng.InjectorService} $injector
- * @returns {import('interface.ts').Directive}
+ * @returns {ng.Directive}
  */
 export function ngInjectDirective(
   $log: ng.LogService,
   $injector: ng.InjectorService,
-): any;
+): ng.Directive;
 export namespace ngInjectDirective {
   let $inject: string[];
 }

package/@types/directive/input/input.d.ts

@@ -45,25 +45,25 @@ export function rangeInputType(
   ctrl: any,
 ): void;
 /**
- * @param {*} $filter
- * @param {*} $parse
- * @returns {import('../../interface.ts').Directive}
+ * @param {ng.FilterService} $filter
+ * @param {ng.ParseService} $parse
+ * @returns {ng.Directive}
  */
 export function inputDirective(
-  $filter: any,
-  $parse: any,
-): import("../../interface.ts").Directive;
+  $filter: ng.FilterService,
+  $parse: ng.ParseService,
+): ng.Directive;
 export namespace inputDirective {
   let $inject: string[];
 }
 /**
- * @returns {import('../../interface.ts').Directive}
+ * @returns {ng.Directive}
  */
-export function hiddenInputBrowserCacheDirective(): import("../../interface.ts").Directive;
+export function hiddenInputBrowserCacheDirective(): ng.Directive;
 /**
- * @returns {import('../../interface.ts').Directive}
+ * @returns {ng.Directive}
  */
-export function ngValueDirective(): import("../../interface.ts").Directive;
+export function ngValueDirective(): ng.Directive;
 export const ISO_DATE_REGEXP: RegExp;
 export const URL_REGEXP: RegExp;
 export const EMAIL_REGEXP: RegExp;

package/@types/directive/messages/messages.d.ts

@@ -1,8 +1,10 @@
-export function ngMessagesDirective($animate: any): {
-  require: string;
-  restrict: string;
-  controller: ($element: any, $scope: any, $attrs: any) => NgMessageCtrl;
-};
+/**
+ * @param {ng.AnimateService} $animate
+ * @returns {ng.Directive<NgMessageCtrl>}
+ */
+export function ngMessagesDirective(
+  $animate: ng.AnimateService,
+): ng.Directive<NgMessageCtrl>;
 export namespace ngMessagesDirective {
   let $inject: string[];
 }
@@ -18,32 +20,26 @@ export namespace ngMessagesIncludeDirective {
   let $inject_1: string[];
   export { $inject_1 as $inject };
 }
-export const ngMessageDirective: (
-  any: any,
-) => import("../../interface.ts").Directive;
-export const ngMessageExpDirective: (
-  any: any,
-) => import("../../interface.ts").Directive;
-export const ngMessageDefaultDirective: (
-  any: any,
-) => import("../../interface.ts").Directive;
+export const ngMessageDirective: (any: any) => ng.Directive;
+export const ngMessageExpDirective: (any: any) => ng.Directive;
+export const ngMessageDefaultDirective: (any: any) => ng.Directive;
 declare class NgMessageCtrl {
   /**
    * @param {Element} $element
-   * @param {import('../../core/scope/scope.js').Scope} $scope
-   * @param {import('../../core/compile/attributes').Attributes} $attrs
-   * @param {*} $animate
+   * @param {ng.Scope} $scope
+   * @param {ng.Attributes} $attrs
+   * @param {ng.AnimateService} $animate
    */
   constructor(
     $element: Element,
-    $scope: import("../../core/scope/scope.js").Scope,
-    $attrs: any,
-    $animate: any,
+    $scope: ng.Scope,
+    $attrs: ng.Attributes,
+    $animate: ng.AnimateService,
   );
   $element: Element;
-  $scope: import("../../core/scope/scope.js").Scope;
-  $attrs: any;
-  $animate: any;
+  $scope: import("../../interface.ts").Scope;
+  $attrs: ng.Attributes;
+  $animate: import("../../interface.ts").AnimateService;
   latestKey: number;
   nextAttachId: number;
   messages: {};

package/@types/directive/model/model.d.ts

@@ -54,7 +54,7 @@ export class NgModelController {
    * @param {import('../../core/compile/attributes.js').Attributes} $attr
    * @param {Element} $element
    * @param {import("../../core/parse/interface.ts").ParseService} $parse
-   * @param {*} $animate
+   * @param {ng.AnimateService} $animate
    * @param {*} $interpolate
    */
   constructor(
@@ -63,7 +63,7 @@ export class NgModelController {
     $attr: import("../../core/compile/attributes.js").Attributes,
     $element: Element,
     $parse: import("../../core/parse/interface.ts").ParseService,
-    $animate: any,
+    $animate: ng.AnimateService,
     $interpolate: any,
   );
   /** @type {any} The actual value from the control's view  */
@@ -139,7 +139,7 @@ export class NgModelController {
   $$scope: import("../../core/scope/scope.js").Scope;
   $$attr: import("../../core/compile/attributes.js").Attributes;
   $$element: Element;
-  $$animate: any;
+  $$animate: import("../../interface.ts").AnimateService;
   $$parse: import("../../core/parse/interface.ts").ParseService;
   $$exceptionHandler: import("../../services/exception/interface.ts").ErrorHandler;
   $$hasNativeValidators: boolean;

package/@types/directive/scope/scope.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @return {ng.Directive}
+ */
+export function ngScopeDirective(): ng.Directive;

package/@types/directive/show-hide/show-hide.d.ts

@@ -1,9 +1,8 @@
 /**
- * @returns {import('../../interface.ts').Directive}
+ * @param {ng.AnimateService} $animate
+ * @returns {ng.Directive}
  */
-export function ngShowDirective(
-  $animate: any,
-): import("../../interface.ts").Directive;
+export function ngShowDirective($animate: ng.AnimateService): ng.Directive;
 export namespace ngShowDirective {
   let $inject: string[];
 }

package/@types/directive/switch/switch.d.ts

@@ -1,10 +1,8 @@
 /**
- * @param {*} $animate
- * @returns {import('../../interface.ts').Directive}
+ * @param {ng.AnimateService} $animate
+ * @returns {ng.Directive}
  */
-export function ngSwitchDirective(
-  $animate: any,
-): import("../../interface.ts").Directive;
+export function ngSwitchDirective($animate: ng.AnimateService): ng.Directive;
 export namespace ngSwitchDirective {
   let $inject: string[];
 }

package/@types/directive/wasm/wasm.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @return {ng.Directive}
+ */
+export function ngWasmDirective(): ng.Directive;

package/@types/{services → directive}/worker/interface.d.ts

@@ -9,4 +9,5 @@ export interface WorkerConnection {
   post(data: any): void;
   terminate(): void;
   restart(): void;
+  config: WorkerConfig;
 }

package/@types/directive/worker/worker.d.ts

@@ -1,15 +1,25 @@
 /**
- * ngWorker directive factory
  * Usage: <div ng-worker="workerName" data-params="{{ expression }}" data-on-result="callback($result)"></div>
+ *
+ * @param {ng.ParseService} $parse
+ * @param {ng.LogService} $log
+ * @returns {ng.Directive}
  */
 export function ngWorkerDirective(
-  $worker: any,
-  $parse: any,
-  $log: any,
-): {
-  restrict: string;
-  link(scope: any, element: any, attrs: any): void;
-};
+  $parse: ng.ParseService,
+  $log: ng.LogService,
+): ng.Directive;
 export namespace ngWorkerDirective {
   let $inject: string[];
 }
+/**
+ * Creates a managed Web Worker connection.
+ *
+ * @param {string | URL} scriptPath
+ * @param {ng.WorkerConfig} [config]
+ * @returns {ng.WorkerConnection}
+ */
+export function createWorkerConnection(
+  scriptPath: string | URL,
+  config?: ng.WorkerConfig,
+): ng.WorkerConnection;

package/@types/interface.d.ts

@@ -1,3 +1,4 @@
+export * from "./animations/interface.ts";
 export * from "./services/http/interface.ts";
 export * from "./services/log/interface.ts";
 export * from "./services/log/log.js";
@@ -6,6 +7,9 @@ export * from "./services/location/location.js";
 export * from "./services/pubsub/pubsub.js";
 export * from "./services/template-cache/template-cache.js";
 export * from "./index.js";
+export * from "./angular.js";
+export * from "./core/di/internal-injector.js";
+export * from "./core/scope/scope.js";
 import { Attributes } from "./core/compile/attributes.js";
 import { Scope } from "./core/scope/scope.js";
 /**
@@ -60,14 +64,13 @@ export type InjectableClass<TInstance = any> = new (...args: any) => TInstance;
  *
  * Parentheses are required around constructor types when used in unions.
  */
+type FactoryFunction<T> = T extends abstract new (...args: any[]) => any
+  ? (...args: ConstructorParameters<T>) => InstanceType<T>
+  : T;
 export type Injectable<
   T extends ((...args: any[]) => any) | (abstract new (...args: any[]) => any),
 > =
-  | AnnotatedFactory<
-      T extends abstract new (...args: any[]) => any
-        ? (...args: ConstructorParameters<T>) => InstanceType<T>
-        : T
-    >
+  | AnnotatedFactory<FactoryFunction<T>>
   | (T extends abstract new (...args: any[]) => any
       ? InjectableClass<InstanceType<T>>
       : never)
@@ -129,7 +132,7 @@ export interface Provider {
    */
   value(name: string, val: any): Provider;
   /**
-   * Register a constant value (available during config).
+   * Register a constant service, such as a string, a number, an array, an object or a function, with the $injector. Unlike value it can be injected into a module configuration function (see config) and it cannot be overridden by an Angular decorator.
    * @param name - The name of the constant.
    * @param val - The constant value.
    */
@@ -144,7 +147,9 @@ export interface Provider {
 /**
  * A controller constructor function used in AngularTS.
  */
-export type ControllerConstructor = (...args: any[]) => void | Controller;
+export type ControllerConstructor =
+  | (new (...args: any[]) => Controller)
+  | ((...args: any[]) => void | Controller);
 /**
  * Describes the changes in component bindings during `$onChanges`.
  */
@@ -160,17 +165,41 @@ export interface ChangesObject<T = any> {
 export type OnChangesObject = Record<string, ChangesObject>;
 /**
  * AngularTS component lifecycle interface.
+ * Directive controllers have a well-defined lifecycle. Each controller can implement "lifecycle hooks". These are methods that
+ * will be called by Angular at certain points in the life cycle of the directive.
+ * https://docs.angularjs.org/api/ng/service/$compile#life-cycle-hooks
+ * https://docs.angularjs.org/guide/component
  */
 export interface Controller {
+  [s: string]: any;
   /** Optional controller name (used in debugging) */
   name?: string;
-  /** Called when the controller is initialized */
+  /**
+   * Called on each controller after all the controllers on an element have been constructed and had their bindings
+   * initialized (and before the pre & post linking functions for the directives on this element). This is a good
+   * place to put initialization code for your controller.
+   */
   $onInit?: () => void;
-  /** Called when one-way bindings are updated */
+  /**
+   * Called whenever one-way bindings are updated. The onChangesObj is a hash whose keys are the names of the bound
+   * properties that have changed, and the values are an {@link IChangesObject} object  of the form
+   * { currentValue, previousValue, isFirstChange() }. Use this hook to trigger updates within a component such as
+   * cloning the bound value to prevent accidental mutation of the outer value.
+   */
   $onChanges?: (changes: OnChangesObject) => void;
-  /** Called before the controller is destroyed */
+  /**
+   * Called on a controller when its containing scope is destroyed. Use this hook for releasing external resources,
+   * watches and event handlers.
+   */
   $onDestroy?: () => void;
-  /** Called after the component is linked */
+  /**
+   * Called after this controller's element and its children have been linked. Similar to the post-link function this
+   * hook can be used to set up DOM event handlers and do direct DOM manipulation. Note that child elements that contain
+   * templateUrl directives will not have been compiled and linked since they are waiting for their template to load
+   * asynchronously and their own compilation and linking has been suspended until that occurs. This hook can be considered
+   * analogous to the ngAfterViewInit and ngAfterContentInit hooks in Angular 2. Since the compilation process is rather
+   * different in Angular 1 there is no direct mapping and care should be taken when upgrading.
+   */
   $postLink?: () => void;
 }
 /**
@@ -242,22 +271,22 @@ export type DirectiveController =
 /**
  * Represents a controller used within directive link functions.
  */
-export type TController = DirectiveController | NgModelController;
+export type TController<T> = DirectiveController | NgModelController | T;
 /**
  * Defines optional pre/post link functions in directive compile phase.
  */
 export interface DirectivePrePost {
-  pre?: DirectiveLinkFn;
-  post?: DirectiveLinkFn;
+  pre?: DirectiveLinkFn<any>;
+  post?: DirectiveLinkFn<any>;
 }
 /**
  * A link function executed during directive linking.
  */
-export type DirectiveLinkFn = (
+export type DirectiveLinkFn<T> = (
   scope: Scope,
   element: HTMLElement,
   attrs: Attributes & Record<string, any>,
-  controller?: TController,
+  controller?: TController<T>,
   transclude?: (...args: any[]) => any,
 ) => void;
 /**
@@ -267,12 +296,11 @@ export type DirectiveCompileFn = (
   templateElement?: HTMLElement,
   templateAttributes?: Attributes & Record<string, any>,
   transclude?: (...args: any[]) => any,
-) => void | DirectiveLinkFn | DirectivePrePost;
+) => void | DirectiveLinkFn<any> | DirectivePrePost;
 /**
  * Defines the structure of an AngularTS directive.
- * @typedef {Object} Directive
  */
-export interface Directive {
+export interface Directive<TController = any> {
   /** Optional name (usually inferred) */
   name?: string;
   /** Restrict option: 'A' and/or 'E'. Defaults to 'EA' if not defined */
@@ -286,7 +314,7 @@ export interface Directive {
   /** Whether to bind scope to controller */
   bindToController?: boolean | Record<string, string>;
   /** Link function(s) executed during linking */
-  link?: DirectiveLinkFn | DirectivePrePost;
+  link?: DirectiveLinkFn<TController> | DirectivePrePost;
   /** Priority of the directive */
   priority?: number;
   /** Stops further directive processing if true */
@@ -311,7 +339,7 @@ export interface Directive {
 }
 export type DirectiveFactoryFn = (
   ...args: any[]
-) => Directive | DirectiveLinkFn;
+) => Directive | DirectiveLinkFn<any>;
 export type AnnotatedDirectiveFactory = Array<string | DirectiveFactoryFn>;
 export type DirectiveFactory = DirectiveFactoryFn | AnnotatedDirectiveFactory;
 /**

package/@types/namespace.d.ts

@@ -2,7 +2,11 @@ export { angular } from "./index.js";
 import { Angular as TAngular } from "./angular.js";
 import { Attributes as TAttributes } from "./core/compile/attributes.js";
 import { Scope as TScope } from "./core/scope/scope.js";
-import { NgModule as TNgModule } from "./core/di/ng-module.js";
+import {
+  ListenerFn as TListenerFn,
+  Listener as TListener,
+} from "./core/scope/interface.ts";
+import { NgModule as TNgModule } from "./core/di/ng-module/ng-module.js";
 import { InjectorService as TInjectorService } from "./core/di/internal-injector.js";
 import {
   AnchorScrollProvider as TAnchorScrollProvider,
@@ -36,6 +40,7 @@ import {
   DirectiveFactory as TDirectiveFactory,
   Component as TComponent,
   Controller as TController,
+  Injectable as TInjectable,
 } from "./interface.ts";
 import {
   SseService as TSseService,
@@ -55,15 +60,23 @@ import {
 import {
   WorkerConnection as TWorkerConnection,
   WorkerConfig as TWorkerConfig,
-} from "./services/worker/interface.ts";
+} from "./directive/worker/interface.ts";
+import { Provider as TProvideService } from "./interface.ts";
+import { Location as TLocationService } from "./services/location/location.js";
+import { AnimateService as TAnimateService } from "./animations/interface.ts";
+import { StorageBackend as TStorageBackend } from "./services/storage/interface.ts";
+import { StreamConnectionConfig as TStreamConnectionConfig } from "./services/stream/interface.ts";
 declare global {
   interface Function {
     $inject?: readonly string[] | undefined;
   }
+  interface Window {
+    angular: TAngular;
+  }
   export namespace ng {
     type Angular = TAngular;
     type Attributes = TAttributes & Record<string, any>;
-    type Directive = TDirective;
+    type Directive<TController = any> = TDirective<TController>;
     type DirectiveFactory = TDirectiveFactory;
     type Component = TComponent;
     type Controller = TController;
@@ -84,6 +97,7 @@ declare global {
     type SceProvider = TSceProvider;
     type SceDelegateProvider = TSceDelegateProvider;
     type AnchorScrollService = TAnchorScrollService;
+    type AnimateService = TAnimateService;
     type CompileService = TCompileFn;
     type ControllerService = TControllerService;
     type ExceptionHandlerService = TErrorHandler;
@@ -92,8 +106,10 @@ declare global {
     type HttpService = THttpService;
     type InterpolateService = TInterpolateService;
     type InjectorService = TInjectorService;
+    type LocationService = TLocationService;
     type LogService = TLogService;
     type ParseService = TParseService;
+    type ProvideService = TProvideService;
     type PubSubService = TPubSub;
     type RootElementService = Element;
     type RootScopeService = TScope;
@@ -103,9 +119,18 @@ declare global {
     type TemplateCacheService = Map<string, string>;
     type TemplateRequestService = TTemplateRequestService;
     type ErrorHandlingConfig = TErrorHandlingConfig;
-    type WindowService = Window;
+    type ListenerFn = TListenerFn;
+    type Listener = TListener;
     type DocumentService = Document;
+    type WindowService = Window;
     type WorkerConfig = TWorkerConfig;
     type WorkerConnection = TWorkerConnection;
+    type Injectable<
+      T extends
+        | ((...args: any[]) => any)
+        | (abstract new (...args: any[]) => any),
+    > = TInjectable<T>;
+    type StorageBackend = TStorageBackend;
+    type StreamConnectionConfig = TStreamConnectionConfig;
   }
 }

package/@types/ng.d.ts

@@ -1,8 +1,6 @@
 /**
  * Initializes core `ng` module.
- * @param {import('./angular.js').Angular} angular
- * @returns {import('./core/di/ng-module.js').NgModule} `ng` module
+ * @param {ng.Angular} angular
+ * @returns {ng.NgModule} `ng` module
  */
-export function registerNgModule(
-  angular: import("./angular.js").Angular,
-): import("./core/di/ng-module.js").NgModule;
+export function registerNgModule(angular: ng.Angular): ng.NgModule;

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

@@ -211,31 +211,6 @@ export interface ParamDeclaration {
    * Default: If squash is not set, it uses the configured default squash policy. (See [[defaultSquashPolicy]]())
    */
   squash?: boolean | string;
-  /**
-   * @internal
-   *
-   * An array of [[Replace]] objects.
-   *
-   * When creating a Transition, defines how to handle certain special values, such as `undefined`, `null`,
-   * or empty string `""`.  If the transition is started, and the parameter value is equal to one of the "to"
-   * values, then the parameter value is replaced with the "from" value.
-   *
-   * #### Example:
-   * ```js
-   * replace: [
-   *   { from: undefined, to: null },
-   *   { from: "", to: null }
-   * ]
-   * ```
-   */
-  replace?: Replace[];
-  /**
-   * @internal
-   * @internal
-   *
-   * This is not part of the declaration; it is a calculated value depending on if a default value was specified or not.
-   */
-  isOptional?: boolean;
   /**
    * Dynamic flag
    *

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

@@ -385,15 +385,6 @@ export interface StateDeclaration {
    * ```
    */
   parent?: string | StateDeclaration;
-  /**
-   * Gets the internal State object API
-   *
-   * Gets the *internal API* for a registered state.
-   *
-   * Note: the internal [[StateObject]] API is subject to change without notice
-   * @internal
-   */
-  $$state?: () => StateObject;
   /**
    * Resolve - a mechanism to asynchronously fetch data, participating in the Transition lifecycle
    *

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

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

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

@@ -5,7 +5,6 @@ import { StateObject } from "../state/state-object.js";
 import { PathNode } from "../path/path-node.js";
 import { TargetState } from "../state/target-state.js";
 import { RegisteredHook } from "./hook-registry.js";
-import { TransitionHookScope } from "./transition-hook.js";
 /**
  * The TransitionOptions object can be used to change the behavior of a transition.
  *
@@ -79,16 +78,6 @@ export interface TransitionOptions {
    * @default `true`
    */
   supercede?: boolean;
-  /** @internal */
-  reloadState?: StateObject;
-  /** @internal
-   * If this transition is a redirect, this property should be the original Transition (which was redirected to this one)
-   */
-  redirectedFrom?: Transition;
-  /** @internal */
-  current?: () => Transition;
-  /** @internal */
-  source?: "sref" | "url" | "redirect" | "otherwise" | "unknown";
 }
 export interface TransitionHookOptions {
   current?: () => Transition;
@@ -299,10 +288,6 @@ export interface HookRegOptions {
  * Note: the Transition object only allows hooks to be registered before the Transition is started.
  */
 export interface IHookRegistry {
-  /** @internal place to store the hooks */
-  _registeredHooks: {
-    [key: string]: RegisteredHook[];
-  };
   /**
    * Registers a [[TransitionHookFn]], called *before a transition starts*.
    *
@@ -838,24 +823,6 @@ export interface IMatchingNodes {
   retained: PathNode[];
   entering: PathNode[];
 }
-/** @internal */
-export interface RegisteredHooks {
-  [key: string]: RegisteredHook[];
-}
-/** @internal */
-export interface PathTypes {
-  [key: string]: PathType;
-  to: PathType;
-  from: PathType;
-  exiting: PathType;
-  retained: PathType;
-  entering: PathType;
-}
-/** @internal */
-export interface PathType {
-  name: string;
-  scope: TransitionHookScope;
-}
 /**
  * Hook Criterion used to match a transition.
  *