@angular-wave/angular.ts 0.0.60 → 0.0.62

package/types-back/router/core/url/urlRules.d.ts

@@ -1,251 +0,0 @@
-import { Router } from "../router";
-import { UrlRule, UrlRuleHandlerFn } from "./interface";
-import { TargetState, TargetStateDef } from "../state";
-import { UrlMatcher } from "./urlMatcher";
-import { UrlRuleFactory } from "./urlRule";
-/**
- * API for managing URL rules
- *
- * This API is used to create and manage URL rules.
- * URL rules are a mechanism to respond to specific URL patterns.
- *
- * The most commonly used methods are [[otherwise]] and [[when]].
- *
- * This API is found at `router.urlService.rules` (see: [[Router.urlService]], [[URLService.rules]])
- */
-export declare class UrlRules {
-  private router;
-  /** used to create [[UrlRule]] objects for common cases */
-  urlRuleFactory: UrlRuleFactory;
-  /** @internal */ private _sortFn;
-  /** @internal */ private _otherwiseFn;
-  /** @internal */ private _sorted;
-  /** @internal */ private _rules;
-  /** @internal */ private _id;
-  /** @internal */
-  constructor(/** @internal */ router: Router);
-  /** @internal */
-  dispose(router?: Router): void;
-  /**
-   * Defines the initial state, path, or behavior to use when the app starts.
-   *
-   * This rule defines the initial/starting state for the application.
-   *
-   * This rule is triggered the first time the URL is checked (when the app initially loads).
-   * The rule is triggered only when the url matches either `""` or `"/"`.
-   *
-   * Note: The rule is intended to be used when the root of the application is directly linked to.
-   * When the URL is *not* `""` or `"/"` and doesn't match other rules, the [[otherwise]] rule is triggered.
-   * This allows 404-like behavior when an unknown URL is deep-linked.
-   *
-   * #### Example:
-   * Start app at `home` state.
-   * ```js
-   * .initial({ state: 'home' });
-   * ```
-   *
-   * #### Example:
-   * Start app at `/home` (by url)
-   * ```js
-   * .initial('/home');
-   * ```
-   *
-   * #### Example:
-   * When no other url rule matches, go to `home` state
-   * ```js
-   * .initial((matchValue, url, router) => {
-   *   console.log('initial state');
-   *   return { state: 'home' };
-   * })
-   * ```
-   *
-   * @param handler The initial state or url path, or a function which returns the state or url path (or performs custom logic).
-   */
-  initial(
-    handler: string | UrlRuleHandlerFn | TargetState | TargetStateDef,
-  ): void;
-  /**
-   * Defines the state, url, or behavior to use when no other rule matches the URL.
-   *
-   * This rule is matched when *no other rule* matches.
-   * It is generally used to handle unknown URLs (similar to "404" behavior, but on the client side).
-   *
-   * - If `handler` a string, it is treated as a url redirect
-   *
-   * #### Example:
-   * When no other url rule matches, redirect to `/index`
-   * ```js
-   * .otherwise('/index');
-   * ```
-   *
-   * - If `handler` is an object with a `state` property, the state is activated.
-   *
-   * #### Example:
-   * When no other url rule matches, redirect to `home` and provide a `dashboard` parameter value.
-   * ```js
-   * .otherwise({ state: 'home', params: { dashboard: 'default' } });
-   * ```
-   *
-   * - If `handler` is a function, the function receives the current url ([[UrlParts]]) and the [[Router]] object.
-   *   The function can perform actions, and/or return a value.
-   *
-   * #### Example:
-   * When no other url rule matches, manually trigger a transition to the `home` state
-   * ```js
-   * .otherwise((matchValue, urlParts, router) => {
-   *   router.stateService.go('home');
-   * });
-   * ```
-   *
-   * #### Example:
-   * When no other url rule matches, go to `home` state
-   * ```js
-   * .otherwise((matchValue, urlParts, router) => {
-   *   return { state: 'home' };
-   * });
-   * ```
-   *
-   * @param handler The url path to redirect to, or a function which returns the url path (or performs custom logic).
-   */
-  otherwise(
-    handler: string | UrlRuleHandlerFn | TargetState | TargetStateDef,
-  ): void;
-  /**
-   * Remove a rule previously registered
-   *
-   * @param rule the matcher rule that was previously registered using [[rule]]
-   */
-  removeRule(rule: any): void;
-  /**
-   * Manually adds a URL Rule.
-   *
-   * Usually, a url rule is added using [[StateDeclaration.url]] or [[when]].
-   * This api can be used directly for more control (to register a [[BaseUrlRule]], for example).
-   * Rules can be created using [[urlRuleFactory]], or created manually as simple objects.
-   *
-   * A rule should have a `match` function which returns truthy if the rule matched.
-   * It should also have a `handler` function which is invoked if the rule is the best match.
-   *
-   * @return a function that deregisters the rule
-   */
-  rule(rule: UrlRule): Function;
-  /**
-   * Gets all registered rules
-   *
-   * @returns an array of all the registered rules
-   */
-  rules(): UrlRule[];
-  /**
-   * Defines URL Rule priorities
-   *
-   * More than one rule ([[UrlRule]]) might match a given URL.
-   * This `compareFn` is used to sort the rules by priority.
-   * Higher priority rules should sort earlier.
-   *
-   * The [[defaultRuleSortFn]] is used by default.
-   *
-   * You only need to call this function once.
-   * The `compareFn` will be used to sort the rules as each is registered.
-   *
-   * If called without any parameter, it will re-sort the rules.
-   *
-   * ---
-   *
-   * Url rules may come from multiple sources: states's urls ([[StateDeclaration.url]]), [[when]], and [[rule]].
-   * Each rule has a (user-provided) [[UrlRule.priority]], a [[UrlRule.type]], and a [[UrlRule.$id]]
-   * The `$id` is is the order in which the rule was registered.
-   *
-   * The sort function should use these data, or data found on a specific type
-   * of [[UrlRule]] (such as [[StateRule.state]]), to order the rules as desired.
-   *
-   * #### Example:
-   * This compare function prioritizes rules by the order in which the rules were registered.
-   * A rule registered earlier has higher priority.
-   *
-   * ```js
-   * function compareFn(a, b) {
-   *   return a.$id - b.$id;
-   * }
-   * ```
-   *
-   * @param compareFn a function that compares to [[UrlRule]] objects.
-   *    The `compareFn` should abide by the `Array.sort` compare function rules.
-   *    Given two rules, `a` and `b`, return a negative number if `a` should be higher priority.
-   *    Return a positive number if `b` should be higher priority.
-   *    Return `0` if the rules are identical.
-   *
-   *    See the [mozilla reference](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#Description)
-   *    for details.
-   */
-  sort(compareFn?: (a: UrlRule, b: UrlRule) => number): void;
-  /** @internal */
-  private ensureSorted;
-  /** @internal */
-  private stableSort;
-  /**
-   * Registers a `matcher` and `handler` for custom URLs handling.
-   *
-   * The `matcher` can be:
-   *
-   * - a [[UrlMatcher]]: See: [[UrlMatcherFactory.compile]]
-   * - a `string`: The string is compiled to a [[UrlMatcher]]
-   * - a `RegExp`: The regexp is used to match the url.
-   *
-   * The `handler` can be:
-   *
-   * - a string: The url is redirected to the value of the string.
-   * - a function: The url is redirected to the return value of the function.
-   *
-   * ---
-   *
-   * When the `handler` is a `string` and the `matcher` is a `UrlMatcher` (or string), the redirect
-   * string is interpolated with parameter values.
-   *
-   * #### Example:
-   * When the URL is `/foo/123` the rule will redirect to `/bar/123`.
-   * ```js
-   * .when("/foo/:param1", "/bar/:param1")
-   * ```
-   *
-   * ---
-   *
-   * When the `handler` is a string and the `matcher` is a `RegExp`, the redirect string is
-   * interpolated with capture groups from the RegExp.
-   *
-   * #### Example:
-   * When the URL is `/foo/123` the rule will redirect to `/bar/123`.
-   * ```js
-   * .when(new RegExp("^/foo/(.*)$"), "/bar/$1");
-   * ```
-   *
-   * ---
-   *
-   * When the handler is a function, it receives the matched value, the current URL, and the `Router` object (See [[UrlRuleHandlerFn]]).
-   * The "matched value" differs based on the `matcher`.
-   * For [[UrlMatcher]]s, it will be the matched state params.
-   * For `RegExp`, it will be the match array from `regexp.exec()`.
-   *
-   * If the handler returns a string, the URL is redirected to the string.
-   *
-   * #### Example:
-   * When the URL is `/foo/123` the rule will redirect to `/bar/123`.
-   * ```js
-   * .when(new RegExp("^/foo/(.*)$"), match => "/bar/" + match[1]);
-   * ```
-   *
-   * Note: the `handler` may also invoke arbitrary code, such as `$state.go()`
-   *
-   * @param matcher A pattern `string` to match, compiled as a [[UrlMatcher]], or a `RegExp`.
-   * @param handler The path to redirect to, or a function that returns the path.
-   * @param options `{ priority: number }`
-   *
-   * @return the registered [[UrlRule]]
-   */
-  when(
-    matcher: RegExp | UrlMatcher | string,
-    handler: string | UrlRuleHandlerFn,
-    options?: {
-      priority: number;
-    },
-  ): UrlRule;
-}

