docs(api): initial auto generated version of docs

still needs to be re organized, but it is a nice base using api-docs-gen :)

diff --git a/docs/api/index.md b/docs/api/index.md
new file mode 100644 (file)
index 0000000..8d136ed
--- /dev/null
+++ b/docs/api/index.md
@@ -0,0 +1,7 @@
+# API Reference
+
+- [Components](./vue-router-variable.md)
+- [Enumerations](./vue-router-enum.md)
+- [Functions](./vue-router-function.md)
+- [Interfaces](./vue-router-interface.md)
+- [Types](./vue-router-typealias.md)

diff --git a/docs/api/vue-router-enum.md b/docs/api/vue-router-enum.md
new file mode 100644 (file)
index 0000000..683c72f
--- /dev/null
+++ b/docs/api/vue-router-enum.md
@@ -0,0 +1,19 @@
+# Enum
+
+## NavigationFailureType
+
+Enumeration with all possible types for navigation failures. Can be passed to  to check for specific failures.
+
+**Signature:**
+```typescript
+export declare enum NavigationFailureType 
+```
+
+### Members
+
+| Member | Value| Description |
+| --- | --- | --- |
+| aborted | 4 | An aborted navigation is a navigation that failed because a navigation guard returned `false` or called `next(false)` |
+| cancelled | 8 | A cancelled navigation is a navigation that failed because a more recent navigation finished started (not necessarily finished). |
+| duplicated | 16 | A duplicated navigation is a navigation that failed because it was initiated while already being at the exact same location. |
+

