@angular-wave/angular.ts 0.10.0 → 0.11.0

package/@types/angular.d.ts

@@ -1,16 +1,32 @@
 export class Angular {
   $cache: Map<number, import("./interface.ts").ExpandoStore>;
-  /** @type {import('./services/pubsub/pubsub.js').PubSub} */
-  $eventBus: import("./services/pubsub/pubsub.js").PubSub;
+  /** @type {ng.PubSubService} */
+  $eventBus: ng.PubSubService;
   /**
    * @type {string} `version` from `package.json`
    */
   version: string;
   /** @type {!Array<string|any>} */
   bootsrappedModules: Array<string | any>;
-  getController: typeof getController;
-  getInjector: typeof getInjector;
-  getScope: typeof getScope;
+  /**
+   * Gets the controller instance for a given element, if exists. Defaults to "ngControllerController"
+   *
+   * @type {(element: Element, name: string?) => ng.Scope|undefined}
+   */
+  getController: (
+    element: Element,
+    name: string | null,
+  ) => ng.Scope | undefined;
+  /**
+   * Return instance of InjectorService attached to element
+   * @type {(Element) => ng.InjectorService}
+   */
+  getInjector: (Element: any) => ng.InjectorService;
+  /**
+   * Gets scope for a given element.
+   * @type {(Element) => *}
+   */
+  getScope: (Element: any) => any;
   errorHandlingConfig: typeof errorHandlingConfig;
   $t: Readonly<Record<string, string>>;
   /**
@@ -61,7 +77,7 @@ export class Angular {
     modules?: Array<string | any>,
     config?: import("./interface.ts").AngularBootstrapConfig,
   ): import("./core/di/internal-injector.js").InjectorService;
-  $injector: import("./core/di/internal-injector.js").InjectorService;
+  $injector: import("./interface.ts").InjectorService;
   /**
    * @param {any[]} modules
    * @param {boolean?} strictDi
@@ -128,8 +144,5 @@ export class Angular {
     configFn?: import("./interface.ts").Injectable<any>,
   ): NgModule;
 }
-import { getController } from "./shared/dom.js";
-import { getInjector } from "./shared/dom.js";
-import { getScope } from "./shared/dom.js";
 import { errorHandlingConfig } from "./shared/utils.js";
 import { NgModule } from "./core/di/ng-module.js";

package/@types/animations/animate-css-driver.d.ts

@@ -8,7 +8,6 @@ export class AnimateCssDriverProvider {
     | string
     | ((
         $animateCss: any,
-        $$AnimateRunner: typeof import("./animate-runner.js").AnimateRunner,
         $rootElement: Element,
       ) => (animationDetails: any) => any)
   )[];

package/@types/animations/animate-css.d.ts

@@ -3,7 +3,6 @@ export class AnimateCssProvider {
   $get: (
     | string
     | ((
-        $$AnimateRunner: any,
         $$animateCache: any,
         $$rAFScheduler: any,
       ) => (

package/@types/animations/animate-js-driver.d.ts

@@ -1,13 +1,7 @@
 export function AnimateJsDriverProvider($$animationProvider: any): void;
 export class AnimateJsDriverProvider {
   constructor($$animationProvider: any);
-  $get: (
-    | string
-    | ((
-        $$animateJs: any,
-        $$AnimateRunner: any,
-      ) => (animationDetails: any) => any)
-  )[];
+  $get: (string | (($$animateJs: any) => (animationDetails: any) => any))[];
 }
 export namespace AnimateJsDriverProvider {
   let $inject: string[];

package/@types/animations/animate-js.d.ts

@@ -3,10 +3,7 @@ export class AnimateJsProvider {
   constructor($animateProvider: any);
   $get: (
     | string
-    | ((
-        $injector: ng.InjectorService,
-        $$AnimateRunner: any,
-      ) => (
+    | (($injector: ng.InjectorService) => (
         element: any,
         event: any,
         classes: any,

package/@types/animations/animate-queue.d.ts

@@ -9,10 +9,9 @@ export class AnimateQueueProvider {
   $get: (
     | string
     | ((
-        $rootScope: import("../core/scope/scope.js").Scope,
-        $injector: import("../core/di/internal-injector.js").InjectorService,
+        $rootScope: ng.RootScopeService,
+        $injector: ng.InjectorService,
         $$animation: any,
-        $$AnimateRunner: any,
         $templateRequest: any,
       ) => {
         on(event: any, container: any, callback: any): void;

package/@types/animations/animate.d.ts

@@ -1,10 +1,8 @@
-/** @param {import('../interface.ts').Provider} $provide */
-export function AnimateProvider(
-  $provide: import("../interface.ts").Provider,
-): void;
+/** @param {ng.ProvideService} $provide */
+export function AnimateProvider($provide: ng.ProvideService): void;
 export class AnimateProvider {
-  /** @param {import('../interface.ts').Provider} $provide */
-  constructor($provide: import("../interface.ts").Provider);
+  /** @param {ng.ProvideService} $provide */
+  constructor($provide: ng.ProvideService);
   $$registeredAnimations: any;
   /**
    * Registers a new injectable animation factory function. The factory function produces the
@@ -218,7 +216,7 @@ export class AnimateProvider {
        * Note that this does not cancel the underlying operation, e.g. the setting of classes or
        * adding the element to the DOM.
        *
-       * @param {import('./animate-runner.js').AnimateRunner} runner An animation runner returned by an $animate function.
+       * @param {import('./runner/animate-runner.js').AnimateRunner} runner An animation runner returned by an $animate function.
        *
        * @example
         <example module="animationExample" deps="angular-animate.js" animations="true" name="animate-cancel">
@@ -282,7 +280,9 @@ export class AnimateProvider {
           </file>
         </example>
        */
-        cancel(runner: import("./animate-runner.js").AnimateRunner): void;
+        cancel(
+          runner: import("./runner/animate-runner.js").AnimateRunner,
+        ): void;
         /**
          * Inserts the element into the DOM either after the `after` element (if provided) or
          * as the first child within the `parent` element and then triggers an animation.
@@ -293,14 +293,14 @@ export class AnimateProvider {
          * @param {Element} parent - the parent element which will append the element as a child (so long as the after element is not present)
          * @param {Element} [after] - after the sibling element after which the element will be appended
          * @param {AnimationOptions} [options] - an optional collection of options/styles that will be applied to the element.
-         * @returns {import('./animate-runner.js').AnimateRunner} the animation runner
+         * @returns {import('./runner/animate-runner.js').AnimateRunner} the animation runner
          */
         enter(
           element: Element,
           parent: Element,
           after?: Element,
           options?: AnimationOptions,
-        ): import("./animate-runner.js").AnimateRunner;
+        ): import("./runner/animate-runner.js").AnimateRunner;
         /**
          * Inserts (moves) the element into its new position in the DOM either after
          * the `after` element (if provided) or as the first child within the `parent` element
@@ -311,14 +311,14 @@ export class AnimateProvider {
          * @param {Element} parent - the parent element which will append the element as a child (so long as the after element is not present)
          * @param {Element} after - after the sibling element after which the element will be appended
          * @param {AnimationOptions} [options] - an optional collection of options/styles that will be applied to the element.
-         * @returns {import('./animate-runner.js').AnimateRunner} the animation runner
+         * @returns {import('./runner/animate-runner.js').AnimateRunner} the animation runner
          */
         move(
           element: Element,
           parent: Element,
           after: Element,
           options?: AnimationOptions,
-        ): import("./animate-runner.js").AnimateRunner;
+        ): import("./runner/animate-runner.js").AnimateRunner;
         /**
          * Triggers an animation and then removes the element from the DOM.
          * When the function is called a promise is returned that will be resolved during the next
@@ -326,12 +326,12 @@ export class AnimateProvider {
          *
          * @param {Element} element the element which will be removed from the DOM
          * @param {AnimationOptions} [options] an optional collection of options/styles that will be applied to the element.
-         * @returns {import('./animate-runner.js').AnimateRunner} the animation runner
+         * @returns {import('./runner/animate-runner.js').AnimateRunner} the animation runner
          */
         leave(
           element: Element,
           options?: AnimationOptions,
-        ): import("./animate-runner.js").AnimateRunner;
+        ): import("./runner/animate-runner.js").AnimateRunner;
         /**
          * Triggers an addClass animation surrounding the addition of the provided CSS class(es). Upon
          * execution, the addClass operation will only be handled after the next digest and it will not trigger an
@@ -343,13 +343,13 @@ export class AnimateProvider {
          * @param {Element} element the element which the CSS classes will be applied to
          * @param {string} className the CSS class(es) that will be added (multiple classes are separated via spaces)
          * @param {AnimationOptions} [options] an optional collection of options/styles that will be applied to the element.
-         * @return {import('./animate-runner.js').AnimateRunner}} animationRunner the animation runner
+         * @return {import('./runner/animate-runner.js').AnimateRunner}} animationRunner the animation runner
          */
         addClass(
           element: Element,
           className: string,
           options?: AnimationOptions,
-        ): import("./animate-runner.js").AnimateRunner;
+        ): import("./runner/animate-runner.js").AnimateRunner;
         /**
          * Triggers a removeClass animation surrounding the removal of the provided CSS class(es). Upon
          * execution, the removeClass operation will only be handled after the next digest and it will not trigger an
@@ -361,13 +361,13 @@ export class AnimateProvider {
          * @param {Element} element the element which the CSS classes will be applied to
          * @param {string} className the CSS class(es) that will be removed (multiple classes are separated via spaces)
          * @param {AnimationOptions} [options] an optional collection of options/styles that will be applied to the element.         *
-         * @return {import('./animate-runner.js').AnimateRunner} animationRunner the animation runner
+         * @return {import('./runner/animate-runner.js').AnimateRunner} animationRunner the animation runner
          */
         removeClass(
           element: Element,
           className: string,
           options?: AnimationOptions,
-        ): import("./animate-runner.js").AnimateRunner;
+        ): import("./runner/animate-runner.js").AnimateRunner;
         /**
          * Performs both the addition and removal of a CSS classes on an element and (during the process)
          * triggers an animation surrounding the class addition/removal. Much like `$animate.addClass` and
@@ -381,14 +381,14 @@ export class AnimateProvider {
          * @param {string} remove the CSS class(es) that will be removed (multiple classes are separated via spaces)
          * @param {object=} options an optional collection of options/styles that will be applied to the element.
          *
-         * @return {import('./animate-runner.js').AnimateRunner} the animation runner
+         * @return {import('./runner/animate-runner.js').AnimateRunner} the animation runner
          */
         setClass(
           element: Element,
           add: string,
           remove: string,
           options?: object | undefined,
-        ): import("./animate-runner.js").AnimateRunner;
+        ): import("./runner/animate-runner.js").AnimateRunner;
         /**
          * Performs an inline animation on the element which applies the provided to and from CSS styles to the element.
          * If any detected CSS transition, keyframe or JavaScript matches the provided className value, then the animation will take
@@ -408,7 +408,7 @@ export class AnimateProvider {
          *   }
          * });
          * ```
-         *  @return {import('./animate-runner.js').AnimateRunner} the animation runner
+         *  @return {import('./runner/animate-runner.js').AnimateRunner} the animation runner
          */
         animate(
           element: any,
@@ -416,7 +416,7 @@ export class AnimateProvider {
           to: any,
           className: any,
           options: any,
-        ): import("./animate-runner.js").AnimateRunner;
+        ): import("./runner/animate-runner.js").AnimateRunner;
       })
   )[];
 }

