ember-source 4.10.0-beta.2 → 4.11.0-alpha.2

package/types/stable/@ember/routing/route.d.ts

@@ -0,0 +1,1456 @@
+declare module '@ember/routing/route.d.ts' {
+  import type Owner from '@ember/owner';
+  import { BucketCache } from '@ember/routing/-internals';
+  import EmberObject from '@ember/object';
+  import Evented from '@ember/object/evented';
+  import type { AnyFn } from '@ember/-internals/utility-types';
+  import Controller from '@ember/controller';
+  import type { Template } from '@glimmer/interfaces';
+  import type { InternalRouteInfo, Route as IRoute, Transition, TransitionState } from 'router_js';
+  import type { QueryParam } from '@ember/routing/router';
+  import EmberRouter from '@ember/routing/router';
+  import type { NamedRouteArgs, RouteArgs } from './lib/utils';
+  export interface ExtendedInternalRouteInfo<R extends Route> extends InternalRouteInfo<R> {
+      _names?: unknown[];
+  }
+  export type QueryParamMeta = {
+      qps: QueryParam[];
+      map: Record<string, QueryParam>;
+      propertyNames: string[];
+      states: {
+          inactive(prop: string, value: unknown): void;
+          active(prop: string, value: unknown): any;
+          allowOverrides(prop: string, value: unknown): any;
+      };
+  };
+  type RouteTransitionState<R extends Route> = TransitionState<R> & {
+      fullQueryParams?: Record<string, unknown>;
+      queryParamsFor?: Record<string, Record<string, unknown>>;
+  };
+  type MaybeParameters<T> = T extends AnyFn ? Parameters<T> : unknown[];
+  type MaybeReturnType<T> = T extends AnyFn ? ReturnType<T> : unknown;
+  export const ROUTE_CONNECTIONS: WeakMap<object, any>;
+  const RENDER: unique symbol;
+  /**
+  @module @ember/routing/route
+  */
+  /**
+    The `Route` class is used to define individual routes. Refer to
+    the [routing guide](https://guides.emberjs.com/release/routing/) for documentation.
+
+    @class Route
+    @extends EmberObject
+    @uses ActionHandler
+    @uses Evented
+    @since 1.0.0
+    @public
+  */
+  interface Route<T = unknown> extends IRoute<T> {
+      /**
+        The `willTransition` action is fired at the beginning of any
+        attempted transition with a `Transition` object as the sole
+        argument. This action can be used for aborting, redirecting,
+        or decorating the transition from the currently active routes.
+    
+        A good example is preventing navigation when a form is
+        half-filled out:
+    
+        ```app/routes/contact-form.js
+        import Route from '@ember/routing/route';
+        import { action } from '@ember/object';
+    
+        export default class ContactFormRoute extends Route {
+          @action
+          willTransition(transition) {
+            if (this.controller.get('userHasEnteredData')) {
+              this.controller.displayNavigationConfirm();
+              transition.abort();
+            }
+          }
+        }
+        ```
+    
+        You can also redirect elsewhere by calling
+        `this.transitionTo('elsewhere')` from within `willTransition`.
+        Note that `willTransition` will not be fired for the
+        redirecting `transitionTo`, since `willTransition` doesn't
+        fire when there is already a transition underway. If you want
+        subsequent `willTransition` actions to fire for the redirecting
+        transition, you must first explicitly call
+        `transition.abort()`.
+    
+        To allow the `willTransition` event to continue bubbling to the parent
+        route, use `return true;`. When the `willTransition` method has a
+        return value of `true` then the parent route's `willTransition` method
+        will be fired, enabling "bubbling" behavior for the event.
+    
+        @event willTransition
+        @param {Transition} transition
+        @since 1.0.0
+        @public
+      */
+      willTransition?(transition: Transition): boolean | void;
+      /**
+        The `didTransition` action is fired after a transition has
+        successfully been completed. This occurs after the normal model
+        hooks (`beforeModel`, `model`, `afterModel`, `setupController`)
+        have resolved. The `didTransition` action has no arguments,
+        however, it can be useful for tracking page views or resetting
+        state on the controller.
+    
+        ```app/routes/login.js
+        import Route from '@ember/routing/route';
+        import { action } from '@ember/object';
+    
+        export default class LoginRoute extends Route {
+          @action
+          didTransition() {
+            this.controller.get('errors.base').clear();
+            return true; // Bubble the didTransition event
+          }
+        }
+        ```
+    
+        @event didTransition
+        @since 1.2.0
+        @public
+      */
+      didTransition?(): boolean | void;
+      /**
+        The `loading` action is fired on the route when a route's `model`
+        hook returns a promise that is not already resolved. The current
+        `Transition` object is the first parameter and the route that
+        triggered the loading event is the second parameter.
+    
+        ```app/routes/application.js
+        import Route from '@ember/routing/route';
+        import { action } from '@ember/object';
+    
+        export default class ApplicationRoute extends Route {
+          @action
+          loading(transition, route) {
+            let controller = this.controllerFor('foo');
+    
+            // The controller may not be instantiated when initially loading
+            if (controller) {
+              controller.currentlyLoading = true;
+    
+              transition.finally(function() {
+                controller.currentlyLoading = false;
+              });
+            }
+          }
+        }
+        ```
+    
+        @event loading
+        @param {Transition} transition
+        @param {Route} route The route that triggered the loading event
+        @since 1.2.0
+        @public
+      */
+      loading?(transition: Transition, route: Route): boolean | void;
+      /**
+        When attempting to transition into a route, any of the hooks
+        may return a promise that rejects, at which point an `error`
+        action will be fired on the partially-entered routes, allowing
+        for per-route error handling logic, or shared error handling
+        logic defined on a parent route.
+    
+        Here is an example of an error handler that will be invoked
+        for rejected promises from the various hooks on the route,
+        as well as any unhandled errors from child routes:
+    
+        ```app/routes/admin.js
+        import { reject } from 'rsvp';
+        import Route from '@ember/routing/route';
+        import { action } from '@ember/object';
+    
+        export default class AdminRoute extends Route {
+          beforeModel() {
+            return reject('bad things!');
+          }
+    
+          @action
+          error(error, transition) {
+            // Assuming we got here due to the error in `beforeModel`,
+            // we can expect that error === "bad things!",
+            // but a promise model rejecting would also
+            // call this hook, as would any errors encountered
+            // in `afterModel`.
+    
+            // The `error` hook is also provided the failed
+            // `transition`, which can be stored and later
+            // `.retry()`d if desired.
+    
+            this.transitionTo('login');
+          }
+        }
+        ```
+    
+        `error` actions that bubble up all the way to `ApplicationRoute`
+        will fire a default error handler that logs the error. You can
+        specify your own global default error handler by overriding the
+        `error` handler on `ApplicationRoute`:
+    
+        ```app/routes/application.js
+        import Route from '@ember/routing/route';
+        import { action } from '@ember/object';
+    
+        export default class ApplicationRoute extends Route {
+          @action
+          error(error, transition) {
+            this.controllerFor('banner').displayError(error.message);
+          }
+        }
+        ```
+        @event error
+        @param {Error} error
+        @param {Transition} transition
+        @since 1.0.0
+        @public
+      */
+      error?(error: Error, transition: Transition): boolean | void;
+  }
+  const Route_base: Readonly<typeof EmberObject> & (new (owner?: Owner | undefined) => EmberObject);
+  class Route<T = unknown> extends Route_base implements IRoute, Evented {
+      static isRouteFactory: boolean;
+      context: T;
+      currentModel: T;
+      _bucketCache: BucketCache;
+      _internalName: string;
+      private _names;
+      _router: EmberRouter;
+      _topLevelViewTemplate: any;
+      _environment: any;
+      constructor(owner: Owner);
+      on: (name: string, method: ((...args: any[]) => void) | string) => this;
+      one: (name: string, method: string | ((...args: any[]) => void)) => this;
+      trigger: (name: string, ...args: any[]) => any;
+      off: (name: string, method: string | ((...args: any[]) => void)) => this;
+      has: (name: string) => boolean;
+      /**
+        A hook you can implement to convert the route's model into parameters
+        for the URL.
+    
+        ```app/router.js
+        // ...
+    
+        Router.map(function() {
+          this.route('post', { path: '/posts/:post_id' });
+        });
+    
+        ```
+    
+        ```app/routes/post.js
+        import Route from '@ember/routing/route';
+    
+        export default class PostRoute extends Route {
+          model({ post_id }) {
+            // the server returns `{ id: 12 }`
+            return fetch(`/posts/${post_id}`;
+          }
+    
+          serialize(model) {
+            // this will make the URL `/posts/12`
+            return { post_id: model.id };
+          }
+        }
+        ```
+    
+        The default `serialize` method will insert the model's `id` into the
+        route's dynamic segment (in this case, `:post_id`) if the segment contains '_id'.
+        If the route has multiple dynamic segments or does not contain '_id', `serialize`
+        will return `getProperties(model, params)`
+    
+        This method is called when `transitionTo` is called with a context
+        in order to populate the URL.
+    
+        @method serialize
+        @param {Object} model the routes model
+        @param {Array} params an Array of parameter names for the current
+          route (in the example, `['post_id']`.
+        @return {Object} the serialized parameters
+        @since 1.0.0
+        @public
+      */
+      serialize(model: T | undefined, params: string[]): {
+          [key: string]: unknown;
+      } | undefined;
+      /**
+        Configuration hash for this route's queryParams. The possible
+        configuration options and their defaults are as follows
+        (assuming a query param whose controller property is `page`):
+    
+        ```javascript
+        queryParams = {
+          page: {
+            // By default, controller query param properties don't
+            // cause a full transition when they are changed, but
+            // rather only cause the URL to update. Setting
+            // `refreshModel` to true will cause an "in-place"
+            // transition to occur, whereby the model hooks for
+            // this route (and any child routes) will re-fire, allowing
+            // you to reload models (e.g., from the server) using the
+            // updated query param values.
+            refreshModel: false,
+    
+            // By default, changes to controller query param properties
+            // cause the URL to update via `pushState`, which means an
+            // item will be added to the browser's history, allowing
+            // you to use the back button to restore the app to the
+            // previous state before the query param property was changed.
+            // Setting `replace` to true will use `replaceState` (or its
+            // hash location equivalent), which causes no browser history
+            // item to be added. This options name and default value are
+            // the same as the `link-to` helper's `replace` option.
+            replace: false,
+    
+            // By default, the query param URL key is the same name as
+            // the controller property name. Use `as` to specify a
+            // different URL key.
+            as: 'page'
+          }
+        };
+        ```
+    
+        @property queryParams
+        @for Route
+        @type Object
+        @since 1.6.0
+        @public
+      */
+      queryParams: Record<string, {
+          refreshModel?: boolean;
+          replace?: boolean;
+          as?: string;
+      }>;
+      /**
+        The name of the template to use by default when rendering this route's
+        template.
+    
+        ```app/routes/posts/list.js
+        import Route from '@ember/routing/route';
+    
+        export default class PostsListRoute extends Route {
+          templateName = 'posts/list';
+        }
+        ```
+    
+        ```app/routes/posts/index.js
+        import PostsListRoute from '../posts/list';
+    
+        export default class PostsIndexRoute extends PostsListRoute {};
+        ```
+    
+        ```app/routes/posts/archived.js
+        import PostsListRoute from '../posts/list';
+    
+        export default class PostsArchivedRoute extends PostsListRoute {};
+        ```
+    
+        @property templateName
+        @type String
+        @default null
+        @since 1.4.0
+        @public
+      */
+      templateName: string | null;
+      /**
+        The name of the controller to associate with this route.
+    
+        By default, Ember will lookup a route's controller that matches the name
+        of the route (i.e. `posts.new`). However,
+        if you would like to define a specific controller to use, you can do so
+        using this property.
+    
+        This is useful in many ways, as the controller specified will be:
+    
+        * passed to the `setupController` method.
+        * used as the controller for the template being rendered by the route.
+        * returned from a call to `controllerFor` for the route.
+    
+        @property controllerName
+        @type String
+        @default null
+        @since 1.4.0
+        @public
+      */
+      controllerName: string | null;
+      /**
+        The controller associated with this route.
+    
+        Example
+    
+        ```app/routes/form.js
+        import Route from '@ember/routing/route';
+        import { action } from '@ember/object';
+    
+        export default class FormRoute extends Route {
+          @action
+          willTransition(transition) {
+            if (this.controller.get('userHasEnteredData') &&
+                !confirm('Are you sure you want to abandon progress?')) {
+              transition.abort();
+            } else {
+              // Bubble the `willTransition` action so that
+              // parent routes can decide whether or not to abort.
+              return true;
+            }
+          }
+        }
+        ```
+    
+        @property controller
+        @type Controller
+        @since 1.6.0
+        @public
+      */
+      controller: Controller;
+      /**
+        The name of the route, dot-delimited.
+    
+        For example, a route found at `app/routes/posts/post.js` will have
+        a `routeName` of `posts.post`.
+    
+        @property routeName
+        @for Route
+        @type String
+        @since 1.0.0
+        @public
+      */
+      routeName: string;
+      /**
+        The name of the route, dot-delimited, including the engine prefix
+        if applicable.
+    
+        For example, a route found at `addon/routes/posts/post.js` within an
+        engine named `admin` will have a `fullRouteName` of `admin.posts.post`.
+    
+        @property fullRouteName
+        @for Route
+        @type String
+        @since 2.10.0
+        @public
+      */
+      fullRouteName: string;
+      /**
+        Sets the name for this route, including a fully resolved name for routes
+        inside engines.
+    
+        @private
+        @method _setRouteName
+        @param {String} name
+      */
+      _setRouteName(name: string): void;
+      /**
+        @private
+    
+        @method _stashNames
+      */
+      _stashNames(routeInfo: ExtendedInternalRouteInfo<this>, dynamicParent: ExtendedInternalRouteInfo<this>): void;
+      /**
+        @private
+    
+        @property _activeQPChanged
+      */
+      _activeQPChanged(qp: QueryParam, value: unknown): void;
+      /**
+        @private
+        @method _updatingQPChanged
+      */
+      _updatingQPChanged(qp: QueryParam): void;
+      /**
+        Returns a hash containing the parameters of an ancestor route.
+    
+        You may notice that `this.paramsFor` sometimes works when referring to a
+        child route, but this behavior should not be relied upon as only ancestor
+        routes are certain to be loaded in time.
+    
+        Example
+    
+        ```app/router.js
+        // ...
+    
+        Router.map(function() {
+          this.route('member', { path: ':name' }, function() {
+            this.route('interest', { path: ':interest' });
+          });
+        });
+        ```
+    
+        ```app/routes/member.js
+        import Route from '@ember/routing/route';
+    
+        export default class MemberRoute extends Route {
+          queryParams = {
+            memberQp: { refreshModel: true }
+          }
+        }
+        ```
+    
+        ```app/routes/member/interest.js
+        import Route from '@ember/routing/route';
+    
+        export default class MemberInterestRoute extends Route {
+          queryParams = {
+            interestQp: { refreshModel: true }
+          }
+    
+          model() {
+            return this.paramsFor('member');
+          }
+        }
+        ```
+    
+        If we visit `/turing/maths?memberQp=member&interestQp=interest` the model for
+        the `member.interest` route is a hash with:
+    
+        * `name`: `turing`
+        * `memberQp`: `member`
+    
+        @method paramsFor
+        @param {String} name
+        @return {Object} hash containing the parameters of the route `name`
+        @since 1.4.0
+        @public
+      */
+      paramsFor(name: string): Record<string, unknown>;
+      /**
+        Serializes the query parameter key
+    
+        @method serializeQueryParamKey
+        @param {String} controllerPropertyName
+        @private
+      */
+      serializeQueryParamKey(controllerPropertyName: string): string;
+      /**
+        Serializes value of the query parameter based on defaultValueType
+    
+        @method serializeQueryParam
+        @param {Object} value
+        @param {String} urlKey
+        @param {String} defaultValueType
+        @private
+      */
+      serializeQueryParam(value: unknown, _urlKey: string, defaultValueType: string): string | null | undefined;
+      /**
+        Deserializes value of the query parameter based on defaultValueType
+    
+        @method deserializeQueryParam
+        @param {Object} value
+        @param {String} urlKey
+        @param {String} defaultValueType
+        @private
+      */
+      deserializeQueryParam(value: unknown, _urlKey: string, defaultValueType: string): {} | null | undefined;
+      /**
+        @private
+    
+        @property _optionsForQueryParam
+      */
+      _optionsForQueryParam(qp: QueryParam): {};
+      /**
+        A hook you can use to reset controller values either when the model
+        changes or the route is exiting.
+    
+        ```app/routes/articles.js
+        import Route from '@ember/routing/route';
+    
+        export default class ArticlesRoute extends Route {
+          resetController(controller, isExiting, transition) {
+            if (isExiting && transition.targetName !== 'error') {
+              controller.set('page', 1);
+            }
+          }
+        }
+        ```
+    
+        @method resetController
+        @param {Controller} controller instance
+        @param {Boolean} isExiting
+        @param {Object} transition
+        @since 1.7.0
+        @public
+      */
+      resetController(_controller: Controller, _isExiting: boolean, _transition: Transition): this;
+      /**
+        @private
+    
+        @method exit
+      */
+      exit(transition?: Transition): void;
+      /**
+        @private
+    
+        @method _internalReset
+        @since 3.6.0
+      */
+      _internalReset(isExiting: boolean, transition: Transition): void;
+      /**
+        @private
+    
+        @method enter
+      */
+      enter(transition: Transition): void;
+      /**
+        This event is triggered when the router enters the route. It is
+        not executed when the model for the route changes.
+    
+        ```app/routes/application.js
+        import { on } from '@ember/object/evented';
+        import Route from '@ember/routing/route';
+    
+        export default Route.extend({
+          collectAnalytics: on('activate', function(){
+            collectAnalytics();
+          })
+        });
+        ```
+    
+        @event activate
+        @since 1.9.0
+        @public
+      */
+      /**
+        This event is triggered when the router completely exits this
+        route. It is not executed when the model for the route changes.
+    
+        ```app/routes/index.js
+        import { on } from '@ember/object/evented';
+        import Route from '@ember/routing/route';
+    
+        export default Route.extend({
+          trackPageLeaveAnalytics: on('deactivate', function(){
+            trackPageLeaveAnalytics();
+          })
+        });
+        ```
+    
+        @event deactivate
+        @since 1.9.0
+        @public
+      */
+      /**
+        This hook is executed when the router completely exits this route. It is
+        not executed when the model for the route changes.
+    
+        @method deactivate
+        @param {Transition} transition
+        @since 1.0.0
+        @public
+      */
+      deactivate(_transition?: Transition): void;
+      /**
+        This hook is executed when the router enters the route. It is not executed
+        when the model for the route changes.
+    
+        @method activate
+        @param {Transition} transition
+        @since 1.0.0
+        @public
+      */
+      activate(_transition: Transition): void;
+      /**
+        Transition the application into another route. The route may
+        be either a single route or route path:
+    
+        ```javascript
+        this.transitionTo('blogPosts');
+        this.transitionTo('blogPosts.recentEntries');
+        ```
+    
+        Optionally supply a model for the route in question. The model
+        will be serialized into the URL using the `serialize` hook of
+        the route:
+    
+        ```javascript
+        this.transitionTo('blogPost', aPost);
+        ```
+    
+        If a literal is passed (such as a number or a string), it will
+        be treated as an identifier instead. In this case, the `model`
+        hook of the route will be triggered:
+    
+        ```javascript
+        this.transitionTo('blogPost', 1);
+        ```
+    
+        Multiple models will be applied last to first recursively up the
+        route tree.
+    
+        ```app/routes.js
+        // ...
+    
+        Router.map(function() {
+          this.route('blogPost', { path:':blogPostId' }, function() {
+            this.route('blogComment', { path: ':blogCommentId' });
+          });
+        });
+    
+        export default Router;
+        ```
+    
+        ```javascript
+        this.transitionTo('blogComment', aPost, aComment);
+        this.transitionTo('blogComment', 1, 13);
+        ```
+    
+        It is also possible to pass a URL (a string that starts with a
+        `/`).
+    
+        ```javascript
+        this.transitionTo('/');
+        this.transitionTo('/blog/post/1/comment/13');
+        this.transitionTo('/blog/posts?sort=title');
+        ```
+    
+        An options hash with a `queryParams` property may be provided as
+        the final argument to add query parameters to the destination URL.
+    
+        ```javascript
+        this.transitionTo('blogPost', 1, {
+          queryParams: { showComments: 'true' }
+        });
+    
+        // if you just want to transition the query parameters without changing the route
+        this.transitionTo({ queryParams: { sort: 'date' } });
+        ```
+    
+        See also [replaceWith](#method_replaceWith).
+    
+        Simple Transition Example
+    
+        ```app/routes.js
+        // ...
+    
+        Router.map(function() {
+          this.route('index');
+          this.route('secret');
+          this.route('fourOhFour', { path: '*:' });
+        });
+    
+        export default Router;
+        ```
+    
+        ```app/routes/index.js
+        import Route from '@ember/routing/route';
+        import { action } from '@ember/object';
+    
+        export default class IndexRoute extends Route {
+          @action
+          moveToSecret(context) {
+            if (authorized()) {
+              this.transitionTo('secret', context);
+            } else {
+              this.transitionTo('fourOhFour');
+            }
+          }
+        }
+        ```
+    
+        Transition to a nested route
+    
+        ```app/router.js
+        // ...
+    
+        Router.map(function() {
+          this.route('articles', { path: '/articles' }, function() {
+            this.route('new');
+          });
+        });
+    
+        export default Router;
+        ```
+    
+        ```app/routes/index.js
+        import Route from '@ember/routing/route';
+        import { action } from '@ember/object';
+    
+        export default class IndexRoute extends Route {
+          @action
+          transitionToNewArticle() {
+            this.transitionTo('articles.new');
+          }
+        }
+        ```
+    
+        Multiple Models Example
+    
+        ```app/router.js
+        // ...
+    
+        Router.map(function() {
+          this.route('index');
+    
+          this.route('breakfast', { path: ':breakfastId' }, function() {
+            this.route('cereal', { path: ':cerealId' });
+          });
+        });
+    
+        export default Router;
+        ```
+    
+        ```app/routes/index.js
+        import Route from '@ember/routing/route';
+        import { action } from '@ember/object';
+    
+        export default class IndexRoute extends Route {
+          @action
+          moveToChocolateCereal() {
+            let cereal = { cerealId: 'ChocolateYumminess' };
+            let breakfast = { breakfastId: 'CerealAndMilk' };
+    
+            this.transitionTo('breakfast.cereal', breakfast, cereal);
+          }
+        }
+        ```
+    
+        Nested Route with Query String Example
+    
+        ```app/routes.js
+        // ...
+    
+        Router.map(function() {
+          this.route('fruits', function() {
+            this.route('apples');
+          });
+        });
+    
+        export default Router;
+        ```
+    
+        ```app/routes/index.js
+        import Route from '@ember/routing/route';
+    
+        export default class IndexRoute extends Route {
+          @action
+          transitionToApples() {
+            this.transitionTo('fruits.apples', { queryParams: { color: 'red' } });
+          }
+        }
+        ```
+    
+        @method transitionTo
+        @param {String} [name] the name of the route or a URL.
+        @param {...Object} [models] the model(s) or identifier(s) to be used while
+          transitioning to the route.
+        @param {Object} [options] optional hash with a queryParams property
+          containing a mapping of query parameters. May be supplied as the only
+          parameter to trigger a query-parameter-only transition.
+        @return {Transition} the transition object associated with this
+          attempted transition
+        @since 1.0.0
+        @deprecated Use transitionTo from the Router service instead.
+        @public
+      */
+      transitionTo(...args: RouteArgs<this>): Transition;
+      /**
+        Perform a synchronous transition into another route without attempting
+        to resolve promises, update the URL, or abort any currently active
+        asynchronous transitions (i.e. regular transitions caused by
+        `transitionTo` or URL changes).
+    
+        This method is handy for performing intermediate transitions on the
+        way to a final destination route, and is called internally by the
+        default implementations of the `error` and `loading` handlers.
+    
+        @method intermediateTransitionTo
+        @param {String} name the name of the route
+        @param {...Object} models the model(s) to be used while transitioning
+        to the route.
+        @since 1.2.0
+        @public
+       */
+      intermediateTransitionTo(...args: NamedRouteArgs<this>): void;
+      /**
+        Refresh the model on this route and any child routes, firing the
+        `beforeModel`, `model`, and `afterModel` hooks in a similar fashion
+        to how routes are entered when transitioning in from other route.
+        The current route params (e.g. `article_id`) will be passed in
+        to the respective model hooks, and if a different model is returned,
+        `setupController` and associated route hooks will re-fire as well.
+    
+        An example usage of this method is re-querying the server for the
+        latest information using the same parameters as when the route
+        was first entered.
+    
+        Note that this will cause `model` hooks to fire even on routes
+        that were provided a model object when the route was initially
+        entered.
+    
+        @method refresh
+        @return {Transition} the transition object associated with this
+          attempted transition
+        @since 1.4.0
+        @public
+       */
+      refresh(): Transition;
+      /**
+        Transition into another route while replacing the current URL, if possible.
+        This will replace the current history entry instead of adding a new one.
+        Beside that, it is identical to `transitionTo` in all other respects. See
+        'transitionTo' for additional information regarding multiple models.
+    
+        Example
+    
+        ```app/router.js
+        // ...
+    
+        Router.map(function() {
+          this.route('index');
+          this.route('secret');
+        });
+    
+        export default Router;
+        ```
+    
+        ```app/routes/secret.js
+        import Route from '@ember/routing/route';
+    
+        export default class SecretRoute Route {
+          afterModel() {
+            if (!authorized()){
+              this.replaceWith('index');
+            }
+          }
+        }
+        ```
+    
+        @method replaceWith
+        @param {String} name the name of the route or a URL
+        @param {...Object} models the model(s) or identifier(s) to be used while
+          transitioning to the route.
+        @param {Object} [options] optional hash with a queryParams property
+          containing a mapping of query parameters
+        @return {Transition} the transition object associated with this
+          attempted transition
+        @since 1.0.0
+        @deprecated Use replaceWith from the Router service instead.
+        @public
+      */
+      replaceWith(...args: any[]): Transition;
+      /**
+        This hook is the entry point for router.js
+    
+        @private
+        @method setup
+      */
+      setup(context: T | undefined, transition: Transition): void;
+      _qpChanged(prop: string, value: unknown, qp: QueryParam): void;
+      /**
+        This hook is the first of the route entry validation hooks
+        called when an attempt is made to transition into a route
+        or one of its children. It is called before `model` and
+        `afterModel`, and is appropriate for cases when:
+    
+        1) A decision can be made to redirect elsewhere without
+           needing to resolve the model first.
+        2) Any async operations need to occur first before the
+           model is attempted to be resolved.
+    
+        This hook is provided the current `transition` attempt
+        as a parameter, which can be used to `.abort()` the transition,
+        save it for a later `.retry()`, or retrieve values set
+        on it from a previous hook. You can also just call
+        `this.transitionTo` to another route to implicitly
+        abort the `transition`.
+    
+        You can return a promise from this hook to pause the
+        transition until the promise resolves (or rejects). This could
+        be useful, for instance, for retrieving async code from
+        the server that is required to enter a route.
+    
+        @method beforeModel
+        @param {Transition} transition
+        @return {any | Promise<any>} if the value returned from this hook is
+          a promise, the transition will pause until the transition
+          resolves. Otherwise, non-promise return values are not
+          utilized in any way.
+        @since 1.0.0
+        @public
+      */
+      beforeModel(_transition: Transition): unknown | Promise<unknown>;
+      /**
+        This hook is called after this route's model has resolved.
+        It follows identical async/promise semantics to `beforeModel`
+        but is provided the route's resolved model in addition to
+        the `transition`, and is therefore suited to performing
+        logic that can only take place after the model has already
+        resolved.
+    
+        ```app/routes/posts.js
+        import Route from '@ember/routing/route';
+    
+        export default class PostsRoute extends Route {
+          afterModel(posts, transition) {
+            if (posts.get('length') === 1) {
+              this.transitionTo('post.show', posts.get('firstObject'));
+            }
+          }
+        }
+        ```
+    
+        Refer to documentation for `beforeModel` for a description
+        of transition-pausing semantics when a promise is returned
+        from this hook.
+    
+        @method afterModel
+        @param {Object} resolvedModel the value returned from `model`,
+          or its resolved value if it was a promise
+        @param {Transition} transition
+        @return {any | Promise<any>} if the value returned from this hook is
+          a promise, the transition will pause until the transition
+          resolves. Otherwise, non-promise return values are not
+          utilized in any way.
+        @since 1.0.0
+        @public
+       */
+      afterModel(_resolvedModel: T | undefined, _transition: Transition): unknown | Promise<unknown>;
+      /**
+        A hook you can implement to optionally redirect to another route.
+    
+        Calling `this.transitionTo` from inside of the `redirect` hook will
+        abort the current transition (into the route that has implemented `redirect`).
+    
+        `redirect` and `afterModel` behave very similarly and are
+        called almost at the same time, but they have an important
+        distinction when calling `this.transitionTo` to a child route
+        of the current route. From `afterModel`, this new transition
+        invalidates the current transition, causing `beforeModel`,
+        `model`, and `afterModel` hooks to be called again. But the
+        same transition started from `redirect` does _not_ invalidate
+        the current transition. In other words, by the time the `redirect`
+        hook has been called, both the resolved model and the attempted
+        entry into this route are considered fully validated.
+    
+        @method redirect
+        @param {Object} model the model for this route
+        @param {Transition} transition the transition object associated with the current transition
+        @since 1.0.0
+        @public
+      */
+      redirect(_model: T, _transition: Transition): void;
+      /**
+        Called when the context is changed by router.js.
+    
+        @private
+        @method contextDidChange
+      */
+      contextDidChange(): void;
+      /**
+        A hook you can implement to convert the URL into the model for
+        this route.
+    
+        ```app/router.js
+        // ...
+    
+        Router.map(function() {
+          this.route('post', { path: '/posts/:post_id' });
+        });
+    
+        export default Router;
+        ```
+    
+        The model for the `post` route is `store.findRecord('post', params.post_id)`.
+    
+        By default, if your route has a dynamic segment ending in `_id`:
+    
+        * The model class is determined from the segment (`post_id`'s
+          class is `App.Post`)
+        * The find method is called on the model class with the value of
+          the dynamic segment.
+    
+        Note that for routes with dynamic segments, this hook is not always
+        executed. If the route is entered through a transition (e.g. when
+        using the `link-to` Handlebars helper or the `transitionTo` method
+        of routes), and a model context is already provided this hook
+        is not called.
+    
+        A model context does not include a primitive string or number,
+        which does cause the model hook to be called.
+    
+        Routes without dynamic segments will always execute the model hook.
+    
+        ```javascript
+        // no dynamic segment, model hook always called
+        this.transitionTo('posts');
+    
+        // model passed in, so model hook not called
+        thePost = store.findRecord('post', 1);
+        this.transitionTo('post', thePost);
+    
+        // integer passed in, model hook is called
+        this.transitionTo('post', 1);
+    
+        // model id passed in, model hook is called
+        // useful for forcing the hook to execute
+        thePost = store.findRecord('post', 1);
+        this.transitionTo('post', thePost.id);
+        ```
+    
+        This hook follows the asynchronous/promise semantics
+        described in the documentation for `beforeModel`. In particular,
+        if a promise returned from `model` fails, the error will be
+        handled by the `error` hook on `Route`.
+    
+        Example
+    
+        ```app/routes/post.js
+        import Route from '@ember/routing/route';
+    
+        export default class PostRoute extends Route {
+          model(params) {
+            return this.store.findRecord('post', params.post_id);
+          }
+        }
+        ```
+    
+        @method model
+        @param {Object} params the parameters extracted from the URL
+        @param {Transition} transition
+        @return {any | Promise<any>} the model for this route. If
+          a promise is returned, the transition will pause until
+          the promise resolves, and the resolved value of the promise
+          will be used as the model for this route.
+        @since 1.0.0
+        @public
+      */
+      model(params: Record<string, unknown>, transition: Transition): T | PromiseLike<T> | undefined;
+      /**
+        @private
+        @method deserialize
+        @param {Object} params the parameters extracted from the URL
+        @param {Transition} transition
+        @return {any | Promise<any>} the model for this route.
+    
+        Router.js hook.
+       */
+      deserialize(_params: {}, transition: Transition): T | PromiseLike<T> | undefined;
+      /**
+    
+        @method findModel
+        @param {String} type the model type
+        @param {Object} value the value passed to find
+        @private
+      */
+      findModel(...args: any[]): any;
+      /**
+        A hook you can use to setup the controller for the current route.
+    
+        This method is called with the controller for the current route and the
+        model supplied by the `model` hook.
+    
+        By default, the `setupController` hook sets the `model` property of
+        the controller to the specified `model` when it is not `undefined`.
+    
+        If you implement the `setupController` hook in your Route, it will
+        prevent this default behavior. If you want to preserve that behavior
+        when implementing your `setupController` function, make sure to call
+        `super`:
+    
+        ```app/routes/photos.js
+        import Route from '@ember/routing/route';
+    
+        export default class PhotosRoute extends Route {
+          model() {
+            return this.store.findAll('photo');
+          }
+    
+          setupController(controller, model) {
+            super.setupController(controller, model);
+    
+            this.controllerFor('application').set('showingPhotos', true);
+          }
+        }
+        ```
+    
+        The provided controller will be one resolved based on the name
+        of this route.
+    
+        If no explicit controller is defined, Ember will automatically create one.
+    
+        As an example, consider the router:
+    
+        ```app/router.js
+        // ...
+    
+        Router.map(function() {
+          this.route('post', { path: '/posts/:post_id' });
+        });
+    
+        export default Router;
+        ```
+    
+        If you have defined a file for the post controller,
+        the framework will use it.
+        If it is not defined, a basic `Controller` instance would be used.
+    
+        @example Behavior of a basic Controller
+    
+        ```app/routes/post.js
+        import Route from '@ember/routing/route';
+    
+        export default class PostRoute extends Route {
+          setupController(controller, model) {
+            controller.set('model', model);
+          }
+        });
+        ```
+    
+        @method setupController
+        @param {Controller} controller instance
+        @param {Object} model
+        @param {Transition} [transition]
+        @since 1.0.0
+        @public
+      */
+      setupController(controller: Controller, context: T | undefined, _transition?: Transition): void;
+      /**
+        Returns the controller of the current route, or a parent (or any ancestor)
+        route in a route hierarchy.
+    
+        The controller instance must already have been created, either through entering the
+        associated route or using `generateController`.
+    
+        ```app/routes/post.js
+        import Route from '@ember/routing/route';
+    
+        export default class PostRoute extends Route {
+          setupController(controller, post) {
+            super.setupController(controller, post);
+    
+            this.controllerFor('posts').set('currentPost', post);
+          }
+        }
+        ```
+    
+        @method controllerFor
+        @param {String} name the name of the route or controller
+        @return {Controller | undefined}
+        @since 1.0.0
+        @public
+      */
+      controllerFor(name: string, _skipAssert: true): Controller | undefined;
+      controllerFor(name: string, _skipAssert?: false): Controller;
+      /**
+        Generates a controller for a route.
+    
+        Example
+    
+        ```app/routes/post.js
+        import Route from '@ember/routing/route';
+    
+        export default class Post extends Route {
+          setupController(controller, post) {
+            super.setupController(controller, post);
+    
+            this.generateController('posts');
+          }
+        }
+        ```
+    
+        @method generateController
+        @param {String} name the name of the controller
+        @private
+      */
+      generateController(name: string): Controller<unknown>;
+      /**
+        Returns the resolved model of a parent (or any ancestor) route
+        in a route hierarchy.  During a transition, all routes
+        must resolve a model object, and if a route
+        needs access to a parent route's model in order to
+        resolve a model (or just reuse the model from a parent),
+        it can call `this.modelFor(theNameOfParentRoute)` to
+        retrieve it. If the ancestor route's model was a promise,
+        its resolved result is returned.
+    
+        Example
+    
+        ```app/router.js
+        // ...
+    
+        Router.map(function() {
+          this.route('post', { path: '/posts/:post_id' }, function() {
+            this.route('comments');
+          });
+        });
+    
+        export default Router;
+        ```
+    
+        ```app/routes/post/comments.js
+        import Route from '@ember/routing/route';
+    
+        export default class PostCommentsRoute extends Route {
+          model() {
+            let post = this.modelFor('post');
+    
+            return post.comments;
+          }
+        }
+        ```
+    
+        @method modelFor
+        @param {String} name the name of the route
+        @return {Object} the model object
+        @since 1.0.0
+        @public
+      */
+      modelFor(_name: string): unknown | undefined;
+      /**
+        `this[RENDER]` is used to render a template into a region of another template
+        (indicated by an `{{outlet}}`).
+    
+        @method this[RENDER]
+        @param {String} name the name of the template to render
+        @param {Object} [options] the options
+        @param {String} [options.into] the template to render into,
+                        referenced by name. Defaults to the parent template
+        @param {String} [options.outlet] the outlet inside `options.into` to render into.
+                        Defaults to 'main'
+        @param {String|Object} [options.controller] the controller to use for this template,
+                        referenced by name or as a controller instance. Defaults to the Route's paired controller
+        @param {Object} [options.model] the model object to set on `options.controller`.
+                        Defaults to the return value of the Route's model hook
+        @private
+       */
+      [RENDER](name?: string, options?: PartialRenderOptions): void;
+      willDestroy(): void;
+      /**
+        @private
+    
+        @method teardownViews
+      */
+      teardownViews(): void;
+      /**
+        Allows you to produce custom metadata for the route.
+        The return value of this method will be attached to
+        its corresponding RouteInfoWithAttributes object.
+    
+        Example
+    
+        ```app/routes/posts/index.js
+        import Route from '@ember/routing/route';
+    
+        export default class PostsIndexRoute extends Route {
+          buildRouteInfoMetadata() {
+            return { title: 'Posts Page' }
+          }
+        }
+        ```
+    
+        ```app/routes/application.js
+        import Route from '@ember/routing/route';
+        import { service } from '@ember/service';
+    
+        export default class ApplicationRoute extends Route {
+          @service router
+    
+          constructor() {
+            super(...arguments);
+    
+            this.router.on('routeDidChange', transition => {
+              document.title = transition.to.metadata.title;
+              // would update document's title to "Posts Page"
+            });
+          }
+        }
+        ```
+        @method buildRouteInfoMetadata
+        @return any
+        @since 3.10.0
+        @public
+       */
+      buildRouteInfoMetadata(): unknown;
+      private _paramsFor;
+      /**
+        Store property provides a hook for data persistence libraries to inject themselves.
+    
+        By default, this store property provides the exact same functionality previously
+        in the model hook.
+    
+        Currently, the required interface is:
+    
+        `store.find(modelName, findArguments)`
+    
+        @property store
+        @type {Object}
+        @private
+      */
+      protected get store(): any;
+      protected set store(value: any);
+      /**
+        @private
+        @property _qp
+        */
+      protected get _qp(): QueryParamMeta;
+      actions: Record<string, AnyFn>;
+      /**
+        Sends an action to the router, which will delegate it to the currently
+        active route hierarchy per the bubbling rules explained under `actions`.
+    
+        Example
+    
+        ```app/router.js
+        // ...
+    
+        Router.map(function() {
+          this.route('index');
+        });
+    
+        export default Router;
+        ```
+    
+        ```app/routes/application.js
+        import Route from '@ember/routing/route';
+        import { action } from '@ember/object';
+    
+        export default class ApplicationRoute extends Route {
+          @action
+          track(arg) {
+            console.log(arg, 'was clicked');
+          }
+        }
+        ```
+    
+        ```app/routes/index.js
+        import Route from '@ember/routing/route';
+        import { action } from '@ember/object';
+    
+        export default class IndexRoute extends Route {
+          @action
+          trackIfDebug(arg) {
+            if (debug) {
+              this.send('track', arg);
+            }
+          }
+        }
+        ```
+    
+        @method send
+        @param {String} name the name of the action to trigger
+        @param {...*} args
+        @since 1.0.0
+        @public
+      */
+      send: <K extends keyof this | keyof this['actions']>(name: K, ...args: MaybeParameters<K extends keyof this ? this[K] : K extends keyof this['actions'] ? this['actions'][K] : never>) => MaybeReturnType<K extends keyof this ? this[K] : K extends keyof this['actions'] ? this['actions'][K] : never>;
+  }
+  export interface RenderOptions {
+      owner: Owner;
+      into?: string;
+      outlet: string;
+      name: string;
+      controller: Controller | string | undefined;
+      model: unknown;
+      template: Template;
+  }
+  type PartialRenderOptions = Partial<Pick<RenderOptions, 'into' | 'outlet' | 'controller' | 'model'>>;
+  export function getFullQueryParams<R extends Route>(router: EmberRouter<R>, state: RouteTransitionState<R>): Record<string, unknown>;
+  const defaultSerialize: (model: any, params: string[]) => {
+      [key: string]: unknown;
+  } | undefined;
+  export { defaultSerialize };
+  export function hasDefaultSerialize(route: Route): boolean;
+  export default Route;
+}