package/types-back/router/core/url/urlService.d.ts

@@ -1,205 +0,0 @@
-import { Router } from "../router";
-import { LocationServices } from "../common";
-import { MatchResult, UrlParts, UrlSyncApi } from "./interface";
-import { UrlRules } from "./urlRules";
-import { UrlConfig } from "./urlConfig";
-/**
- * API for URL management
- */
-export declare class UrlService implements LocationServices, UrlSyncApi {
-  private router;
-  /** @internal */ private _stopListeningFn;
-  /** @internal */ interceptDeferred: boolean;
-  /**
-   * The nested [[UrlRules]] API for managing URL rules and rewrites
-   *
-   * See: [[UrlRules]] for details
-   */
-  rules: UrlRules;
-  /**
-   * The nested [[UrlConfig]] API to configure the URL and retrieve URL information
-   *
-   * See: [[UrlConfig]] for details
-   */
-  config: UrlConfig;
-  /** @internal */
-  constructor(/** @internal */ router: Router);
-
-  /**
-   * Gets the current URL parts
-   *
-   * This method returns the different parts of the current URL (the [[path]], [[search]], and [[hash]]) as a [[UrlParts]] object.
-   */
-  parts(): UrlParts;
-  /**
-   * Activates the best rule for the current URL
-   *
-   * Checks the current URL for a matching [[UrlRule]], then invokes that rule's handler.
-   * This method is called internally any time the URL has changed.
-   *
-   * This effectively activates the state (or redirect, etc) which matches the current URL.
-   *
-   * #### Example:
-   * ```js
-   * urlService.deferIntercept();
-   *
-   * fetch('/states.json').then(resp => resp.json()).then(data => {
-   *   data.forEach(state => $stateRegistry.register(state));
-   *   urlService.listen();
-   *   // Find the matching URL and invoke the handler.
-   *   urlService.sync();
-   * });
-   * ```
-   */
-  sync(evt?: any): void;
-  /**
-   * Starts or stops listening for URL changes
-   *
-   * Call this sometime after calling [[deferIntercept]] to start monitoring the url.
-   * This causes Router to start listening for changes to the URL, if it wasn't already listening.
-   *
-   * If called with `false`, Router will stop listening (call listen(true) to start listening again).
-   *
-   * #### Example:
-   * ```js
-   * urlService.deferIntercept();
-   *
-   * fetch('/states.json').then(resp => resp.json()).then(data => {
-   *   data.forEach(state => $stateRegistry.register(state));
-   *   // Start responding to URL changes
-   *   urlService.listen();
-   *   urlService.sync();
-   * });
-   * ```
-   *
-   * @param enabled `true` or `false` to start or stop listening to URL changes
-   */
-  listen(enabled?: boolean): Function;
-  /**
-   * Disables monitoring of the URL.
-   *
-   * Call this method before Router has bootstrapped.
-   * It will stop Router from performing the initial url sync.
-   *
-   * This can be useful to perform some asynchronous initialization before the router starts.
-   * Once the initialization is complete, call [[listen]] to tell Router to start watching and synchronizing the URL.
-   *
-   * #### Example:
-   * ```js
-   * // Prevent Router from automatically intercepting URL changes when it starts;
-   * urlService.deferIntercept();
-   *
-   * fetch('/states.json').then(resp => resp.json()).then(data => {
-   *   data.forEach(state => $stateRegistry.register(state));
-   *   urlService.listen();
-   *   urlService.sync();
-   * });
-   * ```
-   *
-   * @param defer Indicates whether to defer location change interception.
-   *        Passing no parameter is equivalent to `true`.
-   */
-  deferIntercept(defer?: boolean): void;
-  /**
-   * Matches a URL
-   *
-   * Given a URL (as a [[UrlParts]] object), check all rules and determine the best matching rule.
-   * Return the result as a [[MatchResult]].
-   */
-  match(url: UrlParts): MatchResult;
-  /**
-   * Gets the current url, or updates the url
-   *
-   * ### Getting the current URL
-   *
-   * When no arguments are passed, returns the current URL.
-   * The URL is normalized using the internal [[path]]/[[search]]/[[hash]] values.
-   *
-   * For example, the URL may be stored in the hash ([[HashLocationServices]]) or
-   * have a base HREF prepended ([[PushStateLocationServices]]).
-   *
-   * The raw URL in the browser might be:
-   *
-   * ```
-   * http://mysite.com/somepath/index.html#/internal/path/123?param1=foo#anchor
-   * ```
-   *
-   * or
-   *
-   * ```
-   * http://mysite.com/basepath/internal/path/123?param1=foo#anchor
-   * ```
-   *
-   * then this method returns:
-   *
-   * ```
-   * /internal/path/123?param1=foo#anchor
-   * ```
-   *
-   *
-   * #### Example:
-   * ```js
-   * locationServices.url(); // "/some/path?query=value#anchor"
-   * ```
-   *
-   * ### Updating the URL
-   *
-   * When `newurl` arguments is provided, changes the URL to reflect `newurl`
-   *
-   * #### Example:
-   * ```js
-   * locationServices.url("/some/path?query=value#anchor", true);
-   * ```
-   *
-   * @param newurl The new value for the URL.
-   *               This url should reflect only the new internal [[path]], [[search]], and [[hash]] values.
-   *               It should not include the protocol, site, port, or base path of an absolute HREF.
-   * @param replace When true, replaces the current history entry (instead of appending it) with this new url
-   * @param state The history's state object, i.e., pushState (if the LocationServices implementation supports it)
-   *
-   * @return the url (after potentially being processed)
-   */
-  url: (newurl?: string, replace?: boolean, state?: any) => string;
-  /**
-   * Gets the path part of the current url
-   *
-   * If the current URL is `/some/path?query=value#anchor`, this returns `/some/path`
-   *
-   * @return the path portion of the url
-   */
-  path: () => string;
-  /**
-   * Gets the search part of the current url as an object
-   *
-   * If the current URL is `/some/path?query=value#anchor`, this returns `{ query: 'value' }`
-   *
-   * @return the search (query) portion of the url, as an object
-   */
-  search: () => {
-    [key: string]: any;
-  };
-  /**
-   * Gets the hash part of the current url
-   *
-   * If the current URL is `/some/path?query=value#anchor`, this returns `anchor`
-   *
-   * @return the hash (anchor) portion of the url
-   */
-  hash: () => string;
-  /**
-   * @internal
-   *
-   * Registers a low level url change handler
-   *
-   * Note: Because this is a low level handler, it's not recommended for general use.
-   *
-   * #### Example:
-   * ```js
-   * let deregisterFn = locationServices.onChange((evt) => console.log("url change", evt));
-   * ```
-   *
-   * @param callback a function that will be called when the url is changing
-   * @return a function that de-registers the callback
-   */
-  onChange: (callback: EventListener) => Function;
-}

