From 11ce2139d4020919366b4567a08caece994760cd Mon Sep 17 00:00:00 2001
From: Pesar <pesar369@gmail.com>
Date: Thu, 21 Dec 2023 13:16:46 +0330
Subject: [PATCH 1/2] docs(fa): start Persian docs

---
 packages/docs/.vitepress/config/fa.ts         | 189 +++++++
 packages/docs/.vitepress/config/index.ts      |   2 +
 .../theme/components/HomeSponsors.vue         |   1 +
 .../theme/components/HomeSponsorsGroup.vue    |   2 +-
 .../fa/api/enums/NavigationFailureType.md     |  37 ++
 packages/docs/fa/api/index.md                 | 423 ++++++++++++++++
 .../docs/fa/api/interfaces/HistoryState.md    |  13 +
 .../fa/api/interfaces/NavigationFailure.md    |  79 +++
 .../docs/fa/api/interfaces/NavigationGuard.md |  28 ++
 .../fa/api/interfaces/NavigationGuardNext.md  |  73 +++
 .../api/interfaces/NavigationGuardWithThis.md |  35 ++
 .../fa/api/interfaces/NavigationHookAfter.md  |  25 +
 .../docs/fa/api/interfaces/RouteLocation.md   | 123 +++++
 .../fa/api/interfaces/RouteLocationMatched.md | 147 ++++++
 .../api/interfaces/RouteLocationNormalized.md | 122 +++++
 .../RouteLocationNormalizedLoaded.md          | 124 +++++
 .../fa/api/interfaces/RouteLocationOptions.md |  37 ++
 packages/docs/fa/api/interfaces/RouteMeta.md  |  28 ++
 .../docs/fa/api/interfaces/RouteRecordBase.md | 149 ++++++
 .../interfaces/RouteRecordMultipleViews.md    | 187 +++++++
 .../RouteRecordMultipleViewsWithChildren.md   | 187 +++++++
 .../api/interfaces/RouteRecordNormalized.md   | 107 ++++
 .../fa/api/interfaces/RouteRecordRedirect.md  | 184 +++++++
 .../api/interfaces/RouteRecordSingleView.md   | 185 +++++++
 .../RouteRecordSingleViewWithChildren.md      | 185 +++++++
 packages/docs/fa/api/interfaces/Router.md     | 421 ++++++++++++++++
 .../docs/fa/api/interfaces/RouterHistory.md   | 168 +++++++
 .../docs/fa/api/interfaces/RouterLinkProps.md |  74 +++
 .../docs/fa/api/interfaces/RouterOptions.md   | 188 +++++++
 .../fa/api/interfaces/RouterScrollBehavior.md |  27 +
 .../docs/fa/api/interfaces/RouterViewProps.md |  19 +
 .../docs/fa/guide/advanced/composition-api.md | 133 +++++
 .../docs/fa/guide/advanced/data-fetching.md   | 116 +++++
 .../docs/fa/guide/advanced/dynamic-routing.md | 115 +++++
 .../guide/advanced/extending-router-link.md   |  94 ++++
 .../docs/fa/guide/advanced/lazy-loading.md    |  86 ++++
 packages/docs/fa/guide/advanced/meta.md       |  80 +++
 .../fa/guide/advanced/navigation-failures.md  | 110 +++++
 .../fa/guide/advanced/navigation-guards.md    | 282 +++++++++++
 .../fa/guide/advanced/router-view-slot.md     |  73 +++
 .../docs/fa/guide/advanced/scroll-behavior.md | 115 +++++
 .../docs/fa/guide/advanced/transitions.md     |  84 ++++
 .../docs/fa/guide/advanced/typed-routes.md    |  10 +
 .../fa/guide/essentials/dynamic-matching.md   | 125 +++++
 .../docs/fa/guide/essentials/history-mode.md  | 217 ++++++++
 .../docs/fa/guide/essentials/named-routes.md  |  43 ++
 .../docs/fa/guide/essentials/named-views.md   |  94 ++++
 .../docs/fa/guide/essentials/navigation.md    | 113 +++++
 .../docs/fa/guide/essentials/nested-routes.md | 130 +++++
 .../docs/fa/guide/essentials/passing-props.md |  97 ++++
 .../fa/guide/essentials/redirect-and-alias.md | 113 +++++
 .../guide/essentials/route-matching-syntax.md | 119 +++++
 packages/docs/fa/guide/index.md               | 101 ++++
 packages/docs/fa/guide/migration/index.md     | 462 ++++++++++++++++++
 packages/docs/fa/index.md                     |  45 ++
 packages/docs/fa/installation.md              |  57 +++
 packages/docs/fa/introduction.md              |  27 +
 57 files changed, 6609 insertions(+), 1 deletion(-)
 create mode 100644 packages/docs/.vitepress/config/fa.ts
 create mode 100644 packages/docs/fa/api/enums/NavigationFailureType.md
 create mode 100644 packages/docs/fa/api/index.md
 create mode 100644 packages/docs/fa/api/interfaces/HistoryState.md
 create mode 100644 packages/docs/fa/api/interfaces/NavigationFailure.md
 create mode 100644 packages/docs/fa/api/interfaces/NavigationGuard.md
 create mode 100644 packages/docs/fa/api/interfaces/NavigationGuardNext.md
 create mode 100644 packages/docs/fa/api/interfaces/NavigationGuardWithThis.md
 create mode 100644 packages/docs/fa/api/interfaces/NavigationHookAfter.md
 create mode 100644 packages/docs/fa/api/interfaces/RouteLocation.md
 create mode 100644 packages/docs/fa/api/interfaces/RouteLocationMatched.md
 create mode 100644 packages/docs/fa/api/interfaces/RouteLocationNormalized.md
 create mode 100644 packages/docs/fa/api/interfaces/RouteLocationNormalizedLoaded.md
 create mode 100644 packages/docs/fa/api/interfaces/RouteLocationOptions.md
 create mode 100644 packages/docs/fa/api/interfaces/RouteMeta.md
 create mode 100644 packages/docs/fa/api/interfaces/RouteRecordBase.md
 create mode 100644 packages/docs/fa/api/interfaces/RouteRecordMultipleViews.md
 create mode 100644 packages/docs/fa/api/interfaces/RouteRecordMultipleViewsWithChildren.md
 create mode 100644 packages/docs/fa/api/interfaces/RouteRecordNormalized.md
 create mode 100644 packages/docs/fa/api/interfaces/RouteRecordRedirect.md
 create mode 100644 packages/docs/fa/api/interfaces/RouteRecordSingleView.md
 create mode 100644 packages/docs/fa/api/interfaces/RouteRecordSingleViewWithChildren.md
 create mode 100644 packages/docs/fa/api/interfaces/Router.md
 create mode 100644 packages/docs/fa/api/interfaces/RouterHistory.md
 create mode 100644 packages/docs/fa/api/interfaces/RouterLinkProps.md
 create mode 100644 packages/docs/fa/api/interfaces/RouterOptions.md
 create mode 100644 packages/docs/fa/api/interfaces/RouterScrollBehavior.md
 create mode 100644 packages/docs/fa/api/interfaces/RouterViewProps.md
 create mode 100644 packages/docs/fa/guide/advanced/composition-api.md
 create mode 100644 packages/docs/fa/guide/advanced/data-fetching.md
 create mode 100644 packages/docs/fa/guide/advanced/dynamic-routing.md
 create mode 100644 packages/docs/fa/guide/advanced/extending-router-link.md
 create mode 100644 packages/docs/fa/guide/advanced/lazy-loading.md
 create mode 100644 packages/docs/fa/guide/advanced/meta.md
 create mode 100644 packages/docs/fa/guide/advanced/navigation-failures.md
 create mode 100644 packages/docs/fa/guide/advanced/navigation-guards.md
 create mode 100644 packages/docs/fa/guide/advanced/router-view-slot.md
 create mode 100644 packages/docs/fa/guide/advanced/scroll-behavior.md
 create mode 100644 packages/docs/fa/guide/advanced/transitions.md
 create mode 100644 packages/docs/fa/guide/advanced/typed-routes.md
 create mode 100644 packages/docs/fa/guide/essentials/dynamic-matching.md
 create mode 100644 packages/docs/fa/guide/essentials/history-mode.md
 create mode 100644 packages/docs/fa/guide/essentials/named-routes.md
 create mode 100644 packages/docs/fa/guide/essentials/named-views.md
 create mode 100644 packages/docs/fa/guide/essentials/navigation.md
 create mode 100644 packages/docs/fa/guide/essentials/nested-routes.md
 create mode 100644 packages/docs/fa/guide/essentials/passing-props.md
 create mode 100644 packages/docs/fa/guide/essentials/redirect-and-alias.md
 create mode 100644 packages/docs/fa/guide/essentials/route-matching-syntax.md
 create mode 100644 packages/docs/fa/guide/index.md
 create mode 100644 packages/docs/fa/guide/migration/index.md
 create mode 100644 packages/docs/fa/index.md
 create mode 100644 packages/docs/fa/installation.md
 create mode 100644 packages/docs/fa/introduction.md

diff --git a/packages/docs/.vitepress/config/fa.ts b/packages/docs/.vitepress/config/fa.ts
new file mode 100644
index 000000000..cc2e1498a
--- /dev/null
+++ b/packages/docs/.vitepress/config/fa.ts
@@ -0,0 +1,189 @@
+import type { DefaultTheme, LocaleSpecificConfig } from 'vitepress'
+
+export const META_URL = 'https://router.vuejs.org'
+export const META_TITLE = 'Vue Router'
+export const META_DESCRIPTION = 'مسیریاب رسمی برای Vue.js'
+
+export const faConfig: LocaleSpecificConfig<DefaultTheme.Config> = {
+  description: META_DESCRIPTION,
+  head: [
+    ['meta', { property: 'og:url', content: META_URL }],
+    ['meta', { property: 'og:description', content: META_DESCRIPTION }],
+    ['meta', { property: 'twitter:url', content: META_URL }],
+    ['meta', { property: 'twitter:title', content: META_TITLE }],
+    ['meta', { property: 'twitter:description', content: META_DESCRIPTION }],
+  ],
+
+  themeConfig: {
+    editLink: {
+      pattern: 'https://github.com/vuejs/router/edit/main/packages/docs/:path',
+      text: 'پیشنهاد تغییرات در این صفحه',
+    },
+
+    nav: [
+      // { text: 'Config', link: '/config/' },
+      // { text: 'Plugins', link: '/plugins/' },
+      {
+        text: 'راهنما',
+        link: '/fa/guide/',
+        activeMatch: '^/fa/guide/',
+      },
+      { text: 'API', link: '/fa/api/', activeMatch: '^/fa/api/' },
+      {
+        text: 'v4.x',
+        items: [{ text: 'v3.x', link: 'https://v3.router.vuejs.org/fa' }],
+      },
+      {
+        text: 'پیوند‌ها',
+        items: [
+          {
+            text: 'Discussions',
+            link: 'https://github.com/vuejs/router/discussions',
+          },
+          {
+            text: 'Changelog',
+            link: 'https://github.com/vuejs/router/blob/main/packages/router/CHANGELOG.md',
+          },
+          {
+            text: 'Vue.js Certification',
+            link: 'https://certification.vuejs.org/?friend=VUEROUTER',
+          },
+        ],
+      },
+    ],
+
+    sidebar: {
+      // catch-all fallback
+      '/': [
+        {
+          text: 'آغاز',
+          items: [
+            {
+              text: 'معرفی',
+              link: '/fa/introduction.html',
+            },
+            {
+              text: 'نصب',
+              link: '/fa/installation.html',
+            },
+          ],
+        },
+        {
+          text: 'الزامات',
+          collapsible: false,
+          items: [
+            {
+              text: 'شروع شدن',
+              link: '/fa/guide/',
+            },
+            {
+              text: 'تطبیق مسیر به صورت پویا',
+              link: '/fa/guide/essentials/dynamic-matching.html',
+            },
+            {
+              text: 'نحو تطبیق مسیرها',
+              link: '/fa/guide/essentials/route-matching-syntax.html',
+            },
+            {
+              text: 'مسیرهای تو در تو',
+              link: '/fa/guide/essentials/nested-routes.html',
+            },
+            {
+              text: 'مسیریابی به صورت برنامه‌ای',
+              link: '/fa/guide/essentials/navigation.html',
+            },
+            {
+              text: 'مسیرهای نام‌گذاری‌شده',
+              link: '/fa/guide/essentials/named-routes.html',
+            },
+            {
+              text: 'View های نام‌گذاری‌شده',
+              link: '/fa/guide/essentials/named-views.html',
+            },
+            {
+              text: 'ریدایرکت و مخفف',
+              link: '/fa/guide/essentials/redirect-and-alias.html',
+            },
+            {
+              text: 'ارسال پراپ‌ها به کامپوننت مسیرها',
+              link: '/fa/guide/essentials/passing-props.html',
+            },
+            {
+              text: 'حالت‌های متفاوت هیستوری',
+              link: '/fa/guide/essentials/history-mode.html',
+            },
+          ],
+        },
+        {
+          text: 'پیشرفته',
+          collapsible: false,
+          items: [
+            {
+              text: 'گاردهای مسیریابی',
+              link: '/fa/guide/advanced/navigation-guards.html',
+            },
+            {
+              text: 'فیلدهای متا',
+              link: '/fa/guide/advanced/meta.html',
+            },
+            {
+              text: 'واکشی داده (Data Fetching)',
+              link: '/fa/guide/advanced/data-fetching.html',
+            },
+            {
+              text: 'Composition API',
+              link: '/fa/guide/advanced/composition-api.html',
+            },
+            {
+              text: 'RouterView اسلات',
+              link: '/fa/guide/advanced/router-view-slot.html',
+            },
+            {
+              text: 'ترنزیشن‌ها',
+              link: '/fa/guide/advanced/transitions.html',
+            },
+            {
+              text: 'رفتار اسکرول',
+              link: '/fa/guide/advanced/scroll-behavior.html',
+            },
+            {
+              text: 'مسیرهای تنبل(Lazy Loading)',
+              link: '/fa/guide/advanced/lazy-loading.html',
+            },
+            {
+              text: 'مسیرهای تایپ‌گذاری‌شده',
+              link: '/fa/guide/advanced/typed-routes.html',
+            },
+            {
+              text: 'گسترش RouterLink',
+              link: '/fa/guide/advanced/extending-router-link.html',
+            },
+            {
+              text: 'خطاهای Navigation',
+              link: '/fa/guide/advanced/navigation-failures.html',
+            },
+            {
+              text: 'مسیریابی پویا',
+              link: '/fa/guide/advanced/dynamic-routing.html',
+            },
+          ],
+        },
+        {
+          items: [
+            {
+              text: 'مهاجرت از Vue 2',
+              link: '/fa/guide/migration/index.html',
+            },
+          ],
+        },
+      ],
+
+      '/fa/api/': [
+        {
+          text: 'packages',
+          items: [{ text: 'vue-router', link: '/fa/api/' }],
+        },
+      ],
+    },
+  },
+}
diff --git a/packages/docs/.vitepress/config/index.ts b/packages/docs/.vitepress/config/index.ts
index 4b680a48c..8901c96b7 100644
--- a/packages/docs/.vitepress/config/index.ts
+++ b/packages/docs/.vitepress/config/index.ts
@@ -2,6 +2,7 @@ import { defineConfig } from 'vitepress'
 import { enConfig } from './en'
 import { sharedConfig } from './shared'
 import { zhConfig } from './zh'