package/@types/animations/animation.d.ts

@@ -6,9 +6,9 @@ export class AnimationProvider {
     | ((
         $rootScope: ng.RootScopeService,
         $injector: any,
-        $$AnimateRunner: any,
         $$rAFScheduler: any,
         $$animateCache: any,
-      ) => (element: any, event: any, options: any) => any)
+      ) => (element: any, event: any, options: any) => AnimateRunner)
   )[];
 }
+import { AnimateRunner } from "./runner/animate-runner.js";

package/@types/animations/interface.d.ts

@@ -15,3 +15,15 @@ export type RafScheduler = {
    */
   waitUntilQuiet(fn: () => void): void;
 };
+export interface AnimationHost {
+  /** Pause animation. */
+  pause?: () => void;
+  /** Resume animation. */
+  resume?: () => void;
+  /** End animation. */
+  end?: () => void;
+  /** Cancel animation. */
+  cancel?: () => void;
+  /** Report animation progress. */
+  progress?: (...args: any[]) => void;
+}

package/@types/animations/runner/animate-runner.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Schedule a callback to run on the next animation frame.
+ * Multiple calls within the same frame are batched together.
+ *
+ * @param {VoidFunction} fn - The callback to execute.
+ */
+export function schedule(fn: VoidFunction): void;
+/**
+ * Represents an asynchronous animation operation.
+ * Provides both callback-based and promise-based completion APIs.
+ */
+export class AnimateRunner {
+  /**
+   * Run an array of animation runners in sequence.
+   * Each runner waits for the previous one to complete.
+   *
+   * @param {AnimateRunner[]} runners - Runners to execute in order.
+   * @param {(ok: boolean) => void} callback - Invoked when all complete or one fails.
+   */
+  static chain(runners: AnimateRunner[], callback: (ok: boolean) => void): void;
+  /**
+   * Waits for all animation runners to complete before invoking the callback.
+   *
+   * @param {AnimateRunner[]} runners - Active runners to wait for.
+   * @param {(ok: boolean) => void} callback - Called when all runners complete.
+   */
+  static all(runners: AnimateRunner[], callback: (ok: boolean) => void): void;
+  /**
+   * @param {import("../interface.ts").AnimationHost} [host] - Optional animation host.
+   */
+  constructor(host?: import("../interface.ts").AnimationHost);
+  /** @type {import("../interface.ts").AnimationHost} */
+  host: import("../interface.ts").AnimationHost;
+  /** @type {Array<(ok: boolean) => void>} */
+  _doneCallbacks: Array<(ok: boolean) => void>;
+  /** @type {RunnerState} */
+  _state: RunnerState;
+  /** @type {Promise<void>|null} */
+  _promise: Promise<void> | null;
+  /** @type {(fn: VoidFunction) => void} */
+  _schedule: (fn: VoidFunction) => void;
+  /**
+   * Sets or updates the animation host.
+   * @param {import("../interface.ts").AnimationHost} host - The host object.
+   */
+  setHost(host: import("../interface.ts").AnimationHost): void;
+  /**
+   * Registers a callback to be called once the animation completes.
+   * If the animation is already complete, it's called immediately.
+   *
+   * @param {(ok: boolean) => void} fn - Completion callback.
+   */
+  done(fn: (ok: boolean) => void): void;
+  /**
+   * Notifies the host of animation progress.
+   * @param {...any} args - Progress arguments.
+   */
+  progress(...args: any[]): void;
+  /** Pauses the animation, if supported by the host. */
+  pause(): void;
+  /** Resumes the animation, if supported by the host. */
+  resume(): void;
+  /** Ends the animation successfully. */
+  end(): void;
+  /** Cancels the animation. */
+  cancel(): void;
+  /**
+   * Marks the animation as complete on the next animation frame.
+   * @param {boolean} [status=true] - True if successful, false if canceled.
+   */
+  complete(status?: boolean): void;
+  /**
+   * Returns a promise that resolves or rejects when the animation completes.
+   * @returns {Promise<void>} Promise resolved on success or rejected on cancel.
+   */
+  getPromise(): Promise<void>;
+  /** @inheritdoc */
+  then(onFulfilled: any, onRejected: any): Promise<void>;
+  /** @inheritdoc */
+  catch(onRejected: any): Promise<void>;
+  /** @inheritdoc */
+  finally(onFinally: any): Promise<void>;
+  /**
+   * Completes the animation and invokes all done callbacks.
+   * @private
+   * @param {boolean} status - True if completed successfully, false if canceled.
+   */
+  private _finish;
+}
+/**
+ * Internal runner states.
+ */
+type RunnerState = number;
+declare namespace RunnerState {
+  let INITIAL: number;
+  let PENDING: number;
+  let DONE: number;
+}
+export {};