package/types-back/router/core/view/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./interface";
-export * from "./view";

package/types-back/router/core/view/interface.d.ts

@@ -1,46 +0,0 @@
-import { _ViewDeclaration } from "../state/interface";
-import { PathNode } from "../path/pathNode";
-/** The context ref can be anything that has a `name` and a `parent` reference to another IContextRef */
-export interface ViewContext {
-  name: string;
-  parent: ViewContext;
-}
-export interface ActiveNGView {
-  /** type of framework, e.g., "ng1" or "ng2" */
-  $type: string;
-  /** An auto-incremented id */
-  id: number;
-  /** The ui-view short name */
-  name: string;
-  /** The ui-view's fully qualified name */
-  fqn: string;
-  /** The ViewConfig that is currently loaded into the ui-view */
-  config: ViewConfig;
-  /** The state context in which the ui-view tag was created. */
-  creationContext: ViewContext;
-  /** A callback that should apply a ViewConfig (or clear the ui-view, if config is undefined) */
-  configUpdated: (config: ViewConfig) => void;
-}
-/**
- * This interface represents a [[_ViewDeclaration]] that is bound to a [[PathNode]].
- *
- * A `ViewConfig` is the runtime definition of a single view.
- *
- * During a transition, `ViewConfig`s are created for each [[_ViewDeclaration]] defined on each "entering" [[StateObject]].
- * Then, the [[ViewService]] finds any matching `ui-view`(s) in the DOM, and supplies the ui-view
- * with the `ViewConfig`.  The `ui-view` then loads itself using the information found in the `ViewConfig`.
- *
- * A `ViewConfig` if matched with a `ui-view` by finding all `ui-view`s which were created in the
- * context named by the `ngViewContextAnchor`, and finding the `ui-view` or child `ui-view` that matches
- * the `ngViewName` address.
- */
-export interface ViewConfig {
-  $id: number;
-  /** The normalized view declaration from [[State.views]] */
-  viewDecl: _ViewDeclaration;
-  /** The node the ViewConfig is bound to */
-  path: PathNode[];
-  loaded: boolean;
-  /** Fetches templates, runs dynamic (controller|template)Provider code, lazy loads Components, etc */
-  load(): Promise<ViewConfig>;
-}