+import { faConfig } from './fa'
 
 export default defineConfig({
   ...sharedConfig,
@@ -12,5 +13,6 @@ export default defineConfig({
     ko: { label: '한국어', lang: 'ko-KR', link: 'https://router.vuejs.kr/' },
     pt: { label: 'Português', lang: 'pt-PT', link: 'https://vue-router-docs-pt.netlify.app/' },
     ru: { label: 'Русский', lang: 'ru-RU', link: 'https://vue-router-ru.netlify.app' },
+    fa: { label: 'فارسی', lang: 'fa-IR', link: '/fa/', ...faConfig },
   },
 })
diff --git a/packages/docs/.vitepress/theme/components/HomeSponsors.vue b/packages/docs/.vitepress/theme/components/HomeSponsors.vue
index 458b02c7d..345fd624c 100644
--- a/packages/docs/.vitepress/theme/components/HomeSponsors.vue
+++ b/packages/docs/.vitepress/theme/components/HomeSponsors.vue
@@ -34,6 +34,7 @@ const translations = {
   en: 'Become a sponsor',
   'en-US': 'Become a Sponsor!',
   'zh-CN': '成为赞助者！',
+  'fa-IR': 'حامی شوید!',
 }
 </script>
 
diff --git a/packages/docs/.vitepress/theme/components/HomeSponsorsGroup.vue b/packages/docs/.vitepress/theme/components/HomeSponsorsGroup.vue
index 8e876c6f6..d8f60b60b 100644
--- a/packages/docs/.vitepress/theme/components/HomeSponsorsGroup.vue
+++ b/packages/docs/.vitepress/theme/components/HomeSponsorsGroup.vue
@@ -1,5 +1,5 @@
 <template>
-  <h3>{{ name }} Sponsors</h3>
+  <h3>{{ name }} اسپانسرهای</h3>
 
   <p>
     <a
diff --git a/packages/docs/fa/api/enums/NavigationFailureType.md b/packages/docs/fa/api/enums/NavigationFailureType.md
new file mode 100644
index 000000000..e7ccd2416
--- /dev/null
+++ b/packages/docs/fa/api/enums/NavigationFailureType.md
@@ -0,0 +1,37 @@
+---
+editLink: false
+---
+
+[API Documentation](../index.md) / NavigationFailureType
+
+# Enumeration: NavigationFailureType
+
+Enumeration with all possible types for navigation failures. Can be passed to
+[isNavigationFailure](../index.md#isNavigationFailure) to check for specific failures.
+
+## Enumeration Members
+
+### aborted
+
+• **aborted** = ``4``
+
+An aborted navigation is a navigation that failed because a navigation
+guard returned `false` or called `next(false)`
+
+___
+
+### cancelled
+
+• **cancelled** = ``8``
+
+A cancelled navigation is a navigation that failed because a more recent
+navigation finished started (not necessarily finished).
+
+___
+
+### duplicated
+
+• **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/packages/docs/fa/api/index.md b/packages/docs/fa/api/index.md
new file mode 100644
index 000000000..f52a63a3c
--- /dev/null
+++ b/packages/docs/fa/api/index.md
@@ -0,0 +1,423 @@
+---
+editLink: false
+---
+
+API Documentation
+
+# API Documentation
+
+## Enumerations
+
+- [NavigationFailureType](enums/NavigationFailureType.md)
+
+## Interfaces
+
+- [HistoryState](interfaces/HistoryState.md)
+- [NavigationFailure](interfaces/NavigationFailure.md)
+- [NavigationGuard](interfaces/NavigationGuard.md)
+- [NavigationGuardNext](interfaces/NavigationGuardNext.md)
+- [NavigationGuardWithThis](interfaces/NavigationGuardWithThis.md)
+- [NavigationHookAfter](interfaces/NavigationHookAfter.md)
+- [RouteLocation](interfaces/RouteLocation.md)
+- [RouteLocationMatched](interfaces/RouteLocationMatched.md)
+- [RouteLocationNormalized](interfaces/RouteLocationNormalized.md)
+- [RouteLocationNormalizedLoaded](interfaces/RouteLocationNormalizedLoaded.md)
+- [RouteLocationOptions](interfaces/RouteLocationOptions.md)
+- [RouteMeta](interfaces/RouteMeta.md)
+- [RouteRecordMultipleViews](interfaces/RouteRecordMultipleViews.md)
+- [RouteRecordMultipleViewsWithChildren](interfaces/RouteRecordMultipleViewsWithChildren.md)
+- [RouteRecordNormalized](interfaces/RouteRecordNormalized.md)
+- [RouteRecordRedirect](interfaces/RouteRecordRedirect.md)
+- [RouteRecordSingleView](interfaces/RouteRecordSingleView.md)
+- [RouteRecordSingleViewWithChildren](interfaces/RouteRecordSingleViewWithChildren.md)
+- [Router](interfaces/Router.md)
+- [RouterHistory](interfaces/RouterHistory.md)
+- [RouterLinkProps](interfaces/RouterLinkProps.md)
+- [RouterOptions](interfaces/RouterOptions.md)
+- [RouterScrollBehavior](interfaces/RouterScrollBehavior.md)
+- [RouterViewProps](interfaces/RouterViewProps.md)
+- [\_RouteRecordBase](interfaces/RouteRecordBase.md)
+
+## Type Aliases
+
+### LocationQuery
+
+Ƭ **LocationQuery**: `Record`\<`string`, `LocationQueryValue` \| `LocationQueryValue`[]\>
+
+Normalized query object that appears in [RouteLocationNormalized](interfaces/RouteLocationNormalized.md)
+
+___
+
+### LocationQueryRaw
+
+Ƭ **LocationQueryRaw**: `Record`\<`string` \| `number`, `LocationQueryValueRaw` \| `LocationQueryValueRaw`[]\>
+
+Loose [LocationQuery](index.md#LocationQuery) object that can be passed to functions like
+[Router.push](interfaces/Router.md#push) and [Router.replace](interfaces/Router.md#replace) or anywhere when creating a
+[RouteLocationRaw](index.md#RouteLocationRaw)
+
+___
+
+### PathParserOptions
+
+Ƭ **PathParserOptions**: `Pick`\<`_PathParserOptions`, ``"end"`` \| ``"sensitive"`` \| ``"strict"``\>
+
+___
+
+### RouteComponent
+
+Ƭ **RouteComponent**: `Component` \| `DefineComponent`
+
+Allowed Component in [RouteLocationMatched](interfaces/RouteLocationMatched.md)
+
+___
+
+### RouteLocationRaw
+
+Ƭ **RouteLocationRaw**: `string` \| `RouteLocationPathRaw` \| `RouteLocationNamedRaw`
+
+User-level route location
+
+___
+
+### RouteParams
+
+Ƭ **RouteParams**: `Record`\<`string`, `RouteParamValue` \| `RouteParamValue`[]\>
+
+___
+
+### RouteParamsRaw
+
+Ƭ **RouteParamsRaw**: `Record`\<`string`, `RouteParamValueRaw` \| `Exclude`\<`RouteParamValueRaw`, ``null`` \| `undefined`\>[]\>
+
+___
+
+### RouteRecord
+
+Ƭ **RouteRecord**: [`RouteRecordNormalized`](interfaces/RouteRecordNormalized.md)
+
+Normalized version of a [route record](index.md#RouteRecord).
+
+___
+
+### RouteRecordName
+
+Ƭ **RouteRecordName**: `string` \| `symbol`
+
+Possible values for a user-defined route record's name
+
+___
+
+### RouteRecordRaw
+
+Ƭ **RouteRecordRaw**: [`RouteRecordSingleView`](interfaces/RouteRecordSingleView.md) \| [`RouteRecordSingleViewWithChildren`](interfaces/RouteRecordSingleViewWithChildren.md) \| [`RouteRecordMultipleViews`](interfaces/RouteRecordMultipleViews.md) \| [`RouteRecordMultipleViewsWithChildren`](interfaces/RouteRecordMultipleViewsWithChildren.md) \| [`RouteRecordRedirect`](interfaces/RouteRecordRedirect.md)
+
+___
+
+### UseLinkOptions
+
+Ƭ **UseLinkOptions**: `VueUseOptions`\<`RouterLinkOptions`\>
+
+## Variables
+
+### RouterLink
+
+• `Const` **RouterLink**: `_RouterLinkI`
+
+Component to render a link that triggers a navigation on click.
+
+___
+
+### RouterView
+
+• `Const` **RouterView**: () => \{ `$props`: `AllowedComponentProps` & `ComponentCustomProps` & `VNodeProps` & [`RouterViewProps`](interfaces/RouterViewProps.md) ; `$slots`: \{ `default?`: (`__namedParameters`: \{ `Component`: `VNode`\<`RendererNode`, `RendererElement`, \{ `[key: string]`: `any`;  }\> ; `route`: [`RouteLocationNormalizedLoaded`](interfaces/RouteLocationNormalizedLoaded.md)  }) => `VNode`\<`RendererNode`, `RendererElement`, \{ `[key: string]`: `any`;  }\>[]  }  }
+
+#### Type declaration
+
+• **new RouterView**(): `Object`
+
+Component to display the current route the user is at.
+
+##### Returns
+
+`Object`
+
+| Name | Type |
+| :------ | :------ |
+| `$props` | `AllowedComponentProps` & `ComponentCustomProps` & `VNodeProps` & [`RouterViewProps`](interfaces/RouterViewProps.md) |
+| `$slots` | \{ `default?`: (`__namedParameters`: \{ `Component`: `VNode`\<`RendererNode`, `RendererElement`, \{ `[key: string]`: `any`;  }\> ; `route`: [`RouteLocationNormalizedLoaded`](interfaces/RouteLocationNormalizedLoaded.md)  }) => `VNode`\<`RendererNode`, `RendererElement`, \{ `[key: string]`: `any`;  }\>[]  } |
+| `$slots.default?` | (`__namedParameters`: \{ `Component`: `VNode`\<`RendererNode`, `RendererElement`, \{ `[key: string]`: `any`;  }\> ; `route`: [`RouteLocationNormalizedLoaded`](interfaces/RouteLocationNormalizedLoaded.md)  }) => `VNode`\<`RendererNode`, `RendererElement`, \{ `[key: string]`: `any`;  }\>[] |
+
+___
+
+### START\_LOCATION
+
+• `Const` **START\_LOCATION**: [`RouteLocationNormalizedLoaded`](interfaces/RouteLocationNormalizedLoaded.md)
+
+Initial route location where the router is. Can be used in navigation guards
+to differentiate the initial navigation.
+
+**`Example`**
+
+```js
+import { START_LOCATION } from 'vue-router'
+
+router.beforeEach((to, from) => {
+  if (from === START_LOCATION) {
+    // initial navigation
+  }
+})
+```
+
+## Functions
+
+### createMemoryHistory
+
+▸ **createMemoryHistory**(`base?`): [`RouterHistory`](interfaces/RouterHistory.md)
+
+Creates an 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 by either calling `router.push` or `router.replace`.
+
+#### Parameters
+
+| Name | Type | Default value | Description |
+| :------ | :------ | :------ | :------ |
+| `base` | `string` | `''` | Base applied to all urls, defaults to '/' |
+
+#### Returns
+
+[`RouterHistory`](interfaces/RouterHistory.md)
+
+a history object that can be passed to the router constructor
+
+___
+
+### createRouter
+
+▸ **createRouter**(`options`): [`Router`](interfaces/Router.md)
+
+Creates a Router instance that can be used by a Vue app.
+
+#### Parameters
+
+| Name | Type | Description |
+| :------ | :------ | :------ |
+| `options` | [`RouterOptions`](interfaces/RouterOptions.md) | [RouterOptions](interfaces/RouterOptions.md) |
+
+#### Returns
+
+[`Router`](interfaces/Router.md)
+
+___
+
+### createWebHashHistory
+
+▸ **createWebHashHistory**(`base?`): [`RouterHistory`](interfaces/RouterHistory.md)
+
+Creates a hash history. Useful for web applications with no host (e.g. `file://`) or when configuring a server to
+handle any URL is not possible.
+
+#### Parameters
+
+| Name | Type | Description |
+| :------ | :------ | :------ |
+| `base?` | `string` | optional base to provide. Defaults to `location.pathname + location.search` If there is a `<base>` tag in the `head`, its value will be ignored in favor of this parameter **but note it affects all the history.pushState() calls**, meaning that if you use a `<base>` tag, it's `href` value **has to match this parameter** (ignoring anything after the `#`). |
+
+#### Returns
+
+[`RouterHistory`](interfaces/RouterHistory.md)
+
+**`Example`**
+
+```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
+
+▸ **createWebHistory**(`base?`): [`RouterHistory`](interfaces/RouterHistory.md)
+
+Creates an HTML5 history. Most common history for single page applications.
+
+#### Parameters
+
+| Name | Type |
+| :------ | :------ |
+| `base?` | `string` |
+
+#### Returns
+
+[`RouterHistory`](interfaces/RouterHistory.md)
+
+___
+
+### isNavigationFailure
+
+▸ **isNavigationFailure**(`error`, `type?`): error is NavigationRedirectError
+
+Check if an object is a [NavigationFailure](interfaces/NavigationFailure.md).
+
+#### Parameters
+
+| Name | Type | Description |
+| :------ | :------ | :------ |
+| `error` | `any` | possible [NavigationFailure](interfaces/NavigationFailure.md) |
+| `type?` | `NAVIGATION_GUARD_REDIRECT` | optional types to check for |
+
+#### Returns
+
+error is NavigationRedirectError
+
+**`Example`**
+
+```js
+import { isNavigationFailure, NavigationFailureType } from 'vue-router'
+
+router.afterEach((to, from, failure) => {
+  // Any kind of navigation failure
+  if (isNavigationFailure(failure)) {
+    // ...
+  }
+  // Only duplicated navigations
+  if (isNavigationFailure(failure, NavigationFailureType.duplicated)) {
+    // ...
+  }
+  // Aborted or canceled navigations
+  if (isNavigationFailure(failure, NavigationFailureType.aborted | NavigationFailureType.canceled)) {
+    // ...
+  }
+})
+```
+
+▸ **isNavigationFailure**(`error`, `type?`): error is NavigationFailure
+
+#### Parameters
+
+| Name | Type |
+| :------ | :------ |
+| `error` | `any` |
+| `type?` | `ErrorTypes` \| [`NavigationFailureType`](enums/NavigationFailureType.md) |
+
+#### Returns
+
+error is NavigationFailure
+
+___
+
+### loadRouteLocation
+
+▸ **loadRouteLocation**(`route`): `Promise`\<[`RouteLocationNormalizedLoaded`](interfaces/RouteLocationNormalizedLoaded.md)\>
+
+Ensures a route is loaded, so it can be passed as o prop to `<RouterView>`.
+
+#### Parameters
+
+| Name | Type | Description |
+| :------ | :------ | :------ |
+| `route` | [`RouteLocationNormalized`](interfaces/RouteLocationNormalized.md) | resolved route to load |
+
+#### Returns
+
+`Promise`\<[`RouteLocationNormalizedLoaded`](interfaces/RouteLocationNormalizedLoaded.md)\>
+
+___
+
+### onBeforeRouteLeave
+
+▸ **onBeforeRouteLeave**(`leaveGuard`): `void`
+
+Add a navigation guard that triggers whenever the component for the current
+location is about to be left. Similar to beforeRouteLeave but can be
+used in any component. The guard is removed when the component is unmounted.
+
+#### Parameters
+
+| Name | Type | Description |
+| :------ | :------ | :------ |
+| `leaveGuard` | [`NavigationGuard`](interfaces/NavigationGuard.md) | [NavigationGuard](interfaces/NavigationGuard.md) |
+
+#### Returns
+
+`void`
+
+___
+
+### onBeforeRouteUpdate
+
+▸ **onBeforeRouteUpdate**(`updateGuard`): `void`
+
+Add a navigation guard that triggers whenever the current location is about
+to be updated. Similar to beforeRouteUpdate but can be used in any
+component. The guard is removed when the component is unmounted.
+
+#### Parameters
+
+| Name | Type | Description |
+| :------ | :------ | :------ |
+| `updateGuard` | [`NavigationGuard`](interfaces/NavigationGuard.md) | [NavigationGuard](interfaces/NavigationGuard.md) |
+
+#### Returns
+
+`void`
+
+___
+
+### useLink
+
+▸ **useLink**(`props`): `Object`
+
+#### Parameters
+
+| Name | Type |
+| :------ | :------ |
+| `props` | `VueUseOptions`\<`RouterLinkOptions`\> |
+
+#### Returns
+
+`Object`
+
+| Name | Type |
+| :------ | :------ |
+| `href` | `ComputedRef`\<`string`\> |
+| `isActive` | `ComputedRef`\<`boolean`\> |
+| `isExactActive` | `ComputedRef`\<`boolean`\> |
+| `navigate` | (`e`: `MouseEvent`) => `Promise`\<`void` \| [`NavigationFailure`](interfaces/NavigationFailure.md)\> |
+| `route` | `ComputedRef`\<[`RouteLocation`](interfaces/RouteLocation.md) & \{ `href`: `string`  }\> |
+
+___
+
+### useRoute
+
+▸ **useRoute**(): [`RouteLocationNormalizedLoaded`](interfaces/RouteLocationNormalizedLoaded.md)
+
+Returns the current route location. Equivalent to using `$route` inside
+templates.
+
+#### Returns
+
+[`RouteLocationNormalizedLoaded`](interfaces/RouteLocationNormalizedLoaded.md)
+
+___
+
+### useRouter
+
+▸ **useRouter**(): [`Router`](interfaces/Router.md)
+
+Returns the router instance. Equivalent to using `$router` inside
+templates.
+
+#### Returns
+
+[`Router`](interfaces/Router.md)
diff --git a/packages/docs/fa/api/interfaces/HistoryState.md b/packages/docs/fa/api/interfaces/HistoryState.md
new file mode 100644
index 000000000..ab0ffc718
--- /dev/null
+++ b/packages/docs/fa/api/interfaces/HistoryState.md
@@ -0,0 +1,13 @@
+---
+editLink: false
+---
+
+[API Documentation](../index.md) / HistoryState
+
+# Interface: HistoryState
+
+Allowed HTML history.state
+
+## Indexable
+
+▪ [x: `number`]: `HistoryStateValue`
diff --git a/packages/docs/fa/api/interfaces/NavigationFailure.md b/packages/docs/fa/api/interfaces/NavigationFailure.md
new file mode 100644
index 000000000..c9e80423a
--- /dev/null
+++ b/packages/docs/fa/api/interfaces/NavigationFailure.md
@@ -0,0 +1,79 @@
+---
+editLink: false
+---
+
+[API Documentation](../index.md) / NavigationFailure
+
+# Interface: NavigationFailure
+
+Extended Error that contains extra information regarding a failed navigation.
+
+## Hierarchy
+
+- `Error`
+
+  ↳ **`NavigationFailure`**
+
+## Properties
+
+### cause
+
+• `Optional` **cause**: `unknown`
+
+#### Inherited from
+
+Error.cause
+
+___
+
+### from
+
+• **from**: [`RouteLocationNormalized`](RouteLocationNormalized.md)
+
+Route location we were navigating from
+
+___
+
+### message
+
+• **message**: `string`
+
+#### Inherited from
+
+Error.message
+
+___
+
+### name
+
+• **name**: `string`
+
+#### Inherited from
+
+Error.name
+
+___
+
+### stack
+
+• `Optional` **stack**: `string`
+
+#### Inherited from
+
+Error.stack
+
+___
+
+### to
+
+• **to**: [`RouteLocationNormalized`](RouteLocationNormalized.md)
+
+Route location we were navigating to
+
+___
+
+### type
+
+• **type**: `NAVIGATION_ABORTED` \| `NAVIGATION_CANCELLED` \| `NAVIGATION_DUPLICATED`
+
+Type of the navigation. One of [NavigationFailureType](../enums/NavigationFailureType.md)
diff --git a/packages/docs/fa/api/interfaces/NavigationGuard.md b/packages/docs/fa/api/interfaces/NavigationGuard.md
new file mode 100644
index 000000000..7a9a4865c
--- /dev/null
+++ b/packages/docs/fa/api/interfaces/NavigationGuard.md
@@ -0,0 +1,28 @@
+---
+editLink: false
+---
+
+[API Documentation](../index.md) / NavigationGuard
+
+# Interface: NavigationGuard
+
+Navigation guard. See [Navigation
+Guards](/guide/advanced/navigation-guards.md).
+
+## Callable
+
+### NavigationGuard
+
+▸ **NavigationGuard**(`to`, `from`, `next`): `NavigationGuardReturn` \| `Promise`\<`NavigationGuardReturn`\>
+
+#### Parameters
+
+| Name | Type |
+| :------ | :------ |
+| `to` | [`RouteLocationNormalized`](RouteLocationNormalized.md) |
+| `from` | [`RouteLocationNormalized`](RouteLocationNormalized.md) |
+| `next` | [`NavigationGuardNext`](NavigationGuardNext.md) |
+
+#### Returns
+
+`NavigationGuardReturn` \| `Promise`\<`NavigationGuardReturn`\>
diff --git a/packages/docs/fa/api/interfaces/NavigationGuardNext.md b/packages/docs/fa/api/interfaces/NavigationGuardNext.md
new file mode 100644
index 000000000..b736b12d6
--- /dev/null
+++ b/packages/docs/fa/api/interfaces/NavigationGuardNext.md
@@ -0,0 +1,73 @@
+---
+editLink: false
+---
+
+[API Documentation](../index.md) / NavigationGuardNext
+
+# Interface: NavigationGuardNext
+
+## Callable
+
+### NavigationGuardNext
+
+▸ **NavigationGuardNext**(): `void`
+
+#### Returns
+
+`void`
+
+### NavigationGuardNext
+
+▸ **NavigationGuardNext**(`error`): `void`
+
+#### Parameters
+
+| Name | Type |
+| :------ | :------ |
+| `error` | `Error` |
+
+#### Returns
+
+`void`
+
+### NavigationGuardNext
+
+▸ **NavigationGuardNext**(`location`): `void`
+
+#### Parameters
+
+| Name | Type |
+| :------ | :------ |
+| `location` | [`RouteLocationRaw`](../index.md#RouteLocationRaw) |
+
+#### Returns
+
+`void`
+
+### NavigationGuardNext
+
+▸ **NavigationGuardNext**(`valid`): `void`
+
+#### Parameters
+
+| Name | Type |
+| :------ | :------ |
+| `valid` | `undefined` \| `boolean` |
+
+#### Returns
+
+`void`
+
+### NavigationGuardNext
+
+▸ **NavigationGuardNext**(`cb`): `void`
+
+#### Parameters
+
+| Name | Type |
+| :------ | :------ |
+| `cb` | `NavigationGuardNextCallback` |
+
+#### Returns
+
+`void`
diff --git a/packages/docs/fa/api/interfaces/NavigationGuardWithThis.md b/packages/docs/fa/api/interfaces/NavigationGuardWithThis.md
new file mode 100644
index 000000000..4b4fae7b0
--- /dev/null
+++ b/packages/docs/fa/api/interfaces/NavigationGuardWithThis.md
@@ -0,0 +1,35 @@
+---
+editLink: false
+---
+
+[API Documentation](../index.md) / NavigationGuardWithThis
+
+# Interface: NavigationGuardWithThis\<T\>
+
+Navigation guard. See [Navigation
+Guards](/guide/advanced/navigation-guards.md).
+
+## Type parameters
+
+| Name |
+| :------ |
+| `T` |
+
+## Callable
+
+### NavigationGuardWithThis
+
+▸ **NavigationGuardWithThis**(`this`, `to`, `from`, `next`): `NavigationGuardReturn` \| `Promise`\<`NavigationGuardReturn`\>
+
+#### Parameters
+
+| Name | Type |
+| :------ | :------ |
+| `this` | `T` |
+| `to` | [`RouteLocationNormalized`](RouteLocationNormalized.md) |
+| `from` | [`RouteLocationNormalized`](RouteLocationNormalized.md) |
+| `next` | [`NavigationGuardNext`](NavigationGuardNext.md) |
+
+#### Returns
+
+`NavigationGuardReturn` \| `Promise`\<`NavigationGuardReturn`\>
diff --git a/packages/docs/fa/api/interfaces/NavigationHookAfter.md b/packages/docs/fa/api/interfaces/NavigationHookAfter.md
new file mode 100644
index 000000000..309d11311
--- /dev/null
+++ b/packages/docs/fa/api/interfaces/NavigationHookAfter.md
@@ -0,0 +1,25 @@
+---
+editLink: false
+---
+
+[API Documentation](../index.md) / NavigationHookAfter
+
+# Interface: NavigationHookAfter
+
+## Callable
+
+### NavigationHookAfter
+
+▸ **NavigationHookAfter**(`to`, `from`, `failure?`): `any`
+
+#### Parameters
+
+| Name | Type |
+| :------ | :------ |
+| `to` | [`RouteLocationNormalized`](RouteLocationNormalized.md) |
+| `from` | [`RouteLocationNormalized`](RouteLocationNormalized.md) |
+| `failure?` | `void` \| [`NavigationFailure`](NavigationFailure.md) |
+
+#### Returns
+
+`any`
diff --git a/packages/docs/fa/api/interfaces/RouteLocation.md b/packages/docs/fa/api/interfaces/RouteLocation.md
new file mode 100644
index 000000000..0aa1986ec
--- /dev/null
+++ b/packages/docs/fa/api/interfaces/RouteLocation.md
@@ -0,0 +1,123 @@
+---
+editLink: false
+---
+
+[API Documentation](../index.md) / RouteLocation
+
+# Interface: RouteLocation
+
+[RouteLocationRaw](../index.md#RouteLocationRaw) resolved using the matcher
+
+## Hierarchy
+
+- `_RouteLocationBase`
+
+  ↳ **`RouteLocation`**
+
+## Properties
+
+### fullPath
+
+• **fullPath**: `string`
+
+The whole location including the `search` and `hash`. This string is
+percentage encoded.
+
+#### Inherited from
+
+\_RouteLocationBase.fullPath
+
+___
+
+### hash
+
+• **hash**: `string`
+
+Hash of the current location. If present, starts with a `#`.
+
+#### Inherited from
+
+\_RouteLocationBase.hash
+
+___
+
+### matched
+
+• **matched**: [`RouteRecordNormalized`](RouteRecordNormalized.md)[]
+
+Array of [RouteRecord](../index.md#RouteRecord) containing components as they were
+passed when adding records. It can also contain redirect records. This
+can't be used directly
+
+___
+
+### meta
+
+• **meta**: [`RouteMeta`](RouteMeta.md)
+
+Merged `meta` properties from all the matched route records.
+
+#### Inherited from
+
+\_RouteLocationBase.meta
+
+___
+
+### name
+
+• **name**: `undefined` \| ``null`` \| [`RouteRecordName`](../index.md#RouteRecordName)
+
+Name of the matched record
+
+#### Inherited from
+
+\_RouteLocationBase.name
+
+___
+
+### params
+
+• **params**: [`RouteParams`](../index.md#RouteParams)
+
+Object of decoded params extracted from the `path`.
+
+#### Inherited from
+
+\_RouteLocationBase.params
+
+___
+
+### path
+
+• **path**: `string`
+
+Percentage encoded pathname section of the URL.
+
+#### Inherited from
+
+\_RouteLocationBase.path
+
+___
+
+### query
+
+• **query**: [`LocationQuery`](../index.md#LocationQuery)
+
+Object representation of the `search` property of the current location.
+
+#### Inherited from
+
+\_RouteLocationBase.query
+
+___
+
+### redirectedFrom
+
+• **redirectedFrom**: `undefined` \| [`RouteLocation`](RouteLocation.md)
+
+Contains the location we were initially trying to access before ending up
+on the current location.
+
+#### Inherited from
+
+\_RouteLocationBase.redirectedFrom
diff --git a/packages/docs/fa/api/interfaces/RouteLocationMatched.md b/packages/docs/fa/api/interfaces/RouteLocationMatched.md
new file mode 100644
index 000000000..cf649dd73
--- /dev/null
+++ b/packages/docs/fa/api/interfaces/RouteLocationMatched.md
@@ -0,0 +1,147 @@
+---
+editLink: false
+---
+
+[API Documentation](../index.md) / RouteLocationMatched
+
+# Interface: RouteLocationMatched
+
+Normalized version of a [route record](../index.md#RouteRecord).
+
+## Hierarchy
+
+- [`RouteRecordNormalized`](RouteRecordNormalized.md)
+
+  ↳ **`RouteLocationMatched`**
+
+## Properties
+
+### aliasOf
+
+• **aliasOf**: `undefined` \| [`RouteRecordNormalized`](RouteRecordNormalized.md)
+
+Defines if this record is the alias of another one. This property is
+`undefined` if the record is the original one.
+
+#### Inherited from
+
+[RouteRecordNormalized](RouteRecordNormalized.md).[aliasOf](RouteRecordNormalized.md#aliasOf)
+
+___
+
+### beforeEnter
+
+• **beforeEnter**: `undefined` \| [`NavigationGuardWithThis`](NavigationGuardWithThis.md)\<`undefined`\> \| [`NavigationGuardWithThis`](NavigationGuardWithThis.md)\<`undefined`\>[]
+
+Registered beforeEnter guards
+
+#### Inherited from
+
+[RouteRecordNormalized](RouteRecordNormalized.md).[beforeEnter](RouteRecordNormalized.md#beforeEnter)
+
+___
+
+### children
+
+• **children**: [`RouteRecordRaw`](../index.md#RouteRecordRaw)[]
+
+Nested route records.
+
+#### Inherited from
+
+[RouteRecordNormalized](RouteRecordNormalized.md).[children](RouteRecordNormalized.md#children)
+
+___
+
+### components
+
+• **components**: `undefined` \| ``null`` \| `Record`\<`string`, [`RouteComponent`](../index.md#RouteComponent)\>
+
+Components to display when the URL matches this route. Allow using named views.
+
+#### Overrides
+
+[RouteRecordNormalized](RouteRecordNormalized.md).[components](RouteRecordNormalized.md#components)
+
+___
+
+### instances
+
+• **instances**: `Record`\<`string`, `undefined` \| ``null`` \| `ComponentPublicInstance`\>
+
+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.
+
+#### Inherited from
+
+[RouteRecordNormalized](RouteRecordNormalized.md).[instances](RouteRecordNormalized.md#instances)
+
+___
+
+### meta
+
+• **meta**: [`RouteMeta`](RouteMeta.md)
+
+Arbitrary data attached to the record.
+
+#### Inherited from
+
+[RouteRecordNormalized](RouteRecordNormalized.md).[meta](RouteRecordNormalized.md#meta)
+
+___
+
+### name
+
+• **name**: `undefined` \| [`RouteRecordName`](../index.md#RouteRecordName)
+
+Name for the route record. Must be unique.
+
+#### Inherited from
+
+[RouteRecordNormalized](RouteRecordNormalized.md).[name](RouteRecordNormalized.md#name)
+
+___
+
+### path
+
+• **path**: `string`
+
+Path of the record. Should start with `/` unless the record is the child of
+another record.
+
+#### Inherited from
+
+[RouteRecordNormalized](RouteRecordNormalized.md).[path](RouteRecordNormalized.md#path)
+
+___
+
+### props
+
+• **props**: `Record`\<`string`, `_RouteRecordProps`\>
+
+Allow passing down params as props to the component rendered by
+`router-view`. Should be an object with the same keys as `components` or a
+boolean to be applied to every component.
+
+#### Inherited from
+
+[RouteRecordNormalized](RouteRecordNormalized.md).[props](RouteRecordNormalized.md#props)
+
+___
+
+### redirect
+
+• **redirect**: `undefined` \| `RouteRecordRedirectOption`
+
+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.
+
+#### Inherited from
+
+[RouteRecordNormalized](RouteRecordNormalized.md).[redirect](RouteRecordNormalized.md#redirect)
diff --git a/packages/docs/fa/api/interfaces/RouteLocationNormalized.md b/packages/docs/fa/api/interfaces/RouteLocationNormalized.md
new file mode 100644
index 000000000..43949a3bd
--- /dev/null
+++ b/packages/docs/fa/api/interfaces/RouteLocationNormalized.md
@@ -0,0 +1,122 @@
+---
+editLink: false
+---
+
+[API Documentation](../index.md) / RouteLocationNormalized
+
+# Interface: RouteLocationNormalized
+
+Similar to [RouteLocation](RouteLocation.md) but its
+[RouteLocationNormalized.matched](RouteLocationNormalized.md#matched) cannot contain redirect records
+
+## Hierarchy
+
+- `_RouteLocationBase`
+
+  ↳ **`RouteLocationNormalized`**
+
+## Properties
+
+### fullPath
+
+• **fullPath**: `string`
+
+The whole location including the `search` and `hash`. This string is
+percentage encoded.
+
+#### Inherited from
+
+\_RouteLocationBase.fullPath
+
+___
+
+### hash
+
+• **hash**: `string`
+
+Hash of the current location. If present, starts with a `#`.
+
+#### Inherited from
+
+\_RouteLocationBase.hash
+
+___
+
+### matched
+
+• **matched**: [`RouteRecordNormalized`](RouteRecordNormalized.md)[]
+
+Array of [RouteRecordNormalized](RouteRecordNormalized.md)
+
+___
+
+### meta
+
+• **meta**: [`RouteMeta`](RouteMeta.md)
+
+Merged `meta` properties from all the matched route records.
+
+#### Inherited from
+
+\_RouteLocationBase.meta
+
+___
+
+### name
+
+• **name**: `undefined` \| ``null`` \| [`RouteRecordName`](../index.md#RouteRecordName)
+
+Name of the matched record
+
+#### Inherited from
+
+\_RouteLocationBase.name
+
+___
+
+### params
+
+• **params**: [`RouteParams`](../index.md#RouteParams)
+
+Object of decoded params extracted from the `path`.
+
+#### Inherited from
+
+\_RouteLocationBase.params
+
+___
+
+### path
+
+• **path**: `string`
+
+Percentage encoded pathname section of the URL.
+
+#### Inherited from
+
+\_RouteLocationBase.path
+
+___
+
+### query
+
+• **query**: [`LocationQuery`](../index.md#LocationQuery)
+
+Object representation of the `search` property of the current location.
+
+#### Inherited from
+
+\_RouteLocationBase.query
+
+___
+
+### redirectedFrom
+
+• **redirectedFrom**: `undefined` \| [`RouteLocation`](RouteLocation.md)
+
+Contains the location we were initially trying to access before ending up
+on the current location.
+
+#### Inherited from
+
+\_RouteLocationBase.redirectedFrom
diff --git a/packages/docs/fa/api/interfaces/RouteLocationNormalizedLoaded.md b/packages/docs/fa/api/interfaces/RouteLocationNormalizedLoaded.md
new file mode 100644
index 000000000..79b028385
--- /dev/null
+++ b/packages/docs/fa/api/interfaces/RouteLocationNormalizedLoaded.md
@@ -0,0 +1,124 @@
+---
+editLink: false
+---
+
+[API Documentation](../index.md) / RouteLocationNormalizedLoaded
+
+# Interface: RouteLocationNormalizedLoaded
+
+[RouteLocationRaw](../index.md#RouteLocationRaw) with
+
+## Hierarchy
+
+- `_RouteLocationBase`
+
+  ↳ **`RouteLocationNormalizedLoaded`**
+
+## Properties
+
+### fullPath
+
+• **fullPath**: `string`
+
+The whole location including the `search` and `hash`. This string is
+percentage encoded.
+
+#### Inherited from
+
+\_RouteLocationBase.fullPath
+
+___
+
+### hash
+
+• **hash**: `string`
+
+Hash of the current location. If present, starts with a `#`.
+
+#### Inherited from
+
+\_RouteLocationBase.hash
+
+___
+
+### matched
+
+• **matched**: [`RouteLocationMatched`](RouteLocationMatched.md)[]
+
+Array of [RouteLocationMatched](RouteLocationMatched.md) containing only plain components (any
+lazy-loaded components have been loaded and were replaced inside the
+`components` object) so it can be directly used to display routes. It
+cannot contain redirect records either
+
+___
+
+### meta
+
+• **meta**: [`RouteMeta`](RouteMeta.md)
+
+Merged `meta` properties from all the matched route records.
+
+#### Inherited from
+
+\_RouteLocationBase.meta
+
+___
+
+### name
+
+• **name**: `undefined` \| ``null`` \| [`RouteRecordName`](../index.md#RouteRecordName)
+
+Name of the matched record
+
+#### Inherited from
+
+\_RouteLocationBase.name
+
+___
+
+### params
+
+• **params**: [`RouteParams`](../index.md#RouteParams)
+
+Object of decoded params extracted from the `path`.
+
+#### Inherited from
+
+\_RouteLocationBase.params
+
+___
+
+### path
+
+• **path**: `string`
+
+Percentage encoded pathname section of the URL.
+
+#### Inherited from
+
+\_RouteLocationBase.path
+
+___
+
+### query
+
+• **query**: [`LocationQuery`](../index.md#LocationQuery)
+
+Object representation of the `search` property of the current location.
+
+#### Inherited from
+
+\_RouteLocationBase.query
+
+___
+
+### redirectedFrom
+
+• **redirectedFrom**: `undefined` \| [`RouteLocation`](RouteLocation.md)
+
+Contains the location we were initially trying to access before ending up
+on the current location.
+
+#### Inherited from
+
+\_RouteLocationBase.redirectedFrom
diff --git a/packages/docs/fa/api/interfaces/RouteLocationOptions.md b/packages/docs/fa/api/interfaces/RouteLocationOptions.md
new file mode 100644
index 000000000..59ece3525
--- /dev/null
+++ b/packages/docs/fa/api/interfaces/RouteLocationOptions.md
@@ -0,0 +1,37 @@
+---
+editLink: false
+---
+
+[API Documentation](../index.md) / RouteLocationOptions
+
+# Interface: RouteLocationOptions
+
+Common options for all navigation methods.
+
+## Properties
+
+### force
+
+• `Optional` **force**: `boolean`
+
+Triggers the navigation even if the location is the same as the current one.
+Note this will also add a new entry to the history unless `replace: true`
+is passed.
+
+___
+
+### replace
+
+• `Optional` **replace**: `boolean`
+
+Replace the entry in the history instead of pushing a new entry
+
+___
+
+### state
+
+• `Optional` **state**: [`HistoryState`](HistoryState.md)
+
+State to save using the History API. This cannot contain any reactive
+values and some primitives like Symbols are forbidden. More info at
+https://developer.mozilla.org/en-US/docs/Web/API/History/state
diff --git a/packages/docs/fa/api/interfaces/RouteMeta.md b/packages/docs/fa/api/interfaces/RouteMeta.md
new file mode 100644
index 000000000..5e6007b10
--- /dev/null
+++ b/packages/docs/fa/api/interfaces/RouteMeta.md
@@ -0,0 +1,28 @@
+---
+editLink: false
+---
+
+[API Documentation](../index.md) / RouteMeta
+
+# Interface: RouteMeta
+
+Interface to type `meta` fields in route records.
+
+**`Example`**
+
+```ts
+// typings.d.ts or router.ts
+import 'vue-router';
+
+declare module 'vue-router' {
+  interface RouteMeta {
+    requiresAuth?: boolean
+  }
+ }
+```
+
+## Hierarchy
+
+- `Record`\<`string` \| `number` \| `symbol`, `unknown`\>
+
+  ↳ **`RouteMeta`**
diff --git a/packages/docs/fa/api/interfaces/RouteRecordBase.md b/packages/docs/fa/api/interfaces/RouteRecordBase.md
new file mode 100644
index 000000000..f64004047
--- /dev/null
+++ b/packages/docs/fa/api/interfaces/RouteRecordBase.md
@@ -0,0 +1,149 @@
+---
+editLink: false
+---
+
+[API Documentation](../index.md) / \_RouteRecordBase
+
+# Interface: \_RouteRecordBase
+
+Internal type for common properties among all kind of [RouteRecordRaw](../index.md#RouteRecordRaw).
+
+## Hierarchy
+
+- [`PathParserOptions`](../index.md#PathParserOptions)
+
+  ↳ **`_RouteRecordBase`**
+
+  ↳↳ [`RouteRecordSingleView`](RouteRecordSingleView.md)
+
+  ↳↳ [`RouteRecordSingleViewWithChildren`](RouteRecordSingleViewWithChildren.md)
+
+  ↳↳ [`RouteRecordMultipleViews`](RouteRecordMultipleViews.md)
+
+  ↳↳ [`RouteRecordMultipleViewsWithChildren`](RouteRecordMultipleViewsWithChildren.md)
+
+  ↳↳ [`RouteRecordRedirect`](RouteRecordRedirect.md)
+
+## Properties
+
+### alias
+
+• `Optional` **alias**: `string` \| `string`[]
+
+Aliases for the record. Allows defining extra paths that will behave like a
+copy of the record. Allows having paths shorthands like `/users/:id` and
+`/u/:id`. All `alias` and `path` values must share the same params.
+
+___
+
+### beforeEnter
+
+• `Optional` **beforeEnter**: [`NavigationGuardWithThis`](NavigationGuardWithThis.md)\<`undefined`\> \| [`NavigationGuardWithThis`](NavigationGuardWithThis.md)\<`undefined`\>[]
+
+Before Enter guard specific to this record. Note `beforeEnter` has no
+effect if the record has a `redirect` property.
+
+___
+
+### children
+
+• `Optional` **children**: [`RouteRecordRaw`](../index.md#RouteRecordRaw)[]
+
+Array of nested routes.
+
+___
+
+### end
+
+• `Optional` **end**: `boolean`
+
+Should the RegExp match until the end by appending a `$` to it.
+
+**`Default Value`**
+
+`true`
+
+#### Inherited from
+
+PathParserOptions.end
+
+___
+
+### meta
+
+• `Optional` **meta**: [`RouteMeta`](RouteMeta.md)
+
+Arbitrary data attached to the record.
+
+___
+
+### name
+
+• `Optional` **name**: [`RouteRecordName`](../index.md#RouteRecordName)
+
+Name for the route record. Must be unique.
+
+___
+
+### path
+
+• **path**: `string`
+
+Path of the record. Should start with `/` unless the record is the child of
+another record.
+
+**`Example`**
+
+```ts
+`/users/:id` matches `/users/1` as well as `/users/posva`.
+```
+
+___
+
+### props
+
+• `Optional` **props**: `_RouteRecordProps` \| `Record`\<`string`, `_RouteRecordProps`\>
+
+Allow passing down params as props to the component rendered by `router-view`.
+
+___
+
+### redirect
+
+• `Optional` **redirect**: `RouteRecordRedirectOption`
+
+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.
+
+___
+
+### sensitive
+
+• `Optional` **sensitive**: `boolean`
+
+Makes the RegExp case-sensitive.
+
+**`Default Value`**
+
+`false`
+
+#### Inherited from
+
+PathParserOptions.sensitive
+
+___
+
+### strict
+
+• `Optional` **strict**: `boolean`
+
+Whether to disallow a trailing slash or not.
+
+**`Default Value`**
+
+`false`
+
+#### Inherited from
+
+PathParserOptions.strict
diff --git a/packages/docs/fa/api/interfaces/RouteRecordMultipleViews.md b/packages/docs/fa/api/interfaces/RouteRecordMultipleViews.md
new file mode 100644
index 000000000..2f5007aa5
--- /dev/null
+++ b/packages/docs/fa/api/interfaces/RouteRecordMultipleViews.md
@@ -0,0 +1,187 @@
+---
+editLink: false
+---
+
+[API Documentation](../index.md) / RouteRecordMultipleViews
+
+# Interface: RouteRecordMultipleViews
+
+Route Record defining multiple named components with the `components` option.
+
+## Hierarchy
+
+- [`_RouteRecordBase`](RouteRecordBase.md)
+
+  ↳ **`RouteRecordMultipleViews`**
+
+## Properties
+
+### alias
+
+• `Optional` **alias**: `string` \| `string`[]
+
+Aliases for the record. Allows defining extra paths that will behave like a
+copy of the record. Allows having paths shorthands like `/users/:id` and
+`/u/:id`. All `alias` and `path` values must share the same params.
+
+#### Inherited from
+
+[_RouteRecordBase](RouteRecordBase.md).[alias](RouteRecordBase.md#alias)
+
+___
+
+### beforeEnter
+
+• `Optional` **beforeEnter**: [`NavigationGuardWithThis`](NavigationGuardWithThis.md)\<`undefined`\> \| [`NavigationGuardWithThis`](NavigationGuardWithThis.md)\<`undefined`\>[]
+
+Before Enter guard specific to this record. Note `beforeEnter` has no
+effect if the record has a `redirect` property.
+
+#### Inherited from
+
+[_RouteRecordBase](RouteRecordBase.md).[beforeEnter](RouteRecordBase.md#beforeEnter)
+
+___
+
+### children
+
+• `Optional` **children**: `undefined`
+
+Array of nested routes.
+
+#### Overrides
+
+[_RouteRecordBase](RouteRecordBase.md).[children](RouteRecordBase.md#children)
+
+___
+
+### component
+
+• `Optional` **component**: `undefined`
+
+___
+
+### components
+
+• **components**: `Record`\<`string`, `RawRouteComponent`\>
+
+Components to display when the URL matches this route. Allow using named views.
+
+___
+
+### end
+
+• `Optional` **end**: `boolean`
+
+Should the RegExp match until the end by appending a `$` to it.
+
+**`Default Value`**
+
+`true`
+
+#### Inherited from
+
+[_RouteRecordBase](RouteRecordBase.md).[end](RouteRecordBase.md#end)
+
+___
+
+### meta
+
+• `Optional` **meta**: [`RouteMeta`](RouteMeta.md)
+
+Arbitrary data attached to the record.
+
+#### Inherited from
+
+[_RouteRecordBase](RouteRecordBase.md).[meta](RouteRecordBase.md#meta)
+
+___
+
+### name
+
+• `Optional` **name**: [`RouteRecordName`](../index.md#RouteRecordName)
+
+Name for the route record. Must be unique.
+
+#### Inherited from
+
+[_RouteRecordBase](RouteRecordBase.md).[name](RouteRecordBase.md#name)
+
+___
+
+### path
+
+• **path**: `string`
+
+Path of the record. Should start with `/` unless the record is the child of
+another record.
+
+**`Example`**
+
+```ts
+`/users/:id` matches `/users/1` as well as `/users/posva`.
+```
+
+#### Inherited from
+
+[_RouteRecordBase](RouteRecordBase.md).[path](RouteRecordBase.md#path)
+
+___
+
+### props
+
+• `Optional` **props**: `boolean` \| `Record`\<`string`, `_RouteRecordProps`\>
+
+Allow passing down params as props to the component rendered by
+`router-view`. Should be an object with the same keys as `components` or a
+boolean to be applied to every component.
+
+#### Overrides
+
+[_RouteRecordBase](RouteRecordBase.md).[props](RouteRecordBase.md#props)
+
+___
+
+### redirect
+
+• `Optional` **redirect**: `undefined`
+
+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.
+
+#### Overrides
+
+[_RouteRecordBase](RouteRecordBase.md).[redirect](RouteRecordBase.md#redirect)
+
+___
+
+### sensitive
+
+• `Optional` **sensitive**: `boolean`
+
+Makes the RegExp case-sensitive.
+
+**`Default Value`**
+
+`false`
+
+#### Inherited from
+
+[_RouteRecordBase](RouteRecordBase.md).[sensitive](RouteRecordBase.md#sensitive)
+
+___
+
+### strict
+
+• `Optional` **strict**: `boolean`
+
+Whether to disallow a trailing slash or not.
+
+**`Default Value`**
+
+`false`
+
+#### Inherited from
+
+[_RouteRecordBase](RouteRecordBase.md).[strict](RouteRecordBase.md#strict)
diff --git a/packages/docs/fa/api/interfaces/RouteRecordMultipleViewsWithChildren.md b/packages/docs/fa/api/interfaces/RouteRecordMultipleViewsWithChildren.md
new file mode 100644
index 000000000..ddec0ecaf
--- /dev/null
+++ b/packages/docs/fa/api/interfaces/RouteRecordMultipleViewsWithChildren.md
@@ -0,0 +1,187 @@
+---
+editLink: false
+---
+
+[API Documentation](../index.md) / RouteRecordMultipleViewsWithChildren
+
+# Interface: RouteRecordMultipleViewsWithChildren
+
+Route Record defining multiple named components with the `components` option and children.
+
+## Hierarchy
+
+- [`_RouteRecordBase`](RouteRecordBase.md)
+
+  ↳ **`RouteRecordMultipleViewsWithChildren`**
+
+## Properties
+
+### alias
+
+• `Optional` **alias**: `string` \| `string`[]
+
+Aliases for the record. Allows defining extra paths that will behave like a
+copy of the record. Allows having paths shorthands like `/users/:id` and
+`/u/:id`. All `alias` and `path` values must share the same params.
+
+#### Inherited from
+
+[_RouteRecordBase](RouteRecordBase.md).[alias](RouteRecordBase.md#alias)
+
+___
+
+### beforeEnter
+
+• `Optional` **beforeEnter**: [`NavigationGuardWithThis`](NavigationGuardWithThis.md)\<`undefined`\> \| [`NavigationGuardWithThis`](NavigationGuardWithThis.md)\<`undefined`\>[]
+
+Before Enter guard specific to this record. Note `beforeEnter` has no
+effect if the record has a `redirect` property.
+
+#### Inherited from
+
+[_RouteRecordBase](RouteRecordBase.md).[beforeEnter](RouteRecordBase.md#beforeEnter)
+
+___
+
+### children
+
+• **children**: [`RouteRecordRaw`](../index.md#RouteRecordRaw)[]
+
+Array of nested routes.
+
+#### Overrides
+
+[_RouteRecordBase](RouteRecordBase.md).[children](RouteRecordBase.md#children)
+
+___
+
+### component
+
+• `Optional` **component**: `undefined`
+
+___
+
+### components
+
+• `Optional` **components**: ``null`` \| `Record`\<`string`, `RawRouteComponent`\>
+
+Components to display when the URL matches this route. Allow using named views.
+
+___
+
+### end
+
+• `Optional` **end**: `boolean`
+
+Should the RegExp match until the end by appending a `$` to it.
+
+**`Default Value`**
+
+`true`
+
+#### Inherited from
+
+[_RouteRecordBase](RouteRecordBase.md).[end](RouteRecordBase.md#end)
+
+___
+
+### meta
+
+• `Optional` **meta**: [`RouteMeta`](RouteMeta.md)
+
+Arbitrary data attached to the record.
+
+#### Inherited from
+
+[_RouteRecordBase](RouteRecordBase.md).[meta](RouteRecordBase.md#meta)
+
+___
+
+### name
+
+• `Optional` **name**: [`RouteRecordName`](../index.md#RouteRecordName)
+
+Name for the route record. Must be unique.
+
+#### Inherited from
+
+[_RouteRecordBase](RouteRecordBase.md).[name](RouteRecordBase.md#name)
+
+___
+
+### path
+
+• **path**: `string`
+
+Path of the record. Should start with `/` unless the record is the child of
+another record.
+
+**`Example`**
+
+```ts
+`/users/:id` matches `/users/1` as well as `/users/posva`.
+```
+
+#### Inherited from
+
+[_RouteRecordBase](RouteRecordBase.md).[path](RouteRecordBase.md#path)
+
+___
+
+### props
+
+• `Optional` **props**: `boolean` \| `Record`\<`string`, `_RouteRecordProps`\>
+
+Allow passing down params as props to the component rendered by
+`router-view`. Should be an object with the same keys as `components` or a
+boolean to be applied to every component.
+
+#### Overrides
+
+[_RouteRecordBase](RouteRecordBase.md).[props](RouteRecordBase.md#props)
+
+___
+
+### redirect
+
+• `Optional` **redirect**: `RouteRecordRedirectOption`
+
+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.
+
+#### Inherited from
+
+[_RouteRecordBase](RouteRecordBase.md).[redirect](RouteRecordBase.md#redirect)
+
+___
+
+### sensitive
+
+• `Optional` **sensitive**: `boolean`
+
+Makes the RegExp case-sensitive.
+
+**`Default Value`**
+
+`false`
+
+#### Inherited from
+
+[_RouteRecordBase](RouteRecordBase.md).[sensitive](RouteRecordBase.md#sensitive)
+
+___
+
+### strict
+
+• `Optional` **strict**: `boolean`
+
+Whether to disallow a trailing slash or not.
+
+**`Default Value`**
+
+`false`
+
+#### Inherited from
+
+[_RouteRecordBase](RouteRecordBase.md).[strict](RouteRecordBase.md#strict)
diff --git a/packages/docs/fa/api/interfaces/RouteRecordNormalized.md b/packages/docs/fa/api/interfaces/RouteRecordNormalized.md
new file mode 100644
index 000000000..0107112b6
--- /dev/null
+++ b/packages/docs/fa/api/interfaces/RouteRecordNormalized.md
@@ -0,0 +1,107 @@
+---
+editLink: false
+---
+
+[API Documentation](../index.md) / RouteRecordNormalized
+
+# Interface: RouteRecordNormalized
+
+Normalized version of a [route record](../index.md#RouteRecord).
+
+## Hierarchy
+
+- **`RouteRecordNormalized`**
+
+  ↳ [`RouteLocationMatched`](RouteLocationMatched.md)
+
+## Properties
+
+### aliasOf
+
+• **aliasOf**: `undefined` \| [`RouteRecordNormalized`](RouteRecordNormalized.md)
+
+Defines if this record is the alias of another one. This property is
+`undefined` if the record is the original one.
+
+___
+
+### beforeEnter
+
+• **beforeEnter**: `undefined` \| [`NavigationGuardWithThis`](NavigationGuardWithThis.md)\<`undefined`\> \| [`NavigationGuardWithThis`](NavigationGuardWithThis.md)\<`undefined`\>[]
+
+Registered beforeEnter guards
+
+___
+
+### children
+
+• **children**: [`RouteRecordRaw`](../index.md#RouteRecordRaw)[]
+
+Nested route records.
+
+___
+
+### components
+
+• **components**: `undefined` \| ``null`` \| `Record`\<`string`, `RawRouteComponent`\>
+
+Components to display when the URL matches this route. Allow using named views.
+
+___
+
+### instances
+
+• **instances**: `Record`\<`string`, `undefined` \| ``null`` \| `ComponentPublicInstance`\>
+
+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.
+
+___
+
+### meta
+
+• **meta**: [`RouteMeta`](RouteMeta.md)
+
+Arbitrary data attached to the record.
+
+___
+
+### name
+
+• **name**: `undefined` \| [`RouteRecordName`](../index.md#RouteRecordName)
+
+Name for the route record. Must be unique.
+
+___
+
+### path
+
+• **path**: `string`
+
+Path of the record. Should start with `/` unless the record is the child of
+another record.
+
+___
+
+### props
+
+• **props**: `Record`\<`string`, `_RouteRecordProps`\>
+
+Allow passing down params as props to the component rendered by
+`router-view`. Should be an object with the same keys as `components` or a
+boolean to be applied to every component.
+
+___
+
+### redirect
+
+• **redirect**: `undefined` \| `RouteRecordRedirectOption`
+
+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.
diff --git a/packages/docs/fa/api/interfaces/RouteRecordRedirect.md b/packages/docs/fa/api/interfaces/RouteRecordRedirect.md
new file mode 100644
index 000000000..2f471ddd3
--- /dev/null
+++ b/packages/docs/fa/api/interfaces/RouteRecordRedirect.md
@@ -0,0 +1,184 @@
+---
+editLink: false
+---
+
+[API Documentation](../index.md) / RouteRecordRedirect
+
+# Interface: RouteRecordRedirect
+
+Route Record that defines a redirect. Cannot have `component` or `components`
+as it is never rendered.
+
+## Hierarchy
+
+- [`_RouteRecordBase`](RouteRecordBase.md)
+
+  ↳ **`RouteRecordRedirect`**
+
+## Properties
+
+### alias
+
+• `Optional` **alias**: `string` \| `string`[]
+
+Aliases for the record. Allows defining extra paths that will behave like a
+copy of the record. Allows having paths shorthands like `/users/:id` and
+`/u/:id`. All `alias` and `path` values must share the same params.
+
+#### Inherited from
+
+[_RouteRecordBase](RouteRecordBase.md).[alias](RouteRecordBase.md#alias)
+
+___
+
+### beforeEnter
+
+• `Optional` **beforeEnter**: [`NavigationGuardWithThis`](NavigationGuardWithThis.md)\<`undefined`\> \| [`NavigationGuardWithThis`](NavigationGuardWithThis.md)\<`undefined`\>[]
+
+Before Enter guard specific to this record. Note `beforeEnter` has no
+effect if the record has a `redirect` property.
+
+#### Inherited from
+
+[_RouteRecordBase](RouteRecordBase.md).[beforeEnter](RouteRecordBase.md#beforeEnter)
+
+___
+
+### children
+
+• `Optional` **children**: [`RouteRecordRaw`](../index.md#RouteRecordRaw)[]
+
+Array of nested routes.
+
+#### Inherited from
+
+[_RouteRecordBase](RouteRecordBase.md).[children](RouteRecordBase.md#children)
+
+___
+
+### component
+
+• `Optional` **component**: `undefined`
+
+___
+
+### components
+
+• `Optional` **components**: `undefined`
+
+___
+
+### end
+
+• `Optional` **end**: `boolean`
+
+Should the RegExp match until the end by appending a `$` to it.
+
+**`Default Value`**
+
+`true`
+
+#### Inherited from
+
+[_RouteRecordBase](RouteRecordBase.md).[end](RouteRecordBase.md#end)
+
+___
+
+### meta
+
+• `Optional` **meta**: [`RouteMeta`](RouteMeta.md)
+
+Arbitrary data attached to the record.
+
+#### Inherited from
+
+[_RouteRecordBase](RouteRecordBase.md).[meta](RouteRecordBase.md#meta)
+
+___
+
+### name
+
+• `Optional` **name**: [`RouteRecordName`](../index.md#RouteRecordName)
+
+Name for the route record. Must be unique.
+
+#### Inherited from
+
+[_RouteRecordBase](RouteRecordBase.md).[name](RouteRecordBase.md#name)
+
+___
+
+### path
+
+• **path**: `string`
+
+Path of the record. Should start with `/` unless the record is the child of
+another record.
+
+**`Example`**
+
+```ts
+`/users/:id` matches `/users/1` as well as `/users/posva`.
+```
+
+#### Inherited from
+
+[_RouteRecordBase](RouteRecordBase.md).[path](RouteRecordBase.md#path)
+
+___
+
+### props
+
+• `Optional` **props**: `undefined`
+
+Allow passing down params as props to the component rendered by `router-view`.
+
+#### Overrides
+
+[_RouteRecordBase](RouteRecordBase.md).[props](RouteRecordBase.md#props)
+
+___
+
+### redirect
+
+• **redirect**: `RouteRecordRedirectOption`
+
+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.
+
+#### Overrides
+
+[_RouteRecordBase](RouteRecordBase.md).[redirect](RouteRecordBase.md#redirect)
+
+___
+
+### sensitive
+
+• `Optional` **sensitive**: `boolean`
+
+Makes the RegExp case-sensitive.
+
+**`Default Value`**
+
+`false`
+
+#### Inherited from
+
+[_RouteRecordBase](RouteRecordBase.md).[sensitive](RouteRecordBase.md#sensitive)
+
+___
+
+### strict
+
+• `Optional` **strict**: `boolean`
+
+Whether to disallow a trailing slash or not.
+
+**`Default Value`**
+
+`false`
+
+#### Inherited from
+
+[_RouteRecordBase](RouteRecordBase.md).[strict](RouteRecordBase.md#strict)
diff --git a/packages/docs/fa/api/interfaces/RouteRecordSingleView.md b/packages/docs/fa/api/interfaces/RouteRecordSingleView.md
new file mode 100644
index 000000000..9a64196dc
--- /dev/null
+++ b/packages/docs/fa/api/interfaces/RouteRecordSingleView.md
@@ -0,0 +1,185 @@
+---
+editLink: false
+---
+
+[API Documentation](../index.md) / RouteRecordSingleView
+
+# Interface: RouteRecordSingleView
+
+Route Record defining one single component with the `component` option.
+
+## Hierarchy
+
+- [`_RouteRecordBase`](RouteRecordBase.md)
+
+  ↳ **`RouteRecordSingleView`**
+
+## Properties
+
+### alias
+
+• `Optional` **alias**: `string` \| `string`[]
+
+Aliases for the record. Allows defining extra paths that will behave like a
+copy of the record. Allows having paths shorthands like `/users/:id` and
+`/u/:id`. All `alias` and `path` values must share the same params.
+
+#### Inherited from
+
+[_RouteRecordBase](RouteRecordBase.md).[alias](RouteRecordBase.md#alias)
+
+___
+
+### beforeEnter
+
+• `Optional` **beforeEnter**: [`NavigationGuardWithThis`](NavigationGuardWithThis.md)\<`undefined`\> \| [`NavigationGuardWithThis`](NavigationGuardWithThis.md)\<`undefined`\>[]
+
+Before Enter guard specific to this record. Note `beforeEnter` has no
+effect if the record has a `redirect` property.
+
+#### Inherited from
+
+[_RouteRecordBase](RouteRecordBase.md).[beforeEnter](RouteRecordBase.md#beforeEnter)
+
+___
+
+### children
+
+• `Optional` **children**: `undefined`
+
+Array of nested routes.
+
+#### Overrides
+
+[_RouteRecordBase](RouteRecordBase.md).[children](RouteRecordBase.md#children)
+
+___
+
+### component
+
+• **component**: `RawRouteComponent`
+
+Component to display when the URL matches this route.
+
+___
+
+### components
+
+• `Optional` **components**: `undefined`
+
+___
+
+### end
+
+• `Optional` **end**: `boolean`
+
+Should the RegExp match until the end by appending a `$` to it.
+
+**`Default Value`**
+
+`true`
+
+#### Inherited from
+
+[_RouteRecordBase](RouteRecordBase.md).[end](RouteRecordBase.md#end)
+
+___
+
+### meta
+
+• `Optional` **meta**: [`RouteMeta`](RouteMeta.md)
+
+Arbitrary data attached to the record.
+
+#### Inherited from
+
+[_RouteRecordBase](RouteRecordBase.md).[meta](RouteRecordBase.md#meta)
+
+___
+
+### name
+
+• `Optional` **name**: [`RouteRecordName`](../index.md#RouteRecordName)
+
+Name for the route record. Must be unique.
+
+#### Inherited from
+
+[_RouteRecordBase](RouteRecordBase.md).[name](RouteRecordBase.md#name)
+
+___
+
+### path
+
+• **path**: `string`
+
+Path of the record. Should start with `/` unless the record is the child of
+another record.
+
+**`Example`**
+
+```ts
+`/users/:id` matches `/users/1` as well as `/users/posva`.
+```
+
+#### Inherited from
+
+[_RouteRecordBase](RouteRecordBase.md).[path](RouteRecordBase.md#path)
+
+___
+
+### props
+
+• `Optional` **props**: `_RouteRecordProps`
+
+Allow passing down params as props to the component rendered by `router-view`.
+
+#### Overrides
+
+[_RouteRecordBase](RouteRecordBase.md).[props](RouteRecordBase.md#props)
+
+___
+
+### redirect
+
+• `Optional` **redirect**: `undefined`
+
+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.
+
+#### Overrides
+
+[_RouteRecordBase](RouteRecordBase.md).[redirect](RouteRecordBase.md#redirect)
+
+___
+
+### sensitive
+
+• `Optional` **sensitive**: `boolean`
+
+Makes the RegExp case-sensitive.
+
+**`Default Value`**
+
+`false`
+
+#### Inherited from
+
+[_RouteRecordBase](RouteRecordBase.md).[sensitive](RouteRecordBase.md#sensitive)
+
+___
+
+### strict
+
+• `Optional` **strict**: `boolean`
+
+Whether to disallow a trailing slash or not.
+
+**`Default Value`**
+
+`false`
+
+#### Inherited from
+
+[_RouteRecordBase](RouteRecordBase.md).[strict](RouteRecordBase.md#strict)
diff --git a/packages/docs/fa/api/interfaces/RouteRecordSingleViewWithChildren.md b/packages/docs/fa/api/interfaces/RouteRecordSingleViewWithChildren.md
new file mode 100644
index 000000000..2216c0d92
--- /dev/null
+++ b/packages/docs/fa/api/interfaces/RouteRecordSingleViewWithChildren.md
@@ -0,0 +1,185 @@
+---
+editLink: false
+---
+
+[API Documentation](../index.md) / RouteRecordSingleViewWithChildren
+
+# Interface: RouteRecordSingleViewWithChildren
+
+Route Record defining one single component with a nested view.
+
+## Hierarchy
+
+- [`_RouteRecordBase`](RouteRecordBase.md)
+
+  ↳ **`RouteRecordSingleViewWithChildren`**
+
+## Properties
+
+### alias
+
+• `Optional` **alias**: `string` \| `string`[]
+
+Aliases for the record. Allows defining extra paths that will behave like a
+copy of the record. Allows having paths shorthands like `/users/:id` and
+`/u/:id`. All `alias` and `path` values must share the same params.
+
+#### Inherited from
+
+[_RouteRecordBase](RouteRecordBase.md).[alias](RouteRecordBase.md#alias)
+
+___
+
+### beforeEnter
+
+• `Optional` **beforeEnter**: [`NavigationGuardWithThis`](NavigationGuardWithThis.md)\<`undefined`\> \| [`NavigationGuardWithThis`](NavigationGuardWithThis.md)\<`undefined`\>[]
+
+Before Enter guard specific to this record. Note `beforeEnter` has no
+effect if the record has a `redirect` property.
+
+#### Inherited from
+
+[_RouteRecordBase](RouteRecordBase.md).[beforeEnter](RouteRecordBase.md#beforeEnter)
+
+___
+
+### children
+
+• **children**: [`RouteRecordRaw`](../index.md#RouteRecordRaw)[]
+
+Array of nested routes.
+
+#### Overrides
+
+[_RouteRecordBase](RouteRecordBase.md).[children](RouteRecordBase.md#children)
+
+___
+
+### component
+
+• `Optional` **component**: ``null`` \| `RawRouteComponent`
+
+Component to display when the URL matches this route.
+
+___
+
+### components
+
+• `Optional` **components**: `undefined`
+
+___
+
+### end
+
+• `Optional` **end**: `boolean`
+
+Should the RegExp match until the end by appending a `$` to it.
+
+**`Default Value`**
+
+`true`
+
+#### Inherited from
+
+[_RouteRecordBase](RouteRecordBase.md).[end](RouteRecordBase.md#end)
+
+___
+
+### meta
+
+• `Optional` **meta**: [`RouteMeta`](RouteMeta.md)
+
+Arbitrary data attached to the record.
+
+#### Inherited from
+
+[_RouteRecordBase](RouteRecordBase.md).[meta](RouteRecordBase.md#meta)
+
+___
+
+### name
+
+• `Optional` **name**: [`RouteRecordName`](../index.md#RouteRecordName)
+
+Name for the route record. Must be unique.
+
+#### Inherited from
+
+[_RouteRecordBase](RouteRecordBase.md).[name](RouteRecordBase.md#name)
+
+___
+
+### path
+
+• **path**: `string`
+
+Path of the record. Should start with `/` unless the record is the child of
+another record.
+
+**`Example`**
+
+```ts
+`/users/:id` matches `/users/1` as well as `/users/posva`.
+```
+
+#### Inherited from
+
+[_RouteRecordBase](RouteRecordBase.md).[path](RouteRecordBase.md#path)
+
+___
+
+### props
+
+• `Optional` **props**: `_RouteRecordProps`
+
+Allow passing down params as props to the component rendered by `router-view`.
+
+#### Overrides
+
+[_RouteRecordBase](RouteRecordBase.md).[props](RouteRecordBase.md#props)
+
+___
+
+### redirect
+
+• `Optional` **redirect**: `RouteRecordRedirectOption`
+
+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.
+
+#### Inherited from
+
+[_RouteRecordBase](RouteRecordBase.md).[redirect](RouteRecordBase.md#redirect)
+
+___
+
+### sensitive
+
+• `Optional` **sensitive**: `boolean`
+
+Makes the RegExp case-sensitive.
+
+**`Default Value`**
+
+`false`
+
+#### Inherited from
+
+[_RouteRecordBase](RouteRecordBase.md).[sensitive](RouteRecordBase.md#sensitive)
+
+___
+
+### strict
+
+• `Optional` **strict**: `boolean`
+
+Whether to disallow a trailing slash or not.
+
+**`Default Value`**
+
+`false`
+
+#### Inherited from
+
+[_RouteRecordBase](RouteRecordBase.md).[strict](RouteRecordBase.md#strict)
diff --git a/packages/docs/fa/api/interfaces/Router.md b/packages/docs/fa/api/interfaces/Router.md
new file mode 100644
index 000000000..9d7d79933
--- /dev/null
+++ b/packages/docs/fa/api/interfaces/Router.md
@@ -0,0 +1,421 @@
+---
+editLink: false
+---
+
+[API Documentation](../index.md) / Router
+
+# Interface: Router
+
+Router instance.
+
+## Properties
+
+### currentRoute
+
+• `Readonly` **currentRoute**: `Ref`\<[`RouteLocationNormalizedLoaded`](RouteLocationNormalizedLoaded.md)\>
+
+Current [RouteLocationNormalized](RouteLocationNormalized.md)
+
+___
+
+### listening
+
+• **listening**: `boolean`
+
+Allows turning off the listening of history events. This is a low level api for micro-frontends.
+
+___
+
+### options
+
+• `Readonly` **options**: [`RouterOptions`](RouterOptions.md)
+
+Original options object passed to create the Router
+
+## Methods
+
+### addRoute
+
+▸ **addRoute**(`parentName`, `route`): () => `void`
+
+Add a new [route record](../index.md#RouteRecordRaw) as the child of an existing route.
+
+#### Parameters
+
+| Name | Type | Description |
+| :------ | :------ | :------ |
+| `parentName` | [`RouteRecordName`](../index.md#RouteRecordName) | Parent Route Record where `route` should be appended at |
+| `route` | [`RouteRecordRaw`](../index.md#RouteRecordRaw) | Route Record to add |
+
+#### Returns
+
+`fn`
+
+▸ (): `void`
+
+Add a new [route record](../index.md#RouteRecordRaw) as the child of an existing route.
+
+##### Returns
+
+`void`
+
+▸ **addRoute**(`route`): () => `void`
+
+Add a new [route record](../index.md#RouteRecordRaw) to the router.
+
+#### Parameters
+
+| Name | Type | Description |
+| :------ | :------ | :------ |
+| `route` | [`RouteRecordRaw`](../index.md#RouteRecordRaw) | Route Record to add |
+
+#### Returns
+
+`fn`
+
+▸ (): `void`
+
+Add a new [route record](../index.md#RouteRecordRaw) to the router.
+
+##### Returns
+
+`void`
+
+___
+
+### afterEach
+
+▸ **afterEach**(`guard`): () => `void`
+
+Add a navigation hook that is executed after every navigation. Returns a
+function that removes the registered hook.
+
+#### Parameters
+
+| Name | Type | Description |
+| :------ | :------ | :------ |
+| `guard` | [`NavigationHookAfter`](NavigationHookAfter.md) | navigation hook to add |
+
+#### Returns
+
+`fn`
+
+a function that removes the registered hook
+
+▸ (): `void`
+
+Add a navigation hook that is executed after every navigation. Returns a
+function that removes the registered hook.
+
+##### Returns
+
+`void`
+
+a function that removes the registered hook
+
+**`Example`**
+
+```js
+router.afterEach((to, from, failure) => {
+  if (isNavigationFailure(failure)) {
+    console.log('failed navigation', failure)
+  }
+})
+```
+
+**`Example`**
+
+```js
+router.afterEach((to, from, failure) => {
+  if (isNavigationFailure(failure)) {
+    console.log('failed navigation', failure)
+  }
+})
+```
+
+___
+
+### back
+
+▸ **back**(): `void`
+
+Go back in history if possible by calling `history.back()`. Equivalent to
+`router.go(-1)`.
+
+#### Returns
+
+`void`
+
+___
+
+### beforeEach
+
+▸ **beforeEach**(`guard`): () => `void`
+
+Add a navigation guard that executes before any navigation. Returns a
+function that removes the registered guard.
+
+#### Parameters
+
+| Name | Type | Description |
+| :------ | :------ | :------ |
+| `guard` | [`NavigationGuardWithThis`](NavigationGuardWithThis.md)\<`undefined`\> | navigation guard to add |
+
+#### Returns
+
+`fn`
+
+▸ (): `void`
+
+Add a navigation guard that executes before any navigation. Returns a
+function that removes the registered guard.
+
+##### Returns
+
+`void`
+
+___
+
+### beforeResolve
+
+▸ **beforeResolve**(`guard`): () => `void`
+
+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.
+
+#### Parameters
+
+| Name | Type | Description |
+| :------ | :------ | :------ |
+| `guard` | [`NavigationGuardWithThis`](NavigationGuardWithThis.md)\<`undefined`\> | navigation guard to add |
+
+#### Returns
+
+`fn`
+
+a function that removes the registered guard
+
+▸ (): `void`
+
+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.
+
+##### Returns
+
+`void`
+
+a function that removes the registered guard
+
+**`Example`**
+
+```js
+router.beforeResolve(to => {
+  if (to.meta.requiresAuth && !isAuthenticated) return false
+})
+```
+
+**`Example`**
+
+```js
+router.beforeResolve(to => {
+  if (to.meta.requiresAuth && !isAuthenticated) return false
+})
+```
+
+___
+
+### forward
+
+▸ **forward**(): `void`
+
+Go forward in history if possible by calling `history.forward()`.
+Equivalent to `router.go(1)`.
+
+#### Returns
+
+`void`
+
+___
+
+### getRoutes
+
+▸ **getRoutes**(): [`RouteRecordNormalized`](RouteRecordNormalized.md)[]
+
+Get a full list of all the [route records](../index.md#RouteRecord).
+
+#### Returns
+
+[`RouteRecordNormalized`](RouteRecordNormalized.md)[]
+
+___
+
+### go
+
+▸ **go**(`delta`): `void`
+
+Allows you to move forward or backward through the history. Calls
+`history.go()`.
+
+#### Parameters
+
+| Name | Type | Description |
+| :------ | :------ | :------ |
+| `delta` | `number` | The position in the history to which you want to move, relative to the current page |
+
+#### Returns
+
+`void`
+
+___
+
+### hasRoute
+
+▸ **hasRoute**(`name`): `boolean`
+
+Checks if a route with a given name exists
+
+#### Parameters
+
+| Name | Type | Description |
+| :------ | :------ | :------ |
+| `name` | [`RouteRecordName`](../index.md#RouteRecordName) | Name of the route to check |
+
+#### Returns
+
+`boolean`
+
+___
+
+### isReady
+
+▸ **isReady**(): `Promise`\<`void`\>
+
+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.
+
+#### Returns
+
+`Promise`\<`void`\>
+
+___
+
+### onError
+
+▸ **onError**(`handler`): () => `void`
+
+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.
+
+#### Parameters
+
+| Name | Type | Description |
+| :------ | :------ | :------ |
+| `handler` | `_ErrorListener` | error handler to register |
+
+#### Returns
+
+`fn`
+
+▸ (): `void`
+
+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.
+
+##### Returns
+
+`void`
+
+___
+
+### push
+
+▸ **push**(`to`): `Promise`\<`undefined` \| `void` \| [`NavigationFailure`](NavigationFailure.md)\>
+
+Programmatically navigate to a new URL by pushing an entry in the history
+stack.
+
+#### Parameters
+
+| Name | Type | Description |
+| :------ | :------ | :------ |
+| `to` | [`RouteLocationRaw`](../index.md#RouteLocationRaw) | Route location to navigate to |
+
+#### Returns
+
+`Promise`\<`undefined` \| `void` \| [`NavigationFailure`](NavigationFailure.md)\>
+
+___
+
+### removeRoute
+
+▸ **removeRoute**(`name`): `void`
+
+Remove an existing route by its name.
+
+#### Parameters
+
+| Name | Type | Description |
+| :------ | :------ | :------ |
+| `name` | [`RouteRecordName`](../index.md#RouteRecordName) | Name of the route to remove |
+
+#### Returns
+
+`void`
+
+___
+
+### replace
+
+▸ **replace**(`to`): `Promise`\<`undefined` \| `void` \| [`NavigationFailure`](NavigationFailure.md)\>
+
+Programmatically navigate to a new URL by replacing the current entry in
+the history stack.
+
+#### Parameters
+
+| Name | Type | Description |
+| :------ | :------ | :------ |
+| `to` | [`RouteLocationRaw`](../index.md#RouteLocationRaw) | Route location to navigate to |
+
+#### Returns
+
+`Promise`\<`undefined` \| `void` \| [`NavigationFailure`](NavigationFailure.md)\>
+
+___
+
+### resolve
+
+▸ **resolve**(`to`, `currentLocation?`): [`RouteLocation`](RouteLocation.md) & \{ `href`: `string`  }
+
+Returns the [normalized version](RouteLocation.md) of a
+[route location](../index.md#RouteLocationRaw). Also includes an `href` property
+that includes any existing `base`. By default, the `currentLocation` used is
+`router.currentRoute` and should only be overridden in advanced use cases.
+
+#### Parameters
+
+| Name | Type | Description |
+| :------ | :------ | :------ |
+| `to` | [`RouteLocationRaw`](../index.md#RouteLocationRaw) | Raw route location to resolve |
+| `currentLocation?` | [`RouteLocationNormalizedLoaded`](RouteLocationNormalizedLoaded.md) | Optional current location to resolve against |
+
+#### Returns
+
+[`RouteLocation`](RouteLocation.md) & \{ `href`: `string`  }
diff --git a/packages/docs/fa/api/interfaces/RouterHistory.md b/packages/docs/fa/api/interfaces/RouterHistory.md
new file mode 100644
index 000000000..a7fb4b017
--- /dev/null
+++ b/packages/docs/fa/api/interfaces/RouterHistory.md
@@ -0,0 +1,168 @@
+---
+editLink: false
+---
+
+[API Documentation](../index.md) / RouterHistory
+
+# Interface: RouterHistory
+
+Interface implemented by History implementations that can be passed to the
+router as Router.history
+
+## Properties
+
+### base
+
+• `Readonly` **base**: `string`
+
+Base path that is prepended to every url. This allows hosting an SPA at a
+sub-folder of a domain like `example.com/sub-folder` by having a `base` of
+`/sub-folder`
+
+___
+
+### location
+
+• `Readonly` **location**: `string`
+
+Current History location
+
+___
+
+### state
+
+• `Readonly` **state**: [`HistoryState`](HistoryState.md)
+
+Current History state
+
+## Methods
+
+### createHref
+
+▸ **createHref**(`location`): `string`
+
+Generates the corresponding href to be used in an anchor tag.
+
+#### Parameters
+
+| Name | Type | Description |
+| :------ | :------ | :------ |
+| `location` | `string` | history location that should create an href |
+
+#### Returns
+
+`string`
+
+___
+
+### destroy
+
+▸ **destroy**(): `void`
+
+Clears any event listener attached by the history implementation.
+
+#### Returns
+
+`void`
+
+___
+
+### go
+
+▸ **go**(`delta`, `triggerListeners?`): `void`
+
+Traverses history in a given direction.
+
+#### Parameters
+
+| Name | Type | Description |
+| :------ | :------ | :------ |
+| `delta` | `number` | distance to travel. If delta is \< 0, it will go back, if it's \> 0, it will go forward by that amount of entries. |
+| `triggerListeners?` | `boolean` | whether this should trigger listeners attached to the history |
+
+#### Returns
+
+`void`
+
+**`Example`**
+
+```js
+myHistory.go(-1) // equivalent to window.history.back()
+myHistory.go(1) // equivalent to window.history.forward()
+```
+
+___
+
+### listen
+
+▸ **listen**(`callback`): () => `void`
+
+Attach a listener to the History implementation that is triggered when the
+navigation is triggered from outside (like the Browser back and forward
+buttons) or when passing `true` to RouterHistory.back and
+RouterHistory.forward
+
+#### Parameters
+
+| Name | Type | Description |
+| :------ | :------ | :------ |
+| `callback` | `NavigationCallback` | listener to attach |
+
+#### Returns
+
+`fn`
+
+a callback to remove the listener
+
+▸ (): `void`
+
+Attach a listener to the History implementation that is triggered when the
+navigation is triggered from outside (like the Browser back and forward
+buttons) or when passing `true` to RouterHistory.back and
+RouterHistory.forward
+
+##### Returns
+
+`void`
+
+a callback to remove the listener
+
+___
+
+### push
+
+▸ **push**(`to`, `data?`): `void`
+
+Navigates to a location. In the case of an HTML5 History implementation,
+this will call `history.pushState` to effectively change the URL.
+
+#### Parameters
+
+| Name | Type | Description |
+| :------ | :------ | :------ |
+| `to` | `string` | location to push |
+| `data?` | [`HistoryState`](HistoryState.md) | optional [HistoryState](HistoryState.md) to be associated with the navigation entry |
+
+#### Returns
+
+`void`
+
+___
+
+### replace
+
+▸ **replace**(`to`, `data?`): `void`
+
+Same as [RouterHistory.push](RouterHistory.md#push) but performs a `history.replaceState`
+instead of `history.pushState`
+
+#### Parameters
+
+| Name | Type | Description |
+| :------ | :------ | :------ |
+| `to` | `string` | location to set |
+| `data?` | [`HistoryState`](HistoryState.md) | optional [HistoryState](HistoryState.md) to be associated with the navigation entry |
+
+#### Returns
+
+`void`
diff --git a/packages/docs/fa/api/interfaces/RouterLinkProps.md b/packages/docs/fa/api/interfaces/RouterLinkProps.md
new file mode 100644
index 000000000..e8aa8778d
--- /dev/null
+++ b/packages/docs/fa/api/interfaces/RouterLinkProps.md
@@ -0,0 +1,74 @@
+---
+editLink: false
+---
+
+[API Documentation](../index.md) / RouterLinkProps
+
+# Interface: RouterLinkProps
+
+## Hierarchy
+
+- `RouterLinkOptions`
+
+  ↳ **`RouterLinkProps`**
+
+## Properties
+
+### activeClass
+
+• `Optional` **activeClass**: `string`
+
+Class to apply when the link is active
+
+___
+
+### ariaCurrentValue
+
+• `Optional` **ariaCurrentValue**: ``"location"`` \| ``"time"`` \| ``"page"`` \| ``"step"`` \| ``"date"`` \| ``"true"`` \| ``"false"``
+
+Value passed to the attribute `aria-current` when the link is exact active.
+
+**`Default Value`**
+
+`'page'`
+
+___
+
+### custom
+
+• `Optional` **custom**: `boolean`
+
+Whether RouterLink should not wrap its content in an `a` tag. Useful when
+using `v-slot` to create a custom RouterLink
+
+___
+
+### exactActiveClass
+
+• `Optional` **exactActiveClass**: `string`
+
+Class to apply when the link is exact active
+
+___
+
+### replace
+
+• `Optional` **replace**: `boolean`
+
+Calls `router.replace` instead of `router.push`.
+
+#### Inherited from
+
+RouterLinkOptions.replace
+
+___
+
+### to
+
+• **to**: [`RouteLocationRaw`](../index.md#RouteLocationRaw)
+
+Route Location the link should navigate to when clicked on.
+
+#### Inherited from
+
+RouterLinkOptions.to
diff --git a/packages/docs/fa/api/interfaces/RouterOptions.md b/packages/docs/fa/api/interfaces/RouterOptions.md
new file mode 100644
index 000000000..039498275
--- /dev/null
+++ b/packages/docs/fa/api/interfaces/RouterOptions.md
@@ -0,0 +1,188 @@
+---
+editLink: false
+---
+
+[API Documentation](../index.md) / RouterOptions
+
+# Interface: RouterOptions
+
+Options to initialize a [Router](Router.md) instance.
+
+## Hierarchy
+
+- [`PathParserOptions`](../index.md#PathParserOptions)
+
+  ↳ **`RouterOptions`**
+
+## Properties
+
+### end
+
+• `Optional` **end**: `boolean`
+
+Should the RegExp match until the end by appending a `$` to it.
+
+**`Default Value`**
+
+`true`
+
+#### Inherited from
+
+PathParserOptions.end
+
+___
+
+### history
+
+• **history**: [`RouterHistory`](RouterHistory.md)
+
+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.
+
+**`Example`**
+
+```js
+createRouter({
+  history: createWebHistory(),
+  // other options...
+})
+```
+
+___
+
+### linkActiveClass
+
+• `Optional` **linkActiveClass**: `string`
+
+Default class applied to active [RouterLink](../index.md#RouterLink). If none is provided,
+`router-link-active` will be applied.
+
+___
+
+### linkExactActiveClass
+
+• `Optional` **linkExactActiveClass**: `string`
+
+Default class applied to exact active [RouterLink](../index.md#RouterLink). If none is provided,
+`router-link-exact-active` will be applied.
+
+___
+
+### parseQuery
+
+• `Optional` **parseQuery**: (`search`: `string`) => [`LocationQuery`](../index.md#LocationQuery)
+
+#### Type declaration
+
+▸ (`search`): [`LocationQuery`](../index.md#LocationQuery)
+
+Custom implementation to parse a query. See its counterpart,
+[RouterOptions.stringifyQuery](RouterOptions.md#stringifyQuery).
+
+##### Parameters
+
+| Name | Type |
+| :------ | :------ |
+| `search` | `string` |
+
+##### Returns
+
+[`LocationQuery`](../index.md#LocationQuery)
+
+**`Example`**
+
+Let's say you want to use the [qs package](https://github.com/ljharb/qs)
+to parse queries, you can provide both `parseQuery` and `stringifyQuery`:
+```js
+import qs from 'qs'
+
+createRouter({
+  // other options...
+  parseQuery: qs.parse,
+  stringifyQuery: qs.stringify,
+})
+```
+
+___
+
+### routes
+
+• **routes**: readonly [`RouteRecordRaw`](../index.md#RouteRecordRaw)[]
+
+Initial list of routes that should be added to the router.
+
+___
+
+### scrollBehavior
+
+• `Optional` **scrollBehavior**: [`RouterScrollBehavior`](RouterScrollBehavior.md)
+
+Function to control scrolling when navigating between pages. Can return a
+Promise to delay scrolling. Check ScrollBehavior.
+
+**`Example`**
+
+```js
+function scrollBehavior(to, from, savedPosition) {
+  // `to` and `from` are both route locations
+  // `savedPosition` can be null if there isn't one
+}
+```
+
+___
+
+### sensitive
+
+• `Optional` **sensitive**: `boolean`
+
+Makes the RegExp case-sensitive.
+
+**`Default Value`**
+
+`false`
+
+#### Inherited from
+
+PathParserOptions.sensitive
+
+___
+
+### strict
+
+• `Optional` **strict**: `boolean`
+
+Whether to disallow a trailing slash or not.
+
+**`Default Value`**
+
+`false`
+
+#### Inherited from
+
+PathParserOptions.strict
+
+___
+
+### stringifyQuery
+
+• `Optional` **stringifyQuery**: (`query`: [`LocationQueryRaw`](../index.md#LocationQueryRaw)) => `string`
+
+#### Type declaration
+
+▸ (`query`): `string`
+
+Custom implementation to stringify a query object. Should not prepend a leading `?`.
+[parseQuery](RouterOptions.md#parseQuery) counterpart to handle query parsing.
+
+##### Parameters
+
+| Name | Type |
+| :------ | :------ |
+| `query` | [`LocationQueryRaw`](../index.md#LocationQueryRaw) |
+
+##### Returns
+
+`string`
diff --git a/packages/docs/fa/api/interfaces/RouterScrollBehavior.md b/packages/docs/fa/api/interfaces/RouterScrollBehavior.md
new file mode 100644
index 000000000..049a72503
--- /dev/null
+++ b/packages/docs/fa/api/interfaces/RouterScrollBehavior.md
@@ -0,0 +1,27 @@
+---
+editLink: false
+---
+
+[API Documentation](../index.md) / RouterScrollBehavior
+
+# Interface: RouterScrollBehavior
+
+Type of the `scrollBehavior` option that can be passed to `createRouter`.
+
+## Callable
+
+### RouterScrollBehavior
+
+▸ **RouterScrollBehavior**(`to`, `from`, `savedPosition`): `Awaitable`\<``false`` \| `void` \| `ScrollPosition`\>
+
+#### Parameters
+
+| Name | Type | Description |
+| :------ | :------ | :------ |
+| `to` | [`RouteLocationNormalized`](RouteLocationNormalized.md) | Route location where we are navigating to |
+| `from` | [`RouteLocationNormalizedLoaded`](RouteLocationNormalizedLoaded.md) | Route location where we are navigating from |
+| `savedPosition` | ``null`` \| `_ScrollPositionNormalized` | saved position if it exists, `null` otherwise |
+
+#### Returns
+
+`Awaitable`\<``false`` \| `void` \| `ScrollPosition`\>
diff --git a/packages/docs/fa/api/interfaces/RouterViewProps.md b/packages/docs/fa/api/interfaces/RouterViewProps.md
new file mode 100644
index 000000000..30fc957d2
--- /dev/null
+++ b/packages/docs/fa/api/interfaces/RouterViewProps.md
@@ -0,0 +1,19 @@
+---
+editLink: false
+---
+
+[API Documentation](../index.md) / RouterViewProps
+
+# Interface: RouterViewProps
+
+## Properties
+
+### name
+
+• `Optional` **name**: `string`
+
+___
+
+### route
+
+• `Optional` **route**: [`RouteLocationNormalized`](RouteLocationNormalized.md)
diff --git a/packages/docs/fa/guide/advanced/composition-api.md b/packages/docs/fa/guide/advanced/composition-api.md
new file mode 100644
index 000000000..3e9213f78
--- /dev/null
+++ b/packages/docs/fa/guide/advanced/composition-api.md
@@ -0,0 +1,133 @@
+# Vue Router and the Composition API
+
+<VueSchoolLink
+  href="https://vueschool.io/lessons/router-and-the-composition-api"
+  title="Learn how to use Vue Router with the composition API"
+/>
+
+The introduction of `setup` and Vue's [Composition API](https://vuejs.org/guide/extras/composition-api-faq.html), open up new possibilities but to be able to get the full potential out of Vue Router, we will need to use a few new functions to replace access to `this` and in-component navigation guards.
+
+## Accessing the Router and current Route inside `setup`
+
+Because we don't have access to `this` inside of `setup`, we cannot directly access `this.$router` or `this.$route` anymore. Instead we use the `useRouter` and `useRoute` functions:
+
+```js
+import { useRouter, useRoute } from 'vue-router'
+
+export default {
+  setup() {
+    const router = useRouter()
+    const route = useRoute()
+
+    function pushWithQuery(query) {
+      router.push({
+        name: 'search',
+        query: {
+          ...route.query,
+          ...query,
+        },
+      })
+    }
+  },
+}
+```
+
+The `route` object is a reactive object, so any of its properties can be watched and you should **avoid watching the whole `route`** object. In most scenarios, you should directly watch the param you are expecting to change
+
+```js
+import { useRoute } from 'vue-router'
+import { ref, watch } from 'vue'
+
+export default {
+  setup() {
+    const route = useRoute()
+    const userData = ref()
+
+    // fetch the user information when params change
+    watch(
+      () => route.params.id,
+      async newId => {
+        userData.value = await fetchUser(newId)
+      }
+    )
+  },
+}
+```
+
+Note we still have access to `$router` and `$route` in templates, so there is no need to return `router` or `route` inside of `setup`.
+
+## Navigation Guards
+
+While you can still use in-component navigation guards with a `setup` function, Vue Router exposes update and leave guards as Composition API functions:
+
+```js
+import { onBeforeRouteLeave, onBeforeRouteUpdate } from 'vue-router'
+import { ref } from 'vue'
+
+export default {
+  setup() {
+    // same as beforeRouteLeave option with no access to `this`
+    onBeforeRouteLeave((to, from) => {
+      const answer = window.confirm(
+        'Do you really want to leave? you have unsaved changes!'
+      )
+      // cancel the navigation and stay on the same page
+      if (!answer) return false
+    })
+
+    const userData = ref()
+
+    // same as beforeRouteUpdate option with no access to `this`
+    onBeforeRouteUpdate(async (to, from) => {
+      // only fetch the user if the id changed as maybe only the query or the hash changed
+      if (to.params.id !== from.params.id) {
+        userData.value = await fetchUser(to.params.id)
+      }
+    })
+  },
+}
+```
+
+Composition API guards can also be used in any component rendered by `<router-view>`, they don't have to be used directly on the route component like in-component guards.
+
+## `useLink`
+
+Vue Router exposes the internal behavior of RouterLink as a composable. It accepts a reactive object like the props of `RouterLink` and exposes low-level properties to build your own `RouterLink` component or generate custom links:
+
+```js
+import { RouterLink, useLink } from 'vue-router'
+import { computed } from 'vue'
+
+export default {
+  name: 'AppLink',
+
+  props: {
+    // add @ts-ignore if using TypeScript
+    ...RouterLink.props,
+    inactiveClass: String,
+  },
+
+  setup(props) {
+    const {
+      // the resolved route object
+      route,
+      // the href to use in a link
+      href,
+      // boolean ref  indicating if the link is active
+      isActive,
+      // boolean ref  indicating if the link is exactly active
+      isExactActive,
+      // function to navigate to the link
+      navigate
+      } = useLink(props)
+
+    const isExternalLink = computed(
+      () => typeof props.to === 'string' && props.to.startsWith('http')
+    )
+
+    return { isExternalLink, href, navigate, isActive }
+  },
+}
+```
+
+Note that the RouterLink's `v-slot` gives access to the same properties as the `useLink` composable.
diff --git a/packages/docs/fa/guide/advanced/data-fetching.md b/packages/docs/fa/guide/advanced/data-fetching.md
new file mode 100644
index 000000000..b328b318c
--- /dev/null
+++ b/packages/docs/fa/guide/advanced/data-fetching.md
@@ -0,0 +1,116 @@
+# واکشی داده (Data Fetching)
+
+Sometimes you need to fetch data from the server when a route is activated. For example, before rendering a user profile, you need to fetch the user's data from the server. We can achieve this in two different ways:
+
+- **Fetching After Navigation**: perform the navigation first, and fetch data in the incoming component's lifecycle hook. Display a loading state while data is being fetched.
+
+- **Fetching Before Navigation**: Fetch data before navigation in the route enter guard, and perform the navigation after data has been fetched.
+
+Technically, both are valid choices - it ultimately depends on the user experience you are aiming for.
+
+## Fetching After Navigation
+
+When using this approach, we navigate and render the incoming component immediately, and fetch data in the component's `created` hook. It gives us the opportunity to display a loading state while the data is being fetched over the network, and we can also handle loading differently for each view.
+
+Let's assume we have a `Post` component that needs to fetch the data for a post based on `$route.params.id`:
+
+```html
+<template>
+  <div class="post">
+    <div v-if="loading" class="loading">Loading...</div>
+
+    <div v-if="error" class="error">{{ error }}</div>
+
+    <div v-if="post" class="content">
+      <h2>{{ post.title }}</h2>
+      <p>{{ post.body }}</p>
+    </div>
+  </div>
+</template>
+```
+
+```js
+export default {
+  data() {
+    return {
+      loading: false,
+      post: null,
+      error: null,
+    }
+  },
+  created() {
+    // watch the params of the route to fetch the data again
+    this.$watch(
+      () => this.$route.params,
+      () => {
+        this.fetchData()
+      },
+      // fetch the data when the view is created and the data is
+      // already being observed
+      { immediate: true }
+    )
+  },
+  methods: {
+    fetchData() {
+      this.error = this.post = null
+      this.loading = true
+      // replace `getPost` with your data fetching util / API wrapper
+      getPost(this.$route.params.id, (err, post) => {
+        this.loading = false
+        if (err) {
+          this.error = err.toString()
+        } else {
+          this.post = post
+        }
+      })
+    },
+  },
+}
+```
+
+## Fetching Before Navigation
+
+With this approach we fetch the data before actually navigating to the new
+route. We can perform the data fetching in the `beforeRouteEnter` guard in the incoming component, and only call `next` when the fetch is complete. The callback passed to `next` will be called **after the component is mounted**:
+
+```js
+export default {
+  data() {
+    return {
+      post: null,
+      error: null,
+    }
+  },
+  beforeRouteEnter(to, from, next) {
+    getPost(to.params.id, (err, post) => {
+      // `setData` is a method defined below
+      next(vm => vm.setData(err, post))
+    })
+  },
+  // when route changes and this component is already rendered,
+  // the logic will be slightly different.
+  async beforeRouteUpdate(to, from) {
+    this.post = null
+    try {
+      this.post = await getPost(to.params.id)
+    } catch (error) {
+      this.error = error.toString()
+    }
+  },
+  methods: {
+    setData(error, post) {
+      if (error) {
+        this.error = error
+      } else {
+        this.post = post
+      }
+    }
+  }
+}
+```
+
+The user will stay on the previous view while the resource is being fetched for the incoming view. It is therefore recommended to display a progress bar or some kind of indicator while the data is being fetched. If the data fetch fails, it's also necessary to display some kind of global warning message.
+
+<!-- ### Using Composition API -->
+
+<!-- TODO: -->
diff --git a/packages/docs/fa/guide/advanced/dynamic-routing.md b/packages/docs/fa/guide/advanced/dynamic-routing.md
new file mode 100644
index 000000000..b04b18586
--- /dev/null
+++ b/packages/docs/fa/guide/advanced/dynamic-routing.md
@@ -0,0 +1,115 @@
+# مسیریابی پویا
+
+<VueSchoolLink
+  href="https://vueschool.io/lessons/vue-router-4-dynamic-routing"
+  title="Learn how to add routes at runtime"
+/>
+
+Adding routes to your router is usually done via the `routes` option but in some situations, you might want to add or remove routes while the application is already running. Application with extensible interfaces like [Vue CLI UI](https://cli.vuejs.org/dev-guide/ui-api.html) can use this to make the application grow.
+
+## Adding routes
+
+Dynamic routing is achieved mainly via two functions: `router.addRoute()` and `router.removeRoute()`. They **only** register a new route, meaning that if the newly added route matches the current location, it would require you to **manually navigate** with `router.push()` or `router.replace()` to display that new route. Let's take a look at an example:
+
+Imagine having the following router with one single route:
+
+```js
+const router = createRouter({
+  history: createWebHistory(),
+  routes: [{ path: '/:articleName', component: Article }],
+})
+```
+
+Going to any page, `/about`, `/store`, or `/3-tricks-to-improve-your-routing-code` ends up rendering the `Article` component. If we are on `/about` and we add a new route:
+
+```js
+router.addRoute({ path: '/about', component: About })
+```
+
+The page will still show the `Article` component, we need to manually call `router.replace()` to change the current location and overwrite where we were (instead of pushing a new entry, ending up in the same location twice in our history):
+
+```js
+router.addRoute({ path: '/about', component: About })
+// we could also use this.$route or route = useRoute() (inside a setup)
+router.replace(router.currentRoute.value.fullPath)
+```
+
+Remember you can `await router.replace()` if you need to wait for the new route to be displayed.
+
+## Adding routes inside navigation guards
+
+If you decide to add or remove routes inside of a navigation guard, you should not call `router.replace()` but trigger a redirection by returning the new location:
+
+```js
+router.beforeEach(to => {
+  if (!hasNecessaryRoute(to)) {
+    router.addRoute(generateRoute(to))
+    // trigger a redirection
+    return to.fullPath
+  }
+})
+```
+
+The example above assumes two things: first, the newly added route record will match the `to` location, effectively resulting in a different location from the one we were trying to access. Second, `hasNecessaryRoute()` returns `false` after adding the new route to avoid an infinite redirection.
+
+Because we are redirecting, we are replacing the ongoing navigation, effectively behaving like the example shown before. In real world scenarios, adding is more likely to happen outside of navigation guards, e.g. when a view component mounts, it register new routes.
+
+## Removing routes
+
+There are few different ways to remove existing routes:
+
+- By adding a route with a conflicting name. If you add a route that has the same name as an existing route, it will remove the route first and then add the route:
+
+  ```js
+  router.addRoute({ path: '/about', name: 'about', component: About })
+  // this will remove the previously added route because they have
+  // the same name and names are unique across all routes
+  router.addRoute({ path: '/other', name: 'about', component: Other })
+  ```
+
+- By calling the callback returned by `router.addRoute()`:
+
+  ```js
+  const removeRoute = router.addRoute(routeRecord)
+  removeRoute() // removes the route if it exists
+  ```
+
+  This is useful when the routes do not have a name
+- By using `router.removeRoute()` to remove a route by its name:
+
+  ```js
+  router.addRoute({ path: '/about', name: 'about', component: About })
+  // remove the route
+  router.removeRoute('about')
+  ```
+
+  Note you can use `Symbol`s for names in routes if you wish to use this function but want to avoid conflicts in names.
+
+Whenever a route is removed, **all of its aliases and children** are removed with it.
+
+## Adding nested routes
+
+To add nested routes to an existing route, you can pass the _name_ of the route as its first parameter to `router.addRoute()`, this will effectively add the route as if it was added through `children`:
+
+```js
+router.addRoute({ name: 'admin', path: '/admin', component: Admin })
+router.addRoute('admin', { path: 'settings', component: AdminSettings })
+```
+
+This is equivalent to:
+
+```js
+router.addRoute({
+  name: 'admin',
+  path: '/admin',
+  component: Admin,
+  children: [{ path: 'settings', component: AdminSettings }],
+})
+```
+
+## Looking at existing routes
+
+Vue Router gives you two functions to look at existing routes:
+
+- [`router.hasRoute()`](/api/interfaces/Router.md#hasRoute): check if a route exists
+- [`router.getRoutes()`](/api/interfaces/Router.md#getRoutes): get an array with all the route records.
diff --git a/packages/docs/fa/guide/advanced/extending-router-link.md b/packages/docs/fa/guide/advanced/extending-router-link.md
new file mode 100644
index 000000000..859b690b5
--- /dev/null
+++ b/packages/docs/fa/guide/advanced/extending-router-link.md
@@ -0,0 +1,94 @@
+# گسترش RouterLink
+
+<VueSchoolLink
+  href="https://vueschool.io/lessons/extending-router-link-for-external-urls"
+  title="Learn how to extend router-link"
+/>
+
+The RouterLink component exposes enough `props` to suffice most basic applications but it doesn't try to cover every possible use case and you will likely find yourself using `v-slot` for some advanced cases. In most medium to large sized applications, it's worth creating one if not multiple custom RouterLink components to reuse them across your application. Some examples are Links in a Navigation Menu, handling external links, adding an `inactive-class`, etc.
+
+Let's extend RouterLink to handle external links as well and adding a custom `inactive-class` in an `AppLink.vue` file:
+
+```vue
+<template>
+  <a v-if="isExternalLink" v-bind="$attrs" :href="to" target="_blank">
+    <slot />
+  </a>
+  <router-link
+    v-else
+    v-bind="$props"
+    custom
+    v-slot="{ isActive, href, navigate }"
+  >
+    <a
+      v-bind="$attrs"
+      :href="href"
+      @click="navigate"
+      :class="isActive ? activeClass : inactiveClass"
+    >
+      <slot />
+    </a>
+  </router-link>
+</template>
+
+<script>
+import { RouterLink } from 'vue-router'
+
+export default {
+  name: 'AppLink',
+  inheritAttrs: false,
+
+  props: {
+    // add @ts-ignore if using TypeScript
+    ...RouterLink.props,
+    inactiveClass: String,
+  },
+
+  computed: {
+    isExternalLink() {
+      return typeof this.to === 'string' && this.to.startsWith('http')
+    },
+  },
+}
+</script>
+```
+
+If you prefer using a render function or create `computed` properties, you can use the `useLink` from the [Composition API](./composition-api.md):
+
+```js
+import { RouterLink, useLink } from 'vue-router'
+
+export default {
+  name: 'AppLink',
+
+  props: {
+    // add @ts-ignore if using TypeScript
+    ...RouterLink.props,
+    inactiveClass: String,
+  },
+
+  setup(props) {
+    // `props` contains `to` and any other prop that can be passed to <router-link>
+    const { navigate, href, route, isActive, isExactActive } = useLink(props)
+
+    // profit!
+
+    return { isExternalLink }
+  },
+}
+```
+
+In practice, you might want to use your `AppLink` component for different parts of your application. e.g. using [Tailwind CSS](https://tailwindcss.com), you could create a `NavLink.vue` component with all the classes:
+
+```vue
+<template>
+  <AppLink
+    v-bind="$attrs"
+    class="inline-flex items-center px-1 pt-1 border-b-2 border-transparent text-sm font-medium leading-5 text-gray-500 hover:text-gray-700 hover:border-gray-300 focus:outline-none focus:text-gray-700 focus:border-gray-300 transition duration-150 ease-in-out"
+    active-class="border-indigo-500 text-gray-900 focus:border-indigo-700"
+    inactive-class="text-gray-500 hover:text-gray-700 hover:border-gray-300 focus:text-gray-700 focus:border-gray-300"
+  >
+    <slot />
+  </AppLink>
+</template>
+```
diff --git a/packages/docs/fa/guide/advanced/lazy-loading.md b/packages/docs/fa/guide/advanced/lazy-loading.md
new file mode 100644
index 000000000..1dde03daf
--- /dev/null
+++ b/packages/docs/fa/guide/advanced/lazy-loading.md
@@ -0,0 +1,86 @@
+# مسیرهای تنبل(Lazy Loading)
+
+<VueSchoolLink
+  href="https://vueschool.io/lessons/lazy-loading-routes-vue-cli-only"
+  title="Learn about lazy loading routes"
+/>
+
+When building apps with a bundler, the JavaScript bundle can become quite large, and thus affect the page load time. It would be more efficient if we can split each route's components into separate chunks, and only load them when the route is visited.
+
+Vue Router supports [dynamic imports](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/import) out of the box, meaning you can replace static imports with dynamic ones:
+
+```js
+// replace
+// import UserDetails from './views/UserDetails'
+// with
+const UserDetails = () => import('./views/UserDetails.vue')
+
+const router = createRouter({
+  // ...
+  routes: [
+    { path: '/users/:id', component: UserDetails }
+    // or use it directly in the route definition
+    { path: '/users/:id', component: () => import('./views/UserDetails.vue') },
+  ],
+})
+```
+
+The `component` (and `components`) option accepts a function that returns a Promise of a component and Vue Router **will only fetch it when entering the page for the first time**, then use the cached version. Which means you can also have more complex functions as long as they return a Promise:
+
+```js
+const UserDetails = () =>
+  Promise.resolve({
+    /* component definition */
+  })
+```
+
+In general, it's a good idea **to always use dynamic imports** for all your routes.
+
+::: tip Note
+Do **not** use [Async components](https://vuejs.org/guide/components/async.html) for routes. Async components can still be used inside route components but route component themselves are just dynamic imports.
+:::
+
+When using a bundler like webpack, this will automatically benefit from [code splitting](https://webpack.js.org/guides/code-splitting/)
+
+When using Babel, you will need to add the [syntax-dynamic-import](https://babeljs.io/docs/plugins/syntax-dynamic-import/) plugin so that Babel can properly parse the syntax.
+
+## Grouping Components in the Same Chunk
+
+### With webpack
+
+Sometimes we may want to group all the components nested under the same route into the same async chunk. To achieve that we need to use [named chunks](https://webpack.js.org/guides/code-splitting/#dynamic-imports) by providing a chunk name using a special comment syntax (requires webpack > 2.4):
+
+```js
+const UserDetails = () =>
+  import(/* webpackChunkName: "group-user" */ './UserDetails.vue')
+const UserDashboard = () =>
+  import(/* webpackChunkName: "group-user" */ './UserDashboard.vue')
+const UserProfileEdit = () =>
+  import(/* webpackChunkName: "group-user" */ './UserProfileEdit.vue')
+```
+
+webpack will group any async module with the same chunk name into the same async chunk.
+
+### With Vite
+
+In Vite you can define the chunks under the [`rollupOptions`](https://vitejs.dev/config/#build-rollupoptions):
+
+```js
+// vite.config.js
+export default defineConfig({
+  build: {
+    rollupOptions: {
+      // https://rollupjs.org/guide/en/#outputmanualchunks
+      output: {
+        manualChunks: {
+          'group-user': [
+            './src/UserDetails',
+            './src/UserDashboard',
+            './src/UserProfileEdit',
+          ],
+        },
+      },
+    },
+  },
+})
+```
diff --git a/packages/docs/fa/guide/advanced/meta.md b/packages/docs/fa/guide/advanced/meta.md
new file mode 100644
index 000000000..07e50b0bf
--- /dev/null
+++ b/packages/docs/fa/guide/advanced/meta.md
@@ -0,0 +1,80 @@
+# فیلدهای متا
+
+<VueSchoolLink
+  href="https://vueschool.io/lessons/route-meta-fields"
+  title="Learn how to use route meta fields"
+/>
+
+Sometimes, you might want to attach arbitrary information to routes like： transition names, or roles to control who can access the route, etc. This can be achieved through the `meta` property which accepts an object of properties and can be accessed on the route location and navigation guards. You can define `meta` properties like this:
+
+```js
+const routes = [
+  {
+    path: '/posts',
+    component: PostsLayout,
+    children: [
+      {
+        path: 'new',
+        component: PostsNew,
+        // only authenticated users can create posts
+        meta: { requiresAuth: true },
+      },
+      {
+        path: ':id',
+        component: PostsDetail,
+        // anybody can read a post
+        meta: { requiresAuth: false },
+      },
+    ],
+  },
+]
+```
+
+So how do we access this `meta` field?
+
+<!-- TODO: the explanation about route records should be explained before and things should be moved here -->
+
+First, each route object in the `routes` configuration is called a **route record**. Route records may be nested. Therefore when a route is matched, it can potentially match more than one route record.
+
+For example, with the above route config, the URL `/posts/new` will match both the parent route record (`path: '/posts'`) and the child route record (`path: 'new'`).
+
+All route records matched by a route are exposed on the `$route` object (and also route objects in navigation guards) as the `$route.matched` Array. We could loop through that array to check all `meta` fields, but Vue Router also provides you a `$route.meta` that is a non-recursive merge of **all `meta`** fields from parent to child. Meaning you can simply write
+
+```js
+router.beforeEach((to, from) => {
+  // instead of having to check every route record with
+  // to.matched.some(record => record.meta.requiresAuth)
+  if (to.meta.requiresAuth && !auth.isLoggedIn()) {
+    // this route requires auth, check if logged in
+    // if not, redirect to login page.
+    return {
+      path: '/login',
+      // save the location we were at to come back later
+      query: { redirect: to.fullPath },
+    }
+  }
+})
+```
+
+## TypeScript
+
+It is possible to type the meta field by extending the `RouteMeta` interface from `vue-router`:
+
+```ts
+// This can be directly added to any of your `.ts` files like `router.ts`
+// It can also be added to a `.d.ts` file. Make sure it's included in
+// project's tsconfig.json "files"
+import 'vue-router'
+
+// To ensure it is treated as a module, add at least one `export` statement
+export {}
+
+declare module 'vue-router' {
+  interface RouteMeta {
+    // is optional
+    isAdmin?: boolean
+    // must be declared by every route
+    requiresAuth: boolean
+  }
+}
+```
diff --git a/packages/docs/fa/guide/advanced/navigation-failures.md b/packages/docs/fa/guide/advanced/navigation-failures.md
new file mode 100644
index 000000000..875d6cca1
--- /dev/null
+++ b/packages/docs/fa/guide/advanced/navigation-failures.md
@@ -0,0 +1,110 @@
+# در انتظار نتیجه یک مسیریابی
+
+<VueSchoolLink
+  href="https://vueschool.io/lessons/vue-router-4-detecting-navigation-failures"
+  title="Learn how to detect navigation failures"
+/>
+
+When using `router-link`, Vue Router calls `router.push` to trigger a navigation. While the expected behavior for most links is to navigate a user to a new page, there are a few situations where users will remain on the same page:
+
+- Users are already on the page that they are trying to navigate to.
+- A [navigation guard](./navigation-guards.md) aborts the navigation by doing `return false`.
+- A new navigation guard takes place while the previous one not finished.
+- A [navigation guard](./navigation-guards.md) redirects somewhere else by returning a new location (e.g. `return '/login'`).
+- A [navigation guard](./navigation-guards.md) throws an `Error`.
+
+If we want to do something after a navigation is finished, we need a way to wait after calling `router.push`. Imagine we have a mobile menu that allows us to go to different pages and we only want to hide the menu once we have navigated to the new page, we might want to do something like this:
+
+```js
+router.push('/my-profile')
+this.isMenuOpen = false
+```
+
+But this will close the menu right away because **navigations are asynchronous**, we need to `await` the promise returned by `router.push`:
+
+```js
+await router.push('/my-profile')
+this.isMenuOpen = false
+```
+
+Now the menu will close once the navigation is finished but it will also close if the navigation was prevented. We need a way to detect if we actually changed the page we are on or not.
+
+## Detecting Navigation Failures
+
+If a navigation is prevented, resulting in the user staying on the same page, the resolved value of the `Promise` returned by `router.push` will be a _Navigation Failure_. Otherwise, it will be a _falsy_ value (usually `undefined`). This allows us to differentiate the case where we navigated away from where we are or not:
+
+```js
+const navigationResult = await router.push('/my-profile')
+
+if (navigationResult) {
+  // navigation prevented
+} else {
+  // navigation succeeded (this includes the case of a redirection)
+  this.isMenuOpen = false
+}
+```
+
+_Navigation Failures_ are `Error` instances with a few extra properties that gives us enough information to know what navigation was prevented and why. To check the nature of a navigation result, use the `isNavigationFailure` function:
+
+```js
+import { NavigationFailureType, isNavigationFailure } from 'vue-router'
+
+// trying to leave the editing page of an article without saving
+const failure = await router.push('/articles/2')
+
+if (isNavigationFailure(failure, NavigationFailureType.aborted)) {
+  // show a small notification to the user
+  showToast('You have unsaved changes, discard and leave anyway?')
+}
+```
+
+::: tip
+If you omit the second parameter: `isNavigationFailure(failure)`, it will only check if `failure` is a _Navigation Failure_.
+:::
+
+## Global navigation failures
+
+You can detect global navigation failures globally by using the [`router.afterEach()` navigation guard](./navigation-guards.md#Global-After-Hooks):
+
+```ts
+router.afterEach((to, from, failure) => {
+  if (failure) {
+    sendToAnalytics(to, from, failure)
+  }
+})
+```
+
+## Differentiating Navigation Failures
+
+As we said at the beginning, there are different situations aborting a navigation, all of them resulting in different _Navigation Failures_. They can be differentiated using the `isNavigationFailure` and `NavigationFailureType`. There are three different types:
+
+- `aborted`: `false` was returned inside of a navigation guard to the navigation.
+- `cancelled`: A new navigation took place before the current navigation could finish. e.g. `router.push` was called while waiting inside of a navigation guard.
+- `duplicated`: The navigation was prevented because we are already at the target location.
+
+## _Navigation Failures_'s properties
+
+All navigation failures expose `to` and `from` properties to reflect the current location as well as the target location for the navigation that failed:
+
+```js
+// trying to access the admin page
+router.push('/admin').then(failure => {
+  if (isNavigationFailure(failure, NavigationFailureType.aborted)) {
+    failure.to.path // '/admin'
+    failure.from.path // '/'
+  }
+})
+```
+
+In all cases, `to` and `from` are normalized route locations.
+
+## Detecting Redirections
+
+When returning a new location inside of a Navigation Guard, we are triggering a new navigation that overrides the ongoing one. Differently from other return values, a redirection doesn't prevent a navigation, **it creates a new one**. It is therefore checked differently, by reading the `redirectedFrom` property in a Route Location:
+
+```js
+await router.push('/my-profile')
+if (router.currentRoute.value.redirectedFrom) {
+  // redirectedFrom is resolved route location like to and from in navigation guards
+}
+```
diff --git a/packages/docs/fa/guide/advanced/navigation-guards.md b/packages/docs/fa/guide/advanced/navigation-guards.md
new file mode 100644
index 000000000..fbdfbc4db
--- /dev/null
+++ b/packages/docs/fa/guide/advanced/navigation-guards.md
@@ -0,0 +1,282 @@
+# گاردهای مسیریابی
+
+<VueSchoolLink
+  href="https://vueschool.io/lessons/route-guards"
+  title="Learn how to add navigation guards"
+/>
+
+As the name suggests, the navigation guards provided by Vue router are primarily used to guard navigations either by redirecting it or canceling it. There are a number of ways to hook into the route navigation process: globally, per-route, or in-component.
+
+## Global Before Guards
+
+You can register global before guards using `router.beforeEach`:
+
+```js
+const router = createRouter({ ... })
+
+router.beforeEach((to, from) => {
+  // ...
+  // explicitly return false to cancel the navigation
+  return false
+})
+```
+
+Global before guards are called in creation order, whenever a navigation is triggered. Guards may be resolved asynchronously, and the navigation is considered **pending** before all hooks have been resolved.
+
+Every guard function receives two arguments:
+
+- **`to`**: the target route location [in a normalized format](../../api/interfaces/RouteLocationNormalized.md) being navigated to.
+- **`from`**: the current route location [in a normalized format](../../api/interfaces/RouteLocationNormalized.md) being navigated away from.
+
+And can optionally return any of the following values:
+
+- `false`: cancel the current navigation. If the browser URL was changed (either manually by the user or via back button), it will be reset to that of the `from` route.
+- A [Route Location](../../api/#RouteLocationRaw): Redirect to a different location by passing a route location as if you were calling `router.push()`, which allows you to pass options like `replace: true` or `name: 'home'`. The current navigation is dropped and a new one is created with the same `from`.
+
+  ```js
+  router.beforeEach(async (to, from) => {
+    if (
+      // make sure the user is authenticated
+      !isAuthenticated &&
+      // ❗️ Avoid an infinite redirect
+      to.name !== 'Login'
+    ) {
+      // redirect the user to the login page
+      return { name: 'Login' }
+    }
+  })
+  ```
+
+It's also possible to throw an `Error` if an unexpected situation was met. This will also cancel the navigation and call any callback registered via [`router.onError()`](../../api/interfaces/Router.md#onError).
+
+If nothing, `undefined` or `true` is returned, **the navigation is validated**, and the next navigation guard is called.
+
+All of the things above **work the same way with `async` functions** and Promises:
+
+```js
+router.beforeEach(async (to, from) => {
+  // canUserAccess() returns `true` or `false`
+  const canAccess = await canUserAccess(to)
+  if (!canAccess) return '/login'
+})
+```
+
+### Optional third argument `next`
+
+In previous versions of Vue Router, it was also possible to use a _third argument_ `next`, this was a common source of mistakes and went through an [RFC](https://github.com/vuejs/rfcs/blob/master/active-rfcs/0037-router-return-guards.md#motivation) to remove it. However, it is still supported, meaning you can pass a third argument to any navigation guard. In that case, **you must call `next` exactly once** in any given pass through a navigation guard. It can appear more than once, but only if the logical paths have no overlap, otherwise the hook will never be resolved or produce errors. Here is **a bad example** of redirecting the user to `/login` if they are not authenticated:
+
+```js
+// BAD
+router.beforeEach((to, from, next) => {
+  if (to.name !== 'Login' && !isAuthenticated) next({ name: 'Login' })
+  // if the user is not authenticated, `next` is called twice
+  next()
+})
+```
+
+Here is the correct version:
+
+```js
+// GOOD
+router.beforeEach((to, from, next) => {
+  if (to.name !== 'Login' && !isAuthenticated) next({ name: 'Login' })
+  else next()
+})
+```
+
+## Global Resolve Guards
+
+You can register a global guard with `router.beforeResolve`. This is similar to `router.beforeEach` because it triggers on **every navigation**, but resolve guards are called right before the navigation is confirmed, **after all in-component guards and async route components are resolved**. Here is an example that ensures the user has given access to the Camera for routes that [have defined a custom meta](./meta.md) property `requiresCamera`:
+
+```js
+router.beforeResolve(async to => {
+  if (to.meta.requiresCamera) {
+    try {
+      await askForCameraPermission()
+    } catch (error) {
+      if (error instanceof NotAllowedError) {
+        // ... handle the error and then cancel the navigation
+        return false
+      } else {
+        // unexpected error, cancel the navigation and pass the error to the global handler
+        throw error
+      }
+    }
+  }
+})
+```
+
+`router.beforeResolve` is the ideal spot to fetch data or do any other operation that you want to avoid doing if the user cannot enter a page.
+
+<!-- TODO: how to combine with [`meta` fields](./meta.md) to create a [generic fetching mechanism](#TODO). -->
+
+## Global After Hooks
+
+You can also register global after hooks, however unlike guards, these hooks do not get a `next` function and cannot affect the navigation:
+
+```js
+router.afterEach((to, from) => {
+  sendToAnalytics(to.fullPath)
+})
+```
+
+<!-- TODO: maybe add links to examples -->
+
+They are useful for analytics, changing the title of the page, accessibility features like announcing the page and many other things.
+
+They also reflect [navigation failures](./navigation-failures.md) as the third argument:
+
+```js
+router.afterEach((to, from, failure) => {
+  if (!failure) sendToAnalytics(to.fullPath)
+})
+```
+
+Learn more about navigation failures on [its guide](./navigation-failures.md).
+
+## Global injections within guards
+
+Since Vue 3.3, it is possible to use `inject()` within navigation guards. This is useful for injecting global properties like the [pinia stores](https://pinia.vuejs.org). Anything that is provided with `app.provide()` is also accessible within `router.beforeEach()`, `router.beforeResolve()`, `router.afterEach()`:
+
+```ts
+// main.ts
+const app = createApp(App)
+app.provide('global', 'hello injections')
+
+// router.ts or main.ts
+router.beforeEach((to, from) => {
+  const global = inject('global') // 'hello injections'
+  // a pinia store
+  const userStore = useAuthStore()
+  // ...
+})
+```
+
+## Per-Route Guard
+
+You can define `beforeEnter` guards directly on a route's configuration object:
+
+```js
+const routes = [
+  {
+    path: '/users/:id',
+    component: UserDetails,
+    beforeEnter: (to, from) => {
+      // reject the navigation
+      return false
+    },
+  },
+]
+```
+
+`beforeEnter` guards **only trigger when entering the route**, they don't trigger when the `params`, `query` or `hash` change e.g. going from `/users/2` to `/users/3` or going from `/users/2#info` to `/users/2#projects`. They are only triggered when navigating **from a different** route.
+
+You can also pass an array of functions to `beforeEnter`, this is useful when reusing guards for different routes:
+
+```js
+function removeQueryParams(to) {
+  if (Object.keys(to.query).length)
+    return { path: to.path, query: {}, hash: to.hash }
+}
+
+function removeHash(to) {
+  if (to.hash) return { path: to.path, query: to.query, hash: '' }
+}
+
+const routes = [
+  {
+    path: '/users/:id',
+    component: UserDetails,
+    beforeEnter: [removeQueryParams, removeHash],
+  },
+  {
+    path: '/about',
+    component: UserDetails,
+    beforeEnter: [removeQueryParams],
+  },
+]
+```
+
+Note it is possible to achieve a similar behavior by using [route meta fields](./meta.md) and global navigation guards.
+
+## In-Component Guards
+
+Finally, you can directly define route navigation guards inside route components (the ones passed to the router configuration)
+
+### Using the options API
+
+You can add the following options to route components:
+
+- `beforeRouteEnter`
+- `beforeRouteUpdate`
+- `beforeRouteLeave`
+
+```js
+const UserDetails = {
+  template: `...`,
+  beforeRouteEnter(to, from) {
+    // called before the route that renders this component is confirmed.
+    // does NOT have access to `this` component instance,
+    // because it has not been created yet when this guard is called!
+  },
+  beforeRouteUpdate(to, from) {
+    // called when the route that renders this component has changed, but this component is reused in the new route.
+    // For example, given a route with params `/users/:id`, when we navigate between `/users/1` and `/users/2`,
+    // the same `UserDetails` component instance will be reused, and this hook will be called when that happens.
+    // Because the component is mounted while this happens, the navigation guard has access to `this` component instance.
+  },
+  beforeRouteLeave(to, from) {
+    // called when the route that renders this component is about to be navigated away from.
+    // As with `beforeRouteUpdate`, it has access to `this` component instance.
+  },
+}
+```
+
+The `beforeRouteEnter` guard does **NOT** have access to `this`, because the guard is called before the navigation is confirmed, thus the new entering component has not even been created yet.
+
+However, you can access the instance by passing a callback to `next`. The callback will be called when the navigation is confirmed, and the component instance will be passed to the callback as the argument:
+
+```js
+beforeRouteEnter (to, from, next) {
+  next(vm => {
+    // access to component public instance via `vm`
+  })
+}
+```
+
+Note that `beforeRouteEnter` is the only guard that supports passing a callback to `next`. For `beforeRouteUpdate` and `beforeRouteLeave`, `this` is already available, so passing a callback is unnecessary and therefore _not supported_:
+
+```js
+beforeRouteUpdate (to, from) {
+  // just use `this`
+  this.name = to.params.name
+}
+```
+
+The **leave guard** is usually used to prevent the user from accidentally leaving the route with unsaved edits. The navigation can be canceled by returning `false`.
+
+```js
+beforeRouteLeave (to, from) {
+  const answer = window.confirm('Do you really want to leave? you have unsaved changes!')
+  if (!answer) return false
+}
+```
+
+### Using the composition API
+
+If you are writing your component using the [composition API and a `setup` function](https://vuejs.org/api/composition-api-setup.html), you can add update and leave guards through `onBeforeRouteUpdate` and `onBeforeRouteLeave` respectively. Please refer to the [Composition API section](./composition-api.md#navigation-guards) for more details.
+
+## The Full Navigation Resolution Flow
+
+1. Navigation triggered.
+2. Call `beforeRouteLeave` guards in deactivated components.
+3. Call global `beforeEach` guards.
+4. Call `beforeRouteUpdate` guards in reused components.
+5. Call `beforeEnter` in route configs.
+6. Resolve async route components.
+7. Call `beforeRouteEnter` in activated components.
+8. Call global `beforeResolve` guards.
+9. Navigation is confirmed.
+10. Call global `afterEach` hooks.
+11. DOM updates triggered.
+12. Call callbacks passed to `next` in `beforeRouteEnter` guards with instantiated instances.
diff --git a/packages/docs/fa/guide/advanced/router-view-slot.md b/packages/docs/fa/guide/advanced/router-view-slot.md
new file mode 100644
index 000000000..22c2ac2e8
--- /dev/null
+++ b/packages/docs/fa/guide/advanced/router-view-slot.md
@@ -0,0 +1,73 @@
+# RouterView اسلات
+
+The RouterView component exposes a slot that can be used to render the route component:
+
+```vue-html
+<router-view v-slot="{ Component }">
+  <component :is="Component" />
+</router-view>
+```
+
+The code above is equivalent to using `<router-view />` without the slot, but the slot provides extra flexibility when we want to work with other features.
+
+## KeepAlive & Transition
+
+When working with the [KeepAlive](https://vuejs.org/guide/built-ins/keep-alive.html) component, we would usually want it to keep the route components alive, not the RouterView itself. We can achieve that by putting the KeepAlive inside the slot:
+
+```vue-html
+<router-view v-slot="{ Component }">
+  <keep-alive>
+    <component :is="Component" />
+  </keep-alive>
+</router-view>
+```
+
+Similarly, the slot allows us to use a [Transition](https://vuejs.org/guide/built-ins/transition.html) component to transition between route components:
+
+```vue-html
+<router-view v-slot="{ Component }">
+  <transition>
+    <component :is="Component" />
+  </transition>
+</router-view>
+```
+
+We can also use KeepAlive inside a Transition:
+
+```vue-html
+<router-view v-slot="{ Component }">
+  <transition>
+    <keep-alive>
+      <component :is="Component" />
+    </keep-alive>
+  </transition>
+</router-view>
+```
+
+For more information about using RouterView with the Transition component, see the [Transitions](./transitions) guide.
+
+## Passing props and slots
+
+We can use the slot to pass props or slots to the route component:
+
+```vue-html
+<router-view v-slot="{ Component }">
+  <component :is="Component" some-prop="a value">
+    <p>Some slotted content</p>
+  </component>
+</router-view>
+```
+
+In practice, this usually isn't something you would want to do, as the route components would **all need to use the same props and slots**. See [Passing Props to Route Components](../essentials/passing-props) for other ways to pass props.
+
+## Template refs
+
+Using the slot allows us to put a [template ref](https://vuejs.org/guide/essentials/template-refs.html) directly on the route component:
+
+```vue-html
+<router-view v-slot="{ Component }">
+  <component :is="Component" ref="mainContent" />
+</router-view>
+```
+
+If we put the ref on the `<router-view>` instead then the ref would be populated with the RouterView instance, rather than the route component.
diff --git a/packages/docs/fa/guide/advanced/scroll-behavior.md b/packages/docs/fa/guide/advanced/scroll-behavior.md
new file mode 100644
index 000000000..81a301036
--- /dev/null
+++ b/packages/docs/fa/guide/advanced/scroll-behavior.md
@@ -0,0 +1,115 @@
+# رفتار اسکرول
+
+<VueSchoolLink
+  href="https://vueschool.io/lessons/scroll-behavior"
+  title="Learn how to customize scroll behavior"
+/>
+
+When using client-side routing, we may want to scroll to top when navigating to a new route, or preserve the scrolling position of history entries just like real page reload does. Vue Router allows you to achieve these and even better, allows you to completely customize the scroll behavior on route navigation.
+
+**Note: this feature only works if the browser supports `history.pushState`.**
+
+When creating the router instance, you can provide the `scrollBehavior` function:
+
+```js
+const router = createRouter({
+  history: createWebHashHistory(),
+  routes: [...],
+  scrollBehavior (to, from, savedPosition) {
+    // return desired position
+  }
+})
+```
+
+The `scrollBehavior` function receives the `to` and `from` route objects, like [Navigation Guards](./navigation-guards.md). The third argument, `savedPosition`, is only available if this is a `popstate` navigation (triggered by the browser's back/forward buttons).
+
+The function can return a [`ScrollToOptions`](https://developer.mozilla.org/en-US/docs/Web/API/ScrollToOptions) position object:
+
+```js
+const router = createRouter({
+  scrollBehavior(to, from, savedPosition) {
+    // always scroll to top
+    return { top: 0 }
+  },
+})
+```
+
+You can also pass a CSS selector or a DOM element via `el`. In that scenario, `top` and `left` will be treated as relative offsets to that element.
+
+```js
+const router = createRouter({
+  scrollBehavior(to, from, savedPosition) {
+    // always scroll 10px above the element #main
+    return {
+      // could also be
+      // el: document.getElementById('main'),
+      el: '#main',
+      // 10px above the element
+      top: 10,
+    }
+  },
+})
+```
+
+If a falsy value or an empty object is returned, no scrolling will happen.
+
+Returning the `savedPosition` will result in a native-like behavior when navigating with back/forward buttons:
+
+```js
+const router = createRouter({
+  scrollBehavior(to, from, savedPosition) {
+    if (savedPosition) {
+      return savedPosition
+    } else {
+      return { top: 0 }
+    }
+  },
+})
+```
+
+If you want to simulate the "scroll to anchor" behavior:
+
+```js
+const router = createRouter({
+  scrollBehavior(to, from, savedPosition) {
+    if (to.hash) {
+      return {
+        el: to.hash,
+      }
+    }
+  },
+})
+```
+
+If your browser supports [scroll behavior](https://developer.mozilla.org/en-US/docs/Web/API/ScrollToOptions/behavior), you can make it smooth:
+
+```js
+const router = createRouter({
+  scrollBehavior(to, from, savedPosition) {
+    if (to.hash) {
+      return {
+        el: to.hash,
+        behavior: 'smooth',
+      }
+    }
+  }
+})
+```
+
+## Delaying the scroll
+
+Sometimes we need to wait a bit before scrolling in the page. For example, when dealing with transitions, we want to wait for the transition to finish before scrolling. To do this you can return a Promise that returns the desired position descriptor. Here is an example where we wait 500ms before scrolling:
+
+```js
+const router = createRouter({
+  scrollBehavior(to, from, savedPosition) {
+    return new Promise((resolve, reject) => {
+      setTimeout(() => {
+        resolve({ left: 0, top: 0 })
+      }, 500)
+    })
+  },
+})
+```
+
+It's possible to hook this up with events from a page-level transition component to make the scroll behavior play nicely with your page transitions, but due to the possible variance and complexity in use cases, we simply provide this primitive to enable specific userland implementations.
diff --git a/packages/docs/fa/guide/advanced/transitions.md b/packages/docs/fa/guide/advanced/transitions.md
new file mode 100644
index 000000000..1ab889499
--- /dev/null
+++ b/packages/docs/fa/guide/advanced/transitions.md
@@ -0,0 +1,84 @@
+# ترنزیشن‌ها
+
+<VueSchoolLink
+  href="https://vueschool.io/lessons/route-transitions"
+  title="Learn about route transitions"
+/>
+
+In order to use transitions on your route components and animate navigations, you need to use the [`<RouterView>` slot](./router-view-slot):
+
+```vue-html
+<router-view v-slot="{ Component }">
+  <transition name="fade">
+    <component :is="Component" />
+  </transition>
+</router-view>
+```
+
+[All transition APIs](https://vuejs.org/guide/built-ins/transition.html) work the same here.
+
+## Per-Route Transition
+
+The above usage will apply the same transition for all routes. If you want each route's component to have different transitions, you can instead combine [meta fields](./meta.md) and a dynamic `name` on `<transition>`:
+
+```js
+const routes = [
+  {
+    path: '/custom-transition',
+    component: PanelLeft,
+    meta: { transition: 'slide-left' },
+  },
+  {
+    path: '/other-transition',
+    component: PanelRight,
+    meta: { transition: 'slide-right' },
+  },
+]
+```
+
+```vue-html
+<router-view v-slot="{ Component, route }">
+  <!-- Use a custom transition or fallback to `fade` -->
+  <transition :name="route.meta.transition || 'fade'">
+    <component :is="Component" />
+  </transition>
+</router-view>
+```
+
+## Route-Based Dynamic Transition
+
+It is also possible to determine the transition to use dynamically based on the relationship between the target route and current route. Using a very similar snippet to the one just before:
+
+```vue-html
+<!-- use a dynamic transition name -->
+<router-view v-slot="{ Component, route }">
+  <transition :name="route.meta.transition">
+    <component :is="Component" />
+  </transition>
+</router-view>
+```
+
+We can add an [after navigation hook](./navigation-guards.md#Global-After-Hooks) to dynamically add information to the `meta` field based on the depth of the route
+
+```js
+router.afterEach((to, from) => {
+  const toDepth = to.path.split('/').length
+  const fromDepth = from.path.split('/').length
+  to.meta.transition = toDepth < fromDepth ? 'slide-right' : 'slide-left'
+})
+```
+
+## Forcing a transition between reused views
+
+Vue might automatically reuse components that look alike, avoiding any transition. Fortunately, it is possible [to add a `key` attribute](https://vuejs.org/api/built-in-special-attributes.html#key) to force transitions. This also allows you to trigger transitions while staying on the same route with different params:
+
+```vue-html
+<router-view v-slot="{ Component, route }">
+  <transition name="fade">
+    <component :is="Component" :key="route.path" />
+  </transition>
+</router-view>
+```
+
+<!-- TODO: interactive example -->
+<!-- See full example [here](https://github.com/vuejs/vue-router/blob/dev/examples/transitions/app.js). -->
diff --git a/packages/docs/fa/guide/advanced/typed-routes.md b/packages/docs/fa/guide/advanced/typed-routes.md
new file mode 100644
index 000000000..4c56fd11a
--- /dev/null
+++ b/packages/docs/fa/guide/advanced/typed-routes.md
@@ -0,0 +1,10 @@
+# مسیرهای تایپ‌گذاری‌شده (v4.1.0+)
+
+::: danger ‼️ Experimental feature
+
+Starting from v4.1.0, we are introducing a new feature called Typed Routes. This **experimental** feature is enabled through a Vite/webpack/Rollup plugin.
+
+![RouterLink to autocomplete](https://user-images.githubusercontent.com/664177/176442066-c4e7fa31-4f06-4690-a49f-ed0fd880dfca.png)
+
+[Check the v4.1 release notes](https://github.com/vuejs/router/releases/tag/v4.1.0) for more information about this feature.
+[Check out the plugin](https://github.com/posva/unplugin-vue-router) GitHub repository for installation instructions and documentation.
diff --git a/packages/docs/fa/guide/essentials/dynamic-matching.md b/packages/docs/fa/guide/essentials/dynamic-matching.md
new file mode 100644
index 000000000..99ab3a4e4
--- /dev/null
+++ b/packages/docs/fa/guide/essentials/dynamic-matching.md
@@ -0,0 +1,125 @@
+# تطبیق مسیر به صورت پویا با پارامترها
+
+<VueSchoolLink
+  href="https://vueschool.io/lessons/dynamic-routes"
+  title="Learn about dynamic route matching with params"
+/>
+
+Very often we will need to map routes with the given pattern to the same component. For example, we may have a `User` component which should be rendered for all users but with different user IDs. In Vue Router we can use a dynamic segment in the path to achieve that, we call that a _param_:
+
+```js
+const User = {
+  template: '<div>User</div>',
+}
+
+// these are passed to `createRouter`
+const routes = [
+  // dynamic segments start with a colon
+  { path: '/users/:id', component: User },
+]
+```
+
+Now URLs like `/users/johnny` and `/users/jolyne` will both map to the same route.
+
+A _param_ is denoted by a colon `:`. When a route is matched, the value of its _params_ will be exposed as `this.$route.params` in every component. Therefore, we can render the current user ID by updating `User`'s template to this:
+
+```js
+const User = {
+  template: '<div>User {{ $route.params.id }}</div>',
+}
+```
+
+You can have multiple _params_ in the same route, and they will map to corresponding fields on `$route.params`. Examples:
+
+| pattern                        | matched path             | \$route.params                           |
+| ------------------------------ | ------------------------ | ---------------------------------------- |
+| /users/:username               | /users/eduardo           | `{ username: 'eduardo' }`                |
+| /users/:username/posts/:postId | /users/eduardo/posts/123 | `{ username: 'eduardo', postId: '123' }` |
+
+In addition to `$route.params`, the `$route` object also exposes other useful information such as `$route.query` (if there is a query in the URL), `$route.hash`, etc. You can check out the full details in the [API Reference](../../api/interfaces/RouteLocationNormalized.md).
+
+A working demo of this example can be found [here](https://codesandbox.io/s/route-params-vue-router-examples-mlb14?from-embed&initialpath=%2Fusers%2Feduardo%2Fposts%2F1).
+
+<!-- <iframe
+  src="https://codesandbox.io/embed//route-params-vue-router-examples-mlb14?fontsize=14&theme=light&view=preview&initialpath=%2Fusers%2Feduardo%2Fposts%2F1"
+  style="width:100%; height:500px; border:0; border-radius: 4px; overflow:hidden;"
+  title="Route Params example"
+  allow="accelerometer; ambient-light-sensor; camera; encrypted-media; geolocation; gyroscope; hid; microphone; midi; payment; usb; vr; xr-spatial-tracking"
+  sandbox="allow-forms allow-modals allow-popups allow-presentation allow-same-origin allow-scripts"
+></iframe> -->
+
+## Reacting to Params Changes
+
+<VueSchoolLink
+  href="https://vueschool.io/lessons/reacting-to-param-changes"
+  title="Learn how to react to param changes"
+/>
+
+One thing to note when using routes with params is that when the user navigates from `/users/johnny` to `/users/jolyne`, **the same component instance will be reused**. Since both routes render the same component, this is more efficient than destroying the old instance and then creating a new one. **However, this also means that the lifecycle hooks of the component will not be called**.
+
+To react to params changes in the same component, you can simply watch anything on the `$route` object, in this scenario, the `$route.params`:
+
+```js
+const User = {
+  template: '...',
+  created() {
+    this.$watch(
+      () => this.$route.params,
+      (toParams, previousParams) => {
+        // react to route changes...
+      }
+    )
+  },
+}
+```
+
+Or, use the `beforeRouteUpdate` [navigation guard](../advanced/navigation-guards.md), which also allows to cancel the navigation:
+
+```js
+const User = {
+  template: '...',
+  async beforeRouteUpdate(to, from) {
+    // react to route changes...
+    this.userData = await fetchUser(to.params.id)
+  },
+}
+```
+
+## Catch all / 404 Not found Route
+
+<VueSchoolLink
+  href="https://vueschool.io/lessons/404-not-found-page"
+  title="Learn how to make a catch all/404 not found route"
+/>
+
+Regular params will only match characters in between url fragments, separated by `/`. If we want to match **anything**, we can use a custom _param_ regexp by adding the regexp inside parentheses right after the _param_:
+
+```js
+const routes = [
+  // will match everything and put it under `$route.params.pathMatch`
+  { path: '/:pathMatch(.*)*', name: 'NotFound', component: NotFound },
+  // will match anything starting with `/user-` and put it under `$route.params.afterUser`
+  { path: '/user-:afterUser(.*)', component: UserGeneric },
+]
+```
+
+In this specific scenario, we are using a [custom regexp](./route-matching-syntax.md#custom-regexp-in-params) between parentheses and marking the `pathMatch` param as [optionally repeatable](./route-matching-syntax.md#optional-parameters). This allows us to directly navigate to the route if we need to by splitting the `path` into an array:
+
+```js
+this.$router.push({
+  name: 'NotFound',
+  // preserve current path and remove the first char to avoid the target URL starting with `//`
+  params: { pathMatch: this.$route.path.substring(1).split('/') },
+  // preserve existing query and hash if any
+  query: this.$route.query,
+  hash: this.$route.hash,
+})
+```
+
+See more in the [repeated params](./route-matching-syntax.md#Repeatable-params) section.
+
+If you are using [History mode](./history-mode.md), make sure to follow the instructions to correctly configure your server as well.
+
+## Advanced Matching Patterns
+
+Vue Router uses its own path matching syntax, inspired by the one used by `express`, so it supports many advanced matching patterns such as optional params, zero or more / one or more requirements, and even custom regex patterns. Please check the [Advanced Matching](./route-matching-syntax.md) documentation to explore them.
diff --git a/packages/docs/fa/guide/essentials/history-mode.md b/packages/docs/fa/guide/essentials/history-mode.md
new file mode 100644
index 000000000..af8bfa24b
--- /dev/null
+++ b/packages/docs/fa/guide/essentials/history-mode.md
@@ -0,0 +1,217 @@
+# حالت‌های متفاوت هیستوری
+
+<VueSchoolLink
+  href="https://vueschool.io/lessons/history-mode"
+  title="Learn about the differences between Hash Mode and HTML5 Mode"
+/>
+
+The `history` option when creating the router instance allows us to choose among different history modes.
+
+## Hash Mode
+
+The hash history mode is created with `createWebHashHistory()`:
+
+```js
+import { createRouter, createWebHashHistory } from 'vue-router'
+
+const router = createRouter({
+  history: createWebHashHistory(),
+  routes: [
+    //...
+  ],
+})
+```
+
+It uses a hash character (`#`) before the actual URL that is internally passed. Because this section of the URL is never sent to the server, it doesn't require any special treatment on the server level. **It does however have a bad impact in SEO**. If that's a concern for you, use the HTML5 history mode.
+
+## HTML5 Mode
+
+The HTML5 mode is created with `createWebHistory()` and is the recommended mode:
+
+```js
+import { createRouter, createWebHistory } from 'vue-router'
+
+const router = createRouter({
+  history: createWebHistory(),
+  routes: [
+    //...
+  ],
+})
+```
+
+When using `createWebHistory()`, the URL will look "normal," e.g. `https://example.com/user/id`. Beautiful!
+
+Here comes a problem, though: Since our app is a single page client side app, without a proper server configuration, the users will get a 404 error if they access `https://example.com/user/id` directly in their browser. Now that's ugly.
+
+Not to worry: To fix the issue, all you need to do is add a simple catch-all fallback route to your server. If the URL doesn't match any static assets, it should serve the same `index.html` page that your app lives in. Beautiful, again!
+
+## Memory mode
+
+The memory history mode doesn't assume a browser environment and therefore doesn't interact with the URL **nor automatically triggers the initial navigation**. This makes it perfect for Node environment and SSR. It is created with `createMemoryHistory()` and **requires you to push the initial navigation** after calling `app.use(router)`.
+
+```js
+import { createRouter, createMemoryHistory } from 'vue-router'
+
+const router = createRouter({
+  history: createMemoryHistory(),
+  routes: [
+    //...
+  ],
+})
+```
+
+While it's not recommended, you can use this mode inside Browser applications but note **there will be no history**, meaning you won't be able to go _back_ or _forward_.
+
+## Example Server Configurations
+
+**Note**: The following examples assume you are serving your app from the root folder. If you deploy to a subfolder, you should use [the `publicPath` option of Vue CLI](https://cli.vuejs.org/config/#publicpath) and the related [`base` property of the router](../../api/interfaces/Router.md#createWebHistory). You also need to adjust the examples below to use the subfolder instead of the root folder (e.g. replacing `RewriteBase /` with `RewriteBase /name-of-your-subfolder/`).
+
+### Apache
+
+```
+<IfModule mod_negotiation.c>
+  Options -MultiViews
+</IfModule>
+
+<IfModule mod_rewrite.c>
+  RewriteEngine On
+  RewriteBase /
+  RewriteRule ^index\.html$ - [L]
+  RewriteCond %{REQUEST_FILENAME} !-f
+  RewriteCond %{REQUEST_FILENAME} !-d
+  RewriteRule . /index.html [L]
+</IfModule>
+```
+
+Instead of `mod_rewrite`, you could also use [`FallbackResource`](https://httpd.apache.org/docs/2.4/mod/mod_dir.html#fallbackresource).
+
+### nginx
+
+```nginx
+location / {
+  try_files $uri $uri/ /index.html;
+}
+```
+
+### Native Node.js
+
+```js
+const http = require('http')
+const fs = require('fs')
+const httpPort = 80
+
+http
+  .createServer((req, res) => {
+    fs.readFile('index.html', 'utf-8', (err, content) => {
+      if (err) {
+        console.log('We cannot open "index.html" file.')
+      }
+
+      res.writeHead(200, {
+        'Content-Type': 'text/html; charset=utf-8',
+      })
+
+      res.end(content)
+    })
+  })
+  .listen(httpPort, () => {
+    console.log('Server listening on: http://localhost:%s', httpPort)
+  })
+```
+
+### Express with Node.js
+
+For Node.js/Express, consider using [connect-history-api-fallback middleware](https://github.com/bripkens/connect-history-api-fallback).
+
+### Internet Information Services (IIS)
+
+1. Install [IIS UrlRewrite](https://www.iis.net/downloads/microsoft/url-rewrite)
+2. Create a `web.config` file in the root directory of your site with the following:
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+  <system.webServer>
+    <rewrite>
+      <rules>
+        <rule name="Handle History Mode and custom 404/500" stopProcessing="true">
+          <match url="(.*)" />
+          <conditions logicalGrouping="MatchAll">
+            <add input="{REQUEST_FILENAME}" matchType="IsFile" negate="true" />
+            <add input="{REQUEST_FILENAME}" matchType="IsDirectory" negate="true" />
+          </conditions>
+          <action type="Rewrite" url="/" />
+        </rule>
+      </rules>
+    </rewrite>
+  </system.webServer>
+</configuration>
+```
+
+### Caddy v2
+
+```
+try_files {path} /
+```
+
+### Caddy v1
+
+```
+rewrite {
+    regexp .*
+    to {path} /
+}
+```
+
+### Firebase hosting
+
+Add this to your `firebase.json`:
+
+```json
+{
+  "hosting": {
+    "public": "dist",
+    "rewrites": [
+      {
+        "source": "**",
+        "destination": "/index.html"
+      }
+    ]
+  }
+}
+```
+
+### Netlify
+
+Create a `_redirects` file that is included with your deployed files:
+
+```
+/* /index.html 200
+```
+
+In vue-cli, nuxt, and vite projects, this file usually goes under a folder named `static` or `public`.
+
+You can read more about the syntax on [Netlify documentation](https://docs.netlify.com/routing/redirects/rewrites-proxies/#history-pushstate-and-single-page-apps). You can also [create a `netlify.toml`](https://docs.netlify.com/configure-builds/file-based-configuration/) to combine _redirections_ with other Netlify features.
+
+### Vercel
+
+Create a `vercel.json` file under the root directory of your project with the following:
+
+```json
+{
+  "rewrites": [{ "source": "/:path*", "destination": "/index.html" }]
+}
+```
+
+## Caveat
+
+There is a caveat to this: Your server will no longer report 404 errors as all not-found paths now serve up your `index.html` file. To get around the issue, you should implement a catch-all route within your Vue app to show a 404 page:
+
+```js
+const router = createRouter({
+  history: createWebHistory(),
+  routes: [{ path: '/:pathMatch(.*)', component: NotFoundComponent }],
+})
+```
+
+Alternatively, if you are using a Node.js server, you can implement the fallback by using the router on the server side to match the incoming URL and respond with 404 if no route is matched. Check out the [Vue server side rendering documentation](https://vuejs.org/guide/scaling-up/ssr.html) for more information.
diff --git a/packages/docs/fa/guide/essentials/named-routes.md b/packages/docs/fa/guide/essentials/named-routes.md
new file mode 100644
index 000000000..15d41874e
--- /dev/null
+++ b/packages/docs/fa/guide/essentials/named-routes.md
@@ -0,0 +1,43 @@
+# مسیرهای نام‌گذاری‌شده
+
+<VueSchoolLink
+  href="https://vueschool.io/lessons/named-routes"
+  title="Learn about the named routes"
+/>
+
+Alongside the `path`, you can provide a `name` to any route. This has the following advantages:
+
+- No hardcoded URLs
+- Automatic encoding/decoding of `params`
+- Prevents you from having a typo in the url
+- Bypassing path ranking (e.g. to display a )
+
+```js
+const routes = [
+  {
+    path: '/user/:username',
+    name: 'user',
+    component: User
+  }
+]
+```
+
+To link to a named route, you can pass an object to the `router-link` component's `to` prop:
+
+```vue-html
+<router-link :to="{ name: 'user', params: { username: 'erina' }}">
+  User
+</router-link>
+```
+
+This is the exact same object used programmatically with `router.push()`:
+
+```js
+router.push({ name: 'user', params: { username: 'erina' } })
+```
+
+In both cases, the router will navigate to the path `/user/erina`.
+
+Full example [here](https://github.com/vuejs/vue-router/blob/dev/examples/named-routes/app.js).
+
+Each name **must be unique** across all routes. If you add the same name to multiple routes, the router will only keep the last one. You can read more about this [in the Dynamic Routing](../advanced/dynamic-routing.md#Removing-routes) section.
diff --git a/packages/docs/fa/guide/essentials/named-views.md b/packages/docs/fa/guide/essentials/named-views.md
new file mode 100644
index 000000000..59163453f
--- /dev/null
+++ b/packages/docs/fa/guide/essentials/named-views.md
@@ -0,0 +1,94 @@
+# View های نام‌گذاری‌شده
+
+<VueSchoolLink
+  href="https://vueschool.io/lessons/vue-router-4-named-views"
+  title="Learn how to use named views"
+/>
+
+Sometimes you need to display multiple views at the same time instead of nesting them, e.g. creating a layout with a `sidebar` view and a `main` view. This is where named views come in handy. Instead of having one single outlet in your view, you can have multiple and give each of them a name. A `router-view` without a name will be given `default` as its name.
+
+```vue-html
+<router-view class="view left-sidebar" name="LeftSidebar"></router-view>
+<router-view class="view main-content"></router-view>
+<router-view class="view right-sidebar" name="RightSidebar"></router-view>
+```
+
+A view is rendered by using a component, therefore multiple views require
+multiple components for the same route. Make sure to use the `components` (with
+an **s**) option:
+
+```js
+const router = createRouter({
+  history: createWebHashHistory(),
+  routes: [
+    {
+      path: '/',
+      components: {
+        default: Home,
+        // short for LeftSidebar: LeftSidebar
+        LeftSidebar,
+        // they match the `name` attribute on `<router-view>`
+        RightSidebar,
+      },
+    },
+  ],
+})
+```
+
+A working demo of this example can be found [here](https://codesandbox.io/s/named-views-vue-router-4-examples-rd20l).
+
+## Nested Named Views
+
+It is possible to create complex layouts using named views with nested views. When doing so, you will also need to give nested `router-view` a name. Let's take a Settings panel example:
+
+```
+/settings/emails                                       /settings/profile
++-----------------------------------+                  +------------------------------+
+| UserSettings                      |                  | UserSettings                 |
+| +-----+-------------------------+ |                  | +-----+--------------------+ |
+| | Nav | UserEmailsSubscriptions | |  +------------>  | | Nav | UserProfile        | |
+| |     +-------------------------+ |                  | |     +--------------------+ |
+| |     |                         | |                  | |     | UserProfilePreview | |
+| +-----+-------------------------+ |                  | +-----+--------------------+ |
++-----------------------------------+                  +------------------------------+
+```
+
+- `Nav` is just a regular component
+- `UserSettings` is the parent view component
+- `UserEmailsSubscriptions`, `UserProfile`, `UserProfilePreview` are nested view components
+
+**Note**: _Let's forget about how the HTML/CSS should look like to represent such layout and focus on the components used._
+
+The `<template>` section for `UserSettings` component in the above layout would look something like this:
+
+```vue-html
+<!-- UserSettings.vue -->
+<div>
+  <h1>User Settings</h1>
+  <NavBar />
+  <router-view />
+  <router-view name="helper" />
+</div>
+```
+
+Then you can achieve the layout above with this route configuration:
+
+```js
+{
+  path: '/settings',
+  // You could also have named views at the top
+  component: UserSettings,
+  children: [{
+    path: 'emails',
+    component: UserEmailsSubscriptions
+  }, {
+    path: 'profile',
+    components: {
+      default: UserProfile,
+      helper: UserProfilePreview
+    }
+  }]
+}
+```
+
+A working demo of this example can be found [here](https://codesandbox.io/s/nested-named-views-vue-router-4-examples-re9yl?&initialpath=%2Fsettings%2Femails).
diff --git a/packages/docs/fa/guide/essentials/navigation.md b/packages/docs/fa/guide/essentials/navigation.md
new file mode 100644
index 000000000..53a2f92a6
--- /dev/null
+++ b/packages/docs/fa/guide/essentials/navigation.md
@@ -0,0 +1,113 @@
+---
+sidebarDepth: 0
+---
+
+# مسیریابی به صورت برنامه‌ای
+
+<VueSchoolLink
+  href="https://vueschool.io/lessons/vue-router-4-programmatic-navigation"
+  title="Learn how to navigate programmatically"
+/>
+
+Aside from using `<router-link>` to create anchor tags for declarative navigation, we can do this programmatically using the router's instance methods.
+
+## Navigate to a different location
+
+**Note: The examples below refer to the router instance as `router`. Inside a component, you can access the router using the `$router` property, e.g. `this.$router.push(...)`. If you're using the Composition API, the router is accessible by calling [`useRouter()`](../advanced/composition-api).**
+
+To navigate to a different URL, use `router.push`. This method pushes a new entry into the history stack, so when the user clicks the browser back button they will be taken to the previous URL.
+
+This is the method called internally when you click a `<router-link>`, so clicking `<router-link :to="...">` is the equivalent of calling `router.push(...)`.
+
+| Declarative               | Programmatic       |
+| ------------------------- | ------------------ |
+| `<router-link :to="...">` | `router.push(...)` |
+
+The argument can be a string path, or a location descriptor object. Examples:
+
+```js
+// literal string path
+router.push('/users/eduardo')
+
+// object with path
+router.push({ path: '/users/eduardo' })
+
+// named route with params to let the router build the url
+router.push({ name: 'user', params: { username: 'eduardo' } })
+
+// with query, resulting in /register?plan=private
+router.push({ path: '/register', query: { plan: 'private' } })
+
+// with hash, resulting in /about#team
+router.push({ path: '/about', hash: '#team' })
+```
+
+**Note**: `params` are ignored if a `path` is provided, which is not the case for `query`, as shown in the example above. Instead, you need to provide the `name` of the route or manually specify the whole `path` with any parameter:
+
+```js
+const username = 'eduardo'
+// we can manually build the url but we will have to handle the encoding ourselves
+router.push(`/user/${username}`) // -> /user/eduardo
+// same as
+router.push({ path: `/user/${username}` }) // -> /user/eduardo
+// if possible use `name` and `params` to benefit from automatic URL encoding
+router.push({ name: 'user', params: { username } }) // -> /user/eduardo
+// `params` cannot be used alongside `path`
+router.push({ path: '/user', params: { username } }) // -> /user
+```
+
+When specifying `params`, make sure to either provide a `string` or `number` (or an array of these for [repeatable params](./route-matching-syntax.md#Repeatable-params)). **Any other type (like objects, booleans, etc) will be automatically stringified**. For [optional params](./route-matching-syntax.md#Optional-parameters), you can provide an empty string (`""`) or `null` as the value to remove it.
+
+Since the prop `to` accepts the same kind of object as `router.push`, the exact same rules apply to both of them.
+
+`router.push` and all the other navigation methods return a _Promise_ that allows us to wait till the navigation is finished and to know if it succeeded or failed. We will talk more about that in [Navigation Handling](../advanced/navigation-failures.md).
+
+## Replace current location
+
+It acts like `router.push`, the only difference is that it navigates without pushing a new history entry, as its name suggests - it replaces the current entry.
+
+| Declarative                       | Programmatic          |
+| --------------------------------- | --------------------- |
+| `<router-link :to="..." replace>` | `router.replace(...)` |
+
+It's also possible to directly add a property `replace: true` to the `to` argument that is passed to `router.push`:
+
+```js
+router.push({ path: '/home', replace: true })
+// equivalent to
+router.replace({ path: '/home' })
+```
+
+## Traverse history
+
+<VueSchoolLink
+  href="https://vueschool.io/lessons/go-back"
+  title="Learn how to use Vue Router to go back"
+/>
+
+This method takes a single integer as parameter that indicates by how many steps to go forward or go backward in the history stack, similar to `window.history.go(n)`.
+
+Examples
+
+```js
+// go forward by one record, the same as router.forward()
+router.go(1)
+
+// go back by one record, the same as router.back()
+router.go(-1)
+
+// go forward by 3 records
+router.go(3)
+
+// fails silently if there aren't that many records
+router.go(-100)
+router.go(100)
+```
+
+## History Manipulation
+
+You may have noticed that `router.push`, `router.replace` and `router.go` are counterparts of [`window.history.pushState`, `window.history.replaceState` and `window.history.go`](https://developer.mozilla.org/en-US/docs/Web/API/History), and they do imitate the `window.history` APIs.
+
+Therefore, if you are already familiar with [Browser History APIs](https://developer.mozilla.org/en-US/docs/Web/API/History_API), manipulating history will feel familiar when using Vue Router.
+
+It is worth mentioning that Vue Router navigation methods (`push`, `replace`, `go`) work consistently no matter the `history` option passed when creating the router instance.
diff --git a/packages/docs/fa/guide/essentials/nested-routes.md b/packages/docs/fa/guide/essentials/nested-routes.md
new file mode 100644
index 000000000..4f8a4b6f6
--- /dev/null
+++ b/packages/docs/fa/guide/essentials/nested-routes.md
@@ -0,0 +1,130 @@
+# مسیرهای تو در تو
+
+<VueSchoolLink
+  href="https://vueschool.io/lessons/nested-routes"
+  title="Learn about nested routes"
+/>
+
+Some applications' UIs are composed of components that are nested multiple levels deep. In this case, it is very common that the segments of a URL correspond to a certain structure of nested components, for example:
+
+```
+/user/johnny/profile                     /user/johnny/posts
++------------------+                  +-----------------+
+| User             |                  | User            |
+| +--------------+ |                  | +-------------+ |
+| | Profile      | |  +------------>  | | Posts       | |
+| |              | |                  | |             | |
+| +--------------+ |                  | +-------------+ |
++------------------+                  +-----------------+
+```
+
+With Vue Router, you can express this relationship using nested route configurations.
+
+Given the app we created in the last chapter:
+
+```html
+<div id="app">
+  <router-view></router-view>
+</div>
+```
+
+```js
+const User = {
+  template: '<div>User {{ $route.params.id }}</div>',
+}
+
+// these are passed to `createRouter`
+const routes = [{ path: '/user/:id', component: User }]
+```
+
+The `<router-view>` here is a top-level `router-view`. It renders the component matched by a top level route. Similarly, a rendered component can also contain its own, nested `<router-view>`. For example, if we add one inside the `User` component's template:
+
+```js
+const User = {
+  template: `
+    <div class="user">
+      <h2>User {{ $route.params.id }}</h2>
+      <router-view></router-view>
+    </div>
+  `,
+}
+```
+
+To render components into this nested `router-view`, we need to use the `children` option in any of the routes:
+
+```js
+const routes = [
+  {
+    path: '/user/:id',
+    component: User,
+    children: [
+      {
+        // UserProfile will be rendered inside User's <router-view>
+        // when /user/:id/profile is matched
+        path: 'profile',
+        component: UserProfile,
+      },
+      {
+        // UserPosts will be rendered inside User's <router-view>
+        // when /user/:id/posts is matched
+        path: 'posts',
+        component: UserPosts,
+      },
+    ],
+  },
+]
+```
+
+**Note that nested paths that start with `/` will be treated as root paths. This allows you to leverage the component nesting without having to use a nested URL.**
+
+As you can see, the `children` option is just another Array of routes like `routes` itself. Therefore, you can keep nesting views as much as you need.
+
+At this point, with the above configuration, when you visit `/user/eduardo`, nothing will be rendered inside `User`'s `router-view`, because no nested route is matched. Maybe you do want to render something there. In such case you can provide an empty nested path:
+
+```js
+const routes = [
+  {
+    path: '/user/:id',
+    component: User,
+    children: [
+      // UserHome will be rendered inside User's <router-view>
+      // when /user/:id is matched
+      { path: '', component: UserHome },
+
+      // ...other sub routes
+    ],
+  },
+]
+```
+
+A working demo of this example can be found [here](https://codesandbox.io/s/nested-views-vue-router-4-examples-hl326?initialpath=%2Fusers%2Feduardo).
+
+## Nested Named Routes
+
+When dealing with [Named Routes](./named-routes.md), you usually **name the children routes**:
+
+```js
+const routes = [
+  {
+    path: '/user/:id',
+    component: User,
+    // notice how only the child route has a name
+    children: [{ path: '', name: 'user', component: UserHome }],
+  },
+]
+```
+
+This will ensure navigating to `/user/:id` will always display the nested route.
+
+In some scenarios, you may want to navigate to a named route without navigating to the nested route. For example, if you want to navigate to `/user/:id` without displaying the nested route. In that case, you can **also** name the parent route but note **that reloading the page will always display the nested child** as it's considered a navigation to the path `/users/:id` instead of the named route:
+
+```js
+const routes = [
+  {
+    path: '/user/:id',
+    name: 'user-parent',
+    component: User,
+    children: [{ path: '', name: 'user', component: UserHome }],
+  },
+]
+```
diff --git a/packages/docs/fa/guide/essentials/passing-props.md b/packages/docs/fa/guide/essentials/passing-props.md
new file mode 100644
index 000000000..d5fcd75ca
--- /dev/null
+++ b/packages/docs/fa/guide/essentials/passing-props.md
@@ -0,0 +1,97 @@
+# ارسال پراپ‌ها به کامپوننت مسیرها
+
+<VueSchoolLink
+  href="https://vueschool.io/lessons/route-props"
+  title="Learn how to pass props to route components"
+/>
+
+Using `$route` in your component creates a tight coupling with the route which limits the flexibility of the component as it can only be used on certain URLs. While this is not necessarily a bad thing, we can decouple this behavior with a `props` option:
+
+We can replace
+
+```js
+const User = {
+  template: '<div>User {{ $route.params.id }}</div>'
+}
+const routes = [{ path: '/user/:id', component: User }]
+```
+
+with
+
+```js
+const User = {
+  // make sure to add a prop named exactly like the route param
+  props: ['id'],
+  template: '<div>User {{ id }}</div>'
+}
+const routes = [{ path: '/user/:id', component: User, props: true }]
+```
+
+This allows you to use the component anywhere, which makes the component easier to reuse and test.
+
+## Boolean mode
+
+When `props` is set to `true`, the `route.params` will be set as the component props.
+
+## Named views
+
+For routes with named views, you have to define the `props` option for each named view:
+
+```js
+const routes = [
+  {
+    path: '/user/:id',
+    components: { default: User, sidebar: Sidebar },
+    props: { default: true, sidebar: false }
+  }
+]
+```
+
+## Object mode
+
+When `props` is an object, this will be set as the component props as-is. Useful for when the props are static.
+
+```js
+const routes = [
+  {
+    path: '/promotion/from-newsletter',
+    component: Promotion,
+    props: { newsletterPopup: false }
+  }
+]
+```
+
+## Function mode
+
+You can create a function that returns props. This allows you to cast parameters into other types, combine static values with route-based values, etc.
+
+```js
+const routes = [
+  {
+    path: '/search',
+    component: SearchUser,
+    props: route => ({ query: route.query.q })
+  }
+]
+```
+
+The URL `/search?q=vue` would pass `{query: 'vue'}` as props to the `SearchUser` component.
+
+Try to keep the `props` function stateless, as it's only evaluated on route changes. Use a wrapper component if you need state to define the props, that way Vue can react to state changes.
+
+## Via RouterView
+
+You can also pass any props via the [`<RouterView>` slot](../advanced/router-view-slot):
+
+```vue-html
+<RouterView v-slot="{ Component }">
+  <component
+    :is="Component"
+    view-prop="value"
+   />
+</RouterView>
+```
+
+::: warning
+In this case, **all view components** will receive `view-prop`. This is usually not a good idea as  it means that all of the view components have declared a `view-prop` prop, which is not necessarily true. If possible, use any of the options above.
+:::
diff --git a/packages/docs/fa/guide/essentials/redirect-and-alias.md b/packages/docs/fa/guide/essentials/redirect-and-alias.md
new file mode 100644
index 000000000..52489caba
--- /dev/null
+++ b/packages/docs/fa/guide/essentials/redirect-and-alias.md
@@ -0,0 +1,113 @@
+# ریدایرکت و مخفف
+
+<VueSchoolLink
+  href="https://vueschool.io/lessons/vue-router-4-redirect-and-alias"
+  title="Learn how to use redirect and alias"
+/>
+
+## Redirect
+
+Redirecting is also done in the `routes` configuration. To redirect from `/home` to `/`:
+
+```js
+const routes = [{ path: '/home', redirect: '/' }]
+```
+
+The redirect can also be targeting a named route:
+
+```js
+const routes = [{ path: '/home', redirect: { name: 'homepage' } }]
+```
+
+Or even use a function for dynamic redirecting:
+
+```js
+const routes = [
+  {
+    // /search/screens -> /search?q=screens
+    path: '/search/:searchText',
+    redirect: to => {
+      // the function receives the target route as the argument
+      // we return a redirect path/location here.
+      return { path: '/search', query: { q: to.params.searchText } }
+    },
+  },
+  {
+    path: '/search',
+    // ...
+  },
+]
+```
+
+Note that **[Navigation Guards](../advanced/navigation-guards.md) are not applied on the route that redirects, only on its target**. e.g. In the above example, adding a `beforeEnter` guard to the `/home` route would not have any effect.
+
+When writing a `redirect`, you can omit the `component` option because it is never directly reached so there is no component to render. The only exception are [nested routes](./nested-routes.md): if a route record has `children` and a `redirect` property, it should also have a `component` property.
+
+### Relative redirecting
+
+It's also possible to redirect to a relative location:
+
+```js
+const routes = [
+  {
+    // will always redirect /users/123/posts to /users/123/profile
+    path: '/users/:id/posts',
+    redirect: to => {
+      // the function receives the target route as the argument
+      // a relative location doesn't start with `/`
+      // or { path: 'profile'}
+      return 'profile'
+    },
+  },
+]
+```
+
+## Alias
+
+A redirect means when the user visits `/home`, the URL will be replaced by `/`, and then matched as `/`. But what is an alias?
+
+**An alias of `/` as `/home` means when the user visits `/home`, the URL remains `/home`, but it will be matched as if the user is visiting `/`.**
+
+The above can be expressed in the route configuration as:
+
+```js
+const routes = [{ path: '/', component: Homepage, alias: '/home' }]
+```
+
+An alias gives you the freedom to map a UI structure to an arbitrary URL, instead of being constrained by the configuration's nesting structure. Make the alias start with a `/` to make the path absolute in nested routes. You can even combine both and provide multiple aliases with an array:
+
+```js
+const routes = [
+  {
+    path: '/users',
+    component: UsersLayout,
+    children: [
+      // this will render the UserList for these 3 URLs
+      // - /users
+      // - /users/list
+      // - /people
+      { path: '', component: UserList, alias: ['/people', 'list'] },
+    ],
+  },
+]
+```
+
+If your route has parameters, make sure to include them in any absolute alias:
+
+```js
+const routes = [
+  {
+    path: '/users/:id',
+    component: UsersByIdLayout,
+    children: [
+      // this will render the UserDetails for these 3 URLs
+      // - /users/24
+      // - /users/24/profile
+      // - /24
+      { path: 'profile', component: UserDetails, alias: ['/:id', ''] },
+    ],
+  },
+]
+```
+
+**Note about SEO**: when using aliases, make sure to [define canonical links](https://support.google.com/webmasters/answer/139066?hl=en).
diff --git a/packages/docs/fa/guide/essentials/route-matching-syntax.md b/packages/docs/fa/guide/essentials/route-matching-syntax.md
new file mode 100644
index 000000000..b7b4c74e4
--- /dev/null
+++ b/packages/docs/fa/guide/essentials/route-matching-syntax.md
@@ -0,0 +1,119 @@
+# نحو تطبیق مسیرها
+
+<VueSchoolLink
+  href="https://vueschool.io/lessons/vue-router-4-advanced-routes-matching-syntax"
+  title="Learn how to use advanced route routes' matching syntax"
+/>
+
+Most applications will use static routes like `/about` and dynamic routes like `/users/:userId` like we just saw in [Dynamic Route Matching](./dynamic-matching.md), but Vue Router has much more to offer!
+
+:::tip
+For the sake of simplicity, all route records **are omitting the `component` property** to focus on the `path` value.
+:::
+
+## Custom regex in params
+
+When defining a param like `:userId`, we internally use the following regex `([^/]+)` (at least one character that isn't a slash `/`) to extract params from URLs. This works well unless you need to differentiate two routes based on the param content. Imagine two routes `/:orderId` and `/:productName`, both would match the exact same URLs, so we need a way to differentiate them. The easiest way would be to add a static section to the path that differentiates them:
+
+```js
+const routes = [
+  // matches /o/3549
+  { path: '/o/:orderId' },
+  // matches /p/books
+  { path: '/p/:productName' },
+]
+```
+
+But in some scenarios we don't want to add that static section `/o`/`p`. However, `orderId` is always a number while `productName` can be anything, so we can specify a custom regex for a param in parentheses:
+
+```js
+const routes = [
+  // /:orderId -> matches only numbers
+  { path: '/:orderId(\\d+)' },
+  // /:productName -> matches anything else
+  { path: '/:productName' },
+]
+```
+
+Now, going to `/25` will match `/:orderId` while going to anything else will match `/:productName`. The order of the `routes` array doesn't even matter!
+
+:::tip
+Make sure to **escape backslashes (`\`)** like we did with `\d` (becomes `\\d`) to actually pass the backslash character in a string in JavaScript.
+:::
+
+## Repeatable params
+
+If you need to match routes with multiple sections like `/first/second/third`, you should mark a param as repeatable with `*` (0 or more) and `+` (1 or more):
+
+```js
+const routes = [
+  // /:chapters -> matches /one, /one/two, /one/two/three, etc
+  { path: '/:chapters+' },
+  // /:chapters -> matches /, /one, /one/two, /one/two/three, etc
+  { path: '/:chapters*' },
+]
+```
+
+This will give you an array of params instead of a string and will also require you to pass an array when using named routes:
+
+```js
+// given { path: '/:chapters*', name: 'chapters' },
+router.resolve({ name: 'chapters', params: { chapters: [] } }).href
+// produces /
+router.resolve({ name: 'chapters', params: { chapters: ['a', 'b'] } }).href
+// produces /a/b
+
+// given { path: '/:chapters+', name: 'chapters' },
+router.resolve({ name: 'chapters', params: { chapters: [] } }).href
+// throws an Error because `chapters` is empty
+```
+
+These can also be combined with a custom regex by adding them **after the closing parentheses**:
+
+```js
+const routes = [
+  // only match numbers
+  // matches /1, /1/2, etc
+  { path: '/:chapters(\\d+)+' },
+  // matches /, /1, /1/2, etc
+  { path: '/:chapters(\\d+)*' },
+]
+```
+
+## Sensitive and strict route options 
+
+By default, all routes are case-insensitive and match routes with or without a trailing slash. e.g. a route `/users` matches `/users`, `/users/`, and even `/Users/`. This behavior can be configured with the `strict` and `sensitive` options, they can be set both at a router and route level:
+
+```js
+const router = createRouter({
+  history: createWebHistory(),
+  routes: [
+    // will match /users/posva but not:
+    // - /users/posva/ because of strict: true
+    // - /Users/posva because of sensitive: true
+    { path: '/users/:id', sensitive: true },
+    // will match /users, /Users, and /users/42 but not /users/ or /users/42/
+    { path: '/users/:id?' },
+  ],
+  strict: true, // applies to all routes
+})
+```
+
+## Optional parameters
+
+You can also mark a parameter as optional by using the `?` modifier (0 or 1):
+
+```js
+const routes = [
+  // will match /users and /users/posva
+  { path: '/users/:userId?' },
+  // will match /users and /users/42
+  { path: '/users/:userId(\\d+)?' },
+]
+```
+
+Note that `*` technically also marks a parameter as optional but `?` parameters cannot be repeated.
+
+## Debugging
+
+If you need to dig how your routes are transformed into a regex to understand why a route isn't being matched or, to report a bug, you can use the [path ranker tool](https://paths.esm.dev/?p=AAMeJSyAwR4UbFDAFxAcAGAIJXMAAA..#). It supports sharing your routes through the URL.
diff --git a/packages/docs/fa/guide/index.md b/packages/docs/fa/guide/index.md
new file mode 100644
index 000000000..af809a962
--- /dev/null
+++ b/packages/docs/fa/guide/index.md
@@ -0,0 +1,101 @@
+# شروع شدن
+
+<VueSchoolLink
+href="https://vueschool.io/courses/vue-router-4-for-everyone"
+title="Learn how to build powerful Single Page Applications with the Vue Router on Vue School">Watch a Free Vue Router Video Course</VueSchoolLink>
+
+Creating a Single-page Application with Vue + Vue Router feels natural: with Vue.js, we are already composing our application with components. When adding Vue Router to the mix, all we need to do is map our components to the routes and let Vue Router know where to render them. Here's a basic example:
+
+## HTML
+
+```html
+<script src="https://unpkg.com/vue@3"></script>
+<script src="https://unpkg.com/vue-router@4"></script>
+
+<div id="app">
+  <h1>Hello App!</h1>
+  <p>
+    <!-- use the router-link component for navigation. -->
+    <!-- specify the link by passing the `to` prop. -->
+    <!-- `<router-link>` will render an `<a>` tag with the correct `href` attribute -->
+    <router-link to="/">Go to Home</router-link>
+    <router-link to="/about">Go to About</router-link>
+  </p>
+  <!-- route outlet -->
+  <!-- component matched by the route will render here -->
+  <router-view></router-view>
+</div>
+```
+
+### `router-link`
+
+Note how instead of using regular `a` tags, we use a custom component `router-link` to create links. This allows Vue Router to change the URL without reloading the page, handle URL generation as well as its encoding. We will see later how to benefit from these features.
+
+### `router-view`
+
+`router-view` will display the component that corresponds to the URL. You can put it anywhere to adapt it to your layout.
+
+<VueMasteryLogoLink></VueMasteryLogoLink>
+
+## JavaScript
+
+```js
+// 1. Define route components.
+// These can be imported from other files
+const Home = { template: '<div>Home</div>' }
+const About = { template: '<div>About</div>' }
+
+// 2. Define some routes
+// Each route should map to a component.
+// We'll talk about nested routes later.
+const routes = [
+  { path: '/', component: Home },
+  { path: '/about', component: About },
+]
+
+// 3. Create the router instance and pass the `routes` option
+// You can pass in additional options here, but let's
+// keep it simple for now.
+const router = VueRouter.createRouter({
+  // 4. Provide the history implementation to use. We are using the hash history for simplicity here.
+  history: VueRouter.createWebHashHistory(),
+  routes, // short for `routes: routes`
+})
+
+// 5. Create and mount the root instance.
+const app = Vue.createApp({})
+// Make sure to _use_ the router instance to make the
+// whole app router-aware.
+app.use(router)
+
+app.mount('#app')
+
+// Now the app has started!
+```
+
+By calling `app.use(router)`, we are triggering the initial navigation and giving access to `this.$router` as well as the current route as `this.$route` inside of any component:
+
+```js
+// Home.vue
+export default {
+  computed: {
+    username() {
+      // We will see what `params` is shortly
+      return this.$route.params.username
+    },
+  },
+  methods: {
+    goToDashboard() {
+      if (isAuthenticated) {
+        this.$router.push('/dashboard')
+      } else {
+        this.$router.push('/login')
+      }
+    },
+  },
+}
+```
+
+To access the router or the route inside the `setup` function, call the `useRouter` or `useRoute` functions. We will learn more about this in [the Composition API](./advanced/composition-api.md#Accessing-the-Router-and-current-Route-inside-setup)
+
+Throughout the docs, we will often use the `router` instance. Keep in mind that `this.$router` is exactly the same as directly using the `router` instance created through `createRouter`. The reason we use `this.$router` is because we don't want to import the router in every single component that needs to manipulate routing.
diff --git a/packages/docs/fa/guide/migration/index.md b/packages/docs/fa/guide/migration/index.md
new file mode 100644
index 000000000..07a6ede1f
--- /dev/null
+++ b/packages/docs/fa/guide/migration/index.md
@@ -0,0 +1,462 @@
+# مهاجرت از Vue 2
+
+Most of Vue Router API has remained unchanged during its rewrite from v3 (for Vue 2) to v4 (for Vue 3) but there are still a few breaking changes that you might encounter while migrating your application. This guide is here to help you understand why these changes happened and how to adapt your application to make it work with Vue Router 4.
+
+## Breaking Changes
+
+Changes are ordered by their usage. It is therefore recommended to follow this list in order.
+
+### new Router becomes createRouter
+
+Vue Router is no longer a class but a set of functions. Instead of writing `new Router()`, you now have to call `createRouter`:
+
+```js
+// previously was
+// import Router from 'vue-router'
+import { createRouter } from 'vue-router'
+
+const router = createRouter({
+  // ...
+})
+```
+
+### New `history` option to replace `mode`
+
+The `mode: 'history'` option has been replaced with a more flexible one named `history`. Depending on which mode you were using, you will have to replace it with the appropriate function:
+
+- `"history"`: `createWebHistory()`
+- `"hash"`: `createWebHashHistory()`
+- `"abstract"`: `createMemoryHistory()`
+
+Here is a full snippet:
+
+```js
+import { createRouter, createWebHistory } from 'vue-router'
+// there is also createWebHashHistory and createMemoryHistory
+
+createRouter({
+  history: createWebHistory(),
+  routes: [],
+})
+```
+
+On SSR, you need to manually pass the appropriate history:
+
+```js
+// router.js
+let history = isServer ? createMemoryHistory() : createWebHistory()
+let router = createRouter({ routes, history })
+// somewhere in your server-entry.js
+router.push(req.url) // request url
+router.isReady().then(() => {
+  // resolve the request
+})
+```
+
+**Reason**: enable tree shaking of non used histories as well as implementing custom histories for advanced use cases like native solutions.
+
+### Moved the `base` option
+
+The `base` option is now passed as the first argument to `createWebHistory` (and other histories):
+
+```js
+import { createRouter, createWebHistory } from 'vue-router'
+createRouter({
+  history: createWebHistory('/base-directory/'),
+  routes: [],
+})
+```
+
+### Removal of the `fallback` option
+
+The `fallback` option is no longer supported when creating the router:
+
+```diff
+-new VueRouter({
++createRouter({
+-  fallback: false,
+// other options...
+})
+```
+
+**Reason**: All browsers supported by Vue support the [HTML5 History API](https://developer.mozilla.org/en-US/docs/Web/API/History_API), allowing us to avoid hacks around modifying `location.hash` and directly use `history.pushState()`.
+
+### Removed `*` (star or catch all) routes
+
+Catch all routes (`*`, `/*`) must now be defined using a parameter with a custom regex:
+
+```js
+const routes = [
+  // pathMatch is the name of the param, e.g., going to /not/found yields
+  // { params: { pathMatch: ['not', 'found'] }}
+  // this is thanks to the last *, meaning repeated params and it is necessary if you
+  // plan on directly navigating to the not-found route using its name
+  { path: '/:pathMatch(.*)*', name: 'not-found', component: NotFound },
+  // if you omit the last `*`, the `/` character in params will be encoded when resolving or pushing
+  { path: '/:pathMatch(.*)', name: 'bad-not-found', component: NotFound },
+]
+// bad example if using named routes:
+router.resolve({
+  name: 'bad-not-found',
+  params: { pathMatch: 'not/found' },
+}).href // '/not%2Ffound'
+// good example:
+router.resolve({
+  name: 'not-found',
+  params: { pathMatch: ['not', 'found'] },
+}).href // '/not/found'
+```
+
+:::tip
+You don't need to add the `*` for repeated params if you don't plan to directly push to the not found route using its name. If you call `router.push('/not/found/url')`, it will provide the right `pathMatch` param.
+:::
+
+**Reason**: Vue Router doesn't use `path-to-regexp` anymore, instead it implements its own parsing system that allows route ranking and enables dynamic routing. Since we usually add one single catch-all route per project, there is no big benefit in supporting a special syntax for `*`. The encoding of params is encoding across routes, without exception to make things easier to predict.
+
+### The `currentRoute` property is now a `ref()`
+
+Previously the properties of the [`currentRoute`](https://v3.router.vuejs.org/api/#router-currentroute) object on a router instance could be accessed directly.
+
+With the introduction of vue-router v4, the underlying type of the `currentRoute` object on the router instance has changed to `Ref<RouteLocationNormalizedLoaded>`, which comes from the newer [reactivity fundamentals](https://vuejs.org/guide/essentials/reactivity-fundamentals.html) introduced in Vue 3.
+
+While this doesn't change anything if you're reading the route with `useRoute()` or `this.$route`, if you're accessing it directly on the router instance, you will need to access the actual route object via `currentRoute.value`:
+
+```ts
+const { page } = router.currentRoute.query // [!code --]
+const { page } = router.currentRoute.value.query // [!code ++]
+```
+
+### Replaced `onReady` with `isReady`
+
+The existing `router.onReady()` function has been replaced with `router.isReady()` which doesn't take any argument and returns a Promise:
+
+```js
+// replace
+router.onReady(onSuccess, onError)
+// with
+router.isReady().then(onSuccess).catch(onError)
+// or use await:
+try {
+  await router.isReady()
+  // onSuccess
+} catch (err) {
+  // onError
+}
+```
+
+### `scrollBehavior` changes
+
+The object returned in `scrollBehavior` is now similar to [`ScrollToOptions`](https://developer.mozilla.org/en-US/docs/Web/API/ScrollToOptions): `x` is renamed to `left` and `y` is renamed to `top`. See [RFC](https://github.com/vuejs/rfcs/blob/master/active-rfcs/0035-router-scroll-position.md).
+
+**Reason**: making the object similar to `ScrollToOptions` to make it feel more familiar with native JS APIs and potentially enable future new options.
+
+### `<router-view>`, `<keep-alive>`, and `<transition>`
+
+`transition` and `keep-alive` must now be used **inside** of `RouterView` via the `v-slot` API:
+
+```vue-html
+<router-view v-slot="{ Component }">
+  <transition>
+    <keep-alive>
+      <component :is="Component" />
+    </keep-alive>
+  </transition>
+</router-view>
+```
+
+**Reason**: This was a necessary change. See the [related RFC](https://github.com/vuejs/rfcs/blob/master/active-rfcs/0034-router-view-keep-alive-transitions.md).
+
+### Removal of `append` prop in `<router-link>`
+
+The `append` prop has been removed from `<router-link>`. You can manually concatenate the value to an existing `path` instead:
+
+```vue-html
+replace
+<router-link to="child-route" append>to relative child</router-link>
+with
+<router-link :to="append($route.path, 'child-route')">
+  to relative child
+</router-link>
+```
+
+You must define a global `append` function on your _App_ instance:
+
+```js
+app.config.globalProperties.append = (path, pathToAppend) =>
+  path + (path.endsWith('/') ? '' : '/') + pathToAppend
+```
+
+**Reason**: `append` wasn't used very often, is easy to replicate in user land.
+
+### Removal of `event` and `tag` props in `<router-link>`
+
+Both `event`, and `tag` props have been removed from `<router-link>`. You can use the [`v-slot` API](/guide/advanced/composition-api#uselink) to fully customize `<router-link>`:
+
+```vue-html
+replace
+<router-link to="/about" tag="span" event="dblclick">About Us</router-link>
+with
+<router-link to="/about" custom v-slot="{ navigate }">
+  <span @click="navigate" @keypress.enter="navigate" role="link">About Us</span>
+</router-link>
+```
+
+**Reason**: These props were often used together to use something different from an `<a>` tag but were introduced before the `v-slot` API and are not used enough to justify adding to the bundle size for everybody.
+
+### Removal of the `exact` prop in `<router-link>`
+
+The `exact` prop has been removed because the caveat it was fixing is no longer present so you should be able to safely remove it. There are however two things you should be aware of:
+
+- Routes are now active based on the route records they represent instead of the generated route location objects and their `path`, `query`, and `hash` properties
+- Only the `path` section is matched, `query`, and `hash` aren't taken into account anymore
+
+If you wish to customize this behavior, e.g. take into account the `hash` section, you should use the [`v-slot` API](/guide/advanced/composition-api#useLink) to extend `<router-link>`.
+
+**Reason**: See the [RFC about active matching](https://github.com/vuejs/rfcs/blob/master/active-rfcs/0028-router-active-link.md#summary) changes for more details.
+
+### Navigation guards in mixins are ignored
+
+At the moment navigation guards in mixins are not supported. You can track its support at [vue-router#454](https://github.com/vuejs/router/issues/454).
+
+### Removal of `router.match` and changes to `router.resolve`
+
+Both `router.match`, and `router.resolve` have been merged together into `router.resolve` with a slightly different signature. [Refer to the API](/api/interfaces/Router.md#resolve) for more details.
+
+**Reason**: Uniting multiple methods that were used for the same purpose.
+
+### Removal of `router.getMatchedComponents()`
+
+The method `router.getMatchedComponents` is now removed as matched components can be retrieved from `router.currentRoute.value.matched`:
+
+```js
+router.currentRoute.value.matched.flatMap(record =>
+  Object.values(record.components)
+)
+```
+
+**Reason**: This method was only used during SSR and is a one liner that can be done by the user.
+
+### Redirect records cannot use special paths
+
+Previously, a non documented feature allowed to set a redirect record to a special path like `/events/:id` and it would reuse an existing param `id`. This is no longer possible and there are two options:
+
+- Using the name of the route without the param: `redirect: { name: 'events' }`. Note this won't work if the param `:id` is optional
+- Using a function to recreate the new location based on the target: `redirect: to => ({ name: 'events', params: to.params })`
+
+**Reason**: This syntax was rarely used and _another way of doing things_ that wasn't shorter enough compared to the versions above while introducing some complexity and making the router heavier.
+
+### **All** navigations are now always asynchronous
+
+All navigations, including the first one, are now asynchronous, meaning that, if you use a `transition`, you may need to wait for the router to be _ready_ before mounting the app:
+
+```js
+app.use(router)
+// Note: on Server Side, you need to manually push the initial location
+router.isReady().then(() => app.mount('#app'))
+```
+
+Otherwise there will be an initial transition as if you provided the `appear` prop to `transition` because the router displays its initial location (nothing) and then displays the first location.
+
+Note that **if you have navigation guards upon the initial navigation**, you might not want to block the app render until they are resolved unless you are doing Server Side Rendering. In this scenario, not waiting the router to be ready to mount the app would yield the same result as in Vue 2.
+
+### Removal of `router.app`
+
+`router.app` used to represent the last root component (Vue instance) that injected the router. Vue Router can now be safely used by multiple Vue applications at the same time. You can still add it when using the router:
+
+```js
+app.use(router)
+router.app = app
+```
+
+You can also extend the TypeScript definition of the `Router` interface to add the `app` property.
+
+**Reason**: Vue 3 applications do not exist in Vue 2 and now we properly support multiple applications using the same Router instance, so having an `app` property would have been misleading because it would have been the application instead of the root instance.
+
+### Passing content to route components' `<slot>`
+
+Before you could directly pass a template to be rendered by a route components' `<slot>` by nesting it under a `<router-view>` component:
+
+```vue-html
+<router-view>
+  <p>In Vue Router 3, I render inside the route component</p>
+</router-view>
+```
+
+Because of the introduction of the `v-slot` api for `<router-view>`, you must pass it to the `<component>` using the `v-slot` API:
+
+```vue-html
+<router-view v-slot="{ Component }">
+  <component :is="Component">
+    <p>In Vue Router 3, I render inside the route component</p>
+  </component>
+</router-view>
+```
+
+### Removal of `parent` from route locations
+
+The `parent` property has been removed from normalized route locations (`this.$route` and object returned by `router.resolve`). You can still access it via the `matched` array:
+
+```js
+const parent = this.$route.matched[this.$route.matched.length - 2]
+```
+
+**Reason**: Having `parent` and `children` creates unnecessary circular references while the properties could be retrieved already through `matched`.
+
+### Removal of `pathToRegexpOptions`
+
+The `pathToRegexpOptions` and `caseSensitive` properties of route records have been replaced with `sensitive` and `strict` options for `createRouter()`. They can now also be directly passed when creating the router with `createRouter()`. Any other option specific to `path-to-regexp` has been removed as `path-to-regexp` is no longer used to parse paths.
+
+### Removal of unnamed parameters
+
+Due to the removal of `path-to-regexp`, unnamed parameters are no longer supported:
+
+- `/foo(/foo)?/suffix` becomes `/foo/:_(foo)?/suffix`
+- `/foo(foo)?` becomes `/foo:_(foo)?`
+- `/foo/(.*)` becomes `/foo/:_(.*)`
+
+:::tip
+Note you can use any name instead of `_` for the param. The point is to provide one.
+:::
+
+### Usage of `history.state`
+
+Vue Router saves information on the `history.state`. If you have any code manually calling `history.pushState()`, you should likely avoid it or refactor it with a regular `router.push()` and a `history.replaceState()`:
+
+```js
+// replace
+history.pushState(myState, '', url)
+// with
+await router.push(url)
+history.replaceState({ ...history.state, ...myState }, '')
+```
+
+Similarly, if you were calling `history.replaceState()` without preserving the current state, you will need to pass the current `history.state`:
+
+```js
+// replace
+history.replaceState({}, '', url)
+// with
+history.replaceState(history.state, '', url)
+```
+
+**Reason**: We use the history state to save information about the navigation like the scroll position, previous location, etc.
+
+### `routes` option is required in `options`
+
+The property `routes` is now required in `options`.
+
+```js
+createRouter({ routes: [] })
+```
+
+**Reason**: The router is designed to be created with routes even though you can add them later on. You need at least one route in most scenarios and this is written once per app in general.
+
+### Non existent named routes
+
+Pushing or resolving a non existent named route throws an error:
+
+```js
+// Oops, we made a typo in name
+router.push({ name: 'homee' }) // throws
+router.resolve({ name: 'homee' }) // throws
+```
+
+**Reason**: Previously, the router would navigate to `/` but display nothing (instead of the home page). Throwing an error makes more sense because we cannot produce a valid URL to navigate to.
+
+### Missing required `params` on named routes
+
+Pushing or resolving a named route without its required params will throw an error:
+
+```js
+// given the following route:
+const routes = [{ path: '/users/:id', name: 'user', component: UserDetails }]
+
+// Missing the `id` param will fail
+router.push({ name: 'user' })
+router.resolve({ name: 'user' })
+```
+
+**Reason**: Same as above.
+
+### Named children routes with an empty `path` no longer appends a slash
+
+Given any nested named route with an empty `path`:
+
+```js
+const routes = [
+  {
+    path: '/dashboard',
+    name: 'dashboard-parent',
+    component: DashboardParent,
+    children: [
+      { path: '', name: 'dashboard', component: DashboardDefault },
+      {
+        path: 'settings',
+        name: 'dashboard-settings',
+        component: DashboardSettings,
+      },
+    ],
+  },
+]
+```
+
+Navigating or resolving to the named route `dashboard` will now produce a URL **without a trailing slash**:
+
+```js
+router.resolve({ name: 'dashboard' }).href // '/dashboard'
+```
+
+This has an important side effect about children `redirect` records like these:
+
+```js
+const routes = [
+  {
+    path: '/parent',
+    component: Parent,
+    children: [
+      // this would now redirect to `/home` instead of `/parent/home`
+      { path: '', redirect: 'home' },
+      { path: 'home', component: Home },
+    ],
+  },
+]
+```
+
+Note this will work if `path` was `/parent/` as the relative location `home` to `/parent/` is indeed `/parent/home` but the relative location of `home` to `/parent` is `/home`.
+
+<!-- Learn more about relative links [in the cookbook](../../cookbook/relative-links.md). -->
+
+**Reason**: This is to make trailing slash behavior consistent: by default all routes allow a trailing slash. It can be disabled by using the `strict` option and manually appending (or not) a slash to the routes.
+
+<!-- TODO: maybe a cookbook entry -->
+
+### `$route` properties Encoding
+
+Decoded values in `params`, `query`, and `hash` are now consistent no matter where the navigation is initiated (older browsers will still produce unencoded `path` and `fullPath`). The initial navigation should yield the same results as in-app navigations.
+
+Given any [normalized route location](/api/interfaces/RouteLocationNormalized.md):
+
+- Values in `path`, `fullPath` are not decoded anymore. They will appear as provided by the browser (most browsers provide them encoded). e.g. directly writing on the address bar `https://example.com/hello world` will yield the encoded version: `https://example.com/hello%20world` and both `path` and `fullPath` will be `/hello%20world`.
+- `hash` is now decoded, that way it can be copied over: `router.push({ hash: $route.hash })` and be used directly in [scrollBehavior](/api/interfaces/RouterOptions.md#scrollBehavior)'s `el` option.
+- When using `push`, `resolve`, and `replace` and providing a `string` location or a `path` property in an object, **it must be encoded** (like in the previous version). On the other hand, `params`, `query` and `hash` must be provided in its unencoded version.
+- The slash character (`/`) is now properly decoded inside `params` while still producing an encoded version on the URL: `%2F`.
+
+**Reason**: This allows to easily copy existing properties of a location when calling `router.push()` and `router.resolve()`, and make the resulting route location consistent across browsers. `router.push()` is now idempotent, meaning that calling `router.push(route.fullPath)`, `router.push({ hash: route.hash })`, `router.push({ query: route.query })`, and `router.push({ params: route.params })` will not create extra encoding.
+
+### TypeScript changes
+
+To make typings more consistent and expressive, some types have been renamed:
+
+| `vue-router@3` | `vue-router@4`          |
+| -------------- | ----------------------- |
+| RouteConfig    | RouteRecordRaw          |
+| Location       | RouteLocation           |
+| Route          | RouteLocationNormalized |
+
+## New Features
+
+Some of new features to keep an eye on in Vue Router 4 include:
+
+- [Dynamic Routing](../advanced/dynamic-routing.md)
+- [Composition API](../advanced/composition-api.md)
+<!-- - Custom History implementation -->
diff --git a/packages/docs/fa/index.md b/packages/docs/fa/index.md
new file mode 100644
index 000000000..5eed0a53d
--- /dev/null
+++ b/packages/docs/fa/index.md
@@ -0,0 +1,45 @@
+---
+layout: home
+
+title: Vue Router
+titleTemplate: مسیریاب رسمی برای Vue.js
+
+hero: 
+  name: مسیریاب Vue
+  text: مسیریاب رسمی برای Vue.js
+  tagline: مسیریابی رسا، قابل تنظیم و راحت برای Vue.js
+  image:
+    src: /logo.svg
+    alt: Vue Router
+  actions:
+    - theme: brand
+      text: شروع کنید
+      link: fa/installation
+    - theme: cta vueschool
+      text: دوره ویدیویی رایگان
+      link: https://vueschool.io/courses/vue-router-4-for-everyone?friend=vuerouter&utm_source=vuerouter&utm_medium=link&utm_campaign=homepage
+    - theme: cta vue-mastery
+      text: برگه تقلب روتر Vue را دریافت کنید
+      link: https://www.vuemastery.com/vue-router?coupon=ROUTER-DOCS&via=eduardo
+
+features:
+  - title: 🛣 نحو بیانی مسیر
+    details: مسیرهای استاتیک و پویا را با یک نحو بصری و قدرتمند تعریف کنید.
+  - title: 🛑 کنترل ناوبری ریز دانه
+    details: رهگیری هر مسیریابی و دقیقاً کنترل نتیجه آن.
+  - title: 🧱 پیکربندی مبتنی بر کامپوننت
+    details: هر مسیر را به کامپوننتی که باید نمایش داده شود، نقشه برداری کنید.
+  - title: 🔌 حالت‌های هیستوری
+    details: بین حالت‌های HTML5، Hash یا Memory history یکی را انتخاب کنید.
+  - title: 🎚 کنترل اسکرول
+    details: موقعیت اسکرول را در هر صفحه دقیقاً کنترل کنید.
+  - title: 🌐 رمزگذاری به صورت خودکار
+    details: به طور مستقیم از کاراکترهای یونیکد (你好) در کد خود استفاده کنید.
+---
+
+<script setup>
+import HomeSponsors from '../.vitepress/theme/components/HomeSponsors.vue'
+import '../.vitepress/theme/styles/home-links.css'
+</script>
+
+<HomeSponsors />
diff --git a/packages/docs/fa/installation.md b/packages/docs/fa/installation.md
new file mode 100644
index 000000000..7570da8ec
--- /dev/null
+++ b/packages/docs/fa/installation.md
@@ -0,0 +1,57 @@
+# نصب
+
+<VueMasteryLogoLink></VueMasteryLogoLink>
+
+## Direct Download / CDN
+
+[https://unpkg.com/vue-router@4](https://unpkg.com/vue-router@4)
+
+<!--email_off-->
+
+[Unpkg.com](https://unpkg.com) provides npm-based CDN links. The above link will always point to the latest release on npm. You can also use a specific version/tag via URLs like `https://unpkg.com/vue-router@4.0.15/dist/vue-router.global.js`.
+
+<!--/email_off-->
+
+This will expose Vue Router via a global `VueRouter` object, e.g. `VueRouter.createRouter(...)`.
+
+## Package managers
+
+If you have an existing project that uses a JavaScript package manager, you can install Vue Router from the npm registry:
+
+::: code-group
+
+```bash [npm]
+npm install vue-router@4
+```
+
+```bash [yarn]
+yarn add vue-router@4
+```
+
+```bash [pnpm]
+pnpm add vue-router@4
+```
+
+:::
+
+If you're starting a new project, you might find it easier to use the [create-vue](https://github.com/vuejs/create-vue) scaffolding tool, which creates a Vite-based project with the option to include Vue Router:
+
+::: code-group
+
+```bash [npm]
+npm create vue@latest
+```
+
+```bash [yarn]
+yarn create vue
+```
+
+```bash [pnpm]
+pnpm create vue
+```
+
+:::
+
+You'll be prompted with some questions about the kind of project you want to create. If you choose to install Vue Router, the example application will also demonstrate some of Vue Router's core features.
+
+Projects using package managers will typically use ES modules to access Vue Router, e.g. `import { createRouter } from 'vue-router'`.
\ No newline at end of file
diff --git a/packages/docs/fa/introduction.md b/packages/docs/fa/introduction.md
new file mode 100644
index 000000000..9c3c9f5b7
--- /dev/null
+++ b/packages/docs/fa/introduction.md
@@ -0,0 +1,27 @@
+# معرفی
+
+<VueSchoolLink
+  href="https://vueschool.io/courses/vue-router-4-for-everyone"
+  title="Learn how to build powerful Single Page Applications with the Vue Router on Vue School"
+>Watch a Free Vue Router Video Course</VueSchoolLink>
+
+Vue Router is the official router for [Vue.js](https://vuejs.org). It deeply integrates with Vue.js core to make building Single Page Applications with Vue.js a breeze. Features include:
+
+- Nested routes mapping
+- Dynamic Routing
+- Modular, component-based router configuration
+- Route params, query, wildcards
+- View transition effects powered by Vue.js' transition system
+- Fine-grained navigation control
+- Links with automatic active CSS classes
+- HTML5 history mode or hash mode
+- Customizable Scroll Behavior
+- Proper encoding for URLs
+
+[Get started](./guide/) or play with the [playground](https://github.com/vuejs/router/tree/main/packages/playground) (see [`README.md`](https://github.com/vuejs/router) to run them).
+
+<HomeSponsors />
+
+<script setup>
+import HomeSponsors from '../.vitepress/theme/components/HomeSponsors.vue'
+</script>

From 470ad7b09d962d5987f403ccd09c6b2ce10c593d Mon Sep 17 00:00:00 2001
From: Pesar <pesar369@gmail.com>
Date: Thu, 21 Dec 2023 13:19:48 +0330
Subject: [PATCH 2/2] docs(fa): set first checkpoint

---
 packages/docs/.vitepress/translation-status.json | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/packages/docs/.vitepress/translation-status.json b/packages/docs/.vitepress/translation-status.json
index ea46a9127..c4c164269 100644
--- a/packages/docs/.vitepress/translation-status.json
+++ b/packages/docs/.vitepress/translation-status.json
@@ -2,5 +2,9 @@
   "zh": {
     "hash": "35a9c1b",
     "date": "2023-12-16"
+  },
+  "fa": {
+    "hash": "11ce2139d4020919366b4567a08caece994760cd",
+    "date": "2023-12-21"
   }
 }
\ No newline at end of file