diff --git a/docs/api/vue-router-function.md b/docs/api/vue-router-function.md
new file mode 100644 (file)
index 0000000..379984a
--- /dev/null
+++ b/docs/api/vue-router-function.md
@@ -0,0 +1,149 @@
+# Function
+
+## createMemoryHistory
+
+Creates a in-memory based history. The main purpose of this history is to handle SSR. It starts in a special location that is nowhere. It's up to the user to replace that location with the starter location.
+
+**Signature:**
+```typescript
+export declare function createMemoryHistory(base?: string): RouterHistory;
+```
+
+### Parameters
+
+| Parameter | Type | Description |
+| --- | --- | --- |
+| base | string | Base applied to all urls, defaults to '/' |
+
+### Returns
+
+ a history object that can be passed to the router constructor
+
+## createRouter
+
+Create a Router instance that can be used on a Vue app.
+
+**Signature:**
+```typescript
+export declare function createRouter(options: RouterOptions): Router;
+```
+
+### Parameters
+
+| Parameter | Type | Description |
+| --- | --- | --- |
+| options | RouterOptions | [RouterOptions](./vue-router-interface#routeroptions) |
+
+## createWebHashHistory
+
+Creates a hash history.
+
+**Signature:**
+```typescript
+export declare function createWebHashHistory(base?: string): RouterHistory;
+```
+
+### Parameters
+
+| Parameter | Type | Description |
+| --- | --- | --- |
+| base | string | optional base to provide. Defaults to `location.pathname` or `/` if at root. If there is a `base` tag in the `head`, its value will be **ignored**. |
+
+### Examples
+
+
+```js
+// at https://example.com/folder
+createWebHashHistory() // gives a url of `https://example.com/folder#`
+createWebHashHistory('/folder/') // gives a url of `https://example.com/folder/#`
+// if the `#` is provided in the base, it won't be added by `createWebHashHistory`
+createWebHashHistory('/folder/#/app/') // gives a url of `https://example.com/folder/#/app/`
+// you should avoid doing this because it changes the original url and breaks copying urls
+createWebHashHistory('/other-folder/') // gives a url of `https://example.com/other-folder/#`
+
+// at file:///usr/etc/folder/index.html
+// for locations with no `host`, the base is ignored
+createWebHashHistory('/iAmIgnored') // gives a url of `file:///usr/etc/folder/index.html#`
+```
+
+
+## createWebHistory
+
+## isNavigationFailure
+
+## isNavigationFailure
+
+## onBeforeRouteLeave
+
+Add a navigation guard that triggers whenever the component for the current location is about to be left. Similar to  but can be used in any component. The guard is removed when the component is unmounted.
+
+**Signature:**
+```typescript
+export declare function onBeforeRouteLeave(leaveGuard: NavigationGuard): void;
+```
+
+### Parameters
+
+| Parameter | Type | Description |
+| --- | --- | --- |
+| leaveGuard | NavigationGuard | [NavigationGuard](./vue-router-interface#navigationguard) |
+
+## onBeforeRouteUpdate
+
+Add a navigation guard that triggers whenever the current location is about to be updated. Similar to  but can be used in any component. The guard is removed when the component is unmounted.
+
+**Signature:**
+```typescript
+export declare function onBeforeRouteUpdate(updateGuard: NavigationGuard): void;
+```
+
+### Parameters
+
+| Parameter | Type | Description |
+| --- | --- | --- |
+| updateGuard | NavigationGuard | [NavigationGuard](./vue-router-interface#navigationguard) |
+
+## parseQuery
+
+Transforms a queryString into a [LocationQuery](./vue-router-typealias#locationquery) object. Accept both, a version with the leading `?` and without Should work as URLSearchParams
+
+**Signature:**
+```typescript
+export declare function parseQuery(search: string): LocationQuery;
+```
+
+### Parameters
+
+| Parameter | Type | Description |
+| --- | --- | --- |
+| search | string | search string to parse |
+
+### Returns
+
+ a query object
+
+## stringifyQuery
+
+Stringifies a [LocationQueryRaw](./vue-router-typealias#locationqueryraw) object. Like `URLSearchParams`, it doesn't prepend a `?`
+
+**Signature:**
+```typescript
+export declare function stringifyQuery(query: LocationQueryRaw): string;
+```
+
+### Parameters
+
+| Parameter | Type | Description |
+| --- | --- | --- |
+| query | LocationQueryRaw | query object to stringify |
+
+### Returns
+
+ string version of the query without the leading `?`
+
+## useLink
+
+## useRoute
+
+## useRouter
+

diff --git a/docs/api/vue-router-interface.md b/docs/api/vue-router-interface.md
new file mode 100644 (file)
index 0000000..1b5a9b9
--- /dev/null
+++ b/docs/api/vue-router-interface.md
@@ -0,0 +1,779 @@
+# Interface
+
+## NavigationFailure
+
+Extended Error that contains extra information regarding a failed navigation.
+
+**Signature:**
+```typescript
+export interface NavigationFailure extends RouterErrorBase 
+```
+
+
+### Methods
+
+
+### Properties
+
+#### from
+
+Route location we were navigating from
+
+**Signature:**
+```typescript
+from: RouteLocationNormalized;
+```
+
+#### to
+
+Route location we were navigating to
+
+**Signature:**
+```typescript
+to: RouteLocationNormalized;
+```
+
+#### type
+
+Type of the navigation. One of [NavigationFailureType](./vue-router-enum#navigationfailuretype)
+
+**Signature:**
+```typescript
+type: ErrorTypes.NAVIGATION_CANCELLED | ErrorTypes.NAVIGATION_ABORTED | ErrorTypes.NAVIGATION_DUPLICATED;
+```
+
+
+## NavigationGuard
+
+Navigation guard. See [Navigation Guards](/guide/advanced/navigation-guards.md).
+
+**Signature:**
+```typescript
+export interface NavigationGuard 
+```
+
+
+### Methods
+
+
+### Properties
+
+
+## NavigationGuardNext
+
+
+### Methods
+
+
+### Properties
+
+
+## NavigationHookAfter
+
+
+### Methods
+
+
+### Properties
+
+
+## RouteLocation
+
+[RouteLocationRaw](./vue-router-typealias#routelocationraw) resolved using the matcher
+
+**Signature:**
+```typescript
+export interface RouteLocation extends _RouteLocationBase 
+```
+
+
+### Methods
+
+
+### Properties
+
+#### matched
+
+Array of [RouteRecord](./vue-router-typealias#routerecord) containing components as they were passed when adding records. It can also contain redirect records. This can't be used directly
+
+**Signature:**
+```typescript
+matched: RouteRecord[];
+```
+
+
+## RouteLocationMatched
+
+
+### Methods
+
+
+### Properties
+
+#### components
+
+
+## RouteLocationNormalized
+
+Similar to [RouteLocation](./vue-router-interface#routelocation) but its [matched](./vue-router-interface#routelocationnormalized.matched) cannot contain redirect records
+
+**Signature:**
+```typescript
+export interface RouteLocationNormalized extends _RouteLocationBase 
+```
+
+
+### Methods
+
+
+### Properties
+
+#### matched
+
+Array of [RouteRecordNormalized](./vue-router-interface#routerecordnormalized)
+
+**Signature:**
+```typescript
+matched: RouteRecordNormalized[];
+```
+
+
+## RouteLocationNormalizedLoaded
+
+[RouteLocationRaw](./vue-router-typealias#routelocationraw) with
+
+**Signature:**
+```typescript
+export interface RouteLocationNormalizedLoaded extends _RouteLocationBase 
+```
+
+
+### Methods
+
+
+### Properties
+
+#### matched
+
+Array of [RouteLocationMatched](./vue-router-interface#routelocationmatched) containing only plain components (any lazy-loaded components have been loaded and were replaced inside of the `components` object) so it can be directly used to display routes. It cannot contain redirect records either
+
+**Signature:**
+```typescript
+matched: RouteLocationMatched[];
+```
+
+
+## RouteLocationOptions
+
+
+### Methods
+
+
+### Properties
+
+#### force
+
+Triggers the navigation even if the location is the same as the current one
+
+**Signature:**
+```typescript
+force?: boolean;
+```
+
+#### replace
+
+Replace the entry in the history instead of pushing a new entry
+
+**Signature:**
+```typescript
+replace?: boolean;
+```
+
+#### state
+
+State to save using the History API. This cannot contain any reactive values and some primitives like Symbols are forbidden. More info at TODO: link mdn
+
+**Signature:**
+```typescript
+state?: HistoryState;
+```
+
+
+## RouteMeta
+
+
+### Methods
+
+
+### Properties
+
+
+## Router
+
+
+### Methods
+
+#### addRoute
+
+Add a new [Route Record](./vue-router-typealias#routerecordraw) as the child of an existing route.
+
+**Signature:**
+```typescript
+addRoute(parentName: RouteRecordName, route: RouteRecordRaw): () => void;
+```
+
+*Parameters*
+
+| Parameter | Type | Description |
+| --- | --- | --- |
+| parentName | RouteRecordName | Parent Route Record where `route` should be appended at |
+| route | RouteRecordRaw | Route Record to add |
+
+#### addRoute
+
+Add a new [route record](./vue-router-typealias#routerecordraw) to the router.
+
+**Signature:**
+```typescript
+addRoute(route: RouteRecordRaw): () => void;
+```
+
+*Parameters*
+
+| Parameter | Type | Description |
+| --- | --- | --- |
+| route | RouteRecordRaw | Route Record to add |
+
+#### afterEach
+
+Add a navigation hook that is executed after every navigation. Returns a function that removes the registered hook.
+
+**Signature:**
+```typescript
+afterEach(guard: NavigationHookAfter): () => void;
+```
+
+*Parameters*
+
+| Parameter | Type | Description |
+| --- | --- | --- |
+| guard | NavigationHookAfter | navigation hook to add |
+
+### Examples
+
+
+```js
+router.afterEach((to, from, failure) => {
+  if (isNavigationFailure(failure)) {
+    console.log('failed navigation', failure)
+  }
+})
+```
+
+
+#### back
+
+Go back in history if possible by calling `history.back()`. Equivalent to `router.go(-1)`. Returns a Promise. See the limitations at [go](./vue-router-interface#router.go).
+
+**Signature:**
+```typescript
+back(): Promise<NavigationFailure | void | undefined>;
+```
+
+*Parameters*
+
+| Parameter | Type | Description |
+| --- | --- | --- |
+
+#### beforeEach
+
+Add a navigation guard that executes before any navigation. Returns a function that removes the registered guard.
+
+**Signature:**
+```typescript
+beforeEach(guard: NavigationGuardWithThis<undefined>): () => void;
+```
+
+*Parameters*
+
+| Parameter | Type | Description |
+| --- | --- | --- |
+| guard | NavigationGuardWithThis&lt;undefined&gt; | navigation guard to add |
+
+#### beforeResolve
+
+Add a navigation guard that executes before navigation is about to be resolved. At this state all component have been fetched and other navigation guards have been successful. Returns a function that removes the registered guard.
+
+**Signature:**
+```typescript
+beforeResolve(guard: NavigationGuardWithThis<undefined>): () => void;
+```
+
+*Parameters*
+
+| Parameter | Type | Description |
+| --- | --- | --- |
+| guard | NavigationGuardWithThis&lt;undefined&gt; | navigation guard to add |
+
+### Examples
+
+
+```js
+router.beforeEach(to => {
+  if (to.meta.requiresAuth && !isAuthenticated) return false
+})
+```
+
+
+#### forward
+
+Go forward in history if possible by calling `history.forward()`. Equivalent to `router.go(1)`. Returns a Promise. See the limitations at [go](./vue-router-interface#router.go).
+
+**Signature:**
+```typescript
+forward(): Promise<NavigationFailure | void | undefined>;
+```
+
+*Parameters*
+
+| Parameter | Type | Description |
+| --- | --- | --- |
+
+#### getRoutes
+
+Get a full list of all the [route records](./vue-router-typealias#routerecord).
+
+**Signature:**
+```typescript
+getRoutes(): RouteRecord[];
+```
+
+*Parameters*
+
+| Parameter | Type | Description |
+| --- | --- | --- |
+
+#### go
+
+Allows you to move forward or backward through the history. Returns a Promise that resolves when the navigation finishes. If it wasn't possible to go back, the promise never resolves or rejects
+
+**Signature:**
+```typescript
+go(delta: number): Promise<NavigationFailure | void | undefined>;
+```
+
+*Parameters*
+
+| Parameter | Type | Description |
+| --- | --- | --- |
+| delta | number | The position in the history to which you want to move, relative to the current page |
+
+#### hasRoute
+
+Checks if a route with a given name exists
+
+**Signature:**
+```typescript
+hasRoute(name: RouteRecordName): boolean;
+```
+
+*Parameters*
+
+| Parameter | Type | Description |
+| --- | --- | --- |
+| name | RouteRecordName | Name of the route to check |
+
+#### isReady
+
+Returns a Promise that resolves when the router has completed the initial navigation, which means it has resolved all async enter hooks and async components that are associated with the initial route. If the initial navigation already happened, the promise resolves immediately.This is useful in server-side rendering to ensure consistent output on both the server and the client. Note that on server side, you need to manually push the initial location while on client side, the router automatically picks it up from the URL.
+
+**Signature:**
+```typescript
+isReady(): Promise<void>;
+```
+
+*Parameters*
+
+| Parameter | Type | Description |
+| --- | --- | --- |
+
+#### onError
+
+Adds an error handler that is called every time a non caught error happens during navigation. This includes errors thrown synchronously and asynchronously, errors returned or passed to `next` in any navigation guard, and errors occurred when trying to resolve an async component that is required to render a route.
+
+**Signature:**
+```typescript
+onError(handler: ErrorHandler): () => void;
+```
+
+*Parameters*
+
+| Parameter | Type | Description |
+| --- | --- | --- |
+| handler | ErrorHandler | error handler to register |
+
+#### push
+
+Programmatically navigate to a new URL by pushing an entry in the history stack.
+
+**Signature:**
+```typescript
+push(to: RouteLocationRaw): Promise<NavigationFailure | void | undefined>;
+```
+
+*Parameters*
+
+| Parameter | Type | Description |
+| --- | --- | --- |
+| to | RouteLocationRaw | Route location to navigate to |
+
+#### removeRoute
+
+Remove an existing route by its name.
+
+**Signature:**
+```typescript
+removeRoute(name: RouteRecordName): void;
+```
+
+*Parameters*
+
+| Parameter | Type | Description |
+| --- | --- | --- |
+| name | RouteRecordName | Name of the route to remove |
+
+#### replace
+
+Programmatically navigate to a new URL by replacing the current entry in the history stack.
+
+**Signature:**
+```typescript
+replace(to: RouteLocationRaw): Promise<NavigationFailure | void | undefined>;
+```
+
+*Parameters*
+
+| Parameter | Type | Description |
+| --- | --- | --- |
+| to | RouteLocationRaw | Route location to navigate to |
+
+#### resolve
+
+Returns the [normalized version](./vue-router-interface#routelocation) of a [route location](./vue-router-typealias#routelocationraw). Also includes an `href` property that includes any existing `base`.
+
+**Signature:**
+```typescript
+resolve(to: RouteLocationRaw): RouteLocation & {
+        href: string;
+    };
+```
+
+*Parameters*
+
+| Parameter | Type | Description |
+| --- | --- | --- |
+| to | RouteLocationRaw | Raw route location to resolve |
+
+
+### Properties
+
+#### currentRoute
+
+Current [RouteLocationNormalized](./vue-router-interface#routelocationnormalized)
+
+**Signature:**
+```typescript
+readonly currentRoute: Ref<RouteLocationNormalizedLoaded>;
+```
+
+#### options
+
+Original options object passed to create the Router
+
+**Signature:**
+```typescript
+readonly options: RouterOptions;
+```
+
+
+## RouteRecordNormalized
+
+Normalized version of a [Route Record](./vue-router-typealias#routerecord)
+
+**Signature:**
+```typescript
+export interface RouteRecordNormalized 
+```
+
+
+### Methods
+
+
+### Properties
+
+#### aliasOf
+
+Defines if this record is the alias of another one. This property is `undefined` if the record is the original one.
+
+**Signature:**
+```typescript
+aliasOf: RouteRecordNormalized | undefined;
+```
+
+#### beforeEnter
+
+
+
+**Signature:**
+```typescript
+beforeEnter: RouteRecordMultipleViews['beforeEnter'];
+```
+
+#### children
+
+
+
+**Signature:**
+```typescript
+children: Exclude<_RouteRecordBase['children'], void>;
+```
+
+#### components
+
+
+
+**Signature:**
+```typescript
+components: RouteRecordMultipleViews['components'];
+```
+
+#### instances
+
+Mounted route component instances Having the instances on the record mean beforeRouteUpdate and beforeRouteLeave guards can only be invoked with the latest mounted app instance if there are multiple application instances rendering the same view, basically duplicating the content on the page, which shouldn't happen in practice. It will work if multiple apps are rendering different named views.
+
+**Signature:**
+```typescript
+instances: Record<string, ComponentPublicInstance | undefined | null>;
+```
+
+#### meta
+
+Arbitrary data attached to the record.
+
+**Signature:**
+```typescript
+meta: Exclude<_RouteRecordBase['meta'], void>;
+```
+
+#### name
+
+Name for the route record.
+
+**Signature:**
+```typescript
+name: _RouteRecordBase['name'];
+```
+
+#### path
+
+Path of the record. Should start with `/` unless the record is the child of another record.
+
+**Signature:**
+```typescript
+path: _RouteRecordBase['path'];
+```
+
+#### props
+
+
+
+**Signature:**
+```typescript
+props: Record<string, _RouteRecordProps>;
+```
+
+#### redirect
+
+Where to redirect if the route is directly matched. The redirection happens before any navigation guard and triggers a new navigation with the new target location.
+
+**Signature:**
+```typescript
+redirect: _RouteRecordBase['redirect'] | undefined;
+```
+
+
+## RouterLinkProps
+
+
+### Methods
+
+
+### Properties
+
+#### activeClass
+
+Class to apply when the link is active
+
+**Signature:**
+```typescript
+activeClass?: string;
+```
+
+#### ariaCurrentValue
+
+Value passed to the attribute `aria-current` when the link is exact active. Defaults to "page"
+
+**Signature:**
+```typescript
+ariaCurrentValue?: 'page' | 'step' | 'location' | 'date' | 'time' | 'true' | 'false';
+```
+
+#### custom
+
+Whether RouterLink should not wrap its content in an `a` tag. Useful when using `v-slot` to create a custom RouterLink
+
+**Signature:**
+```typescript
+custom?: boolean;
+```
+
+#### exactActiveClass
+
+Class to apply when the link is exact active
+
+**Signature:**
+```typescript
+exactActiveClass?: string;
+```
+
+
+## RouterOptions
+
+
+### Methods
+
+
+### Properties
+
+#### history
+
+History implementation used by the router. Most web applications should use `createWebHistory` but it requires the server to be properly configured. You can also use a _hash_ based history with `createWebHashHistory` that does not require any configuration on the server but isn't handled at all by search engines and does poorly on SEO.
+
+**Signature:**
+```typescript
+history: RouterHistory;
+```
+
+### Examples
+
+
+```js
+createRouter({
+  history: createWebHistory(),
+  // other options...
+})
+```
+
+
+#### linkActiveClass
+
+Default class applied to active [RouterLink](./vue-router-variable#routerlink). If none is provided, `router-link-active` will be applied.
+
+**Signature:**
+```typescript
+linkActiveClass?: string;
+```
+
+#### linkExactActiveClass
+
+Default class applied to exact active [RouterLink](./vue-router-variable#routerlink). If none is provided, `router-link-exact-active` will be applied.
+
+**Signature:**
+```typescript
+linkExactActiveClass?: string;
+```
+
+#### parseQuery
+
+Custom implementation to parse a query. See its counterpart, [stringifyQuery](./vue-router-interface#routeroptions.stringifyquery).
+
+**Signature:**
+```typescript
+parseQuery?: typeof originalParseQuery;
+```
+
+### Examples
+
+Let's say you want to use the package [qs](https://github.com/ljharb/qs) to parse queries, you can provide both `parseQuery` and `stringifyQuery`:
+```js
+import qs from 'qs'
+
+createRouter({
+  // other options...
+  parse: qs.parse,
+  stringifyQuery: qs.stringify,
+})
+```
+
+
+#### routes
+
+Initial list of routes that should be added to the router.
+
+**Signature:**
+```typescript
+routes: RouteRecordRaw[];
+```
+
+#### scrollBehavior
+
+Function to control scrolling when navigating between pages. Can return a Promise to delay scrolling. Check .
+
+**Signature:**
+```typescript
+scrollBehavior?: ScrollBehavior;
+```
+
+### Examples
+
+
+```js
+function scrollBehavior(to, from, savedPosition) {
+  // `to` and `from` are both route locations
+  // `savedPosition` can be null if there isn't one
+}
+```
+
+
+#### stringifyQuery
+
+Custom implementation to stringify a query object. Should not prepend a leading `?`. [parseQuery](./vue-router-interface#routeroptions.parsequery) counterpart to handle query parsing.
+
+**Signature:**
+```typescript
+stringifyQuery?: typeof originalStringifyQuery;
+```
+
+
+## RouterViewProps
+
+
+### Methods
+
+
+### Properties
+
+#### name
+
+#### route
+
+
+## ScrollBehavior_2
+
+
+### Methods
+
+
+### Properties
+
+

diff --git a/docs/api/vue-router-typealias.md b/docs/api/vue-router-typealias.md
new file mode 100644 (file)
index 0000000..e0499ba
--- /dev/null
+++ b/docs/api/vue-router-typealias.md
@@ -0,0 +1,44 @@
+# TypeAlias
+
+## LocationQuery
+
+Normalized query object that appears in [RouteLocationNormalized](./vue-router-interface#routelocationnormalized)
+
+**Signature:**
+```typescript
+export declare type LocationQuery = Record<string, LocationQueryValue | LocationQueryValue[]>;
+```
+
+## LocationQueryRaw
+
+Loose [LocationQuery](./vue-router-typealias#locationquery) object that can be passed to functions like [push](./vue-router-interface#router.push) and [replace](./vue-router-interface#router.replace) or anywhere when creating a [RouteLocationRaw](./vue-router-typealias#routelocationraw)
+
+**Signature:**
+```typescript
+export declare type LocationQueryRaw = Record<string | number, LocationQueryValueRaw | LocationQueryValueRaw[]>;
+```
+
+## PathParserOptions
+
+## RouteLocationRaw
+
+User-level route location
+
+**Signature:**
+```typescript
+export declare type RouteLocationRaw = string | (RouteQueryAndHash & LocationAsPath & RouteLocationOptions) | (RouteQueryAndHash & LocationAsNameRaw & RouteLocationOptions) | (RouteQueryAndHash & LocationAsRelativeRaw & RouteLocationOptions);
+```
+
+## RouteParams
+
+## RouteRecord
+
+Normalized version of a [Route Record](./vue-router-typealias#routerecord)
+
+**Signature:**
+```typescript
+export declare type RouteRecord = RouteRecordNormalized;
+```
+
+## RouteRecordRaw
+

diff --git a/docs/api/vue-router-variable.md b/docs/api/vue-router-variable.md
new file mode 100644 (file)
index 0000000..81fae9d
--- /dev/null
+++ b/docs/api/vue-router-variable.md
@@ -0,0 +1,29 @@
+# Variable
+
+## RouterLink
+
+## RouterView
+
+## START_LOCATION
+
+Initial route location where the router is. Can be used in navigation guards to differentiate the initial navigation.
+
+**Signature:**
+```typescript
+START_LOCATION_NORMALIZED: RouteLocationNormalizedLoaded
+```
+
+### Examples
+
+
+```js
+import { START_LOCATION } from 'vue-router'
+
+router.beforeEach((to, from) => {
+  if (from === START_LOCATION) {
+    // initial navigation
+  }
+})
+```
+
+