package/@types/core/filter/filter.d.ts

@@ -1,9 +1,9 @@
 export class FilterProvider {
   static $inject: string[];
   /**
-   * @param {import('../../interface.ts').Provider} $provide
+   * @param {ng.ProvideService} $provide
    */
-  constructor($provide: import("../../interface.ts").Provider);
+  constructor($provide: ng.ProvideService);
   $provide: import("../../interface.ts").Provider;
   /**
    * @param {string|Record<string, ng.FilterFn>} name

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

@@ -9,6 +9,11 @@ export function nextId(): number;
  *                                     or the original value if the target is not an object.
  */
 export function createScope(target?: any, context?: Scope): Scope;
+/**
+ * @param {any} target
+ * @returns {boolean}
+ */
+export function isUnsafeGlobal(target: any): boolean;
 export const $postUpdateQueue: any[];
 export class RootScopeProvider {
   rootScope: Scope;

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

@@ -1,3 +1,3 @@
-export const ngClassDirective: () => import("../../interface.ts").Directive;
-export const ngClassOddDirective: () => import("../../interface.ts").Directive;
-export const ngClassEvenDirective: () => import("../../interface.ts").Directive;
+export const ngClassDirective: import("../../interface.ts").DirectiveFactory;
+export const ngClassOddDirective: import("../../interface.ts").DirectiveFactory;
+export const ngClassEvenDirective: import("../../interface.ts").DirectiveFactory;

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

@@ -41,7 +41,7 @@ declare class NgMessageCtrl {
     $animate: any,
   );
   $element: Element;
-  $scope: import("../../core/scope/scope.js").Scope;
+  $scope: import("../../interface.ts").Scope;
   $attrs: any;
   $animate: any;
   latestKey: number;

package/@types/interface.d.ts

@@ -6,6 +6,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";
 /**
@@ -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;
 }
 /**

package/@types/namespace.d.ts

@@ -56,6 +56,8 @@ import {
   WorkerConnection as TWorkerConnection,
   WorkerConfig as TWorkerConfig,
 } from "./services/worker/interface.ts";
+import { Provider as TProvideService } from "./interface.ts";
+import { Location as TLocationService } from "./services/location/location.js";
 declare global {
   interface Function {
     $inject?: readonly string[] | undefined;
@@ -92,8 +94,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;

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