package/types-back/router/core/view/view.d.ts

@@ -1,176 +0,0 @@
-import { TypedMap } from "../common/common";
-import { PathNode } from "../path/pathNode";
-import { ActiveNGView, ViewContext, ViewConfig } from "./interface";
-import { _ViewDeclaration } from "../state/interface";
-import { Router } from "../router";
-export declare type ViewConfigFactory = (
-  path: PathNode[],
-  decl: _ViewDeclaration,
-) => ViewConfig | ViewConfig[];
-export interface ViewServicePluginAPI {
-  _rootViewContext(context?: ViewContext): ViewContext;
-  _viewConfigFactory(viewType: string, factory: ViewConfigFactory): any;
-  /** @param id router.$id + "." + ngView.id */
-  _registeredNGView(id: string): ActiveNGView;
-  _registeredNGViews(): ActiveNGView[];
-  _activeViewConfigs(): ViewConfig[];
-  _onSync(listener: ViewSyncListener): Function;
-}
-export interface ViewTuple {
-  ngView: ActiveNGView;
-  viewConfig: ViewConfig;
-}
-export interface ViewSyncListener {
-  (viewTuples: ViewTuple[]): void;
-}
-/**
- * The View service
- *
- * This service pairs existing `ui-view` components (which live in the DOM)
- * with view configs (from the state declaration objects: [[StateDeclaration.views]]).
- *
- * - After a successful Transition, the views from the newly entered states are activated via [[activateViewConfig]].
- *   The views from exited states are deactivated via [[deactivateViewConfig]].
- *   (See: the [[registerActivateViews]] Transition Hook)
- *
- * - As `ui-view` components pop in and out of existence, they register themselves using [[registerNGView]].
- *
- * - When the [[sync]] function is called, the registered `ui-view`(s) ([[ActiveNGView]])
- * are configured with the matching [[ViewConfig]](s)
- *
- */
-export declare class ViewService {
-  private router;
-  /** @internal */ private _ngViews;
-  /** @internal */ private _viewConfigs;
-  /** @internal */ private _rootContext;
-  /** @internal */ private _viewConfigFactories;
-  /** @internal */ private _listeners;
-  /** @internal */
-  _pluginapi: ViewServicePluginAPI;
-  /**
-   * Given a ui-view and a ViewConfig, determines if they "match".
-   *
-   * A ui-view has a fully qualified name (fqn) and a context object.  The fqn is built from its overall location in
-   * the DOM, describing its nesting relationship to any parent ui-view tags it is nested inside of.
-   *
-   * A ViewConfig has a target ui-view name and a context anchor.  The ui-view name can be a simple name, or
-   * can be a segmented ui-view path, describing a portion of a ui-view fqn.
-   *
-   * In order for a ui-view to match ViewConfig, ui-view's $type must match the ViewConfig's $type
-   *
-   * If the ViewConfig's target ui-view name is a simple name (no dots), then a ui-view matches if:
-   * - the ui-view's name matches the ViewConfig's target name
-   * - the ui-view's context matches the ViewConfig's anchor
-   *
-   * If the ViewConfig's target ui-view name is a segmented name (with dots), then a ui-view matches if:
-   * - There exists a parent ui-view where:
-   *    - the parent ui-view's name matches the first segment (index 0) of the ViewConfig's target name
-   *    - the parent ui-view's context matches the ViewConfig's anchor
-   * - And the remaining segments (index 1..n) of the ViewConfig's target name match the tail of the ui-view's fqn
-   *
-   * Example:
-   *
-   * DOM:
-   * <ui-view>                        <!-- created in the root context (name: "") -->
-   *   <ui-view name="foo">                <!-- created in the context named: "A"      -->
-   *     <ui-view>                    <!-- created in the context named: "A.B"    -->
-   *       <ui-view name="bar">            <!-- created in the context named: "A.B.C"  -->
-   *       </ui-view>
-   *     </ui-view>
-   *   </ui-view>
-   * </ui-view>
-   *
-   * ngViews: [
-   *  { fqn: "$default",                  creationContext: { name: "" } },
-   *  { fqn: "$default.foo",              creationContext: { name: "A" } },
-   *  { fqn: "$default.foo.$default",     creationContext: { name: "A.B" } }
-   *  { fqn: "$default.foo.$default.bar", creationContext: { name: "A.B.C" } }
-   * ]
-   *
-   * These four view configs all match the ui-view with the fqn: "$default.foo.$default.bar":
-   *
-   * - ViewConfig1: { ngViewName: "bar",                       ngViewContextAnchor: "A.B.C" }
-   * - ViewConfig2: { ngViewName: "$default.bar",              ngViewContextAnchor: "A.B" }
-   * - ViewConfig3: { ngViewName: "foo.$default.bar",          ngViewContextAnchor: "A" }
-   * - ViewConfig4: { ngViewName: "$default.foo.$default.bar", ngViewContextAnchor: "" }
-   *
-   * Using ViewConfig3 as an example, it matches the ui-view with fqn "$default.foo.$default.bar" because:
-   * - The ViewConfig's segmented target name is: [ "foo", "$default", "bar" ]
-   * - There exists a parent ui-view (which has fqn: "$default.foo") where:
-   *    - the parent ui-view's name "foo" matches the first segment "foo" of the ViewConfig's target name
-   *    - the parent ui-view's context "A" matches the ViewConfig's anchor context "A"
-   * - And the remaining segments [ "$default", "bar" ].join("."_ of the ViewConfig's target name match
-   *   the tail of the ui-view's fqn "default.bar"
-   *
-   * @internal
-   */
-  static matches: (
-    ngViewsByFqn: TypedMap<ActiveNGView>,
-    ngView: ActiveNGView,
-  ) => (viewConfig: ViewConfig) => boolean;
-  /**
-   * Normalizes a view's name from a state.views configuration block.
-   *
-   * This should be used by a framework implementation to calculate the values for
-   * [[_ViewDeclaration.$ngViewName]] and [[_ViewDeclaration.$ngViewContextAnchor]].
-   *
-   * @param context the context object (state declaration) that the view belongs to
-   * @param rawViewName the name of the view, as declared in the [[StateDeclaration.views]]
-   *
-   * @returns the normalized ngViewName and ngViewContextAnchor that the view targets
-   */
-  static normalizeNGViewTarget(
-    context: ViewContext,
-    rawViewName?: string,
-  ): {
-    ngViewName: string;
-    ngViewContextAnchor: string;
-  };
-  /** @internal */
-  constructor(/** @internal */ router: Router);
-  /** @internal */
-  private _rootViewContext;
-  /** @internal */
-  private _viewConfigFactory;
-  createViewConfig(path: PathNode[], decl: _ViewDeclaration): ViewConfig[];
-  /**
-   * Deactivates a ViewConfig.
-   *
-   * This function deactivates a `ViewConfig`.
-   * After calling [[sync]], it will un-pair from any `ui-view` with which it is currently paired.
-   *
-   * @param viewConfig The ViewConfig view to deregister.
-   */
-  deactivateViewConfig(viewConfig: ViewConfig): void;
-  activateViewConfig(viewConfig: ViewConfig): void;
-  sync(): void;
-  /**
-   * Registers a `ui-view` component
-   *
-   * When a `ui-view` component is created, it uses this method to register itself.
-   * After registration the [[sync]] method is used to ensure all `ui-view` are configured with the proper [[ViewConfig]].
-   *
-   * Note: the `ui-view` component uses the `ViewConfig` to determine what view should be loaded inside the `ui-view`,
-   * and what the view's state context is.
-   *
-   * Note: There is no corresponding `deregisterNGView`.
-   *       A `ui-view` should hang on to the return value of `registerNGView` and invoke it to deregister itself.
-   *
-   * @param ngView The metadata for a NGView
-   * @return a de-registration function used when the view is destroyed.
-   */
-  registerNGView(ngView: ActiveNGView): () => void;
-  /**
-   * Returns the list of views currently available on the page, by fully-qualified name.
-   *
-   * @return {Array} Returns an array of fully-qualified view names.
-   */
-  available(): any[];
-  /**
-   * Returns the list of views on the page containing loaded content.
-   *
-   * @return {Array} Returns an array of fully-qualified view names.
-   */
-  active(): any[];
-}