diff --git a/.github/workflows/action-test.yaml b/.github/workflows/action-test.yaml
deleted file mode 100644
index 5450ffc3..00000000
--- a/.github/workflows/action-test.yaml
+++ /dev/null
@@ -1,26 +0,0 @@
-name: Translate Website
-
-on:
-  push:
-    branches:
-      - '**'
-    paths:
-      - apps/web/**
-
-jobs:
-  translate:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-      pull-requests: write
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Languine Action
-        uses: languine-ai/languine@v1
-        env:
-           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          api-key: ${{ secrets.LANGUINE_API_KEY }}
-          project-id: ${{ secrets.LANGUINE_PROJECT_ID }}
-          working-directory: apps/web
\ No newline at end of file
diff --git a/apps/web/languine.json b/apps/web/languine.json
index b44f215e..5c71878c 100644
--- a/apps/web/languine.json
+++ b/apps/web/languine.json
@@ -6,9 +6,6 @@
   "files": {
     "json": {
       "include": ["src/messages/[locale].json"]
-    },
-    "mdx": {
-      "include": ["src/markdown/docs/en/*.mdx"]
     }
   }
 }
\ No newline at end of file
diff --git a/apps/web/languine.lock b/apps/web/languine.lock
index e593cbc0..91d3d067 100644
--- a/apps/web/languine.lock
+++ b/apps/web/languine.lock
@@ -510,8 +510,8 @@ files:
     header.docs: 43c592501e0d37c63bc038fa182b2ddf
     header.signIn: ecff6ecb514e3e1b66f8b07d8b78bafe
     header.goToApp: 06bdc247034142d7386dc009310a009d
-    hero.title: 8e7b32a7645be2a53c1bef60bb957cf6
-    hero.description: 4e9498f4f6f6c1ac8feb2149f173490b
+    hero.title: 2b0986a91ae718b238391f507207485b
+    hero.description: 1dcdd883c2b462ea791ad89aa0695d9b
     navigation.dashboard: 2938c7f7e560ed972f8a4f68e80ff834
     navigation.tuning: d1010bff5c3a43dc0623b7b3e87f174a
     navigation.overrides: b871acfcee7082fe5315174298b6659b
@@ -520,8 +520,8 @@ files:
     navigation.docs: 43c592501e0d37c63bc038fa182b2ddf
     navigation.account: 8ef1b2ce0360df8af6e52bfdab6e6e9e
     getStarted.heading: 5b29aee5dab4cfb08ca8bd42b06836d6
-    getStarted.title: 8e7b32a7645be2a53c1bef60bb957cf6
-    getStarted.description: 4e9498f4f6f6c1ac8feb2149f173490b
+    getStarted.title: 2b0986a91ae718b238391f507207485b
+    getStarted.description: 1dcdd883c2b462ea791ad89aa0695d9b
     getStarted.button.startAutomating: 59cd3d6f036c298b544bf40f2a9e0b1b
     getStarted.button.readDocumentation: 79e079ea3ad15aec762f5bc740d05d46
     companies.title: 6b3eb08c2d6186d90ac20aca3f745c18
@@ -953,8 +953,8 @@ files:
     header.docs: 71b2ee5ae7a23092389ac5fd6791ff43
     header.signIn: 2eea080f348d1e398b038b37aa3f1a10
     header.goToApp: c4e54e5eeb904f889ffd2aeb11a7023f
-    hero.title: 9242ff4e74ba3dd7e1e482b03d608c31
-    hero.description: 25301996343e55017b1b00a1defe65d9
+    hero.title: 230145d21864c99993724ece51e99d19
+    hero.description: 27e89036983ce499478c728bab045a4c
     navigation.dashboard: 629e199d421911b329a2909925beeb50
     navigation.tuning: 9b8c5566f1323d88d3192d269523bcbe
     navigation.overrides: 3db0abab2211e2f98a5b3304b6c5c049
@@ -963,8 +963,8 @@ files:
     navigation.docs: a1420688c629cb4bac7dfbe1b180fb42
     navigation.account: d1ef184f21c6a19615f873478fe03462
     getStarted.heading: 2788dc861f0cd8b423653c0b6fe4195b
-    getStarted.title: 9242ff4e74ba3dd7e1e482b03d608c31
-    getStarted.description: 25301996343e55017b1b00a1defe65d9
+    getStarted.title: 230145d21864c99993724ece51e99d19
+    getStarted.description: 27e89036983ce499478c728bab045a4c
     getStarted.button.startAutomating: 9b0a69239ff144486dff4e740b4c7329
     getStarted.button.readDocumentation: bf1998ea274fe0873d2ac78fcb0e1006
     companies.title: 806ebdbd9fe082ab396eb70f7002f156
@@ -1396,8 +1396,8 @@ files:
     header.docs: 7821810b7991ea5cb2f215b8a0ae3bfc
     header.signIn: 634983f425e586cdfe14c715fabae635
     header.goToApp: 02a199e2306dd194a6a4c43741c7b8a7
-    hero.title: 5237f4e657e1ebe29677bb7f727f0044
-    hero.description: 0d0c5193029f138cfa89d9cecee7d170
+    hero.title: 8aef5bbd2030cf40b757082600d1e9a9
+    hero.description: a6e31e1571ba9b4f568c99a9d1ec666e
     navigation.dashboard: 820c7142370ede086c0f3db8aad1aeef
     navigation.tuning: a7d3f83ae8cb48c47d4cf1486b00b641
     navigation.overrides: 43a7607dfd166b4f1d0c6ce4644e90ab
@@ -1406,8 +1406,8 @@ files:
     navigation.docs: 7821810b7991ea5cb2f215b8a0ae3bfc
     navigation.account: 884a1de4d3195f10985afac09db0aa6d
     getStarted.heading: 66963d16bba8c9087c0570d1d875781f
-    getStarted.title: 5237f4e657e1ebe29677bb7f727f0044
-    getStarted.description: 0d0c5193029f138cfa89d9cecee7d170
+    getStarted.title: 8aef5bbd2030cf40b757082600d1e9a9
+    getStarted.description: a6e31e1571ba9b4f568c99a9d1ec666e
     getStarted.button.startAutomating: cf14035b33781c88be3ed14c888fea61
     getStarted.button.readDocumentation: e60a4af5dc2d2917776dc426ac102d17
     companies.title: 366f89f81e17fefc585f1a06ef9b3b78
@@ -1839,7 +1839,7 @@ files:
     header.docs: a3907cd461d8739aa3266047bc4b8c0c
     header.signIn: 04fc0f6ce574d7aab7b0157bcdc846f8
     header.goToApp: eca3f47f652b1cefe6f5eda5d09fc7fd
-    hero.title: dfe602cecf5856e3e71d84e52dbbfe3b
+    hero.title: cf783fc8a7512941d24661f38b83c8cf
     hero.description: 69c9a33345e994f42681758839dd4488
     navigation.dashboard: 4a37efc27391cc18714c72981d59c072
     navigation.tuning: 873ced728e03fa88758b36605c38fa5a
@@ -1849,7 +1849,7 @@ files:
     navigation.docs: 5b6cf869265c13af8566f192b4ab3d2a
     navigation.account: 4cd05effefac83d92a4cbd939beac4ef
     getStarted.heading: 62c3f6afd773369cfc24fe9e38c2d9a7
-    getStarted.title: dfe602cecf5856e3e71d84e52dbbfe3b
+    getStarted.title: cf783fc8a7512941d24661f38b83c8cf
     getStarted.description: 69c9a33345e994f42681758839dd4488
     getStarted.button.startAutomating: 749f5c4dd3dcb4e77467f42ee5db6431
     getStarted.button.readDocumentation: 3c0b6b5b54ff6e54844e90d5eb38e4df
@@ -2282,8 +2282,8 @@ files:
     header.docs: f5dd1db267fdc0cfaaaf410c2120ed47
     header.signIn: bd6b12decc2abf95959b791a3578e091
     header.goToApp: 8383c069a4b8e009aa2079632d5e2a7a
-    hero.title: 759728b3f46f64518b24feb9fbc287a1
-    hero.description: b838ded4ec8b56b9a8ecda67b72a6ec8
+    hero.title: 7a4b877b939b7d90c0ec80a6e27ce631
+    hero.description: b4d30a5cff6627e1e27bcb44323e779e
     navigation.dashboard: 677bbd24623970a6c6620a0e5f68d02b
     navigation.tuning: 4707b4f4bf5f1e376a624adacae5b7a7
     navigation.overrides: 0e770b80d21f0a0d6098c1f766da3a67
@@ -2292,8 +2292,8 @@ files:
     navigation.docs: f5dd1db267fdc0cfaaaf410c2120ed47
     navigation.account: 08bd40c7543007ad06e4fce31618f6ec
     getStarted.heading: b09f65d94eb0f9d925129e39c1daa45f
-    getStarted.title: 759728b3f46f64518b24feb9fbc287a1
-    getStarted.description: b838ded4ec8b56b9a8ecda67b72a6ec8
+    getStarted.title: 7a4b877b939b7d90c0ec80a6e27ce631
+    getStarted.description: b4d30a5cff6627e1e27bcb44323e779e
     getStarted.button.startAutomating: 32d4eff0d7584664a169dd5912e79cfb
     getStarted.button.readDocumentation: dd2b0a6d72a676f48319fa75ac8035ce
     companies.title: 35b6b37cca9d116a8bd3b9e731eb4f93
@@ -2725,8 +2725,8 @@ files:
     header.docs: 1c73f88a48ee1402e1719e9b617571ef
     header.signIn: 2228c5945cd5fa864a1a3b067fd95eeb
     header.goToApp: 8af70210bbd12fc6d1fed34223da85a7
-    hero.title: 666c9b0fb4ec2feb59ef069645d64136
-    hero.description: 341274ba0ef8ee629404bf429081c257
+    hero.title: 1068c0ad7182235ae6b21a6edbffea81
+    hero.description: 5407b548dc930b064c3f9c5777d5ff98
     navigation.dashboard: 29cba505cdc4b85b5d40903a19f38e95
     navigation.tuning: 27507514401e9dbec9ccd502d315e814
     navigation.overrides: 06f6d6983ebdee06aa08f8b73c2f4df3
@@ -2735,8 +2735,8 @@ files:
     navigation.docs: 1c73f88a48ee1402e1719e9b617571ef
     navigation.account: a456fb71437a11fe0d625e38c2e30e1a
     getStarted.heading: d3118865aadfde18e6968340f43f5798
-    getStarted.title: 666c9b0fb4ec2feb59ef069645d64136
-    getStarted.description: 341274ba0ef8ee629404bf429081c257
+    getStarted.title: 1068c0ad7182235ae6b21a6edbffea81
+    getStarted.description: 5407b548dc930b064c3f9c5777d5ff98
     getStarted.button.startAutomating: c82a48615ec01323deb6871399d75423
     getStarted.button.readDocumentation: 751eabec2bd379500e0060e3afcf5c2a
     companies.title: 274d0139f3f89f1ca4fbacaa1044909d
@@ -3168,8 +3168,8 @@ files:
     header.docs: c57b370ca67195602d109cc93e5daeba
     header.signIn: e2bdb51e902de10274b096b9aa1c6956
     header.goToApp: d55df6ea362cafad9022c7e7289a1c04
-    hero.title: 2f26b3c3cb90aff2034fa37446775cb9
-    hero.description: e10573cf506b0f87070cfc354d379967
+    hero.title: 0b1ce3affda350a5278c8719b5e3aebe
+    hero.description: b74ca83372be7ead4d5f32cc145c65e4
     navigation.dashboard: 2938c7f7e560ed972f8a4f68e80ff834
     navigation.tuning: 64361509f1002e3e9d660b1bbd5d2759
     navigation.overrides: 0ca08f8f4a8a19f7f1ae87c119494327
@@ -3178,8 +3178,8 @@ files:
     navigation.docs: c57b370ca67195602d109cc93e5daeba
     navigation.account: 08bd40c7543007ad06e4fce31618f6ec
     getStarted.heading: 73c3e754b4ec0f307311dcd984c70c8d
-    getStarted.title: 2f26b3c3cb90aff2034fa37446775cb9
-    getStarted.description: e10573cf506b0f87070cfc354d379967
+    getStarted.title: 0b1ce3affda350a5278c8719b5e3aebe
+    getStarted.description: b74ca83372be7ead4d5f32cc145c65e4
     getStarted.button.startAutomating: 515330f0439f11877c669b98d24c1177
     getStarted.button.readDocumentation: 3de1c7fff574c4ee2cf9c867e4959fdd
     companies.title: 6954d41e0ce7db476c4d7223c44edda2
@@ -3611,8 +3611,8 @@ files:
     header.docs: c8e4482077e73127ff268776de48b9b7
     header.signIn: 80ffad7566d7473a4310841269527e84
     header.goToApp: 8318493edce0ef3e26daeb28ad15e01a
-    hero.title: 008853059684d79b700c38a07e13e3fa
-    hero.description: 94aec46cbca8c4340da549023499593b
+    hero.title: 40fb7889f5fdef4b310ac966718b5378
+    hero.description: daf848f1e095a4c68f1f2309542b8903
     navigation.dashboard: 5967ab15ec405a77b8db5dcdb885d6c6
     navigation.tuning: bf7f60209cc14b4b4f002b4b197de4ae
     navigation.overrides: 9ea0a9b7f1f3c8259e051144b7bf169b
@@ -3621,8 +3621,8 @@ files:
     navigation.docs: c8e4482077e73127ff268776de48b9b7
     navigation.account: 8ef1b2ce0360df8af6e52bfdab6e6e9e
     getStarted.heading: 0b0fe8d91cc4d7be7a41bb108117fb72
-    getStarted.title: 008853059684d79b700c38a07e13e3fa
-    getStarted.description: 94aec46cbca8c4340da549023499593b
+    getStarted.title: 40fb7889f5fdef4b310ac966718b5378
+    getStarted.description: daf848f1e095a4c68f1f2309542b8903
     getStarted.button.startAutomating: c9bb305f055f2beac4298ac1a5d90ad0
     getStarted.button.readDocumentation: c998b1d71e37e80efb656882678602cb
     companies.title: 7a5e9e96648ef44cdd14be531f061d59
@@ -4054,8 +4054,8 @@ files:
     header.docs: c8485e05c2720e903517fa53f1189d33
     header.signIn: a61d196e6576a0a91ac6aab9034d5535
     header.goToApp: 51801703f2d37a0f7a6c332992b5a5a8
-    hero.title: 74d081e34e2c42ce6301b46850b75dc5
-    hero.description: 70441d5bc195de399d1ad7fab15695f4
+    hero.title: f34f5de3d1f5c2a16b8e7f664413c739
+    hero.description: ca29aec84cc0e6156818c1b7cc0063c4
     navigation.dashboard: b8da6df14bf06283cbf588df6998722e
     navigation.tuning: ae7d36ca44e270b02649c5f5a97c0262
     navigation.overrides: 3c1cc27fb6ee71e73df1e12bf61ea9ff
@@ -4064,8 +4064,8 @@ files:
     navigation.docs: c8485e05c2720e903517fa53f1189d33
     navigation.account: 8ef1b2ce0360df8af6e52bfdab6e6e9e
     getStarted.heading: 0fcb84e5416c73280dac88079172aeb8
-    getStarted.title: 74d081e34e2c42ce6301b46850b75dc5
-    getStarted.description: 70441d5bc195de399d1ad7fab15695f4
+    getStarted.title: f34f5de3d1f5c2a16b8e7f664413c739
+    getStarted.description: ca29aec84cc0e6156818c1b7cc0063c4
     getStarted.button.startAutomating: c889b3d6e75a2777e3de3695394fde29
     getStarted.button.readDocumentation: 343964f780f3098d5e49aee852912fd8
     companies.title: f81625b19eb538f093e5f9e676b00f47
@@ -4497,8 +4497,8 @@ files:
     header.docs: 71b2ee5ae7a23092389ac5fd6791ff43
     header.signIn: b687c67a2bfd3c4c97d9eb37450909e5
     header.goToApp: 8575ae96fc03c7fac71de84dc0cc695e
-    hero.title: db8901072eb1bab68634dbeee9fc113f
-    hero.description: 9f83f8904778292c3b3d8508f0fc3391
+    hero.title: e7d31b7c16225ed33ae96a54177cfe14
+    hero.description: 0c630961e14db988285aa3d730895f0f
     navigation.dashboard: 96a7b5490bcd3652a0c2bf36c1ffce2b
     navigation.tuning: 9b8c5566f1323d88d3192d269523bcbe
     navigation.overrides: 72ea96873387ebb56925d2fb2b8debf2
@@ -4507,8 +4507,8 @@ files:
     navigation.docs: bc591132e2c4d691a317893d6a59285a
     navigation.account: 8192dbe80e3401ebe872e0aed980daa1
     getStarted.heading: 434aeab58169e9ed4fca581cf94bf498
-    getStarted.title: db8901072eb1bab68634dbeee9fc113f
-    getStarted.description: 9f83f8904778292c3b3d8508f0fc3391
+    getStarted.title: e7d31b7c16225ed33ae96a54177cfe14
+    getStarted.description: 0c630961e14db988285aa3d730895f0f
     getStarted.button.startAutomating: 9da709fc909bde4b774a02fce2b0d65f
     getStarted.button.readDocumentation: 3920f23fdde081937a7c59a13f351ee4
     companies.title: 806ebdbd9fe082ab396eb70f7002f156
@@ -4954,11 +4954,11 @@ files:
     menu.settings: 04700bee0cd7b00165f310460332b2f8
     menu.docs: 43c592501e0d37c63bc038fa182b2ddf
     menu.account: 8ef1b2ce0360df8af6e52bfdab6e6e9e
-    hero.title: 9a7164f0cd4144911ebfcef911ae89d1
-    hero.description: 3408f3aeaf12889107f73009018f27e6
+    hero.title: 0ba2fa027eb83fc8cb158b51ac0b3786
+    hero.description: 9004ba1e35e9f93744fc84f8b51096d3
     getStarted.heading: 95a8292476e692ab92aa6dcd57518b18
-    getStarted.title: 9a7164f0cd4144911ebfcef911ae89d1
-    getStarted.description: 3408f3aeaf12889107f73009018f27e6
+    getStarted.title: 0ba2fa027eb83fc8cb158b51ac0b3786
+    getStarted.description: 9004ba1e35e9f93744fc84f8b51096d3
     getStarted.button.startAutomating: a04ca6d92fe1c2970e655d82bf36583c
     getStarted.button.readDocumentation: 30b7e90a20189fa21f646422ffee79eb
     companies.title: 1d972c940221026305ecd77c17a64655
diff --git a/apps/web/next.config.ts b/apps/web/next.config.ts
index 50e73c6b..0f1c8b67 100644
--- a/apps/web/next.config.ts
+++ b/apps/web/next.config.ts
@@ -21,6 +21,15 @@ const nextConfig: NextConfig = {
       },
     ],
   },
+  redirects: async () => {
+    return [
+      {
+        source: "/:locale/docs",
+        destination: "/:locale/docs/introduction",
+        permanent: true,
+      },
+    ];
+  },
 };
 
 const withMDX = createMDX();
diff --git a/apps/web/src/app/[locale]/docs/[...all]/page.tsx b/apps/web/src/app/[locale]/docs/[...all]/page.tsx
index 789b641a..96ca3e27 100644
--- a/apps/web/src/app/[locale]/docs/[...all]/page.tsx
+++ b/apps/web/src/app/[locale]/docs/[...all]/page.tsx
@@ -3,11 +3,11 @@ import { notFound } from "next/navigation";
 
 export default async function Page({
   params,
-}: { params: Promise<{ locale: string; all: string[] }> }) {
-  const { locale, all } = await params;
+}: { params: Promise<{ all: string[] }> }) {
+  const { all } = await params;
 
   try {
-    const content = await getMarkdownContent(locale, all?.at(0) ?? "");
+    const content = await getMarkdownContent("en", all?.at(0) ?? "");
     return content;
   } catch (error) {
     notFound();
diff --git a/apps/web/src/components/docs-sidebar.tsx b/apps/web/src/components/docs-sidebar.tsx
index 985db23b..13aceb8c 100644
--- a/apps/web/src/components/docs-sidebar.tsx
+++ b/apps/web/src/components/docs-sidebar.tsx
@@ -23,6 +23,8 @@ export function DocsSidebar() {
   const router = useRouter();
   const { sections, currentPage } = useDocs();
 
+  console.log(pathname);
+
   return (
     <>
       <div className="md:hidden w-full mb-6">
diff --git a/apps/web/src/components/hero.tsx b/apps/web/src/components/hero.tsx
index 21dd22ad..f6a006c5 100644
--- a/apps/web/src/components/hero.tsx
+++ b/apps/web/src/components/hero.tsx
@@ -13,7 +13,7 @@ export function Hero() {
   return (
     <div className="py-12 md:py-28 flex flex-col lg:flex-row gap-12 justify-between items-center">
       <div className="lg:max-w-[590px] space-y-8 w-full">
-        <h1 className="xl:text-4xl text-3xl">{t("title")}</h1>
+        <h1 className="xl:text-4xl !leading-[42px] text-3xl">{t("title")}</h1>
         <p className="text-secondary text-sm">{t("description")}</p>
 
         <div className="lg:max-w-[480px]">
diff --git a/apps/web/src/lib/markdown.ts b/apps/web/src/lib/markdown.ts
index 140c233d..1581652d 100644
--- a/apps/web/src/lib/markdown.ts
+++ b/apps/web/src/lib/markdown.ts
@@ -13,7 +13,7 @@ export async function getCurrentDoc(locale: string, slug: string) {
 }
 
 export async function getMarkdownContent(locale: string, slug: string) {
-  const docPath = await getCurrentDoc(locale, slug);
+  const docPath = await getCurrentDoc("en", slug);
   const source = await fs.readFile(docPath, "utf-8");
   const { content } = await compileMDX({
     source,
diff --git a/apps/web/src/markdown/docs/da/android.mdx b/apps/web/src/markdown/docs/da/android.mdx
deleted file mode 100644
index b4ddd4fa..00000000
--- a/apps/web/src/markdown/docs/da/android.mdx
+++ /dev/null
@@ -1,39 +0,0 @@
-# Android
-
-Languine understøtter Android-strengressourcer (strings.xml) som kildeformat, der håndterer pluraler, strengarrays og formaterede strenge. Dette format er den standard måde at administrere oversættelser i Android-applikationer.
-
----
-
-## Opsætning
-
-Først skal du sikre dig, at du har en languine.config.json eller languine.config.ts konfigurationsfil i rodmappen af dit projekt. Her er et eksempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "android": {
-      "include": ["app/src/main/res/values-[locale]/strings.xml"]
-    }
-  }
-}
-```
-
-## Oversættelse
-
-Når din konfiguration er sat op, skal du køre:
-
-```bash
-npx languine@latest translate
-```
-
-Når du kører denne kommando, vil Languine:
-
-- Indlæse din kilde strings.xml-fil (f.eks. values/strings.xml)
-- Registrere eventuelle nye eller ændrede oversættelsesstrenge
-- Generere oversættelser til dine målsprog
-- Oprette eller opdatere XML-filerne for målsproget (f.eks. values-sv/strings.xml, values-de/strings.xml, values-fr/strings.xml)
-- Bevare eventuelle eksisterende strengarrays og pluralformater
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/da/arb.mdx b/apps/web/src/markdown/docs/da/arb.mdx
deleted file mode 100644
index 363eb98b..00000000
--- a/apps/web/src/markdown/docs/da/arb.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# ARB (Application Resource Bundle)
-
-Languine understøtter ARB-filer, den standard lokaliseringsformat for Flutter-applikationer. Dette format håndterer flertalsformer, pladsholdere og valgudtryk, samtidig med at det opretholder kompatibilitet med Flutters intl-pakke.
-
----
-
-## Opsætning
-
-Først skal du sikre dig, at du har en languine.config.json eller languine.config.ts konfigurationsfil i rodmappen af dit projekt. Her er et eksempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "arb": {
-      "include": ["lib/l10n/intl_[locale].arb"]
-    }
-  }
-}
-```
-
-## Oversættelse
-
-Når din konfiguration er sat op, skal du køre:
-
-```bash
-npx languine@latest translate
-```
-
-Når du kører denne kommando, vil Languine:
-
-- Indlæse din kilde ARB-fil (f.eks. lib/l10n/intl_en.arb)
-- Registrere eventuelle nye eller ændrede oversættelsesstrenge
-- Generere oversættelser til dine målsprog
-- Oprette eller opdatere målsprog ARB-filer (f.eks. lib/l10n/intl_sv.arb)
-- Bevare metadata, pladsholdere og flertal/valgudtryk
-
diff --git a/apps/web/src/markdown/docs/da/authentication.mdx b/apps/web/src/markdown/docs/da/authentication.mdx
deleted file mode 100644
index 172ac6d4..00000000
--- a/apps/web/src/markdown/docs/da/authentication.mdx
+++ /dev/null
@@ -1,48 +0,0 @@
-# Godkendelse
-
-For at bruge Languine skal du godkende dig med vores Engine, det tager kun et par sekunder at komme i gang.
-
----
-
-## Log ind
-
-Du kan logge ind direkte på [Languine Dashboard](https://languine.ai/login) eller køre følgende kommando:
-
-```bash title="Terminal"
-npx languine@latest auth login
-```
-
-
-Hvis du allerede har en konto, vil du automatisk blive logget ind, og en session vil blive gemt på din maskine.
-
----
-
-## Log ud
-
-Du kan logge ud ved at køre følgende kommando:
-
-```bash title="Terminal"
-npx languine@latest auth logout
-```
-
----
-
-## Bruger session
-
-Du kan tjekke, om du er logget ind ved at køre følgende kommando:
-
-```bash title="Terminal"
-npx languine@latest auth whoami
-```
-
----
-
-
-# Miljøvariabler
-
-Du kan indstille følgende miljøvariabler for at konfigurere Languine:
-
-- `LANGUINE_API_KEY`: API-nøglen, der skal bruges til godkendelse.
-- `LANGUINE_PROJECT_ID`: Projekt-ID'et, der skal bruges til projektet.
-
-Du finder dem i [Languine Dashboard](https://languine.ai/login).
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/da/biome.mdx b/apps/web/src/markdown/docs/da/biome.mdx
deleted file mode 100644
index 2d86ca6f..00000000
--- a/apps/web/src/markdown/docs/da/biome.mdx
+++ /dev/null
@@ -1,34 +0,0 @@
-# Biome
-
-Languine understøtter formatering med [Biome](https://biomejs.dev/) gennem hooks. Du kan konfigurere Biome til automatisk at formatere dine oversættelsesfiler, efter de er blevet genereret.
-
-Her er et eksempel på konfiguration:
-
-```typescript title="languine.config.ts"
-import { defineConfig } from "languine";
-
-export default defineConfig({
-  locale: {
-    source: "en",
-    targets: ["es", "fr"],
-  },
-  files: {
-    json: {
-      include: ["locales/[locale].json"],
-    },
-  },
-  hooks: {
-    // Formater genererede filer med Biome
-    afterTranslate: async (files) => {
-      const { check } = await import("@biomejs/biome");
-      
-      for (const file of files) {
-        await check({
-          files: [file],
-          apply: true,
-        });
-      }
-    },
-  },
-});
-```
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/da/ci.mdx b/apps/web/src/markdown/docs/da/ci.mdx
deleted file mode 100644
index 08c0c9ac..00000000
--- a/apps/web/src/markdown/docs/da/ci.mdx
+++ /dev/null
@@ -1,96 +0,0 @@
-# CI/CD
-
-Languine tilbyder en CI/CD-integration for at hjælpe dig med at oversætte din applikation.
-
----
-
-## Sådan fungerer det
-
-CI/CD-arbejdsgangen i Languine følger en struktureret proces for at automatisere oversættelsesopdateringer i din applikation:
-
-### 1. Handlingsinitialisering
-- Arbejdsgangen begynder, når handlingen udløses
-- Opsætter den nødvendige Git-konfiguration og legitimationsoplysninger
-
-### 2. Languine Engine Behandling
-- Languine-motoren behandler indholdet af din applikation
-- Håndterer oversættelsesopgaverne ved hjælp af de konfigurerede indstillinger
-
-### 3. Ændringsdetektion
-Systemet tjekker for eventuelle oversættelsesændringer og følger en af to veje:
-
-**Når ændringer findes:**
-- Ændringer forpligtes til repository'et
-- Ændringer skubbes til den angivne gren
-- En Pull Request (PR) oprettes
-
-**Når ingen ændringer findes:**
-- Arbejdsgangen afsluttes uden at oprette en PR
-
-### 4. Oprettelse af Pull Request
-Når ændringer opdages, oprettes en Pull Request med:
-
-**PR-indhold:**
-- Klar titel, der angiver oversættelsesopdateringer
-- Detaljeret beskrivelse af ændringer
-- Bekræftelser på kvalitetskontrol
-- Instruktioner til gennemgang
-- Links til dokumentation og support
-
-**PR-beskrivelse inkluderer:**
-- Resumé af oversættelsesopdateringer
-- Liste over hvad der er ændret (opdaterede oversættelser, terminologikonsistens)
-- Næste skridt for anmeldere
-- Links til dokumentations- og supportressourcer
-
----
-
-## Arbejdsgangsdiagram
-
-<div className="flex flex-col items-center justify-center p-4 h-[400px] sm:h-[500px] md:h-[650px]">
-  <pre
-    className="p-4 text-sm leading-5 mb-4 scale-[0.5] sm:scale-[0.65] md:scale-90 transform-gpu"
-    style={{
-      fontFamily: "monospace",
-      whiteSpace: "pre",
-      textAlign: "left",
-    }}
-  >
-    {`
-                    ┌─────────────────────┐
-                    │   Handlingen Starter  │
-                    └──────────┬──────────┘
-                               │
-                    ┌──────────▼──────────┐
-                    │    Opsæt Git &      │
-                    │    Legitimationsoplysninger │
-                    └──────────┬──────────┘
-                               │
-┌─────────────────────────────────────────────────────────┐
-│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-│░░░░░░░░░░░░░░░░░░░░ Languine Engine ░░░░░░░░░░░░░░░░░░░░│
-│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-└─────────────────────────────────────────────────────────┘
-                               │
-                    ┌──────────▼──────────┐
-                    │   Tjek Ændringer     │───────┐
-                    └──────────┬──────────┘       │
-                               │                  │
-                               │ [Ændringer]        │ [Ingen Ændringer]
-                               │                  │
-                    ┌──────────▼──────────┐       │
-                    │   Forpligt & Skub    │       │
-                    └──────────┬──────────┘       │
-                               │                  │
-                    ┌──────────▼──────────┐       │
-                    │    Opret PR         │       │
-                    └──────────┬──────────┘       │
-                               │                  │
-                    ┌──────────▼──────────┐       │
-                    │        Færdig       │◄──────┘
-                    └─────────────────────┘
-`}
-  </pre>
-</div>
-
-Arbejdsgangen er designet til at være automatiseret, mens den stadig tillader menneskelig gennemgang og kvalitetskontrol, før ændringer flettes ind i din kodebase. Den opretholder bedste praksis for versionskontrol og sikrer, at oversættelser er korrekt sporet og dokumenteret gennem Git-historikken.
diff --git a/apps/web/src/markdown/docs/da/cli.mdx b/apps/web/src/markdown/docs/da/cli.mdx
deleted file mode 100644
index 00d56ec8..00000000
--- a/apps/web/src/markdown/docs/da/cli.mdx
+++ /dev/null
@@ -1,65 +0,0 @@
-# CLI
-
-Languine tilbyder en CLI til at hjælpe dig med at oversætte din applikation.
-
----
-
-## Kommandoversigt
-
-### Oversæt
-
-`translate`-kommandoen bruges til at oversætte din applikation.
-
-```bash title="Terminal"
-    npx languine@latest translate
-```
-
----
-
-### Init
-
-`init`-kommandoen bruges til at initialisere et nyt Languine-projekt.
-
-```bash title="Terminal"
-    npx languine@latest init
-```
-
----
-
-### Auth
-
-`auth`-kommandoen bruges til at godkende med Languine.
-
-```bash title="Terminal"
-    npx languine@latest auth
-```
-
----
-
-### Sync
-
-`sync`-kommandoen bruges til at synkronisere din applikation med Languine.
-
-```bash title="Terminal"
-    npx languine@latest sync
-```
-
----
-
-### Locale Tilføj
-
-`locale`-kommandoen bruges til at administrere din applikations lokaliteter.
-
-```bash title="Terminal"
-    npx languine@latest locale add pt,fr
-```
-
----
-
-### Locale Fjern
-
-`locale remove`-kommandoen bruges til at fjerne en lokalitet fra din applikation.
-
-```bash title="Terminal"
-    npx languine@latest locale remove pt,fr
-```
diff --git a/apps/web/src/markdown/docs/da/configuration.mdx b/apps/web/src/markdown/docs/da/configuration.mdx
deleted file mode 100644
index 14dad8f8..00000000
--- a/apps/web/src/markdown/docs/da/configuration.mdx
+++ /dev/null
@@ -1,198 +0,0 @@
-# Konfiguration
-
-Languine understøtter både TypeScript og JSON konfigurationsfiler til at administrere din oversættelsesopsætning. Du kan vælge enten languine.config.ts for TypeScript eller languine.config.json for JSON-format. Begge filer definerer dine kilde- og målsprog samt de filer, der skal oversættes.
-
----
-
-## Grundlæggende Konfiguration
-
-Her er et grundlæggende eksempel i begge formater:
-
-```typescript title="languine.config.ts"
-import { defineConfig } from "languine";
-
-export default defineConfig({
-  locale: {
-    source: "en",
-    targets: ["es", "fr", "de"],
-  },
-  files: {
-    json: {
-      include: ["locales/[locale].json"],
-    },
-  },
-});
-```
-
-```json title="languine.config.json"
-{
-  "locale": {
-    "source": "en",
-    "targets": ["es", "fr", "de"]
-  },
-  "files": {
-    "json": {
-      "include": ["locales/[locale].json"]
-    }
-  }
-}
-```
-
-Begge formater understøtter de samme konfigurationsmuligheder. Vælg TypeScript for bedre typekontrol og IDE-understøttelse, eller JSON for enkelhed og bredere værktøjskompatibilitet.
-
-Lad os gennemgå de forskellige sektioner af disse filer.
-
----
-
-## Lokale Konfiguration
-
-Lokal sektionen definerer dine oversættelsessprog:
-
-- source: Dit primære sprog til indholdsskabelse (f.eks. "en" for engelsk)
-- targets: Et array af sprog, du ønsker at oversætte til (f.eks. ["es", "fr", "de"] for spansk, fransk og tysk)
-
-Languine understøtter et bredt udvalg af sprogkoder, herunder:
-- Simple koder: en, es, fr, de
-- Regionsspecifikke koder: pt-BR, zh-CN, zh-TW
-
-## Fil Konfiguration
-
-Filer sektionen definerer, hvilke filer Languine skal oversætte. Du kan konfigurere flere filtyper og mønstre:
-
----
-
-### JSON Filer
-```typescript
-files: {
-  json: {
-    include: ["locales/[locale].json"],
-  },
-}
-```
-
----
-
-### Markdown/MDX Filer
-```typescript
-files: {
-  md: {
-    include: ["docs/[locale]/*.md"],
-  },
-  mdx: {
-    include: ["blog/[locale]/*.mdx"],
-  },
-}
-```
-
----
-
-### Mobile Platform Filer
-
-For iOS (Xcode):
-```typescript
-files: {
-  "xcode-xcstrings": {
-    include: ["Example/Localizable.xcstrings"],
-  },
-  // Eller for traditionelle .strings filer
-  "xcode-strings": {
-    include: ["Example/[locale].lproj/Localizable.strings"],
-  },
-}
-```
-
----
-
-For Android:
-```typescript
-files: {
-  android: {
-    include: ["locales/[locale].xml"],
-  },
-}
-```
-
----
-
-### Andre Formater
-
-Her er en komplet liste over filformater, der understøttes af Languine:
-
-- [JSON](/docs/json) - Standard JSON oversættelsesfiler
-- [YAML](/docs/yaml) - YAML oversættelsesfiler
-- [Properties](/docs/properties) - Java properties filer
-- [Android](/docs/android) - Android XML ressourcefiler
-- [iOS](/docs/ios) - iOS lokaliseringsfiler
-- [iOS Stringsdict](/docs/xcode-stringsdict) - iOS pluraliseringsfiler
-- [iOS XCStrings](/docs/xcode-xcstrings) - Moderne Xcode string kataloger
-- [Markdown](/docs/md) - Dokumentationsfiler
-- [MDX](/docs/mdx) - Dokumentation med JSX
-- [HTML](/docs/html) - HTML filer
-- [JavaScript](/docs/js) - JavaScript filer
-- [TypeScript](/docs/ts) - TypeScript filer
-- [Gettext PO](/docs/po) - GetText oversættelsesfiler
-- [XLIFF](/docs/xliff) - XML Lokaliserings Udvekslingsfilformat
-- [CSV](/docs/csv) - Regnearksbaserede oversættelser
-- [XML](/docs/xml) - XML ressourcefiler
-- [Flutter ARB](/docs/arb) - Applikationsressourcepakke filer
-
----
-
-## Fil Mønstre
-
-[locale] pladsholderen i filmønstre erstattes automatisk med den passende sprogkode under oversættelsen. For eksempel:
-
-- locales/[locale].json bliver:
-  - locales/en.json
-  - locales/es.json
-  - locales/fr.json
-
-Du kan inkludere flere mønstre for hver filtype og bruge glob mønstre:
-```typescript
-files: {
-  json: {
-    include: [
-      "src/locales/[locale].json",
-      "src/components/[locale]/*.json"
-    ],
-  },
-}
-```
-
----
-
-## Projekt ID (Valgfrit)
-
-Hvis du bruger Languines cloud-tjenester, kan du inkludere dit projekt ID i konfigurationen:
-
-```typescript
-export default defineConfig({
-  projectId: "prj_your_project_id",
-  locale: {
-    // ... lokale konfiguration
-  },
-  files: {
-    // ... fil konfiguration
-  },
-});
-```
-
----
-
-## Oversættelsesstatus Sporing
-
-Languine opretter automatisk og vedligeholder en languine.lock fil for at spore status for dine oversættelser. Denne fil:
-
-- Sporer hvilket indhold der er blevet oversat
-- Hjælper med at identificere hvad der skal opdateres, når kildeindhold ændres
-- Skal forpligtes til dit versionskontrolsystem
-
-Du behøver ikke manuelt at redigere låsefilen - Languine håndterer det automatisk, når du kører oversættelseskommandoer.
-
-## Bedste Praksis
-
-1. **Versionskontrol**: Forpligt altid både languine.config.ts og languine.lock til dit repository
-2. **Filorganisation**: Hold dine oversættelsesfiler organiseret i en konsekvent mappestruktur
-3. **Sprogkoder**: Brug standard sprogkoder for at sikre kompatibilitet
-4. **Mønstre**: Brug specifikke inkluderingsmønstre for at undgå at oversætte unødvendige filer
-5. **Projekt ID**: Hold dit projekt ID sikkert og del det ikke offentligt, hvis du bruger cloud-tjenester, brug i stedet `LANGUINE_PROJECT_ID` miljøvariablen.
diff --git a/apps/web/src/markdown/docs/da/csv.mdx b/apps/web/src/markdown/docs/da/csv.mdx
deleted file mode 100644
index fab8d944..00000000
--- a/apps/web/src/markdown/docs/da/csv.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# CSV
-
-Languine understøtter CSV (Comma-Separated Values) filer til enkel oversættelsesstyring. Dette format er ideelt til regnearksbaserede arbejdsgange og nem integration med eksterne oversættelsesværktøjer.
-
----
-
-## Opsætning
-
-Først skal du sikre dig, at du har en languine.config.json eller languine.config.ts konfigurationsfil i rodmappen af dit projekt. Her er et eksempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "csv": {
-      "include": ["translations/[locale].csv"]
-    }
-  }
-}
-```
-
-## Oversættelse
-
-Når din konfiguration er sat op, skal du køre:
-
-```bash
-npx languine@latest translate
-```
-
-Når du kører denne kommando, vil Languine:
-
-- Indlæse din kilde CSV-fil (f.eks. translations/en.csv)
-- Registrere eventuelle nye eller ændrede oversættelsesstrenge
-- Generere oversættelser til dine målsprog
-- Oprette eller opdatere målsprog CSV-filerne (f.eks. translations/sv.csv)
-- Opretholde kolonnens struktur og formatering
-- Bevare eventuelle yderligere metadata kolonner
diff --git a/apps/web/src/markdown/docs/da/expo.mdx b/apps/web/src/markdown/docs/da/expo.mdx
deleted file mode 100644
index bce322ca..00000000
--- a/apps/web/src/markdown/docs/da/expo.mdx
+++ /dev/null
@@ -1,41 +0,0 @@
-# Expo
-
-Languine understøtter Expo-lokalisering og integreres problemfrit med Expos i18n-system. Dette format fungerer med både JavaScript- og TypeScript-projekter og understøtter indlejrede strukturer og pluralisering.
-
----
-
-## Opsætning
-
-Først skal du sikre dig, at du har en languine.config.json eller languine.config.ts konfigurationsfil i rodmappen af dit projekt. Her er et eksempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "expo": {
-      "include": ["assets/locales/[locale].json"]
-    }
-  }
-}
-```
-
-## Oversættelse
-
-Når din konfiguration er sat op, skal du køre:
-
-```bash
-npx languine@latest translate
-```
-
-Når du kører denne kommando, vil Languine:
-
-- Indlæse din kildeoversættelsesfil (f.eks. assets/locales/en.json)
-- Registrere eventuelle nye eller ændrede oversættelsesstrenge
-- Generere oversættelser til dine målsprog
-- Oprette eller opdatere målsprogfilene (f.eks. assets/locales/sv.json)
-- Bevare indlejret struktur og pluraliseringsregler
-- Generere TypeScript-typer, hvis det er aktiveret
-- Opretholde kompatibilitet med expo-localization
diff --git a/apps/web/src/markdown/docs/da/github-actions.mdx b/apps/web/src/markdown/docs/da/github-actions.mdx
deleted file mode 100644
index 041f495c..00000000
--- a/apps/web/src/markdown/docs/da/github-actions.mdx
+++ /dev/null
@@ -1,92 +0,0 @@
-# GitHub Actions
-
-Med GitHub-handlingen kan du nemt oversætte din kode ved blot at skubbe din kode til repositoryet; GitHub-handlingen vil derefter oversætte dine nye nøgler, enten oprette en pull-anmodning eller forpligte dine ændringer.
-Dette sparer dig for meget tid og kræfter, samtidig med at der opretholdes høj kvalitet i oversættelserne.
-
----
-
-## Installation
-
-For at bruge Languine GitHub-handlingen i dit repository skal du:
-
-1. Opsætte dine repository-hemmeligheder med dine Languine-legitimationsoplysninger
-2. Oprette en workflow-fil i dit repository
-
-### Opsætning af Repository-hemmeligheder
-
-Tilføj følgende hemmeligheder i dine repository-indstillinger (Indstillinger > Hemmeligheder og variabler > Handlinger):
-
-- `LANGUINE_API_KEY`: Din Languine API-nøgle
-- `LANGUINE_PROJECT_ID`: Dit Languine projekt-ID
-
-Du kan finde disse værdier i dit Languine-dashboard under Projektindstillinger.
-
-
-
-### Miljøvariabler
-
-GitHub-handlingen bruger følgende miljøvariabler:
-- `LANGUINE_API_KEY` (Obligatorisk): Din Languine API-nøgle til autentificering
-- `LANGUINE_PROJECT_ID` (Obligatorisk): Dit Languine projekt-ID 
-- `GITHUB_TOKEN` (Obligatorisk): Automatisk leveret af GitHub, bruges til at oprette PR'er
-
-### Eksempel på Workflow
-
-Opret en ny fil .github/workflows/languine.yml i dit repository med følgende indhold:
-
-```ts title=".github/workflows/release.yml"
-name: Udrulning af hjemmeside
-
-on:
-  push:
-    branches:
-      - '**'
-    paths:
-      - apps/web/**
-
-jobs:
-  translate:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-      pull-requests: write
-    steps:
-      - uses: actions/checkout@v4
-      
-      - name: Languine Action
-        uses: languine/languine-action@v1
-        env:
-           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          api-key: ${{ secrets.LANGUINE_API_KEY }}
-          project-id: ${{ secrets.LANGUINE_PROJECT_ID }}
-```
- 
- Denne workflow vil:
-- Køre ved skub til hovedgrenen
-- Køre ved pull-anmodninger til hovedgrenen
-- Kan udløses manuelt fra fanen Handlinger
-- Tjekke din kode og køre Languine oversættelsesprocessen
-- Oprette en pull-anmodning med eventuelle nye oversættelser (konfigurerbar)
-
-#### Arbejdsmappeindstilling
-
-`working-directory`-indstillingen giver dig mulighed for at specificere, hvor dine oversættelsesfiler er placeret. Dette er s��rligt nyttigt i monorepos, hvor dine oversættelser kan være i et specifikt pakke- eller app-mappe. For eksempel:
-
-#### Pull-anmodningsindstilling
-
-`create-pull-request`-indstillingen styrer, om handlingen opretter en pull-anmodning med ændringerne eller forpligter dem direkte til grenen:
-
-```typescript title=".github/workflows/languine.yml"
-with:
-  create-pull-request: true # opret en pull-anmodning med ændringerne
-```
-
-Når den er indstillet til `true`, vil handlingen:
-- Oprette en ny gren med ændringerne
-- Oprette en pull-anmodning til gennemgang
-- Tilføje passende etiketter og beskrivelse
-
-Når den er indstillet til `false` (standard), vil handlingen:
-- Forpligte ændringerne direkte til den nuværende gren
-- Skubbe ændringerne uden at oprette en pull-anmodning
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/da/html.mdx b/apps/web/src/markdown/docs/da/html.mdx
deleted file mode 100644
index c0b4f312..00000000
--- a/apps/web/src/markdown/docs/da/html.mdx
+++ /dev/null
@@ -1,41 +0,0 @@
-# HTML
-
-Languine understøtter lokalisering af HTML-filer, der håndterer både tekstindhold og attributter. Dette format er ideelt til statiske hjemmesider og HTML-skabeloner, med støtte til at bevare HTML-struktur og formatering.
-
----
-
-## Opsætning
-
-Først skal du sikre dig, at du har en languine.config.json eller languine.config.ts konfigurationsfil i rodmappen af dit projekt. Her er et eksempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "html": {
-      "include": ["pages/[locale]/*.html"]
-    }
-  }
-}
-```
-
-## Oversættelse
-
-Når din konfiguration er sat op, skal du køre:
-
-```bash
-npx languine@latest translate
-```
-
-Når du kører denne kommando, vil Languine:
-
-- Indlæse dine kilde-HTML-filer (f.eks. pages/en/*.html)
-- Registrere eventuelle nye eller ændrede oversættelsesstrenge
-- Generere oversættelser til dine målsprog
-- Oprette eller opdatere HTML-filerne for målsproget (f.eks. pages/sv/*.html)
-- Bevare HTML-struktur og formatering
-- Håndtere angivne attributoversættelser
-- Bevare kommentarer og specielle tags
diff --git a/apps/web/src/markdown/docs/da/introduction.mdx b/apps/web/src/markdown/docs/da/introduction.mdx
deleted file mode 100644
index dd3ef3b3..00000000
--- a/apps/web/src/markdown/docs/da/introduction.mdx
+++ /dev/null
@@ -1,80 +0,0 @@
-# Introduktion
-
-Languine er en open-source lokaliseringsplatform, der hjælper udviklere med at oversætte deres applikationer med AI-drevne oversættelser. Den tilbyder et problemfrit workflow til at administrere oversættelser på tværs af flere sprog, samtidig med at den opretholder høj kvalitet gennem maskinlæring.
-
-
-<div className="flex flex-col items-center justify-center p-4 mt-10 h-[400px] sm:h-[500px] md:h-[650px]">
-        <pre
-          className="p-4 text-sm leading-5 scale-[0.5] sm:scale-[0.65] md:scale-90 transform-gpu"
-          style={{
-            fontFamily: "monospace",
-            whiteSpace: "pre",
-            textAlign: "left",
-          }}
-        >
-          {`
-                                  ┌───────────────┐
-                                  │   Git Push    │
-                                  └───────────────┘
-                                          │
-                                          ▼
-             ┌─────────────────────────────────────────────────────────┐
-             │░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-             │░░░░░░░░░░░░░░░░░░░░ Languine Engine ░░░░░░░░░░░░░░░░░░░░│
-             │░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-             └─────────────────────────────────────────────────────────┘
-                                          │
-                                          ▼
-                                          │
-            ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┼ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─
-           │                              │                              │
-           ▼                              ▼                              ▼
- ╔═══════════════════╗          ╔═══════════════════╗          ╔═══════════════════╗
- ║                   ║          ║                   ║          ║                   ║
- ║      Engelsk      ║          ║      Spansk       ║          ║      Japansk      ║
- ║    Oversættelse    ║          ║    Oversættelse    ║          ║     Oversættelse   ║
- ║                   ║          ║                   ║          ║                   ║
- ╚═══════════════════╝          ╚═══════════════════╝          ╚═══════════════════╝
-           │                              │                              │
-           └──────────────────────────────┼──────────────────────────────┘
-                                          ▼
-                                  ┌───────────────┐
-                                  │     Sammenflet │
-                                  │ Pull Request  │
-                                  └───────────────┘
-                                          │
-                                          ▼
-                              ┌─────────────────────┐
-                              │      Fuldført       │
-                              │      (Udrulning)    │
-                              └─────────────────────┘
-`}
-        </pre>
-      </div>
-
-## Nøglefunktioner
-
-- **AI-Drevne Oversættelser**: Udnyt avancerede maskinlæringsmodeller til at generere høj kvalitet oversættelser på tværs af 100+ sprog
-- **Git Integration**: Synkroniser dine oversættelser direkte med dine Git-repositorier og automatiser opdateringer gennem CI/CD pipelines
-- **Udvikler-Først**: Bygget med udviklere i tankerne, med en kraftfuld CLI, API og GitHub Action integration
-- **Tilpassede Parsere**: Understøttelse af forskellige filformater og muligheden for at oprette tilpassede parsere til dine specifikke behov
-- **Versionskontrol**: Spor ændringer, administrer grene og oprethold oversættelseshistorik
-- **Open Source**: Fuldstændig open source og tilgængelig på GitHub, hvilket muliggør gennemsigtighed og bidrag fra fællesskabet
-
-## Sådan fungerer det
-
-1. **Opsætning**: Installer Languine CLI og konfigurer dit projekt med en enkel initialiseringsproces
-2. **Forbind**: Link dit repository og opsæt dit foretrukne workflow (CLI, API eller GitHub Action)
-3. **Oversæt**: Push dit kildeindhold og lad Languine håndtere oversættelserne til dine målsprog
-4. **Synkroniser**: Automatisk synkronisering af oversat indhold tilbage til dit repository og udrul med selvtillid
-
-## Kom i gang
-
-For at begynde at bruge Languine, følg vores [Installation](/docs/installation) guide for at opsætte CLI og oprette dit første projekt. Tjek derefter [Quickstart](/docs/quickstart) guiden for at lære det grundlæggende i at administrere oversættelser med Languine.
-
-For detaljeret information om specifikke funktioner og avanceret brug, udforsk vores omfattende dokumentationsafsnit:
-
-- [Konfiguration](/docs/configuration) - Lær hvordan du konfigurerer Languine til dit projekt
-- [CLI](/docs/cli) - Opdag det fulde udvalg af CLI-kommandoer
-- [API](/docs/api) - Integrer Languine programmatisk
-- [Workflows](/docs/workflows) - Opsæt automatiserede oversættelsesworkflows
diff --git a/apps/web/src/markdown/docs/da/ios.mdx b/apps/web/src/markdown/docs/da/ios.mdx
deleted file mode 100644
index a521058b..00000000
--- a/apps/web/src/markdown/docs/da/ios.mdx
+++ /dev/null
@@ -1,39 +0,0 @@
-# iOS
-
-Languine understøtter iOS Localizable.strings-filer, den standard lokaliseringsformat for iOS-applikationer. Dette format håndterer grundlæggende nøgle-værdi-strengpar og understøtter kommentarer til at give kontekst til oversættere.
-
----
-
-## Opsætning
-
-Først skal du sikre dig, at du har en languine.config.json eller languine.config.ts konfigurationsfil i rodmappen af dit projekt. Her er et eksempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "ios": {
-      "include": ["[locale].lproj/Localizable.strings"]
-    }
-  }
-}
-```
-
-## Oversættelse
-
-Når din konfiguration er sat op, skal du køre:
-
-```bash
-npx languine@latest translate
-```
-
-Når du kører denne kommando, vil Languine:
-
-- Indlæse din kilde Localizable.strings-fil (f.eks. en.lproj/Localizable.strings)
-- Registrere eventuelle nye eller ændrede oversættelsesstrenge
-- Generere oversættelser til dine målsprog
-- Oprette eller opdatere målsprogfilene (f.eks. sv.lproj/Localizable.strings)
-- Bevare eventuelle eksisterende kommentarer og formatering
diff --git a/apps/web/src/markdown/docs/da/js.mdx b/apps/web/src/markdown/docs/da/js.mdx
deleted file mode 100644
index fe5e3c9d..00000000
--- a/apps/web/src/markdown/docs/da/js.mdx
+++ /dev/null
@@ -1,42 +0,0 @@
-# JavaScript
-
-Languine understøtter JavaScript/TypeScript lokaliseringsfiler, perfekt til moderne webapplikationer. Dette format håndterer både objektlitteraler og modul-eksporter, understøtter indlejrede strukturer og dynamisk indhold.
-
----
-
-## Opsætning
-
-Først skal du sikre dig, at du har en languine.config.json eller languine.config.ts konfigurationsfil i rodmappen af dit projekt. Her er et eksempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "js": {
-      "include": ["src/locales/[locale].js"]
-    }
-  }
-}
-```
-
-## Oversættelse
-
-Når din konfiguration er sat op, kør:
-
-```bash
-npx languine@latest translate
-```
-
-Når du kører denne kommando, vil Languine:
-
-- Indlæse dine kilde JavaScript-filer (f.eks. src/locales/en.js)
-- Registrere eventuelle nye eller ændrede oversættelsesstrenge
-- Generere oversættelser til dine målsprog
-- Oprette eller opdatere målsprogfilene (f.eks. src/locales/sv.js)
-- Bevare modulstrukturen og eksporter
-- Håndtere indlejrede objekter og arrays
-- Opretholde kodeformatering og kommentarer
-- Generere TypeScript-typer, hvis det er aktiveret
diff --git a/apps/web/src/markdown/docs/da/json.mdx b/apps/web/src/markdown/docs/da/json.mdx
deleted file mode 100644
index 36c8e260..00000000
--- a/apps/web/src/markdown/docs/da/json.mdx
+++ /dev/null
@@ -1,41 +0,0 @@
-# JSON
-
-Languine understøtter JSON-filer som kildeformat med de almindelige krav til pluralisering og interpolation. Dette format bruges i mange rammer som React, Vue, Ruby on Rails og mere.
-
-
----
-
-
-## Opsætning
-
-Først skal du sikre dig, at du har en languine.config.json eller languine.config.ts konfigurationsfil i rodmappen af dit projekt. Her er et eksempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "json": {
-      "include": ["locales/[locale].json"]
-    }
-  }
-}
-
-```
-
-## Oversættelse
-
-Når din konfiguration er sat op, skal du køre:
-
-```bash
-npx languine@latest translate
-```
-
-Når du kører denne kommando, vil Languine:
-
-- Indlæse din kilde JSON-fil (f.eks. locales/en.json)
-- Registrere eventuelle nye eller ændrede oversættelsesstrenge
-- Generere oversættelser til dine målsprog
-- Oprette eller opdatere JSON-filerne for målsprogene (f.eks. locales/sv.json, locales/de.json, locales/fr.json)
diff --git a/apps/web/src/markdown/docs/da/md.mdx b/apps/web/src/markdown/docs/da/md.mdx
deleted file mode 100644
index bd8d12ff..00000000
--- a/apps/web/src/markdown/docs/da/md.mdx
+++ /dev/null
@@ -1,45 +0,0 @@
-# Markdown
-
-Languine understøtter lokalisering af Markdown-filer, perfekt til dokumentation, blogindlæg og indholdstunge websteder. Dette format bevarer Markdown-syntaksen, mens indholdet oversættes, inklusive understøttelse af front matter.
-
----
-
-## Opsætning
-
-Først skal du sikre dig, at du har en languine.config.json eller languine.config.ts konfigurationsfil i rodmappen af dit projekt. Her er et eksempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "md": {
-      "include": ["content/[locale]/**/*.md"],
-      "frontMatter": true,  // Valgfrit: standard er true
-      "translateFrontMatterFields": ["title", "description"]  // Valgfrit: angiv hvilke front matter felter der skal oversættes
-    }
-  }
-}
-```
-
-## Oversættelse
-
-Når din konfiguration er sat op, skal du køre:
-
-```bash
-npx languine@latest translate
-```
-
-Når du kører denne kommando, vil Languine:
-
-- Indlæse dine kilde Markdown-filer (f.eks. content/en/*.md)
-- Registrere eventuelt nyt eller ændret indhold
-- Generere oversættelser til dine målsprog
-- Oprette eller opdatere målsprogfilene (f.eks. content/sv/*.md)
-- Bevare Markdown-formattering og struktur
-- Håndtere oversættelser af front matter
-- Opretholde links og referencer
-- Holde kodeblokke uoversatte
-- Bevare HTML inden for Markdown
diff --git a/apps/web/src/markdown/docs/da/mdx.mdx b/apps/web/src/markdown/docs/da/mdx.mdx
deleted file mode 100644
index 3d7a5a53..00000000
--- a/apps/web/src/markdown/docs/da/mdx.mdx
+++ /dev/null
@@ -1,45 +0,0 @@
-# Markdown (MDX)
-
-Languine understøtter lokalisering af Markdown (MDX) filer, perfekt til dokumentation, blogindlæg og indholdstunge websteder. Dette format bevarer Markdown-syntaksen, mens indholdet oversættes, inklusive understøttelse af front matter.
-
----
-
-## Opsætning
-
-Først skal du sikre dig, at du har en languine.config.json eller languine.config.ts konfigurationsfil i rodmappen af dit projekt. Her er et eksempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "mdx": {
-      "include": ["content/[locale]/**/*.mdx"],
-      "frontMatter": true,  // Valgfrit: standard er true
-      "translateFrontMatterFields": ["title", "description"]  // Valgfrit: angiv hvilke front matter felter der skal oversættes
-    }
-  }
-}
-```
-
-## Oversættelse
-
-Når din konfiguration er sat op, kør:
-
-```bash
-npx languine@latest translate
-```
-
-Når du kører denne kommando, vil Languine:
-
-- Indlæse dine kilde Markdown-filer (f.eks. content/en/*.mdx)
-- Registrere eventuelt nyt eller ændret indhold
-- Generere oversættelser til dine målsprog
-- Oprette eller opdatere målsprogfilene (f.eks. content/sv/*.mdx)
-- Bevare Markdown-format og struktur
-- Håndtere oversættelser af front matter
-- Opretholde links og referencer
-- Holde kodeblokke uoversatte
-- Bevare HTML inden for Markdown
diff --git a/apps/web/src/markdown/docs/da/overrides.mdx b/apps/web/src/markdown/docs/da/overrides.mdx
deleted file mode 100644
index 2379fe2b..00000000
--- a/apps/web/src/markdown/docs/da/overrides.mdx
+++ /dev/null
@@ -1,7 +0,0 @@
-# Overskrivninger
-
-Languine giver dig mulighed for at overskrive oversættelser for specifikke nøgler. Dette er nyttigt, når du vil sikre, at en bestemt oversættelse bruges for en bestemt nøgle, uanset den standardoversættelse.
-
-## Sådan fungerer det
-
-I dashboardet kan du oprette overskrivninger for specifikke nøgler. Du kan også oprette overskrivninger for specifikke sprog.
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/da/po.mdx b/apps/web/src/markdown/docs/da/po.mdx
deleted file mode 100644
index 4768d5e7..00000000
--- a/apps/web/src/markdown/docs/da/po.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# PO (Gettext)
-
-Languine understøtter PO-filer, det udbredte Gettext-lokaliseringsformat. Dette format er populært i mange programmeringsmiljøer, især i Linux-applikationer og PHP-rammer, og tilbyder støtte til kontekst, pluraler og oversætterkommentarer.
-
----
-
-## Opsætning
-
-Først skal du sikre dig, at du har en languine.config.json eller languine.config.ts konfigurationsfil i rodmappen af dit projekt. Her er et eksempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "po": {
-      "include": ["locales/[locale]/LC_MESSAGES/messages.po"]
-    }
-  }
-}
-```
-
-## Oversættelse
-
-Når din konfiguration er sat op, skal du køre:
-
-```bash
-npx languine@latest translate
-```
-
-Når du kører denne kommando, vil Languine:
-
-- Indlæse din kilde PO-fil (f.eks. locales/en/LC_MESSAGES/messages.po)
-- Registrere eventuelle nye eller ændrede oversættelsesstrenge
-- Generere oversættelser til dine målsprog
-- Oprette eller opdatere målsprog PO-filer (f.eks. locales/sv/LC_MESSAGES/messages.po)
-- Bevare metadata, kontekster og pluralformer
-- Opretholde oversætterkommentarer og referenceinformation
diff --git a/apps/web/src/markdown/docs/da/prettier.mdx b/apps/web/src/markdown/docs/da/prettier.mdx
deleted file mode 100644
index 9ff78004..00000000
--- a/apps/web/src/markdown/docs/da/prettier.mdx
+++ /dev/null
@@ -1,26 +0,0 @@
-# Prettier
-
-Languine understøtter formatering med [Prettier](https://prettier.io/) gennem hooks. Du kan konfigurere Prettier til automatisk at formatere dine oversættelsesfiler, efter de er genereret.
-
-Her er et eksempel på konfiguration:
-
-```typescript title="languine.config.ts"
-import { defineConfig } from "languine";
-
-export default defineConfig({
-  locale: {
-    source: "en",
-    targets: ["es", "fr"],
-  },
-  files: {
-    json: {
-      include: ["locales/[locale].json"],
-    },
-  },
-  hooks: {
-    afterTranslate: async (files) => {
-      await prettier.format(files, { parser: "json" });
-    },
-  },
-});
-```
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/da/properties.mdx b/apps/web/src/markdown/docs/da/properties.mdx
deleted file mode 100644
index f676d8df..00000000
--- a/apps/web/src/markdown/docs/da/properties.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# Egenskaber
-
-Languine understøtter Java Properties-filer, den standard lokaliseringsformat for Java-applikationer. Dette format håndterer Unicode-escapning og understøtter både nøgle-værdi-par og kommentarer.
-
----
-
-## Opsætning
-
-Først skal du sikre dig, at du har en languine.config.json eller languine.config.ts konfigurationsfil i rodmappen af dit projekt. Her er et eksempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "properties": {
-      "include": ["src/main/resources/messages_[locale].properties"]
-    }
-  }
-}
-```
-
-## Oversættelse
-
-Når din konfiguration er sat op, skal du køre:
-
-```bash
-npx languine@latest translate
-```
-
-Når du kører denne kommando, vil Languine:
-
-- Indlæse din kilde properties-fil (f.eks. messages_en.properties)
-- Registrere eventuelle nye eller ændrede oversættelsesstrenge
-- Generere oversættelser til dine målsprog
-- Oprette eller opdatere målsprog properties-filer (f.eks. messages_sv.properties)
-- Håndtere Unicode-escapning automatisk
-- Bevare kommentarer og formatering
diff --git a/apps/web/src/markdown/docs/da/quickstart.mdx b/apps/web/src/markdown/docs/da/quickstart.mdx
deleted file mode 100644
index 0fc2957a..00000000
--- a/apps/web/src/markdown/docs/da/quickstart.mdx
+++ /dev/null
@@ -1,60 +0,0 @@
-# Hurtigstart
-
-Start med at installere Languine.
-
-Kør derefter følgende kommando for at initialisere Languine.
-
-```bash title="Terminal"
-npx languine@latest init
-```
-
-Følg trinene for at opsætte dit projekt.
-
-## Første Oversættelse
-
-Nu er du klar til at oversætte din kode.
-
-Start med at tilføje en nøgle til din kildefil, for eksempel hvis du vælger at bruge `en.json` som din kildefil, tilføj en nøgle til den.
-
-```json title="src/locales/en.json"
-{
-  "welcome": "Velkommen til vores applikation!",
-  "user": {
-    "greeting": "Hej, {{name}}!",
-    "profile": {
-      "title": "Din profil",
-      "edit": "Rediger profil"
-    }
-  },
-  "notifications": {
-    "messages": "Du har {{count}} ny(e) besked(er).",
-    "empty": "Ingen nye meddelelser."
-  }
-}
-
-```
-
-
-## Oversæt
-
-Kør følgende kommando for at oversætte dit indhold:
-
-```bash title="Terminal"
-npx languine@latest translate
-```
-
-## Dette vil:
-1. Oprette oversættelsesfiler for hvert målsprog
-2. Generere oversættelser af høj kvalitet med Languine Engine
-3. Oprette en `languine.lock` fil for at spore oversættelsesstatus
-
-Lock-filen hjælper Languine med at identificere, hvilke oversættelser der skal opdateres, når dit kildeindhold ændres. Sørg for at forpligte denne fil til dit repository.
-
-## Næste Skridt
-
-Nu hvor du har Languine opsat, kan du:
-- Tilføje flere sprog i din `languine.config.json` fil
-- Integrere Languine i din CI/CD pipeline
-- Bruge vores API til programmatisk oversættelse
-
-Tjek vores andre vejledninger for at lære mere om Languines avancerede funktioner.
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/da/react-email.mdx b/apps/web/src/markdown/docs/da/react-email.mdx
deleted file mode 100644
index 2fb34105..00000000
--- a/apps/web/src/markdown/docs/da/react-email.mdx
+++ /dev/null
@@ -1,41 +0,0 @@
-# React Email
-
-Languine understøtter React Email-skabeloner, hvilket giver dig mulighed for at håndtere oversættelser til dine e-mail-skabeloner bygget med React Email. Denne integration håndterer både tekstindhold og HTML-attributter, samtidig med at den bevarer React-komponentstrukturen.
-
----
-
-## Opsætning
-
-Først skal du sikre dig, at du har en `languine.config.json` eller `languine.config.ts` konfigurationsfil i roden af dit projekt. Her er et eksempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "react-email": {
-      "include": ["emails/[locale]/*.tsx"]
-    }
-  }
-}
-```
-
-## Oversættelse
-
-Når din konfiguration er sat op, skal du køre:
-
-```bash
-npx languine@latest translate
-```
-
-Når du kører denne kommando, vil Languine:
-
-- Indlæse dine kilde React Email-skabeloner (f.eks. emails/en/*.tsx)
-- Registrere eventuelle nye eller ændrede oversættelsesstrenge
-- Generere oversættelser til dine målsprog
-- Oprette eller opdatere e-mail-skabelonerne på målsproget (f.eks. emails/sv/*.tsx)
-- Bevare React-komponentstrukturen og props
-- Opretholde HTML-formattering og styling
-- Håndtere interpolation og dynamisk indhold
diff --git a/apps/web/src/markdown/docs/da/ts.mdx b/apps/web/src/markdown/docs/da/ts.mdx
deleted file mode 100644
index f0f430b3..00000000
--- a/apps/web/src/markdown/docs/da/ts.mdx
+++ /dev/null
@@ -1,43 +0,0 @@
-# TypeScript
-
-Languine understøtter TypeScript lokaliseringsfiler med fuld typesikkerhed. Dette format udvider JavaScript understøttelse med yderligere TypeScript-specifikke funktioner og typegenereringsmuligheder.
-
----
-
-## Opsætning
-
-Først skal du sikre dig, at du har en languine.config.json eller languine.config.ts konfigurationsfil i rodmappen af dit projekt. Her er et eksempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "ts": {
-      "include": ["src/locales/[locale].ts"]
-    }
-  }
-}
-```
-
-## Oversættelse
-
-Når din konfiguration er sat op, skal du køre:
-
-```bash
-npx languine@latest translate
-```
-
-Når du kører denne kommando, vil Languine:
-
-- Indlæse dine kilde TypeScript-filer (f.eks. src/locales/en.ts)
-- Registrere eventuelle nye eller ændrede oversættelsesstrenge
-- Generere oversættelser til dine målsprog
-- Oprette eller opdatere målsprogfilene (f.eks. src/locales/sv.ts)
-- Generere TypeScript type definitioner
-- Bevare typeannoteringer og interfaces
-- Håndtere indlejrede objekter med korrekt typing
-- Opbevare kodeformatering og dokumentationskommentarer
-- Understøtte bogstavelige typer og unionstyper
diff --git a/apps/web/src/markdown/docs/da/xcode-stringsdict.mdx b/apps/web/src/markdown/docs/da/xcode-stringsdict.mdx
deleted file mode 100644
index 01a56d90..00000000
--- a/apps/web/src/markdown/docs/da/xcode-stringsdict.mdx
+++ /dev/null
@@ -1,44 +0,0 @@
-# Xcode Stringsdict
-
-Languine understøtter Xcodes Stringsdict-format, der bruges til komplekse pluraliseringsregler i iOS- og macOS-applikationer. Dette format håndterer pluralformer, variabelsubstitutioner og sprog-specifikke pluralregler.
-
----
-
-## Opsætning
-
-Først skal du sikre dig, at du har en languine.config.json eller languine.config.ts konfigurationsfil i rodmappen af dit projekt. Her er et eksempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "stringsdict": {
-      "include": ["MyApp/Localizable.stringsdict"]
-    }
-  }
-}
-```
-
-## Oversættelse
-
-Når din konfiguration er sat op, skal du køre:
-
-```bash
-npx languine@latest translate
-```
-
-Når du kører denne kommando, vil Languine:
-
-- Indlæse dine Stringsdict-filer
-- Registrere eventuelle nye eller ændrede pluralregler
-- Generere oversættelser til dine målsprog
-- Opdatere Stringsdict-filerne med nye oversættelser
-- Håndtere komplekse pluralregler for hvert sprog
-- Opretholde variabelsubstitutioner
-- Bevare ordbogsstrukturen
-- Understøtte sprog-specifikke pluralformer
-- Validere konsistensen af pluralregler
-- Bevare formateringsspecifikationer
diff --git a/apps/web/src/markdown/docs/da/xcode-xcstrings.mdx b/apps/web/src/markdown/docs/da/xcode-xcstrings.mdx
deleted file mode 100644
index 3111d562..00000000
--- a/apps/web/src/markdown/docs/da/xcode-xcstrings.mdx
+++ /dev/null
@@ -1,44 +0,0 @@
-# Xcode Strings (XCStrings)
-
-Languine understøtter Xcodes XCStrings-format, det moderne lokaliseringsformat til iOS- og macOS-applikationer. Dette format håndterer strengkataloger med støtte til variationer, pluralisering og udviklerkommentarer.
-
----
-
-## Opsætning
-
-Først skal du sikre dig, at du har en languine.config.json eller languine.config.ts konfigurationsfil i rodmappen af dit projekt. Her er et eksempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "xcstrings": {
-      "include": ["MyApp/Localizable.xcstrings"]
-    }
-  }
-}
-```
-
-## Oversættelse
-
-Når din konfiguration er sat op, skal du køre:
-
-```bash
-npx languine@latest translate
-```
-
-Når du kører denne kommando, vil Languine:
-
-- Indlæse din XCStrings-katalog
-- Registrere eventuelle nye eller ændrede strenge
-- Generere oversættelser til dine målsprog
-- Opdatere strengkatalogen med nye oversættelser
-- Bevare strengvariationer og pluraliseringsregler
-- Opretholde udviklerkommentarer og kontekst
-- Håndtere variabelsubstitutioner
-- Understøtte adaptive strenge
-- Bevare formateringsspecifikationer
-- Validere strukturen af strengkatalogen
diff --git a/apps/web/src/markdown/docs/da/xliff.mdx b/apps/web/src/markdown/docs/da/xliff.mdx
deleted file mode 100644
index 23a19a00..00000000
--- a/apps/web/src/markdown/docs/da/xliff.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# XLIFF
-
-Languine understøtter XLIFF (XML Localization Interchange File Format), et XML-baseret format designet til at udveksle lokaliseringsdata. Dette format er bredt anvendt i professionelle oversættelsesarbejdsgange og understøtter både XLIFF 1.2 og 2.0 versioner.
-
----
-
-## Opsætning
-
-Først skal du sikre dig, at du har en languine.config.json eller languine.config.ts konfigurationsfil i rodmappen af dit projekt. Her er et eksempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "xliff": {
-      "include": ["locales/[locale].xlf"]
-    }
-  }
-}
-```
-
-## Oversættelse
-
-Når din konfiguration er sat op, skal du køre:
-
-```bash
-npx languine@latest translate
-```
-
-Når du kører denne kommando, vil Languine:
-
-- Indlæse din kilde XLIFF-fil (f.eks. locales/en.xlf)
-- Registrere eventuelle nye eller ændrede oversættelsesenheder
-- Generere oversættelser til dine målsprog
-- Oprette eller opdatere målsprog XLIFF-filer (f.eks. locales/sv.xlf)
-- Bevare noter, kontekstinformation og tilstandsattributter
-- Opretholde kompatibilitet med CAT (Computer-Aided Translation) værktøjer
diff --git a/apps/web/src/markdown/docs/da/xml.mdx b/apps/web/src/markdown/docs/da/xml.mdx
deleted file mode 100644
index 19f9c6b7..00000000
--- a/apps/web/src/markdown/docs/da/xml.mdx
+++ /dev/null
@@ -1,44 +0,0 @@
-# XML
-
-Languine understøtter lokalisering af XML-filer, der er velegnede til forskellige XML-baserede konfigurations- og indholdsfiler. Dette format håndterer komplekse XML-strukturer, mens det bevarer formatering og attributter.
-
----
-
-## Opsætning
-
-Først skal du sikre dig, at du har en languine.config.json eller languine.config.ts konfigurationsfil i rodmappen af dit projekt. Her er et eksempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "xml": {
-      "include": ["resources/[locale]/*.xml"]
-    }
-  }
-}
-```
-
-## Oversættelse
-
-Når din konfiguration er sat op, skal du køre:
-
-```bash
-npx languine@latest translate
-```
-
-Når du kører denne kommando, vil Languine:
-
-- Indlæse dine kilde-XML-filer (f.eks. resources/en/*.xml)
-- Registrere eventuelt nyt eller ændret indhold
-- Generere oversættelser til dine målsprog
-- Oprette eller opdatere målsprogfilene (f.eks. resources/sv/*.xml)
-- Bevare XML-struktur og formatering
-- Håndtere attributoversættelser
-- Opretholde CDATA-sektioner
-- Bevare XML-kommentarer
-- Understøtte XML-navnerum
-- Validere XML-struktur
diff --git a/apps/web/src/markdown/docs/da/yaml.mdx b/apps/web/src/markdown/docs/da/yaml.mdx
deleted file mode 100644
index c47b5ab7..00000000
--- a/apps/web/src/markdown/docs/da/yaml.mdx
+++ /dev/null
@@ -1,39 +0,0 @@
-# YAML
-
-Languine understøtter YAML-filer som kildeformat, som ofte bruges i Ruby on Rails, Laravel og andre rammer. Dette format understøtter indlejrede strukturer, arrays og komplekse datatyper.
-
----
-
-## Opsætning
-
-Først skal du sikre dig, at du har en languine.config.json eller languine.config.ts konfigurationsfil i rodmappen af dit projekt. Her er et eksempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "yaml": {
-      "include": ["config/locales/[locale].yml"]
-    }
-  }
-}
-```
-
-## Oversættelse
-
-Når din konfiguration er sat op, skal du køre:
-
-```bash
-npx languine@latest translate
-```
-
-Når du kører denne kommando, vil Languine:
-
-- Indlæse din kilde YAML-fil (f.eks. config/locales/en.yml)
-- Registrere eventuelle nye eller ændrede oversættelsesstrenge
-- Generere oversættelser til dine målsprog
-- Oprette eller opdatere målsprog YAML-filerne (f.eks. config/locales/sv.yml)
-- Bevare indlejrede strukturer og formatering
diff --git a/apps/web/src/markdown/docs/de/android.mdx b/apps/web/src/markdown/docs/de/android.mdx
deleted file mode 100644
index 695a33b6..00000000
--- a/apps/web/src/markdown/docs/de/android.mdx
+++ /dev/null
@@ -1,39 +0,0 @@
-# Android
-
-Languine unterstützt Android-String-Ressourcen (strings.xml) als Quellformat und verarbeitet Pluralformen, String-Arrays und formatierte Strings. Dieses Format ist der Standardweg, um Übersetzungen in Android-Anwendungen zu verwalten.
-
----
-
-## Einrichtung
-
-Zuerst stellen Sie sicher, dass Sie eine languine.json-Konfigurationsdatei im Stammverzeichnis Ihres Projekts haben. Hier ist ein Beispiel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "android": {
-      "include": ["app/src/main/res/values-[locale]/strings.xml"]
-    }
-  }
-}
-```
-
-## Übersetzen
-
-Mit Ihrer Konfiguration führen Sie aus:
-
-```bash
-npx languine@latest translate
-```
-
-Wenn Sie diesen Befehl ausführen, wird Languine:
-
-- Ihre Quell-strings.xml-Datei laden (z. B. values/strings.xml)
-- Neue oder geänderte Übersetzungsstrings erkennen
-- Übersetzungen für Ihre Zielsprache generieren
-- Die XML-Dateien der Zielsprache erstellen oder aktualisieren (z. B. values-sv/strings.xml, values-de/strings.xml, values-fr/strings.xml)
-- Alle vorhandenen String-Arrays und Pluralformatierungen beibehalten
diff --git a/apps/web/src/markdown/docs/de/arb.mdx b/apps/web/src/markdown/docs/de/arb.mdx
deleted file mode 100644
index c15c4fe6..00000000
--- a/apps/web/src/markdown/docs/de/arb.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# ARB (Anwendungsressourcenbündel)
-
-Languine unterstützt ARB-Dateien, das standardisierte Lokalisierungsformat für Flutter-Anwendungen. Dieses Format verarbeitet Pluralformen, Platzhalter und Auswahl-Ausdrücke und bleibt dabei mit Flutter's intl-Paket kompatibel.
-
----
-
-## Einrichtung
-
-Zuerst stellen Sie sicher, dass Sie eine languine.json-Konfigurationsdatei im Stammverzeichnis Ihres Projekts haben. Hier ist ein Beispiel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "arb": {
-      "include": ["lib/l10n/intl_[locale].arb"]
-    }
-  }
-}
-```
-
-## Übersetzung
-
-Mit Ihrer Konfiguration führen Sie aus:
-
-```bash
-npx languine@latest translate
-```
-
-Wenn Sie diesen Befehl ausführen, wird Languine:
-
-- Ihre Quell-ARB-Datei laden (z. B. lib/l10n/intl_en.arb)
-- Neue oder geänderte Übersetzungsstrings erkennen
-- Übersetzungen für Ihre Zielsprache generieren
-- Die ARB-Dateien der Zielsprache erstellen oder aktualisieren (z. B. lib/l10n/intl_sv.arb)
-- Metadaten, Platzhalter und Plural-/Auswahl-Ausdrücke beibehalten
-
diff --git a/apps/web/src/markdown/docs/de/authentication.mdx b/apps/web/src/markdown/docs/de/authentication.mdx
deleted file mode 100644
index 702cb11b..00000000
--- a/apps/web/src/markdown/docs/de/authentication.mdx
+++ /dev/null
@@ -1,48 +0,0 @@
-# Authentifizierung
-
-Um Languine zu nutzen, müssen Sie sich bei unserer Engine authentifizieren. Es dauert nur wenige Sekunden, um zu beginnen.
-
----
-
-## Anmelden
-
-Sie können sich direkt auf dem [Languine Dashboard](https://languine.ai/login) anmelden oder den folgenden Befehl ausführen:
-
-```bash title="Terminal"
-npx languine@latest auth login
-```
-
-
-Wenn Sie bereits ein Konto haben, werden Sie automatisch angemeldet und eine Sitzung wird auf Ihrem Gerät gespeichert.
-
----
-
-## Abmelden
-
-Sie können sich abmelden, indem Sie den folgenden Befehl ausführen:
-
-```bash title="Terminal"
-npx languine@latest auth logout
-```
-
----
-
-## Benutzersitzung
-
-Sie können überprüfen, ob Sie angemeldet sind, indem Sie den folgenden Befehl ausführen:
-
-```bash title="Terminal"
-npx languine@latest auth whoami
-```
-
----
-
-
-# Umgebungsvariablen
-
-Sie können die folgenden Umgebungsvariablen festlegen, um Languine zu konfigurieren:
-
-- `LANGUINE_API_KEY`: Der API-Schlüssel, der für die Authentifizierung verwendet wird.
-- `LANGUINE_PROJECT_ID`: Die Projekt-ID, die für das Projekt verwendet wird.
-
-Sie finden sie im [Languine Dashboard](https://languine.ai/login).
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/de/biome.mdx b/apps/web/src/markdown/docs/de/biome.mdx
deleted file mode 100644
index 381c10a4..00000000
--- a/apps/web/src/markdown/docs/de/biome.mdx
+++ /dev/null
@@ -1,24 +0,0 @@
-# Biome
-
-Languine kann zusammen mit [Biome](https://biomejs.dev/) arbeiten, um sicherzustellen, dass Ihre Übersetzungsdateien konsistent formatiert sind. Dies ist besonders nützlich, wenn Sie mit JSON-Übersetzungsdateien arbeiten, die einen einheitlichen Stil in Ihrem Projekt beibehalten müssen.
-
-## Verwendung mit Languine
-
-Die empfohlene Methode, Biome mit Languine zu verwenden, besteht darin, Ihre Übersetzungsdateien nach ihrer Erstellung zu formatieren. Sie können dies in Ihrer `package.json` einrichten:
-
-```json title="package.json"
-{
-  "scripts": {
-    "translate": "languine translate",
-    "format": "biome format \"locales/**/*.json\"",
-    "translate:format": "npm run translate && npm run format"
-  }
-}
-```
-
-Jetzt können Sie:
-- `npm run translate` ausführen, um nur Übersetzungen zu generieren
-- `npm run format` ausführen, um nur bestehende Übersetzungsdateien zu formatieren
-- `npm run translate:format` ausführen, um Übersetzungen zu generieren und sie in der Reihenfolge zu formatieren
-
-Diese Konfiguration stellt sicher, dass Ihre Übersetzungsdateien konsistent mit einer Einrückung von 2 Leerzeichen und einer maximalen Zeilenbreite von 80 Zeichen formatiert sind.
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/de/ci.mdx b/apps/web/src/markdown/docs/de/ci.mdx
deleted file mode 100644
index fd683136..00000000
--- a/apps/web/src/markdown/docs/de/ci.mdx
+++ /dev/null
@@ -1,97 +0,0 @@
-# CI/CD
-
-Languine bietet eine CI/CD-Integration, um Ihnen bei der Übersetzung Ihrer Anwendung zu helfen.
-
----
-
-## So funktioniert es
-
-Der CI/CD-Workflow in Languine folgt einem strukturierten Prozess, um Übersetzungsaktualisierungen in Ihrer Anwendung zu automatisieren:
-
-### 1. Aktionsinitialisierung
-- Der Workflow beginnt, wenn die Aktion ausgelöst wird
-- Richtet die erforderliche Git-Konfiguration und Anmeldeinformationen ein
-
-### 2. Verarbeitung durch die Languine-Engine
-- Die Languine-Engine verarbeitet den Inhalt Ihrer Anwendung
-- Bearbeitet die Übersetzungsaufgaben mit den konfigurierten Einstellungen
-
-### 3. Änderungsdetektion
-Das System überprüft, ob es Änderungen bei den Übersetzungen gibt, und folgt einem von zwei Wegen:
-
-**Wenn Änderungen gefunden werden:**
-- Änderungen werden im Repository festgeschrieben
-- Änderungen werden in den angegebenen Branch gepusht
-- Ein Pull Request (PR) wird erstellt
-
-**Wenn keine Änderungen gefunden werden:**
-- Der Workflow wird abgeschlossen, ohne einen PR zu erstellen
-
-### 4. Erstellung des Pull Requests
-Wenn Änderungen erkannt werden, wird ein Pull Request mit:
-
-**PR-Inhalt:**
-- Klare Überschrift, die die Übersetzungsaktualisierungen angibt
-- Detaillierte Beschreibung der Änderungen
-- Bestätigungen der Qualitätsprüfung
-- Anweisungen zur Überprüfung
-- Links zu Dokumentation und Unterstützung
-
-**PR-Beschreibung enthält:**
-- Zusammenfassung der Übersetzungsaktualisierungen
-- Liste der Änderungen (aktualisierte Übersetzungen, Konsistenz der Terminologie)
-- Nächste Schritte für die Prüfer
-- Links zu Dokumentations- und Unterstützungsressourcen
-
----
-
-## Workflow-Diagramm
-
-<div className="flex flex-col items-center justify-center p-4 h-[400px] sm:h-[500px] md:h-[650px]">
-  <pre
-    className="p-4 text-sm leading-5 mb-4 scale-[0.5] sm:scale-[0.65] md:scale-90 transform-gpu"
-    style={{
-      fontFamily: "monospace",
-      whiteSpace: "pre",
-      textAlign: "left",
-    }}
-  >
-    {`
-                    ┌─────────────────────┐
-                    │   Aktion startet     │
-                    └──────────┬──────────┘
-                               │
-                    ┌──────────▼──────────┐
-                    │    Git &            │
-                    │    Anmeldeinformationen │
-                    └──────────┬──────────┘
-                               │
-┌─────────────────────────────────────────────────────────┐
-│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-│░░░░░░░░░░░░░░░░░░░░ Languine-Engine ░░░░░░░░░░░░░░░░░░░░│
-│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-└─────────────────────────────────────────────────────────┘
-                               │
-                    ┌──────────▼──────────┐
-                    │   Änderungen prüfen  │───────┐
-                    └──────────┬──────────┘       │
-                               │                  │
-                               │ [Änderungen]     │ [Keine Änderungen]
-                               │                  │
-                    ┌──────────▼──────────┐       │
-                    │   Festschreiben &    │       │
-                    │   Pushen            │       │
-                    └──────────┬──────────┘       │
-                               │                  │
-                    ┌──────────▼──────────┐       │
-                    │    PR erstellen      │       │
-                    └──────────┬──────────┘       │
-                               │                  │
-                    ┌──────────▼──────────┐       │
-                    │        Fertig        │◄──────┘
-                    └─────────────────────┘
-`}
-  </pre>
-</div>
-
-Der Workflow ist so konzipiert, dass er automatisiert wird, während er dennoch eine menschliche Überprüfung und Qualitätskontrolle vor dem Zusammenführen von Änderungen in Ihren Code ermöglicht. Er hält die besten Praktiken der Versionskontrolle ein und stellt sicher, dass Übersetzungen ordnungsgemäß verfolgt und durch die Git-Historie dokumentiert werden.
diff --git a/apps/web/src/markdown/docs/de/cli.mdx b/apps/web/src/markdown/docs/de/cli.mdx
deleted file mode 100644
index 05a799f0..00000000
--- a/apps/web/src/markdown/docs/de/cli.mdx
+++ /dev/null
@@ -1,65 +0,0 @@
-# CLI
-
-Languine bietet eine CLI, um Ihnen bei der Übersetzung Ihrer Anwendung zu helfen.
-
----
-
-## Befehlsübersicht
-
-### Übersetzen
-
-Der Befehl `translate` wird verwendet, um Ihre Anwendung zu übersetzen.
-
-```bash title="Terminal"
-    npx languine@latest translate
-```
-
----
-
-### Initialisieren
-
-Der Befehl `init` wird verwendet, um ein neues Languine-Projekt zu initialisieren.
-
-```bash title="Terminal"
-    npx languine@latest init
-```
-
----
-
-### Authentifizieren
-
-Der Befehl `auth` wird verwendet, um sich bei Languine zu authentifizieren.
-
-```bash title="Terminal"
-    npx languine@latest auth
-```
-
----
-
-### Synchronisieren
-
-Der Befehl `sync` wird verwendet, um Ihre Anwendung mit Languine zu synchronisieren.
-
-```bash title="Terminal"
-    npx languine@latest sync
-```
-
----
-
-### Locale Hinzufügen
-
-Der Befehl `locale` wird verwendet, um die Locales Ihrer Anwendung zu verwalten.
-
-```bash title="Terminal"
-    npx languine@latest locale add pt,fr
-```
-
----
-
-### Locale Entfernen
-
-Der Befehl `locale remove` wird verwendet, um ein Locale aus Ihrer Anwendung zu entfernen.
-
-```bash title="Terminal"
-    npx languine@latest locale remove pt,fr
-```
diff --git a/apps/web/src/markdown/docs/de/configuration.mdx b/apps/web/src/markdown/docs/de/configuration.mdx
deleted file mode 100644
index abf4f313..00000000
--- a/apps/web/src/markdown/docs/de/configuration.mdx
+++ /dev/null
@@ -1,180 +0,0 @@
-# Konfiguration
-
-Languine verwendet eine JSON-Konfigurationsdatei (languine.json), um Ihre Übersetzungseinstellungen zu verwalten. Diese Datei definiert Ihre Quell- und Zielsprache sowie die Dateien, die übersetzt werden müssen.
-
----
-
-## Grundkonfiguration
-
-Hier ist ein einfaches Beispiel in beiden Formaten:
-
-```json title="languine.json"
-{
-  "locale": {
-    "source": "en",
-    "targets": ["es", "fr", "de"]
-  },
-  "files": {
-    "json": {
-      "include": ["locales/[locale].json"]
-    }
-  }
-}
-```
-
-Lassen Sie uns die verschiedenen Abschnitte in der Konfigurationsdatei aufschlüsseln.
-
----
-
-## Locale-Konfiguration
-
-Der Locale-Abschnitt definiert Ihre Übersetzungssprachen:
-
-- source: Ihre Hauptsprache für die Inhaltserstellung (z. B. "en" für Englisch)
-- targets: Ein Array von Sprachen, in die Sie übersetzen möchten (z. B. ["es", "fr", "de"] für Spanisch, Französisch und Deutsch)
-
-Languine unterstützt eine Vielzahl von Sprachcodes, einschließlich:
-- Einfache Codes: en, es, fr, de
-- Regionsspezifische Codes: pt-BR, zh-CN, zh-TW
-
-## Dateikonfiguration
-
-Der Abschnitt Dateien definiert, welche Dateien Languine übersetzen soll. Sie können mehrere Dateitypen und Muster konfigurieren:
-
----
-
-### JSON-Dateien
-```json
-files: {
-  json: {
-    include: ["locales/[locale].json"],
-  },
-}
-```
-
----
-
-### Markdown/MDX-Dateien
-```json
-files: {
-  md: {
-    include: ["docs/[locale]/*.md"],
-  },
-  mdx: {
-    include: ["blog/[locale]/*.mdx"],
-  },
-}
-```
-
----
-
-### Mobile Plattformdateien
-
-Für iOS (Xcode):
-```json
-files: {
-  "xcode-xcstrings": {
-    include: ["Example/Localizable.xcstrings"],
-  },
-  // Oder für traditionelle .strings-Dateien
-  "xcode-strings": {
-    include: ["Example/[locale].lproj/Localizable.strings"],
-  },
-}
-```
-
----
-
-Für Android:
-```json
-files: {
-  android: {
-    include: ["locales/[locale].xml"],
-  },
-}
-```
-
----
-
-### Andere Formate
-
-Hier ist eine vollständige Liste der von Languine unterstützten Dateiformate:
-
-- [JSON](/docs/json) - Standard-JSON-Übersetzungsdateien
-- [YAML](/docs/yaml) - YAML-Übersetzungsdateien
-- [Properties](/docs/properties) - Java-Properties-Dateien
-- [Android](/docs/android) - Android-XML-Ressourcendateien
-- [iOS](/docs/ios) - iOS-Lokalisierungsdateien
-- [iOS Stringsdict](/docs/xcode-stringsdict) - iOS-Pluralisierungsdateien
-- [iOS XCStrings](/docs/xcode-xcstrings) - Moderne Xcode-String-Kataloge
-- [Markdown](/docs/md) - Dokumentationsdateien
-- [MDX](/docs/mdx) - Dokumentation mit JSX
-- [HTML](/docs/html) - HTML-Dateien
-- [JavaScript](/docs/js) - JavaScript-Dateien
-- [TypeScript](/docs/ts) - TypeScript-Dateien
-- [Gettext PO](/docs/po) - GetText-Übersetzungsdateien
-- [XLIFF](/docs/xliff) - XML-Lokalisierungs-Austauschformat
-- [CSV](/docs/csv) - Tabellenkalkulationsbasierte Übersetzungen
-- [XML](/docs/xml) - XML-Ressourcendateien
-- [Flutter ARB](/docs/arb) - Anwendungsressourcensammlungsdateien
-
----
-
-## Dateimuster
-
-Der Platzhalter [locale] in Dateimustern wird während der Übersetzung automatisch durch den entsprechenden Sprachcode ersetzt. Zum Beispiel:
-
-- locales/[locale].json wird zu:
-  - locales/en.json
-  - locales/es.json
-  - locales/fr.json
-
-Sie können mehrere Muster für jeden Dateityp einfügen und Glob-Muster verwenden:
-```json
-files: {
-  json: {
-    include: [
-      "src/locales/[locale].json",
-      "src/components/[locale]/*.json"
-    ],
-  },
-}
-```
-
----
-
-## Projekt-ID (Optional)
-
-Wenn Sie die Cloud-Dienste von Languine nutzen, können Sie Ihre Projekt-ID in die Konfiguration einfügen:
-
-```json
-{
-  "projectId": "prj_your_project_id",
-  "locale": {
-    // ... locale config
-  },
-  files: {
-    // ... files config
-  },
-}
-```
-
----
-
-## Verfolgung des Übersetzungsstatus
-
-Languine erstellt und verwaltet automatisch eine languine.lock-Datei, um den Status Ihrer Übersetzungen zu verfolgen. Diese Datei:
-
-- Verfolgt, welcher Inhalt übersetzt wurde
-- Hilft zu identifizieren, was aktualisiert werden muss, wenn sich der Quellinhalt ändert
-- Sollte in Ihr Versionskontrollsystem eingecheckt werden
-
-Sie müssen die Lock-Datei nicht manuell bearbeiten - Languine verwaltet sie automatisch, wenn Sie Übersetzungsbefehle ausführen.
-
-## Beste Praktiken
-
-1. **Versionskontrolle**: Immer sowohl languine.json als auch languine.lock in Ihr Repository einpflegen
-2. **Dateiorganisation**: Halten Sie Ihre Übersetzungsdateien in einer konsistenten Verzeichnisstruktur organisiert
-3. **Sprachcodes**: Verwenden Sie standardisierte Sprachcodes, um die Kompatibilität sicherzustellen
-4. **Muster**: Verwenden Sie spezifische Einschlussmuster, um zu vermeiden, dass unnötige Dateien übersetzt werden
-5. **Projekt-ID**: Halten Sie Ihre Projekt-ID sicher und teilen Sie sie nicht öffentlich, wenn Sie Cloud-Dienste nutzen, verwenden Sie stattdessen die Umgebungsvariable `LANGUINE_PROJECT_ID`.
diff --git a/apps/web/src/markdown/docs/de/csv.mdx b/apps/web/src/markdown/docs/de/csv.mdx
deleted file mode 100644
index f77df922..00000000
--- a/apps/web/src/markdown/docs/de/csv.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# CSV
-
-Languine unterstützt CSV (Comma-Separated Values) Dateien für eine einfache Übersetzungsverwaltung. Dieses Format ist ideal für arbeitsblattbasierte Workflows und die einfache Integration mit externen Übersetzungstools.
-
----
-
-## Einrichtung
-
-Zuerst stellen Sie sicher, dass Sie eine languine.json Konfigurationsdatei im Stammverzeichnis Ihres Projekts haben. Hier ist ein Beispiel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "csv": {
-      "include": ["translations/[locale].csv"]
-    }
-  }
-}
-```
-
-## Übersetzung
-
-Mit Ihrer Konfiguration ausgeführt, führen Sie aus:
-
-```bash
-npx languine@latest translate
-```
-
-Wenn Sie diesen Befehl ausführen, wird Languine:
-
-- Ihre Quell-CSV-Datei laden (z.B. translations/en.csv)
-- Neue oder geänderte Übersetzungsstrings erkennen
-- Übersetzungen für Ihre Zielsprache generieren
-- Die CSV-Dateien der Zielsprache erstellen oder aktualisieren (z.B. translations/sv.csv)
-- Die Spaltenstruktur und das Format beibehalten
-- Alle zusätzlichen Metadaten-Spalten bewahren
diff --git a/apps/web/src/markdown/docs/de/expo.mdx b/apps/web/src/markdown/docs/de/expo.mdx
deleted file mode 100644
index b40a7756..00000000
--- a/apps/web/src/markdown/docs/de/expo.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# Expo
-
-Languine unterstützt die Lokalisierung für Expo und integriert sich nahtlos in das i18n-System von Expo. Dieses Format funktioniert sowohl mit JavaScript- als auch mit TypeScript-Projekten und unterstützt verschachtelte Strukturen sowie Pluralisierung.
-
----
-
-## Einrichtung
-
-Zuerst stellen Sie sicher, dass Sie eine languine.json-Konfigurationsdatei im Stammverzeichnis Ihres Projekts haben. Hier ist ein Beispiel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "expo": {
-      "include": ["assets/locales/[locale].json"]
-    }
-  }
-}
-```
-
-## Übersetzung
-
-Mit Ihrer Konfiguration führen Sie aus:
-
-```bash
-npx languine@latest translate
-```
-
-Wenn Sie diesen Befehl ausführen, wird Languine:
-
-- Ihre Quelldatei für die Übersetzung laden (z. B. assets/locales/en.json)
-- Neue oder geänderte Übersetzungsstrings erkennen
-- Übersetzungen für Ihre Zielsprache generieren
-- Die Dateien für die Zielsprache erstellen oder aktualisieren (z. B. assets/locales/sv.json)
-- Die verschachtelte Struktur und die Pluralisierungsregeln beibehalten
-- Die Kompatibilität mit expo-localization wahren
diff --git a/apps/web/src/markdown/docs/de/github-actions.mdx b/apps/web/src/markdown/docs/de/github-actions.mdx
deleted file mode 100644
index c246f335..00000000
--- a/apps/web/src/markdown/docs/de/github-actions.mdx
+++ /dev/null
@@ -1,147 +0,0 @@
-# GitHub Actions
-
-Mit der GitHub-Aktion können Sie Ihren Code ganz einfach übersetzen, indem Sie Ihren Code einfach in das Repository pushen. Die GitHub-Aktion übersetzt dann Ihre neuen Schlüssel, erstellt entweder einen Pull-Request oder committet Ihre Änderungen.
-Das spart Ihnen viel Zeit und Mühe und sorgt gleichzeitig für qualitativ hochwertige Übersetzungen.
-
----
-
-## So funktioniert es
-
-
-
-<div className="flex flex-col items-center justify-center p-4 mb-8 h-[400px] sm:h-[500px] md:h-[650px]">
-        <pre
-          className="p-4 text-sm leading-5 scale-[0.5] sm:scale-[0.65] md:scale-90 transform-gpu"
-          style={{
-            fontFamily: "monospace",
-            whiteSpace: "pre",
-            textAlign: "left",
-          }}
-        >
-          {`
-                                  ┌───────────────┐
-                                  │   Git Push    │
-                                  └───────────────┘
-                                          │
-                                          ▼
-             ┌─────────────────────────────────────────────────────────┐
-             │░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-             │░░░░░░░░░░░░░░░░░░░░ Languine Engine ░░░░░░░░░░░░░░░░░░░░│
-             │░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-             └─────────────────────────────────────────────────────────┘
-                                          │
-                                          ▼
-                                          │
-            ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┼ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─
-           │                              │                              │
-           ▼                              ▼                              ▼
- ╔═══════════════════╗          ╔═══════════════════╗          ╔═══════════════════╗
- ║                   ║          ║                   ║          ║                   ║
- ║      Englisch     ║          ║      Spanisch     ║          ║      Japanisch    ║
- ║    Übersetzung    ║          ║    Übersetzung    ║          ║     Übersetzung    ║
- ║                   ║          ║                   ║          ║                   ║
- ╚═══════════════════╝          ╚═══════════════════╝          ╚═══════════════════╝
-           │                              │                              │
-           └──────────────────────────────┼──────────────────────────────┘
-                                          ▼
-                                  ┌───────────────┐
-                                  │     Zusammenf. │
-                                  │ Pull Request  │
-                                  └───────────────┘
-                                          │
-                                          ▼
-                              ┌─────────────────────┐
-                              │      Abgeschlossen    │
-                              │      (Deploy)       │
-                              └─────────────────────┘
-`}
-        </pre>
-      </div>
-
----
-
-## Installation
-
-Um die Languine GitHub-Aktion in Ihrem Repository zu verwenden, müssen Sie:
-
-1. Ihre Repository-Geheimnisse mit Ihren Languine-Anmeldeinformationen einrichten
-2. Eine Workflow-Datei in Ihrem Repository erstellen
-
-### Einrichten der Repository-Geheimnisse
-
-Fügen Sie die folgenden Geheimnisse in den Repository-Einstellungen hinzu (Einstellungen > Geheimnisse und Variablen > Aktionen):
-
-- `LANGUINE_API_KEY`: Ihr Languine API-Schlüssel
-- `LANGUINE_PROJECT_ID`: Ihre Languine Projekt-ID
-
-Diese Werte finden Sie in Ihrem Languine-Dashboard unter Projekteinstellungen.
-
-
-
-### Umgebungsvariablen
-
-Die GitHub-Aktion verwendet die folgenden Umgebungsvariablen:
-- `LANGUINE_API_KEY` (Erforderlich): Ihr Languine API-Schlüssel zur Authentifizierung
-- `LANGUINE_PROJECT_ID` (Erforderlich): Ihre Languine Projekt-ID 
-- `GITHUB_TOKEN` (Erforderlich): Automatisch von GitHub bereitgestellt, wird zur Erstellung von PRs verwendet
-
-### Beispiel-Workflow
-
-Erstellen Sie eine neue Datei .github/workflows/languine.yml in Ihrem Repository mit folgendem Inhalt:
-
-```ts title=".github/workflows/release.yml"
-name: Website bereitstellen
-
-on:
-  push:
-    branches:
-      - '**'
-    paths:
-      - apps/web/**
-
-jobs:
-  translate:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-      pull-requests: write
-    steps:
-      - uses: actions/checkout@v4
-      
-      - name: Languine Aktion
-        uses: languine/languine-action@v1
-        env:
-           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          api-key: ${{ secrets.LANGUINE_API_KEY }}
-          project-id: ${{ secrets.LANGUINE_PROJECT_ID }}
-```
- 
- Dieser Workflow wird:
-- Bei Pushes in den Hauptbranch ausgeführt
-- Bei Pull-Requests in den Hauptbranch ausgeführt
-- Kann manuell über den Tab Aktionen ausgelöst werden
-- Ihren Code auschecken und den Languine-Übersetzungsprozess ausführen
-- Einen Pull-Request mit allen neuen Übersetzungen erstellen (konfigurierbar)
-
-#### Arbeitsverzeichnis-Option
-
-Die Option `working-directory` ermöglicht es Ihnen, anzugeben, wo sich Ihre Übersetzungsdateien befinden. Dies ist besonders nützlich in Monorepos, in denen sich Ihre Übersetzungen in einem bestimmten Paket oder Anwendungsverzeichnis befinden. Zum Beispiel:
-
-#### Pull-Request-Option (kommt bald)
-
-Die Option `create-pull-request` steuert, ob die Aktion einen Pull-Request mit den Änderungen erstellt oder diese direkt in den Branch committet:
-
-```typescript title=".github/workflows/languine.yml"
-with:
-  create-pull-request: true # einen Pull-Request mit den Änderungen erstellen
-```
-
-Wenn auf `true` gesetzt, wird die Aktion:
-- Einen neuen Branch mit den Änderungen erstellen
-- Einen Pull-Request zur Überprüfung erstellen
-- Angemessene Labels und Beschreibungen hinzufügen
-
-Wenn auf `false` (Standard) gesetzt, wird die Aktion:
-- Die Änderungen direkt in den aktuellen Branch committen
-- Die Änderungen ohne Erstellung eines Pull-Requests pushen
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/de/html.mdx b/apps/web/src/markdown/docs/de/html.mdx
deleted file mode 100644
index 00940ba7..00000000
--- a/apps/web/src/markdown/docs/de/html.mdx
+++ /dev/null
@@ -1,41 +0,0 @@
-# HTML
-
-Languine unterstützt die Lokalisierung von HTML-Dateien und verarbeitet sowohl Textinhalte als auch Attribute. Dieses Format ist ideal für statische Websites und HTML-Vorlagen und unterstützt die Erhaltung der HTML-Struktur und -Formatierung.
-
----
-
-## Einrichtung
-
-Stellen Sie zunächst sicher, dass Sie eine languine.json-Konfigurationsdatei im Stammverzeichnis Ihres Projekts haben. Hier ist ein Beispiel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "html": {
-      "include": ["pages/[locale]/*.html"]
-    }
-  }
-}
-```
-
-## Übersetzung
-
-Mit Ihrer Konfiguration führen Sie aus:
-
-```bash
-npx languine@latest translate
-```
-
-Wenn Sie diesen Befehl ausführen, wird Languine:
-
-- Ihre Quell-HTML-Dateien laden (z. B. pages/en/*.html)
-- Neue oder geänderte Übersetzungsstrings erkennen
-- Übersetzungen für Ihre Zielsprache generieren
-- Die HTML-Dateien der Zielsprache erstellen oder aktualisieren (z. B. pages/sv/*.html)
-- Die HTML-Struktur und -Formatierung beibehalten
-- Angegebene Attributübersetzungen verarbeiten
-- Kommentare und spezielle Tags beibehalten
diff --git a/apps/web/src/markdown/docs/de/introduction.mdx b/apps/web/src/markdown/docs/de/introduction.mdx
deleted file mode 100644
index 0757f22e..00000000
--- a/apps/web/src/markdown/docs/de/introduction.mdx
+++ /dev/null
@@ -1,34 +0,0 @@
-# Einführung
-
-Languine automatisiert die Lokalisierung innerhalb Ihres Entwicklungs-Workflows und Ihrer Pipeline, sodass Übersetzungen Sie niemals aufhalten.
-
-Verwandeln Sie Ihre Anwendung in wenigen Minuten in ein mehrsprachiges Erlebnis. Während Sie sich auf den Aufbau von Funktionen konzentrieren, kümmert sich Languine mit Präzision und Zuverlässigkeit um alle Aspekte der Übersetzung.
-
----
-
-## Hauptmerkmale
-
-- **Übersetzungs-Engine**: Nutzen Sie kontextbewusste, qualitativ hochwertige Übersetzungen, die Ihre Markenstimme beibehalten
-- **CI/CD-Integration**: Automatisieren Sie Übersetzungsupdates über Ihre bestehenden Workflows
-- **Formate**: Verarbeiten Sie jedes Dateiformat mit unserem erweiterbaren Parser-System
-- **Open Source**: Greifen Sie auf unseren Code auf GitHub zu, inspizieren Sie ihn und tragen Sie dazu bei - keine Black Boxes, vollständige Transparenz
-
----
-
-## So funktioniert es
-
-1. **Schnelle Einrichtung**: Starten Sie in wenigen Minuten mit unserer intuitiven CLI und geführten Initialisierung
-2. **Einfache Konfiguration**: Definieren Sie Ihre Übersetzungsbedürfnisse mit einer klaren, unkomplizierten Konfigurationsdatei
-3. **Automatisierte Übersetzung**: Übertragen Sie Ihren Inhalt einmal und lassen Sie Languine automatisch die Übersetzung in alle Zielsprache übernehmen
-
----
-
-## Erste Schritte
-
-Beginnen Sie Ihre Lokalisierungsreise mit unserem [Schnellstart](/docs/quickstart) - Sie werden Ihre ersten Übersetzungen in wenigen Minuten am Laufen haben.
-
-Erforschen Sie unsere umfassende Dokumentation, um die Fähigkeiten von Languine zu meistern:
-
-- [Konfiguration](/docs/configuration) - Konfigurieren Sie Languine nach den Bedürfnissen Ihres Projekts
-- [CLI](/docs/cli) - Meistern Sie unsere leistungsstarke Befehlszeilenschnittstelle
-- [Github Actions](/docs/github-actions) - Automatisieren Sie Übersetzungen mit unserer Github-Aktion
diff --git a/apps/web/src/markdown/docs/de/ios.mdx b/apps/web/src/markdown/docs/de/ios.mdx
deleted file mode 100644
index 6b44e215..00000000
--- a/apps/web/src/markdown/docs/de/ios.mdx
+++ /dev/null
@@ -1,39 +0,0 @@
-# iOS
-
-Languine unterstützt iOS Localizable.strings-Dateien, das standardmäßige Lokalisierungsformat für iOS-Anwendungen. Dieses Format verarbeitet grundlegende Schlüssel-Wert-String-Paare und unterstützt Kommentare, um den Übersetzern Kontext zu bieten.
-
----
-
-## Einrichtung
-
-Zuerst stellen Sie sicher, dass Sie eine languine.json-Konfigurationsdatei im Stammverzeichnis Ihres Projekts haben. Hier ist ein Beispiel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "ios": {
-      "include": ["[locale].lproj/Localizable.strings"]
-    }
-  }
-}
-```
-
-## Übersetzung
-
-Mit Ihrer Konfiguration ausgeführt, führen Sie:
-
-```bash
-npx languine@latest translate
-```
-
-Wenn Sie diesen Befehl ausführen, wird Languine:
-
-- Ihre Quell-Localizable.strings-Datei laden (z. B. en.lproj/Localizable.strings)
-- Neue oder geänderte Übersetzungsstrings erkennen
-- Übersetzungen für Ihre Zielsprache generieren
-- Die Zielsprachendateien erstellen oder aktualisieren (z. B. sv.lproj/Localizable.strings)
-- Alle vorhandenen Kommentare und Formatierungen beibehalten
diff --git a/apps/web/src/markdown/docs/de/js.mdx b/apps/web/src/markdown/docs/de/js.mdx
deleted file mode 100644
index c999003b..00000000
--- a/apps/web/src/markdown/docs/de/js.mdx
+++ /dev/null
@@ -1,42 +0,0 @@
-# JavaScript
-
-Languine unterstützt JavaScript/TypeScript-Lokalisierungsdateien, die perfekt für moderne Webanwendungen geeignet sind. Dieses Format verarbeitet sowohl Objektliterale als auch Modul-Exporte und unterstützt verschachtelte Strukturen sowie dynamische Inhalte.
-
----
-
-## Einrichtung
-
-Stellen Sie zunächst sicher, dass Sie eine languine.json-Konfigurationsdatei im Stammverzeichnis Ihres Projekts haben. Hier ist ein Beispiel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "js": {
-      "include": ["src/locales/[locale].js"]
-    }
-  }
-}
-```
-
-## Übersetzen
-
-Mit Ihrer Konfiguration ausgeführt, führen Sie:
-
-```bash
-npx languine@latest translate
-```
-
-Wenn Sie diesen Befehl ausführen, wird Languine:
-
-- Ihre Quell-JavaScript-Dateien laden (z. B. src/locales/en.js)
-- Neue oder geänderte Übersetzungsstrings erkennen
-- Übersetzungen für Ihre Zielsprache generieren
-- Die Zielsprachendateien erstellen oder aktualisieren (z. B. src/locales/sv.js)
-- Die Modulstruktur und Exporte beibehalten
-- Verschachtelte Objekte und Arrays verarbeiten
-- Die Codeformatierung und Kommentare beibehalten
-- TypeScript-Typen generieren, wenn aktiviert
diff --git a/apps/web/src/markdown/docs/de/json.mdx b/apps/web/src/markdown/docs/de/json.mdx
deleted file mode 100644
index 6420a698..00000000
--- a/apps/web/src/markdown/docs/de/json.mdx
+++ /dev/null
@@ -1,41 +0,0 @@
-# JSON
-
-Languine unterstützt JSON-Dateien als Quellformat mit den gängigen Anforderungen für Pluralisierung und Interpolation. Dieses Format wird in vielen Frameworks wie React, Vue, Ruby on Rails und mehr verwendet.
-
-
----
-
-
-## Einrichtung
-
-Zuerst stellen Sie sicher, dass Sie eine languine.json-Konfigurationsdatei im Stammverzeichnis Ihres Projekts haben. Hier ist ein Beispiel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "json": {
-      "include": ["locales/[locale].json"]
-    }
-  }
-}
-
-```
-
-## Übersetzung
-
-Mit Ihrer Konfiguration führen Sie aus:
-
-```bash
-npx languine@latest translate
-```
-
-Wenn Sie diesen Befehl ausführen, wird Languine:
-
-- Ihre Quell-JSON-Datei laden (z. B. locales/en.json)
-- Neue oder geänderte Übersetzungsstrings erkennen
-- Übersetzungen für Ihre Zielsprache generieren
-- Die JSON-Dateien der Zielsprache erstellen oder aktualisieren (z. B. locales/sv.json, locales/de.json, locales/fr.json)
diff --git a/apps/web/src/markdown/docs/de/md.mdx b/apps/web/src/markdown/docs/de/md.mdx
deleted file mode 100644
index ab4ae0c5..00000000
--- a/apps/web/src/markdown/docs/de/md.mdx
+++ /dev/null
@@ -1,43 +0,0 @@
-# Markdown
-
-Languine unterstützt die Lokalisierung von Markdown-Dateien, ideal für Dokumentationen, Blogbeiträge und inhaltsreiche Websites. Dieses Format bewahrt die Markdown-Syntax während der Übersetzung des Inhalts, einschließlich Unterstützung für Front Matter.
-
----
-
-## Einrichtung
-
-Stellen Sie zunächst sicher, dass Sie eine languine.json-Konfigurationsdatei im Stammverzeichnis Ihres Projekts haben. Hier ist ein Beispiel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "md": {
-      "include": ["content/[locale]/**/*.md"]
-    }
-  }
-}
-```
-
-## Übersetzung
-
-Mit Ihrer Konfiguration führen Sie aus:
-
-```bash
-npx languine@latest translate
-```
-
-Wenn Sie diesen Befehl ausführen, wird Languine:
-
-- Ihre Quell-Markdown-Dateien laden (z. B. content/en/*.md)
-- Neue oder geänderte Inhalte erkennen
-- Übersetzungen für Ihre Zielsprache generieren
-- Die Zielsprachendateien erstellen oder aktualisieren (z. B. content/sv/*.md)
-- Die Markdown-Formatierung und -Struktur bewahren
-- Übersetzungen für Front Matter handhaben
-- Links und Referenzen beibehalten
-- Codeblöcke unverändert lassen
-- HTML innerhalb von Markdown bewahren
diff --git a/apps/web/src/markdown/docs/de/mdx.mdx b/apps/web/src/markdown/docs/de/mdx.mdx
deleted file mode 100644
index c1313cf3..00000000
--- a/apps/web/src/markdown/docs/de/mdx.mdx
+++ /dev/null
@@ -1,43 +0,0 @@
-# Markdown (MDX)
-
-Languine unterstützt die Lokalisierung von Markdown (MDX)-Dateien, ideal für Dokumentationen, Blogbeiträge und inhaltsreiche Websites. Dieses Format bewahrt die Markdown-Syntax während der Übersetzung des Inhalts, einschließlich Unterstützung für Front Matter.
-
----
-
-## Einrichtung
-
-Zuerst stellen Sie sicher, dass Sie eine languine.json-Konfigurationsdatei im Stammverzeichnis Ihres Projekts haben. Hier ist ein Beispiel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "mdx": {
-      "include": ["content/[locale]/**/*.mdx"]
-    }
-  }
-}
-```
-
-## Übersetzung
-
-Mit Ihrer Konfiguration ausgeführt, führen Sie aus:
-
-```bash
-npx languine@latest translate
-```
-
-Wenn Sie diesen Befehl ausführen, wird Languine:
-
-- Ihre Quell-Markdown-Dateien laden (z. B. content/en/*.mdx)
-- Neue oder geänderte Inhalte erkennen
-- Übersetzungen für Ihre Zielsprache generieren
-- Die Zielsprache-Dateien erstellen oder aktualisieren (z. B. content/sv/*.mdx)
-- Die Markdown-Formatierung und -Struktur bewahren
-- Übersetzungen für Front Matter handhaben
-- Links und Referenzen beibehalten
-- Codeblöcke unverändert lassen
-- HTML innerhalb von Markdown bewahren
diff --git a/apps/web/src/markdown/docs/de/overrides.mdx b/apps/web/src/markdown/docs/de/overrides.mdx
deleted file mode 100644
index 8d9036d4..00000000
--- a/apps/web/src/markdown/docs/de/overrides.mdx
+++ /dev/null
@@ -1,7 +0,0 @@
-# Überschreibungen
-
-Languine ermöglicht es Ihnen, Übersetzungen für bestimmte Schlüssel zu überschreiben. Dies ist nützlich, wenn Sie sicherstellen möchten, dass eine bestimmte Übersetzung für einen bestimmten Schlüssel verwendet wird, unabhängig von der Standardübersetzung.
-
-## So funktioniert es
-
-Im Dashboard können Sie Überschreibungen für bestimmte Schlüssel erstellen. Sie können auch Überschreibungen für bestimmte Sprachen erstellen.
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/de/po.mdx b/apps/web/src/markdown/docs/de/po.mdx
deleted file mode 100644
index 2ba233f0..00000000
--- a/apps/web/src/markdown/docs/de/po.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# PO (Gettext)
-
-Languine unterstützt PO-Dateien, das weit verbreitete Gettext-Lokalisierungsformat. Dieses Format ist in vielen Programmierumgebungen beliebt, insbesondere in Linux-Anwendungen und PHP-Frameworks, und bietet Unterstützung für Kontexte, Pluralformen und Übersetzerkommentare.
-
----
-
-## Einrichtung
-
-Zuerst stellen Sie sicher, dass Sie eine languine.json-Konfigurationsdatei im Stammverzeichnis Ihres Projekts haben. Hier ist ein Beispiel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "po": {
-      "include": ["locales/[locale]/LC_MESSAGES/messages.po"]
-    }
-  }
-}
-```
-
-## Übersetzen
-
-Mit Ihrer Konfiguration ausgeführt, führen Sie:
-
-```bash
-npx languine@latest translate
-```
-
-Wenn Sie diesen Befehl ausführen, wird Languine:
-
-- Ihre Quell-PO-Datei laden (z. B. locales/en/LC_MESSAGES/messages.po)
-- Neue oder geänderte Übersetzungsstrings erkennen
-- Übersetzungen für Ihre Zielsprache generieren
-- Die PO-Dateien der Zielsprache erstellen oder aktualisieren (z. B. locales/sv/LC_MESSAGES/messages.po)
-- Metadaten, Kontexte und Pluralformen beibehalten
-- Übersetzerkommentare und Referenzinformationen aufrechterhalten
diff --git a/apps/web/src/markdown/docs/de/prettier.mdx b/apps/web/src/markdown/docs/de/prettier.mdx
deleted file mode 100644
index b7719351..00000000
--- a/apps/web/src/markdown/docs/de/prettier.mdx
+++ /dev/null
@@ -1,22 +0,0 @@
-# Prettier
-
-Languine kann zusammen mit [Prettier](https://prettier.io/) verwendet werden, um sicherzustellen, dass Ihre Übersetzungsdateien einheitlich formatiert sind. Dies ist besonders nützlich, wenn Sie mit JSON-Übersetzungsdateien arbeiten, die einen konsistenten Stil in Ihrem Projekt beibehalten müssen.
-
-## Verwendung mit Languine
-
-Die empfohlene Methode, Prettier mit Languine zu verwenden, besteht darin, Ihre Übersetzungsdateien nach deren Erstellung zu formatieren. Sie können dies in Ihrer `package.json` einrichten:
-
-```json title="package.json"
-{
-  "scripts": {
-    "translate": "languine translate",
-    "format": "prettier --write \"locales/**/*.json\"",
-    "translate:format": "npm run translate && npm run format"
-  }
-}
-```
-
-Jetzt können Sie:
-- `npm run translate` ausführen, um nur Übersetzungen zu generieren
-- `npm run format` ausführen, um nur vorhandene Übersetzungsdateien zu formatieren
-- `npm run translate:format` ausführen, um Übersetzungen zu generieren und sie in der Reihenfolge zu formatieren
diff --git a/apps/web/src/markdown/docs/de/properties.mdx b/apps/web/src/markdown/docs/de/properties.mdx
deleted file mode 100644
index be8d7eb8..00000000
--- a/apps/web/src/markdown/docs/de/properties.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# Eigenschaften
-
-Languine unterstützt Java Properties-Dateien, das standardmäßige Lokalisierungsformat für Java-Anwendungen. Dieses Format verarbeitet Unicode-Escaping und unterstützt sowohl Schlüssel-Wert-Paare als auch Kommentare.
-
----
-
-## Einrichtung
-
-Zuerst stellen Sie sicher, dass Sie eine languine.json-Konfigurationsdatei im Stammverzeichnis Ihres Projekts haben. Hier ist ein Beispiel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "properties": {
-      "include": ["src/main/resources/messages_[locale].properties"]
-    }
-  }
-}
-```
-
-## Übersetzung
-
-Mit Ihrer Konfiguration führen Sie aus:
-
-```bash
-npx languine@latest translate
-```
-
-Wenn Sie diesen Befehl ausführen, wird Languine:
-
-- Ihre Quell-Properties-Datei laden (z. B. messages_en.properties)
-- Neue oder geänderte Übersetzungsstrings erkennen
-- Übersetzungen für Ihre Zielsprache generieren
-- Die Properties-Dateien der Zielsprache erstellen oder aktualisieren (z. B. messages_sv.properties)
-- Unicode-Escaping automatisch behandeln
-- Kommentare und Formatierung beibehalten
diff --git a/apps/web/src/markdown/docs/de/quickstart.mdx b/apps/web/src/markdown/docs/de/quickstart.mdx
deleted file mode 100644
index cf85f74d..00000000
--- a/apps/web/src/markdown/docs/de/quickstart.mdx
+++ /dev/null
@@ -1,65 +0,0 @@
-# Schnellstart
-
-Beginnen Sie mit der Installation von Languine.
-
-Führen Sie dann den folgenden Befehl aus, um Languine zu initialisieren.
-
-```bash title="Terminal"
-npx languine@latest init
-```
-
-Befolgen Sie die Schritte, um Ihr Projekt einzurichten.
-
----
-
-## Erste Übersetzung
-
-Jetzt sind Sie bereit, Ihren Code zu übersetzen.
-
-Beginnen Sie damit, einen Schlüssel zu Ihrer Quelldatei hinzuzufügen. Wenn Sie beispielsweise `en.json` als Ihre Quelldatei verwenden, fügen Sie einen Schlüssel hinzu.
-
-```json title="src/locales/en.json"
-{
-  "welcome": "Willkommen in unserer Anwendung!",
-  "user": {
-    "greeting": "Hallo, {{name}}!",
-    "profile": {
-      "title": "Ihr Profil",
-      "edit": "Profil bearbeiten"
-    }
-  },
-  "notifications": {
-    "messages": "Sie haben {{count}} neue Nachricht(en).",
-    "empty": "Keine neuen Benachrichtigungen."
-  }
-}
-
-```
-
----
-
-## Übersetzen
-
-Führen Sie den folgenden Befehl aus, um Ihren Inhalt zu übersetzen:
-
-```bash title="Terminal"
-npx languine@latest translate
-```
-
-## Dies wird:
-1. Übersetzungsdateien für jede Zielsprache erstellen
-2. Hochwertige Übersetzungen mit der Languine Engine generieren
-3. Eine `languine.lock`-Datei erstellen, um den Übersetzungsstatus zu verfolgen
-
-Die Sperrdatei hilft Languine, zu erkennen, welche Übersetzungen aktualisiert werden müssen, wenn sich Ihr Quellinhalt ändert. Stellen Sie sicher, dass Sie diese Datei in Ihr Repository einpflegen.
-
----
-
-## Nächste Schritte
-
-Jetzt, da Sie Languine eingerichtet haben, können Sie:
-- Weitere Sprachen in Ihrer `languine.json`-Datei hinzufügen
-- Languine in Ihre CI/CD-Pipeline integrieren
-- Unsere API für programmgesteuerte Übersetzungen nutzen
-
-Schauen Sie sich unsere anderen Anleitungen an, um mehr über die erweiterten Funktionen von Languine zu erfahren.
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/de/react-email.mdx b/apps/web/src/markdown/docs/de/react-email.mdx
deleted file mode 100644
index 9dcd7c19..00000000
--- a/apps/web/src/markdown/docs/de/react-email.mdx
+++ /dev/null
@@ -1,41 +0,0 @@
-# React Email
-
-Languine unterstützt React Email-Vorlagen und ermöglicht es Ihnen, Übersetzungen für Ihre mit React Email erstellten E-Mail-Vorlagen zu verwalten. Diese Integration verarbeitet sowohl Textinhalte als auch HTML-Attribute und bewahrt dabei die Struktur der React-Komponenten.
-
----
-
-## Einrichtung
-
-Stellen Sie zunächst sicher, dass Sie eine languine.json-Konfigurationsdatei im Stammverzeichnis Ihres Projekts haben. Hier ist ein Beispiel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "react-email": {
-      "include": ["emails/[locale]/*.tsx"]
-    }
-  }
-}
-```
-
-## Übersetzung
-
-Mit Ihrer Konfiguration führen Sie aus:
-
-```bash
-npx languine@latest translate
-```
-
-Wenn Sie diesen Befehl ausführen, wird Languine:
-
-- Ihre Quell-React-Email-Vorlagen laden (z. B. emails/en/*.tsx)
-- Neue oder geänderte Übersetzungsstrings erkennen
-- Übersetzungen für Ihre Zielsprache generieren
-- Die E-Mail-Vorlagen in der Zielsprache erstellen oder aktualisieren (z. B. emails/sv/*.tsx)
-- Die Struktur und Props der React-Komponenten beibehalten
-- HTML-Formatierung und -Styling aufrechterhalten
-- Interpolation und dynamische Inhalte verarbeiten
diff --git a/apps/web/src/markdown/docs/de/ts.mdx b/apps/web/src/markdown/docs/de/ts.mdx
deleted file mode 100644
index 5ec141d6..00000000
--- a/apps/web/src/markdown/docs/de/ts.mdx
+++ /dev/null
@@ -1,42 +0,0 @@
-# TypeScript
-
-Languine unterstützt TypeScript-Lokalisierungsdateien mit vollständiger Typensicherheit. Dieses Format erweitert die Unterstützung für JavaScript um zusätzliche, spezifische Funktionen für TypeScript und Typgenerierungsfähigkeiten.
-
----
-
-## Einrichtung
-
-Stellen Sie zunächst sicher, dass Sie eine languine.json-Konfigurationsdatei im Stammverzeichnis Ihres Projekts haben. Hier ist ein Beispiel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "ts": {
-      "include": ["src/locales/[locale].ts"]
-    }
-  }
-}
-```
-
-## Übersetzung
-
-Mit Ihrer Konfiguration führen Sie aus:
-
-```bash
-npx languine@latest translate
-```
-
-Wenn Sie diesen Befehl ausführen, wird Languine:
-
-- Ihre Quell-TypeScript-Dateien laden (z. B. src/locales/en.ts)
-- Alle neuen oder geänderten Übersetzungsstrings erkennen
-- Übersetzungen für Ihre Zielsprache generieren
-- Die Zielsprachendateien erstellen oder aktualisieren (z. B. src/locales/sv.ts)
-- Typannotationen und Schnittstellen beibehalten
-- Verschachtelte Objekte mit der richtigen Typisierung behandeln
-- Die Codeformatierung und Dokumentationskommentare beibehalten
-- Literale Typen und Unionstypen unterstützen
diff --git a/apps/web/src/markdown/docs/de/xcode-stringsdict.mdx b/apps/web/src/markdown/docs/de/xcode-stringsdict.mdx
deleted file mode 100644
index 489cd4d4..00000000
--- a/apps/web/src/markdown/docs/de/xcode-stringsdict.mdx
+++ /dev/null
@@ -1,44 +0,0 @@
-# Xcode Stringsdict
-
-Languine unterstützt das Stringsdict-Format von Xcode, das für komplexe Pluralisierungsregeln in iOS- und macOS-Anwendungen verwendet wird. Dieses Format behandelt Pluralformen, Variablenersetzungen und sprachspezifische Pluralregeln.
-
----
-
-## Einrichtung
-
-Stellen Sie zunächst sicher, dass Sie eine languine.json-Konfigurationsdatei im Stammverzeichnis Ihres Projekts haben. Hier ist ein Beispiel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "stringsdict": {
-      "include": ["MyApp/Localizable.stringsdict"]
-    }
-  }
-}
-```
-
-## Übersetzung
-
-Mit Ihrer Konfiguration führen Sie aus:
-
-```bash
-npx languine@latest translate
-```
-
-Wenn Sie diesen Befehl ausführen, wird Languine:
-
-- Ihre Stringsdict-Dateien laden
-- Neue oder geänderte Pluralregeln erkennen
-- Übersetzungen für Ihre Zielsprache generieren
-- Die Stringsdict-Dateien mit neuen Übersetzungen aktualisieren
-- Komplexe Pluralregeln für jede Sprache behandeln
-- Variablenersetzungen beibehalten
-- Die Struktur des Wörterbuchs bewahren
-- Sprachspezifische Pluralformen unterstützen
-- Die Konsistenz der Pluralregeln validieren
-- Formatierungsspezifizierer beibehalten
diff --git a/apps/web/src/markdown/docs/de/xcode-xcstrings.mdx b/apps/web/src/markdown/docs/de/xcode-xcstrings.mdx
deleted file mode 100644
index a561e65e..00000000
--- a/apps/web/src/markdown/docs/de/xcode-xcstrings.mdx
+++ /dev/null
@@ -1,44 +0,0 @@
-# Xcode Strings (XCStrings)
-
-Languine unterstützt das XCStrings-Format von Xcode, das moderne Lokalisierungsformat für iOS- und macOS-Anwendungen. Dieses Format verwaltet String-Kataloge mit Unterstützung für Variationen, Pluralisierung und Entwicklerkommentare.
-
----
-
-## Einrichtung
-
-Zuerst stellen Sie sicher, dass Sie eine languine.json-Konfigurationsdatei im Stammverzeichnis Ihres Projekts haben. Hier ist ein Beispiel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "xcstrings": {
-      "include": ["MyApp/Localizable.xcstrings"]
-    }
-  }
-}
-```
-
-## Übersetzen
-
-Mit Ihrer Konfiguration führen Sie aus:
-
-```bash
-npx languine@latest translate
-```
-
-Wenn Sie diesen Befehl ausführen, wird Languine:
-
-- Ihren XCStrings-Katalog laden
-- Alle neuen oder geänderten Strings erkennen
-- Übersetzungen für Ihre Zielsprache generieren
-- Den String-Katalog mit neuen Übersetzungen aktualisieren
-- String-Variationen und Pluralisierungsregeln beibehalten
-- Entwicklerkommentare und Kontext bewahren
-- Variablenersetzungen verarbeiten
-- Adaptive Strings unterstützen
-- Formatierungsspezifizierer beibehalten
-- Die Struktur des String-Katalogs validieren
diff --git a/apps/web/src/markdown/docs/de/xliff.mdx b/apps/web/src/markdown/docs/de/xliff.mdx
deleted file mode 100644
index b95fcd4c..00000000
--- a/apps/web/src/markdown/docs/de/xliff.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# XLIFF
-
-Languine unterstützt XLIFF (XML Localization Interchange File Format), ein XML-basiertes Format, das für den Austausch von Lokalisierungsdaten entwickelt wurde. Dieses Format wird häufig in professionellen Übersetzungsabläufen verwendet und unterstützt sowohl die Versionen XLIFF 1.2 als auch 2.0.
-
----
-
-## Einrichtung
-
-Stellen Sie zunächst sicher, dass Sie eine languine.json-Konfigurationsdatei im Stammverzeichnis Ihres Projekts haben. Hier ist ein Beispiel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "xliff": {
-      "include": ["locales/[locale].xlf"]
-    }
-  }
-}
-```
-
-## Übersetzen
-
-Nachdem Ihre Konfiguration festgelegt ist, führen Sie aus:
-
-```bash
-npx languine@latest translate
-```
-
-Wenn Sie diesen Befehl ausführen, wird Languine:
-
-- Ihre Quell-XLIFF-Datei laden (z. B. locales/en.xlf)
-- Neue oder geänderte Übersetzungseinheiten erkennen
-- Übersetzungen für Ihre Zielsprache generieren
-- Die XLIFF-Dateien der Zielsprache erstellen oder aktualisieren (z. B. locales/sv.xlf)
-- Notizen, Kontextinformationen und Statusattribute beibehalten
-- Die Kompatibilität mit CAT (Computer-Aided Translation)-Tools gewährleisten
diff --git a/apps/web/src/markdown/docs/de/xml.mdx b/apps/web/src/markdown/docs/de/xml.mdx
deleted file mode 100644
index 56391f8d..00000000
--- a/apps/web/src/markdown/docs/de/xml.mdx
+++ /dev/null
@@ -1,44 +0,0 @@
-# XML
-
-Languine unterstützt die Lokalisierung von XML-Dateien und ist geeignet für verschiedene XML-basierte Konfigurations- und Inhaltsdateien. Dieses Format verarbeitet komplexe XML-Strukturen und bewahrt dabei die Formatierung und Attribute.
-
----
-
-## Einrichtung
-
-Zuerst stellen Sie sicher, dass Sie eine languine.json-Konfigurationsdatei im Stammverzeichnis Ihres Projekts haben. Hier ist ein Beispiel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "xml": {
-      "include": ["resources/[locale]/*.xml"]
-    }
-  }
-}
-```
-
-## Übersetzung
-
-Mit Ihrer Konfiguration ausgeführt, führen Sie aus:
-
-```bash
-npx languine@latest translate
-```
-
-Wenn Sie diesen Befehl ausführen, wird Languine:
-
-- Ihre Quell-XML-Dateien laden (z. B. resources/en/*.xml)
-- Neue oder geänderte Inhalte erkennen
-- Übersetzungen für Ihre Zielsprache generieren
-- Die Zielsprache-Dateien erstellen oder aktualisieren (z. B. resources/sv/*.xml)
-- Die XML-Struktur und Formatierung bewahren
-- Attributübersetzungen verarbeiten
-- CDATA-Abschnitte beibehalten
-- XML-Kommentare erhalten
-- XML-Namensräume unterstützen
-- Die XML-Struktur validieren
diff --git a/apps/web/src/markdown/docs/de/yaml.mdx b/apps/web/src/markdown/docs/de/yaml.mdx
deleted file mode 100644
index 5e61e33a..00000000
--- a/apps/web/src/markdown/docs/de/yaml.mdx
+++ /dev/null
@@ -1,39 +0,0 @@
-# YAML
-
-Languine unterstützt YAML-Dateien als Quellformat, das häufig in Ruby on Rails, Laravel und anderen Frameworks verwendet wird. Dieses Format unterstützt verschachtelte Strukturen, Arrays und komplexe Datentypen.
-
----
-
-## Einrichtung
-
-Zuerst stellen Sie sicher, dass Sie eine languine.json-Konfigurationsdatei im Stammverzeichnis Ihres Projekts haben. Hier ist ein Beispiel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "yaml": {
-      "include": ["config/locales/[locale].yml"]
-    }
-  }
-}
-```
-
-## Übersetzen
-
-Mit Ihrer Konfiguration führen Sie aus:
-
-```bash
-npx languine@latest translate
-```
-
-Wenn Sie diesen Befehl ausführen, wird Languine:
-
-- Ihre Quell-YAML-Datei laden (z.B. config/locales/en.yml)
-- Neue oder geänderte Übersetzungsstrings erkennen
-- Übersetzungen für Ihre Zielsprache generieren
-- Die YAML-Dateien der Zielsprache erstellen oder aktualisieren (z.B. config/locales/sv.yml)
-- Verschachtelte Strukturen und Formatierungen beibehalten
diff --git a/apps/web/src/markdown/docs/en/github-actions.mdx b/apps/web/src/markdown/docs/en/github-actions.mdx
index fe1adfaa..722b76fc 100644
--- a/apps/web/src/markdown/docs/en/github-actions.mdx
+++ b/apps/web/src/markdown/docs/en/github-actions.mdx
@@ -9,54 +9,6 @@ This saves you a lot of time and effort while maintaining high quality translati
 
 
 
-<div className="flex flex-col items-center justify-center p-4 mb-8 h-[400px] sm:h-[500px] md:h-[650px]">
-        <pre
-          className="p-4 text-sm leading-5 scale-[0.5] sm:scale-[0.65] md:scale-90 transform-gpu"
-          style={{
-            fontFamily: "monospace",
-            whiteSpace: "pre",
-            textAlign: "left",
-          }}
-        >
-          {`
-                                  ┌───────────────┐
-                                  │   Git Push    │
-                                  └───────────────┘
-                                          │
-                                          ▼
-             ┌─────────────────────────────────────────────────────────┐
-             │░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-             │░░░░░░░░░░░░░░░░░░░░ Languine Engine ░░░░░░░░░░░░░░░░░░░░│
-             │░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-             └─────────────────────────────────────────────────────────┘
-                                          │
-                                          ▼
-                                          │
-            ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┼ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─
-           │                              │                              │
-           ▼                              ▼                              ▼
- ╔═══════════════════╗          ╔═══════════════════╗          ╔═══════════════════╗
- ║                   ║          ║                   ║          ║                   ║
- ║      English      ║          ║      Spanish      ║          ║      Japanese     ║
- ║    Translation    ║          ║    Translation    ║          ║     Translation   ║
- ║                   ║          ║                   ║          ║                   ║
- ╚═══════════════════╝          ╚═══════════════════╝          ╚═══════════════════╝
-           │                              │                              │
-           └──────────────────────────────┼──────────────────────────────┘
-                                          ▼
-                                  ┌───────────────┐
-                                  │     Merge     │
-                                  │ Pull Request  │
-                                  └───────────────┘
-                                          │
-                                          ▼
-                              ┌─────────────────────┐
-                              │      Completed      │
-                              │      (Deploy)       │
-                              └─────────────────────┘
-`}
-        </pre>
-      </div>
 
 ---
 
diff --git a/apps/web/src/markdown/docs/es/android.mdx b/apps/web/src/markdown/docs/es/android.mdx
deleted file mode 100644
index cb34240d..00000000
--- a/apps/web/src/markdown/docs/es/android.mdx
+++ /dev/null
@@ -1,39 +0,0 @@
-# Android
-
-Languine admite recursos de cadena de Android (strings.xml) como formato de origen, manejando plurales, arreglos de cadenas y cadenas formateadas. Este formato es la forma estándar de gestionar traducciones en aplicaciones de Android.
-
----
-
-## Configuración
-
-Primero, asegúrate de tener un archivo de configuración languine.json en la raíz de tu proyecto. Aquí tienes un ejemplo:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "android": {
-      "include": ["app/src/main/res/values-[locale]/strings.xml"]
-    }
-  }
-}
-```
-
-## Traducción
-
-Con tu configuración lista, ejecuta:
-
-```bash
-npx languine@latest translate
-```
-
-Cuando ejecutes este comando, Languine:
-
-- Cargará tu archivo strings.xml de origen (por ejemplo, values/strings.xml)
-- Detectará cualquier cadena de traducción nueva o modificada
-- Generará traducciones para tus idiomas de destino
-- Creará o actualizará los archivos XML del idioma de destino (por ejemplo, values-sv/strings.xml, values-de/strings.xml, values-fr/strings.xml)
-- Preservará cualquier formato existente de arreglos de cadenas y plurales
diff --git a/apps/web/src/markdown/docs/es/arb.mdx b/apps/web/src/markdown/docs/es/arb.mdx
deleted file mode 100644
index 0f31b12e..00000000
--- a/apps/web/src/markdown/docs/es/arb.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# ARB (Paquete de Recursos de Aplicación)
-
-Languine admite archivos ARB, el formato de localización estándar para aplicaciones Flutter. Este formato maneja plurales, marcadores de posición y expresiones selectas mientras mantiene la compatibilidad con el paquete intl de Flutter.
-
----
-
-## Configuración
-
-Primero, asegúrate de tener un archivo de configuración languine.json en la raíz de tu proyecto. Aquí tienes un ejemplo:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "arb": {
-      "include": ["lib/l10n/intl_[locale].arb"]
-    }
-  }
-}
-```
-
-## Traducción
-
-Con tu configuración lista, ejecuta:
-
-```bash
-npx languine@latest translate
-```
-
-Cuando ejecutes este comando, Languine:
-
-- Cargará tu archivo ARB de origen (por ejemplo, lib/l10n/intl_en.arb)
-- Detectará cualquier cadena de traducción nueva o modificada
-- Generará traducciones para tus idiomas de destino
-- Creará o actualizará los archivos ARB del idioma de destino (por ejemplo, lib/l10n/intl_sv.arb)
-- Preservará metadatos, marcadores de posición y expresiones de plural/select
-
diff --git a/apps/web/src/markdown/docs/es/authentication.mdx b/apps/web/src/markdown/docs/es/authentication.mdx
deleted file mode 100644
index 47467e3f..00000000
--- a/apps/web/src/markdown/docs/es/authentication.mdx
+++ /dev/null
@@ -1,48 +0,0 @@
-# Autenticación
-
-Para usar Languine, necesitas autenticarte con nuestro Motor, solo toma unos segundos comenzar.
-
----
-
-## Iniciar sesión
-
-Puedes iniciar sesión directamente en [Languine Dashboard](https://languine.ai/login) o ejecutar el siguiente comando:
-
-```bash title="Terminal"
-npx languine@latest auth login
-```
-
-
-Si ya tienes una cuenta, se iniciará sesión automáticamente y se guardará una sesión en tu máquina.
-
----
-
-## Cerrar sesión
-
-Puedes cerrar sesión ejecutando el siguiente comando:
-
-```bash title="Terminal"
-npx languine@latest auth logout
-```
-
----
-
-## Sesión de usuario
-
-Puedes verificar si has iniciado sesión ejecutando el siguiente comando:
-
-```bash title="Terminal"
-npx languine@latest auth whoami
-```
-
----
-
-
-# Variables de entorno
-
-Puedes establecer las siguientes variables de entorno para configurar Languine:
-
-- `LANGUINE_API_KEY`: La clave API para usar en la autenticación.
-- `LANGUINE_PROJECT_ID`: El ID del proyecto a usar para el proyecto.
-
-Puedes encontrarlas en el [Languine Dashboard](https://languine.ai/login).
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/es/biome.mdx b/apps/web/src/markdown/docs/es/biome.mdx
deleted file mode 100644
index a885fb9a..00000000
--- a/apps/web/src/markdown/docs/es/biome.mdx
+++ /dev/null
@@ -1,24 +0,0 @@
-# Bioma
-
-Languine puede trabajar junto con [Biome](https://biomejs.dev/) para asegurar que tus archivos de traducción estén formateados de manera consistente. Esto es particularmente útil al trabajar con archivos de traducción JSON que necesitan mantener un estilo uniforme en tu proyecto.
-
-## Usando con Languine
-
-La forma recomendada de usar Biome con Languine es formatear tus archivos de traducción después de que se generen. Puedes configurar esto en tu `package.json`:
-
-```json title="package.json"
-{
-  "scripts": {
-    "translate": "languine translate",
-    "format": "biome format \"locales/**/*.json\"",
-    "translate:format": "npm run translate && npm run format"
-  }
-}
-```
-
-Ahora puedes:
-- Ejecutar `npm run translate` para solo generar traducciones
-- Ejecutar `npm run format` para solo formatear archivos de traducción existentes
-- Ejecutar `npm run translate:format` para generar traducciones y formatearlas en secuencia
-
-Esta configuración asegurará que tus archivos de traducción estén formateados de manera consistente con una indentación de 2 espacios y un ancho máximo de línea de 80 caracteres.
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/es/ci.mdx b/apps/web/src/markdown/docs/es/ci.mdx
deleted file mode 100644
index 44c8104f..00000000
--- a/apps/web/src/markdown/docs/es/ci.mdx
+++ /dev/null
@@ -1,96 +0,0 @@
-# CI/CD
-
-Languine proporciona una integración de CI/CD para ayudarte a traducir tu aplicación.
-
----
-
-## Cómo Funciona
-
-El flujo de trabajo de CI/CD en Languine sigue un proceso estructurado para automatizar las actualizaciones de traducción en tu aplicación:
-
-### 1. Inicialización de la Acción
-- El flujo de trabajo comienza cuando se activa la acción
-- Configura la configuración de Git y las credenciales necesarias
-
-### 2. Procesamiento del Motor de Languine
-- El motor de Languine procesa el contenido de tu aplicación
-- Maneja las tareas de traducción utilizando la configuración establecida
-
-### 3. Detección de Cambios
-El sistema verifica si hay cambios en la traducción y sigue uno de dos caminos:
-
-**Cuando se Encuentran Cambios:**
-- Los cambios se confirman en el repositorio
-- Los cambios se envían a la rama especificada
-- Se crea una Solicitud de Extracción (PR)
-
-**Cuando No se Encuentran Cambios:**
-- El flujo de trabajo se completa sin crear un PR
-
-### 4. Creación de la Solicitud de Extracción
-Cuando se detectan cambios, se crea una Solicitud de Extracción con:
-
-**Contenido del PR:**
-- Título claro que indica actualizaciones de traducción
-- Descripción detallada de los cambios
-- Confirmaciones de control de calidad
-- Instrucciones para la revisión
-- Enlaces a documentación y soporte
-
-**La Descripción del PR Incluye:**
-- Resumen de las actualizaciones de traducción
-- Lista de lo que cambió (traducciones actualizadas, consistencia terminológica)
-- Próximos pasos para los revisores
-- Enlaces a recursos de documentación y soporte
-
----
-
-## Diagrama del Flujo de Trabajo
-
-<div className="flex flex-col items-center justify-center p-4 h-[400px] sm:h-[500px] md:h-[650px]">
-  <pre
-    className="p-4 text-sm leading-5 mb-4 scale-[0.5] sm:scale-[0.65] md:scale-90 transform-gpu"
-    style={{
-      fontFamily: "monospace",
-      whiteSpace: "pre",
-      textAlign: "left",
-    }}
-  >
-    {`
-                    ┌─────────────────────┐
-                    │   La Acción Comienza │
-                    └──────────┬──────────┘
-                               │
-                    ┌──────────▼──────────┐
-                    │    Configurar Git & │
-                    │    Credenciales     │
-                    └──────────┬──────────┘
-                               │
-┌─────────────────────────────────────────────────────────┐
-│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-│░░░░░░░░░░░░░░░░░░░░ Motor de Languine ░░░░░░░░░░░░░░░░░░░░│
-│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-└─────────────────────────────────────────────────────────┘
-                               │
-                    ┌──────────▼──────────┐
-                    │   Verificar Cambios │───────┐
-                    └──────────┬──────────┘       │
-                               │                  │
-                               │ [Cambios]        │ [Sin Cambios]
-                               │                  │
-                    ┌──────────▼──────────┐       │
-                    │   Confirmar & Enviar │       │
-                    └──────────┬──────────┘       │
-                               │                  │
-                    ┌──────────▼──────────┐       │
-                    │    Crear PR         │       │
-                    └──────────┬──────────┘       │
-                               │                  │
-                    ┌──────────▼──────────┐       │
-                    │        Listo        │◄──────┘
-                    └─────────────────────┘
-`}
-  </pre>
-</div>
-
-El flujo de trabajo está diseñado para ser automatizado mientras permite la revisión humana y el control de calidad antes de que los cambios se fusionen en tu base de código. Mantiene las mejores prácticas de control de versiones y asegura que las traducciones se rastreen y documenten adecuadamente a través del historial de Git.
diff --git a/apps/web/src/markdown/docs/es/cli.mdx b/apps/web/src/markdown/docs/es/cli.mdx
deleted file mode 100644
index 2e52f292..00000000
--- a/apps/web/src/markdown/docs/es/cli.mdx
+++ /dev/null
@@ -1,65 +0,0 @@
-# CLI
-
-Languine proporciona una CLI para ayudarte a traducir tu aplicación.
-
----
-
-## Resumen de Comandos
-
-### Traducir
-
-El comando `translate` se utiliza para traducir tu aplicación.
-
-```bash title="Terminal"
-    npx languine@latest translate
-```
-
----
-
-### Inicializar
-
-El comando `init` se utiliza para inicializar un nuevo proyecto de Languine.
-
-```bash title="Terminal"
-    npx languine@latest init
-```
-
----
-
-### Autenticación
-
-El comando `auth` se utiliza para autenticarte con Languine.
-
-```bash title="Terminal"
-    npx languine@latest auth
-```
-
----
-
-### Sincronizar
-
-El comando `sync` se utiliza para sincronizar tu aplicación con Languine.
-
-```bash title="Terminal"
-    npx languine@latest sync
-```
-
----
-
-### Agregar Localidad
-
-El comando `locale` se utiliza para gestionar las localidades de tu aplicación.
-
-```bash title="Terminal"
-    npx languine@latest locale add pt,fr
-```
-
----
-
-### Eliminar Localidad
-
-El comando `locale remove` se utiliza para eliminar una localidad de tu aplicación.
-
-```bash title="Terminal"
-    npx languine@latest locale remove pt,fr
-```
diff --git a/apps/web/src/markdown/docs/es/configuration.mdx b/apps/web/src/markdown/docs/es/configuration.mdx
deleted file mode 100644
index 28cbf6ed..00000000
--- a/apps/web/src/markdown/docs/es/configuration.mdx
+++ /dev/null
@@ -1,180 +0,0 @@
-# Configuración
-
-Languine utiliza un archivo de configuración JSON (languine.json) para gestionar tu configuración de traducción. Este archivo define tus idiomas de origen y destino, así como los archivos que necesitan ser traducidos.
-
----
-
-## Configuración Básica
-
-Aquí tienes un ejemplo básico en ambos formatos:
-
-```json title="languine.json"
-{
-  "locale": {
-    "source": "en",
-    "targets": ["es", "fr", "de"]
-  },
-  "files": {
-    "json": {
-      "include": ["locales/[locale].json"]
-    }
-  }
-}
-```
-
-Desglosemos las diferentes secciones en el archivo de configuración.
-
----
-
-## Configuración Regional
-
-La sección de configuración regional define tus idiomas de traducción:
-
-- source: Tu idioma principal para la creación de contenido (por ejemplo, "en" para inglés)
-- targets: Un array de idiomas a los que deseas traducir (por ejemplo, ["es", "fr", "de"] para español, francés y alemán)
-
-Languine soporta una amplia gama de códigos de idioma, incluyendo:
-- Códigos simples: en, es, fr, de
-- Códigos específicos de región: pt-BR, zh-CN, zh-TW
-
-## Configuración de Archivos
-
-La sección de archivos define qué archivos debe traducir Languine. Puedes configurar múltiples tipos de archivos y patrones:
-
----
-
-### Archivos JSON
-```json
-files: {
-  json: {
-    include: ["locales/[locale].json"],
-  },
-}
-```
-
----
-
-### Archivos Markdown/MDX
-```json
-files: {
-  md: {
-    include: ["docs/[locale]/*.md"],
-  },
-  mdx: {
-    include: ["blog/[locale]/*.mdx"],
-  },
-}
-```
-
----
-
-### Archivos de Plataforma Móvil
-
-Para iOS (Xcode):
-```json
-files: {
-  "xcode-xcstrings": {
-    include: ["Example/Localizable.xcstrings"],
-  },
-  // O para archivos .strings tradicionales
-  "xcode-strings": {
-    include: ["Example/[locale].lproj/Localizable.strings"],
-  },
-}
-```
-
----
-
-Para Android:
-```json
-files: {
-  android: {
-    include: ["locales/[locale].xml"],
-  },
-}
-```
-
----
-
-### Otros Formatos
-
-Aquí tienes una lista completa de los formatos de archivo soportados por Languine:
-
-- [JSON](/docs/json) - Archivos de traducción JSON estándar
-- [YAML](/docs/yaml) - Archivos de traducción YAML
-- [Properties](/docs/properties) - Archivos de propiedades de Java
-- [Android](/docs/android) - Archivos de recursos XML de Android
-- [iOS](/docs/ios) - Archivos de localización de iOS
-- [iOS Stringsdict](/docs/xcode-stringsdict) - Archivos de pluralización de iOS
-- [iOS XCStrings](/docs/xcode-xcstrings) - Catálogos de cadenas modernos de Xcode
-- [Markdown](/docs/md) - Archivos de documentación
-- [MDX](/docs/mdx) - Documentación con JSX
-- [HTML](/docs/html) - Archivos HTML
-- [JavaScript](/docs/js) - Archivos JavaScript
-- [TypeScript](/docs/ts) - Archivos TypeScript
-- [Gettext PO](/docs/po) - Archivos de traducción GetText
-- [XLIFF](/docs/xliff) - Formato de Intercambio de Localización XML
-- [CSV](/docs/csv) - Traducciones basadas en hojas de cálculo
-- [XML](/docs/xml) - Archivos de recursos XML
-- [Flutter ARB](/docs/arb) - Archivos de Paquete de Recursos de Aplicación
-
----
-
-## Patrones de Archivos
-
-El marcador de posición [locale] en los patrones de archivo se reemplaza automáticamente con el código de idioma apropiado durante la traducción. Por ejemplo:
-
-- locales/[locale].json se convierte en:
-  - locales/en.json
-  - locales/es.json
-  - locales/fr.json
-
-Puedes incluir múltiples patrones para cada tipo de archivo y usar patrones glob:
-```json
-files: {
-  json: {
-    include: [
-      "src/locales/[locale].json",
-      "src/components/[locale]/*.json"
-    ],
-  },
-}
-```
-
----
-
-## ID del Proyecto (Opcional)
-
-Si estás utilizando los servicios en la nube de Languine, puedes incluir tu ID de proyecto en la configuración:
-
-```json
-{
-  "projectId": "prj_your_project_id",
-  "locale": {
-    // ... configuración regional
-  },
-  files: {
-    // ... configuración de archivos
-  },
-}
-```
-
----
-
-## Seguimiento del Estado de Traducción
-
-Languine crea y mantiene automáticamente un archivo languine.lock para rastrear el estado de tus traducciones. Este archivo:
-
-- Rastrear qué contenido ha sido traducido
-- Ayuda a identificar qué necesita ser actualizado cuando el contenido de origen cambia
-- Debe ser comprometido en tu sistema de control de versiones
-
-No necesitas editar manualmente el archivo de bloqueo - Languine lo gestiona automáticamente cuando ejecutas comandos de traducción.
-
-## Mejores Prácticas
-
-1. **Control de Versiones**: Siempre compromete tanto languine.json como languine.lock en tu repositorio
-2. **Organización de Archivos**: Mantén tus archivos de traducción organizados en una estructura de directorios consistente
-3. **Códigos de Idioma**: Usa códigos de idioma estándar para asegurar compatibilidad
-4. **Patrones**: Usa patrones de inclusión específicos para evitar traducir archivos innecesarios
-5. **ID del Proyecto**: Mantén seguro tu ID de proyecto y no lo compartas públicamente si estás utilizando servicios en la nube, usa la variable de entorno `LANGUINE_PROJECT_ID` en su lugar.
diff --git a/apps/web/src/markdown/docs/es/csv.mdx b/apps/web/src/markdown/docs/es/csv.mdx
deleted file mode 100644
index b8f645d7..00000000
--- a/apps/web/src/markdown/docs/es/csv.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# CSV
-
-Languine admite archivos CSV (Valores Separados por Comas) para una gestión de traducción sencilla. Este formato es ideal para flujos de trabajo basados en hojas de cálculo y una fácil integración con herramientas de traducción externas.
-
----
-
-## Configuración
-
-Primero, asegúrate de tener un archivo de configuración languine.json en la raíz de tu proyecto. Aquí tienes un ejemplo:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "csv": {
-      "include": ["translations/[locale].csv"]
-    }
-  }
-}
-```
-
-## Traducción
-
-Con tu configuración lista, ejecuta:
-
-```bash
-npx languine@latest translate
-```
-
-Cuando ejecutes este comando, Languine:
-
-- Cargará tu archivo CSV de origen (por ejemplo, translations/en.csv)
-- Detectará cualquier cadena de traducción nueva o modificada
-- Generará traducciones para tus idiomas de destino
-- Creará o actualizará los archivos CSV del idioma de destino (por ejemplo, translations/sv.csv)
-- Mantendrá la estructura y el formato de las columnas
-- Preservará cualquier columna de metadatos adicional
diff --git a/apps/web/src/markdown/docs/es/expo.mdx b/apps/web/src/markdown/docs/es/expo.mdx
deleted file mode 100644
index 01cca00a..00000000
--- a/apps/web/src/markdown/docs/es/expo.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# Expo
-
-Languine admite la localización de Expo, integrándose a la perfección con el sistema i18n de Expo. Este formato funciona tanto con proyectos de JavaScript como de TypeScript, admitiendo estructuras anidadas y pluralización.
-
----
-
-## Configuración
-
-Primero, asegúrate de tener un archivo de configuración languine.json en la raíz de tu proyecto. Aquí tienes un ejemplo:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "expo": {
-      "include": ["assets/locales/[locale].json"]
-    }
-  }
-}
-```
-
-## Traducción
-
-Con tu configuración lista, ejecuta:
-
-```bash
-npx languine@latest translate
-```
-
-Cuando ejecutes este comando, Languine:
-
-- Cargará tu archivo de traducción fuente (por ejemplo, assets/locales/en.json)
-- Detectará cualquier cadena de traducción nueva o modificada
-- Generará traducciones para tus idiomas de destino
-- Creará o actualizará los archivos de idioma de destino (por ejemplo, assets/locales/sv.json)
-- Preservará la estructura anidada y las reglas de pluralización
-- Mantendrá la compatibilidad con expo-localization
diff --git a/apps/web/src/markdown/docs/es/github-actions.mdx b/apps/web/src/markdown/docs/es/github-actions.mdx
deleted file mode 100644
index 382c75f8..00000000
--- a/apps/web/src/markdown/docs/es/github-actions.mdx
+++ /dev/null
@@ -1,148 +0,0 @@
-# GitHub Actions
-
-Con la acción de GitHub, puedes traducir tu código fácilmente simplemente al subir tu código al repositorio; la acción de GitHub traducirá tus nuevas claves, ya sea creando una solicitud de extracción o confirmando tus cambios.
-Esto te ahorra mucho tiempo y esfuerzo mientras mantienes traducciones de alta calidad.
-
----
-
-## Cómo funciona
-
-
-
-<div className="flex flex-col items-center justify-center p-4 mb-8 h-[400px] sm:h-[500px] md:h-[650px]">
-        <pre
-          className="p-4 text-sm leading-5 scale-[0.5] sm:scale-[0.65] md:scale-90 transform-gpu"
-          style={{
-            fontFamily: "monospace",
-            whiteSpace: "pre",
-            textAlign: "left",
-          }}
-        >
-          {`
-                                  ┌───────────────┐
-                                  │   Git Push    │
-                                  └───────────────┘
-                                          │
-                                          ▼
-             ┌─────────────────────────────────────────────────────────┐
-             │░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-             │░░░░░░░░░░░░░░░░░░░░ Languine Engine ░░░░░░░░░░░░░░░░░░░░│
-             │░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-             └─────────────────────────────────────────────────────────┘
-                                          │
-                                          ▼
-                                          │
-            ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┼ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─
-           │                              │                              │
-           ▼                              ▼                              ▼
- ╔═══════════════════╗          ╔═══════════════════╗          ╔═══════════════════╗
- ║                   ║          ║                   ║          ║                   ║
- ║      Inglés       ║          ║      Español      ║          ║      Japonés      ║
- ║    Traducción     ║          ║    Traducción     ║          ║     Traducción    ║
- ║                   ║          ║                   ║          ║                   ║
- ╚═══════════════════╝          ╚═══════════════════╝          ╚═══════════════════╝
-           │                              │                              │
-           └──────────────────────────────┼──────────────────────────────┘
-                                          ▼
-                                  ┌───────────────┐
-                                  │     Fusionar   │
-                                  │ Solicitud de   │
-                                  │   Extracción   │
-                                  └───────────────┘
-                                          │
-                                          ▼
-                              ┌─────────────────────┐
-                              │      Completado     │
-                              │      (Desplegar)    │
-                              └─────────────────────┘
-`}
-        </pre>
-      </div>
-
----
-
-## Instalación
-
-Para usar la acción de Languine en tu repositorio, necesitarás:
-
-1. Configurar los secretos de tu repositorio con tus credenciales de Languine
-2. Crear un archivo de flujo de trabajo en tu repositorio
-
-### Configuración de Secretos del Repositorio
-
-Agrega los siguientes secretos en la configuración de tu repositorio (Configuración > Secretos y variables > Acciones):
-
-- `LANGUINE_API_KEY`: Tu clave API de Languine
-- `LANGUINE_PROJECT_ID`: Tu ID de proyecto de Languine
-
-Puedes encontrar estos valores en tu panel de Languine bajo Configuración del Proyecto.
-
-
-
-### Variables de Entorno
-
-La acción de GitHub utiliza las siguientes variables de entorno:
-- `LANGUINE_API_KEY` (Requerido): Tu clave API de Languine para autenticación
-- `LANGUINE_PROJECT_ID` (Requerido): Tu ID de proyecto de Languine 
-- `GITHUB_TOKEN` (Requerido): Proporcionado automáticamente por GitHub, utilizado para crear PRs
-
-### Ejemplo de Flujo de Trabajo
-
-Crea un nuevo archivo .github/workflows/languine.yml en tu repositorio con el siguiente contenido:
-
-```ts title=".github/workflows/release.yml"
-name: Desplegar Sitio Web
-
-on:
-  push:
-    branches:
-      - '**'
-    paths:
-      - apps/web/**
-
-jobs:
-  translate:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-      pull-requests: write
-    steps:
-      - uses: actions/checkout@v4
-      
-      - name: Acción de Languine
-        uses: languine/languine-action@v1
-        env:
-           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          api-key: ${{ secrets.LANGUINE_API_KEY }}
-          project-id: ${{ secrets.LANGUINE_PROJECT_ID }}
-```
- 
- Este flujo de trabajo:
-- Se ejecutará en los pushes a la rama principal
-- Se ejecutará en las solicitudes de extracción a la rama principal
-- Puede ser activado manualmente desde la pestaña de Acciones
-- Revisará tu código y ejecutará el proceso de traducción de Languine
-- Creará una solicitud de extracción con cualquier nueva traducción (configurable)
-
-#### Opción de Directorio de Trabajo
-
-La opción `working-directory` te permite especificar dónde se encuentran tus archivos de traducción. Esto es particularmente útil en monorepos donde tus traducciones pueden estar en un paquete o directorio de aplicación específico. Por ejemplo:
-
-#### Opción de Solicitud de Extracción (próximamente)
-
-La opción `create-pull-request` controla si la acción crea una solicitud de extracción con los cambios o los confirma directamente en la rama:
-
-```typescript title=".github/workflows/languine.yml"
-with:
-  create-pull-request: true # crear una solicitud de extracción con los cambios
-```
-
-Cuando se establece en `true`, la acción:
-- Creará una nueva rama con los cambios
-- Creará una solicitud de extracción para revisión
-- Agregará etiquetas y descripciones apropiadas
-
-Cuando se establece en `false` (predeterminado), la acción:
-- Confirmará los cambios directamente en la rama actual
-- Subirá los cambios sin crear una solicitud de extracción
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/es/html.mdx b/apps/web/src/markdown/docs/es/html.mdx
deleted file mode 100644
index a34c2615..00000000
--- a/apps/web/src/markdown/docs/es/html.mdx
+++ /dev/null
@@ -1,41 +0,0 @@
-# HTML
-
-Languine admite la localización de archivos HTML, manejando tanto el contenido de texto como los atributos. Este formato es ideal para sitios web estáticos y plantillas HTML, con soporte para preservar la estructura y el formato HTML.
-
----
-
-## Configuración
-
-Primero, asegúrate de tener un archivo de configuración languine.json en la raíz de tu proyecto. Aquí tienes un ejemplo:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "html": {
-      "include": ["pages/[locale]/*.html"]
-    }
-  }
-}
-```
-
-## Traducción
-
-Con tu configuración lista, ejecuta:
-
-```bash
-npx languine@latest translate
-```
-
-Cuando ejecutes este comando, Languine:
-
-- Cargará tus archivos HTML de origen (por ejemplo, pages/en/*.html)
-- Detectará cualquier cadena de traducción nueva o modificada
-- Generará traducciones para tus idiomas de destino
-- Creará o actualizará los archivos HTML del idioma de destino (por ejemplo, pages/sv/*.html)
-- Preservará la estructura y el formato HTML
-- Manejará las traducciones de atributos especificados
-- Mantendrá los comentarios y las etiquetas especiales
diff --git a/apps/web/src/markdown/docs/es/introduction.mdx b/apps/web/src/markdown/docs/es/introduction.mdx
deleted file mode 100644
index e4558a7c..00000000
--- a/apps/web/src/markdown/docs/es/introduction.mdx
+++ /dev/null
@@ -1,34 +0,0 @@
-# Introducción
-
-Languine automatiza la localización dentro de su flujo de trabajo y pipeline de desarrollo, asegurando que las traducciones nunca lo detengan.
-
-Transforme su aplicación en una experiencia multilingüe en minutos. Mientras usted se concentra en construir características, Languine maneja todos los aspectos de la traducción con precisión y fiabilidad.
-
----
-
-## Características Clave
-
-- **Motor de Traducción**: Aproveche traducciones de alta calidad y con conciencia del contexto que mantienen la voz de su marca
-- **Integración CI/CD**: Automatice las actualizaciones de traducción a través de sus flujos de trabajo existentes
-- **Formatos**: Maneje cualquier formato de archivo con nuestro sistema de parser extensible
-- **Código Abierto**: Acceda, inspeccione y contribuya a nuestra base de código en GitHub - sin cajas negras, completa transparencia
-
----
-
-## Cómo Funciona
-
-1. **Configuración Rápida**: Comience en minutos con nuestra CLI intuitiva y la inicialización guiada
-2. **Configuración Simple**: Defina sus necesidades de traducción con un archivo de configuración claro y directo
-3. **Traducción Automatizada**: Envíe su contenido una vez y deje que Languine maneje automáticamente la traducción a todos los idiomas de destino
-
----
-
-## Comenzando
-
-Comience su viaje de localización con nuestra guía de [Inicio Rápido](/docs/quickstart) - tendrá sus primeras traducciones funcionando en minutos.
-
-Explore nuestra documentación completa para dominar las capacidades de Languine:
-
-- [Configuración](/docs/configuration) - Configure Languine según las necesidades de su proyecto
-- [CLI](/docs/cli) - Domine nuestra poderosa interfaz de línea de comandos
-- [Acciones de Github](/docs/github-actions) - Automatice las traducciones con nuestra Acción de Github
diff --git a/apps/web/src/markdown/docs/es/ios.mdx b/apps/web/src/markdown/docs/es/ios.mdx
deleted file mode 100644
index 4a24ecc9..00000000
--- a/apps/web/src/markdown/docs/es/ios.mdx
+++ /dev/null
@@ -1,39 +0,0 @@
-# iOS
-
-Languine admite archivos Localizable.strings de iOS, el formato de localización estándar para aplicaciones de iOS. Este formato maneja pares de cadenas clave-valor básicos y admite comentarios para proporcionar contexto a los traductores.
-
----
-
-## Configuración
-
-Primero, asegúrate de tener un archivo de configuración languine.json en la raíz de tu proyecto. Aquí tienes un ejemplo:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "ios": {
-      "include": ["[locale].lproj/Localizable.strings"]
-    }
-  }
-}
-```
-
-## Traducción
-
-Con tu configuración lista, ejecuta:
-
-```bash
-npx languine@latest translate
-```
-
-Cuando ejecutes este comando, Languine:
-
-- Cargará tu archivo Localizable.strings de origen (por ejemplo, en.lproj/Localizable.strings)
-- Detectará cualquier cadena de traducción nueva o modificada
-- Generará traducciones para tus idiomas de destino
-- Creará o actualizará los archivos de idioma de destino (por ejemplo, sv.lproj/Localizable.strings)
-- Preservará cualquier comentario y formato existente
diff --git a/apps/web/src/markdown/docs/es/js.mdx b/apps/web/src/markdown/docs/es/js.mdx
deleted file mode 100644
index 9c995fd0..00000000
--- a/apps/web/src/markdown/docs/es/js.mdx
+++ /dev/null
@@ -1,42 +0,0 @@
-# JavaScript
-
-Languine admite archivos de localización de JavaScript/TypeScript, perfectos para aplicaciones web modernas. Este formato maneja tanto literales de objeto como exportaciones de módulos, soportando estructuras anidadas y contenido dinámico.
-
----
-
-## Configuración
-
-Primero, asegúrate de tener un archivo de configuración languine.json en la raíz de tu proyecto. Aquí tienes un ejemplo:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "js": {
-      "include": ["src/locales/[locale].js"]
-    }
-  }
-}
-```
-
-## Traducción
-
-Con tu configuración lista, ejecuta:
-
-```bash
-npx languine@latest translate
-```
-
-Cuando ejecutes este comando, Languine:
-
-- Cargará tus archivos JavaScript de origen (por ejemplo, src/locales/en.js)
-- Detectará cualquier cadena de traducción nueva o modificada
-- Generará traducciones para tus idiomas de destino
-- Creará o actualizará los archivos de idioma de destino (por ejemplo, src/locales/sv.js)
-- Preservará la estructura del módulo y las exportaciones
-- Manejará objetos y arreglos anidados
-- Mantendrá el formato del código y los comentarios
-- Generará tipos de TypeScript si está habilitado
diff --git a/apps/web/src/markdown/docs/es/json.mdx b/apps/web/src/markdown/docs/es/json.mdx
deleted file mode 100644
index e96f906e..00000000
--- a/apps/web/src/markdown/docs/es/json.mdx
+++ /dev/null
@@ -1,41 +0,0 @@
-# JSON
-
-Languine admite archivos JSON como formato de origen con los requisitos comunes para la pluralización y la interpolación. Este formato se utiliza en muchos frameworks como React, Vue, Ruby on Rails y más.
-
-
----
-
-
-## Configuración
-
-Primero, asegúrate de tener un archivo de configuración languine.json en la raíz de tu proyecto. Aquí tienes un ejemplo:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "json": {
-      "include": ["locales/[locale].json"]
-    }
-  }
-}
-
-```
-
-## Traducción
-
-Con tu configuración lista, ejecuta:
-
-```bash
-npx languine@latest translate
-```
-
-Cuando ejecutes este comando, Languine:
-
-- Cargará tu archivo JSON de origen (por ejemplo, locales/en.json)
-- Detectará cualquier cadena de traducción nueva o modificada
-- Generará traducciones para tus idiomas de destino
-- Creará o actualizará los archivos JSON de los idiomas de destino (por ejemplo, locales/sv.json, locales/de.json, locales/fr.json)
diff --git a/apps/web/src/markdown/docs/es/md.mdx b/apps/web/src/markdown/docs/es/md.mdx
deleted file mode 100644
index e216fa96..00000000
--- a/apps/web/src/markdown/docs/es/md.mdx
+++ /dev/null
@@ -1,43 +0,0 @@
-# Markdown
-
-Languine admite la localización de archivos Markdown, perfecto para documentación, publicaciones de blog y sitios con mucho contenido. Este formato preserva la sintaxis de Markdown mientras traduce el contenido, incluyendo soporte para front matter.
-
----
-
-## Configuración
-
-Primero, asegúrate de tener un archivo de configuración languine.json en la raíz de tu proyecto. Aquí tienes un ejemplo:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "md": {
-      "include": ["content/[locale]/**/*.md"]
-    }
-  }
-}
-```
-
-## Traducción
-
-Con tu configuración lista, ejecuta:
-
-```bash
-npx languine@latest translate
-```
-
-Cuando ejecutes este comando, Languine:
-
-- Cargará tus archivos Markdown fuente (por ejemplo, content/en/*.md)
-- Detectará cualquier contenido nuevo o modificado
-- Generará traducciones para tus idiomas de destino
-- Creará o actualizará los archivos de idioma de destino (por ejemplo, content/sv/*.md)
-- Preservará el formato y la estructura de Markdown
-- Manejará las traducciones de front matter
-- Mantendrá enlaces y referencias
-- Mantendrá bloques de código sin traducir
-- Preservará HTML dentro de Markdown
diff --git a/apps/web/src/markdown/docs/es/mdx.mdx b/apps/web/src/markdown/docs/es/mdx.mdx
deleted file mode 100644
index 2d3f4651..00000000
--- a/apps/web/src/markdown/docs/es/mdx.mdx
+++ /dev/null
@@ -1,43 +0,0 @@
-# Markdown (MDX)
-
-Languine admite la localización de archivos Markdown (MDX), perfecto para documentación, publicaciones de blog y sitios con mucho contenido. Este formato preserva la sintaxis de Markdown mientras traduce el contenido, incluyendo soporte para front matter.
-
----
-
-## Configuración
-
-Primero, asegúrate de tener un archivo de configuración languine.json en la raíz de tu proyecto. Aquí tienes un ejemplo:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "mdx": {
-      "include": ["content/[locale]/**/*.mdx"]
-    }
-  }
-}
-```
-
-## Traducción
-
-Con tu configuración lista, ejecuta:
-
-```bash
-npx languine@latest translate
-```
-
-Cuando ejecutes este comando, Languine:
-
-- Cargará tus archivos Markdown de origen (por ejemplo, content/en/*.mdx)
-- Detectará cualquier contenido nuevo o modificado
-- Generará traducciones para tus idiomas de destino
-- Creará o actualizará los archivos del idioma de destino (por ejemplo, content/sv/*.mdx)
-- Preservará el formato y la estructura de Markdown
-- Manejará las traducciones de front matter
-- Mantendrá enlaces y referencias
-- Mantendrá los bloques de código sin traducir
-- Preservará HTML dentro de Markdown
diff --git a/apps/web/src/markdown/docs/es/overrides.mdx b/apps/web/src/markdown/docs/es/overrides.mdx
deleted file mode 100644
index 30b702aa..00000000
--- a/apps/web/src/markdown/docs/es/overrides.mdx
+++ /dev/null
@@ -1,7 +0,0 @@
-# Sobrescrituras
-
-Languine te permite sobrescribir traducciones para claves específicas. Esto es útil cuando deseas asegurarte de que se utilice una traducción específica para una clave en particular, independientemente de la traducción predeterminada.
-
-## Cómo funciona
-
-En el panel de control, puedes crear sobrescrituras para claves específicas. También puedes crear sobrescrituras para idiomas específicos.
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/es/po.mdx b/apps/web/src/markdown/docs/es/po.mdx
deleted file mode 100644
index ef700152..00000000
--- a/apps/web/src/markdown/docs/es/po.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# PO (Gettext)
-
-Languine admite archivos PO, el formato de localización Gettext ampliamente utilizado. Este formato es popular en muchos entornos de programación, particularmente en aplicaciones de Linux y frameworks de PHP, ofreciendo soporte para contexto, plurales y comentarios de traductores.
-
----
-
-## Configuración
-
-Primero, asegúrate de tener un archivo de configuración languine.json en la raíz de tu proyecto. Aquí tienes un ejemplo:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "po": {
-      "include": ["locales/[locale]/LC_MESSAGES/messages.po"]
-    }
-  }
-}
-```
-
-## Traducción
-
-Con tu configuración lista, ejecuta:
-
-```bash
-npx languine@latest translate
-```
-
-Cuando ejecutes este comando, Languine:
-
-- Cargará tu archivo PO de origen (por ejemplo, locales/en/LC_MESSAGES/messages.po)
-- Detectará cualquier cadena de traducción nueva o modificada
-- Generará traducciones para tus idiomas de destino
-- Creará o actualizará los archivos PO del idioma de destino (por ejemplo, locales/sv/LC_MESSAGES/messages.po)
-- Preservará metadatos, contextos y formas plurales
-- Mantendrá comentarios de traductores e información de referencia
diff --git a/apps/web/src/markdown/docs/es/prettier.mdx b/apps/web/src/markdown/docs/es/prettier.mdx
deleted file mode 100644
index 82ab07da..00000000
--- a/apps/web/src/markdown/docs/es/prettier.mdx
+++ /dev/null
@@ -1,22 +0,0 @@
-# Prettier
-
-Languine puede trabajar junto con [Prettier](https://prettier.io/) para asegurar que tus archivos de traducción estén formateados de manera consistente. Esto es particularmente útil al trabajar con archivos de traducción JSON que necesitan mantener un estilo uniforme en todo tu proyecto.
-
-## Usando con Languine
-
-La forma recomendada de usar Prettier con Languine es formatear tus archivos de traducción después de que se generen. Puedes configurar esto en tu `package.json`:
-
-```json title="package.json"
-{
-  "scripts": {
-    "translate": "languine translate",
-    "format": "prettier --write \"locales/**/*.json\"",
-    "translate:format": "npm run translate && npm run format"
-  }
-}
-```
-
-Ahora puedes:
-- Ejecutar `npm run translate` para generar solo traducciones
-- Ejecutar `npm run format` para formatear solo los archivos de traducción existentes
-- Ejecutar `npm run translate:format` para generar traducciones y formatearlas en secuencia
diff --git a/apps/web/src/markdown/docs/es/properties.mdx b/apps/web/src/markdown/docs/es/properties.mdx
deleted file mode 100644
index 77ab3efe..00000000
--- a/apps/web/src/markdown/docs/es/properties.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# Propiedades
-
-Languine admite archivos de propiedades de Java, el formato de localización estándar para aplicaciones Java. Este formato maneja la escape de Unicode y admite tanto pares clave-valor como comentarios.
-
----
-
-## Configuración
-
-Primero, asegúrate de tener un archivo de configuración languine.json en la raíz de tu proyecto. Aquí tienes un ejemplo:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "properties": {
-      "include": ["src/main/resources/messages_[locale].properties"]
-    }
-  }
-}
-```
-
-## Traducción
-
-Con tu configuración lista, ejecuta:
-
-```bash
-npx languine@latest translate
-```
-
-Cuando ejecutes este comando, Languine:
-
-- Cargará tu archivo de propiedades de origen (por ejemplo, messages_en.properties)
-- Detectará cualquier cadena de traducción nueva o modificada
-- Generará traducciones para tus idiomas de destino
-- Creará o actualizará los archivos de propiedades del idioma de destino (por ejemplo, messages_sv.properties)
-- Manejará la escape de Unicode automáticamente
-- Preservará comentarios y formato
diff --git a/apps/web/src/markdown/docs/es/quickstart.mdx b/apps/web/src/markdown/docs/es/quickstart.mdx
deleted file mode 100644
index 578a3700..00000000
--- a/apps/web/src/markdown/docs/es/quickstart.mdx
+++ /dev/null
@@ -1,65 +0,0 @@
-# Guía Rápida
-
-Comienza instalando Languine.
-
-Luego, ejecuta el siguiente comando para inicializar Languine.
-
-```bash title="Terminal"
-npx languine@latest init
-```
-
-Sigue los pasos para configurar tu proyecto.
-
----
-
-## Primera Traducción
-
-Ahora estás listo para traducir tu código.
-
-Comienza agregando una clave a tu archivo fuente, por ejemplo, si decides usar `en.json` como tu archivo fuente, agrega una clave a él.
-
-```json title="src/locales/en.json"
-{
-  "welcome": "¡Bienvenido a nuestra aplicación!",
-  "user": {
-    "greeting": "¡Hola, {{name}}!",
-    "profile": {
-      "title": "Tu perfil",
-      "edit": "Editar perfil"
-    }
-  },
-  "notifications": {
-    "messages": "Tienes {{count}} nuevo(s) mensaje(s).",
-    "empty": "No hay nuevas notificaciones."
-  }
-}
-
-```
-
----
-
-## Traducir
-
-Ejecuta el siguiente comando para traducir tu contenido:
-
-```bash title="Terminal"
-npx languine@latest translate
-```
-
-## Esto hará:
-1. Crear archivos de traducción para cada idioma objetivo
-2. Generar traducciones de alta calidad con el Motor Languine
-3. Crear un archivo `languine.lock` para rastrear los estados de traducción
-
-El archivo de bloqueo ayuda a Languine a identificar qué traducciones necesitan actualizaciones cuando tu contenido fuente cambia. Asegúrate de comprometer este archivo en tu repositorio.
-
----
-
-## Próximos Pasos
-
-Ahora que tienes Languine configurado, puedes:
-- Agregar más idiomas en tu archivo `languine.json`
-- Integrar Languine en tu pipeline de CI/CD
-- Usar nuestra API para traducciones programáticas
-
-Consulta nuestras otras guías para aprender más sobre las características avanzadas de Languine.
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/es/react-email.mdx b/apps/web/src/markdown/docs/es/react-email.mdx
deleted file mode 100644
index 8bc09f3e..00000000
--- a/apps/web/src/markdown/docs/es/react-email.mdx
+++ /dev/null
@@ -1,41 +0,0 @@
-# React Email
-
-Languine admite plantillas de correo electrónico de React, lo que te permite gestionar traducciones para tus plantillas de correo electrónico construidas con React Email. Esta integración maneja tanto el contenido de texto como los atributos HTML, preservando la estructura del componente React.
-
----
-
-## Configuración
-
-Primero, asegúrate de tener un archivo de configuración languine.json en la raíz de tu proyecto. Aquí tienes un ejemplo:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "react-email": {
-      "include": ["emails/[locale]/*.tsx"]
-    }
-  }
-}
-```
-
-## Traducción
-
-Con tu configuración lista, ejecuta:
-
-```bash
-npx languine@latest translate
-```
-
-Cuando ejecutes este comando, Languine:
-
-- Cargará tus plantillas de correo electrónico de React de origen (por ejemplo, emails/en/*.tsx)
-- Detectará cualquier cadena de traducción nueva o modificada
-- Generará traducciones para tus idiomas de destino
-- Creará o actualizará las plantillas de correo electrónico en el idioma de destino (por ejemplo, emails/sv/*.tsx)
-- Preservará la estructura del componente React y las props
-- Mantendrá el formato y el estilo HTML
-- Manejará la interpolación y el contenido dinámico
diff --git a/apps/web/src/markdown/docs/es/ts.mdx b/apps/web/src/markdown/docs/es/ts.mdx
deleted file mode 100644
index 86c3e4fc..00000000
--- a/apps/web/src/markdown/docs/es/ts.mdx
+++ /dev/null
@@ -1,42 +0,0 @@
-# TypeScript
-
-Languine admite archivos de localización de TypeScript con total seguridad de tipo. Este formato amplía el soporte de JavaScript con características específicas de TypeScript y capacidades de generación de tipos.
-
----
-
-## Configuración
-
-Primero, asegúrate de tener un archivo de configuración languine.json en la raíz de tu proyecto. Aquí tienes un ejemplo:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "ts": {
-      "include": ["src/locales/[locale].ts"]
-    }
-  }
-}
-```
-
-## Traducción
-
-Con tu configuración lista, ejecuta:
-
-```bash
-npx languine@latest translate
-```
-
-Cuando ejecutes este comando, Languine:
-
-- Cargará tus archivos de TypeScript fuente (por ejemplo, src/locales/en.ts)
-- Detectará cualquier cadena de traducción nueva o modificada
-- Generará traducciones para tus idiomas de destino
-- Creará o actualizará los archivos de idioma de destino (por ejemplo, src/locales/sv.ts)
-- Preservará las anotaciones de tipo y las interfaces
-- Manejará objetos anidados con tipado adecuado
-- Mantendrá el formato del código y los comentarios de documentación
-- Soportará tipos literales y tipos de unión
diff --git a/apps/web/src/markdown/docs/es/xcode-stringsdict.mdx b/apps/web/src/markdown/docs/es/xcode-stringsdict.mdx
deleted file mode 100644
index 43db02f0..00000000
--- a/apps/web/src/markdown/docs/es/xcode-stringsdict.mdx
+++ /dev/null
@@ -1,44 +0,0 @@
-# Xcode Stringsdict
-
-Languine admite el formato Stringsdict de Xcode, utilizado para reglas de pluralización complejas en aplicaciones de iOS y macOS. Este formato maneja formas plurales, sustituciones de variables y reglas de pluralización específicas del idioma.
-
----
-
-## Configuración
-
-Primero, asegúrate de tener un archivo de configuración languine.json en la raíz de tu proyecto. Aquí tienes un ejemplo:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "stringsdict": {
-      "include": ["MyApp/Localizable.stringsdict"]
-    }
-  }
-}
-```
-
-## Traducción
-
-Con tu configuración lista, ejecuta:
-
-```bash
-npx languine@latest translate
-```
-
-Cuando ejecutes este comando, Languine:
-
-- Cargará tus archivos Stringsdict
-- Detectará cualquier regla plural nueva o modificada
-- Generará traducciones para tus idiomas de destino
-- Actualizará los archivos Stringsdict con nuevas traducciones
-- Manejará reglas plurales complejas para cada idioma
-- Mantendrá las sustituciones de variables
-- Preservará la estructura del diccionario
-- Soportará formas plurales específicas del idioma
-- Validará la consistencia de las reglas plurales
-- Mantendrá los especificadores de formato
diff --git a/apps/web/src/markdown/docs/es/xcode-xcstrings.mdx b/apps/web/src/markdown/docs/es/xcode-xcstrings.mdx
deleted file mode 100644
index 733ba081..00000000
--- a/apps/web/src/markdown/docs/es/xcode-xcstrings.mdx
+++ /dev/null
@@ -1,44 +0,0 @@
-# Cadenas de Xcode (XCStrings)
-
-Languine admite el formato XCStrings de Xcode, el formato de localización moderno para aplicaciones de iOS y macOS. Este formato maneja catálogos de cadenas con soporte para variaciones, pluralización y comentarios de desarrolladores.
-
----
-
-## Configuración
-
-Primero, asegúrate de tener un archivo de configuración languine.json en la raíz de tu proyecto. Aquí tienes un ejemplo:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "xcstrings": {
-      "include": ["MyApp/Localizable.xcstrings"]
-    }
-  }
-}
-```
-
-## Traducción
-
-Con tu configuración lista, ejecuta:
-
-```bash
-npx languine@latest translate
-```
-
-Cuando ejecutes este comando, Languine:
-
-- Cargará tu catálogo de XCStrings
-- Detectará cualquier cadena nueva o modificada
-- Generará traducciones para tus idiomas de destino
-- Actualizará el catálogo de cadenas con nuevas traducciones
-- Preservará las variaciones de cadenas y las reglas de pluralización
-- Mantendrá los comentarios y el contexto del desarrollador
-- Manejará sustituciones de variables
-- Soportará cadenas adaptativas
-- Mantendrá los especificadores de formato
-- Validará la estructura del catálogo de cadenas
diff --git a/apps/web/src/markdown/docs/es/xliff.mdx b/apps/web/src/markdown/docs/es/xliff.mdx
deleted file mode 100644
index 8bd91372..00000000
--- a/apps/web/src/markdown/docs/es/xliff.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# XLIFF
-
-Languine admite XLIFF (Formato de Intercambio de Archivos de Localización XML), un formato basado en XML diseñado para intercambiar datos de localización. Este formato se utiliza ampliamente en flujos de trabajo de traducción profesional y es compatible con las versiones XLIFF 1.2 y 2.0.
-
----
-
-## Configuración
-
-Primero, asegúrate de tener un archivo de configuración languine.json en la raíz de tu proyecto. Aquí tienes un ejemplo:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "xliff": {
-      "include": ["locales/[locale].xlf"]
-    }
-  }
-}
-```
-
-## Traducción
-
-Con tu configuración lista, ejecuta:
-
-```bash
-npx languine@latest translate
-```
-
-Cuando ejecutes este comando, Languine:
-
-- Cargará tu archivo XLIFF de origen (por ejemplo, locales/en.xlf)
-- Detectará cualquier unidad de traducción nueva o modificada
-- Generará traducciones para tus idiomas de destino
-- Creará o actualizará los archivos XLIFF del idioma de destino (por ejemplo, locales/sv.xlf)
-- Preservará notas, información de contexto y atributos de estado
-- Mantendrá la compatibilidad con herramientas de CAT (Traducción Asistida por Computadora)
diff --git a/apps/web/src/markdown/docs/es/xml.mdx b/apps/web/src/markdown/docs/es/xml.mdx
deleted file mode 100644
index 3165e0b6..00000000
--- a/apps/web/src/markdown/docs/es/xml.mdx
+++ /dev/null
@@ -1,44 +0,0 @@
-# XML
-
-Languine admite la localización de archivos XML, adecuada para varios archivos de configuración y contenido basados en XML. Este formato maneja estructuras XML complejas mientras preserva el formato y los atributos.
-
----
-
-## Configuración
-
-Primero, asegúrate de tener un archivo de configuración languine.json en la raíz de tu proyecto. Aquí tienes un ejemplo:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "xml": {
-      "include": ["resources/[locale]/*.xml"]
-    }
-  }
-}
-```
-
-## Traducción
-
-Con tu configuración lista, ejecuta:
-
-```bash
-npx languine@latest translate
-```
-
-Cuando ejecutes este comando, Languine:
-
-- Cargará tus archivos XML de origen (por ejemplo, resources/en/*.xml)
-- Detectará cualquier contenido nuevo o modificado
-- Generará traducciones para tus idiomas de destino
-- Creará o actualizará los archivos de idioma de destino (por ejemplo, resources/sv/*.xml)
-- Preservará la estructura y el formato XML
-- Manejará las traducciones de atributos
-- Mantendrá las secciones CDATA
-- Conservará los comentarios XML
-- Soportará los espacios de nombres XML
-- Validará la estructura XML
diff --git a/apps/web/src/markdown/docs/es/yaml.mdx b/apps/web/src/markdown/docs/es/yaml.mdx
deleted file mode 100644
index 9a5cef90..00000000
--- a/apps/web/src/markdown/docs/es/yaml.mdx
+++ /dev/null
@@ -1,39 +0,0 @@
-# YAML
-
-Languine admite archivos YAML como formato de origen, que se utiliza comúnmente en Ruby on Rails, Laravel y otros frameworks. Este formato admite estructuras anidadas, arreglos y tipos de datos complejos.
-
----
-
-## Configuración
-
-Primero, asegúrate de tener un archivo de configuración languine.json en la raíz de tu proyecto. Aquí tienes un ejemplo:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "yaml": {
-      "include": ["config/locales/[locale].yml"]
-    }
-  }
-}
-```
-
-## Traducción
-
-Con tu configuración lista, ejecuta:
-
-```bash
-npx languine@latest translate
-```
-
-Cuando ejecutes este comando, Languine:
-
-- Cargará tu archivo YAML de origen (por ejemplo, config/locales/en.yml)
-- Detectará cualquier cadena de traducción nueva o modificada
-- Generará traducciones para tus idiomas de destino
-- Creará o actualizará los archivos YAML del idioma de destino (por ejemplo, config/locales/sv.yml)
-- Preservará las estructuras anidadas y el formato
diff --git a/apps/web/src/markdown/docs/fi/android.mdx b/apps/web/src/markdown/docs/fi/android.mdx
deleted file mode 100644
index 769b6d30..00000000
--- a/apps/web/src/markdown/docs/fi/android.mdx
+++ /dev/null
@@ -1,39 +0,0 @@
-# Android
-
-Languine tukee Androidin merkkiresursseja (strings.xml) lähdeformaatina, käsitellen monikoita, merkkitaulukkoja ja muotoiltuja merkkijonoja. Tämä formaatti on standarditapa hallita käännöksiä Android-sovelluksissa.
-
----
-
-## Asetusten määrittäminen
-
-Ensinnäkin varmista, että sinulla on languine.json -konfiguraatiotiedosto projektisi juurihakemistossa. Tässä on esimerkki:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "android": {
-      "include": ["app/src/main/res/values-[locale]/strings.xml"]
-    }
-  }
-}
-```
-
-## Kääntäminen
-
-Kun konfiguraatiosi on asetettu, suorita:
-
-```bash
-npx languine@latest translate
-```
-
-Kun suoritat tämän komennon, Languine:
-
-- Lataa lähde strings.xml -tiedostosi (esim. values/strings.xml)
-- Havaitsee kaikki uudet tai muokatut käännösmerkkijonot
-- Luo käännöksiä kohdekielillesi
-- Luo tai päivittää kohdekielen XML-tiedostot (esim. values-sv/strings.xml, values-de/strings.xml, values-fr/strings.xml)
-- Säilyttää kaikki olemassa olevat merkkitaulukot ja monikoiden muotoilut
diff --git a/apps/web/src/markdown/docs/fi/arb.mdx b/apps/web/src/markdown/docs/fi/arb.mdx
deleted file mode 100644
index 5a9a11ff..00000000
--- a/apps/web/src/markdown/docs/fi/arb.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# ARB (Sovellusresurssipaketti)
-
-Languine tukee ARB-tiedostoja, jotka ovat Flutter-sovellusten standardi lokalisointimuoto. Tämä muoto käsittelee monikkomuotoja, paikkamerkkejä ja valintailmaisuja säilyttäen yhteensopivuuden Flutterin intl-paketin kanssa.
-
----
-
-## Asetusten määrittäminen
-
-Varmista ensin, että sinulla on languine.json -konfigurointitiedosto projektisi juurihakemistossa. Tässä on esimerkki:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "arb": {
-      "include": ["lib/l10n/intl_[locale].arb"]
-    }
-  }
-}
-```
-
-## Kääntäminen
-
-Kun konfiguraatiosi on asetettu, suorita:
-
-```bash
-npx languine@latest translate
-```
-
-Kun suoritat tämän komennon, Languine:
-
-- Lataa lähde ARB-tiedostosi (esim. lib/l10n/intl_en.arb)
-- Tunnistaa kaikki uudet tai muokatut käännöstekstit
-- Tuottaa käännöksiä kohdekielillesi
-- Luo tai päivittää kohdekielen ARB-tiedostoja (esim. lib/l10n/intl_sv.arb)
-- Säilyttää metatiedot, paikkamerkit ja monikko/valintailmaukset
-
diff --git a/apps/web/src/markdown/docs/fi/authentication.mdx b/apps/web/src/markdown/docs/fi/authentication.mdx
deleted file mode 100644
index e168843f..00000000
--- a/apps/web/src/markdown/docs/fi/authentication.mdx
+++ /dev/null
@@ -1,48 +0,0 @@
-# Varmennus
-
-Languinen käyttämiseksi sinun on vahvistettava henkilöllisyytesi meidän moottorimme kanssa, aloittaminen vie vain muutaman sekunnin.
-
----
-
-## Kirjaudu sisään
-
-Voit kirjautua suoraan [Languine Dashboard](https://languine.ai/login) -sivustolle tai suorittaa seuraavan komennon:
-
-```bash title="Terminal"
-npx languine@latest auth login
-```
-
-
-Jos sinulla on jo tili, kirjaudut automaattisesti sisään ja istunto tallennetaan koneellesi.
-
----
-
-## Kirjaudu ulos
-
-Voit kirjautua ulos suorittamalla seuraavan komennon:
-
-```bash title="Terminal"
-npx languine@latest auth logout
-```
-
----
-
-## Käyttäjäistunto
-
-Voit tarkistaa, oletko kirjautunut sisään suorittamalla seuraavan komennon:
-
-```bash title="Terminal"
-npx languine@latest auth whoami
-```
-
----
-
-
-# Ympäristömuuttujat
-
-Voit asettaa seuraavat ympäristömuuttujat Languinen konfiguroimiseksi:
-
-- `LANGUINE_API_KEY`: API-avain, jota käytetään vahvistamiseen.
-- `LANGUINE_PROJECT_ID`: Projektin ID, jota käytetään projektille.
-
-Löydät ne [Languine Dashboard](https://languine.ai/login) -sivustolta.
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/fi/biome.mdx b/apps/web/src/markdown/docs/fi/biome.mdx
deleted file mode 100644
index 782a1ec5..00000000
--- a/apps/web/src/markdown/docs/fi/biome.mdx
+++ /dev/null
@@ -1,24 +0,0 @@
-# Biomi
-
-Languine voi työskennellä yhdessä [Biomin](https://biomejs.dev/) kanssa varmistaakseen, että käännöstiedostosi ovat johdonmukaisesti muotoiltuja. Tämä on erityisen hyödyllistä työskennellessäsi JSON-käännöstiedostojen kanssa, jotka tarvitsevat johdonmukaisen tyylin koko projektisi ajan.
-
-## Käyttö Languinen kanssa
-
-Suositeltu tapa käyttää Biomia Languinen kanssa on muotoilla käännöstiedostosi niiden luomisen jälkeen. Voit asettaa tämän `package.json`-tiedostossasi:
-
-```json title="package.json"
-{
-  "scripts": {
-    "translate": "languine translate",
-    "format": "biome format \"locales/**/*.json\"",
-    "translate:format": "npm run translate && npm run format"
-  }
-}
-```
-
-Nyt voit:
-- Suorittaa `npm run translate` vain käännösten luomiseksi
-- Suorittaa `npm run format` vain olemassa olevien käännöstiedostojen muotoilemiseksi
-- Suorittaa `npm run translate:format` luodaksesi käännöksiä ja muotoillaksesi ne peräkkäin
-
-Tämä kokoonpano varmistaa, että käännöstiedostosi on muotoiltu johdonmukaisesti 2-välin sisennystä käyttäen ja enintään 80 merkin rivileveyden mukaan.
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/fi/ci.mdx b/apps/web/src/markdown/docs/fi/ci.mdx
deleted file mode 100644
index 36767e2c..00000000
--- a/apps/web/src/markdown/docs/fi/ci.mdx
+++ /dev/null
@@ -1,96 +0,0 @@
-# CI/CD
-
-Languine tarjoaa CI/CD-integraation auttaakseen sinua kääntämään sovelluksesi.
-
----
-
-## Kuinka se toimii
-
-CI/CD-työnkulku Languinessa seuraa jäsenneltyä prosessia käännöspäivitysten automatisoimiseksi sovelluksessasi:
-
-### 1. Toiminnan aloitus
-- Työnkulku alkaa, kun toiminto laukaistaan
-- Määrittää tarvittavat Git-asetukset ja tunnistetiedot
-
-### 2. Languine-moottorin käsittely
-- Languine-moottori käsittelee sovelluksesi sisältöä
-- Hoitaa käännöstehtävät määritettyjen asetusten avulla
-
-### 3. Muutosten havaitseminen
-Järjestelmä tarkistaa mahdolliset käännösmuutokset ja seuraa yhtä kahta polkua:
-
-**Kun muutoksia löytyy:**
-- Muutokset tallennetaan repositorioon
-- Muutokset työnnetään määritettyyn haaraan
-- Pull Request (PR) luodaan
-
-**Kun muutoksia ei löydy:**
-- Työnkulku päättyy ilman PR:n luomista
-
-### 4. Pull Requestin luominen
-Kun muutoksia havaitaan, Pull Request luodaan seuraavilla:
-
-**PR-sisältö:**
-- Selkeä otsikko, joka osoittaa käännöspäivitykset
-- Yksityiskohtainen kuvaus muutoksista
-- Laadunvarmistusvahvistukset
-- Ohjeet tarkastusta varten
-- Linkit dokumentaatioon ja tukeen
-
-**PR-kuvaus sisältää:**
-- Yhteenveto käännöspäivityksistä
-- Lista siitä, mitä on muuttunut (päivitetyt käännökset, terminologian johdonmukaisuus)
-- Seuraavat vaiheet tarkastajille
-- Linkit dokumentaatioon ja tukiresursseihin
-
----
-
-## Työnkulku Kaavio
-
-<div className="flex flex-col items-center justify-center p-4 h-[400px] sm:h-[500px] md:h-[650px]">
-  <pre
-    className="p-4 text-sm leading-5 mb-4 scale-[0.5] sm:scale-[0.65] md:scale-90 transform-gpu"
-    style={{
-      fontFamily: "monospace",
-      whiteSpace: "pre",
-      textAlign: "left",
-    }}
-  >
-    {`
-                    ┌─────────────────────┐
-                    │   Toiminta alkaa    │
-                    └──────────┬──────────┘
-                               │
-                    ┌──────────▼──────────┐
-                    │    Määritä Git &    │
-                    │    Tunnistetiedot   │
-                    └──────────┬──────────┘
-                               │
-┌─────────────────────────────────────────────────────────┐
-│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-│░░░░░░░░░░░░░░░░░░░░ Languine-moottori ░░░░░░░░░░░░░░░░░░░░│
-│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-└─────────────────────────────────────────────────────────┘
-                               │
-                    ┌──────────▼──────────┐
-                    │   Tarkista muutokset │───────┐
-                    └──────────┬──────────┘       │
-                               │                  │
-                               │ [Muutoksia]      │ [Ei muutoksia]
-                               │                  │
-                    ┌──────────▼──────────┐       │
-                    │   Tallenna & Työnnä  │       │
-                    └──────────┬──────────┘       │
-                               │                  │
-                    ┌──────────▼──────────┐       │
-                    │    Luo PR           │       │
-                    └──────────┬──────────┘       │
-                               │                  │
-                    ┌──────────▼──────────┐       │
-                    │        Valmis        │◄──────┘
-                    └─────────────────────┘
-`}
-  </pre>
-</div>
-
-Työnkulku on suunniteltu automatisoiduksi, mutta se sallii silti ihmisten tarkastuksen ja laadunvalvonnan ennen muutosten yhdistämistä koodipohjaasi. Se ylläpitää versionhallinnan parhaita käytäntöjä ja varmistaa, että käännökset on asianmukaisesti seurattu ja dokumentoitu Git-historiassa.
diff --git a/apps/web/src/markdown/docs/fi/cli.mdx b/apps/web/src/markdown/docs/fi/cli.mdx
deleted file mode 100644
index c0d68255..00000000
--- a/apps/web/src/markdown/docs/fi/cli.mdx
+++ /dev/null
@@ -1,65 +0,0 @@
-# CLI
-
-Languine tarjoaa CLI:n, joka auttaa sinua kääntämään sovelluksesi.
-
----
-
-## Komentojen Yhteenveto
-
-### Käännä
-
-`translate`-komentoa käytetään sovelluksesi kääntämiseen.
-
-```bash title="Terminal"
-    npx languine@latest translate
-```
-
----
-
-### Alusta
-
-`init`-komentoa käytetään uuden Languine-projektin alustamiseen.
-
-```bash title="Terminal"
-    npx languine@latest init
-```
-
----
-
-### Tunnista
-
-`auth`-komentoa käytetään tunnistautumiseen Languinelle.
-
-```bash title="Terminal"
-    npx languine@latest auth
-```
-
----
-
-### Synkronoi
-
-`sync`-komentoa käytetään sovelluksesi synkronoimiseen Languinen kanssa.
-
-```bash title="Terminal"
-    npx languine@latest sync
-```
-
----
-
-### Paikalliset Lisää
-
-`locale`-komentoa käytetään sovelluksesi paikallisten hallintaan.
-
-```bash title="Terminal"
-    npx languine@latest locale add pt,fr
-```
-
----
-
-### Paikalliset Poista
-
-`locale remove`-komentoa käytetään paikallisen poistamiseen sovelluksestasi.
-
-```bash title="Terminal"
-    npx languine@latest locale remove pt,fr
-```
diff --git a/apps/web/src/markdown/docs/fi/configuration.mdx b/apps/web/src/markdown/docs/fi/configuration.mdx
deleted file mode 100644
index 940fa016..00000000
--- a/apps/web/src/markdown/docs/fi/configuration.mdx
+++ /dev/null
@@ -1,180 +0,0 @@
-# Konfigurointi
-
-Languine käyttää JSON-konfigurointitiedostoa (languine.json) hallitakseen käännöksesi asetuksia. Tämä tiedosto määrittelee lähde- ja kohdekielet sekä käännettävät tiedostot.
-
----
-
-## Peruskonfigurointi
-
-Tässä on perusesimerkki molemmissa muodoissa:
-
-```json title="languine.json"
-{
-  "locale": {
-    "source": "en",
-    "targets": ["es", "fr", "de"]
-  },
-  "files": {
-    "json": {
-      "include": ["locales/[locale].json"]
-    }
-  }
-}
-```
-
-Käydään läpi konfigurointitiedoston eri osiot.
-
----
-
-## Paikalliskonfigurointi
-
-Paikallisosio määrittelee käännöskielet:
-
-- source: Pääasiallinen kielesi sisällön luomiseen (esim. "en" englanniksi)
-- targets: Taulukko kielistä, joihin haluat kääntää (esim. ["es", "fr", "de"] espanjaksi, ranskaksi ja saksaksi)
-
-Languine tukee laajaa valikoimaa kielikoodeja, mukaan lukien:
-- Yksinkertaiset koodit: en, es, fr, de
-- Aluekohtaiset koodit: pt-BR, zh-CN, zh-TW
-
-## Tiedostokonfigurointi
-
-Tiedostot-osio määrittelee, mitkä tiedostot Languinen tulisi kääntää. Voit määrittää useita tiedostotyyppejä ja -malleja:
-
----
-
-### JSON-tiedostot
-```json
-files: {
-  json: {
-    include: ["locales/[locale].json"],
-  },
-}
-```
-
----
-
-### Markdown/MDX-tiedostot
-```json
-files: {
-  md: {
-    include: ["docs/[locale]/*.md"],
-  },
-  mdx: {
-    include: ["blog/[locale]/*.mdx"],
-  },
-}
-```
-
----
-
-### Mobiilialustatiedostot
-
-iOS:lle (Xcode):
-```json
-files: {
-  "xcode-xcstrings": {
-    include: ["Example/Localizable.xcstrings"],
-  },
-  // Tai perinteisille .strings-tiedostoille
-  "xcode-strings": {
-    include: ["Example/[locale].lproj/Localizable.strings"],
-  },
-}
-```
-
----
-
-Androidille:
-```json
-files: {
-  android: {
-    include: ["locales/[locale].xml"],
-  },
-}
-```
-
----
-
-### Muut muodot
-
-Tässä on täydellinen luettelo Languinen tukemista tiedostomuodoista:
-
-- [JSON](/docs/json) - Standardit JSON-käännöstiedostot
-- [YAML](/docs/yaml) - YAML-käännöstiedostot
-- [Properties](/docs/properties) - Java properties -tiedostot
-- [Android](/docs/android) - Android XML -resurssitiedostot
-- [iOS](/docs/ios) - iOS-lokalisointitiedostot
-- [iOS Stringsdict](/docs/xcode-stringsdict) - iOS monikkomuotoiset tiedostot
-- [iOS XCStrings](/docs/xcode-xcstrings) - Modernit Xcode-merkkiluettelot
-- [Markdown](/docs/md) - Dokumentaatiotiedostot
-- [MDX](/docs/mdx) - Dokumentaatio JSX:llä
-- [HTML](/docs/html) - HTML-tiedostot
-- [JavaScript](/docs/js) - JavaScript-tiedostot
-- [TypeScript](/docs/ts) - TypeScript-tiedostot
-- [Gettext PO](/docs/po) - GetText-käännöstiedostot
-- [XLIFF](/docs/xliff) - XML-lokalisointivaihtoehtotiedostomuoto
-- [CSV](/docs/csv) - Taulukkolaskentapohjaiset käännökset
-- [XML](/docs/xml) - XML-resurssitiedostot
-- [Flutter ARB](/docs/arb) - Sovelluksen resurssikokoelmatiedostot
-
----
-
-## Tiedostomallit
-
-[Tiedostomallin] paikallismuuttuja korvataan automaattisesti oikealla kielikoodilla käännöksen aikana. Esimerkiksi:
-
-- locales/[locale].json muuttuu:
-  - locales/en.json
-  - locales/es.json
-  - locales/fr.json
-
-Voit sisällyttää useita malleja jokaiselle tiedostotyypille ja käyttää glob-malleja:
-```json
-files: {
-  json: {
-    include: [
-      "src/locales/[locale].json",
-      "src/components/[locale]/*.json"
-    ],
-  },
-}
-```
-
----
-
-## Projektitunnus (valinnainen)
-
-Jos käytät Languinen pilvipalveluja, voit sisällyttää projektitunnuksesi konfigurointiin:
-
-```json
-{
-  "projectId": "prj_your_project_id",
-  "locale": {
-    // ... paikalliskonfigurointi
-  },
-  files: {
-    // ... tiedostokonfigurointi
-  },
-}
-```
-
----
-
-## Käännöksen tilan seuranta
-
-Languine luo ja ylläpitää automaattisesti languine.lock-tiedostoa käännöksesi tilan seuraamiseksi. Tämä tiedosto:
-
-- Seuraa, mikä sisältö on käännetty
-- Auttaa tunnistamaan, mitä on päivitettävä, kun lähdesisältö muuttuu
-- Tulisi sitoa versionhallintajärjestelmääsi
-
-Sinun ei tarvitse muokata lukitustiedostoa manuaalisesti - Languine hallitsee sitä automaattisesti, kun suoritat käännöskomentoja.
-
-## Parhaat käytännöt
-
-1. **Versionhallinta**: Sitoudu aina sekä languine.json että languine.lock repositorioon
-2. **Tiedostojen järjestäminen**: Pidä käännöstiedostosi järjestettyinä johdonmukaisessa hakemistorakenteessa
-3. **Kielikoodit**: Käytä standardeja kielikoodeja varmistaaksesi yhteensopivuuden
-4. **Mallit**: Käytä erityisiä sisällyttämismalleja välttääksesi tarpeettomien tiedostojen kääntämisen
-5. **Projektitunnus**: Pidä projektitunnuksesi turvassa, äläkä jaa sitä julkisesti, jos käytät pilvipalveluja, käytä sen sijaan `LANGUINE_PROJECT_ID` ympäristömuuttujaa.
diff --git a/apps/web/src/markdown/docs/fi/csv.mdx b/apps/web/src/markdown/docs/fi/csv.mdx
deleted file mode 100644
index 458d06bc..00000000
--- a/apps/web/src/markdown/docs/fi/csv.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# CSV
-
-Languine tukee CSV (pilkuilla erotettu arvot) tiedostoja yksinkertaista käännöshallintoa varten. Tämä formaatti on ihanteellinen taulukkolaskentapohjaisille työnkuluilla ja helppoon integrointiin ulkoisten käännöstyökalujen kanssa.
-
----
-
-## Asetusten määrittäminen
-
-Ensinnäkin varmista, että sinulla on languine.json -konfiguraatiotiedosto projektisi juurihakemistossa. Tässä on esimerkki:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "csv": {
-      "include": ["translations/[locale].csv"]
-    }
-  }
-}
-```
-
-## Kääntäminen
-
-Kun konfiguraatiosi on asetettu, suorita:
-
-```bash
-npx languine@latest translate
-```
-
-Kun suoritat tämän komennon, Languine:
-
-- Lataa lähde CSV-tiedostosi (esim. translations/en.csv)
-- Havaitsee kaikki uudet tai muokatut käännöstekstit
-- Tuottaa käännöksiä kohdekielille
-- Luo tai päivittää kohdekielen CSV-tiedostot (esim. translations/sv.csv)
-- Säilyttää sarake-rakenteen ja muotoilun
-- Säilyttää kaikki lisämetatietosarakkeet
diff --git a/apps/web/src/markdown/docs/fi/expo.mdx b/apps/web/src/markdown/docs/fi/expo.mdx
deleted file mode 100644
index ba7941ad..00000000
--- a/apps/web/src/markdown/docs/fi/expo.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# Expo
-
-Languine tukee Expo-lokalisointia, integroiden saumattomasti Expon i18n-järjestelmään. Tämä formaatti toimii sekä JavaScript- että TypeScript-projekteissa, tukien sisäkkäisiä rakenteita ja monikkomuotoja.
-
----
-
-## Asetusten määrittäminen
-
-Ensinnäkin, varmista, että sinulla on languine.json -konfiguraatiotiedosto projektisi juurihakemistossa. Tässä on esimerkki:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "expo": {
-      "include": ["assets/locales/[locale].json"]
-    }
-  }
-}
-```
-
-## Kääntäminen
-
-Kun konfiguraatiosi on asetettu, suorita:
-
-```bash
-npx languine@latest translate
-```
-
-Kun suoritat tämän komennon, Languine:
-
-- Lataa lähdekäännöstiedostosi (esim. assets/locales/en.json)
-- Tunnistaa kaikki uudet tai muokatut käännöstekstit
-- Generoi käännökset kohdekielillesi
-- Luo tai päivittää kohdekielitiedostot (esim. assets/locales/sv.json)
-- Säilyttää sisäkkäisen rakenteen ja monikkomuotojen säännöt
-- Ylläpitää yhteensopivuutta expo-localizationin kanssa
diff --git a/apps/web/src/markdown/docs/fi/github-actions.mdx b/apps/web/src/markdown/docs/fi/github-actions.mdx
deleted file mode 100644
index aae2674a..00000000
--- a/apps/web/src/markdown/docs/fi/github-actions.mdx
+++ /dev/null
@@ -1,147 +0,0 @@
-# GitHub Actions
-
-GitHub-toiminnolla voit helposti kääntää koodiasi yksinkertaisesti työntämällä koodisi repositorioon, jolloin GitHub-toiminto kääntää uudet avaimet, luo pull-pyynnön tai sitoo muutoksesi.
-Tämä säästää sinulta paljon aikaa ja vaivannäköä samalla kun säilyttää korkean laadun käännöksissä.
-
----
-
-## Kuinka se toimii
-
-
-
-<div className="flex flex-col items-center justify-center p-4 mb-8 h-[400px] sm:h-[500px] md:h-[650px]">
-        <pre
-          className="p-4 text-sm leading-5 scale-[0.5] sm:scale-[0.65] md:scale-90 transform-gpu"
-          style={{
-            fontFamily: "monospace",
-            whiteSpace: "pre",
-            textAlign: "left",
-          }}
-        >
-          {`
-                                  ┌───────────────┐
-                                  │   Git Push    │
-                                  └───────────────┘
-                                          │
-                                          ▼
-             ┌─────────────────────────────────────────────────────────┐
-             │░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-             │░░░░░░░░░░░░░░░░░░░░ Languine Engine ░░░░░░░░░░░░░░░░░░░░│
-             │░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-             └─────────────────────────────────────────────────────────┘
-                                          │
-                                          ▼
-                                          │
-            ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┼ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─
-           │                              │                              │
-           ▼                              ▼                              ▼
- ╔═══════════════════╗          ╔═══════════════════╗          ╔═══════════════════╗
- ║                   ║          ║                   ║          ║                   ║
- ║      Englanti     ║          ║      Espanja      ║          ║      Japani      ║
- ║    Käännös       ║          ║    Käännös       ║          ║     Käännös      ║
- ║                   ║          ║                   ║          ║                   ║
- ╚═══════════════════╝          ╚═══════════════════╝          ╚═══════════════════╝
-           │                              │                              │
-           └──────────────────────────────┼──────────────────────────────┘
-                                          ▼
-                                  ┌───────────────┐
-                                  │     Yhdistä    │
-                                  │ Pull-pyyntö    │
-                                  └───────────────┘
-                                          │
-                                          ▼
-                              ┌─────────────────────┐
-                              │      Valmis         │
-                              │      (Käynnistä)    │
-                              └─────────────────────┘
-`}
-        </pre>
-      </div>
-
----
-
-## Asennus
-
-Käyttääksesi Languine GitHub-toimintoa repositoriossasi, sinun on:
-
-1. Määritettävä repositoriosi salaisuudet Languine-tunnuksillasi
-2. Luotava työnkulku-tiedosto repositoriosi
-
-### Repositorion salaisuuksien määrittäminen
-
-Lisää seuraavat salaisuudet repositoriosi asetuksiin (Asetukset > Salaisuudet ja muuttujat > Toiminnot):
-
-- `LANGUINE_API_KEY`: Languine API-avaimesi
-- `LANGUINE_PROJECT_ID`: Languine projektitunnuksesi
-
-Voit löytää nämä arvot Languine-hallintapaneelista Projektin asetukset -kohdasta.
-
-
-
-### Ympäristömuuttujat
-
-GitHub-toiminto käyttää seuraavia ympäristömuuttujia:
-- `LANGUINE_API_KEY` (Pakollinen): Languine API-avaimesi todennusta varten
-- `LANGUINE_PROJECT_ID` (Pakollinen): Languine projektitunnuksesi 
-- `GITHUB_TOKEN` (Pakollinen): GitHubin automaattisesti tarjoama, käytetään PR:ien luomiseen
-
-### Esimerkkityönkulku
-
-Luo uusi tiedosto .github/workflows/languine.yml repositoriosi seuraavalla sisällöllä:
-
-```ts title=".github/workflows/release.yml"
-name: Julkaise verkkosivusto
-
-on:
-  push:
-    branches:
-      - '**'
-    paths:
-      - apps/web/**
-
-jobs:
-  translate:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-      pull-requests: write
-    steps:
-      - uses: actions/checkout@v4
-      
-      - name: Languine-toiminto
-        uses: languine/languine-action@v1
-        env:
-           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          api-key: ${{ secrets.LANGUINE_API_KEY }}
-          project-id: ${{ secrets.LANGUINE_PROJECT_ID }}
-```
- 
- Tämä työnkulku:
-- Suoritetaan, kun koodia työntetään päähaaraan
-- Suoritetaan, kun pull-pyyntöjä tehdään päähaaraan
-- Voidaan käynnistää manuaalisesti Toiminnot-välilehdeltä
-- Tarkistaa koodisi ja suorittaa Languine-käännösprosessin
-- Luo pull-pyynnön kaikista uusista käännöksistä (konfiguroitavissa)
-
-#### Työhakemiston vaihtoehto
-
-`working-directory`-vaihtoehto mahdollistaa sen määrittämisen, missä käännöstiedostosi sijaitsevat. Tämä on erityisen hyödyllistä monorepoissa, joissa käännöksesi voivat olla tietyssä pakettikansiossa tai sovelluskansiossa. Esimerkiksi:
-
-#### Pull-pyyntö -vaihtoehto (tulossa pian)
-
-`create-pull-request`-vaihtoehto hallitsee, luoko toiminto pull-pyynnön muutoksista vai sitooko se ne suoraan haaraan:
-
-```typescript title=".github/workflows/languine.yml"
-with:
-  create-pull-request: true # luo pull-pyyntö muutoksista
-```
-
-Kun se on asetettu `true`, toiminto:
-- Luo uuden haara muutoksista
-- Luo pull-pyynnön tarkistettavaksi
-- Lisää asianmukaiset tarrat ja kuvauksen
-
-Kun se on asetettu `false` (oletus), toiminto:
-- Sitoo muutokset suoraan nykyiseen haaraan
-- Työntää muutokset ilman pull-pyynnön luomista
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/fi/html.mdx b/apps/web/src/markdown/docs/fi/html.mdx
deleted file mode 100644
index a9218140..00000000
--- a/apps/web/src/markdown/docs/fi/html.mdx
+++ /dev/null
@@ -1,41 +0,0 @@
-# HTML
-
-Languine tukee HTML-tiedostojen lokalisointia, käsitellen sekä tekstisisältöä että attribuutteja. Tämä formaatti on ihanteellinen staattisille verkkosivustoille ja HTML-malleille, ja se tukee HTML-rakenteen ja muotoilun säilyttämistä.
-
----
-
-## Asetusten määrittäminen
-
-Ensinnäkin varmista, että sinulla on languine.json -konfiguraatiotiedosto projektisi juurihakemistossa. Tässä on esimerkki:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "html": {
-      "include": ["pages/[locale]/*.html"]
-    }
-  }
-}
-```
-
-## Kääntäminen
-
-Kun konfiguraatiosi on asetettu, suorita:
-
-```bash
-npx languine@latest translate
-```
-
-Kun suoritat tämän komennon, Languine:
-
-- Lataa lähde-HTML-tiedostosi (esim. pages/en/*.html)
-- Havaitsee kaikki uudet tai muokatut käännöstekstit
-- Tuottaa käännöksiä kohdekielillesi
-- Luo tai päivittää kohdekielen HTML-tiedostot (esim. pages/sv/*.html)
-- Säilyttää HTML-rakenteen ja muotoilun
-- Käsittelee määritettyjen attribuuttien käännöksiä
-- Säilyttää kommentit ja erityiset tagit
diff --git a/apps/web/src/markdown/docs/fi/introduction.mdx b/apps/web/src/markdown/docs/fi/introduction.mdx
deleted file mode 100644
index 454efe63..00000000
--- a/apps/web/src/markdown/docs/fi/introduction.mdx
+++ /dev/null
@@ -1,34 +0,0 @@
-# Johdanto
-
-Languine automatisoi lokalisoinnin kehitysprosessissasi ja putkistossasi, varmistaen, että käännökset eivät koskaan hidasta sinua.
-
-Muunna sovelluksesi monikieliseksi kokemukseksi minuuteissa. Kun keskityt ominaisuuksien rakentamiseen, Languine hoitaa kaikki käännöksiin liittyvät asiat tarkkuudella ja luotettavuudella.
-
----
-
-## Avainominaisuudet
-
-- **Käännösmootori**: Hyödynnä kontekstitietoisia, korkealaatuisia käännöksiä, jotka säilyttävät brändisi äänen
-- **CI/CD-integraatio**: Automatisoi käännöspäivitykset olemassa olevien työnkulkujesi kautta
-- **Muodot**: Käsittele mitä tahansa tiedostomuotoa laajennettavan jäsentäjämme avulla
-- **Avoin lähdekoodi**: Pääsy, tarkastelu ja osallistuminen koodipohjaamme GitHubissa - ei mustia laatikoita, täydellinen läpinäkyvyys
-
----
-
-## Kuinka se toimii
-
-1. **Nopea asennus**: Aloita minuuteissa intuitiivisen CLI:mme ja ohjatun aloituksen avulla
-2. **Yksinkertainen konfigurointi**: Määritä käännöstarpeesi selkeällä ja suoraviivaisella konfigurointitiedostolla
-3. **Automaattinen käännös**: Työnnä sisältösi kerran ja anna Languinen hoitaa käännös automaattisesti kaikkiin kohdekieliin
-
----
-
-## Aloittaminen
-
-Aloita lokalisointimatkasi [Nopea opas](/docs/quickstart) -oppaamme avulla - saat ensimmäiset käännöksesi toimimaan minuuteissa.
-
-Tutustu kattavaan dokumentaatioomme hallitaksesi Languinen ominaisuuksia:
-
-- [Konfigurointi](/docs/configuration) - Määritä Languine projektisi tarpeiden mukaan
-- [CLI](/docs/cli) - Hallitse tehokasta komentoriviliittymäämme
-- [Github-toiminnot](/docs/github-actions) - Automatisoi käännökset GitHub-toimintomme avulla
diff --git a/apps/web/src/markdown/docs/fi/ios.mdx b/apps/web/src/markdown/docs/fi/ios.mdx
deleted file mode 100644
index 9b4568de..00000000
--- a/apps/web/src/markdown/docs/fi/ios.mdx
+++ /dev/null
@@ -1,39 +0,0 @@
-# iOS
-
-Languine tukee iOS Localizable.strings -tiedostoja, joka on standardi lokalisointimuoto iOS-sovelluksille. Tämä muoto käsittelee perus avain-arvo merkkijonoja ja tukee kommentteja, jotka tarjoavat kontekstia kääntäjille.
-
----
-
-## Asetusten määrittäminen
-
-Ensinnäkin varmista, että sinulla on languine.json -konfiguraatiotiedosto projektisi juurihakemistossa. Tässä esimerkki:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "ios": {
-      "include": ["[locale].lproj/Localizable.strings"]
-    }
-  }
-}
-```
-
-## Kääntäminen
-
-Kun konfiguraatiosi on asetettu, suorita:
-
-```bash
-npx languine@latest translate
-```
-
-Kun suoritat tämän komennon, Languine:
-
-- Lataa lähde Localizable.strings -tiedostosi (esim. en.lproj/Localizable.strings)
-- Tunnistaa kaikki uudet tai muokatut käännösmerkkijonot
-- Luo käännöksiä kohdekielillesi
-- Luo tai päivittää kohdekielitiedostot (esim. sv.lproj/Localizable.strings)
-- Säilyttää kaikki olemassa olevat kommentit ja muotoilut
diff --git a/apps/web/src/markdown/docs/fi/js.mdx b/apps/web/src/markdown/docs/fi/js.mdx
deleted file mode 100644
index 37befb74..00000000
--- a/apps/web/src/markdown/docs/fi/js.mdx
+++ /dev/null
@@ -1,42 +0,0 @@
-# JavaScript
-
-Languine tukee JavaScript/TypeScript-lokalisointitiedostoja, jotka ovat täydellisiä moderneille verkkosovelluksille. Tämä formaatti käsittelee sekä objektikirjallisuutta että moduulivientiä, tukien sisäkkäisiä rakenteita ja dynaamista sisältöä.
-
----
-
-## Asetusten määrittäminen
-
-Ensinnäkin varmista, että sinulla on languine.json -konfiguraatiotiedosto projektisi juurihakemistossa. Tässä on esimerkki:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "js": {
-      "include": ["src/locales/[locale].js"]
-    }
-  }
-}
-```
-
-## Kääntäminen
-
-Kun konfiguraatiosi on asetettu, suorita:
-
-```bash
-npx languine@latest translate
-```
-
-Kun suoritat tämän komennon, Languine:
-
-- Lataa lähde JavaScript-tiedostosi (esim. src/locales/en.js)
-- Havaitsee kaikki uudet tai muokatut käännöstekstit
-- Luo käännöksiä kohdekielillesi
-- Luo tai päivittää kohdekielitiedostot (esim. src/locales/sv.js)
-- Säilyttää moduulirakenteen ja viennit
-- Käsittelee sisäkkäisiä objekteja ja taulukoita
-- Säilyttää koodin muotoilun ja kommentit
-- Luo TypeScript-tyyppejä, jos se on käytössä
diff --git a/apps/web/src/markdown/docs/fi/json.mdx b/apps/web/src/markdown/docs/fi/json.mdx
deleted file mode 100644
index 3e59cc63..00000000
--- a/apps/web/src/markdown/docs/fi/json.mdx
+++ /dev/null
@@ -1,41 +0,0 @@
-# JSON
-
-Languine tukee JSON-tiedostoja lähdeformaatina, jossa on yleiset vaatimukset monikollistamiselle ja interpoloinnille. Tätä formaattia käytetään monissa kehysratkaisuissa, kuten React, Vue, Ruby on Rails ja muissa.
-
-
----
-
-
-## Asetusten määrittäminen
-
-Varmista ensin, että sinulla on languine.json -konfiguraatiotiedosto projektisi juurihakemistossa. Tässä on esimerkki:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "json": {
-      "include": ["locales/[locale].json"]
-    }
-  }
-}
-
-```
-
-## Kääntäminen
-
-Kun konfiguraatiosi on asetettu, suorita:
-
-```bash
-npx languine@latest translate
-```
-
-Kun suoritat tämän komennon, Languine:
-
-- Lataa lähde JSON-tiedostosi (esim. locales/en.json)
-- Havaitsee kaikki uudet tai muokatut käännöstekstit
-- Luo käännöksiä kohdekielille
-- Luo tai päivittää kohdekielen JSON-tiedostot (esim. locales/sv.json, locales/de.json, locales/fr.json)
diff --git a/apps/web/src/markdown/docs/fi/md.mdx b/apps/web/src/markdown/docs/fi/md.mdx
deleted file mode 100644
index 1cfc16df..00000000
--- a/apps/web/src/markdown/docs/fi/md.mdx
+++ /dev/null
@@ -1,43 +0,0 @@
-# Markdown
-
-Languine tukee Markdown-tiedostojen lokalisointia, mikä on täydellinen dokumentaatiota, blogikirjoituksia ja sisältöpainotteisia sivustoja varten. Tämä formaatti säilyttää Markdown-syntaksin samalla kun se kääntää sisältöä, mukaan lukien etumateriatuki.
-
----
-
-## Asetusten määrittäminen
-
-Ensinnäkin varmista, että sinulla on languine.json -konfiguraatiotiedosto projektisi juurihakemistossa. Tässä on esimerkki:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "md": {
-      "include": ["content/[locale]/**/*.md"]
-    }
-  }
-}
-```
-
-## Kääntäminen
-
-Kun konfiguraatiosi on asetettu, suorita:
-
-```bash
-npx languine@latest translate
-```
-
-Kun suoritat tämän komennon, Languine:
-
-- Lataa lähde Markdown-tiedostosi (esim. content/en/*.md)
-- Havaitsee kaikki uudet tai muokatut sisällöt
-- Generoi käännökset kohdekielillesi
-- Luo tai päivittää kohdekielitiedostot (esim. content/sv/*.md)
-- Säilyttää Markdown-muotoilun ja rakenteen
-- Käsittelee etumaterian käännöksiä
-- Säilyttää linkit ja viittaukset
-- Pitää koodilohkot kääntämättöminä
-- Säilyttää HTML:n Markdownin sisällä
diff --git a/apps/web/src/markdown/docs/fi/mdx.mdx b/apps/web/src/markdown/docs/fi/mdx.mdx
deleted file mode 100644
index 534b8f0a..00000000
--- a/apps/web/src/markdown/docs/fi/mdx.mdx
+++ /dev/null
@@ -1,43 +0,0 @@
-# Markdown (MDX)
-
-Languine tukee Markdown (MDX) -tiedostojen lokalisointia, mikä on täydellinen dokumentaatioon, blogikirjoituksiin ja sisältöpainotteisiin sivustoihin. Tämä formaatti säilyttää Markdown-syntaksin samalla kun se kääntää sisältöä, mukaan lukien front matter -tuki.
-
----
-
-## Asetusten määrittäminen
-
-Ensinnäkin varmista, että sinulla on languine.json -konfigurointitiedosto projektisi juurihakemistossa. Tässä on esimerkki:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "mdx": {
-      "include": ["content/[locale]/**/*.mdx"]
-    }
-  }
-}
-```
-
-## Kääntäminen
-
-Kun konfiguraatiosi on asetettu, suorita:
-
-```bash
-npx languine@latest translate
-```
-
-Kun suoritat tämän komennon, Languine:
-
-- Lataa lähde Markdown -tiedostosi (esim. content/en/*.mdx)
-- Havaitsee kaikki uudet tai muokatut sisällöt
-- Luo käännöksiä kohdekielillesi
-- Luo tai päivittää kohdekielitiedostot (esim. content/sv/*.mdx)
-- Säilyttää Markdown-muotoilun ja rakenteen
-- Käsittelee front matter -käännöksiä
-- Säilyttää linkit ja viittaukset
-- Pitää koodilohkot kääntämättöminä
-- Säilyttää HTML:n Markdownin sisällä
diff --git a/apps/web/src/markdown/docs/fi/overrides.mdx b/apps/web/src/markdown/docs/fi/overrides.mdx
deleted file mode 100644
index 14846dd1..00000000
--- a/apps/web/src/markdown/docs/fi/overrides.mdx
+++ /dev/null
@@ -1,7 +0,0 @@
-# Ohitukset
-
-Languine antaa sinun ohittaa käännökset tietyille avaimille. Tämä on hyödyllistä, kun haluat varmistaa, että tietty käännös käytetään tietylle avaimelle riippumatta oletuskäännöksestä.
-
-## Kuinka se toimii
-
-Ohjauspaneelissa voit luoda ohituksia tietyille avaimille. Voit myös luoda ohituksia tietyille kielille.
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/fi/po.mdx b/apps/web/src/markdown/docs/fi/po.mdx
deleted file mode 100644
index 8ccf814a..00000000
--- a/apps/web/src/markdown/docs/fi/po.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# PO (Gettext)
-
-Languine tukee PO-tiedostoja, laajasti käytettyä Gettext-lokalisointimuotoa. Tämä muoto on suosittu monissa ohjelmointiympäristöissä, erityisesti Linux-sovelluksissa ja PHP-kehyksissä, tarjoten tukea konteksteille, monikolle ja kääntäjäkommenteille.
-
----
-
-## Asetusten määrittäminen
-
-Ensinnäkin varmista, että sinulla on languine.json -konfiguraatiotiedosto projektisi juurihakemistossa. Tässä on esimerkki:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "po": {
-      "include": ["locales/[locale]/LC_MESSAGES/messages.po"]
-    }
-  }
-}
-```
-
-## Kääntäminen
-
-Kun konfiguraatiosi on asetettu, suorita:
-
-```bash
-npx languine@latest translate
-```
-
-Kun suoritat tämän komennon, Languine:
-
-- Lataa lähde PO-tiedostosi (esim. locales/en/LC_MESSAGES/messages.po)
-- Havaitsee kaikki uudet tai muokatut käännöstekstit
-- Generoi käännökset kohdekielillesi
-- Luo tai päivittää kohdekielen PO-tiedostot (esim. locales/sv/LC_MESSAGES/messages.po)
-- Säilyttää metatiedot, kontekstit ja monikkomuodot
-- Pitää yllä kääntäjäkommentteja ja viittausinfoa
diff --git a/apps/web/src/markdown/docs/fi/prettier.mdx b/apps/web/src/markdown/docs/fi/prettier.mdx
deleted file mode 100644
index ab0200bd..00000000
--- a/apps/web/src/markdown/docs/fi/prettier.mdx
+++ /dev/null
@@ -1,22 +0,0 @@
-# Prettier
-
-Languine voi toimia yhdessä [Prettierin](https://prettier.io/) kanssa varmistaakseen, että käännöstiedostosi ovat johdonmukaisesti muotoiltuja. Tämä on erityisen hyödyllistä työskenneltäessä JSON-käännöstiedostojen kanssa, jotka tarvitsevat johdonmukaisen tyylin koko projektin ajan.
-
-## Käyttö Languinen kanssa
-
-Suositeltu tapa käyttää Prettieriä Languinen kanssa on muotoilla käännöstiedostosi niiden luomisen jälkeen. Voit asettaa tämän `package.json`-tiedostossasi:
-
-```json title="package.json"
-{
-  "scripts": {
-    "translate": "languine translate",
-    "format": "prettier --write \"locales/**/*.json\"",
-    "translate:format": "npm run translate && npm run format"
-  }
-}
-```
-
-Nyt voit:
-- Suorittaa `npm run translate` vain käännösten luomiseksi
-- Suorittaa `npm run format` vain olemassa olevien käännöstiedostojen muotoilemiseksi
-- Suorittaa `npm run translate:format` luodaksesi käännökset ja muotoillaksesi ne peräkkäin
diff --git a/apps/web/src/markdown/docs/fi/properties.mdx b/apps/web/src/markdown/docs/fi/properties.mdx
deleted file mode 100644
index 5d625709..00000000
--- a/apps/web/src/markdown/docs/fi/properties.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# Ominaisuudet
-
-Languine tukee Java Properties -tiedostoja, jotka ovat standardi lokalisointimuoto Java-sovelluksille. Tämä muoto käsittelee Unicode-escapeja ja tukee sekä avain-arvo-pareja että kommentteja.
-
----
-
-## Asetusten määrittäminen
-
-Ensinnäkin varmista, että sinulla on languine.json -konfigurointitiedosto projektisi juurihakemistossa. Tässä on esimerkki:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "properties": {
-      "include": ["src/main/resources/messages_[locale].properties"]
-    }
-  }
-}
-```
-
-## Kääntäminen
-
-Kun konfiguraatiosi on asetettu, suorita:
-
-```bash
-npx languine@latest translate
-```
-
-Kun suoritat tämän komennon, Languine:
-
-- Lataa lähde properties -tiedostosi (esim. messages_en.properties)
-- Havaitsee kaikki uudet tai muokatut käännöstekstit
-- Tuottaa käännöksiä kohdekielillesi
-- Luo tai päivittää kohdekielen properties -tiedostot (esim. messages_sv.properties)
-- Käsittelee Unicode-escapeja automaattisesti
-- Säilyttää kommentit ja muotoilun
diff --git a/apps/web/src/markdown/docs/fi/quickstart.mdx b/apps/web/src/markdown/docs/fi/quickstart.mdx
deleted file mode 100644
index 5e0b4dd0..00000000
--- a/apps/web/src/markdown/docs/fi/quickstart.mdx
+++ /dev/null
@@ -1,65 +0,0 @@
-# Aloitusopas
-
-Aloita asentamalla Languine.
-
-Suorita sitten seuraava komento Languinen alustamiseksi.
-
-```bash title="Pääte"
-npx languine@latest init
-```
-
-Seuraa ohjeita projektisi määrittämiseksi.
-
----
-
-## Ensimmäinen Käännös
-
-Nyt olet valmis kääntämään koodiasi.
-
-Aloita lisäämällä avain lähdetiedostoosi, esimerkiksi jos valitset käyttää `en.json`-tiedostoa lähdetiedostona, lisää siihen avain.
-
-```json title="src/locales/en.json"
-{
-  "welcome": "Tervetuloa sovellukseemme!",
-  "user": {
-    "greeting": "Hei, {{name}}!",
-    "profile": {
-      "title": "Profiilisi",
-      "edit": "Muokkaa profiilia"
-    }
-  },
-  "notifications": {
-    "messages": "Sinulla on {{count}} uutta viestiä.",
-    "empty": "Ei uusia ilmoituksia."
-  }
-}
-
-```
-
----
-
-## Käännä
-
-Suorita seuraava komento kääntääksesi sisältösi:
-
-```bash title="Pääte"
-npx languine@latest translate
-```
-
-## Tämä tekee:
-1. Luo käännöstiedostot jokaiselle kohdekielelle
-2. Tuottaa korkealaatuisia käännöksiä Languine-moottorilla
-3. Luo `languine.lock`-tiedoston käännösten tilan seuraamiseksi
-
-Lukitustiedosto auttaa Languinea tunnistamaan, mitkä käännökset tarvitsevat päivityksiä, kun lähdesisältösi muuttuu. Varmista, että sitoudut tähän tiedostoon repositoriossasi.
-
----
-
-## Seuraavat Askeleet
-
-Nyt kun sinulla on Languine asetettuna, voit:
-- Lisätä lisää kieliä `languine.json`-tiedostoosi
-- Integroi Languine CI/CD-putkeesi
-- Käytä APIamme ohjelmallisiin käännöksiin
-
-Tutustu muihin oppaisiin saadaksesi lisätietoja Languinen edistyneistä ominaisuuksista.
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/fi/react-email.mdx b/apps/web/src/markdown/docs/fi/react-email.mdx
deleted file mode 100644
index 964d2591..00000000
--- a/apps/web/src/markdown/docs/fi/react-email.mdx
+++ /dev/null
@@ -1,41 +0,0 @@
-# React Email
-
-Languine tukee React Email -mallipohjia, mikä mahdollistaa sähköpostimallien käännösten hallinnan, jotka on rakennettu React Emailin avulla. Tämä integraatio käsittelee sekä tekstisisältöä että HTML-attribuutteja säilyttäen React-komponentin rakenteen.
-
----
-
-## Asetusten määrittäminen
-
-Varmista ensin, että sinulla on languine.json -konfiguraatiotiedosto projektisi juurihakemistossa. Tässä on esimerkki:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "react-email": {
-      "include": ["emails/[locale]/*.tsx"]
-    }
-  }
-}
-```
-
-## Kääntäminen
-
-Kun konfiguraatiosi on asetettu, suorita:
-
-```bash
-npx languine@latest translate
-```
-
-Kun suoritat tämän komennon, Languine:
-
-- Lataa lähde React Email -mallipohjasi (esim. emails/en/*.tsx)
-- Havaitsee kaikki uudet tai muokatut käännöstekstit
-- Generoi käännökset kohdekielillesi
-- Luo tai päivittää kohdekieliset sähköpostimallit (esim. emails/sv/*.tsx)
-- Säilyttää React-komponentin rakenteen ja propsit
-- Ylläpitää HTML-muotoilua ja tyylittelyä
-- Käsittelee interpolointia ja dynaamista sisältöä
diff --git a/apps/web/src/markdown/docs/fi/ts.mdx b/apps/web/src/markdown/docs/fi/ts.mdx
deleted file mode 100644
index b906c7e0..00000000
--- a/apps/web/src/markdown/docs/fi/ts.mdx
+++ /dev/null
@@ -1,42 +0,0 @@
-# TypeScript
-
-Languine tukee TypeScript-lokalisointitiedostoja täydellä tyyppiturvalla. Tämä formaatti laajentaa JavaScript-tukea lisätyyppikohtaisilla ominaisuuksilla ja tyyppigenerointikyvyillä.
-
----
-
-## Asetusten määrittäminen
-
-Ensinnäkin varmista, että sinulla on languine.json -konfiguraatiotiedosto projektisi juurihakemistossa. Tässä on esimerkki:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "ts": {
-      "include": ["src/locales/[locale].ts"]
-    }
-  }
-}
-```
-
-## Kääntäminen
-
-Kun konfiguraatiosi on asetettu, suorita:
-
-```bash
-npx languine@latest translate
-```
-
-Kun suoritat tämän komennon, Languine:
-
-- Lataa lähde TypeScript-tiedostosi (esim. src/locales/en.ts)
-- Havaitsee kaikki uudet tai muokatut käännöstekstit
-- Generoi käännökset kohdekielillesi
-- Luo tai päivittää kohdekielitiedostot (esim. src/locales/sv.ts)
-- Säilyttää tyyppimerkinnät ja rajapinnat
-- Käsittelee sisäkkäisiä objekteja oikealla tyypityksellä
-- Säilyttää koodin muotoilun ja dokumentaatiokommentit
-- Tukee kirjaimellisia tyyppejä ja yhdistelmätippejä
diff --git a/apps/web/src/markdown/docs/fi/xcode-stringsdict.mdx b/apps/web/src/markdown/docs/fi/xcode-stringsdict.mdx
deleted file mode 100644
index 7893d25f..00000000
--- a/apps/web/src/markdown/docs/fi/xcode-stringsdict.mdx
+++ /dev/null
@@ -1,44 +0,0 @@
-# Xcode Stringsdict
-
-Languine tukee Xcoden Stringsdict-muotoa, jota käytetään monimutkaisissa monikkomuotojen säännöissä iOS- ja macOS-sovelluksissa. Tämä muoto käsittelee monikkomuotoja, muuttujan korvauksia ja kielikohtaisia monikkomuotojen sääntöjä.
-
----
-
-## Asetusten määrittäminen
-
-Ensinnäkin varmista, että sinulla on languine.json -konfiguraatiotiedosto projektisi juurihakemistossa. Tässä on esimerkki:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "stringsdict": {
-      "include": ["MyApp/Localizable.stringsdict"]
-    }
-  }
-}
-```
-
-## Kääntäminen
-
-Kun konfiguraatiosi on asetettu, suorita:
-
-```bash
-npx languine@latest translate
-```
-
-Kun suoritat tämän komennon, Languine:
-
-- Lataa Stringsdict-tiedostosi
-- Havaitsee kaikki uudet tai muokatut monikkomuotojen säännöt
-- Tuottaa käännöksiä kohdekielillesi
-- Päivittää Stringsdict-tiedostot uusilla käännöksillä
-- Käsittelee monimutkaisia monikkomuotojen sääntöjä jokaiselle kielelle
-- Säilyttää muuttujan korvaukset
-- Säilyttää sanakirjan rakenteen
-- Tukee kielikohtaisia monikkomuotoja
-- Vahvistaa monikkomuotojen sääntöjen johdonmukaisuuden
-- Säilyttää muotoilun erottimet
diff --git a/apps/web/src/markdown/docs/fi/xcode-xcstrings.mdx b/apps/web/src/markdown/docs/fi/xcode-xcstrings.mdx
deleted file mode 100644
index 4aeb3f82..00000000
--- a/apps/web/src/markdown/docs/fi/xcode-xcstrings.mdx
+++ /dev/null
@@ -1,44 +0,0 @@
-# Xcode Strings (XCStrings)
-
-Languine tukee Xcoden XCStrings-muotoa, joka on moderni lokalisointimuoto iOS- ja macOS-sovelluksille. Tämä muoto käsittelee merkkijonoluetteloita, joissa on tuki variaatioille, monikolle ja kehittäjäkommenteille.
-
----
-
-## Asetusten määrittäminen
-
-Ensinnäkin varmista, että sinulla on languine.json -konfiguraatiotiedosto projektisi juurihakemistossa. Tässä on esimerkki:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "xcstrings": {
-      "include": ["MyApp/Localizable.xcstrings"]
-    }
-  }
-}
-```
-
-## Kääntäminen
-
-Kun konfiguraatiosi on asetettu, suorita:
-
-```bash
-npx languine@latest translate
-```
-
-Kun suoritat tämän komennon, Languine:
-
-- Lataa XCStrings-luettelosi
-- Havaitsee kaikki uudet tai muokatut merkkijonot
-- Tuottaa käännöksiä kohdekielillesi
-- Päivittää merkkijonoluetteloa uusilla käännöksillä
-- Säilyttää merkkijonovariaatiot ja monikkosäännöt
-- Pitää kehittäjäkommentit ja kontekstin
-- Käsittelee muuttujan korvauksia
-- Tukee mukautuvia merkkijonoja
-- Säilyttää muotoilun määrittäjät
-- Vahvistaa merkkijonoluettelon rakennetta
diff --git a/apps/web/src/markdown/docs/fi/xliff.mdx b/apps/web/src/markdown/docs/fi/xliff.mdx
deleted file mode 100644
index 354bd62f..00000000
--- a/apps/web/src/markdown/docs/fi/xliff.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# XLIFF
-
-Languine tukee XLIFF:ia (XML Localization Interchange File Format), XML-pohjaista formaattia, joka on suunniteltu lokalisointidatan vaihtamiseen. Tätä formaattia käytetään laajalti ammatillisissa käännösprosesseissa, ja se tukee sekä XLIFF 1.2 että 2.0 versioita.
-
----
-
-## Asetusten määrittäminen
-
-Ensinnäkin varmista, että sinulla on languine.json -konfiguraatiotiedosto projektin juurihakemistossa. Tässä on esimerkki:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "xliff": {
-      "include": ["locales/[locale].xlf"]
-    }
-  }
-}
-```
-
-## Kääntäminen
-
-Kun konfiguraatiosi on asetettu, suorita:
-
-```bash
-npx languine@latest translate
-```
-
-Kun suoritat tämän komennon, Languine:
-
-- Lataa lähde XLIFF-tiedostosi (esim. locales/en.xlf)
-- Havaitsee kaikki uudet tai muokatut käännösyksiköt
-- Tuottaa käännöksiä kohdekielillesi
-- Luo tai päivittää kohdekielen XLIFF-tiedostot (esim. locales/sv.xlf)
-- Säilyttää muistiinpanot, kontekstitiedot ja tilatiedot
-- Ylläpitää yhteensopivuutta CAT (tietokoneavusteinen käännös) -työkalujen kanssa
diff --git a/apps/web/src/markdown/docs/fi/xml.mdx b/apps/web/src/markdown/docs/fi/xml.mdx
deleted file mode 100644
index 5b058892..00000000
--- a/apps/web/src/markdown/docs/fi/xml.mdx
+++ /dev/null
@@ -1,44 +0,0 @@
-# XML
-
-Languine tukee XML-tiedostojen lokalisointia, joka soveltuu erilaisille XML-pohjaisille konfiguraatio- ja sisältötiedostoille. Tämä formaatti käsittelee monimutkaisia XML-rakenteita säilyttäen muotoilun ja attribuutit.
-
----
-
-## Asetusten määrittäminen
-
-Ensinnäkin varmista, että sinulla on languine.json-konfiguraatiotiedosto projektisi juurihakemistossa. Tässä on esimerkki:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "xml": {
-      "include": ["resources/[locale]/*.xml"]
-    }
-  }
-}
-```
-
-## Kääntäminen
-
-Kun konfiguraatiosi on asetettu, suorita:
-
-```bash
-npx languine@latest translate
-```
-
-Kun suoritat tämän komennon, Languine:
-
-- Lataa lähde-XML-tiedostosi (esim. resources/en/*.xml)
-- Havaitsee kaikki uudet tai muokatut sisällöt
-- Tuottaa käännöksiä kohdekielillesi
-- Luo tai päivittää kohdekielitiedostot (esim. resources/sv/*.xml)
-- Säilyttää XML-rakenteen ja muotoilun
-- Käsittelee attribuuttikäännöksiä
-- Säilyttää CDATA-osuudet
-- Pitää XML-kommentit
-- Tukee XML-nimiavaruuksia
-- Vahvistaa XML-rakenteen
diff --git a/apps/web/src/markdown/docs/fi/yaml.mdx b/apps/web/src/markdown/docs/fi/yaml.mdx
deleted file mode 100644
index 0cd8dd7e..00000000
--- a/apps/web/src/markdown/docs/fi/yaml.mdx
+++ /dev/null
@@ -1,39 +0,0 @@
-# YAML
-
-Languine tukee YAML-tiedostoja lähdeformaatina, jota käytetään yleisesti Ruby on Railsissa, Laravelissa ja muissa kehyksissä. Tämä formaatti tukee sisäkkäisiä rakenteita, taulukoita ja monimutkaisia tietotyyppejä.
-
----
-
-## Asetusten määrittäminen
-
-Ensinnäkin varmista, että sinulla on languine.json -konfigurointitiedosto projektisi juurihakemistossa. Tässä on esimerkki:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "yaml": {
-      "include": ["config/locales/[locale].yml"]
-    }
-  }
-}
-```
-
-## Kääntäminen
-
-Kun konfiguraatiosi on asetettu, suorita:
-
-```bash
-npx languine@latest translate
-```
-
-Kun suoritat tämän komennon, Languine:
-
-- Lataa lähde YAML -tiedostosi (esim. config/locales/en.yml)
-- Havaitsee kaikki uudet tai muokatut käännösmerkkijonot
-- Luo käännöksiä kohdekielillesi
-- Luo tai päivittää kohdekielen YAML -tiedostot (esim. config/locales/sv.yml)
-- Säilyttää sisäkkäiset rakenteet ja muotoilut
diff --git a/apps/web/src/markdown/docs/fr/android.mdx b/apps/web/src/markdown/docs/fr/android.mdx
deleted file mode 100644
index 3b4a94f6..00000000
--- a/apps/web/src/markdown/docs/fr/android.mdx
+++ /dev/null
@@ -1,39 +0,0 @@
-# Android
-
-Languine prend en charge les ressources de chaîne Android (strings.xml) comme format source, gérant les pluriels, les tableaux de chaînes et les chaînes formatées. Ce format est la méthode standard pour gérer les traductions dans les applications Android.
-
----
-
-## Configuration
-
-Tout d'abord, assurez-vous d'avoir un fichier de configuration languine.json à la racine de votre projet. Voici un exemple :
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "android": {
-      "include": ["app/src/main/res/values-[locale]/strings.xml"]
-    }
-  }
-}
-```
-
-## Traduction
-
-Avec votre configuration en place, exécutez :
-
-```bash
-npx languine@latest translate
-```
-
-Lorsque vous exécutez cette commande, Languine va :
-
-- Charger votre fichier source strings.xml (par exemple, values/strings.xml)
-- Détecter toute nouvelle chaîne de traduction ou toute chaîne modifiée
-- Générer des traductions pour vos langues cibles
-- Créer ou mettre à jour les fichiers XML de langue cible (par exemple, values-sv/strings.xml, values-de/strings.xml, values-fr/strings.xml)
-- Préserver tout formatage existant des tableaux de chaînes et des pluriels
diff --git a/apps/web/src/markdown/docs/fr/arb.mdx b/apps/web/src/markdown/docs/fr/arb.mdx
deleted file mode 100644
index 7e727e1e..00000000
--- a/apps/web/src/markdown/docs/fr/arb.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# ARB (Application Resource Bundle)
-
-Languine prend en charge les fichiers ARB, le format de localisation standard pour les applications Flutter. Ce format gère les pluriels, les espaces réservés et les expressions de sélection tout en maintenant la compatibilité avec le package intl de Flutter.
-
----
-
-## Configuration
-
-Tout d'abord, assurez-vous d'avoir un fichier de configuration languine.json à la racine de votre projet. Voici un exemple :
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "arb": {
-      "include": ["lib/l10n/intl_[locale].arb"]
-    }
-  }
-}
-```
-
-## Traduction
-
-Avec votre configuration en place, exécutez :
-
-```bash
-npx languine@latest translate
-```
-
-Lorsque vous exécutez cette commande, Languine va :
-
-- Charger votre fichier ARB source (par exemple, lib/l10n/intl_en.arb)
-- Détecter toutes les chaînes de traduction nouvelles ou modifiées
-- Générer des traductions pour vos langues cibles
-- Créer ou mettre à jour les fichiers ARB de la langue cible (par exemple, lib/l10n/intl_sv.arb)
-- Préserver les métadonnées, les espaces réservés et les expressions de pluriel/sélection
-
diff --git a/apps/web/src/markdown/docs/fr/authentication.mdx b/apps/web/src/markdown/docs/fr/authentication.mdx
deleted file mode 100644
index a589abc9..00000000
--- a/apps/web/src/markdown/docs/fr/authentication.mdx
+++ /dev/null
@@ -1,48 +0,0 @@
-# Authentification
-
-Pour utiliser Languine, vous devez vous authentifier auprès de notre moteur, cela ne prend que quelques secondes pour commencer.
-
----
-
-## Connexion
-
-Vous pouvez vous connecter directement sur le [Tableau de bord Languine](https://languine.ai/login) ou exécuter la commande suivante :
-
-```bash title="Terminal"
-npx languine@latest auth login
-```
-
-
-Si vous avez déjà un compte, vous serez automatiquement connecté et une session sera enregistrée sur votre machine.
-
----
-
-## Déconnexion
-
-Vous pouvez vous déconnecter en exécutant la commande suivante :
-
-```bash title="Terminal"
-npx languine@latest auth logout
-```
-
----
-
-## Session utilisateur
-
-Vous pouvez vérifier si vous êtes connecté en exécutant la commande suivante :
-
-```bash title="Terminal"
-npx languine@latest auth whoami
-```
-
----
-
-
-# Variables d'environnement
-
-Vous pouvez définir les variables d'environnement suivantes pour configurer Languine :
-
-- `LANGUINE_API_KEY` : La clé API à utiliser pour l'authentification.
-- `LANGUINE_PROJECT_ID` : L'ID du projet à utiliser pour le projet.
-
-Vous les trouverez dans le [Tableau de bord Languine](https://languine.ai/login).
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/fr/biome.mdx b/apps/web/src/markdown/docs/fr/biome.mdx
deleted file mode 100644
index b4199ce2..00000000
--- a/apps/web/src/markdown/docs/fr/biome.mdx
+++ /dev/null
@@ -1,24 +0,0 @@
-# Biome
-
-Languine peut travailler avec [Biome](https://biomejs.dev/) pour garantir que vos fichiers de traduction sont formatés de manière cohérente. Cela est particulièrement utile lors de l'utilisation de fichiers de traduction JSON qui doivent maintenir un style uniforme dans votre projet.
-
-## Utilisation avec Languine
-
-La manière recommandée d'utiliser Biome avec Languine est de formater vos fichiers de traduction après leur génération. Vous pouvez configurer cela dans votre `package.json`:
-
-```json title="package.json"
-{
-  "scripts": {
-    "translate": "languine translate",
-    "format": "biome format \"locales/**/*.json\"",
-    "translate:format": "npm run translate && npm run format"
-  }
-}
-```
-
-Maintenant, vous pouvez :
-- Exécuter `npm run translate` pour générer uniquement des traductions
-- Exécuter `npm run format` pour formater uniquement les fichiers de traduction existants
-- Exécuter `npm run translate:format` pour générer des traductions et les formater en séquence
-
-Cette configuration garantira que vos fichiers de traduction sont formatés de manière cohérente avec une indentation de 2 espaces et une largeur maximale de ligne de 80 caractères.
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/fr/ci.mdx b/apps/web/src/markdown/docs/fr/ci.mdx
deleted file mode 100644
index fa2629a8..00000000
--- a/apps/web/src/markdown/docs/fr/ci.mdx
+++ /dev/null
@@ -1,97 +0,0 @@
-# CI/CD
-
-Languine fournit une intégration CI/CD pour vous aider à traduire votre application.
-
----
-
-## Comment ça fonctionne
-
-Le flux de travail CI/CD dans Languine suit un processus structuré pour automatiser les mises à jour de traduction dans votre application :
-
-### 1. Initialisation de l'Action
-- Le flux de travail commence lorsque l'action est déclenchée
-- Configure les paramètres Git et les identifiants nécessaires
-
-### 2. Traitement par le Moteur Languine
-- Le moteur Languine traite le contenu de votre application
-- Gère les tâches de traduction en utilisant les paramètres configurés
-
-### 3. Détection des Changements
-Le système vérifie s'il y a des changements de traduction et suit l'un des deux chemins :
-
-**Lorsque des Changements sont Trouvés :**
-- Les changements sont engagés dans le dépôt
-- Les changements sont poussés vers la branche spécifiée
-- Une Demande de Tirage (PR) est créée
-
-**Lorsque Aucun Changement n'est Trouvé :**
-- Le flux de travail se termine sans créer de PR
-
-### 4. Création de la Demande de Tirage
-Lorsque des changements sont détectés, une Demande de Tirage est créée avec :
-
-**Contenu de la PR :**
-- Titre clair indiquant les mises à jour de traduction
-- Description détaillée des changements
-- Confirmations de contrôle de qualité
-- Instructions pour la révision
-- Liens vers la documentation et le support
-
-**La Description de la PR Comprend :**
-- Résumé des mises à jour de traduction
-- Liste des changements (traductions mises à jour, cohérence terminologique)
-- Prochaines étapes pour les réviseurs
-- Liens vers la documentation et les ressources de support
-
----
-
-## Diagramme de Flux de Travail
-
-<div className="flex flex-col items-center justify-center p-4 h-[400px] sm:h-[500px] md:h-[650px]">
-  <pre
-    className="p-4 text-sm leading-5 mb-4 scale-[0.5] sm:scale-[0.65] md:scale-90 transform-gpu"
-    style={{
-      fontFamily: "monospace",
-      whiteSpace: "pre",
-      textAlign: "left",
-    }}
-  >
-    {`
-                    ┌─────────────────────┐
-                    │   L'action Commence  │
-                    └──────────┬──────────┘
-                               │
-                    ┌──────────▼──────────┐
-                    │    Configuration     │
-                    │    Git & Identifiants│
-                    └──────────┬──────────┘
-                               │
-┌─────────────────────────────────────────────────────────┐
-│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-│░░░░░░░░░░░░░░░░░░░░ Moteur Languine ░░░░░░░░░░░░░░░░░░░░│
-│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-└─────────────────────────────────────────────────────────┘
-                               │
-                    ┌──────────▼──────────┐
-                    │   Vérifier les      │───────┐
-                    │     Changements     │       │
-                    └──────────┬──────────┘       │
-                               │                  │
-                               │ [Changements]    │ [Aucun Changement]
-                               │                  │
-                    ┌──────────▼──────────┐       │
-                    │   Engager & Pousser  │       │
-                    └──────────┬──────────┘       │
-                               │                  │
-                    ┌──────────▼──────────┐       │
-                    │    Créer PR         │       │
-                    └──────────┬──────────┘       │
-                               │                  │
-                    ┌──────────▼──────────┐       │
-                    │        Fait         │◄──────┘
-                    └─────────────────────┘
-`}
-  </pre>
-</div>
-
-Le flux de travail est conçu pour être automatisé tout en permettant une révision humaine et un contrôle de qualité avant que les changements ne soient fusionnés dans votre code source. Il maintient les meilleures pratiques de contrôle de version et garantit que les traductions sont correctement suivies et documentées à travers l'historique Git.
diff --git a/apps/web/src/markdown/docs/fr/cli.mdx b/apps/web/src/markdown/docs/fr/cli.mdx
deleted file mode 100644
index afacd621..00000000
--- a/apps/web/src/markdown/docs/fr/cli.mdx
+++ /dev/null
@@ -1,65 +0,0 @@
-# CLI
-
-Languine fournit une interface en ligne de commande (CLI) pour vous aider à traduire votre application.
-
----
-
-## Vue d'ensemble des commandes
-
-### Traduire
-
-La commande `translate` est utilisée pour traduire votre application.
-
-```bash title="Terminal"
-    npx languine@latest translate
-```
-
----
-
-### Init
-
-La commande `init` est utilisée pour initialiser un nouveau projet Languine.
-
-```bash title="Terminal"
-    npx languine@latest init
-```
-
----
-
-### Auth
-
-La commande `auth` est utilisée pour s'authentifier auprès de Languine.
-
-```bash title="Terminal"
-    npx languine@latest auth
-```
-
----
-
-### Sync
-
-La commande `sync` est utilisée pour synchroniser votre application avec Languine.
-
-```bash title="Terminal"
-    npx languine@latest sync
-```
-
----
-
-### Ajouter une locale
-
-La commande `locale` est utilisée pour gérer les locales de votre application.
-
-```bash title="Terminal"
-    npx languine@latest locale add pt,fr
-```
-
----
-
-### Supprimer une locale
-
-La commande `locale remove` est utilisée pour supprimer une locale de votre application.
-
-```bash title="Terminal"
-    npx languine@latest locale remove pt,fr
-```
diff --git a/apps/web/src/markdown/docs/fr/configuration.mdx b/apps/web/src/markdown/docs/fr/configuration.mdx
deleted file mode 100644
index c1ec1967..00000000
--- a/apps/web/src/markdown/docs/fr/configuration.mdx
+++ /dev/null
@@ -1,180 +0,0 @@
-# Configuration
-
-Languine utilise un fichier de configuration JSON (languine.json) pour gérer votre configuration de traduction. Ce fichier définit vos langues source et cible, ainsi que les fichiers à traduire.
-
----
-
-## Configuration de base
-
-Voici un exemple de base dans les deux formats :
-
-```json title="languine.json"
-{
-  "locale": {
-    "source": "en",
-    "targets": ["es", "fr", "de"]
-  },
-  "files": {
-    "json": {
-      "include": ["locales/[locale].json"]
-    }
-  }
-}
-```
-
-Décomposons les différentes sections du fichier de configuration.
-
----
-
-## Configuration de la locale
-
-La section locale définit vos langues de traduction :
-
-- source : Votre langue principale pour la création de contenu (par exemple, "en" pour l'anglais)
-- targets : Un tableau des langues dans lesquelles vous souhaitez traduire (par exemple, ["es", "fr", "de"] pour l'espagnol, le français et l'allemand)
-
-Languine prend en charge un large éventail de codes de langue, y compris :
-- Codes simples : en, es, fr, de
-- Codes spécifiques à la région : pt-BR, zh-CN, zh-TW
-
-## Configuration des fichiers
-
-La section des fichiers définit quels fichiers Languine doit traduire. Vous pouvez configurer plusieurs types de fichiers et motifs :
-
----
-
-### Fichiers JSON
-```json
-files: {
-  json: {
-    include: ["locales/[locale].json"],
-  },
-}
-```
-
----
-
-### Fichiers Markdown/MDX
-```json
-files: {
-  md: {
-    include: ["docs/[locale]/*.md"],
-  },
-  mdx: {
-    include: ["blog/[locale]/*.mdx"],
-  },
-}
-```
-
----
-
-### Fichiers de plateforme mobile
-
-Pour iOS (Xcode) :
-```json
-files: {
-  "xcode-xcstrings": {
-    include: ["Example/Localizable.xcstrings"],
-  },
-  // Ou pour les fichiers .strings traditionnels
-  "xcode-strings": {
-    include: ["Example/[locale].lproj/Localizable.strings"],
-  },
-}
-```
-
----
-
-Pour Android :
-```json
-files: {
-  android: {
-    include: ["locales/[locale].xml"],
-  },
-}
-```
-
----
-
-### Autres formats
-
-Voici une liste complète des formats de fichiers pris en charge par Languine :
-
-- [JSON](/docs/json) - Fichiers de traduction JSON standard
-- [YAML](/docs/yaml) - Fichiers de traduction YAML
-- [Properties](/docs/properties) - Fichiers de propriétés Java
-- [Android](/docs/android) - Fichiers de ressources XML Android
-- [iOS](/docs/ios) - Fichiers de localisation iOS
-- [iOS Stringsdict](/docs/xcode-stringsdict) - Fichiers de pluralisation iOS
-- [iOS XCStrings](/docs/xcode-xcstrings) - Catalogues de chaînes modernes Xcode
-- [Markdown](/docs/md) - Fichiers de documentation
-- [MDX](/docs/mdx) - Documentation avec JSX
-- [HTML](/docs/html) - Fichiers HTML
-- [JavaScript](/docs/js) - Fichiers JavaScript
-- [TypeScript](/docs/ts) - Fichiers TypeScript
-- [Gettext PO](/docs/po) - Fichiers de traduction GetText
-- [XLIFF](/docs/xliff) - Format de fichier d'échange de localisation XML
-- [CSV](/docs/csv) - Traductions basées sur des tableurs
-- [XML](/docs/xml) - Fichiers de ressources XML
-- [Flutter ARB](/docs/arb) - Fichiers de bundle de ressources d'application
-
----
-
-## Motifs de fichiers
-
-Le placeholder [locale] dans les motifs de fichiers est automatiquement remplacé par le code de langue approprié lors de la traduction. Par exemple :
-
-- locales/[locale].json devient :
-  - locales/en.json
-  - locales/es.json
-  - locales/fr.json
-
-Vous pouvez inclure plusieurs motifs pour chaque type de fichier et utiliser des motifs globaux :
-```json
-files: {
-  json: {
-    include: [
-      "src/locales/[locale].json",
-      "src/components/[locale]/*.json"
-    ],
-  },
-}
-```
-
----
-
-## ID de projet (optionnel)
-
-Si vous utilisez les services cloud de Languine, vous pouvez inclure votre ID de projet dans la configuration :
-
-```json
-{
-  "projectId": "prj_your_project_id",
-  "locale": {
-    // ... configuration de la locale
-  },
-  files: {
-    // ... configuration des fichiers
-  },
-}
-```
-
----
-
-## Suivi de l'état de la traduction
-
-Languine crée et maintient automatiquement un fichier languine.lock pour suivre l'état de vos traductions. Ce fichier :
-
-- Suit quel contenu a été traduit
-- Aide à identifier ce qui doit être mis à jour lorsque le contenu source change
-- Doit être engagé dans votre système de contrôle de version
-
-Vous n'avez pas besoin de modifier manuellement le fichier de verrouillage - Languine le gère automatiquement lorsque vous exécutez des commandes de traduction.
-
-## Meilleures pratiques
-
-1. **Contrôle de version** : Engagez toujours à la fois languine.json et languine.lock dans votre dépôt
-2. **Organisation des fichiers** : Gardez vos fichiers de traduction organisés dans une structure de répertoire cohérente
-3. **Codes de langue** : Utilisez des codes de langue standard pour garantir la compatibilité
-4. **Motifs** : Utilisez des motifs d'inclusion spécifiques pour éviter de traduire des fichiers inutiles
-5. **ID de projet** : Gardez votre ID de projet sécurisé et ne le partagez pas publiquement si vous utilisez des services cloud, utilisez plutôt la variable d'environnement `LANGUINE_PROJECT_ID`.
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/fr/csv.mdx b/apps/web/src/markdown/docs/fr/csv.mdx
deleted file mode 100644
index f493b4d0..00000000
--- a/apps/web/src/markdown/docs/fr/csv.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# CSV
-
-Languine prend en charge les fichiers CSV (Comma-Separated Values) pour une gestion simple des traductions. Ce format est idéal pour les flux de travail basés sur des tableurs et une intégration facile avec des outils de traduction externes.
-
----
-
-## Configuration
-
-Tout d'abord, assurez-vous d'avoir un fichier de configuration languine.json à la racine de votre projet. Voici un exemple :
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "csv": {
-      "include": ["translations/[locale].csv"]
-    }
-  }
-}
-```
-
-## Traduction
-
-Avec votre configuration en place, exécutez :
-
-```bash
-npx languine@latest translate
-```
-
-Lorsque vous exécutez cette commande, Languine va :
-
-- Charger votre fichier CSV source (par exemple, translations/en.csv)
-- Détecter toutes les chaînes de traduction nouvelles ou modifiées
-- Générer des traductions pour vos langues cibles
-- Créer ou mettre à jour les fichiers CSV des langues cibles (par exemple, translations/sv.csv)
-- Maintenir la structure et le format des colonnes
-- Préserver toutes les colonnes de métadonnées supplémentaires
diff --git a/apps/web/src/markdown/docs/fr/expo.mdx b/apps/web/src/markdown/docs/fr/expo.mdx
deleted file mode 100644
index 10ffd05c..00000000
--- a/apps/web/src/markdown/docs/fr/expo.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# Expo
-
-Languine prend en charge la localisation Expo, s'intégrant parfaitement au système i18n d'Expo. Ce format fonctionne avec des projets JavaScript et TypeScript, prenant en charge les structures imbriquées et la pluralisation.
-
----
-
-## Configuration
-
-Tout d'abord, assurez-vous d'avoir un fichier de configuration languine.json à la racine de votre projet. Voici un exemple :
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "expo": {
-      "include": ["assets/locales/[locale].json"]
-    }
-  }
-}
-```
-
-## Traduction
-
-Avec votre configuration en place, exécutez :
-
-```bash
-npx languine@latest translate
-```
-
-Lorsque vous exécutez cette commande, Languine va :
-
-- Charger votre fichier de traduction source (par exemple, assets/locales/en.json)
-- Détecter toutes les chaînes de traduction nouvelles ou modifiées
-- Générer des traductions pour vos langues cibles
-- Créer ou mettre à jour les fichiers de langue cible (par exemple, assets/locales/sv.json)
-- Préserver la structure imbriquée et les règles de pluralisation
-- Maintenir la compatibilité avec expo-localization
diff --git a/apps/web/src/markdown/docs/fr/github-actions.mdx b/apps/web/src/markdown/docs/fr/github-actions.mdx
deleted file mode 100644
index cae98208..00000000
--- a/apps/web/src/markdown/docs/fr/github-actions.mdx
+++ /dev/null
@@ -1,147 +0,0 @@
-# GitHub Actions
-
-Avec l'action GitHub, vous pouvez facilement traduire votre code en poussant simplement votre code dans le dépôt, l'action GitHub traduira alors vos nouvelles clés, créera soit une demande de tirage, soit validera vos modifications.
-Cela vous fait gagner beaucoup de temps et d'efforts tout en maintenant des traductions de haute qualité.
-
----
-
-## Comment ça fonctionne
-
-
-
-<div className="flex flex-col items-center justify-center p-4 mb-8 h-[400px] sm:h-[500px] md:h-[650px]">
-        <pre
-          className="p-4 text-sm leading-5 scale-[0.5] sm:scale-[0.65] md:scale-90 transform-gpu"
-          style={{
-            fontFamily: "monospace",
-            whiteSpace: "pre",
-            textAlign: "left",
-          }}
-        >
-          {`
-                                  ┌───────────────┐
-                                  │   Git Push    │
-                                  └───────────────┘
-                                          │
-                                          ▼
-             ┌─────────────────────────────────────────────────────────┐
-             │░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-             │░░░░░░░░░░░░░░░░░░░░ Moteur Languine ░░░░░░░░░░░░░░░░░░░░│
-             │░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-             └─────────────────────────────────────────────────────────┘
-                                          │
-                                          ▼
-                                          │
-            ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┼ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─
-           │                              │                              │
-           ▼                              ▼                              ▼
- ╔═══════════════════╗          ╔═══════════════════╗          ╔═══════════════════╗
- ║                   ║          ║                   ║          ║                   ║
- ║      Anglais      ║          ║      Espagnol     ║          ║      Japonais     ║
- ║    Traduction     ║          ║    Traduction     ║          ║     Traduction    ║
- ║                   ║          ║                   ║          ║                   ║
- ╚═══════════════════╝          ╚═══════════════════╝          ╚═══════════════════╝
-           │                              │                              │
-           └──────────────────────────────┼──────────────────────────────┘
-                                          ▼
-                                  ┌───────────────┐
-                                  │     Fusionner  │
-                                  │ Demande de tirage │
-                                  └───────────────┘
-                                          │
-                                          ▼
-                              ┌─────────────────────┐
-                              │      Terminé        │
-                              │      (Déployer)     │
-                              └─────────────────────┘
-`}
-        </pre>
-      </div>
-
----
-
-## Installation
-
-Pour utiliser l'action GitHub Languine dans votre dépôt, vous devez :
-
-1. Configurer les secrets de votre dépôt avec vos identifiants Languine
-2. Créer un fichier de workflow dans votre dépôt
-
-### Configuration des Secrets du Dépôt
-
-Ajoutez les secrets suivants dans les paramètres de votre dépôt (Paramètres > Secrets et variables > Actions) :
-
-- `LANGUINE_API_KEY` : Votre clé API Languine
-- `LANGUINE_PROJECT_ID` : Votre ID de projet Languine
-
-Vous pouvez trouver ces valeurs dans votre tableau de bord Languine sous Paramètres du projet.
-
-
-
-### Variables d'Environnement
-
-L'action GitHub utilise les variables d'environnement suivantes :
-- `LANGUINE_API_KEY` (Requis) : Votre clé API Languine pour l'authentification
-- `LANGUINE_PROJECT_ID` (Requis) : Votre ID de projet Languine 
-- `GITHUB_TOKEN` (Requis) : Fournie automatiquement par GitHub, utilisée pour créer des PRs
-
-### Exemple de Workflow
-
-Créez un nouveau fichier .github/workflows/languine.yml dans votre dépôt avec le contenu suivant :
-
-```ts title=".github/workflows/release.yml"
-name: Déployer le site web
-
-on:
-  push:
-    branches:
-      - '**'
-    paths:
-      - apps/web/**
-
-jobs:
-  translate:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-      pull-requests: write
-    steps:
-      - uses: actions/checkout@v4
-      
-      - name: Action Languine
-        uses: languine/languine-action@v1
-        env:
-           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          api-key: ${{ secrets.LANGUINE_API_KEY }}
-          project-id: ${{ secrets.LANGUINE_PROJECT_ID }}
-```
- 
- Ce workflow va :
-- S'exécuter lors des poussées vers la branche principale
-- S'exécuter lors des demandes de tirage vers la branche principale
-- Peut être déclenché manuellement depuis l'onglet Actions
-- Vérifier votre code et exécuter le processus de traduction Languine
-- Créer une demande de tirage avec toutes nouvelles traductions (configurable)
-
-#### Option de Répertoire de Travail
-
-L'option `working-directory` vous permet de spécifier où se trouvent vos fichiers de traduction. Cela est particulièrement utile dans les monorepos où vos traductions peuvent se trouver dans un package ou un répertoire d'application spécifique. Par exemple :
-
-#### Option de Demande de Tirage (bientôt disponible)
-
-L'option `create-pull-request` contrôle si l'action crée une demande de tirage avec les modifications ou les valide directement dans la branche :
-
-```typescript title=".github/workflows/languine.yml"
-with:
-  create-pull-request: true # créer une demande de tirage avec les modifications
-```
-
-Lorsqu'elle est définie sur `true`, l'action va :
-- Créer une nouvelle branche avec les modifications
-- Créer une demande de tirage pour révision
-- Ajouter des étiquettes et une description appropriées
-
-Lorsqu'elle est définie sur `false` (par défaut), l'action va :
-- Valider les modifications directement dans la branche actuelle
-- Pousser les modifications sans créer de demande de tirage
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/fr/html.mdx b/apps/web/src/markdown/docs/fr/html.mdx
deleted file mode 100644
index f062684a..00000000
--- a/apps/web/src/markdown/docs/fr/html.mdx
+++ /dev/null
@@ -1,41 +0,0 @@
-# HTML
-
-Languine prend en charge la localisation des fichiers HTML, gérant à la fois le contenu textuel et les attributs. Ce format est idéal pour les sites web statiques et les modèles HTML, avec un support pour préserver la structure et le formatage HTML.
-
----
-
-## Configuration
-
-Tout d'abord, assurez-vous d'avoir un fichier de configuration languine.json à la racine de votre projet. Voici un exemple :
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "html": {
-      "include": ["pages/[locale]/*.html"]
-    }
-  }
-}
-```
-
-## Traduction
-
-Avec votre configuration en place, exécutez :
-
-```bash
-npx languine@latest translate
-```
-
-Lorsque vous exécutez cette commande, Languine va :
-
-- Charger vos fichiers HTML source (par exemple, pages/en/*.html)
-- Détecter toutes les nouvelles chaînes de traduction ou celles modifiées
-- Générer des traductions pour vos langues cibles
-- Créer ou mettre à jour les fichiers HTML de la langue cible (par exemple, pages/sv/*.html)
-- Préserver la structure et le formatage HTML
-- Gérer les traductions des attributs spécifiés
-- Maintenir les commentaires et les balises spéciales
diff --git a/apps/web/src/markdown/docs/fr/introduction.mdx b/apps/web/src/markdown/docs/fr/introduction.mdx
deleted file mode 100644
index 11d70c6e..00000000
--- a/apps/web/src/markdown/docs/fr/introduction.mdx
+++ /dev/null
@@ -1,34 +0,0 @@
-# Introduction
-
-Languine automatise la localisation dans votre flux de développement et votre pipeline, garantissant que les traductions ne vous ralentissent jamais.
-
-Transformez votre application en une expérience multilingue en quelques minutes. Pendant que vous vous concentrez sur la création de fonctionnalités, Languine gère tous les aspects de la traduction avec précision et fiabilité.
-
----
-
-## Caractéristiques Principales
-
-- **Moteur de Traduction** : Profitez de traductions de haute qualité, conscientes du contexte, qui maintiennent la voix de votre marque
-- **Intégration CI/CD** : Automatisez les mises à jour de traduction via vos flux de travail existants
-- **Formats** : Gérez n'importe quel format de fichier avec notre système de parseur extensible
-- **Open Source** : Accédez, inspectez et contribuez à notre code sur GitHub - pas de boîtes noires, transparence totale
-
----
-
-## Comment Ça Fonctionne
-
-1. **Configuration Rapide** : Commencez en quelques minutes avec notre CLI intuitive et une initialisation guidée
-2. **Configuration Simple** : Définissez vos besoins en traduction avec un fichier de configuration clair et simple
-3. **Traduction Automatisée** : Poussez votre contenu une fois et laissez Languine gérer automatiquement la traduction dans toutes les langues cibles
-
----
-
-## Prise en Main
-
-Commencez votre parcours de localisation avec notre guide [Quickstart](/docs/quickstart) - vous aurez vos premières traductions en quelques minutes.
-
-Explorez notre documentation complète pour maîtriser les capacités de Languine :
-
-- [Configuration](/docs/configuration) - Configurez Languine selon les besoins de votre projet
-- [CLI](/docs/cli) - Maîtrisez notre interface en ligne de commande puissante
-- [Github Actions](/docs/github-actions) - Automatisez les traductions avec notre action Github
diff --git a/apps/web/src/markdown/docs/fr/ios.mdx b/apps/web/src/markdown/docs/fr/ios.mdx
deleted file mode 100644
index 5e18d4d9..00000000
--- a/apps/web/src/markdown/docs/fr/ios.mdx
+++ /dev/null
@@ -1,39 +0,0 @@
-# iOS
-
-Languine prend en charge les fichiers Localizable.strings d'iOS, le format de localisation standard pour les applications iOS. Ce format gère les paires de chaînes clé-valeur de base et prend en charge les commentaires pour fournir un contexte aux traducteurs.
-
----
-
-## Configuration
-
-Tout d'abord, assurez-vous d'avoir un fichier de configuration languine.json à la racine de votre projet. Voici un exemple :
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "ios": {
-      "include": ["[locale].lproj/Localizable.strings"]
-    }
-  }
-}
-```
-
-## Traduction
-
-Avec votre configuration en place, exécutez :
-
-```bash
-npx languine@latest translate
-```
-
-Lorsque vous exécutez cette commande, Languine va :
-
-- Charger votre fichier source Localizable.strings (par exemple, en.lproj/Localizable.strings)
-- Détecter toute nouvelle chaîne de traduction ou toute chaîne modifiée
-- Générer des traductions pour vos langues cibles
-- Créer ou mettre à jour les fichiers de langue cible (par exemple, sv.lproj/Localizable.strings)
-- Préserver tous les commentaires et la mise en forme existants
diff --git a/apps/web/src/markdown/docs/fr/js.mdx b/apps/web/src/markdown/docs/fr/js.mdx
deleted file mode 100644
index 010cd96e..00000000
--- a/apps/web/src/markdown/docs/fr/js.mdx
+++ /dev/null
@@ -1,42 +0,0 @@
-# JavaScript
-
-Languine prend en charge les fichiers de localisation JavaScript/TypeScript, parfaits pour les applications web modernes. Ce format gère à la fois les littéraux d'objet et les exports de module, prenant en charge les structures imbriquées et le contenu dynamique.
-
----
-
-## Configuration
-
-Tout d'abord, assurez-vous d'avoir un fichier de configuration languine.json à la racine de votre projet. Voici un exemple :
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "js": {
-      "include": ["src/locales/[locale].js"]
-    }
-  }
-}
-```
-
-## Traduction
-
-Avec votre configuration en place, exécutez :
-
-```bash
-npx languine@latest translate
-```
-
-Lorsque vous exécutez cette commande, Languine va :
-
-- Charger vos fichiers JavaScript source (par exemple, src/locales/en.js)
-- Détecter toutes les nouvelles chaînes de traduction ou celles modifiées
-- Générer des traductions pour vos langues cibles
-- Créer ou mettre à jour les fichiers de langue cible (par exemple, src/locales/sv.js)
-- Préserver la structure des modules et les exports
-- Gérer les objets et tableaux imbriqués
-- Maintenir le formatage du code et les commentaires
-- Générer des types TypeScript si activé
diff --git a/apps/web/src/markdown/docs/fr/json.mdx b/apps/web/src/markdown/docs/fr/json.mdx
deleted file mode 100644
index d745e427..00000000
--- a/apps/web/src/markdown/docs/fr/json.mdx
+++ /dev/null
@@ -1,41 +0,0 @@
-# JSON
-
-Languine prend en charge les fichiers JSON comme format source avec les exigences courantes pour la pluralisation et l'interpolation. Ce format est utilisé dans de nombreux frameworks comme React, Vue, Ruby on Rails, et plus encore.
-
-
----
-
-
-## Configuration
-
-Tout d'abord, assurez-vous d'avoir un fichier de configuration languine.json à la racine de votre projet. Voici un exemple :
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "json": {
-      "include": ["locales/[locale].json"]
-    }
-  }
-}
-
-```
-
-## Traduction
-
-Avec votre configuration en place, exécutez :
-
-```bash
-npx languine@latest translate
-```
-
-Lorsque vous exécutez cette commande, Languine va :
-
-- Charger votre fichier JSON source (par exemple, locales/en.json)
-- Détecter toute nouvelle chaîne de traduction ou toute chaîne modifiée
-- Générer des traductions pour vos langues cibles
-- Créer ou mettre à jour les fichiers JSON des langues cibles (par exemple, locales/sv.json, locales/de.json, locales/fr.json)
diff --git a/apps/web/src/markdown/docs/fr/md.mdx b/apps/web/src/markdown/docs/fr/md.mdx
deleted file mode 100644
index acdd99e8..00000000
--- a/apps/web/src/markdown/docs/fr/md.mdx
+++ /dev/null
@@ -1,43 +0,0 @@
-# Markdown
-
-Languine prend en charge la localisation des fichiers Markdown, parfait pour la documentation, les articles de blog et les sites riches en contenu. Ce format préserve la syntaxe Markdown tout en traduisant le contenu, y compris le support des métadonnées.
-
----
-
-## Configuration
-
-Tout d'abord, assurez-vous d'avoir un fichier de configuration languine.json à la racine de votre projet. Voici un exemple :
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "md": {
-      "include": ["content/[locale]/**/*.md"]
-    }
-  }
-}
-```
-
-## Traduction
-
-Avec votre configuration en place, exécutez :
-
-```bash
-npx languine@latest translate
-```
-
-Lorsque vous exécutez cette commande, Languine va :
-
-- Charger vos fichiers Markdown source (par exemple, content/en/*.md)
-- Détecter tout nouveau contenu ou contenu modifié
-- Générer des traductions pour vos langues cibles
-- Créer ou mettre à jour les fichiers de langue cible (par exemple, content/sv/*.md)
-- Préserver le formatage et la structure Markdown
-- Gérer les traductions des métadonnées
-- Maintenir les liens et références
-- Garder les blocs de code non traduits
-- Préserver le HTML au sein du Markdown
diff --git a/apps/web/src/markdown/docs/fr/mdx.mdx b/apps/web/src/markdown/docs/fr/mdx.mdx
deleted file mode 100644
index 126c1f96..00000000
--- a/apps/web/src/markdown/docs/fr/mdx.mdx
+++ /dev/null
@@ -1,43 +0,0 @@
-# Markdown (MDX)
-
-Languine prend en charge la localisation des fichiers Markdown (MDX), parfait pour la documentation, les articles de blog et les sites riches en contenu. Ce format préserve la syntaxe Markdown tout en traduisant le contenu, y compris le support des métadonnées.
-
----
-
-## Configuration
-
-Tout d'abord, assurez-vous d'avoir un fichier de configuration languine.json à la racine de votre projet. Voici un exemple :
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "mdx": {
-      "include": ["content/[locale]/**/*.mdx"]
-    }
-  }
-}
-```
-
-## Traduction
-
-Avec votre configuration en place, exécutez :
-
-```bash
-npx languine@latest translate
-```
-
-Lorsque vous exécutez cette commande, Languine va :
-
-- Charger vos fichiers Markdown source (par exemple, content/en/*.mdx)
-- Détecter tout nouveau contenu ou contenu modifié
-- Générer des traductions pour vos langues cibles
-- Créer ou mettre à jour les fichiers de langue cible (par exemple, content/sv/*.mdx)
-- Préserver le formatage et la structure Markdown
-- Gérer les traductions des métadonnées
-- Maintenir les liens et références
-- Garder les blocs de code non traduits
-- Préserver le HTML dans Markdown
diff --git a/apps/web/src/markdown/docs/fr/overrides.mdx b/apps/web/src/markdown/docs/fr/overrides.mdx
deleted file mode 100644
index c4d6b14d..00000000
--- a/apps/web/src/markdown/docs/fr/overrides.mdx
+++ /dev/null
@@ -1,7 +0,0 @@
-# Remplacements
-
-Languine vous permet de remplacer les traductions pour des clés spécifiques. Cela est utile lorsque vous souhaitez garantir qu'une traduction particulière est utilisée pour une clé donnée, indépendamment de la traduction par défaut.
-
-## Comment ça fonctionne
-
-Dans le tableau de bord, vous pouvez créer des remplacements pour des clés spécifiques. Vous pouvez également créer des remplacements pour des langues spécifiques.
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/fr/po.mdx b/apps/web/src/markdown/docs/fr/po.mdx
deleted file mode 100644
index 68a275f1..00000000
--- a/apps/web/src/markdown/docs/fr/po.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# PO (Gettext)
-
-Languine prend en charge les fichiers PO, le format de localisation Gettext largement utilisé. Ce format est populaire dans de nombreux environnements de programmation, en particulier dans les applications Linux et les frameworks PHP, offrant un support pour le contexte, les pluriels et les commentaires des traducteurs.
-
----
-
-## Configuration
-
-Tout d'abord, assurez-vous d'avoir un fichier de configuration languine.json à la racine de votre projet. Voici un exemple :
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "po": {
-      "include": ["locales/[locale]/LC_MESSAGES/messages.po"]
-    }
-  }
-}
-```
-
-## Traduction
-
-Avec votre configuration en place, exécutez :
-
-```bash
-npx languine@latest translate
-```
-
-Lorsque vous exécutez cette commande, Languine va :
-
-- Charger votre fichier PO source (par exemple, locales/en/LC_MESSAGES/messages.po)
-- Détecter toute nouvelle chaîne de traduction ou toute chaîne modifiée
-- Générer des traductions pour vos langues cibles
-- Créer ou mettre à jour les fichiers PO de la langue cible (par exemple, locales/sv/LC_MESSAGES/messages.po)
-- Préserver les métadonnées, les contextes et les formes plurielles
-- Maintenir les commentaires des traducteurs et les informations de référence
diff --git a/apps/web/src/markdown/docs/fr/prettier.mdx b/apps/web/src/markdown/docs/fr/prettier.mdx
deleted file mode 100644
index 2d2095eb..00000000
--- a/apps/web/src/markdown/docs/fr/prettier.mdx
+++ /dev/null
@@ -1,22 +0,0 @@
-# Prettier
-
-Languine peut travailler avec [Prettier](https://prettier.io/) pour garantir que vos fichiers de traduction sont formatés de manière cohérente. Cela est particulièrement utile lors de l'utilisation de fichiers de traduction JSON qui doivent maintenir un style uniforme dans votre projet.
-
-## Utilisation avec Languine
-
-La manière recommandée d'utiliser Prettier avec Languine est de formater vos fichiers de traduction après leur génération. Vous pouvez configurer cela dans votre `package.json`:
-
-```json title="package.json"
-{
-  "scripts": {
-    "translate": "languine translate",
-    "format": "prettier --write \"locales/**/*.json\"",
-    "translate:format": "npm run translate && npm run format"
-  }
-}
-```
-
-Maintenant, vous pouvez :
-- Exécuter `npm run translate` pour générer uniquement des traductions
-- Exécuter `npm run format` pour formater uniquement les fichiers de traduction existants
-- Exécuter `npm run translate:format` pour générer des traductions et les formater en séquence
diff --git a/apps/web/src/markdown/docs/fr/properties.mdx b/apps/web/src/markdown/docs/fr/properties.mdx
deleted file mode 100644
index c28b993b..00000000
--- a/apps/web/src/markdown/docs/fr/properties.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# Propriétés
-
-Languine prend en charge les fichiers de propriétés Java, le format de localisation standard pour les applications Java. Ce format gère l'échappement Unicode et prend en charge à la fois les paires clé-valeur et les commentaires.
-
----
-
-## Configuration
-
-Tout d'abord, assurez-vous d'avoir un fichier de configuration languine.json à la racine de votre projet. Voici un exemple :
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "properties": {
-      "include": ["src/main/resources/messages_[locale].properties"]
-    }
-  }
-}
-```
-
-## Traduction
-
-Avec votre configuration en place, exécutez :
-
-```bash
-npx languine@latest translate
-```
-
-Lorsque vous exécutez cette commande, Languine va :
-
-- Charger votre fichier de propriétés source (par exemple, messages_en.properties)
-- Détecter toute nouvelle chaîne de traduction ou toute chaîne modifiée
-- Générer des traductions pour vos langues cibles
-- Créer ou mettre à jour les fichiers de propriétés des langues cibles (par exemple, messages_sv.properties)
-- Gérer automatiquement l'échappement Unicode
-- Préserver les commentaires et le formatage
diff --git a/apps/web/src/markdown/docs/fr/quickstart.mdx b/apps/web/src/markdown/docs/fr/quickstart.mdx
deleted file mode 100644
index 9812550a..00000000
--- a/apps/web/src/markdown/docs/fr/quickstart.mdx
+++ /dev/null
@@ -1,65 +0,0 @@
-# Démarrage rapide
-
-Commencez par installer Languine.
-
-Ensuite, exécutez la commande suivante pour initialiser Languine.
-
-```bash title="Terminal"
-npx languine@latest init
-```
-
-Suivez les étapes pour configurer votre projet.
-
----
-
-## Première traduction
-
-Maintenant, vous êtes prêt à traduire votre code.
-
-Commencez par ajouter une clé à votre fichier source, par exemple si vous choisissez d'utiliser `en.json` comme fichier source, ajoutez-y une clé.
-
-```json title="src/locales/en.json"
-{
-  "welcome": "Bienvenue dans notre application !",
-  "user": {
-    "greeting": "Salut, {{name}} !",
-    "profile": {
-      "title": "Votre profil",
-      "edit": "Modifier le profil"
-    }
-  },
-  "notifications": {
-    "messages": "Vous avez {{count}} nouveau(x) message(s).",
-    "empty": "Aucune nouvelle notification."
-  }
-}
-
-```
-
----
-
-## Traduire
-
-Exécutez la commande suivante pour traduire votre contenu :
-
-```bash title="Terminal"
-npx languine@latest translate
-```
-
-## Cela va :
-1. Créer des fichiers de traduction pour chaque langue cible
-2. Générer des traductions de haute qualité avec le moteur Languine
-3. Créer un fichier `languine.lock` pour suivre l'état des traductions
-
-Le fichier de verrouillage aide Languine à identifier quelles traductions nécessitent des mises à jour lorsque votre contenu source change. Assurez-vous de valider ce fichier dans votre dépôt.
-
----
-
-## Étapes suivantes
-
-Maintenant que vous avez configuré Languine, vous pouvez :
-- Ajouter plus de langues dans votre fichier `languine.json`
-- Intégrer Languine dans votre pipeline CI/CD
-- Utiliser notre API pour des traductions programmatiques
-
-Consultez nos autres guides pour en savoir plus sur les fonctionnalités avancées de Languine.
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/fr/react-email.mdx b/apps/web/src/markdown/docs/fr/react-email.mdx
deleted file mode 100644
index e0f358e4..00000000
--- a/apps/web/src/markdown/docs/fr/react-email.mdx
+++ /dev/null
@@ -1,41 +0,0 @@
-# Email React
-
-Languine prend en charge les modèles d'email React, vous permettant de gérer les traductions de vos modèles d'email construits avec React Email. Cette intégration gère à la fois le contenu textuel et les attributs HTML tout en préservant la structure des composants React.
-
----
-
-## Configuration
-
-Tout d'abord, assurez-vous d'avoir un fichier de configuration languine.json à la racine de votre projet. Voici un exemple :
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "react-email": {
-      "include": ["emails/[locale]/*.tsx"]
-    }
-  }
-}
-```
-
-## Traduction
-
-Avec votre configuration en place, exécutez :
-
-```bash
-npx languine@latest translate
-```
-
-Lorsque vous exécutez cette commande, Languine va :
-
-- Charger vos modèles d'email React source (par exemple, emails/en/*.tsx)
-- Détecter toute nouvelle chaîne de traduction ou toute chaîne modifiée
-- Générer des traductions pour vos langues cibles
-- Créer ou mettre à jour les modèles d'email dans la langue cible (par exemple, emails/sv/*.tsx)
-- Préserver la structure des composants React et les props
-- Maintenir le formatage et le style HTML
-- Gérer l'interpolation et le contenu dynamique
diff --git a/apps/web/src/markdown/docs/fr/ts.mdx b/apps/web/src/markdown/docs/fr/ts.mdx
deleted file mode 100644
index c4217b06..00000000
--- a/apps/web/src/markdown/docs/fr/ts.mdx
+++ /dev/null
@@ -1,42 +0,0 @@
-# TypeScript
-
-Languine prend en charge les fichiers de localisation TypeScript avec une sécurité de type complète. Ce format étend le support de JavaScript avec des fonctionnalités spécifiques à TypeScript et des capacités de génération de types.
-
----
-
-## Configuration
-
-Tout d'abord, assurez-vous d'avoir un fichier de configuration languine.json à la racine de votre projet. Voici un exemple :
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "ts": {
-      "include": ["src/locales/[locale].ts"]
-    }
-  }
-}
-```
-
-## Traduction
-
-Avec votre configuration en place, exécutez :
-
-```bash
-npx languine@latest translate
-```
-
-Lorsque vous exécutez cette commande, Languine va :
-
-- Charger vos fichiers TypeScript source (par exemple, src/locales/en.ts)
-- Détecter toutes les nouvelles chaînes de traduction ou celles modifiées
-- Générer des traductions pour vos langues cibles
-- Créer ou mettre à jour les fichiers de langue cible (par exemple, src/locales/sv.ts)
-- Préserver les annotations de type et les interfaces
-- Gérer les objets imbriqués avec un typage approprié
-- Maintenir le formatage du code et les commentaires de documentation
-- Supporter les types littéraux et les types d'union
diff --git a/apps/web/src/markdown/docs/fr/xcode-stringsdict.mdx b/apps/web/src/markdown/docs/fr/xcode-stringsdict.mdx
deleted file mode 100644
index cdc15a41..00000000
--- a/apps/web/src/markdown/docs/fr/xcode-stringsdict.mdx
+++ /dev/null
@@ -1,44 +0,0 @@
-# Xcode Stringsdict
-
-Languine prend en charge le format Stringsdict d'Xcode, utilisé pour des règles de pluralisation complexes dans les applications iOS et macOS. Ce format gère les formes plurielles, les substitutions de variables et les règles de pluralisation spécifiques à chaque langue.
-
----
-
-## Configuration
-
-Tout d'abord, assurez-vous d'avoir un fichier de configuration languine.json à la racine de votre projet. Voici un exemple :
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "stringsdict": {
-      "include": ["MyApp/Localizable.stringsdict"]
-    }
-  }
-}
-```
-
-## Traduction
-
-Avec votre configuration en place, exécutez :
-
-```bash
-npx languine@latest translate
-```
-
-Lorsque vous exécutez cette commande, Languine va :
-
-- Charger vos fichiers Stringsdict
-- Détecter toute nouvelle règle de pluralisation ou toute règle modifiée
-- Générer des traductions pour vos langues cibles
-- Mettre à jour les fichiers Stringsdict avec les nouvelles traductions
-- Gérer des règles de pluralisation complexes pour chaque langue
-- Maintenir les substitutions de variables
-- Préserver la structure du dictionnaire
-- Supporter les formes plurielles spécifiques à chaque langue
-- Valider la cohérence des règles de pluralisation
-- Conserver les spécificateurs de formatage
diff --git a/apps/web/src/markdown/docs/fr/xcode-xcstrings.mdx b/apps/web/src/markdown/docs/fr/xcode-xcstrings.mdx
deleted file mode 100644
index 27c36048..00000000
--- a/apps/web/src/markdown/docs/fr/xcode-xcstrings.mdx
+++ /dev/null
@@ -1,44 +0,0 @@
-# Xcode Strings (XCStrings)
-
-Languine prend en charge le format XCStrings d'Xcode, le format de localisation moderne pour les applications iOS et macOS. Ce format gère les catalogues de chaînes avec prise en charge des variations, de la pluralisation et des commentaires des développeurs.
-
----
-
-## Configuration
-
-Tout d'abord, assurez-vous d'avoir un fichier de configuration languine.json à la racine de votre projet. Voici un exemple :
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "xcstrings": {
-      "include": ["MyApp/Localizable.xcstrings"]
-    }
-  }
-}
-```
-
-## Traduction
-
-Avec votre configuration en place, exécutez :
-
-```bash
-npx languine@latest translate
-```
-
-Lorsque vous exécutez cette commande, Languine va :
-
-- Charger votre catalogue XCStrings
-- Détecter toutes les chaînes nouvelles ou modifiées
-- Générer des traductions pour vos langues cibles
-- Mettre à jour le catalogue de chaînes avec les nouvelles traductions
-- Préserver les variations de chaînes et les règles de pluralisation
-- Maintenir les commentaires et le contexte des développeurs
-- Gérer les substitutions de variables
-- Prendre en charge les chaînes adaptatives
-- Conserver les spécificateurs de format
-- Valider la structure du catalogue de chaînes
diff --git a/apps/web/src/markdown/docs/fr/xliff.mdx b/apps/web/src/markdown/docs/fr/xliff.mdx
deleted file mode 100644
index 42eba2ed..00000000
--- a/apps/web/src/markdown/docs/fr/xliff.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# XLIFF
-
-Languine prend en charge XLIFF (XML Localization Interchange File Format), un format basé sur XML conçu pour l'échange de données de localisation. Ce format est largement utilisé dans les flux de travail de traduction professionnels et prend en charge les versions XLIFF 1.2 et 2.0.
-
----
-
-## Configuration
-
-Tout d'abord, assurez-vous d'avoir un fichier de configuration languine.json à la racine de votre projet. Voici un exemple :
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "xliff": {
-      "include": ["locales/[locale].xlf"]
-    }
-  }
-}
-```
-
-## Traduction
-
-Avec votre configuration en place, exécutez :
-
-```bash
-npx languine@latest translate
-```
-
-Lorsque vous exécutez cette commande, Languine va :
-
-- Charger votre fichier XLIFF source (par exemple, locales/en.xlf)
-- Détecter toute nouvelle unité de traduction ou toute unité modifiée
-- Générer des traductions pour vos langues cibles
-- Créer ou mettre à jour les fichiers XLIFF de la langue cible (par exemple, locales/sv.xlf)
-- Préserver les notes, les informations contextuelles et les attributs d'état
-- Maintenir la compatibilité avec les outils de TAO (Traduction Assistée par Ordinateur)
diff --git a/apps/web/src/markdown/docs/fr/xml.mdx b/apps/web/src/markdown/docs/fr/xml.mdx
deleted file mode 100644
index 232ae662..00000000
--- a/apps/web/src/markdown/docs/fr/xml.mdx
+++ /dev/null
@@ -1,44 +0,0 @@
-# XML
-
-Languine prend en charge la localisation des fichiers XML, adaptée à divers fichiers de configuration et de contenu basés sur XML. Ce format gère des structures XML complexes tout en préservant le formatage et les attributs.
-
----
-
-## Configuration
-
-Tout d'abord, assurez-vous d'avoir un fichier de configuration languine.json à la racine de votre projet. Voici un exemple :
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "xml": {
-      "include": ["resources/[locale]/*.xml"]
-    }
-  }
-}
-```
-
-## Traduction
-
-Avec votre configuration en place, exécutez :
-
-```bash
-npx languine@latest translate
-```
-
-Lorsque vous exécutez cette commande, Languine va :
-
-- Charger vos fichiers XML source (par exemple, resources/en/*.xml)
-- Détecter tout contenu nouveau ou modifié
-- Générer des traductions pour vos langues cibles
-- Créer ou mettre à jour les fichiers de langue cible (par exemple, resources/sv/*.xml)
-- Préserver la structure et le formatage XML
-- Gérer les traductions d'attributs
-- Maintenir les sections CDATA
-- Conserver les commentaires XML
-- Supporter les espaces de noms XML
-- Valider la structure XML
diff --git a/apps/web/src/markdown/docs/fr/yaml.mdx b/apps/web/src/markdown/docs/fr/yaml.mdx
deleted file mode 100644
index 1c917817..00000000
--- a/apps/web/src/markdown/docs/fr/yaml.mdx
+++ /dev/null
@@ -1,39 +0,0 @@
-# YAML
-
-Languine prend en charge les fichiers YAML comme format source, qui est couramment utilisé dans Ruby on Rails, Laravel et d'autres frameworks. Ce format prend en charge les structures imbriquées, les tableaux et les types de données complexes.
-
----
-
-## Configuration
-
-Tout d'abord, assurez-vous d'avoir un fichier de configuration languine.json à la racine de votre projet. Voici un exemple :
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "yaml": {
-      "include": ["config/locales/[locale].yml"]
-    }
-  }
-}
-```
-
-## Traduction
-
-Avec votre configuration en place, exécutez :
-
-```bash
-npx languine@latest translate
-```
-
-Lorsque vous exécutez cette commande, Languine va :
-
-- Charger votre fichier YAML source (par exemple, config/locales/en.yml)
-- Détecter toute nouvelle chaîne de traduction ou toute chaîne modifiée
-- Générer des traductions pour vos langues cibles
-- Créer ou mettre à jour les fichiers YAML de la langue cible (par exemple, config/locales/sv.yml)
-- Préserver les structures imbriquées et le formatage
diff --git a/apps/web/src/markdown/docs/it/android.mdx b/apps/web/src/markdown/docs/it/android.mdx
deleted file mode 100644
index 5e774436..00000000
--- a/apps/web/src/markdown/docs/it/android.mdx
+++ /dev/null
@@ -1,39 +0,0 @@
-# Android
-
-Languine supporta le risorse di stringa Android (strings.xml) come formato sorgente, gestendo plurali, array di stringhe e stringhe formattate. Questo formato è il modo standard per gestire le traduzioni nelle applicazioni Android.
-
----
-
-## Configurazione
-
-Per prima cosa, assicurati di avere un file di configurazione languine.json nella radice del tuo progetto. Ecco un esempio:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "android": {
-      "include": ["app/src/main/res/values-[locale]/strings.xml"]
-    }
-  }
-}
-```
-
-## Traduzione
-
-Con la tua configurazione impostata, esegui:
-
-```bash
-npx languine@latest translate
-```
-
-Quando esegui questo comando, Languine:
-
-- Caricherà il tuo file strings.xml sorgente (ad es., values/strings.xml)
-- Rileverà eventuali nuove stringhe di traduzione o modifiche
-- Genererà traduzioni per le tue lingue target
-- Creerà o aggiornerà i file XML delle lingue target (ad es., values-sv/strings.xml, values-de/strings.xml, values-fr/strings.xml)
-- Preserverà qualsiasi formattazione esistente di array di stringhe e plurali
diff --git a/apps/web/src/markdown/docs/it/arb.mdx b/apps/web/src/markdown/docs/it/arb.mdx
deleted file mode 100644
index c846d458..00000000
--- a/apps/web/src/markdown/docs/it/arb.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# ARB (Application Resource Bundle)
-
-Languine supporta i file ARB, il formato standard di localizzazione per le applicazioni Flutter. Questo formato gestisce plurali, segnaposto ed espressioni selettive mantenendo la compatibilità con il pacchetto intl di Flutter.
-
----
-
-## Configurazione
-
-Per prima cosa, assicurati di avere un file di configurazione languine.json nella radice del tuo progetto. Ecco un esempio:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "arb": {
-      "include": ["lib/l10n/intl_[locale].arb"]
-    }
-  }
-}
-```
-
-## Traduzione
-
-Con la tua configurazione impostata, esegui:
-
-```bash
-npx languine@latest translate
-```
-
-Quando esegui questo comando, Languine:
-
-- Caricherà il tuo file ARB sorgente (ad es., lib/l10n/intl_en.arb)
-- Rileverà eventuali nuove stringhe di traduzione o stringhe modificate
-- Genererà traduzioni per le tue lingue target
-- Creerà o aggiornerà i file ARB delle lingue target (ad es., lib/l10n/intl_sv.arb)
-- Preserverà i metadati, i segnaposto e le espressioni plurali/selettive
-
diff --git a/apps/web/src/markdown/docs/it/authentication.mdx b/apps/web/src/markdown/docs/it/authentication.mdx
deleted file mode 100644
index e85c7028..00000000
--- a/apps/web/src/markdown/docs/it/authentication.mdx
+++ /dev/null
@@ -1,48 +0,0 @@
-# Autenticazione
-
-Per utilizzare Languine, è necessario autenticarsi con il nostro Engine, ci vogliono solo pochi secondi per iniziare.
-
----
-
-## Accedi
-
-Puoi accedere direttamente al [Languine Dashboard](https://languine.ai/login) oppure eseguire il seguente comando:
-
-```bash title="Terminale"
-npx languine@latest auth login
-```
-
-
-Se hai già un account, verrai automaticamente autenticato e una sessione verrà salvata sul tuo dispositivo.
-
----
-
-## Disconnetti
-
-Puoi disconnetterti eseguendo il seguente comando:
-
-```bash title="Terminale"
-npx languine@latest auth logout
-```
-
----
-
-## Sessione utente
-
-Puoi controllare se sei autenticato eseguendo il seguente comando:
-
-```bash title="Terminale"
-npx languine@latest auth whoami
-```
-
----
-
-
-# Variabili d'ambiente
-
-Puoi impostare le seguenti variabili d'ambiente per configurare Languine:
-
-- `LANGUINE_API_KEY`: La chiave API da utilizzare per l'autenticazione.
-- `LANGUINE_PROJECT_ID`: L'ID del progetto da utilizzare per il progetto.
-
-Puoi trovarle nel [Languine Dashboard](https://languine.ai/login).
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/it/biome.mdx b/apps/web/src/markdown/docs/it/biome.mdx
deleted file mode 100644
index 9d7b71aa..00000000
--- a/apps/web/src/markdown/docs/it/biome.mdx
+++ /dev/null
@@ -1,24 +0,0 @@
-# Bioma
-
-Languine può lavorare insieme a [Biome](https://biomejs.dev/) per garantire che i tuoi file di traduzione siano formattati in modo coerente. Questo è particolarmente utile quando si lavora con file di traduzione JSON che devono mantenere uno stile coerente nel tuo progetto.
-
-## Utilizzo con Languine
-
-Il modo consigliato per utilizzare Biome con Languine è formattare i tuoi file di traduzione dopo che sono stati generati. Puoi configurarlo nel tuo `package.json`:
-
-```json title="package.json"
-{
-  "scripts": {
-    "translate": "languine translate",
-    "format": "biome format \"locales/**/*.json\"",
-    "translate:format": "npm run translate && npm run format"
-  }
-}
-```
-
-Ora puoi:
-- Eseguire `npm run translate` per generare solo le traduzioni
-- Eseguire `npm run format` per formattare solo i file di traduzione esistenti
-- Eseguire `npm run translate:format` per generare le traduzioni e formattarle in sequenza
-
-Questa configurazione garantirà che i tuoi file di traduzione siano formattati in modo coerente con un'indentazione di 2 spazi e una larghezza massima di riga di 80 caratteri.
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/it/ci.mdx b/apps/web/src/markdown/docs/it/ci.mdx
deleted file mode 100644
index c591449a..00000000
--- a/apps/web/src/markdown/docs/it/ci.mdx
+++ /dev/null
@@ -1,96 +0,0 @@
-# CI/CD
-
-Languine offre un'integrazione CI/CD per aiutarti a tradurre la tua applicazione.
-
----
-
-## Come Funziona
-
-Il flusso di lavoro CI/CD in Languine segue un processo strutturato per automatizzare gli aggiornamenti delle traduzioni nella tua applicazione:
-
-### 1. Inizializzazione dell'Azione
-- Il flusso di lavoro inizia quando l'azione viene attivata
-- Configura le impostazioni Git e le credenziali necessarie
-
-### 2. Elaborazione del Motore Languine
-- Il motore Languine elabora il contenuto della tua applicazione
-- Gestisce i compiti di traduzione utilizzando le impostazioni configurate
-
-### 3. Rilevamento delle Modifiche
-Il sistema controlla eventuali modifiche alle traduzioni e segue uno dei due percorsi:
-
-**Quando Vengono Trovate Modifiche:**
-- Le modifiche vengono registrate nel repository
-- Le modifiche vengono inviate al ramo specificato
-- Viene creata una Pull Request (PR)
-
-**Quando Non Vengono Trovate Modifiche:**
-- Il flusso di lavoro si completa senza creare una PR
-
-### 4. Creazione della Pull Request
-Quando vengono rilevate modifiche, viene creata una Pull Request con:
-
-**Contenuto della PR:**
-- Titolo chiaro che indica gli aggiornamenti delle traduzioni
-- Descrizione dettagliata delle modifiche
-- Conferme di controllo qualità
-- Istruzioni per la revisione
-- Link alla documentazione e al supporto
-
-**La Descrizione della PR Include:**
-- Riepilogo degli aggiornamenti delle traduzioni
-- Elenco di cosa è cambiato (traduzioni aggiornate, coerenza terminologica)
-- Prossimi passi per i revisori
-- Link alla documentazione e alle risorse di supporto
-
----
-
-## Diagramma del Flusso di Lavoro
-
-<div className="flex flex-col items-center justify-center p-4 h-[400px] sm:h-[500px] md:h-[650px]">
-  <pre
-    className="p-4 text-sm leading-5 mb-4 scale-[0.5] sm:scale-[0.65] md:scale-90 transform-gpu"
-    style={{
-      fontFamily: "monospace",
-      whiteSpace: "pre",
-      textAlign: "left",
-    }}
-  >
-    {`
-                    ┌─────────────────────┐
-                    │   Inizio Azione     │
-                    └──────────┬──────────┘
-                               │
-                    ┌──────────▼──────────┐
-                    │    Configura Git &   │
-                    │    Credenziali      │
-                    └──────────┬──────────┘
-                               │
-┌─────────────────────────────────────────────────────────┐
-│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-│░░░░░░░░░░░░░░░░░░░░ Motore Languine ░░░░░░░░░░░░░░░░░░░░│
-│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-└─────────────────────────────────────────────────────────┘
-                               │
-                    ┌──────────▼──────────┐
-                    │   Controlla Modifiche │───────┐
-                    └──────────┬──────────┘       │
-                               │                  │
-                               │ [Modifiche]      │ [Nessuna Modifica]
-                               │                  │
-                    ┌──────────▼──────────┐       │
-                    │   Registra & Invia   │       │
-                    └──────────┬──────────┘       │
-                               │                  │
-                    ┌──────────▼──────────┐       │
-                    │    Crea PR          │       │
-                    └──────────┬──────────┘       │
-                               │                  │
-                    ┌──────────▼──────────┐       │
-                    │        Fatto        │◄──────┘
-                    └─────────────────────┘
-`}
-  </pre>
-</div>
-
-Il flusso di lavoro è progettato per essere automatizzato pur consentendo una revisione umana e un controllo qualità prima che le modifiche vengano integrate nel tuo codice. Mantiene le migliori pratiche di controllo delle versioni e garantisce che le traduzioni siano correttamente tracciate e documentate attraverso la cronologia di Git.
diff --git a/apps/web/src/markdown/docs/it/cli.mdx b/apps/web/src/markdown/docs/it/cli.mdx
deleted file mode 100644
index 84096e39..00000000
--- a/apps/web/src/markdown/docs/it/cli.mdx
+++ /dev/null
@@ -1,65 +0,0 @@
-# CLI
-
-Languine fornisce un'interfaccia a riga di comando (CLI) per aiutarti a tradurre la tua applicazione.
-
----
-
-## Panoramica dei Comandi
-
-### Traduci
-
-Il comando `translate` viene utilizzato per tradurre la tua applicazione.
-
-```bash title="Terminal"
-    npx languine@latest translate
-```
-
----
-
-### Inizializza
-
-Il comando `init` viene utilizzato per inizializzare un nuovo progetto Languine.
-
-```bash title="Terminal"
-    npx languine@latest init
-```
-
----
-
-### Autenticazione
-
-Il comando `auth` viene utilizzato per autenticarsi con Languine.
-
-```bash title="Terminal"
-    npx languine@latest auth
-```
-
----
-
-### Sincronizza
-
-Il comando `sync` viene utilizzato per sincronizzare la tua applicazione con Languine.
-
-```bash title="Terminal"
-    npx languine@latest sync
-```
-
----
-
-### Aggiungi Locale
-
-Il comando `locale` viene utilizzato per gestire i locali della tua applicazione.
-
-```bash title="Terminal"
-    npx languine@latest locale add pt,fr
-```
-
----
-
-### Rimuovi Locale
-
-Il comando `locale remove` viene utilizzato per rimuovere un locale dalla tua applicazione.
-
-```bash title="Terminal"
-    npx languine@latest locale remove pt,fr
-```
diff --git a/apps/web/src/markdown/docs/it/configuration.mdx b/apps/web/src/markdown/docs/it/configuration.mdx
deleted file mode 100644
index 819f4858..00000000
--- a/apps/web/src/markdown/docs/it/configuration.mdx
+++ /dev/null
@@ -1,180 +0,0 @@
-# Configurazione
-
-Languine utilizza un file di configurazione JSON (languine.json) per gestire la tua impostazione di traduzione. Questo file definisce le tue lingue di origine e di destinazione, così come i file che devono essere tradotti.
-
----
-
-## Configurazione di Base
-
-Ecco un esempio di base in entrambi i formati:
-
-```json title="languine.json"
-{
-  "locale": {
-    "source": "en",
-    "targets": ["es", "fr", "de"]
-  },
-  "files": {
-    "json": {
-      "include": ["locales/[locale].json"]
-    }
-  }
-}
-```
-
-Analizziamo le diverse sezioni nel file di configurazione.
-
----
-
-## Configurazione della Lingua
-
-La sezione lingua definisce le tue lingue di traduzione:
-
-- source: La tua lingua principale per la creazione di contenuti (ad es., "en" per l'inglese)
-- targets: Un array di lingue in cui desideri tradurre (ad es., ["es", "fr", "de"] per spagnolo, francese e tedesco)
-
-Languine supporta un'ampia gamma di codici lingua, tra cui:
-- Codici semplici: en, es, fr, de
-- Codici specifici per regione: pt-BR, zh-CN, zh-TW
-
-## Configurazione dei File
-
-La sezione file definisce quali file Languine dovrebbe tradurre. Puoi configurare più tipi di file e modelli:
-
----
-
-### File JSON
-```json
-files: {
-  json: {
-    include: ["locales/[locale].json"],
-  },
-}
-```
-
----
-
-### File Markdown/MDX
-```json
-files: {
-  md: {
-    include: ["docs/[locale]/*.md"],
-  },
-  mdx: {
-    include: ["blog/[locale]/*.mdx"],
-  },
-}
-```
-
----
-
-### File per Piattaforme Mobili
-
-Per iOS (Xcode):
-```json
-files: {
-  "xcode-xcstrings": {
-    include: ["Example/Localizable.xcstrings"],
-  },
-  // O per file .strings tradizionali
-  "xcode-strings": {
-    include: ["Example/[locale].lproj/Localizable.strings"],
-  },
-}
-```
-
----
-
-Per Android:
-```json
-files: {
-  android: {
-    include: ["locales/[locale].xml"],
-  },
-}
-```
-
----
-
-### Altri Formati
-
-Ecco un elenco completo dei formati di file supportati da Languine:
-
-- [JSON](/docs/json) - File di traduzione JSON standard
-- [YAML](/docs/yaml) - File di traduzione YAML
-- [Properties](/docs/properties) - File di proprietà Java
-- [Android](/docs/android) - File di risorse XML Android
-- [iOS](/docs/ios) - File di localizzazione iOS
-- [iOS Stringsdict](/docs/xcode-stringsdict) - File di pluralizzazione iOS
-- [iOS XCStrings](/docs/xcode-xcstrings) - Cataloghi di stringhe moderni di Xcode
-- [Markdown](/docs/md) - File di documentazione
-- [MDX](/docs/mdx) - Documentazione con JSX
-- [HTML](/docs/html) - File HTML
-- [JavaScript](/docs/js) - File JavaScript
-- [TypeScript](/docs/ts) - File TypeScript
-- [Gettext PO](/docs/po) - File di traduzione GetText
-- [XLIFF](/docs/xliff) - Formato di file di interscambio di localizzazione XML
-- [CSV](/docs/csv) - Traduzioni basate su fogli di calcolo
-- [XML](/docs/xml) - File di risorse XML
-- [Flutter ARB](/docs/arb) - File Application Resource Bundle
-
----
-
-## Modelli di File
-
-Il segnaposto [locale] nei modelli di file viene automaticamente sostituito con il codice lingua appropriato durante la traduzione. Ad esempio:
-
-- locales/[locale].json diventa:
-  - locales/en.json
-  - locales/es.json
-  - locales/fr.json
-
-Puoi includere più modelli per ciascun tipo di file e utilizzare modelli glob:
-```json
-files: {
-  json: {
-    include: [
-      "src/locales/[locale].json",
-      "src/components/[locale]/*.json"
-    ],
-  },
-}
-```
-
----
-
-## ID Progetto (Opzionale)
-
-Se stai utilizzando i servizi cloud di Languine, puoi includere il tuo ID progetto nella configurazione:
-
-```json
-{
-  "projectId": "prj_your_project_id",
-  "locale": {
-    // ... configurazione lingua
-  },
-  files: {
-    // ... configurazione file
-  },
-}
-```
-
----
-
-## Monitoraggio dello Stato di Traduzione
-
-Languine crea e mantiene automaticamente un file languine.lock per monitorare lo stato delle tue traduzioni. Questo file:
-
-- Tiene traccia di quali contenuti sono stati tradotti
-- Aiuta a identificare cosa deve essere aggiornato quando il contenuto sorgente cambia
-- Dovrebbe essere impegnato nel tuo sistema di controllo versione
-
-Non è necessario modificare manualmente il file di blocco - Languine lo gestisce automaticamente quando esegui i comandi di traduzione.
-
-## Migliori Pratiche
-
-1. **Controllo Versione**: Impegnati sempre sia languine.json che languine.lock nel tuo repository
-2. **Organizzazione dei File**: Mantieni i tuoi file di traduzione organizzati in una struttura di directory coerente
-3. **Codici Lingua**: Utilizza codici lingua standard per garantire compatibilità
-4. **Modelli**: Utilizza modelli di inclusione specifici per evitare di tradurre file non necessari
-5. **ID Progetto**: Mantieni il tuo ID progetto sicuro e non condividerlo pubblicamente se stai utilizzando servizi cloud, utilizza invece la variabile di ambiente `LANGUINE_PROJECT_ID`.
diff --git a/apps/web/src/markdown/docs/it/csv.mdx b/apps/web/src/markdown/docs/it/csv.mdx
deleted file mode 100644
index bcbcedbd..00000000
--- a/apps/web/src/markdown/docs/it/csv.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# CSV
-
-Languine supporta i file CSV (Comma-Separated Values) per una gestione semplice delle traduzioni. Questo formato è ideale per flussi di lavoro basati su fogli di calcolo e per una facile integrazione con strumenti di traduzione esterni.
-
----
-
-## Configurazione
-
-Per prima cosa, assicurati di avere un file di configurazione languine.json nella radice del tuo progetto. Ecco un esempio:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "csv": {
-      "include": ["translations/[locale].csv"]
-    }
-  }
-}
-```
-
-## Traduzione
-
-Con la tua configurazione impostata, esegui:
-
-```bash
-npx languine@latest translate
-```
-
-Quando esegui questo comando, Languine:
-
-- Caricherà il tuo file CSV sorgente (ad es., translations/en.csv)
-- Rileverà eventuali nuove stringhe di traduzione o stringhe modificate
-- Genererà traduzioni per le lingue di destinazione
-- Creerà o aggiornerà i file CSV delle lingue di destinazione (ad es., translations/sv.csv)
-- Mantenere la struttura e il formato delle colonne
-- Preserverà eventuali colonne di metadati aggiuntive
diff --git a/apps/web/src/markdown/docs/it/expo.mdx b/apps/web/src/markdown/docs/it/expo.mdx
deleted file mode 100644
index e7c29a46..00000000
--- a/apps/web/src/markdown/docs/it/expo.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# Expo
-
-Languine supporta la localizzazione di Expo, integrandosi perfettamente con il sistema i18n di Expo. Questo formato funziona sia con progetti JavaScript che TypeScript, supportando strutture annidate e pluralizzazione.
-
----
-
-## Configurazione
-
-Per prima cosa, assicurati di avere un file di configurazione languine.json nella radice del tuo progetto. Ecco un esempio:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "expo": {
-      "include": ["assets/locales/[locale].json"]
-    }
-  }
-}
-```
-
-## Traduzione
-
-Con la tua configurazione impostata, esegui:
-
-```bash
-npx languine@latest translate
-```
-
-Quando esegui questo comando, Languine:
-
-- Caricherà il tuo file di traduzione sorgente (ad es., assets/locales/en.json)
-- Rileverà eventuali nuove stringhe di traduzione o modifiche
-- Genererà traduzioni per le lingue target
-- Creerà o aggiornerà i file delle lingue target (ad es., assets/locales/sv.json)
-- Preserverà la struttura annidata e le regole di pluralizzazione
-- Mantenere la compatibilità con expo-localization
diff --git a/apps/web/src/markdown/docs/it/github-actions.mdx b/apps/web/src/markdown/docs/it/github-actions.mdx
deleted file mode 100644
index 7f0df123..00000000
--- a/apps/web/src/markdown/docs/it/github-actions.mdx
+++ /dev/null
@@ -1,147 +0,0 @@
-# GitHub Actions
-
-Con l'azione GitHub, puoi facilmente tradurre il tuo codice semplicemente inviando il tuo codice al repository; l'azione GitHub tradurrà quindi le tue nuove chiavi, creando una pull request o impegnando le tue modifiche.
-Questo ti fa risparmiare molto tempo e fatica mantenendo traduzioni di alta qualità.
-
----
-
-## Come funziona
-
-
-
-<div className="flex flex-col items-center justify-center p-4 mb-8 h-[400px] sm:h-[500px] md:h-[650px]">
-        <pre
-          className="p-4 text-sm leading-5 scale-[0.5] sm:scale-[0.65] md:scale-90 transform-gpu"
-          style={{
-            fontFamily: "monospace",
-            whiteSpace: "pre",
-            textAlign: "left",
-          }}
-        >
-          {`
-                                  ┌───────────────┐
-                                  │   Git Push    │
-                                  └───────────────┘
-                                          │
-                                          ▼
-             ┌─────────────────────────────────────────────────────────┐
-             │░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-             │░░░░░░░░░░░░░░░░░░░░ Languine Engine ░░░░░░░░░░░░░░░░░░░░│
-             │░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-             └─────────────────────────────────────────────────────────┘
-                                          │
-                                          ▼
-                                          │
-            ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┼ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─
-           │                              │                              │
-           ▼                              ▼                              ▼
- ╔═══════════════════╗          ╔═══════════════════╗          ╔═══════════════════╗
- ║                   ║          ║                   ║          ║                   ║
- ║      English      ║          ║      Spanish      ║          ║      Japanese     ║
- ║    Translation    ║          ║    Translation    ║          ║     Translation   ║
- ║                   ║          ║                   ║          ║                   ║
- ╚═══════════════════╝          ╚═══════════════════╝          ╚═══════════════════╝
-           │                              │                              │
-           └──────────────────────────────┼──────────────────────────────┘
-                                          ▼
-                                  ┌───────────────┐
-                                  │     Merge     │
-                                  │ Pull Request  │
-                                  └───────────────┘
-                                          │
-                                          ▼
-                              ┌─────────────────────┐
-                              │      Completed      │
-                              │      (Deploy)       │
-                              └─────────────────────┘
-`}
-        </pre>
-      </div>
-
----
-
-## Installazione
-
-Per utilizzare l'azione Languine GitHub nel tuo repository, dovrai:
-
-1. Configurare i segreti del tuo repository con le tue credenziali Languine
-2. Creare un file di workflow nel tuo repository
-
-### Configurazione dei Segreti del Repository
-
-Aggiungi i seguenti segreti nelle impostazioni del tuo repository (Impostazioni > Segreti e variabili > Azioni):
-
-- `LANGUINE_API_KEY`: La tua chiave API Languine
-- `LANGUINE_PROJECT_ID`: Il tuo ID progetto Languine
-
-Puoi trovare questi valori nel tuo dashboard Languine sotto Impostazioni Progetto.
-
-
-
-### Variabili d'Ambiente
-
-L'azione GitHub utilizza le seguenti variabili d'ambiente:
-- `LANGUINE_API_KEY` (Obbligatoria): La tua chiave API Languine per l'autenticazione
-- `LANGUINE_PROJECT_ID` (Obbligatoria): Il tuo ID progetto Languine 
-- `GITHUB_TOKEN` (Obbligatoria): Fornito automaticamente da GitHub, utilizzato per creare PR
-
-### Esempio di Workflow
-
-Crea un nuovo file .github/workflows/languine.yml nel tuo repository con il seguente contenuto:
-
-```ts title=".github/workflows/release.yml"
-name: Deploy Website
-
-on:
-  push:
-    branches:
-      - '**'
-    paths:
-      - apps/web/**
-
-jobs:
-  translate:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-      pull-requests: write
-    steps:
-      - uses: actions/checkout@v4
-      
-      - name: Languine Action
-        uses: languine/languine-action@v1
-        env:
-           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          api-key: ${{ secrets.LANGUINE_API_KEY }}
-          project-id: ${{ secrets.LANGUINE_PROJECT_ID }}
-```
- 
- Questo workflow:
-- Verrà eseguito su push al ramo principale
-- Verrà eseguito su pull request al ramo principale
-- Può essere attivato manualmente dalla scheda Azioni
-- Controlla il tuo codice ed esegue il processo di traduzione Languine
-- Crea una pull request con eventuali nuove traduzioni (configurabile)
-
-#### Opzione Directory di Lavoro
-
-L'opzione `working-directory` ti consente di specificare dove si trovano i tuoi file di traduzione. Questo è particolarmente utile nei monorepo dove le tue traduzioni possono trovarsi in un pacchetto o in una directory di app specifica. Ad esempio:
-
-#### Opzione Pull Request (in arrivo)
-
-L'opzione `create-pull-request` controlla se l'azione crea una pull request con le modifiche o le impegna direttamente nel ramo:
-
-```typescript title=".github/workflows/languine.yml"
-with:
-  create-pull-request: true # crea una pull request con le modifiche
-```
-
-Quando impostato su `true`, l'azione:
-- Crea un nuovo ramo con le modifiche
-- Crea una pull request per la revisione
-- Aggiunge etichette e descrizioni appropriate
-
-Quando impostato su `false` (predefinito), l'azione:
-- Impegna le modifiche direttamente nel ramo corrente
-- Spinge le modifiche senza creare una pull request
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/it/html.mdx b/apps/web/src/markdown/docs/it/html.mdx
deleted file mode 100644
index e8f8a7c7..00000000
--- a/apps/web/src/markdown/docs/it/html.mdx
+++ /dev/null
@@ -1,41 +0,0 @@
-# HTML
-
-Languine supporta la localizzazione dei file HTML, gestendo sia il contenuto testuale che gli attributi. Questo formato è ideale per siti web statici e modelli HTML, con supporto per preservare la struttura e il formato HTML.
-
----
-
-## Configurazione
-
-Per prima cosa, assicurati di avere un file di configurazione languine.json nella radice del tuo progetto. Ecco un esempio:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "html": {
-      "include": ["pages/[locale]/*.html"]
-    }
-  }
-}
-```
-
-## Traduzione
-
-Con la tua configurazione impostata, esegui:
-
-```bash
-npx languine@latest translate
-```
-
-Quando esegui questo comando, Languine:
-
-- Caricherà i tuoi file HTML sorgente (ad es., pages/en/*.html)
-- Rileverà eventuali nuove stringhe di traduzione o modifiche
-- Genererà traduzioni per le lingue target
-- Creerà o aggiornerà i file HTML delle lingue target (ad es., pages/sv/*.html)
-- Preserverà la struttura e il formato HTML
-- Gestirà le traduzioni degli attributi specificati
-- Mantenere commenti e tag speciali
diff --git a/apps/web/src/markdown/docs/it/introduction.mdx b/apps/web/src/markdown/docs/it/introduction.mdx
deleted file mode 100644
index 8022d58d..00000000
--- a/apps/web/src/markdown/docs/it/introduction.mdx
+++ /dev/null
@@ -1,34 +0,0 @@
-# Introduzione
-
-Languine automatizza la localizzazione all'interno del tuo flusso di lavoro e pipeline di sviluppo, garantendo che le traduzioni non ti rallentino mai.
-
-Trasforma la tua applicazione in un'esperienza multilingue in pochi minuti. Mentre ti concentri sulla creazione di funzionalità, Languine gestisce tutti gli aspetti della traduzione con precisione e affidabilità.
-
----
-
-## Caratteristiche Principali
-
-- **Motore di Traduzione**: Sfrutta traduzioni di alta qualità e consapevoli del contesto che mantengono la voce del tuo marchio
-- **Integrazione CI/CD**: Automatizza gli aggiornamenti delle traduzioni attraverso i tuoi flussi di lavoro esistenti
-- **Formati**: Gestisci qualsiasi formato di file con il nostro sistema di parser estensibile
-- **Open Source**: Accedi, ispeziona e contribuisci al nostro codice su GitHub - niente scatole nere, completa trasparenza
-
----
-
-## Come Funziona
-
-1. **Impostazione Veloce**: Inizia in pochi minuti con il nostro CLI intuitivo e l'inizializzazione guidata
-2. **Configurazione Semplice**: Definisci le tue esigenze di traduzione con un file di configurazione chiaro e diretto
-3. **Traduzione Automatica**: Invia il tuo contenuto una sola volta e lascia che Languine gestisca automaticamente la traduzione in tutte le lingue target
-
----
-
-## Iniziare
-
-Inizia il tuo viaggio di localizzazione con la nostra guida [Quickstart](/docs/quickstart) - avrai le tue prime traduzioni in esecuzione in pochi minuti.
-
-Esplora la nostra documentazione completa per padroneggiare le capacità di Languine:
-
-- [Configurazione](/docs/configuration) - Configura Languine in base alle esigenze del tuo progetto
-- [CLI](/docs/cli) - Padroneggia la nostra potente interfaccia a riga di comando
-- [Github Actions](/docs/github-actions) - Automatizza le traduzioni con la nostra Azione Github
diff --git a/apps/web/src/markdown/docs/it/ios.mdx b/apps/web/src/markdown/docs/it/ios.mdx
deleted file mode 100644
index 87c3df39..00000000
--- a/apps/web/src/markdown/docs/it/ios.mdx
+++ /dev/null
@@ -1,39 +0,0 @@
-# iOS
-
-Languine supporta i file Localizable.strings di iOS, il formato standard di localizzazione per le applicazioni iOS. Questo formato gestisce coppie di stringhe chiave-valore di base e supporta commenti per fornire contesto ai traduttori.
-
----
-
-## Configurazione
-
-Prima di tutto, assicurati di avere un file di configurazione languine.json nella radice del tuo progetto. Ecco un esempio:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "ios": {
-      "include": ["[locale].lproj/Localizable.strings"]
-    }
-  }
-}
-```
-
-## Traduzione
-
-Con la tua configurazione impostata, esegui:
-
-```bash
-npx languine@latest translate
-```
-
-Quando esegui questo comando, Languine:
-
-- Caricherà il tuo file Localizable.strings sorgente (ad esempio, en.lproj/Localizable.strings)
-- Rileverà eventuali nuove stringhe di traduzione o stringhe modificate
-- Genererà traduzioni per le lingue di destinazione
-- Creerà o aggiornerà i file delle lingue di destinazione (ad esempio, sv.lproj/Localizable.strings)
-- Preserverà eventuali commenti e formattazioni esistenti
diff --git a/apps/web/src/markdown/docs/it/js.mdx b/apps/web/src/markdown/docs/it/js.mdx
deleted file mode 100644
index 0e0404e0..00000000
--- a/apps/web/src/markdown/docs/it/js.mdx
+++ /dev/null
@@ -1,42 +0,0 @@
-# JavaScript
-
-Languine supporta i file di localizzazione JavaScript/TypeScript, perfetti per le moderne applicazioni web. Questo formato gestisce sia i letterali degli oggetti che le esportazioni dei moduli, supportando strutture annidate e contenuti dinamici.
-
----
-
-## Configurazione
-
-Per prima cosa, assicurati di avere un file di configurazione languine.json nella radice del tuo progetto. Ecco un esempio:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "js": {
-      "include": ["src/locales/[locale].js"]
-    }
-  }
-}
-```
-
-## Traduzione
-
-Con la tua configurazione impostata, esegui:
-
-```bash
-npx languine@latest translate
-```
-
-Quando esegui questo comando, Languine:
-
-- Caricherà i tuoi file JavaScript sorgente (ad esempio, src/locales/en.js)
-- Rileverà eventuali nuove stringhe di traduzione o stringhe modificate
-- Genererà traduzioni per le tue lingue target
-- Creerà o aggiornerà i file delle lingue target (ad esempio, src/locales/sv.js)
-- Preserverà la struttura e le esportazioni dei moduli
-- Gestirà oggetti e array annidati
-- Mantenere la formattazione del codice e i commenti
-- Genererà tipi TypeScript se abilitato
diff --git a/apps/web/src/markdown/docs/it/json.mdx b/apps/web/src/markdown/docs/it/json.mdx
deleted file mode 100644
index 5482af1c..00000000
--- a/apps/web/src/markdown/docs/it/json.mdx
+++ /dev/null
@@ -1,41 +0,0 @@
-# JSON
-
-Languine supporta i file JSON come formato sorgente con i requisiti comuni per la pluralizzazione e l'interpolazione. Questo formato è utilizzato in molti framework come React, Vue, Ruby on Rails e altri.
-
-
----
-
-
-## Configurazione
-
-Per prima cosa, assicurati di avere un file di configurazione languine.json nella radice del tuo progetto. Ecco un esempio:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "json": {
-      "include": ["locales/[locale].json"]
-    }
-  }
-}
-
-```
-
-## Traduzione
-
-Con la tua configurazione impostata, esegui:
-
-```bash
-npx languine@latest translate
-```
-
-Quando esegui questo comando, Languine:
-
-- Caricherà il tuo file JSON sorgente (ad es., locales/en.json)
-- Rileverà eventuali nuove stringhe di traduzione o stringhe modificate
-- Genererà traduzioni per le lingue di destinazione
-- Creerà o aggiornerà i file JSON delle lingue di destinazione (ad es., locales/sv.json, locales/de.json, locales/fr.json)
diff --git a/apps/web/src/markdown/docs/it/md.mdx b/apps/web/src/markdown/docs/it/md.mdx
deleted file mode 100644
index c8283abb..00000000
--- a/apps/web/src/markdown/docs/it/md.mdx
+++ /dev/null
@@ -1,43 +0,0 @@
-# Markdown
-
-Languine supporta la localizzazione dei file Markdown, perfetta per documentazione, post di blog e siti ricchi di contenuti. Questo formato preserva la sintassi Markdown durante la traduzione dei contenuti, inclusa la gestione dei front matter.
-
----
-
-## Impostazione
-
-Per prima cosa, assicurati di avere un file di configurazione languine.json nella radice del tuo progetto. Ecco un esempio:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "md": {
-      "include": ["content/[locale]/**/*.md"]
-    }
-  }
-}
-```
-
-## Traduzione
-
-Con la tua configurazione impostata, esegui:
-
-```bash
-npx languine@latest translate
-```
-
-Quando esegui questo comando, Languine:
-
-- Caricherà i tuoi file Markdown sorgente (ad es., content/en/*.md)
-- Rileverà eventuali contenuti nuovi o modificati
-- Genererà traduzioni per le tue lingue target
-- Creerà o aggiornerà i file delle lingue target (ad es., content/sv/*.md)
-- Preserverà la formattazione e la struttura Markdown
-- Gestirà le traduzioni dei front matter
-- Mantenere i collegamenti e i riferimenti
-- Terrà i blocchi di codice non tradotti
-- Preserverà l'HTML all'interno del Markdown
diff --git a/apps/web/src/markdown/docs/it/mdx.mdx b/apps/web/src/markdown/docs/it/mdx.mdx
deleted file mode 100644
index 08788b93..00000000
--- a/apps/web/src/markdown/docs/it/mdx.mdx
+++ /dev/null
@@ -1,43 +0,0 @@
-# Markdown (MDX)
-
-Languine supporta la localizzazione dei file Markdown (MDX), perfetta per documentazione, post di blog e siti ricchi di contenuti. Questo formato preserva la sintassi Markdown durante la traduzione dei contenuti, inclusa la gestione dei front matter.
-
----
-
-## Configurazione
-
-Per prima cosa, assicurati di avere un file di configurazione languine.json nella radice del tuo progetto. Ecco un esempio:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "mdx": {
-      "include": ["content/[locale]/**/*.mdx"]
-    }
-  }
-}
-```
-
-## Traduzione
-
-Con la tua configurazione impostata, esegui:
-
-```bash
-npx languine@latest translate
-```
-
-Quando esegui questo comando, Languine:
-
-- Caricherà i tuoi file Markdown sorgente (ad es., content/en/*.mdx)
-- Rileverà eventuali contenuti nuovi o modificati
-- Genererà traduzioni per le tue lingue target
-- Creerà o aggiornerà i file delle lingue target (ad es., content/sv/*.mdx)
-- Preserverà la formattazione e la struttura Markdown
-- Gestirà le traduzioni dei front matter
-- Mantenere i collegamenti e i riferimenti
-- Terrà i blocchi di codice non tradotti
-- Preserverà l'HTML all'interno del Markdown
diff --git a/apps/web/src/markdown/docs/it/overrides.mdx b/apps/web/src/markdown/docs/it/overrides.mdx
deleted file mode 100644
index c8da0252..00000000
--- a/apps/web/src/markdown/docs/it/overrides.mdx
+++ /dev/null
@@ -1,7 +0,0 @@
-# Sovrascritture
-
-Languine ti consente di sovrascrivere le traduzioni per chiavi specifiche. Questo è utile quando desideri garantire che una traduzione specifica venga utilizzata per una particolare chiave, indipendentemente dalla traduzione predefinita.
-
-## Come funziona
-
-Nel pannello di controllo, puoi creare sovrascritture per chiavi specifiche. Puoi anche creare sovrascritture per lingue specifiche.
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/it/po.mdx b/apps/web/src/markdown/docs/it/po.mdx
deleted file mode 100644
index 7838baae..00000000
--- a/apps/web/src/markdown/docs/it/po.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# PO (Gettext)
-
-Languine supporta i file PO, il formato di localizzazione Gettext ampiamente utilizzato. Questo formato è popolare in molti ambienti di programmazione, in particolare nelle applicazioni Linux e nei framework PHP, offrendo supporto per contesti, plurali e commenti dei traduttori.
-
----
-
-## Configurazione
-
-Per prima cosa, assicurati di avere un file di configurazione languine.json nella radice del tuo progetto. Ecco un esempio:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "po": {
-      "include": ["locales/[locale]/LC_MESSAGES/messages.po"]
-    }
-  }
-}
-```
-
-## Traduzione
-
-Con la tua configurazione impostata, esegui:
-
-```bash
-npx languine@latest translate
-```
-
-Quando esegui questo comando, Languine:
-
-- Caricherà il tuo file PO sorgente (ad esempio, locales/en/LC_MESSAGES/messages.po)
-- Rileverà eventuali nuove stringhe di traduzione o stringhe modificate
-- Genererà traduzioni per le lingue di destinazione
-- Creerà o aggiornerà i file PO delle lingue di destinazione (ad esempio, locales/sv/LC_MESSAGES/messages.po)
-- Preserverà i metadati, i contesti e le forme plurali
-- Mantenere i commenti dei traduttori e le informazioni di riferimento
diff --git a/apps/web/src/markdown/docs/it/prettier.mdx b/apps/web/src/markdown/docs/it/prettier.mdx
deleted file mode 100644
index 668ab4a5..00000000
--- a/apps/web/src/markdown/docs/it/prettier.mdx
+++ /dev/null
@@ -1,22 +0,0 @@
-# Prettier
-
-Languine può lavorare insieme a [Prettier](https://prettier.io/) per garantire che i tuoi file di traduzione siano formattati in modo coerente. Questo è particolarmente utile quando si lavora con file di traduzione JSON che devono mantenere uno stile uniforme nel tuo progetto.
-
-## Utilizzo con Languine
-
-Il modo consigliato per utilizzare Prettier con Languine è formattare i tuoi file di traduzione dopo che sono stati generati. Puoi configurarlo nel tuo `package.json`:
-
-```json title="package.json"
-{
-  "scripts": {
-    "translate": "languine translate",
-    "format": "prettier --write \"locales/**/*.json\"",
-    "translate:format": "npm run translate && npm run format"
-  }
-}
-```
-
-Ora puoi:
-- Eseguire `npm run translate` per generare solo traduzioni
-- Eseguire `npm run format` per formattare solo i file di traduzione esistenti
-- Eseguire `npm run translate:format` per generare traduzioni e formattarle in sequenza
diff --git a/apps/web/src/markdown/docs/it/properties.mdx b/apps/web/src/markdown/docs/it/properties.mdx
deleted file mode 100644
index 08f59312..00000000
--- a/apps/web/src/markdown/docs/it/properties.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# Proprietà
-
-Languine supporta i file di proprietà Java, il formato standard di localizzazione per le applicazioni Java. Questo formato gestisce l'escaping Unicode e supporta sia coppie chiave-valore che commenti.
-
----
-
-## Configurazione
-
-Per prima cosa, assicurati di avere un file di configurazione languine.json nella radice del tuo progetto. Ecco un esempio:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "properties": {
-      "include": ["src/main/resources/messages_[locale].properties"]
-    }
-  }
-}
-```
-
-## Traduzione
-
-Con la tua configurazione impostata, esegui:
-
-```bash
-npx languine@latest translate
-```
-
-Quando esegui questo comando, Languine:
-
-- Caricherà il tuo file di proprietà sorgente (ad esempio, messages_en.properties)
-- Rileverà eventuali nuove stringhe di traduzione o modifiche
-- Genererà traduzioni per le lingue target
-- Creerà o aggiornerà i file di proprietà delle lingue target (ad esempio, messages_sv.properties)
-- Gestirà automaticamente l'escaping Unicode
-- Preserverà commenti e formattazione
diff --git a/apps/web/src/markdown/docs/it/quickstart.mdx b/apps/web/src/markdown/docs/it/quickstart.mdx
deleted file mode 100644
index feadda93..00000000
--- a/apps/web/src/markdown/docs/it/quickstart.mdx
+++ /dev/null
@@ -1,65 +0,0 @@
-# Introduzione rapida
-
-Inizia installando Languine.
-
-Poi, esegui il seguente comando per inizializzare Languine.
-
-```bash title="Terminale"
-npx languine@latest init
-```
-
-Segui i passaggi per configurare il tuo progetto.
-
----
-
-## Prima Traduzione
-
-Ora sei pronto per tradurre il tuo codice.
-
-Inizia aggiungendo una chiave al tuo file sorgente, ad esempio se scegli di utilizzare `en.json` come tuo file sorgente, aggiungi una chiave ad esso.
-
-```json title="src/locales/en.json"
-{
-  "welcome": "Benvenuto nella nostra applicazione!",
-  "user": {
-    "greeting": "Ciao, {{name}}!",
-    "profile": {
-      "title": "Il tuo profilo",
-      "edit": "Modifica profilo"
-    }
-  },
-  "notifications": {
-    "messages": "Hai {{count}} nuovo/i messaggio/i.",
-    "empty": "Nessuna nuova notifica."
-  }
-}
-
-```
-
----
-
-## Traduci
-
-Esegui il seguente comando per tradurre il tuo contenuto:
-
-```bash title="Terminale"
-npx languine@latest translate
-```
-
-## Questo farà:
-1. Creare file di traduzione per ogni lingua target
-2. Generare traduzioni di alta qualità con il motore Languine
-3. Creare un file `languine.lock` per tenere traccia degli stati di traduzione
-
-Il file di blocco aiuta Languine a identificare quali traduzioni necessitano di aggiornamenti quando il tuo contenuto sorgente cambia. Assicurati di impegnare questo file nel tuo repository.
-
----
-
-## Prossimi Passi
-
-Ora che hai configurato Languine, puoi:
-- Aggiungere più lingue nel tuo file `languine.json`
-- Integrare Languine nel tuo pipeline CI/CD
-- Utilizzare la nostra API per traduzioni programmatiche
-
-Dai un'occhiata alle nostre altre guide per saperne di più sulle funzionalità avanzate di Languine.
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/it/react-email.mdx b/apps/web/src/markdown/docs/it/react-email.mdx
deleted file mode 100644
index c396c974..00000000
--- a/apps/web/src/markdown/docs/it/react-email.mdx
+++ /dev/null
@@ -1,41 +0,0 @@
-# Email React
-
-Languine supporta i modelli di email React, consentendoti di gestire le traduzioni per i tuoi modelli di email costruiti con React Email. Questa integrazione gestisce sia il contenuto testuale che gli attributi HTML, preservando la struttura dei componenti React.
-
----
-
-## Configurazione
-
-Per prima cosa, assicurati di avere un file di configurazione languine.json nella radice del tuo progetto. Ecco un esempio:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "react-email": {
-      "include": ["emails/[locale]/*.tsx"]
-    }
-  }
-}
-```
-
-## Traduzione
-
-Con la tua configurazione impostata, esegui:
-
-```bash
-npx languine@latest translate
-```
-
-Quando esegui questo comando, Languine:
-
-- Caricherà i tuoi modelli di email React sorgente (ad es., emails/en/*.tsx)
-- Rileverà eventuali nuove stringhe di traduzione o modificate
-- Genererà traduzioni per le tue lingue target
-- Creerà o aggiornerà i modelli di email nella lingua target (ad es., emails/sv/*.tsx)
-- Preserverà la struttura e le props dei componenti React
-- Mantenere la formattazione e lo stile HTML
-- Gestirà l'interpolazione e i contenuti dinamici
diff --git a/apps/web/src/markdown/docs/it/ts.mdx b/apps/web/src/markdown/docs/it/ts.mdx
deleted file mode 100644
index d7e148d6..00000000
--- a/apps/web/src/markdown/docs/it/ts.mdx
+++ /dev/null
@@ -1,42 +0,0 @@
-# TypeScript
-
-Languine supporta i file di localizzazione TypeScript con piena sicurezza dei tipi. Questo formato estende il supporto di JavaScript con funzionalità specifiche di TypeScript e capacità di generazione dei tipi.
-
----
-
-## Configurazione
-
-Per prima cosa, assicurati di avere un file di configurazione languine.json nella radice del tuo progetto. Ecco un esempio:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "ts": {
-      "include": ["src/locales/[locale].ts"]
-    }
-  }
-}
-```
-
-## Traduzione
-
-Con la tua configurazione impostata, esegui:
-
-```bash
-npx languine@latest translate
-```
-
-Quando esegui questo comando, Languine:
-
-- Caricherà i tuoi file TypeScript sorgente (ad es., src/locales/en.ts)
-- Rileverà eventuali nuove stringhe di traduzione o stringhe modificate
-- Genererà traduzioni per le tue lingue target
-- Creerà o aggiornerà i file delle lingue target (ad es., src/locales/sv.ts)
-- Preserverà le annotazioni di tipo e le interfacce
-- Gestirà oggetti annidati con la corretta tipizzazione
-- Mantenere la formattazione del codice e i commenti di documentazione
-- Supporterà i tipi letterali e i tipi unione
diff --git a/apps/web/src/markdown/docs/it/xcode-stringsdict.mdx b/apps/web/src/markdown/docs/it/xcode-stringsdict.mdx
deleted file mode 100644
index 7b391751..00000000
--- a/apps/web/src/markdown/docs/it/xcode-stringsdict.mdx
+++ /dev/null
@@ -1,44 +0,0 @@
-# Xcode Stringsdict
-
-Languine supporta il formato Stringsdict di Xcode, utilizzato per regole di pluralizzazione complesse nelle applicazioni iOS e macOS. Questo formato gestisce le forme plurali, le sostituzioni di variabili e le regole di pluralizzazione specifiche per lingua.
-
----
-
-## Configurazione
-
-Per prima cosa, assicurati di avere un file di configurazione languine.json nella radice del tuo progetto. Ecco un esempio:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "stringsdict": {
-      "include": ["MyApp/Localizable.stringsdict"]
-    }
-  }
-}
-```
-
-## Traduzione
-
-Con la tua configurazione impostata, esegui:
-
-```bash
-npx languine@latest translate
-```
-
-Quando esegui questo comando, Languine:
-
-- Caricherà i tuoi file Stringsdict
-- Rileverà eventuali nuove o modificate regole di pluralizzazione
-- Genererà traduzioni per le lingue target
-- Aggiornerà i file Stringsdict con le nuove traduzioni
-- Gestirà regole di pluralizzazione complesse per ogni lingua
-- Mantenere le sostituzioni di variabili
-- Preserverà la struttura del dizionario
-- Supporterà forme plurali specifiche per lingua
-- Validerà la coerenza delle regole di pluralizzazione
-- Mantenere i formati specificatori
diff --git a/apps/web/src/markdown/docs/it/xcode-xcstrings.mdx b/apps/web/src/markdown/docs/it/xcode-xcstrings.mdx
deleted file mode 100644
index 0cc85274..00000000
--- a/apps/web/src/markdown/docs/it/xcode-xcstrings.mdx
+++ /dev/null
@@ -1,44 +0,0 @@
-# Xcode Strings (XCStrings)
-
-Languine supporta il formato XCStrings di Xcode, il moderno formato di localizzazione per applicazioni iOS e macOS. Questo formato gestisce cataloghi di stringhe con supporto per variazioni, pluralizzazione e commenti degli sviluppatori.
-
----
-
-## Configurazione
-
-Per prima cosa, assicurati di avere un file di configurazione languine.json nella radice del tuo progetto. Ecco un esempio:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "xcstrings": {
-      "include": ["MyApp/Localizable.xcstrings"]
-    }
-  }
-}
-```
-
-## Traduzione
-
-Con la tua configurazione impostata, esegui:
-
-```bash
-npx languine@latest translate
-```
-
-Quando esegui questo comando, Languine:
-
-- Caricherà il tuo catalogo XCStrings
-- Rileverà eventuali nuove stringhe o stringhe modificate
-- Genererà traduzioni per le tue lingue target
-- Aggiornerà il catalogo delle stringhe con le nuove traduzioni
-- Preserverà le variazioni delle stringhe e le regole di pluralizzazione
-- Mantenere i commenti e il contesto degli sviluppatori
-- Gestirà le sostituzioni delle variabili
-- Supporterà stringhe adattive
-- Mantenere i specificatori di formattazione
-- Validerà la struttura del catalogo delle stringhe
diff --git a/apps/web/src/markdown/docs/it/xliff.mdx b/apps/web/src/markdown/docs/it/xliff.mdx
deleted file mode 100644
index abc14ea5..00000000
--- a/apps/web/src/markdown/docs/it/xliff.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# XLIFF
-
-Languine supporta XLIFF (XML Localization Interchange File Format), un formato basato su XML progettato per lo scambio di dati di localizzazione. Questo formato è ampiamente utilizzato nei flussi di lavoro di traduzione professionale e supporta sia le versioni XLIFF 1.2 che 2.0.
-
----
-
-## Configurazione
-
-Per prima cosa, assicurati di avere un file di configurazione languine.json nella radice del tuo progetto. Ecco un esempio:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "xliff": {
-      "include": ["locales/[locale].xlf"]
-    }
-  }
-}
-```
-
-## Traduzione
-
-Con la tua configurazione impostata, esegui:
-
-```bash
-npx languine@latest translate
-```
-
-Quando esegui questo comando, Languine:
-
-- Caricherà il tuo file XLIFF sorgente (ad esempio, locales/en.xlf)
-- Rileverà eventuali unità di traduzione nuove o modificate
-- Genererà traduzioni per le tue lingue target
-- Creerà o aggiornerà i file XLIFF delle lingue target (ad esempio, locales/sv.xlf)
-- Preserverà note, informazioni di contesto e attributi di stato
-- Mantenere la compatibilità con gli strumenti CAT (Computer-Aided Translation)
diff --git a/apps/web/src/markdown/docs/it/xml.mdx b/apps/web/src/markdown/docs/it/xml.mdx
deleted file mode 100644
index f799b12a..00000000
--- a/apps/web/src/markdown/docs/it/xml.mdx
+++ /dev/null
@@ -1,44 +0,0 @@
-# XML
-
-Languine supporta la localizzazione dei file XML, adatta per vari file di configurazione e contenuto basati su XML. Questo formato gestisce strutture XML complesse mantenendo la formattazione e gli attributi.
-
----
-
-## Impostazione
-
-Per prima cosa, assicurati di avere un file di configurazione languine.json nella radice del tuo progetto. Ecco un esempio:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "xml": {
-      "include": ["resources/[locale]/*.xml"]
-    }
-  }
-}
-```
-
-## Traduzione
-
-Con la tua configurazione impostata, esegui:
-
-```bash
-npx languine@latest translate
-```
-
-Quando esegui questo comando, Languine:
-
-- Caricherà i tuoi file XML sorgente (ad es., resources/en/*.xml)
-- Rileverà eventuali contenuti nuovi o modificati
-- Genererà traduzioni per le tue lingue target
-- Creerà o aggiornerà i file delle lingue target (ad es., resources/sv/*.xml)
-- Preserverà la struttura e la formattazione XML
-- Gestirà le traduzioni degli attributi
-- Mantenere le sezioni CDATA
-- Terrà i commenti XML
-- Supporterà i namespace XML
-- Validerà la struttura XML
diff --git a/apps/web/src/markdown/docs/it/yaml.mdx b/apps/web/src/markdown/docs/it/yaml.mdx
deleted file mode 100644
index ccc8a93c..00000000
--- a/apps/web/src/markdown/docs/it/yaml.mdx
+++ /dev/null
@@ -1,39 +0,0 @@
-# YAML
-
-Languine supporta i file YAML come formato sorgente, comunemente utilizzato in Ruby on Rails, Laravel e altri framework. Questo formato supporta strutture annidate, array e tipi di dati complessi.
-
----
-
-## Configurazione
-
-Per prima cosa, assicurati di avere un file di configurazione languine.json nella radice del tuo progetto. Ecco un esempio:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "yaml": {
-      "include": ["config/locales/[locale].yml"]
-    }
-  }
-}
-```
-
-## Traduzione
-
-Con la tua configurazione impostata, esegui:
-
-```bash
-npx languine@latest translate
-```
-
-Quando esegui questo comando, Languine:
-
-- Caricherà il tuo file YAML sorgente (ad es., config/locales/en.yml)
-- Rileverà eventuali nuove stringhe di traduzione o modificate
-- Genererà traduzioni per le lingue target
-- Creerà o aggiornerà i file YAML delle lingue target (ad es., config/locales/sv.yml)
-- Preserverà le strutture annidate e il formato
diff --git a/apps/web/src/markdown/docs/ja/csv.mdx b/apps/web/src/markdown/docs/ja/csv.mdx
deleted file mode 100644
index bb41e7d9..00000000
--- a/apps/web/src/markdown/docs/ja/csv.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# CSV
-
-Languineは、シンプルな翻訳管理のためにCSV（カンマ区切り値）ファイルをサポートしています。このフォーマットは、スプレッドシートベースのワークフローに最適で、外部翻訳ツールとの簡単な統合が可能です。
-
----
-
-## セットアップ
-
-まず、プロジェクトのルートにlanguine.config.jsonまたはlanguine.config.tsの設定ファイルがあることを確認してください。以下はその例です：
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "csv": {
-      "include": ["translations/[locale].csv"]
-    }
-  }
-}
-```
-
-## 翻訳
-
-設定が完了したら、次のコマンドを実行します：
-
-```bash
-npx languine@latest translate
-```
-
-このコマンドを実行すると、Languineは以下の処理を行います：
-
-- ソースCSVファイル（例：translations/en.csv）を読み込む
-- 新しいまたは変更された翻訳文字列を検出する
-- 対象言語の翻訳を生成する
-- 対象言語のCSVファイルを作成または更新する（例：translations/sv.csv）
-- 列の構造とフォーマットを維持する
-- 追加のメタデータ列を保持する
diff --git a/apps/web/src/markdown/docs/ja/ios.mdx b/apps/web/src/markdown/docs/ja/ios.mdx
deleted file mode 100644
index fd6d208d..00000000
--- a/apps/web/src/markdown/docs/ja/ios.mdx
+++ /dev/null
@@ -1,39 +0,0 @@
-# iOS
-
-Languineは、iOSアプリケーションの標準ローカリゼーション形式であるiOS Localizable.stringsファイルをサポートしています。この形式は、基本的なキーと値の文字列ペアを処理し、翻訳者にコンテキストを提供するためのコメントをサポートします。
-
----
-
-## セットアップ
-
-まず、プロジェクトのルートにlanguine.config.jsonまたはlanguine.config.tsの設定ファイルがあることを確認してください。以下はその例です：
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "ios": {
-      "include": ["[locale].lproj/Localizable.strings"]
-    }
-  }
-}
-```
-
-## 翻訳
-
-設定が完了したら、次のコマンドを実行します：
-
-```bash
-npx languine@latest translate
-```
-
-このコマンドを実行すると、Languineは以下を行います：
-
-- ソースのLocalizable.stringsファイル（例：en.lproj/Localizable.strings）を読み込みます
-- 新しいまたは変更された翻訳文字列を検出します
-- 対象言語の翻訳を生成します
-- 対象言語ファイル（例：sv.lproj/Localizable.strings）を作成または更新します
-- 既存のコメントとフォーマットを保持します
diff --git a/apps/web/src/markdown/docs/ja/quickstart.mdx b/apps/web/src/markdown/docs/ja/quickstart.mdx
deleted file mode 100644
index 8302513e..00000000
--- a/apps/web/src/markdown/docs/ja/quickstart.mdx
+++ /dev/null
@@ -1,60 +0,0 @@
-# クイックスタート
-
-Languineをインストールすることから始めましょう。
-
-次に、以下のコマンドを実行してLanguineを初期化します。
-
-```bash title="ターミナル"
-npx languine@latest init
-```
-
-プロジェクトを設定するための手順に従ってください。
-
-## 最初の翻訳
-
-これでコードの翻訳を行う準備が整いました。
-
-まず、ソースファイルにキーを追加します。たとえば、`en.json`をソースファイルとして使用する場合は、それにキーを追加します。
-
-```json title="src/locales/en.json"
-{
-  "welcome": "私たちのアプリケーションへようこそ！",
-  "user": {
-    "greeting": "こんにちは、{{name}}！",
-    "profile": {
-      "title": "あなたのプロフィール",
-      "edit": "プロフィールを編集"
-    }
-  },
-  "notifications": {
-    "messages": "{{count}} 件の新しいメッセージがあります。",
-    "empty": "新しい通知はありません。"
-  }
-}
-
-```
-
-
-## 翻訳
-
-以下のコマンドを実行してコンテンツを翻訳します：
-
-```bash title="ターミナル"
-npx languine@latest translate
-```
-
-## これにより：
-1. 各ターゲット言語の翻訳ファイルが作成されます
-2. Languineエンジンによる高品質な翻訳が生成されます
-3. 翻訳の状態を追跡するための`languine.lock`ファイルが作成されます
-
-ロックファイルは、ソースコンテンツが変更されたときにLanguineがどの翻訳を更新する必要があるかを特定するのに役立ちます。このファイルをリポジトリにコミットすることを忘れないでください。
-
-## 次のステップ
-
-Languineの設定が完了したので、次のことができます：
-- `languine.config.json`ファイルに他の言語を追加する
-- CI/CDパイプラインにLanguineを統合する
-- プログラムによる翻訳のためにAPIを使用する
-
-Languineの高度な機能について詳しく知るには、他のガイドもご覧ください。
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/ko/android.mdx b/apps/web/src/markdown/docs/ko/android.mdx
deleted file mode 100644
index 11ba3d8e..00000000
--- a/apps/web/src/markdown/docs/ko/android.mdx
+++ /dev/null
@@ -1,39 +0,0 @@
-# 안드로이드
-
-Languine은 Android 문자열 리소스(strings.xml)를 소스 형식으로 지원하며, 복수형, 문자열 배열 및 형식화된 문자열을 처리합니다. 이 형식은 Android 애플리케이션에서 번역을 관리하는 표준 방법입니다.
-
----
-
-## 설정하기
-
-먼저, 프로젝트 루트에 languine.json 구성 파일이 있는지 확인하세요. 다음은 예시입니다:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "android": {
-      "include": ["app/src/main/res/values-[locale]/strings.xml"]
-    }
-  }
-}
-```
-
-## 번역하기
-
-구성이 설정되면, 다음을 실행하세요:
-
-```bash
-npx languine@latest translate
-```
-
-이 명령을 실행하면, Languine은:
-
-- 소스 strings.xml 파일(예: values/strings.xml)을 로드합니다.
-- 새로운 또는 수정된 번역 문자열을 감지합니다.
-- 대상 언어에 대한 번역을 생성합니다.
-- 대상 언어 XML 파일(예: values-sv/strings.xml, values-de/strings.xml, values-fr/strings.xml)을 생성하거나 업데이트합니다.
-- 기존 문자열 배열 및 복수형 형식을 유지합니다.
diff --git a/apps/web/src/markdown/docs/ko/arb.mdx b/apps/web/src/markdown/docs/ko/arb.mdx
deleted file mode 100644
index 4103e855..00000000
--- a/apps/web/src/markdown/docs/ko/arb.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# ARB (응용 프로그램 리소스 번들)
-
-Languine은 Flutter 애플리케이션의 표준 로컬라이제이션 형식인 ARB 파일을 지원합니다. 이 형식은 복수형, 자리 표시자 및 선택 표현을 처리하면서 Flutter의 intl 패키지와의 호환성을 유지합니다.
-
----
-
-## 설정하기
-
-먼저, 프로젝트 루트에 languine.json 구성 파일이 있는지 확인하세요. 다음은 예시입니다:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "arb": {
-      "include": ["lib/l10n/intl_[locale].arb"]
-    }
-  }
-}
-```
-
-## 번역하기
-
-구성이 완료되면 다음 명령어를 실행하세요:
-
-```bash
-npx languine@latest translate
-```
-
-이 명령어를 실행하면 Languine이:
-
-- 소스 ARB 파일(예: lib/l10n/intl_en.arb)을 로드합니다.
-- 새로운 또는 수정된 번역 문자열을 감지합니다.
-- 대상 언어에 대한 번역을 생성합니다.
-- 대상 언어 ARB 파일(예: lib/l10n/intl_sv.arb)을 생성하거나 업데이트합니다.
-- 메타데이터, 자리 표시자 및 복수형/선택 표현을 보존합니다.
-
diff --git a/apps/web/src/markdown/docs/ko/authentication.mdx b/apps/web/src/markdown/docs/ko/authentication.mdx
deleted file mode 100644
index a048c088..00000000
--- a/apps/web/src/markdown/docs/ko/authentication.mdx
+++ /dev/null
@@ -1,48 +0,0 @@
-# 인증
-
-Languine을 사용하려면 엔진에 인증해야 하며, 시작하는 데 몇 초밖에 걸리지 않습니다.
-
----
-
-## 로그인
-
-[Languine 대시보드](https://languine.ai/login)에서 직접 로그인하거나 다음 명령어를 실행할 수 있습니다:
-
-```bash title="터미널"
-npx languine@latest auth login
-```
-
-
-계정이 이미 있는 경우 자동으로 로그인되며, 세션이 귀하의 기계에 저장됩니다.
-
----
-
-## 로그아웃
-
-다음 명령어를 실행하여 로그아웃할 수 있습니다:
-
-```bash title="터미널"
-npx languine@latest auth logout
-```
-
----
-
-## 사용자 세션
-
-다음 명령어를 실행하여 로그인 상태를 확인할 수 있습니다:
-
-```bash title="터미널"
-npx languine@latest auth whoami
-```
-
----
-
-
-# 환경 변수
-
-Languine을 구성하기 위해 다음 환경 변수를 설정할 수 있습니다:
-
-- `LANGUINE_API_KEY`: 인증에 사용할 API 키입니다.
-- `LANGUINE_PROJECT_ID`: 프로젝트에 사용할 프로젝트 ID입니다.
-
-[Languine 대시보드](https://languine.ai/login)에서 확인할 수 있습니다.
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/ko/biome.mdx b/apps/web/src/markdown/docs/ko/biome.mdx
deleted file mode 100644
index 82170771..00000000
--- a/apps/web/src/markdown/docs/ko/biome.mdx
+++ /dev/null
@@ -1,24 +0,0 @@
-# 생태계
-
-Languine은 [Biome](https://biomejs.dev/)와 함께 작업하여 번역 파일이 일관되게 형식화되도록 할 수 있습니다. 이는 프로젝트 전반에 걸쳐 일관된 스타일을 유지해야 하는 JSON 번역 파일 작업 시 특히 유용합니다.
-
-## Languine과 함께 사용하기
-
-Languine과 함께 Biome을 사용하는 권장 방법은 번역 파일이 생성된 후에 형식을 지정하는 것입니다. 이를 `package.json`에서 설정할 수 있습니다:
-
-```json title="package.json"
-{
-  "scripts": {
-    "translate": "languine translate",
-    "format": "biome format \"locales/**/*.json\"",
-    "translate:format": "npm run translate && npm run format"
-  }
-}
-```
-
-이제 다음을 수행할 수 있습니다:
-- `npm run translate`를 실행하여 번역만 생성
-- `npm run format`을 실행하여 기존 번역 파일만 형식화
-- `npm run translate:format`을 실행하여 번역을 생성하고 순차적으로 형식화
-
-이 구성은 번역 파일이 2칸 들여쓰기로 일관되게 형식화되고 최대 80자 너비로 제한되도록 보장합니다.
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/ko/ci.mdx b/apps/web/src/markdown/docs/ko/ci.mdx
deleted file mode 100644
index 28928fd8..00000000
--- a/apps/web/src/markdown/docs/ko/ci.mdx
+++ /dev/null
@@ -1,96 +0,0 @@
-# CI/CD
-
-Languine은 애플리케이션 번역을 돕기 위해 CI/CD 통합 기능을 제공합니다.
-
----
-
-## 작동 방식
-
-Languine의 CI/CD 워크플로우는 애플리케이션의 번역 업데이트를 자동화하기 위한 구조화된 프로세스를 따릅니다:
-
-### 1. 작업 초기화
-- 작업이 트리거되면 워크플로우가 시작됩니다.
-- 필요한 Git 구성 및 자격 증명을 설정합니다.
-
-### 2. Languine 엔진 처리
-- Languine 엔진이 애플리케이션의 내용을 처리합니다.
-- 구성된 설정을 사용하여 번역 작업을 수행합니다.
-
-### 3. 변경 감지
-시스템은 번역 변경 사항을 확인하고 두 가지 경로 중 하나를 따릅니다:
-
-**변경 사항이 발견된 경우:**
-- 변경 사항이 리포지토리에 커밋됩니다.
-- 변경 사항이 지정된 브랜치에 푸시됩니다.
-- Pull Request (PR)가 생성됩니다.
-
-**변경 사항이 발견되지 않은 경우:**
-- 워크플로우가 PR을 생성하지 않고 완료됩니다.
-
-### 4. Pull Request 생성
-변경 사항이 감지되면 다음과 함께 Pull Request가 생성됩니다:
-
-**PR 내용:**
-- 번역 업데이트를 나타내는 명확한 제목
-- 변경 사항에 대한 자세한 설명
-- 품질 검사 확인
-- 검토를 위한 지침
-- 문서 및 지원 링크
-
-**PR 설명 포함:**
-- 번역 업데이트 요약
-- 변경된 내용 목록 (업데이트된 번역, 용어 일관성)
-- 검토자를 위한 다음 단계
-- 문서 및 지원 리소스 링크
-
----
-
-## 워크플로우 다이어그램
-
-<div className="flex flex-col items-center justify-center p-4 h-[400px] sm:h-[500px] md:h-[650px]">
-  <pre
-    className="p-4 text-sm leading-5 mb-4 scale-[0.5] sm:scale-[0.65] md:scale-90 transform-gpu"
-    style={{
-      fontFamily: "monospace",
-      whiteSpace: "pre",
-      textAlign: "left",
-    }}
-  >
-    {`
-                    ┌─────────────────────┐
-                    │   작업 시작        │
-                    └──────────┬──────────┘
-                               │
-                    ┌──────────▼──────────┐
-                    │    Git 및 설정      │
-                    │    자격 증명        │
-                    └──────────┬──────────┘
-                               │
-┌─────────────────────────────────────────────────────────┐
-│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-│░░░░░░░░░░░░░░░░░░░░ Languine 엔진 ░░░░░░░░░░░░░░░░░░░░│
-│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-└─────────────────────────────────────────────────────────┘
-                               │
-                    ┌──────────▼──────────┐
-                    │   변경 사항 확인    │───────┐
-                    └──────────┬──────────┘       │
-                               │                  │
-                               │ [변경 사항]      │ [변경 없음]
-                               │                  │
-                    ┌──────────▼──────────┐       │
-                    │   커밋 및 푸시      │       │
-                    └──────────┬──────────┘       │
-                               │                  │
-                    ┌──────────▼──────────┐       │
-                    │    PR 생성          │       │
-                    └──────────┬──────────┘       │
-                               │                  │
-                    ┌──────────▼──────────┐       │
-                    │        완료         │◄──────┘
-                    └─────────────────────┘
-`}
-  </pre>
-</div>
-
-워크플로우는 자동화되도록 설계되었지만, 변경 사항이 코드베이스에 병합되기 전에 인간 검토 및 품질 관리를 허용합니다. 버전 관리 모범 사례를 유지하며, 번역이 Git 기록을 통해 적절하게 추적되고 문서화되도록 보장합니다.
diff --git a/apps/web/src/markdown/docs/ko/cli.mdx b/apps/web/src/markdown/docs/ko/cli.mdx
deleted file mode 100644
index fae9fc69..00000000
--- a/apps/web/src/markdown/docs/ko/cli.mdx
+++ /dev/null
@@ -1,65 +0,0 @@
-# CLI
-
-Languine은 애플리케이션 번역을 돕기 위한 CLI를 제공합니다.
-
----
-
-## 명령어 개요
-
-### 번역
-
-`translate` 명령어는 애플리케이션을 번역하는 데 사용됩니다.
-
-```bash title="Terminal"
-    npx languine@latest translate
-```
-
----
-
-### 초기화
-
-`init` 명령어는 새로운 Languine 프로젝트를 초기화하는 데 사용됩니다.
-
-```bash title="Terminal"
-    npx languine@latest init
-```
-
----
-
-### 인증
-
-`auth` 명령어는 Languine에 인증하는 데 사용됩니다.
-
-```bash title="Terminal"
-    npx languine@latest auth
-```
-
----
-
-### 동기화
-
-`sync` 명령어는 애플리케이션을 Languine과 동기화하는 데 사용됩니다.
-
-```bash title="Terminal"
-    npx languine@latest sync
-```
-
----
-
-### 로케일 추가
-
-`locale` 명령어는 애플리케이션의 로케일을 관리하는 데 사용됩니다.
-
-```bash title="Terminal"
-    npx languine@latest locale add pt,fr
-```
-
----
-
-### 로케일 제거
-
-`locale remove` 명령어는 애플리케이션에서 로케일을 제거하는 데 사용됩니다.
-
-```bash title="Terminal"
-    npx languine@latest locale remove pt,fr
-```
diff --git a/apps/web/src/markdown/docs/ko/configuration.mdx b/apps/web/src/markdown/docs/ko/configuration.mdx
deleted file mode 100644
index e994ae9b..00000000
--- a/apps/web/src/markdown/docs/ko/configuration.mdx
+++ /dev/null
@@ -1,180 +0,0 @@
-# 구성
-
-Languine은 번역 설정을 관리하기 위해 JSON 구성 파일(languine.json)을 사용합니다. 이 파일은 소스 언어와 대상 언어, 번역이 필요한 파일을 정의합니다.
-
----
-
-## 기본 구성
-
-다음은 두 가지 형식의 기본 예입니다:
-
-```json title="languine.json"
-{
-  "locale": {
-    "source": "en",
-    "targets": ["es", "fr", "de"]
-  },
-  "files": {
-    "json": {
-      "include": ["locales/[locale].json"]
-    }
-  }
-}
-```
-
-구성 파일의 다양한 섹션을 살펴보겠습니다.
-
----
-
-## 로케일 구성
-
-로케일 섹션은 번역 언어를 정의합니다:
-
-- source: 콘텐츠 생성의 기본 언어 (예: "en"은 영어)
-- targets: 번역하고자 하는 언어의 배열 (예: ["es", "fr", "de"]는 스페인어, 프랑스어, 독일어)
-
-Languine은 다음과 같은 다양한 언어 코드를 지원합니다:
-- 간단한 코드: en, es, fr, de
-- 지역별 코드: pt-BR, zh-CN, zh-TW
-
-## 파일 구성
-
-파일 섹션은 Languine이 번역해야 할 파일을 정의합니다. 여러 파일 유형과 패턴을 구성할 수 있습니다:
-
----
-
-### JSON 파일
-```json
-files: {
-  json: {
-    include: ["locales/[locale].json"],
-  },
-}
-```
-
----
-
-### Markdown/MDX 파일
-```json
-files: {
-  md: {
-    include: ["docs/[locale]/*.md"],
-  },
-  mdx: {
-    include: ["blog/[locale]/*.mdx"],
-  },
-}
-```
-
----
-
-### 모바일 플랫폼 파일
-
-iOS (Xcode)의 경우:
-```json
-files: {
-  "xcode-xcstrings": {
-    include: ["Example/Localizable.xcstrings"],
-  },
-  // 전통적인 .strings 파일의 경우
-  "xcode-strings": {
-    include: ["Example/[locale].lproj/Localizable.strings"],
-  },
-}
-```
-
----
-
-Android의 경우:
-```json
-files: {
-  android: {
-    include: ["locales/[locale].xml"],
-  },
-}
-```
-
----
-
-### 기타 형식
-
-Languine이 지원하는 파일 형식의 전체 목록은 다음과 같습니다:
-
-- [JSON](/docs/json) - 표준 JSON 번역 파일
-- [YAML](/docs/yaml) - YAML 번역 파일
-- [Properties](/docs/properties) - Java 속성 파일
-- [Android](/docs/android) - Android XML 리소스 파일
-- [iOS](/docs/ios) - iOS 지역화 파일
-- [iOS Stringsdict](/docs/xcode-stringsdict) - iOS 복수형 파일
-- [iOS XCStrings](/docs/xcode-xcstrings) - 현대 Xcode 문자열 카탈로그
-- [Markdown](/docs/md) - 문서 파일
-- [MDX](/docs/mdx) - JSX가 포함된 문서
-- [HTML](/docs/html) - HTML 파일
-- [JavaScript](/docs/js) - JavaScript 파일
-- [TypeScript](/docs/ts) - TypeScript 파일
-- [Gettext PO](/docs/po) - GetText 번역 파일
-- [XLIFF](/docs/xliff) - XML 지역화 교환 파일 형식
-- [CSV](/docs/csv) - 스프레드시트 기반 번역
-- [XML](/docs/xml) - XML 리소스 파일
-- [Flutter ARB](/docs/arb) - 애플리케이션 리소스 번들 파일
-
----
-
-## 파일 패턴
-
-파일 패턴의 [locale] 자리 표시자는 번역 중에 적절한 언어 코드로 자동 교체됩니다. 예를 들어:
-
-- locales/[locale].json은 다음과 같이 변환됩니다:
-  - locales/en.json
-  - locales/es.json
-  - locales/fr.json
-
-각 파일 유형에 대해 여러 패턴을 포함할 수 있으며 glob 패턴을 사용할 수 있습니다:
-```json
-files: {
-  json: {
-    include: [
-      "src/locales/[locale].json",
-      "src/components/[locale]/*.json"
-    ],
-  },
-}
-```
-
----
-
-## 프로젝트 ID (선택 사항)
-
-Languine의 클라우드 서비스를 사용하는 경우 구성에 프로젝트 ID를 포함할 수 있습니다:
-
-```json
-{
-  "projectId": "prj_your_project_id",
-  "locale": {
-    // ... 로케일 구성
-  },
-  files: {
-    // ... 파일 구성
-  },
-}
-```
-
----
-
-## 번역 상태 추적
-
-Languine은 번역 상태를 추적하기 위해 자동으로 languine.lock 파일을 생성하고 유지 관리합니다. 이 파일은:
-
-- 어떤 콘텐츠가 번역되었는지 추적합니다
-- 소스 콘텐츠가 변경될 때 업데이트해야 할 내용을 식별하는 데 도움을 줍니다
-- 버전 관리 시스템에 커밋해야 합니다
-
-잠금 파일을 수동으로 편집할 필요는 없습니다 - Languine은 번역 명령을 실행할 때 자동으로 관리합니다.
-
-## 모범 사례
-
-1. **버전 관리**: 항상 languine.json과 languine.lock을 리포지토리에 커밋하세요
-2. **파일 조직**: 번역 파일을 일관된 디렉토리 구조로 정리하세요
-3. **언어 코드**: 호환성을 보장하기 위해 표준 언어 코드를 사용하세요
-4. **패턴**: 불필요한 파일 번역을 피하기 위해 특정 포함 패턴을 사용하세요
-5. **프로젝트 ID**: 클라우드 서비스를 사용하는 경우 프로젝트 ID를 안전하게 유지하고 공개적으로 공유하지 마세요. 대신 `LANGUINE_PROJECT_ID` 환경 변수를 사용하세요.
diff --git a/apps/web/src/markdown/docs/ko/csv.mdx b/apps/web/src/markdown/docs/ko/csv.mdx
deleted file mode 100644
index 2cd7b16e..00000000
--- a/apps/web/src/markdown/docs/ko/csv.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# CSV
-
-Languine은 간단한 번역 관리를 위해 CSV(Comma-Separated Values) 파일을 지원합니다. 이 형식은 스프레드시트 기반의 작업 흐름에 적합하며 외부 번역 도구와의 쉬운 통합이 가능합니다.
-
----
-
-## 설정하기
-
-먼저, 프로젝트 루트에 languine.json 구성 파일이 있는지 확인하세요. 다음은 예시입니다:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "csv": {
-      "include": ["translations/[locale].csv"]
-    }
-  }
-}
-```
-
-## 번역하기
-
-구성이 완료되면 다음 명령어를 실행하세요:
-
-```bash
-npx languine@latest translate
-```
-
-이 명령어를 실행하면 Languine은:
-
-- 소스 CSV 파일(예: translations/en.csv)을 로드합니다.
-- 새로운 또는 수정된 번역 문자열을 감지합니다.
-- 대상 언어에 대한 번역을 생성합니다.
-- 대상 언어 CSV 파일(예: translations/sv.csv)을 생성하거나 업데이트합니다.
-- 열 구조와 형식을 유지합니다.
-- 추가 메타데이터 열을 보존합니다.
diff --git a/apps/web/src/markdown/docs/ko/expo.mdx b/apps/web/src/markdown/docs/ko/expo.mdx
deleted file mode 100644
index b8da69f9..00000000
--- a/apps/web/src/markdown/docs/ko/expo.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# 엑스포
-
-Languine은 Expo 로컬라이제이션을 지원하며, Expo의 i18n 시스템과 원활하게 통합됩니다. 이 형식은 JavaScript 및 TypeScript 프로젝트 모두에서 작동하며, 중첩 구조와 복수형을 지원합니다.
-
----
-
-## 설정하기
-
-먼저, 프로젝트 루트에 languine.json 구성 파일이 있는지 확인하세요. 다음은 예시입니다:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "expo": {
-      "include": ["assets/locales/[locale].json"]
-    }
-  }
-}
-```
-
-## 번역하기
-
-구성이 완료되면, 다음 명령어를 실행하세요:
-
-```bash
-npx languine@latest translate
-```
-
-이 명령어를 실행하면, Languine은:
-
-- 소스 번역 파일(예: assets/locales/en.json)을 로드합니다.
-- 새로운 또는 수정된 번역 문자열을 감지합니다.
-- 대상 언어에 대한 번역을 생성합니다.
-- 대상 언어 파일(예: assets/locales/sv.json)을 생성하거나 업데이트합니다.
-- 중첩 구조와 복수형 규칙을 유지합니다.
-- expo-localization과의 호환성을 유지합니다.
diff --git a/apps/web/src/markdown/docs/ko/github-actions.mdx b/apps/web/src/markdown/docs/ko/github-actions.mdx
deleted file mode 100644
index dbb6d66c..00000000
--- a/apps/web/src/markdown/docs/ko/github-actions.mdx
+++ /dev/null
@@ -1,147 +0,0 @@
-# GitHub Actions
-
-GitHub Action을 사용하면 코드를 리포지토리에 푸시하기만 하면 쉽게 번역할 수 있습니다. 그러면 GitHub Action이 새로운 키를 번역하고, 풀 리퀘스트를 생성하거나 변경 사항을 커밋합니다.
-이렇게 하면 많은 시간과 노력을 절약하면서도 높은 품질의 번역을 유지할 수 있습니다.
-
----
-
-## 작동 방식
-
-
-
-<div className="flex flex-col items-center justify-center p-4 mb-8 h-[400px] sm:h-[500px] md:h-[650px]">
-        <pre
-          className="p-4 text-sm leading-5 scale-[0.5] sm:scale-[0.65] md:scale-90 transform-gpu"
-          style={{
-            fontFamily: "monospace",
-            whiteSpace: "pre",
-            textAlign: "left",
-          }}
-        >
-          {`
-                                  ┌───────────────┐
-                                  │   Git Push    │
-                                  └───────────────┘
-                                          │
-                                          ▼
-             ┌─────────────────────────────────────────────────────────┐
-             │░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-             │░░░░░░░░░░░░░░░░░░░░ Languine Engine ░░░░░░░░░░░░░░░░░░░░│
-             │░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-             └─────────────────────────────────────────────────────────┘
-                                          │
-                                          ▼
-                                          │
-            ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┼ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─
-           │                              │                              │
-           ▼                              ▼                              ▼
- ╔═══════════════════╗          ╔═══════════════════╗          ╔═══════════════════╗
- ║                   ║          ║                   ║          ║                   ║
- ║      영어        ║          ║      스페인어    ║          ║      일본어      ║
- ║    번역         ║          ║    번역         ║          ║     번역        ║
- ║                   ║          ║                   ║          ║                   ║
- ╚═══════════════════╝          ╚═══════════════════╝          ╚═══════════════════╝
-           │                              │                              │
-           └──────────────────────────────┼──────────────────────────────┘
-                                          ▼
-                                  ┌───────────────┐
-                                  │     병합      │
-                                  │ 풀 리퀘스트   │
-                                  └───────────────┘
-                                          │
-                                          ▼
-                              ┌─────────────────────┐
-                              │      완료됨        │
-                              │      (배포)        │
-                              └─────────────────────┘
-`}
-        </pre>
-      </div>
-
----
-
-## 설치
-
-리포지토리에서 Languine GitHub Action을 사용하려면 다음을 수행해야 합니다:
-
-1. Languine 자격 증명으로 리포지토리 비밀을 설정합니다.
-2. 리포지토리에 워크플로 파일을 생성합니다.
-
-### 리포지토리 비밀 설정
-
-리포지토리 설정(설정 > 비밀 및 변수 > 작업)에서 다음 비밀을 추가합니다:
-
-- `LANGUINE_API_KEY`: Languine API 키
-- `LANGUINE_PROJECT_ID`: Languine 프로젝트 ID
-
-이 값들은 Languine 대시보드의 프로젝트 설정에서 찾을 수 있습니다.
-
-
-
-### 환경 변수
-
-GitHub Action은 다음 환경 변수를 사용합니다:
-- `LANGUINE_API_KEY` (필수): 인증을 위한 Languine API 키
-- `LANGUINE_PROJECT_ID` (필수): Languine 프로젝트 ID 
-- `GITHUB_TOKEN` (필수): GitHub에서 자동으로 제공되며, PR 생성을 위해 사용됩니다.
-
-### 예제 워크플로
-
-리포지토리에 다음 내용을 가진 .github/workflows/languine.yml 파일을 새로 만듭니다:
-
-```ts title=".github/workflows/release.yml"
-name: 웹사이트 배포
-
-on:
-  push:
-    branches:
-      - '**'
-    paths:
-      - apps/web/**
-
-jobs:
-  translate:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-      pull-requests: write
-    steps:
-      - uses: actions/checkout@v4
-      
-      - name: Languine Action
-        uses: languine/languine-action@v1
-        env:
-           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          api-key: ${{ secrets.LANGUINE_API_KEY }}
-          project-id: ${{ secrets.LANGUINE_PROJECT_ID }}
-```
- 
- 이 워크플로는:
-- 메인 브랜치에 푸시할 때 실행됩니다.
-- 메인 브랜치에 대한 풀 리퀘스트에서 실행됩니다.
-- 작업 탭에서 수동으로 트리거할 수 있습니다.
-- 코드를 체크아웃하고 Languine 번역 프로세스를 실행합니다.
-- 새로운 번역이 있을 경우 풀 리퀘스트를 생성합니다(구성 가능).
-
-#### 작업 디렉토리 옵션
-
-`working-directory` 옵션을 사용하면 번역 파일이 위치한 경로를 지정할 수 있습니다. 이는 번역이 특정 패키지나 앱 디렉토리에 있을 수 있는 모노레포에서 특히 유용합니다. 예를 들어:
-
-#### 풀 리퀘스트 옵션 (곧 출시 예정)
-
-`create-pull-request` 옵션은 액션이 변경 사항으로 풀 리퀘스트를 생성할지 아니면 직접 브랜치에 커밋할지를 제어합니다:
-
-```typescript title=".github/workflows/languine.yml"
-with:
-  create-pull-request: true # 변경 사항으로 풀 리퀘스트 생성
-```
-
-`true`로 설정하면, 액션은:
-- 변경 사항으로 새 브랜치를 생성합니다.
-- 검토를 위한 풀 리퀘스트를 생성합니다.
-- 적절한 레이블과 설명을 추가합니다.
-
-`false`(기본값)로 설정하면, 액션은:
-- 현재 브랜치에 직접 변경 사항을 커밋합니다.
-- 풀 리퀘스트를 생성하지 않고 변경 사항을 푸시합니다.
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/ko/html.mdx b/apps/web/src/markdown/docs/ko/html.mdx
deleted file mode 100644
index 5a481391..00000000
--- a/apps/web/src/markdown/docs/ko/html.mdx
+++ /dev/null
@@ -1,41 +0,0 @@
-# HTML
-
-Languine은 HTML 파일 현지화를 지원하며, 텍스트 콘텐츠와 속성을 모두 처리합니다. 이 형식은 정적 웹사이트와 HTML 템플릿에 적합하며, HTML 구조와 형식을 유지하는 것을 지원합니다.
-
----
-
-## 설정하기
-
-먼저, 프로젝트 루트에 languine.json 구성 파일이 있는지 확인하세요. 다음은 예시입니다:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "html": {
-      "include": ["pages/[locale]/*.html"]
-    }
-  }
-}
-```
-
-## 번역하기
-
-구성이 완료되면 다음을 실행하세요:
-
-```bash
-npx languine@latest translate
-```
-
-이 명령을 실행하면 Languine이:
-
-- 소스 HTML 파일을 로드합니다 (예: pages/en/*.html)
-- 새로운 또는 수정된 번역 문자열을 감지합니다
-- 대상 언어에 대한 번역을 생성합니다
-- 대상 언어 HTML 파일을 생성하거나 업데이트합니다 (예: pages/sv/*.html)
-- HTML 구조와 형식을 유지합니다
-- 지정된 속성 번역을 처리합니다
-- 주석과 특수 태그를 유지합니다
diff --git a/apps/web/src/markdown/docs/ko/introduction.mdx b/apps/web/src/markdown/docs/ko/introduction.mdx
deleted file mode 100644
index 49fa6423..00000000
--- a/apps/web/src/markdown/docs/ko/introduction.mdx
+++ /dev/null
@@ -1,34 +0,0 @@
-# 소개
-
-Languine은 개발 워크플로우와 파이프라인 내에서 현지화를 자동화하여 번역이 지연되지 않도록 보장합니다.
-
-몇 분 안에 애플리케이션을 다국어 경험으로 변환하세요. 기능 구축에 집중하는 동안, Languine은 모든 번역 작업을 정밀하고 신뢰성 있게 처리합니다.
-
----
-
-## 주요 기능
-
-- **번역 엔진**: 브랜드 음성을 유지하는 맥락 인식 고품질 번역 활용
-- **CI/CD 통합**: 기존 워크플로우를 통해 번역 업데이트 자동화
-- **형식**: 확장 가능한 파서 시스템으로 모든 파일 형식 처리
-- **오픈 소스**: GitHub에서 코드베이스에 접근하고, 검사하고, 기여 - 블랙 박스 없음, 완전한 투명성
-
----
-
-## 작동 방식
-
-1. **빠른 설정**: 직관적인 CLI와 안내된 초기화로 몇 분 안에 시작
-2. **간단한 구성**: 명확하고 간단한 구성 파일로 번역 요구 사항 정의
-3. **자동 번역**: 콘텐츠를 한 번 푸시하고 Languine이 모든 대상 언어로 자동 번역 처리
-
----
-
-## 시작하기
-
-[빠른 시작](/docs/quickstart) 가이드를 통해 현지화 여정을 시작하세요 - 몇 분 안에 첫 번째 번역을 실행할 수 있습니다.
-
-Languine의 기능을 마스터하기 위해 포괄적인 문서를 탐색하세요:
-
-- [구성](/docs/configuration) - 프로젝트의 요구에 맞게 Languine 구성
-- [CLI](/docs/cli) - 강력한 명령줄 인터페이스 마스터
-- [Github Actions](/docs/github-actions) - Github Action으로 번역 자동화
diff --git a/apps/web/src/markdown/docs/ko/ios.mdx b/apps/web/src/markdown/docs/ko/ios.mdx
deleted file mode 100644
index daf2201b..00000000
--- a/apps/web/src/markdown/docs/ko/ios.mdx
+++ /dev/null
@@ -1,39 +0,0 @@
-# iOS
-
-Languine은 iOS 애플리케이션을 위한 표준 로컬라이제이션 형식인 Localizable.strings 파일을 지원합니다. 이 형식은 기본 키-값 문자열 쌍을 처리하며 번역가에게 맥락을 제공하기 위한 주석을 지원합니다.
-
----
-
-## 설정하기
-
-먼저, 프로젝트 루트에 languine.json 구성 파일이 있는지 확인하세요. 다음은 예시입니다:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "ios": {
-      "include": ["[locale].lproj/Localizable.strings"]
-    }
-  }
-}
-```
-
-## 번역하기
-
-구성이 완료되면, 다음 명령어를 실행하세요:
-
-```bash
-npx languine@latest translate
-```
-
-이 명령어를 실행하면 Languine이:
-
-- 소스 Localizable.strings 파일(예: en.lproj/Localizable.strings)을 로드합니다.
-- 새로운 또는 수정된 번역 문자열을 감지합니다.
-- 대상 언어에 대한 번역을 생성합니다.
-- 대상 언어 파일(예: sv.lproj/Localizable.strings)을 생성하거나 업데이트합니다.
-- 기존 주석과 형식을 유지합니다.
diff --git a/apps/web/src/markdown/docs/ko/js.mdx b/apps/web/src/markdown/docs/ko/js.mdx
deleted file mode 100644
index eb680342..00000000
--- a/apps/web/src/markdown/docs/ko/js.mdx
+++ /dev/null
@@ -1,42 +0,0 @@
-# 자바스크립트
-
-Languine은 현대 웹 애플리케이션에 적합한 JavaScript/TypeScript 로컬라이제이션 파일을 지원합니다. 이 형식은 객체 리터럴과 모듈 내보내기를 모두 처리하며, 중첩 구조와 동적 콘텐츠를 지원합니다.
-
----
-
-## 설정하기
-
-먼저, 프로젝트 루트에 languine.json 구성 파일이 있는지 확인하세요. 다음은 예시입니다:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "js": {
-      "include": ["src/locales/[locale].js"]
-    }
-  }
-}
-```
-
-## 번역하기
-
-구성이 완료되면 다음을 실행하세요:
-
-```bash
-npx languine@latest translate
-```
-
-이 명령을 실행하면 Languine이:
-
-- 소스 JavaScript 파일을 로드합니다 (예: src/locales/en.js)
-- 새로운 또는 수정된 번역 문자열을 감지합니다
-- 대상 언어에 대한 번역을 생성합니다
-- 대상 언어 파일을 생성하거나 업데이트합니다 (예: src/locales/sv.js)
-- 모듈 구조와 내보내기를 유지합니다
-- 중첩 객체와 배열을 처리합니다
-- 코드 형식과 주석을 유지합니다
-- 활성화된 경우 TypeScript 유형을 생성합니다
diff --git a/apps/web/src/markdown/docs/ko/json.mdx b/apps/web/src/markdown/docs/ko/json.mdx
deleted file mode 100644
index 6e2cf6c5..00000000
--- a/apps/web/src/markdown/docs/ko/json.mdx
+++ /dev/null
@@ -1,41 +0,0 @@
-# JSON
-
-Languine은 복수형 및 보간에 대한 일반적인 요구 사항을 갖춘 소스 형식으로 JSON 파일을 지원합니다. 이 형식은 React, Vue, Ruby on Rails 등 많은 프레임워크에서 사용됩니다.
-
-
----
-
-
-## 설정하기
-
-먼저, 프로젝트 루트에 languine.json 구성 파일이 있는지 확인하세요. 다음은 예시입니다:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "json": {
-      "include": ["locales/[locale].json"]
-    }
-  }
-}
-
-```
-
-## 번역하기
-
-구성이 완료되면 다음을 실행하세요:
-
-```bash
-npx languine@latest translate
-```
-
-이 명령을 실행하면 Languine은:
-
-- 소스 JSON 파일(예: locales/en.json)을 로드합니다.
-- 새로 추가되거나 수정된 번역 문자열을 감지합니다.
-- 대상 언어에 대한 번역을 생성합니다.
-- 대상 언어 JSON 파일(예: locales/sv.json, locales/de.json, locales/fr.json)을 생성하거나 업데이트합니다.
diff --git a/apps/web/src/markdown/docs/ko/md.mdx b/apps/web/src/markdown/docs/ko/md.mdx
deleted file mode 100644
index 96c33eed..00000000
--- a/apps/web/src/markdown/docs/ko/md.mdx
+++ /dev/null
@@ -1,43 +0,0 @@
-# 마크다운
-
-Languine은 문서화, 블로그 게시물 및 콘텐츠가 많은 사이트에 적합한 마크다운 파일 현지화를 지원합니다. 이 형식은 콘텐츠를 번역하는 동안 마크다운 구문을 유지하며, 프론트 매터 지원도 포함됩니다.
-
----
-
-## 설정하기
-
-먼저, 프로젝트 루트에 languine.json 구성 파일이 있는지 확인하세요. 다음은 예시입니다:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "md": {
-      "include": ["content/[locale]/**/*.md"]
-    }
-  }
-}
-```
-
-## 번역하기
-
-구성이 완료되면 다음 명령어를 실행하세요:
-
-```bash
-npx languine@latest translate
-```
-
-이 명령어를 실행하면 Languine이:
-
-- 소스 마크다운 파일을 로드합니다 (예: content/en/*.md)
-- 새로운 또는 수정된 콘텐츠를 감지합니다
-- 대상 언어에 대한 번역을 생성합니다
-- 대상 언어 파일을 생성하거나 업데이트합니다 (예: content/sv/*.md)
-- 마크다운 형식 및 구조를 유지합니다
-- 프론트 매터 번역을 처리합니다
-- 링크 및 참조를 유지합니다
-- 코드 블록은 번역하지 않습니다
-- 마크다운 내 HTML을 유지합니다
diff --git a/apps/web/src/markdown/docs/ko/mdx.mdx b/apps/web/src/markdown/docs/ko/mdx.mdx
deleted file mode 100644
index 3e5f409e..00000000
--- a/apps/web/src/markdown/docs/ko/mdx.mdx
+++ /dev/null
@@ -1,43 +0,0 @@
-# 마크다운 (MDX)
-
-Languine은 문서화, 블로그 게시물 및 콘텐츠가 많은 사이트에 적합한 마크다운 (MDX) 파일 현지화를 지원합니다. 이 형식은 콘텐츠를 번역하면서 마크다운 구문을 유지하며, 프론트 매터 지원도 포함됩니다.
-
----
-
-## 설정하기
-
-먼저, 프로젝트 루트에 languine.json 구성 파일이 있는지 확인하세요. 다음은 예시입니다:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "mdx": {
-      "include": ["content/[locale]/**/*.mdx"]
-    }
-  }
-}
-```
-
-## 번역하기
-
-구성이 완료되면 다음을 실행하세요:
-
-```bash
-npx languine@latest translate
-```
-
-이 명령을 실행하면 Languine은:
-
-- 소스 마크다운 파일을 로드합니다 (예: content/en/*.mdx)
-- 새로운 또는 수정된 콘텐츠를 감지합니다
-- 대상 언어에 대한 번역을 생성합니다
-- 대상 언어 파일을 생성하거나 업데이트합니다 (예: content/sv/*.mdx)
-- 마크다운 형식과 구조를 유지합니다
-- 프론트 매터 번역을 처리합니다
-- 링크와 참조를 유지합니다
-- 코드 블록은 번역하지 않습니다
-- 마크다운 내 HTML을 유지합니다
diff --git a/apps/web/src/markdown/docs/ko/overrides.mdx b/apps/web/src/markdown/docs/ko/overrides.mdx
deleted file mode 100644
index 44b123ea..00000000
--- a/apps/web/src/markdown/docs/ko/overrides.mdx
+++ /dev/null
@@ -1,7 +0,0 @@
-# 재정의
-
-Languine은 특정 키에 대한 번역을 재정의할 수 있도록 합니다. 이는 기본 번역과 관계없이 특정 키에 대해 특정 번역이 사용되도록 보장하고 싶을 때 유용합니다.
-
-## 작동 방식
-
-대시보드에서 특정 키에 대한 재정의를 생성할 수 있습니다. 특정 언어에 대한 재정의도 생성할 수 있습니다.
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/ko/po.mdx b/apps/web/src/markdown/docs/ko/po.mdx
deleted file mode 100644
index d4ddd33c..00000000
--- a/apps/web/src/markdown/docs/ko/po.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# PO (Gettext)
-
-Languine은 널리 사용되는 Gettext 로컬라이제이션 형식인 PO 파일을 지원합니다. 이 형식은 많은 프로그래밍 환경, 특히 리눅스 애플리케이션과 PHP 프레임워크에서 인기가 있으며, 문맥, 복수형 및 번역자 주석을 지원합니다.
-
----
-
-## 설정하기
-
-먼저, 프로젝트 루트에 languine.json 구성 파일이 있는지 확인하세요. 다음은 예시입니다:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "po": {
-      "include": ["locales/[locale]/LC_MESSAGES/messages.po"]
-    }
-  }
-}
-```
-
-## 번역하기
-
-구성이 완료되면 다음 명령어를 실행하세요:
-
-```bash
-npx languine@latest translate
-```
-
-이 명령어를 실행하면 Languine이:
-
-- 소스 PO 파일을 로드합니다 (예: locales/en/LC_MESSAGES/messages.po)
-- 새로 추가되거나 수정된 번역 문자열을 감지합니다
-- 대상 언어에 대한 번역을 생성합니다
-- 대상 언어 PO 파일을 생성하거나 업데이트합니다 (예: locales/sv/LC_MESSAGES/messages.po)
-- 메타데이터, 문맥 및 복수형을 보존합니다
-- 번역자 주석 및 참조 정보를 유지합니다
diff --git a/apps/web/src/markdown/docs/ko/prettier.mdx b/apps/web/src/markdown/docs/ko/prettier.mdx
deleted file mode 100644
index 68321ba5..00000000
--- a/apps/web/src/markdown/docs/ko/prettier.mdx
+++ /dev/null
@@ -1,22 +0,0 @@
-# 프리티어
-
-랭귀인은 [프리티어](https://prettier.io/)와 함께 작업하여 번역 파일이 일관되게 포맷되도록 할 수 있습니다. 이는 프로젝트 전반에 걸쳐 일관된 스타일을 유지해야 하는 JSON 번역 파일 작업 시 특히 유용합니다.
-
-## 랭귀인과 함께 사용하기
-
-프리티어를 랭귀인과 함께 사용하는 권장 방법은 번역 파일이 생성된 후에 포맷하는 것입니다. 이를 `package.json`에서 설정할 수 있습니다:
-
-```json title="package.json"
-{
-  "scripts": {
-    "translate": "languine translate",
-    "format": "prettier --write \"locales/**/*.json\"",
-    "translate:format": "npm run translate && npm run format"
-  }
-}
-```
-
-이제 다음을 수행할 수 있습니다:
-- `npm run translate`를 실행하여 번역만 생성
-- `npm run format`을 실행하여 기존 번역 파일만 포맷
-- `npm run translate:format`을 실행하여 번역을 생성하고 순차적으로 포맷
diff --git a/apps/web/src/markdown/docs/ko/properties.mdx b/apps/web/src/markdown/docs/ko/properties.mdx
deleted file mode 100644
index 4db7ced8..00000000
--- a/apps/web/src/markdown/docs/ko/properties.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# 속성
-
-Languine은 Java 애플리케이션을 위한 표준 로컬라이제이션 형식인 Java Properties 파일을 지원합니다. 이 형식은 유니코드 이스케이핑을 처리하며 키-값 쌍과 주석을 모두 지원합니다.
-
----
-
-## 설정하기
-
-먼저, 프로젝트 루트에 languine.json 구성 파일이 있는지 확인하세요. 다음은 예시입니다:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "properties": {
-      "include": ["src/main/resources/messages_[locale].properties"]
-    }
-  }
-}
-```
-
-## 번역하기
-
-구성이 완료되면 다음을 실행하세요:
-
-```bash
-npx languine@latest translate
-```
-
-이 명령을 실행하면 Languine이:
-
-- 소스 프로퍼티 파일(예: messages_en.properties)을 로드합니다.
-- 새로 추가되거나 수정된 번역 문자열을 감지합니다.
-- 대상 언어에 대한 번역을 생성합니다.
-- 대상 언어 프로퍼티 파일(예: messages_sv.properties)을 생성하거나 업데이트합니다.
-- 유니코드 이스케이핑을 자동으로 처리합니다.
-- 주석과 형식을 유지합니다.
diff --git a/apps/web/src/markdown/docs/ko/quickstart.mdx b/apps/web/src/markdown/docs/ko/quickstart.mdx
deleted file mode 100644
index f2d4f8b8..00000000
--- a/apps/web/src/markdown/docs/ko/quickstart.mdx
+++ /dev/null
@@ -1,65 +0,0 @@
-# 빠른 시작
-
-Languine을 설치하는 것으로 시작하세요.
-
-그런 다음, Languine을 초기화하기 위해 다음 명령어를 실행하세요.
-
-```bash title="터미널"
-npx languine@latest init
-```
-
-프로젝트를 설정하기 위한 단계를 따르세요.
-
----
-
-## 첫 번째 번역
-
-이제 코드를 번역할 준비가 되었습니다.
-
-소스 파일에 키를 추가하는 것으로 시작하세요. 예를 들어, `en.json`을 소스 파일로 선택한 경우, 그에 키를 추가하세요.
-
-```json title="src/locales/en.json"
-{
-  "welcome": "우리 애플리케이션에 오신 것을 환영합니다!",
-  "user": {
-    "greeting": "안녕하세요, {{name}}!",
-    "profile": {
-      "title": "당신의 프로필",
-      "edit": "프로필 수정"
-    }
-  },
-  "notifications": {
-    "messages": "새 메시지가 {{count}}개 있습니다.",
-    "empty": "새 알림이 없습니다."
-  }
-}
-
-```
-
----
-
-## 번역
-
-다음 명령어를 실행하여 콘텐츠를 번역하세요:
-
-```bash title="터미널"
-npx languine@latest translate
-```
-
-## 이 작업은 다음을 수행합니다:
-1. 각 대상 언어에 대한 번역 파일을 생성합니다.
-2. Languine 엔진으로 고품질 번역을 생성합니다.
-3. 번역 상태를 추적하기 위해 `languine.lock` 파일을 생성합니다.
-
-잠금 파일은 Languine이 소스 콘텐츠가 변경될 때 어떤 번역이 업데이트가 필요한지 식별하는 데 도움을 줍니다. 이 파일을 리포지토리에 커밋하는 것을 잊지 마세요.
-
----
-
-## 다음 단계
-
-이제 Languine이 설정되었으므로, 다음을 수행할 수 있습니다:
-- `languine.json` 파일에 더 많은 언어 추가
-- CI/CD 파이프라인에 Languine 통합
-- 프로그래밍 방식의 번역을 위한 API 사용
-
-Languine의 고급 기능에 대해 더 알아보려면 다른 가이드를 확인하세요.
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/ko/react-email.mdx b/apps/web/src/markdown/docs/ko/react-email.mdx
deleted file mode 100644
index 494e32cc..00000000
--- a/apps/web/src/markdown/docs/ko/react-email.mdx
+++ /dev/null
@@ -1,41 +0,0 @@
-# 리액트 이메일
-
-Languine은 리액트 이메일 템플릿을 지원하여 리액트 이메일로 작성된 이메일 템플릿의 번역을 관리할 수 있습니다. 이 통합은 텍스트 콘텐츠와 HTML 속성을 모두 처리하면서 리액트 컴포넌트 구조를 유지합니다.
-
----
-
-## 설정하기
-
-먼저, 프로젝트 루트에 languine.json 구성 파일이 있는지 확인하세요. 다음은 예시입니다:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "react-email": {
-      "include": ["emails/[locale]/*.tsx"]
-    }
-  }
-}
-```
-
-## 번역하기
-
-구성이 완료되면 다음을 실행하세요:
-
-```bash
-npx languine@latest translate
-```
-
-이 명령을 실행하면 Languine은:
-
-- 소스 리액트 이메일 템플릿을 로드합니다 (예: emails/en/*.tsx)
-- 새로운 또는 수정된 번역 문자열을 감지합니다
-- 대상 언어에 대한 번역을 생성합니다
-- 대상 언어 이메일 템플릿을 생성하거나 업데이트합니다 (예: emails/sv/*.tsx)
-- 리액트 컴포넌트 구조와 props를 유지합니다
-- HTML 형식과 스타일을 유지합니다
-- 보간 및 동적 콘텐츠를 처리합니다
diff --git a/apps/web/src/markdown/docs/ko/ts.mdx b/apps/web/src/markdown/docs/ko/ts.mdx
deleted file mode 100644
index 1fe67700..00000000
--- a/apps/web/src/markdown/docs/ko/ts.mdx
+++ /dev/null
@@ -1,42 +0,0 @@
-# TypeScript
-
-Languine은 완전한 타입 안전성을 갖춘 TypeScript 로컬라이제이션 파일을 지원합니다. 이 형식은 JavaScript 지원을 추가적인 TypeScript 전용 기능 및 타입 생성 기능으로 확장합니다.
-
----
-
-## 설정하기
-
-먼저, 프로젝트 루트에 languine.json 구성 파일이 있는지 확인하세요. 다음은 예시입니다:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "ts": {
-      "include": ["src/locales/[locale].ts"]
-    }
-  }
-}
-```
-
-## 번역하기
-
-구성이 완료되면 다음을 실행하세요:
-
-```bash
-npx languine@latest translate
-```
-
-이 명령을 실행하면 Languine은:
-
-- 소스 TypeScript 파일을 로드합니다 (예: src/locales/en.ts)
-- 새로운 또는 수정된 번역 문자열을 감지합니다
-- 대상 언어에 대한 번역을 생성합니다
-- 대상 언어 파일을 생성하거나 업데이트합니다 (예: src/locales/sv.ts)
-- 타입 주석 및 인터페이스를 보존합니다
-- 적절한 타입으로 중첩 객체를 처리합니다
-- 코드 형식 및 문서 주석을 유지합니다
-- 리터럴 타입 및 유니온 타입을 지원합니다
diff --git a/apps/web/src/markdown/docs/ko/xcode-stringsdict.mdx b/apps/web/src/markdown/docs/ko/xcode-stringsdict.mdx
deleted file mode 100644
index 77481e36..00000000
--- a/apps/web/src/markdown/docs/ko/xcode-stringsdict.mdx
+++ /dev/null
@@ -1,44 +0,0 @@
-# Xcode Stringsdict
-
-Languine은 iOS 및 macOS 애플리케이션에서 복잡한 복수화 규칙에 사용되는 Xcode의 Stringsdict 형식을 지원합니다. 이 형식은 복수형, 변수 치환 및 언어별 복수형 규칙을 처리합니다.
-
----
-
-## 설정하기
-
-먼저, 프로젝트 루트에 languine.json 구성 파일이 있는지 확인하세요. 다음은 예시입니다:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "stringsdict": {
-      "include": ["MyApp/Localizable.stringsdict"]
-    }
-  }
-}
-```
-
-## 번역하기
-
-구성이 완료되면 다음 명령어를 실행하세요:
-
-```bash
-npx languine@latest translate
-```
-
-이 명령어를 실행하면 Languine이:
-
-- Stringsdict 파일을 로드합니다
-- 새로운 또는 수정된 복수형 규칙을 감지합니다
-- 대상 언어에 대한 번역을 생성합니다
-- 새로운 번역으로 Stringsdict 파일을 업데이트합니다
-- 각 언어에 대한 복잡한 복수형 규칙을 처리합니다
-- 변수 치환을 유지합니다
-- 사전 구조를 보존합니다
-- 언어별 복수형을 지원합니다
-- 복수형 규칙의 일관성을 검증합니다
-- 형식 지정자를 유지합니다
diff --git a/apps/web/src/markdown/docs/ko/xcode-xcstrings.mdx b/apps/web/src/markdown/docs/ko/xcode-xcstrings.mdx
deleted file mode 100644
index 81903b29..00000000
--- a/apps/web/src/markdown/docs/ko/xcode-xcstrings.mdx
+++ /dev/null
@@ -1,44 +0,0 @@
-# Xcode 문자열 (XCStrings)
-
-Languine은 iOS 및 macOS 애플리케이션을 위한 현대적인 지역화 형식인 Xcode의 XCStrings 형식을 지원합니다. 이 형식은 변형, 복수형 및 개발자 주석을 지원하는 문자열 카탈로그를 처리합니다.
-
----
-
-## 설정하기
-
-먼저, 프로젝트 루트에 languine.json 구성 파일이 있는지 확인하세요. 다음은 예시입니다:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "xcstrings": {
-      "include": ["MyApp/Localizable.xcstrings"]
-    }
-  }
-}
-```
-
-## 번역하기
-
-구성이 완료되면 다음을 실행하세요:
-
-```bash
-npx languine@latest translate
-```
-
-이 명령을 실행하면 Languine이:
-
-- XCStrings 카탈로그를 로드합니다
-- 새로 추가되거나 수정된 문자열을 감지합니다
-- 대상 언어에 대한 번역을 생성합니다
-- 새로운 번역으로 문자열 카탈로그를 업데이트합니다
-- 문자열 변형 및 복수형 규칙을 유지합니다
-- 개발자 주석 및 문맥을 유지합니다
-- 변수 치환을 처리합니다
-- 적응형 문자열을 지원합니다
-- 형식 지정자를 유지합니다
-- 문자열 카탈로그 구조를 검증합니다
diff --git a/apps/web/src/markdown/docs/ko/xliff.mdx b/apps/web/src/markdown/docs/ko/xliff.mdx
deleted file mode 100644
index 81190ef3..00000000
--- a/apps/web/src/markdown/docs/ko/xliff.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# XLIFF
-
-Languine은 XLIFF (XML Localization Interchange File Format)를 지원합니다. 이는 로컬라이제이션 데이터를 교환하기 위해 설계된 XML 기반 형식입니다. 이 형식은 전문 번역 워크플로우에서 널리 사용되며 XLIFF 1.2 및 2.0 버전을 모두 지원합니다.
-
----
-
-## 설정하기
-
-먼저, 프로젝트 루트에 languine.json 구성 파일이 있는지 확인하세요. 다음은 예시입니다:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "xliff": {
-      "include": ["locales/[locale].xlf"]
-    }
-  }
-}
-```
-
-## 번역하기
-
-구성이 완료되면 다음 명령어를 실행하세요:
-
-```bash
-npx languine@latest translate
-```
-
-이 명령어를 실행하면 Languine은:
-
-- 소스 XLIFF 파일을 로드합니다 (예: locales/en.xlf)
-- 새로운 또는 수정된 번역 단위를 감지합니다
-- 대상 언어에 대한 번역을 생성합니다
-- 대상 언어 XLIFF 파일을 생성하거나 업데이트합니다 (예: locales/sv.xlf)
-- 노트, 컨텍스트 정보 및 상태 속성을 보존합니다
-- CAT (Computer-Aided Translation) 도구와의 호환성을 유지합니다
diff --git a/apps/web/src/markdown/docs/ko/xml.mdx b/apps/web/src/markdown/docs/ko/xml.mdx
deleted file mode 100644
index 8eba2565..00000000
--- a/apps/web/src/markdown/docs/ko/xml.mdx
+++ /dev/null
@@ -1,44 +0,0 @@
-# XML
-
-Languine은 다양한 XML 기반 구성 및 콘텐츠 파일에 적합한 XML 파일 현지화를 지원합니다. 이 형식은 복잡한 XML 구조를 처리하면서 형식과 속성을 유지합니다.
-
----
-
-## 설정하기
-
-먼저, 프로젝트 루트에 languine.json 구성 파일이 있는지 확인하세요. 다음은 예시입니다:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "xml": {
-      "include": ["resources/[locale]/*.xml"]
-    }
-  }
-}
-```
-
-## 번역하기
-
-구성이 완료되면 다음을 실행하세요:
-
-```bash
-npx languine@latest translate
-```
-
-이 명령을 실행하면 Languine은:
-
-- 소스 XML 파일을 로드합니다 (예: resources/en/*.xml)
-- 새로운 또는 수정된 콘텐츠를 감지합니다
-- 대상 언어에 대한 번역을 생성합니다
-- 대상 언어 파일을 생성하거나 업데이트합니다 (예: resources/sv/*.xml)
-- XML 구조와 형식을 유지합니다
-- 속성 번역을 처리합니다
-- CDATA 섹션을 유지합니다
-- XML 주석을 보존합니다
-- XML 네임스페이스를 지원합니다
-- XML 구조를 검증합니다
diff --git a/apps/web/src/markdown/docs/ko/yaml.mdx b/apps/web/src/markdown/docs/ko/yaml.mdx
deleted file mode 100644
index 4f807b9a..00000000
--- a/apps/web/src/markdown/docs/ko/yaml.mdx
+++ /dev/null
@@ -1,39 +0,0 @@
-# YAML
-
-Languine은 Ruby on Rails, Laravel 및 기타 프레임워크에서 일반적으로 사용되는 소스 형식으로 YAML 파일을 지원합니다. 이 형식은 중첩 구조, 배열 및 복잡한 데이터 유형을 지원합니다.
-
----
-
-## 설정하기
-
-먼저, 프로젝트 루트에 languine.json 구성 파일이 있는지 확인하세요. 다음은 예시입니다:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "yaml": {
-      "include": ["config/locales/[locale].yml"]
-    }
-  }
-}
-```
-
-## 번역하기
-
-구성이 완료되면 다음을 실행하세요:
-
-```bash
-npx languine@latest translate
-```
-
-이 명령을 실행하면 Languine은:
-
-- 소스 YAML 파일을 로드합니다 (예: config/locales/en.yml)
-- 새로운 또는 수정된 번역 문자열을 감지합니다
-- 대상 언어에 대한 번역을 생성합니다
-- 대상 언어 YAML 파일을 생성하거나 업데이트합니다 (예: config/locales/sv.yml)
-- 중첩 구조와 형식을 유지합니다
diff --git a/apps/web/src/markdown/docs/nl/android.mdx b/apps/web/src/markdown/docs/nl/android.mdx
deleted file mode 100644
index 61db8af4..00000000
--- a/apps/web/src/markdown/docs/nl/android.mdx
+++ /dev/null
@@ -1,39 +0,0 @@
-# Android
-
-Languine ondersteunt Android string resources (strings.xml) als een bronformaat, en verwerkt meervouden, stringarrays en geformatteerde strings. Dit formaat is de standaard manier om vertalingen te beheren in Android-applicaties.
-
----
-
-## Instellen
-
-Zorg er eerst voor dat je een languine.json configuratiebestand in de hoofdmap van je project hebt. Hier is een voorbeeld:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "android": {
-      "include": ["app/src/main/res/values-[locale]/strings.xml"]
-    }
-  }
-}
-```
-
-## Vertalen
-
-Met je configuratie ingesteld, voer je uit:
-
-```bash
-npx languine@latest translate
-```
-
-Wanneer je dit commando uitvoert, zal Languine:
-
-- Je bron strings.xml bestand laden (bijv. values/strings.xml)
-- Nieuwe of gewijzigde vertaalstrings detecteren
-- Vertalingen genereren voor je doeltalen
-- De XML-bestanden voor de doeltaal aanmaken of bijwerken (bijv. values-sv/strings.xml, values-de/strings.xml, values-fr/strings.xml)
-- Bestaande stringarrays en meervoudformattering behouden
diff --git a/apps/web/src/markdown/docs/nl/arb.mdx b/apps/web/src/markdown/docs/nl/arb.mdx
deleted file mode 100644
index 567d9516..00000000
--- a/apps/web/src/markdown/docs/nl/arb.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# ARB (Application Resource Bundle)
-
-Languine ondersteunt ARB-bestanden, het standaardlokalisatieformaat voor Flutter-toepassingen. Dit formaat behandelt meervouden, plaatsaanduidingen en selectexpressies terwijl het compatibiliteit behoudt met Flutter's intl-pakket.
-
----
-
-## Instellen
-
-Zorg er eerst voor dat je een languine.json-configuratiebestand in de hoofdmap van je project hebt. Hier is een voorbeeld:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "arb": {
-      "include": ["lib/l10n/intl_[locale].arb"]
-    }
-  }
-}
-```
-
-## Vertalen
-
-Met je configuratie ingesteld, voer je uit:
-
-```bash
-npx languine@latest translate
-```
-
-Wanneer je dit commando uitvoert, zal Languine:
-
-- Je bron-ARB-bestand laden (bijv. lib/l10n/intl_en.arb)
-- Nieuwe of gewijzigde vertaalstrings detecteren
-- Vertalingen genereren voor je doeltalen
-- De ARB-bestanden voor de doeltaal aanmaken of bijwerken (bijv. lib/l10n/intl_sv.arb)
-- Metadata, plaatsaanduidingen en meervoud/select-expressies behouden
-
diff --git a/apps/web/src/markdown/docs/nl/authentication.mdx b/apps/web/src/markdown/docs/nl/authentication.mdx
deleted file mode 100644
index a95d6cc8..00000000
--- a/apps/web/src/markdown/docs/nl/authentication.mdx
+++ /dev/null
@@ -1,48 +0,0 @@
-# Authenticatie
-
-Om Languine te gebruiken, moet je je authentiseren bij onze Engine, het duurt slechts een paar seconden om te beginnen.
-
----
-
-## Inloggen
-
-Je kunt direct inloggen op [Languine Dashboard](https://languine.ai/login) of de volgende opdracht uitvoeren:
-
-```bash title="Terminal"
-npx languine@latest auth login
-```
-
-
-Als je al een account hebt, word je automatisch ingelogd en wordt er een sessie op je machine opgeslagen.
-
----
-
-## Uitloggen
-
-Je kunt uitloggen door de volgende opdracht uit te voeren:
-
-```bash title="Terminal"
-npx languine@latest auth logout
-```
-
----
-
-## Gebruikerssessie
-
-Je kunt controleren of je bent ingelogd door de volgende opdracht uit te voeren:
-
-```bash title="Terminal"
-npx languine@latest auth whoami
-```
-
----
-
-
-# Omgevingsvariabelen
-
-Je kunt de volgende omgevingsvariabelen instellen om Languine te configureren:
-
-- `LANGUINE_API_KEY`: De API-sleutel die je gebruikt voor authenticatie.
-- `LANGUINE_PROJECT_ID`: De project-ID die je gebruikt voor het project.
-
-Je vindt ze in het [Languine Dashboard](https://languine.ai/login).
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/nl/biome.mdx b/apps/web/src/markdown/docs/nl/biome.mdx
deleted file mode 100644
index 65c3cd99..00000000
--- a/apps/web/src/markdown/docs/nl/biome.mdx
+++ /dev/null
@@ -1,24 +0,0 @@
-# Biome
-
-Languine kan samenwerken met [Biome](https://biomejs.dev/) om ervoor te zorgen dat je vertaalbestanden consistent zijn opgemaakt. Dit is bijzonder nuttig bij het werken met JSON-vertalingsbestanden die een consistente stijl door je project heen moeten behouden.
-
-## Gebruik met Languine
-
-De aanbevolen manier om Biome met Languine te gebruiken is om je vertaalbestanden op te maken nadat ze zijn gegenereerd. Je kunt dit instellen in je `package.json`:
-
-```json title="package.json"
-{
-  "scripts": {
-    "translate": "languine translate",
-    "format": "biome format \"locales/**/*.json\"",
-    "translate:format": "npm run translate && npm run format"
-  }
-}
-```
-
-Nu kun je:
-- `npm run translate` uitvoeren om alleen vertalingen te genereren
-- `npm run format` uitvoeren om alleen bestaande vertaalbestanden op te maken
-- `npm run translate:format` uitvoeren om vertalingen te genereren en ze in volgorde op te maken
-
-Deze configuratie zorgt ervoor dat je vertaalbestanden consistent zijn opgemaakt met een inspringing van 2 spaties en een maximale regelbreedte van 80 tekens.
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/nl/ci.mdx b/apps/web/src/markdown/docs/nl/ci.mdx
deleted file mode 100644
index 3e07cf05..00000000
--- a/apps/web/src/markdown/docs/nl/ci.mdx
+++ /dev/null
@@ -1,96 +0,0 @@
-# CI/CD
-
-Languine biedt een CI/CD-integratie om je te helpen bij het vertalen van je applicatie.
-
----
-
-## Hoe het Werkt
-
-De CI/CD-werkstroom in Languine volgt een gestructureerd proces om vertaalupdates in je applicatie te automatiseren:
-
-### 1. Actie Initialisatie
-- De werkstroom begint wanneer de actie wordt geactiveerd
-- Stelt de benodigde Git-configuratie en inloggegevens in
-
-### 2. Languine Engine Verwerking
-- De Languine-engine verwerkt de inhoud van je applicatie
-- Behandelt de vertaaltaken met behulp van de geconfigureerde instellingen
-
-### 3. Wijzigingsdetectie
-Het systeem controleert op eventuele vertaalwijzigingen en volgt een van de twee paden:
-
-**Wanneer Wijzigingen Worden Gevonden:**
-- Wijzigingen worden gecommit naar de repository
-- Wijzigingen worden gepusht naar de opgegeven branch
-- Een Pull Request (PR) wordt aangemaakt
-
-**Wanneer Geen Wijzigingen Worden Gevonden:**
-- De werkstroom wordt voltooid zonder een PR aan te maken
-
-### 4. Pull Request Creatie
-Wanneer wijzigingen worden gedetecteerd, wordt er een Pull Request aangemaakt met:
-
-**PR Inhoud:**
-- Duidelijke titel die de vertaalupdates aangeeft
-- Gedetailleerde beschrijving van de wijzigingen
-- Bevestigingen van kwaliteitscontroles
-- Instructies voor beoordeling
-- Links naar documentatie en ondersteuning
-
-**PR Beschrijving Bevat:**
-- Samenvatting van vertaalupdates
-- Lijst van wat is veranderd (geupdate vertalingen, consistentie in terminologie)
-- Volgende stappen voor beoordelaars
-- Links naar documentatie en ondersteuningsbronnen
-
----
-
-## Werkstroom Diagram
-
-<div className="flex flex-col items-center justify-center p-4 h-[400px] sm:h-[500px] md:h-[650px]">
-  <pre
-    className="p-4 text-sm leading-5 mb-4 scale-[0.5] sm:scale-[0.65] md:scale-90 transform-gpu"
-    style={{
-      fontFamily: "monospace",
-      whiteSpace: "pre",
-      textAlign: "left",
-    }}
-  >
-    {`
-                    ┌─────────────────────┐
-                    │   Actie Start       │
-                    └──────────┬──────────┘
-                               │
-                    ┌──────────▼──────────┐
-                    │    Git &            │
-                    │    Inloggegevens     │
-                    └──────────┬──────────┘
-                               │
-┌─────────────────────────────────────────────────────────┐
-│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-│░░░░░░░░░░░░░░░░░░░░ Languine Engine ░░░░░░░░░░░░░░░░░░░░│
-│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-└─────────────────────────────────────────────────────────┘
-                               │
-                    ┌──────────▼──────────┐
-                    │   Controle Wijzigingen│───────┐
-                    └──────────┬──────────┘       │
-                               │                  │
-                               │ [Wijzigingen]    │ [Geen Wijzigingen]
-                               │                  │
-                    ┌──────────▼──────────┐       │
-                    │   Commit & Push     │       │
-                    └──────────┬──────────┘       │
-                               │                  │
-                    ┌──────────▼──────────┐       │
-                    │    Creëer PR        │       │
-                    └──────────┬──────────┘       │
-                               │                  │
-                    ┌──────────▼──────────┐       │
-                    │        Klaar        │◄──────┘
-                    └─────────────────────┘
-`}
-  </pre>
-</div>
-
-De werkstroom is ontworpen om geautomatiseerd te zijn, terwijl er toch ruimte is voor menselijke beoordeling en kwaliteitscontrole voordat wijzigingen in je codebase worden samengevoegd. Het handhaaft de beste praktijken voor versiebeheer en zorgt ervoor dat vertalingen goed worden bijgehouden en gedocumenteerd via de Git-geschiedenis.
diff --git a/apps/web/src/markdown/docs/nl/cli.mdx b/apps/web/src/markdown/docs/nl/cli.mdx
deleted file mode 100644
index 69a50129..00000000
--- a/apps/web/src/markdown/docs/nl/cli.mdx
+++ /dev/null
@@ -1,65 +0,0 @@
-# CLI
-
-Languine biedt een CLI om je applicatie te vertalen.
-
----
-
-## Overzicht van Commando's
-
-### Vertalen
-
-Het `translate` commando wordt gebruikt om je applicatie te vertalen.
-
-```bash title="Terminal"
-    npx languine@latest translate
-```
-
----
-
-### Init
-
-Het `init` commando wordt gebruikt om een nieuw Languine-project te initialiseren.
-
-```bash title="Terminal"
-    npx languine@latest init
-```
-
----
-
-### Auth
-
-Het `auth` commando wordt gebruikt om je te authenticeren bij Languine.
-
-```bash title="Terminal"
-    npx languine@latest auth
-```
-
----
-
-### Sync
-
-Het `sync` commando wordt gebruikt om je applicatie te synchroniseren met Languine.
-
-```bash title="Terminal"
-    npx languine@latest sync
-```
-
----
-
-### Locale Toevoegen
-
-Het `locale` commando wordt gebruikt om de locales van je applicatie te beheren.
-
-```bash title="Terminal"
-    npx languine@latest locale add pt,fr
-```
-
----
-
-### Locale Verwijderen
-
-Het `locale remove` commando wordt gebruikt om een locale uit je applicatie te verwijderen.
-
-```bash title="Terminal"
-    npx languine@latest locale remove pt,fr
-```
diff --git a/apps/web/src/markdown/docs/nl/configuration.mdx b/apps/web/src/markdown/docs/nl/configuration.mdx
deleted file mode 100644
index 690bf997..00000000
--- a/apps/web/src/markdown/docs/nl/configuration.mdx
+++ /dev/null
@@ -1,180 +0,0 @@
-# Configuratie
-
-Languine gebruikt een JSON-configuratiebestand (languine.json) om je vertaalinstellingen te beheren. Dit bestand definieert je brontalen en doeltalen, evenals de bestanden die vertaald moeten worden.
-
----
-
-## Basisconfiguratie
-
-Hier is een basisvoorbeeld in beide formaten:
-
-```json title="languine.json"
-{
-  "locale": {
-    "source": "en",
-    "targets": ["es", "fr", "de"]
-  },
-  "files": {
-    "json": {
-      "include": ["locales/[locale].json"]
-    }
-  }
-}
-```
-
-Laten we de verschillende secties in het configuratiebestand bekijken.
-
----
-
-## Locale-configuratie
-
-De locale-sectie definieert je vertaal talen:
-
-- source: Je primaire taal voor contentcreatie (bijv. "en" voor Engels)
-- targets: Een array van talen waarin je wilt vertalen (bijv. ["es", "fr", "de"] voor Spaans, Frans en Duits)
-
-Languine ondersteunt een breed scala aan taalcodes, waaronder:
-- Eenvoudige codes: en, es, fr, de
-- Regio-specifieke codes: pt-BR, zh-CN, zh-TW
-
-## Bestandsconfiguratie
-
-De bestanden sectie definieert welke bestanden Languine moet vertalen. Je kunt meerdere bestandstypen en patronen configureren:
-
----
-
-### JSON-bestanden
-```json
-files: {
-  json: {
-    include: ["locales/[locale].json"],
-  },
-}
-```
-
----
-
-### Markdown/MDX-bestanden
-```json
-files: {
-  md: {
-    include: ["docs/[locale]/*.md"],
-  },
-  mdx: {
-    include: ["blog/[locale]/*.mdx"],
-  },
-}
-```
-
----
-
-### Mobiele platformbestanden
-
-Voor iOS (Xcode):
-```json
-files: {
-  "xcode-xcstrings": {
-    include: ["Example/Localizable.xcstrings"],
-  },
-  // Of voor traditionele .strings-bestanden
-  "xcode-strings": {
-    include: ["Example/[locale].lproj/Localizable.strings"],
-  },
-}
-```
-
----
-
-Voor Android:
-```json
-files: {
-  android: {
-    include: ["locales/[locale].xml"],
-  },
-}
-```
-
----
-
-### Andere formaten
-
-Hier is een complete lijst van bestandsformaten die door Languine worden ondersteund:
-
-- [JSON](/docs/json) - Standaard JSON-vertalingsbestanden
-- [YAML](/docs/yaml) - YAML-vertalingsbestanden
-- [Properties](/docs/properties) - Java-eigenschappenbestanden
-- [Android](/docs/android) - Android XML-bronbestanden
-- [iOS](/docs/ios) - iOS-localisatiebestanden
-- [iOS Stringsdict](/docs/xcode-stringsdict) - iOS-meervoudige bestanden
-- [iOS XCStrings](/docs/xcode-xcstrings) - Moderne Xcode-stringcatalogi
-- [Markdown](/docs/md) - Documentatiebestanden
-- [MDX](/docs/mdx) - Documentatie met JSX
-- [HTML](/docs/html) - HTML-bestanden
-- [JavaScript](/docs/js) - JavaScript-bestanden
-- [TypeScript](/docs/ts) - TypeScript-bestanden
-- [Gettext PO](/docs/po) - GetText-vertalingsbestanden
-- [XLIFF](/docs/xliff) - XML Localization Interchange File Format
-- [CSV](/docs/csv) - Spreadsheet-gebaseerde vertalingen
-- [XML](/docs/xml) - XML-bronbestanden
-- [Flutter ARB](/docs/arb) - Application Resource Bundle-bestanden
-
----
-
-## Bestands patronen
-
-De [locale] placeholder in bestands patronen wordt automatisch vervangen door de juiste taalcode tijdens de vertaling. Bijvoorbeeld:
-
-- locales/[locale].json wordt:
-  - locales/en.json
-  - locales/es.json
-  - locales/fr.json
-
-Je kunt meerdere patronen voor elk bestandstype opnemen en glob-patronen gebruiken:
-```json
-files: {
-  json: {
-    include: [
-      "src/locales/[locale].json",
-      "src/components/[locale]/*.json"
-    ],
-  },
-}
-```
-
----
-
-## Project-ID (Optioneel)
-
-Als je gebruik maakt van de cloudservices van Languine, kun je je project-ID in de configuratie opnemen:
-
-```json
-{
-  "projectId": "prj_your_project_id",
-  "locale": {
-    // ... locale-configuratie
-  },
-  files: {
-    // ... bestandenconfiguratie
-  },
-}
-```
-
----
-
-## Volgen van vertaalstatus
-
-Languine maakt automatisch een languine.lock-bestand aan en onderhoudt dit om de status van je vertalingen bij te houden. Dit bestand:
-
-- Houdt bij welke content is vertaald
-- Helpt identificeren wat moet worden bijgewerkt wanneer de brontekst verandert
-- Moet worden gecommit naar je versiebeheersysteem
-
-Je hoeft het lock-bestand niet handmatig te bewerken - Languine beheert dit automatisch wanneer je vertaalopdrachten uitvoert.
-
-## Beste praktijken
-
-1. **Versiebeheer**: Commit altijd zowel languine.json als languine.lock naar je repository
-2. **Bestandsorganisatie**: Houd je vertaalbestanden georganiseerd in een consistente mappenstructuur
-3. **Taalcodes**: Gebruik standaardtaalcodes om compatibiliteit te waarborgen
-4. **Patronen**: Gebruik specifieke inclusiepatronen om te voorkomen dat onnodige bestanden worden vertaald
-5. **Project-ID**: Houd je project-ID veilig en deel deze niet openbaar als je cloudservices gebruikt, gebruik in plaats daarvan de omgevingsvariabele `LANGUINE_PROJECT_ID`.
diff --git a/apps/web/src/markdown/docs/nl/csv.mdx b/apps/web/src/markdown/docs/nl/csv.mdx
deleted file mode 100644
index bde8ddd1..00000000
--- a/apps/web/src/markdown/docs/nl/csv.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# CSV
-
-Languine ondersteunt CSV (Comma-Separated Values) bestanden voor eenvoudige vertaalbeheer. Dit formaat is ideaal voor spreadsheet-gebaseerde workflows en eenvoudige integratie met externe vertaaltools.
-
----
-
-## Instellen
-
-Zorg er eerst voor dat je een languine.json configuratiebestand in de hoofdmap van je project hebt. Hier is een voorbeeld:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "csv": {
-      "include": ["translations/[locale].csv"]
-    }
-  }
-}
-```
-
-## Vertalen
-
-Met je configuratie ingesteld, voer je uit:
-
-```bash
-npx languine@latest translate
-```
-
-Wanneer je dit commando uitvoert, zal Languine:
-
-- Je bron CSV-bestand laden (bijv. translations/en.csv)
-- Nieuwe of gewijzigde vertaalstrings detecteren
-- Vertalingen genereren voor je doeltalen
-- De CSV-bestanden voor de doeltalen aanmaken of bijwerken (bijv. translations/sv.csv)
-- De kolomstructuur en opmaak behouden
-- Eventuele extra metadata-kolommen behouden
diff --git a/apps/web/src/markdown/docs/nl/expo.mdx b/apps/web/src/markdown/docs/nl/expo.mdx
deleted file mode 100644
index 639477a5..00000000
--- a/apps/web/src/markdown/docs/nl/expo.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# Expo
-
-Languine ondersteunt Expo-localisatie en integreert naadloos met het i18n-systeem van Expo. Dit formaat werkt met zowel JavaScript- als TypeScript-projecten en ondersteunt geneste structuren en pluralisatie.
-
----
-
-## Instellen
-
-Zorg er eerst voor dat je een languine.json-configuratiebestand in de hoofdmap van je project hebt. Hier is een voorbeeld:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "expo": {
-      "include": ["assets/locales/[locale].json"]
-    }
-  }
-}
-```
-
-## Vertalen
-
-Met je configuratie ingesteld, voer je uit:
-
-```bash
-npx languine@latest translate
-```
-
-Wanneer je dit commando uitvoert, zal Languine:
-
-- Je brondocument met vertalingen laden (bijv. assets/locales/en.json)
-- Nieuwe of gewijzigde vertaalstrings detecteren
-- Vertalingen genereren voor je doeltalen
-- De bestanden voor de doeltalen aanmaken of bijwerken (bijv. assets/locales/sv.json)
-- De geneste structuur en pluralisatieregels behouden
-- Compatibiliteit met expo-localization handhaven
diff --git a/apps/web/src/markdown/docs/nl/github-actions.mdx b/apps/web/src/markdown/docs/nl/github-actions.mdx
deleted file mode 100644
index 341a11c5..00000000
--- a/apps/web/src/markdown/docs/nl/github-actions.mdx
+++ /dev/null
@@ -1,147 +0,0 @@
-# GitHub Acties
-
-Met de GitHub-actie kun je eenvoudig je code vertalen door je code naar de repository te pushen; de GitHub-actie vertaalt vervolgens je nieuwe sleutels, maakt een pull request of commit je wijzigingen.
-Dit bespaart je veel tijd en moeite terwijl je hoogwaardige vertalingen behoudt.
-
----
-
-## Hoe het werkt
-
-
-
-<div className="flex flex-col items-center justify-center p-4 mb-8 h-[400px] sm:h-[500px] md:h-[650px]">
-        <pre
-          className="p-4 text-sm leading-5 scale-[0.5] sm:scale-[0.65] md:scale-90 transform-gpu"
-          style={{
-            fontFamily: "monospace",
-            whiteSpace: "pre",
-            textAlign: "left",
-          }}
-        >
-          {`
-                                  ┌───────────────┐
-                                  │   Git Push    │
-                                  └───────────────┘
-                                          │
-                                          ▼
-             ┌─────────────────────────────────────────────────────────┐
-             │░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-             │░░░░░░░░░░░░░░░░░░░░ Languine Engine ░░░░░░░░░░░░░░░░░░░░│
-             │░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-             └─────────────────────────────────────────────────────────┘
-                                          │
-                                          ▼
-                                          │
-            ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┼ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─
-           │                              │                              │
-           ▼                              ▼                              ▼
- ╔═══════════════════╗          ╔═══════════════════╗          ╔═══════════════════╗
- ║                   ║          ║                   ║          ║                   ║
- ║      Engels       ║          ║      Spaans       ║          ║      Japans      ║
- ║    Vertaling      ║          ║    Vertaling      ║          ║     Vertaling    ║
- ║                   ║          ║                   ║          ║                   ║
- ╚═══════════════════╝          ╚═══════════════════╝          ╚═══════════════════╝
-           │                              │                              │
-           └──────────────────────────────┼──────────────────────────────┘
-                                          ▼
-                                  ┌───────────────┐
-                                  │     Samenvoegen │
-                                  │ Pull Request  │
-                                  └───────────────┘
-                                          │
-                                          ▼
-                              ┌─────────────────────┐
-                              │      Voltooid       │
-                              │      (Implementeren) │
-                              └─────────────────────┘
-`}
-        </pre>
-      </div>
-
----
-
-## Installatie
-
-Om de Languine GitHub-actie in je repository te gebruiken, moet je:
-
-1. Je repository-secrets instellen met je Languine-gegevens
-2. Een workflow-bestand in je repository maken
-
-### Instellen van Repository Secrets
-
-Voeg de volgende secrets toe in je repository-instellingen (Instellingen > Secrets en variabelen > Acties):
-
-- `LANGUINE_API_KEY`: Je Languine API-sleutel
-- `LANGUINE_PROJECT_ID`: Je Languine project-ID
-
-Je kunt deze waarden vinden in je Languine-dashboard onder Projectinstellingen.
-
-
-
-### Omgevingsvariabelen
-
-De GitHub-actie gebruikt de volgende omgevingsvariabelen:
-- `LANGUINE_API_KEY` (Vereist): Je Languine API-sleutel voor authenticatie
-- `LANGUINE_PROJECT_ID` (Vereist): Je Languine project-ID 
-- `GITHUB_TOKEN` (Vereist): Automatisch geleverd door GitHub, gebruikt voor het maken van PR's
-
-### Voorbeeld Workflow
-
-Maak een nieuw bestand .github/workflows/languine.yml in je repository met de volgende inhoud:
-
-```ts title=".github/workflows/release.yml"
-name: Website Implementeren
-
-on:
-  push:
-    branches:
-      - '**'
-    paths:
-      - apps/web/**
-
-jobs:
-  translate:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-      pull-requests: write
-    steps:
-      - uses: actions/checkout@v4
-      
-      - name: Languine Actie
-        uses: languine/languine-action@v1
-        env:
-           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          api-key: ${{ secrets.LANGUINE_API_KEY }}
-          project-id: ${{ secrets.LANGUINE_PROJECT_ID }}
-```
- 
- Deze workflow zal:
-- Uitvoeren bij pushes naar de hoofdbranch
-- Uitvoeren bij pull requests naar de hoofdbranch
-- Handmatig geactiveerd kunnen worden vanuit het tabblad Acties
-- Je code uitchecken en het Languine-vertalingsproces uitvoeren
-- Een pull request maken met eventuele nieuwe vertalingen (configureerbaar)
-
-#### Werkdirectory Optie
-
-De optie `working-directory` stelt je in staat om op te geven waar je vertaalbestanden zich bevinden. Dit is bijzonder nuttig in monorepos waar je vertalingen zich in een specifieke pakket- of app-directory kunnen bevinden. Bijvoorbeeld:
-
-#### Pull Request Optie (binnenkort beschikbaar)
-
-De optie `create-pull-request` bepaalt of de actie een pull request maakt met de wijzigingen of deze rechtstreeks naar de branch commit:
-
-```typescript title=".github/workflows/languine.yml"
-with:
-  create-pull-request: true # maak een pull request met de wijzigingen
-```
-
-Wanneer ingesteld op `true`, zal de actie:
-- Een nieuwe branch maken met de wijzigingen
-- Een pull request voor beoordeling maken
-- Geschikte labels en beschrijving toevoegen
-
-Wanneer ingesteld op `false` (standaard), zal de actie:
-- De wijzigingen rechtstreeks naar de huidige branch committen
-- De wijzigingen pushen zonder een pull request te maken
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/nl/html.mdx b/apps/web/src/markdown/docs/nl/html.mdx
deleted file mode 100644
index ab9f071c..00000000
--- a/apps/web/src/markdown/docs/nl/html.mdx
+++ /dev/null
@@ -1,41 +0,0 @@
-# HTML
-
-Languine ondersteunt de lokalisatie van HTML-bestanden, waarbij zowel tekstinhoud als attributen worden behandeld. Dit formaat is ideaal voor statische websites en HTML-sjablonen, met ondersteuning voor het behouden van de HTML-structuur en opmaak.
-
----
-
-## Instellen
-
-Zorg er eerst voor dat je een languine.json-configuratiebestand in de hoofdmap van je project hebt. Hier is een voorbeeld:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "html": {
-      "include": ["pages/[locale]/*.html"]
-    }
-  }
-}
-```
-
-## Vertalen
-
-Met je configuratie ingesteld, voer je uit:
-
-```bash
-npx languine@latest translate
-```
-
-Wanneer je dit commando uitvoert, zal Languine:
-
-- Je bron-HTML-bestanden laden (bijv. pages/en/*.html)
-- Nieuwe of gewijzigde vertaalstrings detecteren
-- Vertalingen genereren voor je doeltalen
-- De HTML-bestanden in de doeltaal maken of bijwerken (bijv. pages/sv/*.html)
-- De HTML-structuur en opmaak behouden
-- Gespecificeerde attribuutvertalingen verwerken
-- Opmerkingen en speciale tags behouden
diff --git a/apps/web/src/markdown/docs/nl/introduction.mdx b/apps/web/src/markdown/docs/nl/introduction.mdx
deleted file mode 100644
index ce181f7d..00000000
--- a/apps/web/src/markdown/docs/nl/introduction.mdx
+++ /dev/null
@@ -1,34 +0,0 @@
-# Introductie
-
-Languine automatiseert lokalisatie binnen uw ontwikkelingsworkflow en pipeline, zodat vertalingen u nooit ophouden.
-
-Transformeer uw applicatie in enkele minuten in een meertalige ervaring. Terwijl u zich richt op het bouwen van functies, zorgt Languine voor alle aspecten van vertaling met precisie en betrouwbaarheid.
-
----
-
-## Belangrijkste Kenmerken
-
-- **Vertaalmachine**: Maak gebruik van contextbewuste, hoogwaardige vertalingen die uw merksstem behouden
-- **CI/CD Integratie**: Automatiseer vertaalupdates via uw bestaande workflows
-- **Formaten**: Beheer elk bestandsformaat met ons uitbreidbare parser-systeem
-- **Open Source**: Toegang, inspectie en bijdragen aan onze codebase op GitHub - geen black boxes, volledige transparantie
-
----
-
-## Hoe Het Werkt
-
-1. **Snelle Setup**: Begin in enkele minuten met onze intuïtieve CLI en begeleide initialisatie
-2. **Eenvoudige Configuratie**: Definieer uw vertaalbehoeften met een duidelijk, eenvoudig configuratiebestand
-3. **Geautomatiseerde Vertaling**: Push uw inhoud één keer en laat Languine automatisch de vertaling naar alle doeltalen afhandelen
-
----
-
-## Aan de Slag
-
-Begin uw lokalisatie-reis met onze [Quickstart](/docs/quickstart) gids - u heeft uw eerste vertalingen binnen enkele minuten draaien.
-
-Verken onze uitgebreide documentatie om de mogelijkheden van Languine te beheersen:
-
-- [Configuratie](/docs/configuration) - Configureer Languine naar de behoeften van uw project
-- [CLI](/docs/cli) - Beheers onze krachtige opdrachtregelinterface
-- [Github Acties](/docs/github-actions) - Automatiseer vertalingen met onze Github Actie
diff --git a/apps/web/src/markdown/docs/nl/ios.mdx b/apps/web/src/markdown/docs/nl/ios.mdx
deleted file mode 100644
index dc143c90..00000000
--- a/apps/web/src/markdown/docs/nl/ios.mdx
+++ /dev/null
@@ -1,39 +0,0 @@
-# iOS
-
-Languine ondersteunt iOS Localizable.strings-bestanden, het standaardlokalisatieformaat voor iOS-toepassingen. Dit formaat behandelt basis sleutel-waarde stringparen en ondersteunt opmerkingen om context te bieden aan vertalers.
-
----
-
-## Instellen
-
-Zorg er eerst voor dat je een languine.json-configuratiebestand in de hoofdmap van je project hebt. Hier is een voorbeeld:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "ios": {
-      "include": ["[locale].lproj/Localizable.strings"]
-    }
-  }
-}
-```
-
-## Vertalen
-
-Met je configuratie ingesteld, voer je uit:
-
-```bash
-npx languine@latest translate
-```
-
-Wanneer je dit commando uitvoert, zal Languine:
-
-- Je bron Localizable.strings-bestand laden (bijv. en.lproj/Localizable.strings)
-- Nieuwe of gewijzigde vertaalstrings detecteren
-- Vertalingen genereren voor je doeltalen
-- De doeltaalbestanden aanmaken of bijwerken (bijv. sv.lproj/Localizable.strings)
-- Bestaande opmerkingen en opmaak behouden
diff --git a/apps/web/src/markdown/docs/nl/js.mdx b/apps/web/src/markdown/docs/nl/js.mdx
deleted file mode 100644
index af390aab..00000000
--- a/apps/web/src/markdown/docs/nl/js.mdx
+++ /dev/null
@@ -1,42 +0,0 @@
-# JavaScript
-
-Languine ondersteunt JavaScript/TypeScript lokalisatiebestanden, perfect voor moderne webapplicaties. Dit formaat ondersteunt zowel objectliteral als module-exporten, en ondersteunt geneste structuren en dynamische inhoud.
-
----
-
-## Instellen
-
-Zorg er eerst voor dat je een languine.json-configuratiebestand in de hoofdmap van je project hebt. Hier is een voorbeeld:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "js": {
-      "include": ["src/locales/[locale].js"]
-    }
-  }
-}
-```
-
-## Vertalen
-
-Met je configuratie ingesteld, voer je uit:
-
-```bash
-npx languine@latest translate
-```
-
-Wanneer je dit commando uitvoert, zal Languine:
-
-- Je bron JavaScript-bestanden laden (bijv. src/locales/en.js)
-- Nieuwe of gewijzigde vertaalstrings detecteren
-- Vertalingen genereren voor je doeltalen
-- De doeltaalbestanden maken of bijwerken (bijv. src/locales/sv.js)
-- De module-structuur en exporten behouden
-- Geneste objecten en arrays verwerken
-- De code-indeling en opmerkingen behouden
-- TypeScript-typen genereren indien ingeschakeld
diff --git a/apps/web/src/markdown/docs/nl/json.mdx b/apps/web/src/markdown/docs/nl/json.mdx
deleted file mode 100644
index 91a15900..00000000
--- a/apps/web/src/markdown/docs/nl/json.mdx
+++ /dev/null
@@ -1,41 +0,0 @@
-# JSON
-
-Languine ondersteunt JSON-bestanden als een brontype met de gebruikelijke vereisten voor pluralisatie en interpolatie. Dit formaat wordt gebruikt in veel frameworks zoals React, Vue, Ruby on Rails en meer.
-
-
----
-
-
-## Instellen
-
-Zorg er eerst voor dat je een languine.json-configuratiebestand in de hoofdmap van je project hebt. Hier is een voorbeeld:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "json": {
-      "include": ["locales/[locale].json"]
-    }
-  }
-}
-
-```
-
-## Vertalen
-
-Met je configuratie ingesteld, voer je uit:
-
-```bash
-npx languine@latest translate
-```
-
-Wanneer je dit commando uitvoert, zal Languine:
-
-- Je bron JSON-bestand laden (bijv. locales/en.json)
-- Nieuwe of gewijzigde vertaalstrings detecteren
-- Vertalingen genereren voor je doeltalen
-- De JSON-bestanden voor de doeltalen aanmaken of bijwerken (bijv. locales/sv.json, locales/de.json, locales/fr.json)
diff --git a/apps/web/src/markdown/docs/nl/md.mdx b/apps/web/src/markdown/docs/nl/md.mdx
deleted file mode 100644
index 98cbaa14..00000000
--- a/apps/web/src/markdown/docs/nl/md.mdx
+++ /dev/null
@@ -1,43 +0,0 @@
-# Markdown
-
-Languine ondersteunt de lokalisatie van Markdown-bestanden, perfect voor documentatie, blogposts en contentrijke sites. Dit formaat behoudt de Markdown-syntaxis tijdens het vertalen van de inhoud, inclusief ondersteuning voor front matter.
-
----
-
-## Instellen
-
-Zorg er eerst voor dat je een languine.json-configuratiebestand in de hoofdmap van je project hebt. Hier is een voorbeeld:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "md": {
-      "include": ["content/[locale]/**/*.md"]
-    }
-  }
-}
-```
-
-## Vertalen
-
-Met je configuratie ingesteld, voer je uit:
-
-```bash
-npx languine@latest translate
-```
-
-Wanneer je dit commando uitvoert, zal Languine:
-
-- Je bron Markdown-bestanden laden (bijv. content/en/*.md)
-- Nieuwe of gewijzigde inhoud detecteren
-- Vertalingen genereren voor je doeltalen
-- De doeltaalbestanden aanmaken of bijwerken (bijv. content/sv/*.md)
-- De Markdown-opmaak en -structuur behouden
-- Vertalingen van front matter afhandelen
-- Links en verwijzingen behouden
-- Codeblokken onvertaald houden
-- HTML binnen Markdown behouden
diff --git a/apps/web/src/markdown/docs/nl/mdx.mdx b/apps/web/src/markdown/docs/nl/mdx.mdx
deleted file mode 100644
index a914dac6..00000000
--- a/apps/web/src/markdown/docs/nl/mdx.mdx
+++ /dev/null
@@ -1,43 +0,0 @@
-# Markdown (MDX)
-
-Languine ondersteunt de lokalisatie van Markdown (MDX) bestanden, perfect voor documentatie, blogposts en contentrijke sites. Dit formaat behoudt de Markdown-syntaxis terwijl de inhoud wordt vertaald, inclusief ondersteuning voor front matter.
-
----
-
-## Instellen
-
-Zorg er eerst voor dat je een languine.json configuratiebestand in de hoofdmap van je project hebt. Hier is een voorbeeld:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "mdx": {
-      "include": ["content/[locale]/**/*.mdx"]
-    }
-  }
-}
-```
-
-## Vertalen
-
-Met je configuratie ingesteld, voer je uit:
-
-```bash
-npx languine@latest translate
-```
-
-Wanneer je dit commando uitvoert, zal Languine:
-
-- Je bron Markdown-bestanden laden (bijv. content/en/*.mdx)
-- Nieuwe of gewijzigde inhoud detecteren
-- Vertalingen genereren voor je doeltalen
-- De doeltaalbestanden aanmaken of bijwerken (bijv. content/sv/*.mdx)
-- De Markdown-opmaak en -structuur behouden
-- Vertalingen van front matter afhandelen
-- Links en verwijzingen behouden
-- Codeblokken onvertaald laten
-- HTML binnen Markdown behouden
diff --git a/apps/web/src/markdown/docs/nl/overrides.mdx b/apps/web/src/markdown/docs/nl/overrides.mdx
deleted file mode 100644
index eb7a9c51..00000000
--- a/apps/web/src/markdown/docs/nl/overrides.mdx
+++ /dev/null
@@ -1,7 +0,0 @@
-# Overschrijvingen
-
-Languine stelt je in staat om vertalingen voor specifieke sleutels te overschrijven. Dit is nuttig wanneer je wilt zorgen dat een specifieke vertaling wordt gebruikt voor een bepaalde sleutel, ongeacht de standaardvertaling.
-
-## Hoe het werkt
-
-In het dashboard kun je overschrijvingen maken voor specifieke sleutels. Je kunt ook overschrijvingen maken voor specifieke talen.
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/nl/po.mdx b/apps/web/src/markdown/docs/nl/po.mdx
deleted file mode 100644
index 470347d5..00000000
--- a/apps/web/src/markdown/docs/nl/po.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# PO (Gettext)
-
-Languine ondersteunt PO-bestanden, het veelgebruikte Gettext-lokalisatieformaat. Dit formaat is populair in veel programmeeromgevingen, met name in Linux-toepassingen en PHP-frameworks, en biedt ondersteuning voor context, meervouden en vertalercommentaren.
-
----
-
-## Instellen
-
-Zorg er eerst voor dat je een languine.json-configuratiebestand in de hoofdmap van je project hebt. Hier is een voorbeeld:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "po": {
-      "include": ["locales/[locale]/LC_MESSAGES/messages.po"]
-    }
-  }
-}
-```
-
-## Vertalen
-
-Met je configuratie ingesteld, voer je uit:
-
-```bash
-npx languine@latest translate
-```
-
-Wanneer je dit commando uitvoert, zal Languine:
-
-- Je bron PO-bestand laden (bijv. locales/en/LC_MESSAGES/messages.po)
-- Nieuwe of gewijzigde vertaalstrings detecteren
-- Vertalingen genereren voor je doeltalen
-- De PO-bestanden voor de doeltaal aanmaken of bijwerken (bijv. locales/sv/LC_MESSAGES/messages.po)
-- Metadata, contexten en meervoudsvormen behouden
-- Vertalercommentaren en referentie-informatie onderhouden
diff --git a/apps/web/src/markdown/docs/nl/prettier.mdx b/apps/web/src/markdown/docs/nl/prettier.mdx
deleted file mode 100644
index f5f38344..00000000
--- a/apps/web/src/markdown/docs/nl/prettier.mdx
+++ /dev/null
@@ -1,22 +0,0 @@
-# Prettier
-
-Languine kan samenwerken met [Prettier](https://prettier.io/) om ervoor te zorgen dat je vertaalbestanden consistent zijn opgemaakt. Dit is bijzonder nuttig bij het werken met JSON-vertalingsbestanden die een consistente stijl in je project moeten behouden.
-
-## Gebruik met Languine
-
-De aanbevolen manier om Prettier met Languine te gebruiken, is door je vertaalbestanden op te maken nadat ze zijn gegenereerd. Je kunt dit instellen in je `package.json`:
-
-```json title="package.json"
-{
-  "scripts": {
-    "translate": "languine translate",
-    "format": "prettier --write \"locales/**/*.json\"",
-    "translate:format": "npm run translate && npm run format"
-  }
-}
-```
-
-Nu kun je:
-- `npm run translate` uitvoeren om alleen vertalingen te genereren
-- `npm run format` uitvoeren om alleen bestaande vertaalbestanden op te maken
-- `npm run translate:format` uitvoeren om vertalingen te genereren en ze in volgorde op te maken
diff --git a/apps/web/src/markdown/docs/nl/properties.mdx b/apps/web/src/markdown/docs/nl/properties.mdx
deleted file mode 100644
index 86c02940..00000000
--- a/apps/web/src/markdown/docs/nl/properties.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# Eigenschappen
-
-Languine ondersteunt Java Properties-bestanden, het standaardlokalisatieformaat voor Java-toepassingen. Dit formaat behandelt Unicode-escapingen en ondersteunt zowel sleutel-waardeparen als opmerkingen.
-
----
-
-## Instellen
-
-Zorg er eerst voor dat je een languine.json-configuratiebestand in de hoofdmap van je project hebt. Hier is een voorbeeld:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "properties": {
-      "include": ["src/main/resources/messages_[locale].properties"]
-    }
-  }
-}
-```
-
-## Vertalen
-
-Met je configuratie ingesteld, voer je uit:
-
-```bash
-npx languine@latest translate
-```
-
-Wanneer je dit commando uitvoert, zal Languine:
-
-- Je bronpropertiesbestand laden (bijv. messages_en.properties)
-- Nieuwe of gewijzigde vertaalstrings detecteren
-- Vertalingen genereren voor je doeltalen
-- De doeltaalpropertiesbestanden aanmaken of bijwerken (bijv. messages_sv.properties)
-- Unicode-escapingen automatisch afhandelen
-- Opmerkingen en opmaak behouden
diff --git a/apps/web/src/markdown/docs/nl/quickstart.mdx b/apps/web/src/markdown/docs/nl/quickstart.mdx
deleted file mode 100644
index 213a8d8c..00000000
--- a/apps/web/src/markdown/docs/nl/quickstart.mdx
+++ /dev/null
@@ -1,65 +0,0 @@
-# Snelle Start
-
-Begin met het installeren van Languine.
-
-Voer vervolgens de volgende opdracht uit om Languine te initialiseren.
-
-```bash title="Terminal"
-npx languine@latest init
-```
-
-Volg de stappen om uw project in te stellen.
-
----
-
-## Eerste Vertaling
-
-Nu bent u klaar om uw code te vertalen.
-
-Begin met het toevoegen van een sleutel aan uw bronbestand, bijvoorbeeld als u ervoor kiest om `en.json` als uw bronbestand te gebruiken, voeg dan een sleutel toe.
-
-```json title="src/locales/en.json"
-{
-  "welcome": "Welkom bij onze applicatie!",
-  "user": {
-    "greeting": "Hallo, {{name}}!",
-    "profile": {
-      "title": "Uw profiel",
-      "edit": "Profiel bewerken"
-    }
-  },
-  "notifications": {
-    "messages": "U heeft {{count}} nieuw(e) bericht(en).",
-    "empty": "Geen nieuwe meldingen."
-  }
-}
-
-```
-
----
-
-## Vertalen
-
-Voer de volgende opdracht uit om uw inhoud te vertalen:
-
-```bash title="Terminal"
-npx languine@latest translate
-```
-
-## Dit zal:
-1. Vertaalbestanden maken voor elke doeltaal
-2. Hoogwaardige vertalingen genereren met de Languine Engine
-3. Een `languine.lock`-bestand maken om de vertaalstatussen bij te houden
-
-Het lockbestand helpt Languine te identificeren welke vertalingen updates nodig hebben wanneer uw broninhoud verandert. Zorg ervoor dat u dit bestand aan uw repository toevoegt.
-
----
-
-## Volgende Stappen
-
-Nu u Languine hebt ingesteld, kunt u:
-- Meer talen toevoegen in uw `languine.json`-bestand
-- Languine integreren in uw CI/CD-pijplijn
-- Onze API gebruiken voor programmatic vertalingen
-
-Bekijk onze andere handleidingen om meer te leren over de geavanceerde functies van Languine.
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/nl/react-email.mdx b/apps/web/src/markdown/docs/nl/react-email.mdx
deleted file mode 100644
index 192243dd..00000000
--- a/apps/web/src/markdown/docs/nl/react-email.mdx
+++ /dev/null
@@ -1,41 +0,0 @@
-# React Email
-
-Languine ondersteunt React Email-sjablonen, waarmee je vertalingen voor je e-mailsjablonen die zijn gebouwd met React Email kunt beheren. Deze integratie behandelt zowel tekstinhoud als HTML-attributen, terwijl de React-componentstructuur behouden blijft.
-
----
-
-## Instellen
-
-Zorg er eerst voor dat je een languine.json-configuratiebestand in de hoofdmap van je project hebt. Hier is een voorbeeld:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "react-email": {
-      "include": ["emails/[locale]/*.tsx"]
-    }
-  }
-}
-```
-
-## Vertalen
-
-Met je configuratie ingesteld, voer je uit:
-
-```bash
-npx languine@latest translate
-```
-
-Wanneer je dit commando uitvoert, zal Languine:
-
-- Je bron React Email-sjablonen laden (bijv. emails/en/*.tsx)
-- Nieuwe of gewijzigde vertaalstrings detecteren
-- Vertalingen genereren voor je doeltalen
-- De e-mailsjablonen in de doeltaal aanmaken of bijwerken (bijv. emails/sv/*.tsx)
-- De React-componentstructuur en props behouden
-- HTML-opmaak en styling handhaven
-- Interpolatie en dynamische inhoud verwerken
diff --git a/apps/web/src/markdown/docs/nl/ts.mdx b/apps/web/src/markdown/docs/nl/ts.mdx
deleted file mode 100644
index 66efe646..00000000
--- a/apps/web/src/markdown/docs/nl/ts.mdx
+++ /dev/null
@@ -1,42 +0,0 @@
-# TypeScript
-
-Languine ondersteunt TypeScript-lokalisatiebestanden met volledige typeveiligheid. Dit formaat breidt de ondersteuning voor JavaScript uit met extra TypeScript-specifieke functies en mogelijkheden voor typegeneratie.
-
----
-
-## Instellen
-
-Zorg er eerst voor dat je een languine.json-configuratiebestand in de hoofdmap van je project hebt. Hier is een voorbeeld:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "ts": {
-      "include": ["src/locales/[locale].ts"]
-    }
-  }
-}
-```
-
-## Vertalen
-
-Met je configuratie ingesteld, voer je uit:
-
-```bash
-npx languine@latest translate
-```
-
-Wanneer je dit commando uitvoert, zal Languine:
-
-- Je bron TypeScript-bestanden laden (bijv. src/locales/en.ts)
-- Nieuwe of gewijzigde vertaalstrings detecteren
-- Vertalingen genereren voor je doeltalen
-- De doeltaalbestanden maken of bijwerken (bijv. src/locales/sv.ts)
-- Type-aantekeningen en interfaces behouden
-- Geneste objecten met de juiste typing verwerken
-- De code-indeling en documentatiecommentaar behouden
-- Ondersteuning bieden voor letterlijke types en unietypes
diff --git a/apps/web/src/markdown/docs/nl/xcode-stringsdict.mdx b/apps/web/src/markdown/docs/nl/xcode-stringsdict.mdx
deleted file mode 100644
index 1dc7c0b6..00000000
--- a/apps/web/src/markdown/docs/nl/xcode-stringsdict.mdx
+++ /dev/null
@@ -1,44 +0,0 @@
-# Xcode Stringsdict
-
-Languine ondersteunt het Stringsdict-formaat van Xcode, dat wordt gebruikt voor complexe pluralisatie regels in iOS- en macOS-toepassingen. Dit formaat behandelt meervoudsvormen, variabele substituties en taalspecifieke meervoudregels.
-
----
-
-## Instellen
-
-Zorg er eerst voor dat je een languine.json-configuratiebestand in de hoofdmap van je project hebt. Hier is een voorbeeld:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "stringsdict": {
-      "include": ["MyApp/Localizable.stringsdict"]
-    }
-  }
-}
-```
-
-## Vertalen
-
-Met je configuratie ingesteld, voer je uit:
-
-```bash
-npx languine@latest translate
-```
-
-Wanneer je dit commando uitvoert, zal Languine:
-
-- Je Stringsdict-bestanden laden
-- Nieuwe of gewijzigde meervoudregels detecteren
-- Vertalingen genereren voor je doeltalen
-- De Stringsdict-bestanden bijwerken met nieuwe vertalingen
-- Complexe meervoudregels voor elke taal afhandelen
-- Variabele substituties behouden
-- De structuur van het woordenboek behouden
-- Ondersteuning bieden voor taalspecifieke meervoudsvormen
-- De consistentie van meervoudregels valideren
-- Formatteringsspecificaties behouden
diff --git a/apps/web/src/markdown/docs/nl/xcode-xcstrings.mdx b/apps/web/src/markdown/docs/nl/xcode-xcstrings.mdx
deleted file mode 100644
index 85c25b95..00000000
--- a/apps/web/src/markdown/docs/nl/xcode-xcstrings.mdx
+++ /dev/null
@@ -1,44 +0,0 @@
-# Xcode Strings (XCStrings)
-
-Languine ondersteunt het XCStrings-formaat van Xcode, het moderne lokalisatieformaat voor iOS- en macOS-toepassingen. Dit formaat beheert stringcatalogi met ondersteuning voor variaties, pluralisatie en opmerkingen van ontwikkelaars.
-
----
-
-## Instellen
-
-Zorg er eerst voor dat je een languine.json-configuratiebestand in de hoofdmap van je project hebt. Hier is een voorbeeld:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "xcstrings": {
-      "include": ["MyApp/Localizable.xcstrings"]
-    }
-  }
-}
-```
-
-## Vertalen
-
-Met je configuratie ingesteld, voer je uit:
-
-```bash
-npx languine@latest translate
-```
-
-Wanneer je dit commando uitvoert, zal Languine:
-
-- Je XCStrings-catalogus laden
-- Nieuwe of gewijzigde strings detecteren
-- Vertalingen genereren voor je doeltalen
-- De stringcatalogus bijwerken met nieuwe vertalingen
-- Stringvariaties en pluralisatieregels behouden
-- Opmerkingen van ontwikkelaars en context behouden
-- Variabele substituties verwerken
-- Adaptieve strings ondersteunen
-- Formatteringsspecificaties behouden
-- De structuur van de stringcatalogus valideren
diff --git a/apps/web/src/markdown/docs/nl/xliff.mdx b/apps/web/src/markdown/docs/nl/xliff.mdx
deleted file mode 100644
index e644e6e8..00000000
--- a/apps/web/src/markdown/docs/nl/xliff.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# XLIFF
-
-Languine ondersteunt XLIFF (XML Localization Interchange File Format), een op XML gebaseerd formaat dat is ontworpen voor het uitwisselen van lokalisatiegegevens. Dit formaat wordt veel gebruikt in professionele vertaalworkflows en ondersteunt zowel XLIFF 1.2 als 2.0 versies.
-
----
-
-## Instellen
-
-Zorg er eerst voor dat je een languine.json configuratiebestand in de hoofdmap van je project hebt. Hier is een voorbeeld:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "xliff": {
-      "include": ["locales/[locale].xlf"]
-    }
-  }
-}
-```
-
-## Vertalen
-
-Met je configuratie ingesteld, voer je uit:
-
-```bash
-npx languine@latest translate
-```
-
-Wanneer je dit commando uitvoert, zal Languine:
-
-- Je bron XLIFF-bestand laden (bijv. locales/en.xlf)
-- Nieuwe of gewijzigde vertaalunits detecteren
-- Vertalingen genereren voor je doeltalen
-- De XLIFF-bestanden voor de doeltaal aanmaken of bijwerken (bijv. locales/sv.xlf)
-- Notities, contextinformatie en statusattributen behouden
-- Compatibiliteit met CAT (Computer-Aided Translation) tools handhaven
diff --git a/apps/web/src/markdown/docs/nl/xml.mdx b/apps/web/src/markdown/docs/nl/xml.mdx
deleted file mode 100644
index 4083d91a..00000000
--- a/apps/web/src/markdown/docs/nl/xml.mdx
+++ /dev/null
@@ -1,44 +0,0 @@
-# XML
-
-Languine ondersteunt de lokalisatie van XML-bestanden, geschikt voor verschillende op XML gebaseerde configuratie- en inhoudsbestanden. Dit formaat kan complexe XML-structuren verwerken terwijl het de opmaak en attributen behoudt.
-
----
-
-## Instellen
-
-Zorg er eerst voor dat je een languine.json-configuratiebestand in de hoofdmap van je project hebt. Hier is een voorbeeld:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "xml": {
-      "include": ["resources/[locale]/*.xml"]
-    }
-  }
-}
-```
-
-## Vertalen
-
-Met je configuratie ingesteld, voer je uit:
-
-```bash
-npx languine@latest translate
-```
-
-Wanneer je dit commando uitvoert, zal Languine:
-
-- Je bron-XML-bestanden laden (bijv. resources/en/*.xml)
-- Nieuwe of gewijzigde inhoud detecteren
-- Vertalingen genereren voor je doeltalen
-- De doeltaalbestanden aanmaken of bijwerken (bijv. resources/sv/*.xml)
-- De XML-structuur en opmaak behouden
-- Attribuutvertalingen verwerken
-- CDATA-secties behouden
-- XML-opmerkingen behouden
-- XML-namespaces ondersteunen
-- De XML-structuur valideren
diff --git a/apps/web/src/markdown/docs/nl/yaml.mdx b/apps/web/src/markdown/docs/nl/yaml.mdx
deleted file mode 100644
index 4355180e..00000000
--- a/apps/web/src/markdown/docs/nl/yaml.mdx
+++ /dev/null
@@ -1,39 +0,0 @@
-# YAML
-
-Languine ondersteunt YAML-bestanden als een bronformaat, dat veel wordt gebruikt in Ruby on Rails, Laravel en andere frameworks. Dit formaat ondersteunt geneste structuren, arrays en complexe gegevenstypen.
-
----
-
-## Instellen
-
-Zorg er eerst voor dat je een languine.json-configuratiebestand in de hoofdmap van je project hebt. Hier is een voorbeeld:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "yaml": {
-      "include": ["config/locales/[locale].yml"]
-    }
-  }
-}
-```
-
-## Vertalen
-
-Met je configuratie ingesteld, voer je uit:
-
-```bash
-npx languine@latest translate
-```
-
-Wanneer je dit commando uitvoert, zal Languine:
-
-- Je bron-YAML-bestand laden (bijv. config/locales/en.yml)
-- Nieuwe of gewijzigde vertaalstrings detecteren
-- Vertalingen genereren voor je doeltalen
-- De YAML-bestanden voor de doeltaal aanmaken of bijwerken (bijv. config/locales/sv.yml)
-- Geneste structuren en opmaak behouden
diff --git a/apps/web/src/markdown/docs/no/android.mdx b/apps/web/src/markdown/docs/no/android.mdx
deleted file mode 100644
index c4f61579..00000000
--- a/apps/web/src/markdown/docs/no/android.mdx
+++ /dev/null
@@ -1,39 +0,0 @@
-# Android
-
-Languine støtter Android-strengressurser (strings.xml) som kildeformat, og håndterer flertall, strengarrayer og formaterte strenger. Dette formatet er den standard måten å håndtere oversettelser i Android-applikasjoner på.
-
----
-
-## Oppsett
-
-Først, sørg for at du har en languine.json konfigurasjonsfil i rotmappen til prosjektet ditt. Her er et eksempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "android": {
-      "include": ["app/src/main/res/values-[locale]/strings.xml"]
-    }
-  }
-}
-```
-
-## Oversettelse
-
-Når konfigurasjonen din er satt opp, kjør:
-
-```bash
-npx languine@latest translate
-```
-
-Når du kjører denne kommandoen, vil Languine:
-
-- Laste inn din kilde strings.xml-fil (f.eks. values/strings.xml)
-- Oppdage eventuelle nye eller endrede oversettelsesstrenger
-- Generere oversettelser for målspråkene dine
-- Opprette eller oppdatere XML-filene for målspråkene (f.eks. values-sv/strings.xml, values-de/strings.xml, values-fr/strings.xml)
-- Beholde eksisterende formatering for strengarrayer og flertall
diff --git a/apps/web/src/markdown/docs/no/arb.mdx b/apps/web/src/markdown/docs/no/arb.mdx
deleted file mode 100644
index 43ecfca7..00000000
--- a/apps/web/src/markdown/docs/no/arb.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# ARB (Application Resource Bundle)
-
-Languine støtter ARB-filer, den standardiserte lokaliseringsformatet for Flutter-applikasjoner. Dette formatet håndterer flertall, plassholdere og valgfrie uttrykk samtidig som det opprettholder kompatibilitet med Flutters intl-pakke.
-
----
-
-## Oppsett
-
-Først, sørg for at du har en languine.json konfigurasjonsfil i rotmappen til prosjektet ditt. Her er et eksempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "arb": {
-      "include": ["lib/l10n/intl_[locale].arb"]
-    }
-  }
-}
-```
-
-## Oversettelse
-
-Når konfigurasjonen din er satt opp, kjør:
-
-```bash
-npx languine@latest translate
-```
-
-Når du kjører denne kommandoen, vil Languine:
-
-- Laste inn din kilde ARB-fil (f.eks. lib/l10n/intl_en.arb)
-- Oppdage eventuelle nye eller endrede oversettelsesstrenger
-- Generere oversettelser for dine målrettede språk
-- Opprette eller oppdatere ARB-filene for målrettet språk (f.eks. lib/l10n/intl_sv.arb)
-- Bevare metadata, plassholdere og flertalls-/valgsuttrykk
-
diff --git a/apps/web/src/markdown/docs/no/authentication.mdx b/apps/web/src/markdown/docs/no/authentication.mdx
deleted file mode 100644
index 74ce24ba..00000000
--- a/apps/web/src/markdown/docs/no/authentication.mdx
+++ /dev/null
@@ -1,48 +0,0 @@
-# Autentisering
-
-For å bruke Languine, må du autentisere deg med vår motor, det tar bare noen sekunder å komme i gang.
-
----
-
-## Logg inn
-
-Du kan logge inn direkte på [Languine Dashboard](https://languine.ai/login) eller kjøre følgende kommando:
-
-```bash title="Terminal"
-npx languine@latest auth login
-```
-
-
-Hvis du allerede har en konto, vil du bli automatisk logget inn og en økt vil bli lagret på maskinen din.
-
----
-
-## Logg ut
-
-Du kan logge ut ved å kjøre følgende kommando:
-
-```bash title="Terminal"
-npx languine@latest auth logout
-```
-
----
-
-## Brukerøkt
-
-Du kan sjekke om du er logget inn ved å kjøre følgende kommando:
-
-```bash title="Terminal"
-npx languine@latest auth whoami
-```
-
----
-
-
-# Miljøvariabler
-
-Du kan sette følgende miljøvariabler for å konfigurere Languine:
-
-- `LANGUINE_API_KEY`: API-nøkkelen som skal brukes for autentisering.
-- `LANGUINE_PROJECT_ID`: Prosjekt-ID-en som skal brukes for prosjektet.
-
-Du finner dem i [Languine Dashboard](https://languine.ai/login).
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/no/biome.mdx b/apps/web/src/markdown/docs/no/biome.mdx
deleted file mode 100644
index c2655b58..00000000
--- a/apps/web/src/markdown/docs/no/biome.mdx
+++ /dev/null
@@ -1,24 +0,0 @@
-# Biome
-
-Languine kan samarbeide med [Biome](https://biomejs.dev/) for å sikre at oversettelsesfilene dine er konsekvent formatert. Dette er spesielt nyttig når du arbeider med JSON-oversettelsesfiler som må opprettholde en konsekvent stil gjennom prosjektet ditt.
-
-## Bruke med Languine
-
-Den anbefalte måten å bruke Biome med Languine på er å formatere oversettelsesfilene etter at de er generert. Du kan sette dette opp i din `package.json`:
-
-```json title="package.json"
-{
-  "scripts": {
-    "translate": "languine translate",
-    "format": "biome format \"locales/**/*.json\"",
-    "translate:format": "npm run translate && npm run format"
-  }
-}
-```
-
-Nå kan du:
-- Kjør `npm run translate` for kun å generere oversettelser
-- Kjør `npm run format` for kun å formatere eksisterende oversettelsesfiler
-- Kjør `npm run translate:format` for å generere oversettelser og formatere dem i rekkefølge
-
-Denne konfigurasjonen vil sikre at oversettelsesfilene dine er formatert konsekvent med 2-roms innrykk og en maksimal linjelengde på 80 tegn.
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/no/ci.mdx b/apps/web/src/markdown/docs/no/ci.mdx
deleted file mode 100644
index 96c2e74a..00000000
--- a/apps/web/src/markdown/docs/no/ci.mdx
+++ /dev/null
@@ -1,96 +0,0 @@
-# CI/CD
-
-Languine tilbyr en CI/CD-integrasjon for å hjelpe deg med å oversette applikasjonen din.
-
----
-
-## Slik fungerer det
-
-CI/CD-arbeidsflyten i Languine følger en strukturert prosess for å automatisere oversettelsesoppdateringer i applikasjonen din:
-
-### 1. Handlingsinitialisering
-- Arbeidsflyten begynner når handlingen utløses
-- Setter opp nødvendig Git-konfigurasjon og legitimasjon
-
-### 2. Languine-motorbehandling
-- Languine-motoren behandler innholdet i applikasjonen din
-- Håndterer oversettelsesoppgavene ved hjelp av de konfigurerte innstillingene
-
-### 3. Endringsdeteksjon
-Systemet sjekker for eventuelle oversettelsesendringer og følger en av to veier:
-
-**Når endringer finnes:**
-- Endringer blir forpliktet til depotet
-- Endringer blir dyttet til den spesifiserte grenen
-- En Pull Request (PR) opprettes
-
-**Når ingen endringer finnes:**
-- Arbeidsflyten fullføres uten å opprette en PR
-
-### 4. Oppretting av Pull Request
-Når endringer oppdages, opprettes en Pull Request med:
-
-**PR-innhold:**
-- Klar tittel som indikerer oversettelsesoppdateringer
-- Detaljert beskrivelse av endringer
-- Bekreftelser på kvalitetskontroll
-- Instruksjoner for gjennomgang
-- Lenker til dokumentasjon og støtte
-
-**PR-beskrivelsen inkluderer:**
-- Sammendrag av oversettelsesoppdateringer
-- Liste over hva som ble endret (oppdaterte oversettelser, terminologikonsistens)
-- Neste steg for anmeldere
-- Lenker til dokumentasjons- og støtteressurser
-
----
-
-## Arbeidsflytdiagram
-
-<div className="flex flex-col items-center justify-center p-4 h-[400px] sm:h-[500px] md:h-[650px]">
-  <pre
-    className="p-4 text-sm leading-5 mb-4 scale-[0.5] sm:scale-[0.65] md:scale-90 transform-gpu"
-    style={{
-      fontFamily: "monospace",
-      whiteSpace: "pre",
-      textAlign: "left",
-    }}
-  >
-    {`
-                    ┌─────────────────────┐
-                    │   Handlingen starter  │
-                    └──────────┬──────────┘
-                               │
-                    ┌──────────▼──────────┐
-                    │    Sett opp Git &    │
-                    │    Legitimasjon      │
-                    └──────────┬──────────┘
-                               │
-┌─────────────────────────────────────────────────────────┐
-│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-│░░░░░░░░░░░░░░░░░░░░ Languine-motoren ░░░░░░░░░░░░░░░░░░░░│
-│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-└─────────────────────────────────────────────────────────┘
-                               │
-                    ┌──────────▼──────────┐
-                    │   Sjekk endringer    │───────┐
-                    └──────────┬──────────┘       │
-                               │                  │
-                               │ [Endringer]      │ [Ingen endringer]
-                               │                  │
-                    ┌──────────▼──────────┐       │
-                    │   Forplikt & dytt    │       │
-                    └──────────┬──────────┘       │
-                               │                  │
-                    ┌──────────▼──────────┐       │
-                    │    Opprett PR        │       │
-                    └──────────┬──────────┘       │
-                               │                  │
-                    ┌──────────▼──────────┐       │
-                    │        Ferdig        │◄──────┘
-                    └─────────────────────┘
-`}
-  </pre>
-</div>
-
-Arbeidsflyten er designet for å være automatisert samtidig som den fortsatt tillater menneskelig gjennomgang og kvalitetskontroll før endringer blir slått sammen i kodebasen din. Den opprettholder beste praksis for versjonskontroll og sikrer at oversettelser blir riktig sporet og dokumentert gjennom Git-historikken.
diff --git a/apps/web/src/markdown/docs/no/cli.mdx b/apps/web/src/markdown/docs/no/cli.mdx
deleted file mode 100644
index 94614621..00000000
--- a/apps/web/src/markdown/docs/no/cli.mdx
+++ /dev/null
@@ -1,65 +0,0 @@
-# CLI
-
-Languine tilbyr en CLI for å hjelpe deg med å oversette applikasjonen din.
-
----
-
-## Kommandoversikt
-
-### Oversett
-
-`oversett`-kommandoen brukes til å oversette applikasjonen din.
-
-```bash title="Terminal"
-    npx languine@latest oversett
-```
-
----
-
-### Init
-
-`init`-kommandoen brukes til å initialisere et nytt Languine-prosjekt.
-
-```bash title="Terminal"
-    npx languine@latest init
-```
-
----
-
-### Auth
-
-`auth`-kommandoen brukes til å autentisere med Languine.
-
-```bash title="Terminal"
-    npx languine@latest auth
-```
-
----
-
-### Sync
-
-`sync`-kommandoen brukes til å synkronisere applikasjonen din med Languine.
-
-```bash title="Terminal"
-    npx languine@latest sync
-```
-
----
-
-### Locale Legg til
-
-`locale`-kommandoen brukes til å administrere applikasjonens lokaliteter.
-
-```bash title="Terminal"
-    npx languine@latest locale legg til pt,fr
-```
-
----
-
-### Locale Fjern
-
-`locale fjern`-kommandoen brukes til å fjerne en lokalitet fra applikasjonen din.
-
-```bash title="Terminal"
-    npx languine@latest locale fjern pt,fr
-```
diff --git a/apps/web/src/markdown/docs/no/configuration.mdx b/apps/web/src/markdown/docs/no/configuration.mdx
deleted file mode 100644
index e8a80166..00000000
--- a/apps/web/src/markdown/docs/no/configuration.mdx
+++ /dev/null
@@ -1,180 +0,0 @@
-# Konfigurasjon
-
-Languine bruker en JSON-konfigurasjonsfil (languine.json) for å administrere oversettelsesoppsettet ditt. Denne filen definerer kildespråket og målspråkene, samt filene som må oversettes.
-
----
-
-## Grunnleggende Konfigurasjon
-
-Her er et grunnleggende eksempel i begge formater:
-
-```json title="languine.json"
-{
-  "locale": {
-    "source": "en",
-    "targets": ["es", "fr", "de"]
-  },
-  "files": {
-    "json": {
-      "include": ["locales/[locale].json"]
-    }
-  }
-}
-```
-
-La oss bryte ned de forskjellige seksjonene i konfigurasjonsfilen.
-
----
-
-## Lokalisasjonskonfigurasjon
-
-Lokalisasjonsseksjonen definerer oversettelsesspråkene dine:
-
-- source: Ditt primære språk for innholdsproduksjon (f.eks. "en" for engelsk)
-- targets: Et array av språk du ønsker å oversette til (f.eks. ["es", "fr", "de"] for spansk, fransk og tysk)
-
-Languine støtter et bredt spekter av språk koder, inkludert:
-- Enkle koder: en, es, fr, de
-- Regionspesifikke koder: pt-BR, zh-CN, zh-TW
-
-## Filkonfigurasjon
-
-Files-seksjonen definerer hvilke filer Languine skal oversette. Du kan konfigurere flere filtyper og mønstre:
-
----
-
-### JSON-filer
-```json
-files: {
-  json: {
-    include: ["locales/[locale].json"],
-  },
-}
-```
-
----
-
-### Markdown/MDX-filer
-```json
-files: {
-  md: {
-    include: ["docs/[locale]/*.md"],
-  },
-  mdx: {
-    include: ["blog/[locale]/*.mdx"],
-  },
-}
-```
-
----
-
-### Mobilplattformfiler
-
-For iOS (Xcode):
-```json
-files: {
-  "xcode-xcstrings": {
-    include: ["Example/Localizable.xcstrings"],
-  },
-  // Eller for tradisjonelle .strings-filer
-  "xcode-strings": {
-    include: ["Example/[locale].lproj/Localizable.strings"],
-  },
-}
-```
-
----
-
-For Android:
-```json
-files: {
-  android: {
-    include: ["locales/[locale].xml"],
-  },
-}
-```
-
----
-
-### Andre formater
-
-Her er en komplett liste over filformater som støttes av Languine:
-
-- [JSON](/docs/json) - Standard JSON oversettelsesfiler
-- [YAML](/docs/yaml) - YAML oversettelsesfiler
-- [Properties](/docs/properties) - Java properties-filer
-- [Android](/docs/android) - Android XML ressursfiler
-- [iOS](/docs/ios) - iOS lokaliseringsfiler
-- [iOS Stringsdict](/docs/xcode-stringsdict) - iOS pluraliseringsfiler
-- [iOS XCStrings](/docs/xcode-xcstrings) - Moderne Xcode tekstkataloger
-- [Markdown](/docs/md) - Dokumentasjonsfiler
-- [MDX](/docs/mdx) - Dokumentasjon med JSX
-- [HTML](/docs/html) - HTML-filer
-- [JavaScript](/docs/js) - JavaScript-filer
-- [TypeScript](/docs/ts) - TypeScript-filer
-- [Gettext PO](/docs/po) - GetText oversettelsesfiler
-- [XLIFF](/docs/xliff) - XML Lokaliseringsutvekslingsfilformat
-- [CSV](/docs/csv) - Regnearkbaserte oversettelser
-- [XML](/docs/xml) - XML ressursfiler
-- [Flutter ARB](/docs/arb) - Applikasjonsressursbuntfiler
-
----
-
-## Filmønstre
-
-[locale]-plassholderen i filmønstre blir automatisk erstattet med den aktuelle språk koden under oversettelse. For eksempel:
-
-- locales/[locale].json blir:
-  - locales/en.json
-  - locales/es.json
-  - locales/fr.json
-
-Du kan inkludere flere mønstre for hver filtype og bruke glob-mønstre:
-```json
-files: {
-  json: {
-    include: [
-      "src/locales/[locale].json",
-      "src/components/[locale]/*.json"
-    ],
-  },
-}
-```
-
----
-
-## Prosjekt-ID (Valgfritt)
-
-Hvis du bruker Languines skytjenester, kan du inkludere prosjekt-ID-en din i konfigurasjonen:
-
-```json
-{
-  "projectId": "prj_your_project_id",
-  "locale": {
-    // ... lokalisasjonskonfig
-  },
-  files: {
-    // ... filkonfig
-  },
-}
-```
-
----
-
-## Oversettelsesstatussporing
-
-Languine oppretter og vedlikeholder automatisk en languine.lock-fil for å spore statusen til oversettelsene dine. Denne filen:
-
-- Sporer hvilket innhold som har blitt oversatt
-- Hjelper med å identifisere hva som må oppdateres når kildeinnholdet endres
-- Bør forpliktes til versjonskontrollsystemet ditt
-
-Du trenger ikke å redigere låsefilen manuelt - Languine administrerer den automatisk når du kjører oversettelseskommandoer.
-
-## Beste praksis
-
-1. **Versjonskontroll**: Forplikt alltid både languine.json og languine.lock til depotet ditt
-2. **Filorganisering**: Hold oversettelsesfilene dine organisert i en konsekvent katalogstruktur
-3. **Språkkoder**: Bruk standard språkkoder for å sikre kompatibilitet
-4. **Mønstre**: Bruk spesifikke inkluderingsmønstre for å unngå å oversette unødvendige filer
-5. **Prosjekt-ID**: Hold prosjekt-ID-en din sikker og ikke del den offentlig hvis du bruker skytjenester, bruk miljøvariabelen `LANGUINE_PROJECT_ID` i stedet.
diff --git a/apps/web/src/markdown/docs/no/csv.mdx b/apps/web/src/markdown/docs/no/csv.mdx
deleted file mode 100644
index e7e580b6..00000000
--- a/apps/web/src/markdown/docs/no/csv.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# CSV
-
-Languine støtter CSV (Comma-Separated Values) filer for enkel oversettelsesadministrasjon. Dette formatet er ideelt for regnearkbaserte arbeidsflyter og enkel integrasjon med eksterne oversettelsesverktøy.
-
----
-
-## Oppsett
-
-Først, sørg for at du har en languine.json konfigurasjonsfil i rotmappen til prosjektet ditt. Her er et eksempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "csv": {
-      "include": ["translations/[locale].csv"]
-    }
-  }
-}
-```
-
-## Oversettelse
-
-Når konfigurasjonen din er satt opp, kjør:
-
-```bash
-npx languine@latest translate
-```
-
-Når du kjører denne kommandoen, vil Languine:
-
-- Laste inn din kilde CSV-fil (f.eks., translations/en.csv)
-- Oppdage eventuelle nye eller endrede oversettelsesstrenger
-- Generere oversettelser for dine målspråk
-- Opprette eller oppdatere målspråk CSV-filer (f.eks., translations/sv.csv)
-- Opprettholde kolonneoppsett og formatering
-- Bevare eventuelle ekstra metadata-kolonner
diff --git a/apps/web/src/markdown/docs/no/expo.mdx b/apps/web/src/markdown/docs/no/expo.mdx
deleted file mode 100644
index 075197af..00000000
--- a/apps/web/src/markdown/docs/no/expo.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# Expo
-
-Languine støtter Expo-lokalisering og integreres sømløst med Expos i18n-system. Dette formatet fungerer med både JavaScript- og TypeScript-prosjekter, og støtter nestede strukturer og pluralisering.
-
----
-
-## Oppsett
-
-Først, sørg for at du har en languine.json konfigurasjonsfil i rotmappen til prosjektet ditt. Her er et eksempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "expo": {
-      "include": ["assets/locales/[locale].json"]
-    }
-  }
-}
-```
-
-## Oversettelse
-
-Når konfigurasjonen din er satt opp, kjør:
-
-```bash
-npx languine@latest translate
-```
-
-Når du kjører denne kommandoen, vil Languine:
-
-- Laste inn kildeoversettelsesfilen din (f.eks. assets/locales/en.json)
-- Oppdage eventuelle nye eller endrede oversettelsesstrenger
-- Generere oversettelser for målspråkene dine
-- Opprette eller oppdatere målspråkfilene (f.eks. assets/locales/sv.json)
-- Bevare nestet struktur og pluraliseringsregler
-- Opprettholde kompatibilitet med expo-localization
diff --git a/apps/web/src/markdown/docs/no/github-actions.mdx b/apps/web/src/markdown/docs/no/github-actions.mdx
deleted file mode 100644
index 30e8bd59..00000000
--- a/apps/web/src/markdown/docs/no/github-actions.mdx
+++ /dev/null
@@ -1,147 +0,0 @@
-# GitHub Actions
-
-Med GitHub-handlingen kan du enkelt oversette koden din ved bare å pushe koden til depotet. GitHub-handlingen vil deretter oversette de nye nøklene dine, enten opprette en pull request eller commite endringene dine.
-Dette sparer deg for mye tid og arbeid samtidig som det opprettholder høy kvalitet på oversettelsene.
-
----
-
-## Hvordan det fungerer
-
-
-
-<div className="flex flex-col items-center justify-center p-4 mb-8 h-[400px] sm:h-[500px] md:h-[650px]">
-        <pre
-          className="p-4 text-sm leading-5 scale-[0.5] sm:scale-[0.65] md:scale-90 transform-gpu"
-          style={{
-            fontFamily: "monospace",
-            whiteSpace: "pre",
-            textAlign: "left",
-          }}
-        >
-          {`
-                                  ┌───────────────┐
-                                  │   Git Push    │
-                                  └───────────────┘
-                                          │
-                                          ▼
-             ┌─────────────────────────────────────────────────────────┐
-             │░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-             │░░░░░░░░░░░░░░░░░░░░ Languine Engine ░░░░░░░░░░░░░░░░░░░░│
-             │░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-             └─────────────────────────────────────────────────────────┘
-                                          │
-                                          ▼
-                                          │
-            ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┼ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─
-           │                              │                              │
-           ▼                              ▼                              ▼
- ╔═══════════════════╗          ╔═══════════════════╗          ╔═══════════════════╗
- ║                   ║          ║                   ║          ║                   ║
- ║      Engelsk      ║          ║      Spansk       ║          ║      Japansk      ║
- ║    Oversettelse   ║          ║    Oversettelse   ║          ║     Oversettelse   ║
- ║                   ║          ║                   ║          ║                   ║
- ╚═══════════════════╝          ╚═══════════════════╝          ╚═══════════════════╝
-           │                              │                              │
-           └──────────────────────────────┼──────────────────────────────┘
-                                          ▼
-                                  ┌───────────────┐
-                                  │     Slå sammen  │
-                                  │ Pull Request  │
-                                  └───────────────┘
-                                          │
-                                          ▼
-                              ┌─────────────────────┐
-                              │      Fullført       │
-                              │      (Distribuer)   │
-                              └─────────────────────┘
-`}
-        </pre>
-      </div>
-
----
-
-## Installasjon
-
-For å bruke Languine GitHub Action i depotet ditt, må du:
-
-1. Sette opp hemmeligheter for depotet med Languine-legitimasjonen din
-2. Opprette en arbeidsflytfil i depotet ditt
-
-### Sette opp depothemmeligheter
-
-Legg til følgende hemmeligheter i innstillingene for depotet ditt (Innstillinger > Hemmeligheter og variabler > Handlinger):
-
-- `LANGUINE_API_KEY`: Din Languine API-nøkkel
-- `LANGUINE_PROJECT_ID`: Din Languine prosjekt-ID
-
-Du kan finne disse verdiene i Languine-dashbordet under Prosjektinnstillinger.
-
-
-
-### Miljøvariabler
-
-GitHub-handlingen bruker følgende miljøvariabler:
-- `LANGUINE_API_KEY` (Obligatorisk): Din Languine API-nøkkel for autentisering
-- `LANGUINE_PROJECT_ID` (Obligatorisk): Din Languine prosjekt-ID 
-- `GITHUB_TOKEN` (Obligatorisk): Automatisk levert av GitHub, brukt til å opprette PR-er
-
-### Eksempel på arbeidsflyt
-
-Opprett en ny fil .github/workflows/languine.yml i depotet ditt med følgende innhold:
-
-```ts title=".github/workflows/release.yml"
-name: Distribuer nettsted
-
-on:
-  push:
-    branches:
-      - '**'
-    paths:
-      - apps/web/**
-
-jobs:
-  translate:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-      pull-requests: write
-    steps:
-      - uses: actions/checkout@v4
-      
-      - name: Languine Action
-        uses: languine/languine-action@v1
-        env:
-           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          api-key: ${{ secrets.LANGUINE_API_KEY }}
-          project-id: ${{ secrets.LANGUINE_PROJECT_ID }}
-```
- 
- Denne arbeidsflyten vil:
-- Kjøres ved pushes til hovedgrenen
-- Kjøres ved pull requests til hovedgrenen
-- Kan utløses manuelt fra Handlinger-fanen
-- Sjekke ut koden din og kjøre Languine oversettelsesprosessen
-- Opprette en pull request med eventuelle nye oversettelser (konfigurerbar)
-
-#### Arbeidskatalogalternativ
-
-`working-directory`-alternativet lar deg spesifisere hvor oversettelsesfilene dine ligger. Dette er spesielt nyttig i monorepos der oversettelsene dine kan være i en spesifikk pakke eller app-katalog. For eksempel:
-
-#### Pull Request-alternativ (kommer snart)
-
-`create-pull-request`-alternativet styrer om handlingen oppretter en pull request med endringene eller commiter dem direkte til grenen:
-
-```typescript title=".github/workflows/languine.yml"
-with:
-  create-pull-request: true # opprett en pull request med endringene
-```
-
-Når det er satt til `true`, vil handlingen:
-- Opprette en ny gren med endringene
-- Opprette en pull request for gjennomgang
-- Legge til passende etiketter og beskrivelse
-
-Når det er satt til `false` (standard), vil handlingen:
-- Commite endringene direkte til den nåværende grenen
-- Pushe endringene uten å opprette en pull request
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/no/html.mdx b/apps/web/src/markdown/docs/no/html.mdx
deleted file mode 100644
index 2728f7cb..00000000
--- a/apps/web/src/markdown/docs/no/html.mdx
+++ /dev/null
@@ -1,41 +0,0 @@
-# HTML
-
-Languine støtter lokalisering av HTML-filer, og håndterer både tekstinnhold og attributter. Dette formatet er ideelt for statiske nettsteder og HTML-maler, med støtte for å bevare HTML-struktur og formatering.
-
----
-
-## Oppsett
-
-Først, sørg for at du har en languine.json konfigurasjonsfil i rotmappen til prosjektet ditt. Her er et eksempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "html": {
-      "include": ["pages/[locale]/*.html"]
-    }
-  }
-}
-```
-
-## Oversettelse
-
-Når konfigurasjonen din er satt opp, kjør:
-
-```bash
-npx languine@latest translate
-```
-
-Når du kjører denne kommandoen, vil Languine:
-
-- Laste inn dine kilde HTML-filer (f.eks. pages/en/*.html)
-- Oppdage eventuelle nye eller endrede oversettelsesstrenger
-- Generere oversettelser for målspråkene dine
-- Opprette eller oppdatere HTML-filer for målspråket (f.eks. pages/sv/*.html)
-- Bevare HTML-struktur og formatering
-- Håndtere spesifiserte attributtoversettelser
-- Opprettholde kommentarer og spesielle tagger
diff --git a/apps/web/src/markdown/docs/no/introduction.mdx b/apps/web/src/markdown/docs/no/introduction.mdx
deleted file mode 100644
index 1e44dcc5..00000000
--- a/apps/web/src/markdown/docs/no/introduction.mdx
+++ /dev/null
@@ -1,34 +0,0 @@
-# Introduksjon
-
-Languine automatiserer lokalisering innenfor din utviklingsarbeidsflyt og pipeline, og sikrer at oversettelser aldri holder deg tilbake.
-
-Forvandle applikasjonen din til en flerspråklig opplevelse på minutter. Mens du fokuserer på å bygge funksjoner, håndterer Languine alle aspekter av oversettelse med presisjon og pålitelighet.
-
----
-
-## Nøkkelfunksjoner
-
-- **Oversettelsesmotor**: Utnytt kontekstbevisste, høy-kvalitets oversettelser som opprettholder din merkevarestemme
-- **CI/CD Integrasjon**: Automatiser oversettelsesoppdateringer gjennom dine eksisterende arbeidsflyter
-- **Formater**: Håndter ethvert filformat med vårt utvidbare parser-system
-- **Åpen Kildekode**: Få tilgang til, inspiser og bidra til vår kodebase på GitHub - ingen svarte bokser, full åpenhet
-
----
-
-## Hvordan Det Fungerer
-
-1. **Rask Oppsett**: Kom i gang på minutter med vår intuitive CLI og veiledet initiering
-2. **Enkel Konfigurasjon**: Definer dine oversettelsesbehov med en klar, enkel konfigurasjonsfil
-3. **Automatisert Oversettelse**: Push innholdet ditt én gang og la Languine automatisk håndtere oversettelse til alle målrettede språk
-
----
-
-## Kom I Gang
-
-Begynn din lokaliseringreise med vår [Rask Start](/docs/quickstart) guide - du vil ha dine første oversettelser i gang på minutter.
-
-Utforsk vår omfattende dokumentasjon for å mestre Languines kapabiliteter:
-
-- [Konfigurasjon](/docs/configuration) - Konfigurer Languine til prosjektets behov
-- [CLI](/docs/cli) - Mestre vårt kraftige kommandolinjegrensesnitt
-- [Github Actions](/docs/github-actions) - Automatiser oversettelser med vår Github Action
diff --git a/apps/web/src/markdown/docs/no/ios.mdx b/apps/web/src/markdown/docs/no/ios.mdx
deleted file mode 100644
index f925434d..00000000
--- a/apps/web/src/markdown/docs/no/ios.mdx
+++ /dev/null
@@ -1,39 +0,0 @@
-# iOS
-
-Languine støtter iOS Localizable.strings-filer, den standardiserte lokaliseringsformatet for iOS-applikasjoner. Dette formatet håndterer grunnleggende nøkkel-verdi tekstpar og støtter kommentarer for å gi kontekst til oversettere.
-
----
-
-## Oppsett
-
-Først, sørg for at du har en languine.json konfigurasjonsfil i rotmappen til prosjektet ditt. Her er et eksempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "ios": {
-      "include": ["[locale].lproj/Localizable.strings"]
-    }
-  }
-}
-```
-
-## Oversetting
-
-Når konfigurasjonen din er satt opp, kjør:
-
-```bash
-npx languine@latest translate
-```
-
-Når du kjører denne kommandoen, vil Languine:
-
-- Laste inn din kilde Localizable.strings-fil (f.eks. en.lproj/Localizable.strings)
-- Oppdage eventuelle nye eller endrede oversettelsesstrenger
-- Generere oversettelser for målspråkene dine
-- Opprette eller oppdatere målspråkfilene (f.eks. sv.lproj/Localizable.strings)
-- Bevare eventuelle eksisterende kommentarer og formatering
diff --git a/apps/web/src/markdown/docs/no/js.mdx b/apps/web/src/markdown/docs/no/js.mdx
deleted file mode 100644
index 2e1521fe..00000000
--- a/apps/web/src/markdown/docs/no/js.mdx
+++ /dev/null
@@ -1,42 +0,0 @@
-# JavaScript
-
-Languine støtter JavaScript/TypeScript lokaliseringsfiler, perfekt for moderne webapplikasjoner. Dette formatet håndterer både objektliteraler og modulutganger, og støtter nestede strukturer og dynamisk innhold.
-
----
-
-## Oppsett
-
-Først, sørg for at du har en languine.json konfigurasjonsfil i rotmappen til prosjektet ditt. Her er et eksempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "js": {
-      "include": ["src/locales/[locale].js"]
-    }
-  }
-}
-```
-
-## Oversetting
-
-Når konfigurasjonen din er satt opp, kjør:
-
-```bash
-npx languine@latest translate
-```
-
-Når du kjører denne kommandoen, vil Languine:
-
-- Laste inn kilde-JavaScript-filene dine (f.eks. src/locales/en.js)
-- Oppdage eventuelle nye eller endrede oversettelsesstrenger
-- Generere oversettelser for målspråkene dine
-- Opprette eller oppdatere målspråkfilene (f.eks. src/locales/sv.js)
-- Bevare modulstrukturen og eksportene
-- Håndtere nestede objekter og matriser
-- Opprettholde kodeformatering og kommentarer
-- Generere TypeScript-typer hvis aktivert
diff --git a/apps/web/src/markdown/docs/no/json.mdx b/apps/web/src/markdown/docs/no/json.mdx
deleted file mode 100644
index 3170041f..00000000
--- a/apps/web/src/markdown/docs/no/json.mdx
+++ /dev/null
@@ -1,41 +0,0 @@
-# JSON
-
-Languine støtter JSON-filer som kildeformat med de vanlige kravene for pluralisering og interpolering. Dette formatet brukes i mange rammeverk som React, Vue, Ruby on Rails, og mer.
-
-
----
-
-
-## Oppsett
-
-Først, sørg for at du har en languine.json konfigurasjonsfil i rotmappen til prosjektet ditt. Her er et eksempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "json": {
-      "include": ["locales/[locale].json"]
-    }
-  }
-}
-
-```
-
-## Oversettelse
-
-Når konfigurasjonen din er satt opp, kjør:
-
-```bash
-npx languine@latest translate
-```
-
-Når du kjører denne kommandoen, vil Languine:
-
-- Laste inn kilde JSON-filen din (f.eks. locales/en.json)
-- Oppdage eventuelle nye eller endrede oversettelsesstrenger
-- Generere oversettelser for målspråkene dine
-- Opprette eller oppdatere JSON-filene for målspråkene (f.eks. locales/sv.json, locales/de.json, locales/fr.json)
diff --git a/apps/web/src/markdown/docs/no/md.mdx b/apps/web/src/markdown/docs/no/md.mdx
deleted file mode 100644
index 51b67534..00000000
--- a/apps/web/src/markdown/docs/no/md.mdx
+++ /dev/null
@@ -1,43 +0,0 @@
-# Markdown
-
-Languine støtter lokalisering av Markdown-filer, perfekt for dokumentasjon, blogginnlegg og innholdsrike nettsteder. Dette formatet bevarer Markdown-syntaksen mens innholdet oversettes, inkludert støtte for front matter.
-
----
-
-## Oppsett
-
-Først, sørg for at du har en languine.json konfigurasjonsfil i rotmappen til prosjektet ditt. Her er et eksempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "md": {
-      "include": ["content/[locale]/**/*.md"]
-    }
-  }
-}
-```
-
-## Oversettelse
-
-Når konfigurasjonen din er satt opp, kjør:
-
-```bash
-npx languine@latest translate
-```
-
-Når du kjører denne kommandoen, vil Languine:
-
-- Laste inn dine kildemarkdown-filer (f.eks., content/en/*.md)
-- Oppdage nytt eller endret innhold
-- Generere oversettelser for målspråkene dine
-- Opprette eller oppdatere målspråkfilene (f.eks., content/sv/*.md)
-- Bevare Markdown-format og struktur
-- Håndtere oversettelser av front matter
-- Opprettholde lenker og referanser
-- Holde kodeblokker uoversatt
-- Bevare HTML innen Markdown
diff --git a/apps/web/src/markdown/docs/no/mdx.mdx b/apps/web/src/markdown/docs/no/mdx.mdx
deleted file mode 100644
index 30977f9e..00000000
--- a/apps/web/src/markdown/docs/no/mdx.mdx
+++ /dev/null
@@ -1,43 +0,0 @@
-# Markdown (MDX)
-
-Languine støtter lokalisering av Markdown (MDX) filer, perfekt for dokumentasjon, blogginnlegg og innholdsrike nettsteder. Dette formatet bevarer Markdown-syntaksen mens innholdet oversettes, inkludert støtte for front matter.
-
----
-
-## Oppsett
-
-Først, sørg for at du har en languine.json konfigurasjonsfil i rotmappen til prosjektet ditt. Her er et eksempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "mdx": {
-      "include": ["content/[locale]/**/*.mdx"]
-    }
-  }
-}
-```
-
-## Oversettelse
-
-Når konfigurasjonen din er satt opp, kjør:
-
-```bash
-npx languine@latest translate
-```
-
-Når du kjører denne kommandoen, vil Languine:
-
-- Laste inn kilde Markdown-filer (f.eks., content/en/*.mdx)
-- Oppdage nytt eller endret innhold
-- Generere oversettelser for målspråkene dine
-- Opprette eller oppdatere målspråkfilene (f.eks., content/sv/*.mdx)
-- Bevare Markdown-format og struktur
-- Håndtere oversettelser av front matter
-- Opprettholde lenker og referanser
-- Holde kodeblokker uoversatt
-- Bevare HTML innen Markdown
diff --git a/apps/web/src/markdown/docs/no/overrides.mdx b/apps/web/src/markdown/docs/no/overrides.mdx
deleted file mode 100644
index cd41b063..00000000
--- a/apps/web/src/markdown/docs/no/overrides.mdx
+++ /dev/null
@@ -1,7 +0,0 @@
-# Overstyringer
-
-Languine lar deg overstyre oversettelser for spesifikke nøkler. Dette er nyttig når du vil sikre at en spesifikk oversettelse brukes for en bestemt nøkkel, uavhengig av standardoversettelsen.
-
-## Slik fungerer det
-
-I dashbordet kan du opprette overstyringer for spesifikke nøkler. Du kan også opprette overstyringer for spesifikke språk.
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/no/po.mdx b/apps/web/src/markdown/docs/no/po.mdx
deleted file mode 100644
index e4d791c0..00000000
--- a/apps/web/src/markdown/docs/no/po.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# PO (Gettext)
-
-Languine støtter PO-filer, det mye brukte Gettext lokaliseringsformatet. Dette formatet er populært i mange programmeringsmiljøer, spesielt i Linux-applikasjoner og PHP-rammeverk, og tilbyr støtte for kontekst, flertall og oversetterkommentarer.
-
----
-
-## Oppsett
-
-Først, sørg for at du har en languine.json konfigurasjonsfil i rotmappen til prosjektet ditt. Her er et eksempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "po": {
-      "include": ["locales/[locale]/LC_MESSAGES/messages.po"]
-    }
-  }
-}
-```
-
-## Oversettelse
-
-Når konfigurasjonen din er satt opp, kjør:
-
-```bash
-npx languine@latest translate
-```
-
-Når du kjører denne kommandoen, vil Languine:
-
-- Laste inn din kilde PO-fil (f.eks. locales/en/LC_MESSAGES/messages.po)
-- Oppdage eventuelle nye eller endrede oversettelsesstrenger
-- Generere oversettelser for målspråkene dine
-- Opprette eller oppdatere målspråkets PO-filer (f.eks. locales/sv/LC_MESSAGES/messages.po)
-- Bevare metadata, kontekster og flertallsformer
-- Opprettholde oversetterkommentarer og referanseinformasjon
diff --git a/apps/web/src/markdown/docs/no/prettier.mdx b/apps/web/src/markdown/docs/no/prettier.mdx
deleted file mode 100644
index 859cd400..00000000
--- a/apps/web/src/markdown/docs/no/prettier.mdx
+++ /dev/null
@@ -1,22 +0,0 @@
-# Prettier
-
-Languine kan samarbeide med [Prettier](https://prettier.io/) for å sikre at oversettelsesfilene dine er konsekvent formatert. Dette er spesielt nyttig når du arbeider med JSON-oversettelsesfiler som må opprettholde en konsekvent stil gjennom prosjektet ditt.
-
-## Bruke med Languine
-
-Den anbefalte måten å bruke Prettier med Languine på er å formatere oversettelsesfilene dine etter at de er generert. Du kan sette dette opp i `package.json`:
-
-```json title="package.json"
-{
-  "scripts": {
-    "translate": "languine translate",
-    "format": "prettier --write \"locales/**/*.json\"",
-    "translate:format": "npm run translate && npm run format"
-  }
-}
-```
-
-Nå kan du:
-- Kjør `npm run translate` for kun å generere oversettelser
-- Kjør `npm run format` for kun å formatere eksisterende oversettelsesfiler
-- Kjør `npm run translate:format` for å generere oversettelser og formatere dem i rekkefølge
diff --git a/apps/web/src/markdown/docs/no/properties.mdx b/apps/web/src/markdown/docs/no/properties.mdx
deleted file mode 100644
index 2748658d..00000000
--- a/apps/web/src/markdown/docs/no/properties.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# Egenskaper
-
-Languine støtter Java Properties-filer, den standardiserte lokaliseringsformatet for Java-applikasjoner. Dette formatet håndterer Unicode-escaping og støtter både nøkkel-verdi-par og kommentarer.
-
----
-
-## Oppsett
-
-Først, sørg for at du har en languine.json konfigurasjonsfil i rotmappen til prosjektet ditt. Her er et eksempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "properties": {
-      "include": ["src/main/resources/messages_[locale].properties"]
-    }
-  }
-}
-```
-
-## Oversetting
-
-Når konfigurasjonen din er satt opp, kjør:
-
-```bash
-npx languine@latest translate
-```
-
-Når du kjører denne kommandoen, vil Languine:
-
-- Laste inn kilde properties-filen din (f.eks. messages_en.properties)
-- Oppdage eventuelle nye eller endrede oversettelsesstrenger
-- Generere oversettelser for målspråkene dine
-- Opprette eller oppdatere målspråkets properties-filer (f.eks. messages_sv.properties)
-- Håndtere Unicode-escaping automatisk
-- Bevare kommentarer og formatering
diff --git a/apps/web/src/markdown/docs/no/quickstart.mdx b/apps/web/src/markdown/docs/no/quickstart.mdx
deleted file mode 100644
index 72bd953a..00000000
--- a/apps/web/src/markdown/docs/no/quickstart.mdx
+++ /dev/null
@@ -1,65 +0,0 @@
-# Hurtigstart
-
-Begynn med å installere Languine.
-
-Kjør deretter følgende kommando for å initialisere Languine.
-
-```bash title="Terminal"
-npx languine@latest init
-```
-
-Følg trinnene for å sette opp prosjektet ditt.
-
----
-
-## Første oversettelse
-
-Nå er du klar til å oversette koden din.
-
-Begynn med å legge til en nøkkel i kildefilen din, for eksempel hvis du velger å bruke `en.json` som kildefil, legg til en nøkkel i den.
-
-```json title="src/locales/en.json"
-{
-  "welcome": "Velkommen til applikasjonen vår!",
-  "user": {
-    "greeting": "Hei, {{name}}!",
-    "profile": {
-      "title": "Din profil",
-      "edit": "Rediger profil"
-    }
-  },
-  "notifications": {
-    "messages": "Du har {{count}} nye melding(er).",
-    "empty": "Ingen nye varsler."
-  }
-}
-
-```
-
----
-
-## Oversett
-
-Kjør følgende kommando for å oversette innholdet ditt:
-
-```bash title="Terminal"
-npx languine@latest translate
-```
-
-## Dette vil:
-1. Opprette oversettelsesfiler for hvert målspråk
-2. Generere høykvalitets oversettelser med Languine Engine
-3. Opprette en `languine.lock`-fil for å spore oversettelsesstatus
-
-Låsefilen hjelper Languine med å identifisere hvilke oversettelser som trenger oppdateringer når kildeinnholdet ditt endres. Sørg for å forplikte denne filen til depotet ditt.
-
----
-
-## Neste trinn
-
-Nå som du har satt opp Languine, kan du:
-- Legge til flere språk i `languine.json`-filen din
-- Integrere Languine i CI/CD-pipelinen din
-- Bruke API-en vår for programmerbare oversettelser
-
-Sjekk ut våre andre guider for å lære mer om Languines avanserte funksjoner.
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/no/react-email.mdx b/apps/web/src/markdown/docs/no/react-email.mdx
deleted file mode 100644
index 39980a12..00000000
--- a/apps/web/src/markdown/docs/no/react-email.mdx
+++ /dev/null
@@ -1,41 +0,0 @@
-# React Email
-
-Languine støtter React Email-maler, som lar deg administrere oversettelser for e-postmalene dine bygget med React Email. Denne integrasjonen håndterer både tekstinnhold og HTML-attributter samtidig som den bevarer React-komponentstrukturen.
-
----
-
-## Oppsett
-
-Først, sørg for at du har en languine.json konfigurasjonsfil i rotmappen til prosjektet ditt. Her er et eksempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "react-email": {
-      "include": ["emails/[locale]/*.tsx"]
-    }
-  }
-}
-```
-
-## Oversettelse
-
-Når konfigurasjonen din er satt opp, kjør:
-
-```bash
-npx languine@latest translate
-```
-
-Når du kjører denne kommandoen, vil Languine:
-
-- Laste inn dine kilde React Email-maler (f.eks. emails/en/*.tsx)
-- Oppdage eventuelle nye eller endrede oversettelsesstrenger
-- Generere oversettelser for målspråkene dine
-- Opprette eller oppdatere e-postmalene for målspråk (f.eks. emails/sv/*.tsx)
-- Bevare React-komponentstruktur og props
-- Opprettholde HTML-format og styling
-- Håndtere interpolering og dynamisk innhold
diff --git a/apps/web/src/markdown/docs/no/ts.mdx b/apps/web/src/markdown/docs/no/ts.mdx
deleted file mode 100644
index 61b8d15e..00000000
--- a/apps/web/src/markdown/docs/no/ts.mdx
+++ /dev/null
@@ -1,42 +0,0 @@
-# TypeScript
-
-Languine støtter TypeScript lokaliseringsfiler med full typesikkerhet. Dette formatet utvider JavaScript-støtten med tillegg av TypeScript-spesifikke funksjoner og muligheter for typegenerering.
-
----
-
-## Oppsett
-
-Først, sørg for at du har en languine.json konfigurasjonsfil i rotmappen til prosjektet ditt. Her er et eksempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "ts": {
-      "include": ["src/locales/[locale].ts"]
-    }
-  }
-}
-```
-
-## Oversettelse
-
-Når konfigurasjonen din er satt opp, kjør:
-
-```bash
-npx languine@latest translate
-```
-
-Når du kjører denne kommandoen, vil Languine:
-
-- Laste inn kilde TypeScript-filene dine (f.eks. src/locales/en.ts)
-- Oppdage eventuelle nye eller endrede oversettelsesstrenger
-- Generere oversettelser for målspråkene dine
-- Opprette eller oppdatere målspråkfilene (f.eks. src/locales/sv.ts)
-- Bevare typeannotasjoner og grensesnitt
-- Håndtere nestede objekter med riktig typing
-- Opprettholde kodeformatering og dokumentasjonskommentarer
-- Støtte litterale typer og unionstyper
diff --git a/apps/web/src/markdown/docs/no/xcode-stringsdict.mdx b/apps/web/src/markdown/docs/no/xcode-stringsdict.mdx
deleted file mode 100644
index a6ac1c06..00000000
--- a/apps/web/src/markdown/docs/no/xcode-stringsdict.mdx
+++ /dev/null
@@ -1,44 +0,0 @@
-# Xcode Stringsdict
-
-Languine støtter Xcode sitt Stringsdict-format, som brukes for komplekse pluraliseringsregler i iOS- og macOS-applikasjoner. Dette formatet håndterer pluralformer, variabelsubstitusjoner og språkspesifikke pluralregler.
-
----
-
-## Oppsett
-
-Først, sørg for at du har en languine.json konfigurasjonsfil i rotmappen til prosjektet ditt. Her er et eksempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "stringsdict": {
-      "include": ["MyApp/Localizable.stringsdict"]
-    }
-  }
-}
-```
-
-## Oversettelse
-
-Når konfigurasjonen din er satt opp, kjør:
-
-```bash
-npx languine@latest translate
-```
-
-Når du kjører denne kommandoen, vil Languine:
-
-- Laste inn Stringsdict-filene dine
-- Oppdage eventuelle nye eller endrede pluralregler
-- Generere oversettelser for målspråkene dine
-- Oppdatere Stringsdict-filene med nye oversettelser
-- Håndtere komplekse pluralregler for hvert språk
-- Opprettholde variabelsubstitusjoner
-- Bevare ordbokstrukturen
-- Støtte språkspesifikke pluralformer
-- Validere konsistensen i pluralreglene
-- Beholde formateringsspesifikatorer
diff --git a/apps/web/src/markdown/docs/no/xcode-xcstrings.mdx b/apps/web/src/markdown/docs/no/xcode-xcstrings.mdx
deleted file mode 100644
index 8976c7e7..00000000
--- a/apps/web/src/markdown/docs/no/xcode-xcstrings.mdx
+++ /dev/null
@@ -1,44 +0,0 @@
-# Xcode Strings (XCStrings)
-
-Languine støtter Xcodes XCStrings-format, det moderne lokaliseringsformatet for iOS- og macOS-applikasjoner. Dette formatet håndterer strengkataloger med støtte for variasjoner, pluralisering og utviklerkommentarer.
-
----
-
-## Oppsett
-
-Først, sørg for at du har en languine.json konfigurasjonsfil i rotmappen til prosjektet ditt. Her er et eksempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "xcstrings": {
-      "include": ["MyApp/Localizable.xcstrings"]
-    }
-  }
-}
-```
-
-## Oversettelse
-
-Når konfigurasjonen din er satt opp, kjør:
-
-```bash
-npx languine@latest translate
-```
-
-Når du kjører denne kommandoen, vil Languine:
-
-- Laste inn XCStrings-katalogen din
-- Oppdage eventuelle nye eller endrede strenger
-- Generere oversettelser for målspråkene dine
-- Oppdatere strengkatalogen med nye oversettelser
-- Bevare strengvariasjoner og pluraliseringsregler
-- Opprettholde utviklerkommentarer og kontekst
-- Håndtere variabelsubstitusjoner
-- Støtte adaptive strenger
-- Beholde formateringsspesifikatorer
-- Validere strukturen til strengkatalogen
diff --git a/apps/web/src/markdown/docs/no/xliff.mdx b/apps/web/src/markdown/docs/no/xliff.mdx
deleted file mode 100644
index 5e2fc8ff..00000000
--- a/apps/web/src/markdown/docs/no/xliff.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# XLIFF
-
-Languine støtter XLIFF (XML Localization Interchange File Format), et XML-basert format designet for å utveksle lokaliseringsdata. Dette formatet brukes mye i profesjonelle oversettelsesarbeidsflyter og støtter både XLIFF 1.2 og 2.0 versjoner.
-
----
-
-## Oppsett
-
-Først, sørg for at du har en languine.json konfigurasjonsfil i rotmappen til prosjektet ditt. Her er et eksempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "xliff": {
-      "include": ["locales/[locale].xlf"]
-    }
-  }
-}
-```
-
-## Oversettelse
-
-Når konfigurasjonen din er satt opp, kjør:
-
-```bash
-npx languine@latest translate
-```
-
-Når du kjører denne kommandoen, vil Languine:
-
-- Laste inn din kilde XLIFF-fil (f.eks. locales/en.xlf)
-- Oppdage eventuelle nye eller endrede oversettelsesenheter
-- Generere oversettelser for dine målspråk
-- Opprette eller oppdatere målspråk XLIFF-filene (f.eks. locales/sv.xlf)
-- Bevare notater, kontekstinformasjon og tilstandsattributter
-- Opprettholde kompatibilitet med CAT (Computer-Aided Translation) verktøy
diff --git a/apps/web/src/markdown/docs/no/xml.mdx b/apps/web/src/markdown/docs/no/xml.mdx
deleted file mode 100644
index 3ea53b8e..00000000
--- a/apps/web/src/markdown/docs/no/xml.mdx
+++ /dev/null
@@ -1,44 +0,0 @@
-# XML
-
-Languine støtter lokalisering av XML-filer, egnet for ulike XML-baserte konfigurasjons- og innholdsfilformater. Dette formatet håndterer komplekse XML-strukturer samtidig som det bevarer formatering og attributter.
-
----
-
-## Oppsett
-
-Først, sørg for at du har en languine.json konfigurasjonsfil i rotmappen til prosjektet ditt. Her er et eksempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "xml": {
-      "include": ["resources/[locale]/*.xml"]
-    }
-  }
-}
-```
-
-## Oversettelse
-
-Når konfigurasjonen din er satt opp, kjør:
-
-```bash
-npx languine@latest translate
-```
-
-Når du kjører denne kommandoen, vil Languine:
-
-- Laste inn dine kilde XML-filer (f.eks. resources/en/*.xml)
-- Oppdage nytt eller endret innhold
-- Generere oversettelser for dine målspråk
-- Opprette eller oppdatere målspråksfilene (f.eks. resources/sv/*.xml)
-- Bevare XML-struktur og formatering
-- Håndtere attributtoversettelser
-- Opprettholde CDATA-seksjoner
-- Beholde XML-kommentarer
-- Støtte XML-navnerom
-- Validere XML-struktur
diff --git a/apps/web/src/markdown/docs/no/yaml.mdx b/apps/web/src/markdown/docs/no/yaml.mdx
deleted file mode 100644
index 3a058365..00000000
--- a/apps/web/src/markdown/docs/no/yaml.mdx
+++ /dev/null
@@ -1,39 +0,0 @@
-# YAML
-
-Languine støtter YAML-filer som kildeformat, som ofte brukes i Ruby on Rails, Laravel og andre rammeverk. Dette formatet støtter nestede strukturer, matriser og komplekse datatyper.
-
----
-
-## Oppsett
-
-Først, sørg for at du har en languine.json konfigurasjonsfil i rotmappen til prosjektet ditt. Her er et eksempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "yaml": {
-      "include": ["config/locales/[locale].yml"]
-    }
-  }
-}
-```
-
-## Oversettelse
-
-Når konfigurasjonen din er satt opp, kjør:
-
-```bash
-npx languine@latest translate
-```
-
-Når du kjører denne kommandoen, vil Languine:
-
-- Laste inn kilde-YAML-filen din (f.eks. config/locales/en.yml)
-- Oppdage eventuelle nye eller endrede oversettelsesstrenger
-- Generere oversettelser for målspråkene dine
-- Opprette eller oppdatere målspråk-YAML-filene (f.eks. config/locales/sv.yml)
-- Bevare nestede strukturer og formatering
diff --git a/apps/web/src/markdown/docs/pl/android.mdx b/apps/web/src/markdown/docs/pl/android.mdx
deleted file mode 100644
index 7c641366..00000000
--- a/apps/web/src/markdown/docs/pl/android.mdx
+++ /dev/null
@@ -1,39 +0,0 @@
-# Android
-
-Languine obsługuje zasoby ciągów Androida (strings.xml) jako format źródłowy, obsługując liczby mnogie, tablice ciągów i sformatowane ciągi. Ten format jest standardowym sposobem zarządzania tłumaczeniami w aplikacjach na Androida.
-
----
-
-## Konfiguracja
-
-Najpierw upewnij się, że masz plik konfiguracyjny languine.json w katalogu głównym projektu. Oto przykład:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "android": {
-      "include": ["app/src/main/res/values-[locale]/strings.xml"]
-    }
-  }
-}
-```
-
-## Tłumaczenie
-
-Po ustawieniu konfiguracji uruchom:
-
-```bash
-npx languine@latest translate
-```
-
-Kiedy uruchomisz to polecenie, Languine:
-
-- Załaduje twój plik źródłowy strings.xml (np. values/strings.xml)
-- Wykryje wszelkie nowe lub zmodyfikowane ciągi tłumaczeń
-- Wygeneruje tłumaczenia dla twoich docelowych języków
-- Utworzy lub zaktualizuje pliki XML dla języków docelowych (np. values-sv/strings.xml, values-de/strings.xml, values-fr/strings.xml)
-- Zachowa wszelkie istniejące formatowanie tablic ciągów i liczby mnogiej
diff --git a/apps/web/src/markdown/docs/pl/arb.mdx b/apps/web/src/markdown/docs/pl/arb.mdx
deleted file mode 100644
index 61bec61c..00000000
--- a/apps/web/src/markdown/docs/pl/arb.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# ARB (Zestaw zasobów aplikacji)
-
-Languine obsługuje pliki ARB, standardowy format lokalizacji dla aplikacji Flutter. Ten format obsługuje liczby mnogie, miejsca na tekst oraz wyrażenia wyboru, zachowując zgodność z pakietem intl Fluttera.
-
----
-
-## Konfiguracja
-
-Najpierw upewnij się, że masz plik konfiguracyjny languine.json w katalogu głównym projektu. Oto przykład:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "arb": {
-      "include": ["lib/l10n/intl_[locale].arb"]
-    }
-  }
-}
-```
-
-## Tłumaczenie
-
-Po ustawieniu konfiguracji uruchom:
-
-```bash
-npx languine@latest translate
-```
-
-Kiedy uruchomisz to polecenie, Languine:
-
-- Załaduje twój źródłowy plik ARB (np. lib/l10n/intl_en.arb)
-- Wykryje wszelkie nowe lub zmodyfikowane ciągi tłumaczeń
-- Wygeneruje tłumaczenia dla twoich docelowych języków
-- Utworzy lub zaktualizuje pliki ARB dla języków docelowych (np. lib/l10n/intl_sv.arb)
-- Zachowa metadane, miejsca na tekst oraz liczby mnogie/wyrażenia wyboru
-
diff --git a/apps/web/src/markdown/docs/pl/authentication.mdx b/apps/web/src/markdown/docs/pl/authentication.mdx
deleted file mode 100644
index 8b74ab94..00000000
--- a/apps/web/src/markdown/docs/pl/authentication.mdx
+++ /dev/null
@@ -1,48 +0,0 @@
-# Uwierzytelnianie
-
-Aby korzystać z Languine, musisz uwierzytelnić się w naszym silniku, co zajmuje tylko kilka sekund, aby rozpocząć.
-
----
-
-## Zaloguj się
-
-Możesz zalogować się bezpośrednio na [Languine Dashboard](https://languine.ai/login) lub uruchomić następujące polecenie:
-
-```bash title="Terminal"
-npx languine@latest auth login
-```
-
-
-Jeśli masz już konto, zostaniesz automatycznie zalogowany, a sesja zostanie zapisana na twoim urządzeniu.
-
----
-
-## Wyloguj się
-
-Możesz się wylogować, uruchamiając następujące polecenie:
-
-```bash title="Terminal"
-npx languine@latest auth logout
-```
-
----
-
-## Sesja użytkownika
-
-Możesz sprawdzić, czy jesteś zalogowany, uruchamiając następujące polecenie:
-
-```bash title="Terminal"
-npx languine@latest auth whoami
-```
-
----
-
-
-# Zmienne środowiskowe
-
-Możesz ustawić następujące zmienne środowiskowe, aby skonfigurować Languine:
-
-- `LANGUINE_API_KEY`: Klucz API do użycia w celu uwierzytelnienia.
-- `LANGUINE_PROJECT_ID`: Identyfikator projektu do użycia w projekcie.
-
-Znajdziesz je w [Languine Dashboard](https://languine.ai/login).
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/pl/biome.mdx b/apps/web/src/markdown/docs/pl/biome.mdx
deleted file mode 100644
index 9977b445..00000000
--- a/apps/web/src/markdown/docs/pl/biome.mdx
+++ /dev/null
@@ -1,24 +0,0 @@
-# Biome
-
-Languine może współpracować z [Biome](https://biomejs.dev/), aby zapewnić, że Twoje pliki tłumaczeń są spójnie sformatowane. Jest to szczególnie przydatne podczas pracy z plikami tłumaczeń JSON, które muszą utrzymywać spójny styl w całym projekcie.
-
-## Użycie z Languine
-
-Zalecanym sposobem użycia Biome z Languine jest formatowanie plików tłumaczeń po ich wygenerowaniu. Możesz to skonfigurować w swoim `package.json`:
-
-```json title="package.json"
-{
-  "scripts": {
-    "translate": "languine translate",
-    "format": "biome format \"locales/**/*.json\"",
-    "translate:format": "npm run translate && npm run format"
-  }
-}
-```
-
-Teraz możesz:
-- Uruchomić `npm run translate`, aby tylko wygenerować tłumaczenia
-- Uruchomić `npm run format`, aby tylko sformatować istniejące pliki tłumaczeń
-- Uruchomić `npm run translate:format`, aby wygenerować tłumaczenia i sformatować je w kolejności
-
-Ta konfiguracja zapewni, że Twoje pliki tłumaczeń będą sformatowane spójnie z wcięciem 2-spaces i maksymalną szerokością linii wynoszącą 80 znaków.
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/pl/ci.mdx b/apps/web/src/markdown/docs/pl/ci.mdx
deleted file mode 100644
index 3838b132..00000000
--- a/apps/web/src/markdown/docs/pl/ci.mdx
+++ /dev/null
@@ -1,96 +0,0 @@
-# CI/CD
-
-Languine oferuje integrację CI/CD, aby pomóc Ci w tłumaczeniu aplikacji.
-
----
-
-## Jak to działa
-
-Workflow CI/CD w Languine opiera się na uporządkowanym procesie automatyzacji aktualizacji tłumaczeń w Twojej aplikacji:
-
-### 1. Inicjalizacja akcji
-- Workflow rozpoczyna się, gdy akcja jest wyzwalana
-- Ustawia niezbędną konfigurację Git i dane uwierzytelniające
-
-### 2. Przetwarzanie silnika Languine
-- Silnik Languine przetwarza zawartość Twojej aplikacji
-- Obsługuje zadania tłumaczeniowe przy użyciu skonfigurowanych ustawień
-
-### 3. Wykrywanie zmian
-System sprawdza, czy wystąpiły jakiekolwiek zmiany w tłumaczeniach i podąża jedną z dwóch ścieżek:
-
-**Gdy zmiany zostaną znalezione:**
-- Zmiany są zatwierdzane w repozytorium
-- Zmiany są przesyłane do określonej gałęzi
-- Tworzony jest Pull Request (PR)
-
-**Gdy nie znaleziono zmian:**
-- Workflow kończy się bez tworzenia PR
-
-### 4. Tworzenie Pull Request
-Gdy zmiany zostaną wykryte, tworzony jest Pull Request z:
-
-**Zawartość PR:**
-- Jasny tytuł wskazujący na aktualizacje tłumaczeń
-- Szczegółowy opis zmian
-- Potwierdzenia kontroli jakości
-- Instrukcje do przeglądu
-- Linki do dokumentacji i wsparcia
-
-**Opis PR zawiera:**
-- Podsumowanie aktualizacji tłumaczeń
-- Listę zmian (zaktualizowane tłumaczenia, spójność terminologii)
-- Następne kroki dla recenzentów
-- Linki do dokumentacji i zasobów wsparcia
-
----
-
-## Diagram workflow
-
-<div className="flex flex-col items-center justify-center p-4 h-[400px] sm:h-[500px] md:h-[650px]">
-  <pre
-    className="p-4 text-sm leading-5 mb-4 scale-[0.5] sm:scale-[0.65] md:scale-90 transform-gpu"
-    style={{
-      fontFamily: "monospace",
-      whiteSpace: "pre",
-      textAlign: "left",
-    }}
-  >
-    {`
-                    ┌─────────────────────┐
-                    │   Akcja Rozpoczyna  │
-                    └──────────┬──────────┘
-                               │
-                    ┌──────────▼──────────┐
-                    │    Ustaw Git &      │
-                    │    Dane Uwierzytelniające │
-                    └──────────┬──────────┘
-                               │
-┌─────────────────────────────────────────────────────────┐
-│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-│░░░░░░░░░░░░░░░░░░░░ Silnik Languine ░░░░░░░░░░░░░░░░░░░░│
-│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-└─────────────────────────────────────────────────────────┘
-                               │
-                    ┌──────────▼──────────┐
-                    │   Sprawdź Zmiany    │───────┐
-                    └──────────┬──────────┘       │
-                               │                  │
-                               │ [Zmiany]        │ [Brak Zmian]
-                               │                  │
-                    ┌──────────▼──────────┐       │
-                    │   Zatwierdź & Prześlij │       │
-                    └──────────┬──────────┘       │
-                               │                  │
-                    ┌──────────▼──────────┐       │
-                    │    Utwórz PR        │       │
-                    └──────────┬──────────┘       │
-                               │                  │
-                    ┌──────────▼──────────┐       │
-                    │        Gotowe       │◄──────┘
-                    └─────────────────────┘
-`}
-  </pre>
-</div>
-
-Workflow został zaprojektowany tak, aby był zautomatyzowany, jednocześnie umożliwiając przegląd i kontrolę jakości przed scaleniem zmian do Twojej bazy kodu. Utrzymuje najlepsze praktyki kontroli wersji i zapewnia, że tłumaczenia są odpowiednio śledzone i dokumentowane w historii Git.
diff --git a/apps/web/src/markdown/docs/pl/cli.mdx b/apps/web/src/markdown/docs/pl/cli.mdx
deleted file mode 100644
index 15da5ee7..00000000
--- a/apps/web/src/markdown/docs/pl/cli.mdx
+++ /dev/null
@@ -1,65 +0,0 @@
-# CLI
-
-Languine oferuje interfejs wiersza poleceń (CLI), aby pomóc Ci w tłumaczeniu aplikacji.
-
----
-
-## Przegląd poleceń
-
-### Tłumaczenie
-
-Polecenie `translate` służy do tłumaczenia Twojej aplikacji.
-
-```bash title="Terminal"
-    npx languine@latest translate
-```
-
----
-
-### Inicjalizacja
-
-Polecenie `init` służy do inicjalizacji nowego projektu Languine.
-
-```bash title="Terminal"
-    npx languine@latest init
-```
-
----
-
-### Uwierzytelnianie
-
-Polecenie `auth` służy do uwierzytelniania w Languine.
-
-```bash title="Terminal"
-    npx languine@latest auth
-```
-
----
-
-### Synchronizacja
-
-Polecenie `sync` służy do synchronizacji Twojej aplikacji z Languine.
-
-```bash title="Terminal"
-    npx languine@latest sync
-```
-
----
-
-### Dodaj lokalizację
-
-Polecenie `locale` służy do zarządzania lokalizacjami Twojej aplikacji.
-
-```bash title="Terminal"
-    npx languine@latest locale add pt,fr
-```
-
----
-
-### Usuń lokalizację
-
-Polecenie `locale remove` służy do usunięcia lokalizacji z Twojej aplikacji.
-
-```bash title="Terminal"
-    npx languine@latest locale remove pt,fr
-```
diff --git a/apps/web/src/markdown/docs/pl/configuration.mdx b/apps/web/src/markdown/docs/pl/configuration.mdx
deleted file mode 100644
index 6017020e..00000000
--- a/apps/web/src/markdown/docs/pl/configuration.mdx
+++ /dev/null
@@ -1,180 +0,0 @@
-# Konfiguracja
-
-Languine używa pliku konfiguracyjnego JSON (languine.json) do zarządzania ustawieniami tłumaczenia. Plik ten definiuje twoje języki źródłowe i docelowe, a także pliki, które należy przetłumaczyć.
-
----
-
-## Podstawowa konfiguracja
-
-Oto podstawowy przykład w obu formatach:
-
-```json title="languine.json"
-{
-  "locale": {
-    "source": "en",
-    "targets": ["es", "fr", "de"]
-  },
-  "files": {
-    "json": {
-      "include": ["locales/[locale].json"]
-    }
-  }
-}
-```
-
-Rozłóżmy różne sekcje w pliku konfiguracyjnym.
-
----
-
-## Konfiguracja lokalizacji
-
-Sekcja lokalizacji definiuje twoje języki tłumaczenia:
-
-- source: Twój podstawowy język do tworzenia treści (np. "en" dla angielskiego)
-- targets: Tablica języków, na które chcesz przetłumaczyć (np. ["es", "fr", "de"] dla hiszpańskiego, francuskiego i niemieckiego)
-
-Languine obsługuje szeroki zakres kodów językowych, w tym:
-- Proste kody: en, es, fr, de
-- Kody specyficzne dla regionu: pt-BR, zh-CN, zh-TW
-
-## Konfiguracja plików
-
-Sekcja plików definiuje, które pliki Languine powinno przetłumaczyć. Możesz skonfigurować wiele typów plików i wzorców:
-
----
-
-### Pliki JSON
-```json
-files: {
-  json: {
-    include: ["locales/[locale].json"],
-  },
-}
-```
-
----
-
-### Pliki Markdown/MDX
-```json
-files: {
-  md: {
-    include: ["docs/[locale]/*.md"],
-  },
-  mdx: {
-    include: ["blog/[locale]/*.mdx"],
-  },
-}
-```
-
----
-
-### Pliki platform mobilnych
-
-Dla iOS (Xcode):
-```json
-files: {
-  "xcode-xcstrings": {
-    include: ["Example/Localizable.xcstrings"],
-  },
-  // Lub dla tradycyjnych plików .strings
-  "xcode-strings": {
-    include: ["Example/[locale].lproj/Localizable.strings"],
-  },
-}
-```
-
----
-
-Dla Androida:
-```json
-files: {
-  android: {
-    include: ["locales/[locale].xml"],
-  },
-}
-```
-
----
-
-### Inne formaty
-
-Oto pełna lista formatów plików obsługiwanych przez Languine:
-
-- [JSON](/docs/json) - Standardowe pliki tłumaczeń JSON
-- [YAML](/docs/yaml) - Pliki tłumaczeń YAML
-- [Properties](/docs/properties) - Pliki właściwości Java
-- [Android](/docs/android) - Pliki zasobów XML Androida
-- [iOS](/docs/ios) - Pliki lokalizacyjne iOS
-- [iOS Stringsdict](/docs/xcode-stringsdict) - Pliki pluralizacji iOS
-- [iOS XCStrings](/docs/xcode-xcstrings) - Nowoczesne katalogi ciągów Xcode
-- [Markdown](/docs/md) - Pliki dokumentacji
-- [MDX](/docs/mdx) - Dokumentacja z JSX
-- [HTML](/docs/html) - Pliki HTML
-- [JavaScript](/docs/js) - Pliki JavaScript
-- [TypeScript](/docs/ts) - Pliki TypeScript
-- [Gettext PO](/docs/po) - Pliki tłumaczeń GetText
-- [XLIFF](/docs/xliff) - Format wymiany lokalizacji XML
-- [CSV](/docs/csv) - Tłumaczenia oparte na arkuszach kalkulacyjnych
-- [XML](/docs/xml) - Pliki zasobów XML
-- [Flutter ARB](/docs/arb) - Pliki Application Resource Bundle
-
----
-
-## Wzorce plików
-
-Zmienna [locale] w wzorcach plików jest automatycznie zastępowana odpowiednim kodem językowym podczas tłumaczenia. Na przykład:
-
-- locales/[locale].json staje się:
-  - locales/en.json
-  - locales/es.json
-  - locales/fr.json
-
-Możesz uwzględnić wiele wzorców dla każdego typu pliku i używać wzorców glob:
-```json
-files: {
-  json: {
-    include: [
-      "src/locales/[locale].json",
-      "src/components/[locale]/*.json"
-    ],
-  },
-}
-```
-
----
-
-## ID projektu (opcjonalne)
-
-Jeśli korzystasz z usług chmurowych Languine, możesz uwzględnić swoje ID projektu w konfiguracji:
-
-```json
-{
-  "projectId": "prj_your_project_id",
-  "locale": {
-    // ... konfiguracja lokalizacji
-  },
-  files: {
-    // ... konfiguracja plików
-  },
-}
-```
-
----
-
-## Śledzenie stanu tłumaczeń
-
-Languine automatycznie tworzy i utrzymuje plik languine.lock, aby śledzić stan twoich tłumaczeń. Plik ten:
-
-- Śledzi, która treść została przetłumaczona
-- Pomaga zidentyfikować, co należy zaktualizować, gdy zmienia się treść źródłowa
-- Powinien być zatwierdzony w twoim systemie kontroli wersji
-
-Nie musisz ręcznie edytować pliku blokady - Languine zarządza nim automatycznie, gdy uruchamiasz polecenia tłumaczenia.
-
-## Najlepsze praktyki
-
-1. **Kontrola wersji**: Zawsze zatwierdzaj zarówno languine.json, jak i languine.lock w swoim repozytorium
-2. **Organizacja plików**: Utrzymuj swoje pliki tłumaczeń w zorganizowanej i spójnej strukturze katalogów
-3. **Kody językowe**: Używaj standardowych kodów językowych, aby zapewnić zgodność
-4. **Wzorce**: Używaj specyficznych wzorców dołączania, aby uniknąć tłumaczenia niepotrzebnych plików
-5. **ID projektu**: Zachowaj swoje ID projektu w bezpiecznym miejscu i nie udostępniaj go publicznie, jeśli korzystasz z usług chmurowych, zamiast tego użyj zmiennej środowiskowej `LANGUINE_PROJECT_ID`.
diff --git a/apps/web/src/markdown/docs/pl/csv.mdx b/apps/web/src/markdown/docs/pl/csv.mdx
deleted file mode 100644
index acccfc5d..00000000
--- a/apps/web/src/markdown/docs/pl/csv.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# CSV
-
-Languine obsługuje pliki CSV (Wartości Oddzielone Przecinkami) do prostego zarządzania tłumaczeniami. Ten format jest idealny do pracy z arkuszami kalkulacyjnymi i łatwej integracji z zewnętrznymi narzędziami tłumaczeniowymi.
-
----
-
-## Konfiguracja
-
-Najpierw upewnij się, że masz plik konfiguracyjny languine.json w głównym katalogu projektu. Oto przykład:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "csv": {
-      "include": ["translations/[locale].csv"]
-    }
-  }
-}
-```
-
-## Tłumaczenie
-
-Po ustawieniu konfiguracji uruchom:
-
-```bash
-npx languine@latest translate
-```
-
-Gdy uruchomisz to polecenie, Languine:
-
-- Załaduje twój źródłowy plik CSV (np. translations/en.csv)
-- Wykryje nowe lub zmodyfikowane ciągi tłumaczeń
-- Wygeneruje tłumaczenia dla twoich docelowych języków
-- Utworzy lub zaktualizuje pliki CSV dla docelowych języków (np. translations/sv.csv)
-- Zachowa strukturę kolumn i formatowanie
-- Zachowa wszelkie dodatkowe kolumny metadanych
diff --git a/apps/web/src/markdown/docs/pl/expo.mdx b/apps/web/src/markdown/docs/pl/expo.mdx
deleted file mode 100644
index aa26e2f9..00000000
--- a/apps/web/src/markdown/docs/pl/expo.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# Expo
-
-Languine wspiera lokalizację Expo, integrując się płynnie z systemem i18n Expo. Ten format działa zarówno z projektami JavaScript, jak i TypeScript, wspierając zagnieżdżone struktury oraz pluralizację.
-
----
-
-## Konfiguracja
-
-Najpierw upewnij się, że masz plik konfiguracyjny languine.json w głównym katalogu projektu. Oto przykład:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "expo": {
-      "include": ["assets/locales/[locale].json"]
-    }
-  }
-}
-```
-
-## Tłumaczenie
-
-Po ustawieniu konfiguracji uruchom:
-
-```bash
-npx languine@latest translate
-```
-
-Kiedy uruchomisz to polecenie, Languine:
-
-- Załaduje twój plik źródłowy z tłumaczeniem (np. assets/locales/en.json)
-- Wykryje wszelkie nowe lub zmodyfikowane ciągi tłumaczeń
-- Wygeneruje tłumaczenia dla twoich docelowych języków
-- Utworzy lub zaktualizuje pliki językowe docelowe (np. assets/locales/sv.json)
-- Zachowa zagnieżdżoną strukturę oraz zasady pluralizacji
-- Utrzyma zgodność z expo-localization
diff --git a/apps/web/src/markdown/docs/pl/github-actions.mdx b/apps/web/src/markdown/docs/pl/github-actions.mdx
deleted file mode 100644
index 11704424..00000000
--- a/apps/web/src/markdown/docs/pl/github-actions.mdx
+++ /dev/null
@@ -1,147 +0,0 @@
-# GitHub Actions
-
-Dzięki akcji GitHub możesz łatwo przetłumaczyć swój kod, po prostu przesyłając go do repozytorium. Akcja GitHub przetłumaczy nowe klucze, tworząc pull request lub zatwierdzając zmiany.
-To oszczędza dużo czasu i wysiłku, jednocześnie utrzymując wysoką jakość tłumaczeń.
-
----
-
-## Jak to działa
-
-
-
-<div className="flex flex-col items-center justify-center p-4 mb-8 h-[400px] sm:h-[500px] md:h-[650px]">
-        <pre
-          className="p-4 text-sm leading-5 scale-[0.5] sm:scale-[0.65] md:scale-90 transform-gpu"
-          style={{
-            fontFamily: "monospace",
-            whiteSpace: "pre",
-            textAlign: "left",
-          }}
-        >
-          {`
-                                  ┌───────────────┐
-                                  │   Git Push    │
-                                  └───────────────┘
-                                          │
-                                          ▼
-             ┌─────────────────────────────────────────────────────────┐
-             │░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-             │░░░░░░░░░░░░░░░░░░░░ Languine Engine ░░░░░░░░░░░░░░░░░░░░│
-             │░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-             └─────────────────────────────────────────────────────────┘
-                                          │
-                                          ▼
-                                          │
-            ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┼ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─
-           │                              │                              │
-           ▼                              ▼                              ▼
- ╔═══════════════════╗          ╔═══════════════════╗          ╔═══════════════════╗
- ║                   ║          ║                   ║          ║                   ║
- ║      English      ║          ║      Spanish      ║          ║      Japanese     ║
- ║    Translation    ║          ║    Translation    ║          ║     Translation   ║
- ║                   ║          ║                   ║          ║                   ║
- ╚═══════════════════╝          ╚═══════════════════╝          ╚═══════════════════╝
-           │                              │                              │
-           └──────────────────────────────┼──────────────────────────────┘
-                                          ▼
-                                  ┌───────────────┐
-                                  │     Merge     │
-                                  │ Pull Request  │
-                                  └───────────────┘
-                                          │
-                                          ▼
-                              ┌─────────────────────┐
-                              │      Completed      │
-                              │      (Deploy)       │
-                              └─────────────────────┘
-`}
-        </pre>
-      </div>
-
----
-
-## Instalacja
-
-Aby użyć akcji Languine GitHub w swoim repozytorium, musisz:
-
-1. Ustawić sekrety repozytorium z danymi uwierzytelniającymi Languine
-2. Utworzyć plik roboczy w swoim repozytorium
-
-### Ustawianie sekretów repozytorium
-
-Dodaj następujące sekrety w ustawieniach swojego repozytorium (Ustawienia > Sekrety i zmienne > Akcje):
-
-- `LANGUINE_API_KEY`: Twój klucz API Languine
-- `LANGUINE_PROJECT_ID`: Twój identyfikator projektu Languine
-
-Możesz znaleźć te wartości w swoim panelu Languine w sekcji Ustawienia projektu.
-
-
-
-### Zmienne środowiskowe
-
-Akcja GitHub używa następujących zmiennych środowiskowych:
-- `LANGUINE_API_KEY` (Wymagane): Twój klucz API Languine do uwierzytelniania
-- `LANGUINE_PROJECT_ID` (Wymagane): Twój identyfikator projektu Languine 
-- `GITHUB_TOKEN` (Wymagane): Automatycznie dostarczane przez GitHub, używane do tworzenia PR-ów
-
-### Przykład roboczego pliku
-
-Utwórz nowy plik .github/workflows/languine.yml w swoim repozytorium z następującą zawartością:
-
-```ts title=".github/workflows/release.yml"
-name: Wdróż stronę
-
-on:
-  push:
-    branches:
-      - '**'
-    paths:
-      - apps/web/**
-
-jobs:
-  translate:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-      pull-requests: write
-    steps:
-      - uses: actions/checkout@v4
-      
-      - name: Akcja Languine
-        uses: languine/languine-action@v1
-        env:
-           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          api-key: ${{ secrets.LANGUINE_API_KEY }}
-          project-id: ${{ secrets.LANGUINE_PROJECT_ID }}
-```
- 
- Ten plik roboczy:
-- Uruchomi się przy przesyłaniu do głównej gałęzi
-- Uruchomi się przy pull requestach do głównej gałęzi
-- Może być uruchamiany ręcznie z zakładki Akcje
-- Sprawdzi Twój kod i uruchomi proces tłumaczenia Languine
-- Utworzy pull request z nowymi tłumaczeniami (możliwe do skonfigurowania)
-
-#### Opcja katalogu roboczego
-
-Opcja `working-directory` pozwala określić, gdzie znajdują się Twoje pliki tłumaczeń. Jest to szczególnie przydatne w monorepo, gdzie Twoje tłumaczenia mogą znajdować się w określonym pakiecie lub katalogu aplikacji. Na przykład:
-
-#### Opcja Pull Request (wkrótce)
-
-Opcja `create-pull-request` kontroluje, czy akcja tworzy pull request ze zmianami, czy zatwierdza je bezpośrednio do gałęzi:
-
-```typescript title=".github/workflows/languine.yml"
-with:
-  create-pull-request: true # utwórz pull request ze zmianami
-```
-
-Gdy ustawione na `true`, akcja:
-- Utworzy nową gałąź ze zmianami
-- Utworzy pull request do przeglądu
-- Doda odpowiednie etykiety i opis
-
-Gdy ustawione na `false` (domyślnie), akcja:
-- Zatwierdzi zmiany bezpośrednio do bieżącej gałęzi
-- Przesyła zmiany bez tworzenia pull requesta
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/pl/html.mdx b/apps/web/src/markdown/docs/pl/html.mdx
deleted file mode 100644
index 49f9e1aa..00000000
--- a/apps/web/src/markdown/docs/pl/html.mdx
+++ /dev/null
@@ -1,41 +0,0 @@
-# HTML
-
-Languine obsługuje lokalizację plików HTML, zajmując się zarówno treścią tekstową, jak i atrybutami. Ten format jest idealny dla statycznych stron internetowych i szablonów HTML, z obsługą zachowania struktury i formatowania HTML.
-
----
-
-## Konfiguracja
-
-Najpierw upewnij się, że masz plik konfiguracyjny languine.json w głównym katalogu projektu. Oto przykład:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "html": {
-      "include": ["pages/[locale]/*.html"]
-    }
-  }
-}
-```
-
-## Tłumaczenie
-
-Po ustawieniu konfiguracji uruchom:
-
-```bash
-npx languine@latest translate
-```
-
-Kiedy uruchomisz to polecenie, Languine:
-
-- Załaduje twoje źródłowe pliki HTML (np. pages/en/*.html)
-- Wykryje nowe lub zmodyfikowane ciągi tłumaczeń
-- Wygeneruje tłumaczenia dla twoich docelowych języków
-- Utworzy lub zaktualizuje pliki HTML w docelowym języku (np. pages/sv/*.html)
-- Zachowa strukturę i formatowanie HTML
-- Zajmie się tłumaczeniem określonych atrybutów
-- Zachowa komentarze i specjalne tagi
diff --git a/apps/web/src/markdown/docs/pl/introduction.mdx b/apps/web/src/markdown/docs/pl/introduction.mdx
deleted file mode 100644
index 2f2f6436..00000000
--- a/apps/web/src/markdown/docs/pl/introduction.mdx
+++ /dev/null
@@ -1,34 +0,0 @@
-# Wprowadzenie
-
-Languine automatyzuje lokalizację w Twoim procesie rozwoju i pipeline, zapewniając, że tłumaczenia nigdy nie będą Cię spowalniać.
-
-Przekształć swoją aplikację w wielojęzyczne doświadczenie w kilka minut. Podczas gdy Ty koncentrujesz się na budowaniu funkcji, Languine zajmuje się wszystkimi aspektami tłumaczenia z precyzją i niezawodnością.
-
----
-
-## Kluczowe funkcje
-
-- **Silnik Tłumaczeń**: Wykorzystaj tłumaczenia wysokiej jakości, uwzględniające kontekst, które zachowują głos Twojej marki
-- **Integracja CI/CD**: Automatyzuj aktualizacje tłumaczeń w ramach istniejących procesów
-- **Formaty**: Obsługuj dowolny format pliku dzięki naszemu rozszerzalnemu systemowi parserów
-- **Open Source**: Uzyskaj dostęp, przeglądaj i wnieś wkład do naszej bazy kodu na GitHubie - żadnych czarnych skrzynek, pełna przejrzystość
-
----
-
-## Jak to działa
-
-1. **Szybka konfiguracja**: Rozpocznij w kilka minut z naszym intuicyjnym CLI i prowadzeniem przez proces inicjalizacji
-2. **Prosta konfiguracja**: Zdefiniuj swoje potrzeby tłumaczeniowe w jasnym, przejrzystym pliku konfiguracyjnym
-3. **Automatyczne tłumaczenie**: Prześlij swoją treść raz i pozwól Languine automatycznie zająć się tłumaczeniem na wszystkie docelowe języki
-
----
-
-## Jak zacząć
-
-Rozpocznij swoją podróż lokalizacyjną z naszym przewodnikiem [Szybki start](/docs/quickstart) - Twoje pierwsze tłumaczenia będą działać w kilka minut.
-
-Zbadaj naszą obszerną dokumentację, aby opanować możliwości Languine:
-
-- [Konfiguracja](/docs/configuration) - Skonfiguruj Languine do potrzeb Twojego projektu
-- [CLI](/docs/cli) - Opanuj nasz potężny interfejs wiersza poleceń
-- [Github Actions](/docs/github-actions) - Automatyzuj tłumaczenia za pomocą naszej akcji Github
diff --git a/apps/web/src/markdown/docs/pl/ios.mdx b/apps/web/src/markdown/docs/pl/ios.mdx
deleted file mode 100644
index 12a47d08..00000000
--- a/apps/web/src/markdown/docs/pl/ios.mdx
+++ /dev/null
@@ -1,39 +0,0 @@
-# iOS
-
-Languine obsługuje pliki Localizable.strings dla iOS, standardowy format lokalizacji dla aplikacji iOS. Format ten obsługuje podstawowe pary klucz-wartość i wspiera komentarze, które dostarczają kontekstu dla tłumaczy.
-
----
-
-## Konfiguracja
-
-Najpierw upewnij się, że masz plik konfiguracyjny languine.json w głównym katalogu projektu. Oto przykład:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "ios": {
-      "include": ["[locale].lproj/Localizable.strings"]
-    }
-  }
-}
-```
-
-## Tłumaczenie
-
-Po ustawieniu konfiguracji uruchom:
-
-```bash
-npx languine@latest translate
-```
-
-Kiedy uruchomisz to polecenie, Languine:
-
-- Załaduje twój źródłowy plik Localizable.strings (np. en.lproj/Localizable.strings)
-- Wykryje wszelkie nowe lub zmodyfikowane ciągi tłumaczeń
-- Wygeneruje tłumaczenia dla twoich docelowych języków
-- Utworzy lub zaktualizuje pliki językowe docelowe (np. sv.lproj/Localizable.strings)
-- Zachowa wszelkie istniejące komentarze i formatowanie
diff --git a/apps/web/src/markdown/docs/pl/js.mdx b/apps/web/src/markdown/docs/pl/js.mdx
deleted file mode 100644
index 2b53df1e..00000000
--- a/apps/web/src/markdown/docs/pl/js.mdx
+++ /dev/null
@@ -1,42 +0,0 @@
-# JavaScript
-
-Languine obsługuje pliki lokalizacyjne JavaScript/TypeScript, idealne do nowoczesnych aplikacji internetowych. Ten format obsługuje zarówno literały obiektów, jak i eksporty modułów, wspierając zagnieżdżone struktury oraz dynamiczne treści.
-
----
-
-## Konfiguracja
-
-Najpierw upewnij się, że masz plik konfiguracyjny languine.json w głównym katalogu projektu. Oto przykład:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "js": {
-      "include": ["src/locales/[locale].js"]
-    }
-  }
-}
-```
-
-## Tłumaczenie
-
-Po ustawieniu konfiguracji uruchom:
-
-```bash
-npx languine@latest translate
-```
-
-Kiedy uruchomisz to polecenie, Languine:
-
-- Załaduje Twoje źródłowe pliki JavaScript (np. src/locales/en.js)
-- Wykryje wszelkie nowe lub zmodyfikowane ciągi tłumaczeń
-- Wygeneruje tłumaczenia dla Twoich docelowych języków
-- Utworzy lub zaktualizuje pliki językowe docelowe (np. src/locales/sv.js)
-- Zachowa strukturę modułów i eksporty
-- Obsłuży zagnieżdżone obiekty i tablice
-- Utrzyma formatowanie kodu i komentarze
-- Wygeneruje typy TypeScript, jeśli są włączone
diff --git a/apps/web/src/markdown/docs/pl/json.mdx b/apps/web/src/markdown/docs/pl/json.mdx
deleted file mode 100644
index ea9ed778..00000000
--- a/apps/web/src/markdown/docs/pl/json.mdx
+++ /dev/null
@@ -1,41 +0,0 @@
-# JSON
-
-Languine obsługuje pliki JSON jako format źródłowy z powszechnymi wymaganiami dotyczącymi pluralizacji i interpolacji. Format ten jest używany w wielu frameworkach, takich jak React, Vue, Ruby on Rails i innych.
-
-
----
-
-
-## Konfiguracja
-
-Najpierw upewnij się, że masz plik konfiguracyjny languine.json w katalogu głównym projektu. Oto przykład:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "json": {
-      "include": ["locales/[locale].json"]
-    }
-  }
-}
-
-```
-
-## Tłumaczenie
-
-Po ustawieniu konfiguracji uruchom:
-
-```bash
-npx languine@latest translate
-```
-
-Gdy uruchomisz to polecenie, Languine:
-
-- Załaduje twój źródłowy plik JSON (np. locales/en.json)
-- Wykryje wszelkie nowe lub zmodyfikowane ciągi tłumaczeń
-- Wygeneruje tłumaczenia dla twoich docelowych języków
-- Utworzy lub zaktualizuje pliki JSON dla języków docelowych (np. locales/sv.json, locales/de.json, locales/fr.json)
diff --git a/apps/web/src/markdown/docs/pl/md.mdx b/apps/web/src/markdown/docs/pl/md.mdx
deleted file mode 100644
index 32ee5899..00000000
--- a/apps/web/src/markdown/docs/pl/md.mdx
+++ /dev/null
@@ -1,43 +0,0 @@
-# Markdown
-
-Languine wspiera lokalizację plików Markdown, idealną do dokumentacji, postów na blogu i stron z dużą ilością treści. Ten format zachowuje składnię Markdown podczas tłumaczenia treści, w tym wsparcie dla front matter.
-
----
-
-## Konfiguracja
-
-Najpierw upewnij się, że masz plik konfiguracyjny languine.json w głównym katalogu projektu. Oto przykład:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "md": {
-      "include": ["content/[locale]/**/*.md"]
-    }
-  }
-}
-```
-
-## Tłumaczenie
-
-Po ustawieniu konfiguracji uruchom:
-
-```bash
-npx languine@latest translate
-```
-
-Kiedy uruchomisz to polecenie, Languine:
-
-- Załaduje twoje źródłowe pliki Markdown (np. content/en/*.md)
-- Wykryje wszelkie nowe lub zmodyfikowane treści
-- Wygeneruje tłumaczenia dla twoich docelowych języków
-- Utworzy lub zaktualizuje pliki w docelowym języku (np. content/sv/*.md)
-- Zachowa formatowanie i strukturę Markdown
-- Obsłuży tłumaczenia front matter
-- Utrzyma linki i odniesienia
-- Zachowa bloki kodu nietłumaczone
-- Zachowa HTML w Markdown
diff --git a/apps/web/src/markdown/docs/pl/mdx.mdx b/apps/web/src/markdown/docs/pl/mdx.mdx
deleted file mode 100644
index 53fe183e..00000000
--- a/apps/web/src/markdown/docs/pl/mdx.mdx
+++ /dev/null
@@ -1,43 +0,0 @@
-# Markdown (MDX)
-
-Languine wspiera lokalizację plików Markdown (MDX), idealną do dokumentacji, postów na blogach i stron z dużą ilością treści. Ten format zachowuje składnię Markdown podczas tłumaczenia treści, w tym wsparcie dla front matter.
-
----
-
-## Konfiguracja
-
-Najpierw upewnij się, że masz plik konfiguracyjny languine.json w katalogu głównym projektu. Oto przykład:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "mdx": {
-      "include": ["content/[locale]/**/*.mdx"]
-    }
-  }
-}
-```
-
-## Tłumaczenie
-
-Po ustawieniu konfiguracji uruchom:
-
-```bash
-npx languine@latest translate
-```
-
-Kiedy uruchomisz to polecenie, Languine:
-
-- Załaduje twoje źródłowe pliki Markdown (np. content/en/*.mdx)
-- Wykryje wszelkie nowe lub zmodyfikowane treści
-- Wygeneruje tłumaczenia dla twoich docelowych języków
-- Utworzy lub zaktualizuje pliki języków docelowych (np. content/sv/*.mdx)
-- Zachowa formatowanie i strukturę Markdown
-- Obsłuży tłumaczenia front matter
-- Utrzyma linki i odniesienia
-- Zachowa bloki kodu nietłumaczone
-- Zachowa HTML w Markdown
diff --git a/apps/web/src/markdown/docs/pl/overrides.mdx b/apps/web/src/markdown/docs/pl/overrides.mdx
deleted file mode 100644
index 324da70b..00000000
--- a/apps/web/src/markdown/docs/pl/overrides.mdx
+++ /dev/null
@@ -1,7 +0,0 @@
-# Nadpisy
-
-Languine pozwala na nadpisywanie tłumaczeń dla konkretnych kluczy. Jest to przydatne, gdy chcesz zapewnić, że konkretne tłumaczenie jest używane dla danego klucza, niezależnie od domyślnego tłumaczenia.
-
-## Jak to działa
-
-W panelu sterowania możesz tworzyć nadpisania dla konkretnych kluczy. Możesz również tworzyć nadpisania dla konkretnych języków.
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/pl/po.mdx b/apps/web/src/markdown/docs/pl/po.mdx
deleted file mode 100644
index 6a540f10..00000000
--- a/apps/web/src/markdown/docs/pl/po.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# PO (Gettext)
-
-Languine obsługuje pliki PO, powszechnie używany format lokalizacji Gettext. Format ten jest popularny w wielu środowiskach programistycznych, szczególnie w aplikacjach Linux i frameworkach PHP, oferując wsparcie dla kontekstu, liczby mnogiej oraz komentarzy tłumaczy.
-
----
-
-## Konfiguracja
-
-Najpierw upewnij się, że masz plik konfiguracyjny languine.json w katalogu głównym projektu. Oto przykład:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "po": {
-      "include": ["locales/[locale]/LC_MESSAGES/messages.po"]
-    }
-  }
-}
-```
-
-## Tłumaczenie
-
-Po ustawieniu konfiguracji uruchom:
-
-```bash
-npx languine@latest translate
-```
-
-Kiedy uruchomisz to polecenie, Languine:
-
-- Załaduje twój źródłowy plik PO (np. locales/en/LC_MESSAGES/messages.po)
-- Wykryje nowe lub zmodyfikowane ciągi tłumaczeń
-- Wygeneruje tłumaczenia dla twoich docelowych języków
-- Utworzy lub zaktualizuje pliki PO dla języków docelowych (np. locales/sv/LC_MESSAGES/messages.po)
-- Zachowa metadane, konteksty i formy liczby mnogiej
-- Utrzyma komentarze tłumaczy i informacje referencyjne
diff --git a/apps/web/src/markdown/docs/pl/prettier.mdx b/apps/web/src/markdown/docs/pl/prettier.mdx
deleted file mode 100644
index 78759c12..00000000
--- a/apps/web/src/markdown/docs/pl/prettier.mdx
+++ /dev/null
@@ -1,22 +0,0 @@
-# Prettier
-
-Languine może współpracować z [Prettier](https://prettier.io/), aby zapewnić, że Twoje pliki tłumaczeń są konsekwentnie sformatowane. Jest to szczególnie przydatne podczas pracy z plikami tłumaczeń JSON, które muszą utrzymywać spójny styl w całym projekcie.
-
-## Używanie z Languine
-
-Zalecany sposób używania Prettier z Languine to formatowanie plików tłumaczeń po ich wygenerowaniu. Możesz to skonfigurować w swoim `package.json`:
-
-```json title="package.json"
-{
-  "scripts": {
-    "translate": "languine translate",
-    "format": "prettier --write \"locales/**/*.json\"",
-    "translate:format": "npm run translate && npm run format"
-  }
-}
-```
-
-Teraz możesz:
-- Uruchomić `npm run translate`, aby tylko wygenerować tłumaczenia
-- Uruchomić `npm run format`, aby tylko sformatować istniejące pliki tłumaczeń
-- Uruchomić `npm run translate:format`, aby wygenerować tłumaczenia i sformatować je w kolejności
diff --git a/apps/web/src/markdown/docs/pl/properties.mdx b/apps/web/src/markdown/docs/pl/properties.mdx
deleted file mode 100644
index 1fab917f..00000000
--- a/apps/web/src/markdown/docs/pl/properties.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# Właściwości
-
-Languine obsługuje pliki Java Properties, standardowy format lokalizacji dla aplikacji Java. Ten format obsługuje ucieczkę Unicode i wspiera zarówno pary klucz-wartość, jak i komentarze.
-
----
-
-## Konfiguracja
-
-Najpierw upewnij się, że masz plik konfiguracyjny languine.json w głównym katalogu projektu. Oto przykład:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "properties": {
-      "include": ["src/main/resources/messages_[locale].properties"]
-    }
-  }
-}
-```
-
-## Tłumaczenie
-
-Po ustawieniu konfiguracji uruchom:
-
-```bash
-npx languine@latest translate
-```
-
-Kiedy uruchomisz to polecenie, Languine:
-
-- Załaduje twój plik źródłowy properties (np. messages_en.properties)
-- Wykryje wszelkie nowe lub zmodyfikowane ciągi tłumaczeń
-- Wygeneruje tłumaczenia dla twoich docelowych języków
-- Utworzy lub zaktualizuje pliki properties dla języków docelowych (np. messages_sv.properties)
-- Automatycznie obsłuży ucieczkę Unicode
-- Zachowa komentarze i formatowanie
diff --git a/apps/web/src/markdown/docs/pl/quickstart.mdx b/apps/web/src/markdown/docs/pl/quickstart.mdx
deleted file mode 100644
index a6181903..00000000
--- a/apps/web/src/markdown/docs/pl/quickstart.mdx
+++ /dev/null
@@ -1,65 +0,0 @@
-# Szybki start
-
-Zacznij od zainstalowania Languine.
-
-Następnie uruchom następujące polecenie, aby zainicjować Languine.
-
-```bash title="Terminal"
-npx languine@latest init
-```
-
-Postępuj zgodnie z krokami, aby skonfigurować swój projekt.
-
----
-
-## Pierwsze tłumaczenie
-
-Teraz jesteś gotowy do przetłumaczenia swojego kodu.
-
-Zacznij od dodania klucza do swojego pliku źródłowego, na przykład, jeśli zdecydujesz się użyć `en.json` jako swojego pliku źródłowego, dodaj do niego klucz.
-
-```json title="src/locales/en.json"
-{
-  "welcome": "Witamy w naszej aplikacji!",
-  "user": {
-    "greeting": "Cześć, {{name}}!",
-    "profile": {
-      "title": "Twój profil",
-      "edit": "Edytuj profil"
-    }
-  },
-  "notifications": {
-    "messages": "Masz {{count}} nową wiadomość(-i).",
-    "empty": "Brak nowych powiadomień."
-  }
-}
-
-```
-
----
-
-## Tłumaczenie
-
-Uruchom następujące polecenie, aby przetłumaczyć swoją treść:
-
-```bash title="Terminal"
-npx languine@latest translate
-```
-
-## To spowoduje:
-1. Utworzenie plików tłumaczeń dla każdego docelowego języka
-2. Wygenerowanie wysokiej jakości tłumaczeń przez silnik Languine
-3. Utworzenie pliku `languine.lock`, aby śledzić stany tłumaczeń
-
-Plik blokady pomaga Languine zidentyfikować, które tłumaczenia wymagają aktualizacji, gdy zmienia się Twoja treść źródłowa. Upewnij się, że dodasz ten plik do swojego repozytorium.
-
----
-
-## Następne kroki
-
-Teraz, gdy masz skonfigurowane Languine, możesz:
-- Dodać więcej języków w swoim pliku `languine.json`
-- Zintegrować Languine z Twoim procesem CI/CD
-- Użyć naszego API do programatycznych tłumaczeń
-
-Sprawdź nasze inne przewodniki, aby dowiedzieć się więcej o zaawansowanych funkcjach Languine.
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/pl/react-email.mdx b/apps/web/src/markdown/docs/pl/react-email.mdx
deleted file mode 100644
index 6eaea6e5..00000000
--- a/apps/web/src/markdown/docs/pl/react-email.mdx
+++ /dev/null
@@ -1,41 +0,0 @@
-# React Email
-
-Languine obsługuje szablony e-mailowe React, umożliwiając zarządzanie tłumaczeniami dla szablonów e-mailowych stworzonych za pomocą React Email. Ta integracja obsługuje zarówno treść tekstową, jak i atrybuty HTML, zachowując strukturę komponentów React.
-
----
-
-## Konfiguracja
-
-Najpierw upewnij się, że masz plik konfiguracyjny languine.json w katalogu głównym projektu. Oto przykład:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "react-email": {
-      "include": ["emails/[locale]/*.tsx"]
-    }
-  }
-}
-```
-
-## Tłumaczenie
-
-Po ustawieniu konfiguracji uruchom:
-
-```bash
-npx languine@latest translate
-```
-
-Kiedy uruchomisz to polecenie, Languine:
-
-- Załaduje twoje źródłowe szablony e-mailowe React (np. emails/en/*.tsx)
-- Wykryje wszelkie nowe lub zmodyfikowane ciągi tłumaczeń
-- Wygeneruje tłumaczenia dla twoich docelowych języków
-- Utworzy lub zaktualizuje szablony e-mailowe w docelowym języku (np. emails/sv/*.tsx)
-- Zachowa strukturę komponentów React i właściwości
-- Utrzyma formatowanie i styl HTML
-- Obsłuży interpolację i dynamiczną treść
diff --git a/apps/web/src/markdown/docs/pl/ts.mdx b/apps/web/src/markdown/docs/pl/ts.mdx
deleted file mode 100644
index 77f41abd..00000000
--- a/apps/web/src/markdown/docs/pl/ts.mdx
+++ /dev/null
@@ -1,42 +0,0 @@
-# TypeScript
-
-Languine obsługuje pliki lokalizacyjne TypeScript z pełnym bezpieczeństwem typów. Ten format rozszerza wsparcie dla JavaScript o dodatkowe funkcje specyficzne dla TypeScript oraz możliwości generowania typów.
-
----
-
-## Konfiguracja
-
-Najpierw upewnij się, że masz plik konfiguracyjny languine.json w głównym katalogu projektu. Oto przykład:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "ts": {
-      "include": ["src/locales/[locale].ts"]
-    }
-  }
-}
-```
-
-## Tłumaczenie
-
-Po ustawieniu konfiguracji uruchom:
-
-```bash
-npx languine@latest translate
-```
-
-Kiedy uruchomisz to polecenie, Languine:
-
-- Załaduje Twoje źródłowe pliki TypeScript (np. src/locales/en.ts)
-- Wykryje wszelkie nowe lub zmodyfikowane ciągi tłumaczeń
-- Wygeneruje tłumaczenia dla Twoich docelowych języków
-- Utworzy lub zaktualizuje pliki języków docelowych (np. src/locales/sv.ts)
-- Zachowa adnotacje typów i interfejsy
-- Obsłuży zagnieżdżone obiekty z odpowiednim typowaniem
-- Utrzyma formatowanie kodu i komentarze dokumentacyjne
-- Wspiera typy dosłowne i typy unijne
diff --git a/apps/web/src/markdown/docs/pl/xcode-stringsdict.mdx b/apps/web/src/markdown/docs/pl/xcode-stringsdict.mdx
deleted file mode 100644
index 7dad3bbc..00000000
--- a/apps/web/src/markdown/docs/pl/xcode-stringsdict.mdx
+++ /dev/null
@@ -1,44 +0,0 @@
-# Xcode Stringsdict
-
-Languine obsługuje format Stringsdict Xcode, używany do złożonych reguł pluralizacji w aplikacjach iOS i macOS. Ten format obsługuje formy mnogie, podstawienia zmiennych oraz specyficzne dla języka reguły pluralizacji.
-
----
-
-## Konfiguracja
-
-Najpierw upewnij się, że masz plik konfiguracyjny languine.json w głównym katalogu projektu. Oto przykład:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "stringsdict": {
-      "include": ["MyApp/Localizable.stringsdict"]
-    }
-  }
-}
-```
-
-## Tłumaczenie
-
-Gdy masz ustawioną konfigurację, uruchom:
-
-```bash
-npx languine@latest translate
-```
-
-Kiedy uruchomisz to polecenie, Languine:
-
-- Załaduje twoje pliki Stringsdict
-- Wykryje wszelkie nowe lub zmodyfikowane reguły pluralizacji
-- Wygeneruje tłumaczenia dla twoich docelowych języków
-- Zaktualizuje pliki Stringsdict o nowe tłumaczenia
-- Obsłuży złożone reguły pluralizacji dla każdego języka
-- Utrzyma podstawienia zmiennych
-- Zachowa strukturę słownika
-- Wspiera specyficzne dla języka formy mnogie
-- Zweryfikuje spójność reguł pluralizacji
-- Zachowa specyfikatory formatowania
diff --git a/apps/web/src/markdown/docs/pl/xcode-xcstrings.mdx b/apps/web/src/markdown/docs/pl/xcode-xcstrings.mdx
deleted file mode 100644
index ea60adfe..00000000
--- a/apps/web/src/markdown/docs/pl/xcode-xcstrings.mdx
+++ /dev/null
@@ -1,44 +0,0 @@
-# Xcode Strings (XCStrings)
-
-Languine obsługuje format XCStrings Xcode, nowoczesny format lokalizacji dla aplikacji iOS i macOS. Format ten obsługuje katalogi ciągów z wsparciem dla wariantów, pluralizacji i komentarzy deweloperów.
-
----
-
-## Konfiguracja
-
-Najpierw upewnij się, że masz plik konfiguracyjny languine.json w głównym katalogu projektu. Oto przykład:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "xcstrings": {
-      "include": ["MyApp/Localizable.xcstrings"]
-    }
-  }
-}
-```
-
-## Tłumaczenie
-
-Po ustawieniu konfiguracji uruchom:
-
-```bash
-npx languine@latest translate
-```
-
-Gdy uruchomisz to polecenie, Languine:
-
-- Załaduje twój katalog XCStrings
-- Wykryje wszelkie nowe lub zmodyfikowane ciągi
-- Wygeneruje tłumaczenia dla twoich docelowych języków
-- Zaktualizuje katalog ciągów o nowe tłumaczenia
-- Zachowa warianty ciągów i zasady pluralizacji
-- Utrzyma komentarze deweloperów i kontekst
-- Obsłuży podstawienia zmiennych
-- Wspiera adaptacyjne ciągi
-- Zachowa specyfikatory formatowania
-- Zweryfikuje strukturę katalogu ciągów
diff --git a/apps/web/src/markdown/docs/pl/xliff.mdx b/apps/web/src/markdown/docs/pl/xliff.mdx
deleted file mode 100644
index d056d173..00000000
--- a/apps/web/src/markdown/docs/pl/xliff.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# XLIFF
-
-Languine obsługuje XLIFF (XML Localization Interchange File Format), oparty na XML format zaprojektowany do wymiany danych lokalizacyjnych. Format ten jest szeroko stosowany w profesjonalnych procesach tłumaczeniowych i obsługuje zarówno wersje XLIFF 1.2, jak i 2.0.
-
----
-
-## Konfiguracja
-
-Najpierw upewnij się, że masz plik konfiguracyjny languine.json w głównym katalogu projektu. Oto przykład:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "xliff": {
-      "include": ["locales/[locale].xlf"]
-    }
-  }
-}
-```
-
-## Tłumaczenie
-
-Po ustawieniu konfiguracji uruchom:
-
-```bash
-npx languine@latest translate
-```
-
-Kiedy uruchomisz to polecenie, Languine:
-
-- Załaduje twój źródłowy plik XLIFF (np. locales/en.xlf)
-- Wykryje nowe lub zmodyfikowane jednostki tłumaczeniowe
-- Wygeneruje tłumaczenia dla twoich docelowych języków
-- Utworzy lub zaktualizuje pliki XLIFF dla docelowego języka (np. locales/sv.xlf)
-- Zachowa notatki, informacje kontekstowe i atrybuty stanu
-- Utrzyma zgodność z narzędziami CAT (Computer-Aided Translation)
diff --git a/apps/web/src/markdown/docs/pl/xml.mdx b/apps/web/src/markdown/docs/pl/xml.mdx
deleted file mode 100644
index 0c40d446..00000000
--- a/apps/web/src/markdown/docs/pl/xml.mdx
+++ /dev/null
@@ -1,44 +0,0 @@
-# XML
-
-Languine wspiera lokalizację plików XML, odpowiednią dla różnych plików konfiguracyjnych i treści opartych na XML. Ten format obsługuje złożone struktury XML, zachowując formatowanie i atrybuty.
-
----
-
-## Konfiguracja
-
-Najpierw upewnij się, że masz plik konfiguracyjny languine.json w głównym katalogu projektu. Oto przykład:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "xml": {
-      "include": ["resources/[locale]/*.xml"]
-    }
-  }
-}
-```
-
-## Tłumaczenie
-
-Po ustawieniu konfiguracji uruchom:
-
-```bash
-npx languine@latest translate
-```
-
-Kiedy uruchomisz to polecenie, Languine:
-
-- Załaduje twoje źródłowe pliki XML (np. resources/en/*.xml)
-- Wykryje wszelkie nowe lub zmodyfikowane treści
-- Wygeneruje tłumaczenia dla twoich docelowych języków
-- Utworzy lub zaktualizuje pliki języków docelowych (np. resources/sv/*.xml)
-- Zachowa strukturę i formatowanie XML
-- Obsłuży tłumaczenia atrybutów
-- Utrzyma sekcje CDATA
-- Zachowa komentarze XML
-- Wspiera przestrzenie nazw XML
-- Zweryfikuje strukturę XML
diff --git a/apps/web/src/markdown/docs/pl/yaml.mdx b/apps/web/src/markdown/docs/pl/yaml.mdx
deleted file mode 100644
index 7927fa37..00000000
--- a/apps/web/src/markdown/docs/pl/yaml.mdx
+++ /dev/null
@@ -1,39 +0,0 @@
-# YAML
-
-Languine obsługuje pliki YAML jako format źródłowy, który jest powszechnie używany w Ruby on Rails, Laravel i innych frameworkach. Ten format obsługuje zagnieżdżone struktury, tablice i złożone typy danych.
-
----
-
-## Konfiguracja
-
-Najpierw upewnij się, że masz plik konfiguracyjny languine.json w głównym katalogu projektu. Oto przykład:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "yaml": {
-      "include": ["config/locales/[locale].yml"]
-    }
-  }
-}
-```
-
-## Tłumaczenie
-
-Po ustawieniu konfiguracji uruchom:
-
-```bash
-npx languine@latest translate
-```
-
-Kiedy uruchomisz to polecenie, Languine:
-
-- Załaduje twój źródłowy plik YAML (np. config/locales/en.yml)
-- Wykryje nowe lub zmodyfikowane ciągi tłumaczeń
-- Wygeneruje tłumaczenia dla twoich docelowych języków
-- Utworzy lub zaktualizuje pliki YAML dla języków docelowych (np. config/locales/sv.yml)
-- Zachowa zagnieżdżone struktury i formatowanie
diff --git a/apps/web/src/markdown/docs/pt-BR/csv.mdx b/apps/web/src/markdown/docs/pt-BR/csv.mdx
deleted file mode 100644
index e424a5b9..00000000
--- a/apps/web/src/markdown/docs/pt-BR/csv.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# CSV
-
-Languine suporta arquivos CSV (Comma-Separated Values) para gerenciamento simples de traduções. Este formato é ideal para fluxos de trabalho baseados em planilhas e fácil integração com ferramentas de tradução externas.
-
----
-
-## Configurando
-
-Primeiro, certifique-se de que você tem um arquivo de configuração languine.config.json ou languine.config.ts na raiz do seu projeto. Aqui está um exemplo:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "csv": {
-      "include": ["translations/[locale].csv"]
-    }
-  }
-}
-```
-
-## Traduzindo
-
-Com sua configuração definida, execute:
-
-```bash
-npx languine@latest translate
-```
-
-Quando você executar este comando, o Languine irá:
-
-- Carregar seu arquivo CSV de origem (por exemplo, translations/en.csv)
-- Detectar quaisquer novas ou modificadas strings de tradução
-- Gerar traduções para seus idiomas-alvo
-- Criar ou atualizar os arquivos CSV dos idiomas-alvo (por exemplo, translations/sv.csv)
-- Manter a estrutura e formatação das colunas
-- Preservar quaisquer colunas de metadados adicionais
diff --git a/apps/web/src/markdown/docs/pt-BR/ios.mdx b/apps/web/src/markdown/docs/pt-BR/ios.mdx
deleted file mode 100644
index e38c9892..00000000
--- a/apps/web/src/markdown/docs/pt-BR/ios.mdx
+++ /dev/null
@@ -1,39 +0,0 @@
-# iOS
-
-Languine suporta arquivos Localizable.strings do iOS, o formato padrão de localização para aplicativos iOS. Este formato lida com pares de chave-valor básicos e suporta comentários para fornecer contexto aos tradutores.
-
----
-
-## Configurando
-
-Primeiro, certifique-se de que você tem um arquivo de configuração languine.config.json ou languine.config.ts na raiz do seu projeto. Aqui está um exemplo:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "ios": {
-      "include": ["[locale].lproj/Localizable.strings"]
-    }
-  }
-}
-```
-
-## Traduzindo
-
-Com sua configuração definida, execute:
-
-```bash
-npx languine@latest translate
-```
-
-Quando você executar este comando, o Languine irá:
-
-- Carregar seu arquivo Localizable.strings de origem (por exemplo, en.lproj/Localizable.strings)
-- Detectar quaisquer novas ou modificadas strings de tradução
-- Gerar traduções para seus idiomas-alvo
-- Criar ou atualizar os arquivos de idioma-alvo (por exemplo, sv.lproj/Localizable.strings)
-- Preservar quaisquer comentários e formatação existentes
diff --git a/apps/web/src/markdown/docs/pt-BR/quickstart.mdx b/apps/web/src/markdown/docs/pt-BR/quickstart.mdx
deleted file mode 100644
index 5494c589..00000000
--- a/apps/web/src/markdown/docs/pt-BR/quickstart.mdx
+++ /dev/null
@@ -1,60 +0,0 @@
-# Introdução Rápida
-
-Comece instalando o Languine.
-
-Em seguida, execute o seguinte comando para inicializar o Languine.
-
-```bash title="Terminal"
-npx languine@latest init
-```
-
-Siga os passos para configurar seu projeto.
-
-## Primeira Tradução
-
-Agora você está pronto para traduzir seu código.
-
-Comece adicionando uma chave ao seu arquivo de origem, por exemplo, se você optar por usar `en.json` como seu arquivo de origem, adicione uma chave a ele.
-
-```json title="src/locales/en.json"
-{
-  "welcome": "Bem-vindo ao nosso aplicativo!",
-  "user": {
-    "greeting": "Oi, {{name}}!",
-    "profile": {
-      "title": "Seu perfil",
-      "edit": "Editar perfil"
-    }
-  },
-  "notifications": {
-    "messages": "Você tem {{count}} nova(s) mensagem(ns).",
-    "empty": "Sem novas notificações."
-  }
-}
-
-```
-
-
-## Traduzir
-
-Execute o seguinte comando para traduzir seu conteúdo:
-
-```bash title="Terminal"
-npx languine@latest translate
-```
-
-## Isso irá:
-1. Criar arquivos de tradução para cada idioma de destino
-2. Gerar traduções de alta qualidade com o Languine Engine
-3. Criar um arquivo `languine.lock` para rastrear os estados de tradução
-
-O arquivo de bloqueio ajuda o Languine a identificar quais traduções precisam de atualizações quando seu conteúdo de origem muda. Certifique-se de commitar este arquivo em seu repositório.
-
-## Próximos Passos
-
-Agora que você configurou o Languine, você pode:
-- Adicionar mais idiomas no seu arquivo `languine.config.json`
-- Integrar o Languine em seu pipeline de CI/CD
-- Usar nossa API para traduções programáticas
-
-Confira nossos outros guias para aprender mais sobre os recursos avançados do Languine.
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/pt/android.mdx b/apps/web/src/markdown/docs/pt/android.mdx
deleted file mode 100644
index fae67113..00000000
--- a/apps/web/src/markdown/docs/pt/android.mdx
+++ /dev/null
@@ -1,39 +0,0 @@
-# Android
-
-Languine suporta recursos de string do Android (strings.xml) como um formato de origem, lidando com plurais, arrays de strings e strings formatadas. Este formato é a maneira padrão de gerenciar traduções em aplicativos Android.
-
----
-
-## Configurando
-
-Primeiro, certifique-se de que você tem um arquivo de configuração languine.json na raiz do seu projeto. Aqui está um exemplo:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "android": {
-      "include": ["app/src/main/res/values-[locale]/strings.xml"]
-    }
-  }
-}
-```
-
-## Traduzindo
-
-Com sua configuração definida, execute:
-
-```bash
-npx languine@latest translate
-```
-
-Quando você executar este comando, Languine irá:
-
-- Carregar seu arquivo strings.xml de origem (por exemplo, values/strings.xml)
-- Detectar quaisquer novas ou modificadas strings de tradução
-- Gerar traduções para seus idiomas-alvo
-- Criar ou atualizar os arquivos XML do idioma-alvo (por exemplo, values-sv/strings.xml, values-de/strings.xml, values-fr/strings.xml)
-- Preservar qualquer formatação existente de arrays de strings e plurais
diff --git a/apps/web/src/markdown/docs/pt/arb.mdx b/apps/web/src/markdown/docs/pt/arb.mdx
deleted file mode 100644
index 283e2190..00000000
--- a/apps/web/src/markdown/docs/pt/arb.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# ARB (Pacote de Recursos da Aplicação)
-
-Languine suporta arquivos ARB, o formato padrão de localização para aplicações Flutter. Este formato lida com plurais, espaços reservados e expressões de seleção, mantendo a compatibilidade com o pacote intl do Flutter.
-
----
-
-## Configurando
-
-Primeiro, certifique-se de que você tem um arquivo de configuração languine.json na raiz do seu projeto. Aqui está um exemplo:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "arb": {
-      "include": ["lib/l10n/intl_[locale].arb"]
-    }
-  }
-}
-```
-
-## Traduzindo
-
-Com sua configuração definida, execute:
-
-```bash
-npx languine@latest translate
-```
-
-Quando você executar este comando, o Languine irá:
-
-- Carregar seu arquivo ARB de origem (por exemplo, lib/l10n/intl_en.arb)
-- Detectar quaisquer novas ou modificadas strings de tradução
-- Gerar traduções para seus idiomas-alvo
-- Criar ou atualizar os arquivos ARB dos idiomas-alvo (por exemplo, lib/l10n/intl_sv.arb)
-- Preservar metadados, espaços reservados e expressões de plural/seleção
-
diff --git a/apps/web/src/markdown/docs/pt/authentication.mdx b/apps/web/src/markdown/docs/pt/authentication.mdx
deleted file mode 100644
index 62860cb7..00000000
--- a/apps/web/src/markdown/docs/pt/authentication.mdx
+++ /dev/null
@@ -1,48 +0,0 @@
-# Autenticação
-
-Para usar o Languine, você precisa se autenticar com nosso Engine, leva apenas alguns segundos para começar.
-
----
-
-## Fazer login
-
-Você pode fazer login diretamente no [Painel do Languine](https://languine.ai/login) ou executar o seguinte comando:
-
-```bash title="Terminal"
-npx languine@latest auth login
-```
-
-
-Se você já tiver uma conta, você será automaticamente conectado e uma sessão será salva em sua máquina.
-
----
-
-## Sair
-
-Você pode sair executando o seguinte comando:
-
-```bash title="Terminal"
-npx languine@latest auth logout
-```
-
----
-
-## Sessão do usuário
-
-Você pode verificar se está conectado executando o seguinte comando:
-
-```bash title="Terminal"
-npx languine@latest auth whoami
-```
-
----
-
-
-# Variáveis de Ambiente
-
-Você pode definir as seguintes variáveis de ambiente para configurar o Languine:
-
-- `LANGUINE_API_KEY`: A chave da API a ser usada para autenticação.
-- `LANGUINE_PROJECT_ID`: O ID do projeto a ser usado para o projeto.
-
-Você pode encontrá-las no [Painel do Languine](https://languine.ai/login).
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/pt/biome.mdx b/apps/web/src/markdown/docs/pt/biome.mdx
deleted file mode 100644
index dfb9a991..00000000
--- a/apps/web/src/markdown/docs/pt/biome.mdx
+++ /dev/null
@@ -1,24 +0,0 @@
-# Bioma
-
-Languine pode trabalhar em conjunto com [Biome](https://biomejs.dev/) para garantir que seus arquivos de tradução estejam formatados de maneira consistente. Isso é particularmente útil ao trabalhar com arquivos de tradução JSON que precisam manter um estilo consistente em todo o seu projeto.
-
-## Usando com Languine
-
-A maneira recomendada de usar o Biome com o Languine é formatar seus arquivos de tradução após serem gerados. Você pode configurar isso em seu `package.json`:
-
-```json title="package.json"
-{
-  "scripts": {
-    "translate": "languine translate",
-    "format": "biome format \"locales/**/*.json\"",
-    "translate:format": "npm run translate && npm run format"
-  }
-}
-```
-
-Agora você pode:
-- Executar `npm run translate` para gerar apenas traduções
-- Executar `npm run format` para formatar apenas arquivos de tradução existentes
-- Executar `npm run translate:format` para gerar traduções e formatá-las em sequência
-
-Essa configuração garantirá que seus arquivos de tradução sejam formatados de maneira consistente com indentação de 2 espaços e uma largura máxima de linha de 80 caracteres.
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/pt/ci.mdx b/apps/web/src/markdown/docs/pt/ci.mdx
deleted file mode 100644
index 8df15d03..00000000
--- a/apps/web/src/markdown/docs/pt/ci.mdx
+++ /dev/null
@@ -1,96 +0,0 @@
-# CI/CD
-
-Languine fornece uma integração CI/CD para ajudar você a traduzir seu aplicativo.
-
----
-
-## Como Funciona
-
-O fluxo de trabalho CI/CD no Languine segue um processo estruturado para automatizar as atualizações de tradução em seu aplicativo:
-
-### 1. Inicialização da Ação
-- O fluxo de trabalho começa quando a ação é acionada
-- Configura as credenciais e a configuração do Git necessárias
-
-### 2. Processamento do Motor Languine
-- O motor Languine processa o conteúdo do seu aplicativo
-- Realiza as tarefas de tradução usando as configurações configuradas
-
-### 3. Detecção de Mudanças
-O sistema verifica se há mudanças nas traduções e segue um de dois caminhos:
-
-**Quando Mudanças São Encontradas:**
-- As mudanças são confirmadas no repositório
-- As mudanças são enviadas para o branch especificado
-- Um Pull Request (PR) é criado
-
-**Quando Nenhuma Mudança é Encontrada:**
-- O fluxo de trabalho é concluído sem criar um PR
-
-### 4. Criação do Pull Request
-Quando mudanças são detectadas, um Pull Request é criado com:
-
-**Conteúdo do PR:**
-- Título claro indicando atualizações de tradução
-- Descrição detalhada das mudanças
-- Confirmações de verificação de qualidade
-- Instruções para revisão
-- Links para documentação e suporte
-
-**Descrição do PR Inclui:**
-- Resumo das atualizações de tradução
-- Lista do que mudou (traduções atualizadas, consistência de terminologia)
-- Próximos passos para os revisores
-- Links para documentação e recursos de suporte
-
----
-
-## Diagrama do Fluxo de Trabalho
-
-<div className="flex flex-col items-center justify-center p-4 h-[400px] sm:h-[500px] md:h-[650px]">
-  <pre
-    className="p-4 text-sm leading-5 mb-4 scale-[0.5] sm:scale-[0.65] md:scale-90 transform-gpu"
-    style={{
-      fontFamily: "monospace",
-      whiteSpace: "pre",
-      textAlign: "left",
-    }}
-  >
-    {`
-                    ┌─────────────────────┐
-                    │   Ação Iniciada     │
-                    └──────────┬──────────┘
-                               │
-                    ┌──────────▼──────────┐
-                    │    Configurar Git &  │
-                    │    Credenciais      │
-                    └──────────┬──────────┘
-                               │
-┌─────────────────────────────────────────────────────────┐
-│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-│░░░░░░░░░░░░░░░░░░░░ Motor Languine ░░░░░░░░░░░░░░░░░░░░│
-│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-└─────────────────────────────────────────────────────────┘
-                               │
-                    ┌──────────▼──────────┐
-                    │   Verificar Mudanças │───────┐
-                    └──────────┬──────────┘       │
-                               │                  │
-                               │ [Mudanças]        │ [Sem Mudanças]
-                               │                  │
-                    ┌──────────▼──────────┐       │
-                    │   Confirmar & Enviar │       │
-                    └──────────┬──────────┘       │
-                               │                  │
-                    ┌──────────▼──────────┐       │
-                    │    Criar PR         │       │
-                    └──────────┬──────────┘       │
-                               │                  │
-                    ┌──────────▼──────────┐       │
-                    │        Concluído     │◄──────┘
-                    └─────────────────────┘
-`}
-  </pre>
-</div>
-
-O fluxo de trabalho é projetado para ser automatizado, permitindo ainda a revisão humana e o controle de qualidade antes que as mudanças sejam mescladas ao seu código. Ele mantém as melhores práticas de controle de versão e garante que as traduções sejam devidamente rastreadas e documentadas através do histórico do Git.
diff --git a/apps/web/src/markdown/docs/pt/cli.mdx b/apps/web/src/markdown/docs/pt/cli.mdx
deleted file mode 100644
index 73952402..00000000
--- a/apps/web/src/markdown/docs/pt/cli.mdx
+++ /dev/null
@@ -1,65 +0,0 @@
-# CLI
-
-Languine fornece uma CLI para ajudar você a traduzir sua aplicação.
-
----
-
-## Visão Geral dos Comandos
-
-### Traduzir
-
-O comando `translate` é usado para traduzir sua aplicação.
-
-```bash title="Terminal"
-    npx languine@latest translate
-```
-
----
-
-### Inicializar
-
-O comando `init` é usado para inicializar um novo projeto Languine.
-
-```bash title="Terminal"
-    npx languine@latest init
-```
-
----
-
-### Autenticar
-
-O comando `auth` é usado para autenticar-se com o Languine.
-
-```bash title="Terminal"
-    npx languine@latest auth
-```
-
----
-
-### Sincronizar
-
-O comando `sync` é usado para sincronizar sua aplicação com o Languine.
-
-```bash title="Terminal"
-    npx languine@latest sync
-```
-
----
-
-### Adicionar Localidade
-
-O comando `locale` é usado para gerenciar as localidades da sua aplicação.
-
-```bash title="Terminal"
-    npx languine@latest locale add pt,fr
-```
-
----
-
-### Remover Localidade
-
-O comando `locale remove` é usado para remover uma localidade da sua aplicação.
-
-```bash title="Terminal"
-    npx languine@latest locale remove pt,fr
-```
diff --git a/apps/web/src/markdown/docs/pt/configuration.mdx b/apps/web/src/markdown/docs/pt/configuration.mdx
deleted file mode 100644
index 2c60150a..00000000
--- a/apps/web/src/markdown/docs/pt/configuration.mdx
+++ /dev/null
@@ -1,180 +0,0 @@
-# Configuração
-
-Languine utiliza um arquivo de configuração JSON (languine.json) para gerenciar sua configuração de tradução. Este arquivo define seus idiomas de origem e destino, bem como os arquivos que precisam ser traduzidos.
-
----
-
-## Configuração Básica
-
-Aqui está um exemplo básico em ambos os formatos:
-
-```json title="languine.json"
-{
-  "locale": {
-    "source": "en",
-    "targets": ["es", "fr", "de"]
-  },
-  "files": {
-    "json": {
-      "include": ["locales/[locale].json"]
-    }
-  }
-}
-```
-
-Vamos analisar as diferentes seções no arquivo de configuração.
-
----
-
-## Configuração de Localidade
-
-A seção de localidade define seus idiomas de tradução:
-
-- source: Seu idioma principal para criação de conteúdo (por exemplo, "en" para inglês)
-- targets: Um array de idiomas para os quais você deseja traduzir (por exemplo, ["es", "fr", "de"] para espanhol, francês e alemão)
-
-Languine suporta uma ampla gama de códigos de idiomas, incluindo:
-- Códigos simples: en, es, fr, de
-- Códigos específicos de região: pt-BR, zh-CN, zh-TW
-
-## Configuração de Arquivos
-
-A seção de arquivos define quais arquivos o Languine deve traduzir. Você pode configurar múltiplos tipos e padrões de arquivos:
-
----
-
-### Arquivos JSON
-```json
-files: {
-  json: {
-    include: ["locales/[locale].json"],
-  },
-}
-```
-
----
-
-### Arquivos Markdown/MDX
-```json
-files: {
-  md: {
-    include: ["docs/[locale]/*.md"],
-  },
-  mdx: {
-    include: ["blog/[locale]/*.mdx"],
-  },
-}
-```
-
----
-
-### Arquivos de Plataforma Móvel
-
-Para iOS (Xcode):
-```json
-files: {
-  "xcode-xcstrings": {
-    include: ["Example/Localizable.xcstrings"],
-  },
-  // Ou para arquivos .strings tradicionais
-  "xcode-strings": {
-    include: ["Example/[locale].lproj/Localizable.strings"],
-  },
-}
-```
-
----
-
-Para Android:
-```json
-files: {
-  android: {
-    include: ["locales/[locale].xml"],
-  },
-}
-```
-
----
-
-### Outros Formatos
-
-Aqui está uma lista completa de formatos de arquivo suportados pelo Languine:
-
-- [JSON](/docs/json) - Arquivos de tradução JSON padrão
-- [YAML](/docs/yaml) - Arquivos de tradução YAML
-- [Properties](/docs/properties) - Arquivos de propriedades Java
-- [Android](/docs/android) - Arquivos de recursos XML do Android
-- [iOS](/docs/ios) - Arquivos de localização do iOS
-- [iOS Stringsdict](/docs/xcode-stringsdict) - Arquivos de pluralização do iOS
-- [iOS XCStrings](/docs/xcode-xcstrings) - Catálogos de strings modernos do Xcode
-- [Markdown](/docs/md) - Arquivos de documentação
-- [MDX](/docs/mdx) - Documentação com JSX
-- [HTML](/docs/html) - Arquivos HTML
-- [JavaScript](/docs/js) - Arquivos JavaScript
-- [TypeScript](/docs/ts) - Arquivos TypeScript
-- [Gettext PO](/docs/po) - Arquivos de tradução GetText
-- [XLIFF](/docs/xliff) - Formato de Arquivo de Intercâmbio de Localização XML
-- [CSV](/docs/csv) - Traduções baseadas em planilhas
-- [XML](/docs/xml) - Arquivos de recursos XML
-- [Flutter ARB](/docs/arb) - Arquivos de Pacote de Recursos de Aplicação
-
----
-
-## Padrões de Arquivo
-
-O espaço reservado [locale] nos padrões de arquivo é automaticamente substituído pelo código de idioma apropriado durante a tradução. Por exemplo:
-
-- locales/[locale].json se torna:
-  - locales/en.json
-  - locales/es.json
-  - locales/fr.json
-
-Você pode incluir múltiplos padrões para cada tipo de arquivo e usar padrões glob:
-```json
-files: {
-  json: {
-    include: [
-      "src/locales/[locale].json",
-      "src/components/[locale]/*.json"
-    ],
-  },
-}
-```
-
----
-
-## ID do Projeto (Opcional)
-
-Se você estiver usando os serviços em nuvem do Languine, pode incluir seu ID de projeto na configuração:
-
-```json
-{
-  "projectId": "prj_your_project_id",
-  "locale": {
-    // ... configuração de localidade
-  },
-  files: {
-    // ... configuração de arquivos
-  },
-}
-```
-
----
-
-## Rastreamento do Estado de Tradução
-
-O Languine cria e mantém automaticamente um arquivo languine.lock para rastrear o estado de suas traduções. Este arquivo:
-
-- Rastreia qual conteúdo foi traduzido
-- Ajuda a identificar o que precisa ser atualizado quando o conteúdo de origem muda
-- Deve ser comprometido no seu sistema de controle de versão
-
-Você não precisa editar manualmente o arquivo de bloqueio - o Languine o gerencia automaticamente quando você executa comandos de tradução.
-
-## Melhores Práticas
-
-1. **Controle de Versão**: Sempre comprometa tanto o languine.json quanto o languine.lock em seu repositório
-2. **Organização de Arquivos**: Mantenha seus arquivos de tradução organizados em uma estrutura de diretório consistente
-3. **Códigos de Idioma**: Use códigos de idioma padrão para garantir compatibilidade
-4. **Padrões**: Use padrões de inclusão específicos para evitar traduzir arquivos desnecessários
-5. **ID do Projeto**: Mantenha seu ID de projeto seguro e não o compartilhe publicamente se estiver usando serviços em nuvem, use a variável de ambiente `LANGUINE_PROJECT_ID` em vez disso.
diff --git a/apps/web/src/markdown/docs/pt/csv.mdx b/apps/web/src/markdown/docs/pt/csv.mdx
deleted file mode 100644
index b0dfff5a..00000000
--- a/apps/web/src/markdown/docs/pt/csv.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# CSV
-
-Languine suporta arquivos CSV (Valores Separados por Vírgula) para gerenciamento simples de traduções. Este formato é ideal para fluxos de trabalho baseados em planilhas e fácil integração com ferramentas de tradução externas.
-
----
-
-## Configurando
-
-Primeiro, certifique-se de que você tem um arquivo de configuração languine.json na raiz do seu projeto. Aqui está um exemplo:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "csv": {
-      "include": ["translations/[locale].csv"]
-    }
-  }
-}
-```
-
-## Traduzindo
-
-Com sua configuração definida, execute:
-
-```bash
-npx languine@latest translate
-```
-
-Quando você executar este comando, o Languine irá:
-
-- Carregar seu arquivo CSV de origem (por exemplo, translations/en.csv)
-- Detectar quaisquer novas ou modificadas strings de tradução
-- Gerar traduções para seus idiomas-alvo
-- Criar ou atualizar os arquivos CSV dos idiomas-alvo (por exemplo, translations/sv.csv)
-- Manter a estrutura e formatação das colunas
-- Preservar quaisquer colunas de metadados adicionais
diff --git a/apps/web/src/markdown/docs/pt/expo.mdx b/apps/web/src/markdown/docs/pt/expo.mdx
deleted file mode 100644
index e65af4ae..00000000
--- a/apps/web/src/markdown/docs/pt/expo.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# Expo
-
-Languine suporta a localização do Expo, integrando-se perfeitamente ao sistema i18n do Expo. Este formato funciona tanto com projetos JavaScript quanto TypeScript, suportando estruturas aninhadas e pluralização.
-
----
-
-## Configurando
-
-Primeiro, certifique-se de que você tem um arquivo de configuração languine.json na raiz do seu projeto. Aqui está um exemplo:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "expo": {
-      "include": ["assets/locales/[locale].json"]
-    }
-  }
-}
-```
-
-## Traduzindo
-
-Com sua configuração definida, execute:
-
-```bash
-npx languine@latest translate
-```
-
-Quando você executar este comando, Languine irá:
-
-- Carregar seu arquivo de tradução fonte (por exemplo, assets/locales/en.json)
-- Detectar quaisquer novas ou modificadas strings de tradução
-- Gerar traduções para seus idiomas-alvo
-- Criar ou atualizar os arquivos de idioma-alvo (por exemplo, assets/locales/sv.json)
-- Preservar a estrutura aninhada e as regras de pluralização
-- Manter a compatibilidade com expo-localization
diff --git a/apps/web/src/markdown/docs/pt/github-actions.mdx b/apps/web/src/markdown/docs/pt/github-actions.mdx
deleted file mode 100644
index 244102cf..00000000
--- a/apps/web/src/markdown/docs/pt/github-actions.mdx
+++ /dev/null
@@ -1,147 +0,0 @@
-# GitHub Actions
-
-Com a ação do GitHub, você pode traduzir seu código facilmente apenas enviando seu código para o repositório; a ação do GitHub então traduz suas novas chaves, criando um pull request ou confirmando suas alterações.
-Isso economiza muito tempo e esforço, mantendo traduções de alta qualidade.
-
----
-
-## Como funciona
-
-
-
-<div className="flex flex-col items-center justify-center p-4 mb-8 h-[400px] sm:h-[500px] md:h-[650px]">
-        <pre
-          className="p-4 text-sm leading-5 scale-[0.5] sm:scale-[0.65] md:scale-90 transform-gpu"
-          style={{
-            fontFamily: "monospace",
-            whiteSpace: "pre",
-            textAlign: "left",
-          }}
-        >
-          {`
-                                  ┌───────────────┐
-                                  │   Git Push    │
-                                  └───────────────┘
-                                          │
-                                          ▼
-             ┌─────────────────────────────────────────────────────────┐
-             │░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-             │░░░░░░░░░░░░░░░░░░░░ Languine Engine ░░░░░░░░░░░░░░░░░░░░│
-             │░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-             └─────────────────────────────────────────────────────────┘
-                                          │
-                                          ▼
-                                          │
-            ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┼ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─
-           │                              │                              │
-           ▼                              ▼                              ▼
- ╔═══════════════════╗          ╔═══════════════════╗          ╔═══════════════════╗
- ║                   ║          ║                   ║          ║                   ║
- ║      Inglês      ║          ║      Espanhol     ║          ║      Japonês      ║
- ║    Tradução      ║          ║    Tradução      ║          ║     Tradução      ║
- ║                   ║          ║                   ║          ║                   ║
- ╚═══════════════════╝          ╚═══════════════════╝          ╚═══════════════════╝
-           │                              │                              │
-           └──────────────────────────────┼──────────────────────────────┘
-                                          ▼
-                                  ┌───────────────┐
-                                  │     Mesclar    │
-                                  │ Pull Request  │
-                                  └───────────────┘
-                                          │
-                                          ▼
-                              ┌─────────────────────┐
-                              │      Concluído      │
-                              │      (Implantar)    │
-                              └─────────────────────┘
-`}
-        </pre>
-      </div>
-
----
-
-## Instalação
-
-Para usar a Ação do GitHub Languine em seu repositório, você precisará:
-
-1. Configurar os segredos do seu repositório com suas credenciais Languine
-2. Criar um arquivo de fluxo de trabalho em seu repositório
-
-### Configurando Segredos do Repositório
-
-Adicione os seguintes segredos nas configurações do seu repositório (Configurações > Segredos e variáveis > Ações):
-
-- `LANGUINE_API_KEY`: Sua chave de API Languine
-- `LANGUINE_PROJECT_ID`: Seu ID de projeto Languine
-
-Você pode encontrar esses valores no seu painel Languine em Configurações do Projeto.
-
-
-
-### Variáveis de Ambiente
-
-A Ação do GitHub usa as seguintes variáveis de ambiente:
-- `LANGUINE_API_KEY` (Obrigatório): Sua chave de API Languine para autenticação
-- `LANGUINE_PROJECT_ID` (Obrigatório): Seu ID de projeto Languine 
-- `GITHUB_TOKEN` (Obrigatório): Fornecido automaticamente pelo GitHub, usado para criar PRs
-
-### Exemplo de Fluxo de Trabalho
-
-Crie um novo arquivo .github/workflows/languine.yml em seu repositório com o seguinte conteúdo:
-
-```ts title=".github/workflows/release.yml"
-name: Implantar Website
-
-on:
-  push:
-    branches:
-      - '**'
-    paths:
-      - apps/web/**
-
-jobs:
-  translate:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-      pull-requests: write
-    steps:
-      - uses: actions/checkout@v4
-      
-      - name: Ação Languine
-        uses: languine/languine-action@v1
-        env:
-           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          api-key: ${{ secrets.LANGUINE_API_KEY }}
-          project-id: ${{ secrets.LANGUINE_PROJECT_ID }}
-```
- 
- Este fluxo de trabalho irá:
-- Executar em envios para a branch principal
-- Executar em pull requests para a branch principal
-- Pode ser acionado manualmente na aba Ações
-- Fazer checkout do seu código e executar o processo de tradução Languine
-- Criar um pull request com quaisquer novas traduções (configurável)
-
-#### Opção de Diretório de Trabalho
-
-A opção `working-directory` permite que você especifique onde seus arquivos de tradução estão localizados. Isso é particularmente útil em monorepos onde suas traduções podem estar em um pacote ou diretório de aplicativo específico. Por exemplo:
-
-#### Opção de Pull Request (em breve)
-
-A opção `create-pull-request` controla se a ação cria um pull request com as alterações ou as confirma diretamente na branch:
-
-```typescript title=".github/workflows/languine.yml"
-with:
-  create-pull-request: true # criar um pull request com as alterações
-```
-
-Quando definido como `true`, a ação irá:
-- Criar uma nova branch com as alterações
-- Criar um pull request para revisão
-- Adicionar rótulos e descrição apropriados
-
-Quando definido como `false` (padrão), a ação irá:
-- Confirmar as alterações diretamente na branch atual
-- Enviar as alterações sem criar um pull request
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/pt/html.mdx b/apps/web/src/markdown/docs/pt/html.mdx
deleted file mode 100644
index 95fc8d2d..00000000
--- a/apps/web/src/markdown/docs/pt/html.mdx
+++ /dev/null
@@ -1,41 +0,0 @@
-# HTML
-
-Languine suporta a localização de arquivos HTML, lidando tanto com o conteúdo de texto quanto com atributos. Este formato é ideal para sites estáticos e templates HTML, com suporte para preservar a estrutura e formatação do HTML.
-
----
-
-## Configurando
-
-Primeiro, certifique-se de que você tem um arquivo de configuração languine.json na raiz do seu projeto. Aqui está um exemplo:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "html": {
-      "include": ["pages/[locale]/*.html"]
-    }
-  }
-}
-```
-
-## Traduzindo
-
-Com sua configuração definida, execute:
-
-```bash
-npx languine@latest translate
-```
-
-Quando você executar este comando, Languine irá:
-
-- Carregar seus arquivos HTML de origem (por exemplo, pages/en/*.html)
-- Detectar quaisquer novas ou modificadas strings de tradução
-- Gerar traduções para seus idiomas-alvo
-- Criar ou atualizar os arquivos HTML do idioma-alvo (por exemplo, pages/sv/*.html)
-- Preservar a estrutura e formatação do HTML
-- Lidar com traduções de atributos especificados
-- Manter comentários e tags especiais
diff --git a/apps/web/src/markdown/docs/pt/introduction.mdx b/apps/web/src/markdown/docs/pt/introduction.mdx
deleted file mode 100644
index ebc064bb..00000000
--- a/apps/web/src/markdown/docs/pt/introduction.mdx
+++ /dev/null
@@ -1,34 +0,0 @@
-# Introdução
-
-O Languine automatiza a localização dentro do seu fluxo de trabalho e pipeline de desenvolvimento, garantindo que as traduções nunca atrasem você.
-
-Transforme sua aplicação em uma experiência multilíngue em minutos. Enquanto você se concentra em construir recursos, o Languine cuida de todos os aspectos da tradução com precisão e confiabilidade.
-
----
-
-## Principais Recursos
-
-- **Motor de Tradução**: Aproveite traduções de alta qualidade, cientes do contexto, que mantêm a voz da sua marca
-- **Integração CI/CD**: Automatize atualizações de tradução através dos seus fluxos de trabalho existentes
-- **Formatos**: Lide com qualquer formato de arquivo com nosso sistema de parser extensível
-- **Código Aberto**: Acesse, inspecione e contribua para nossa base de código no GitHub - sem caixas pretas, total transparência
-
----
-
-## Como Funciona
-
-1. **Configuração Rápida**: Comece em minutos com nosso CLI intuitivo e inicialização guiada
-2. **Configuração Simples**: Defina suas necessidades de tradução com um arquivo de configuração claro e direto
-3. **Tradução Automatizada**: Envie seu conteúdo uma vez e deixe o Languine lidar automaticamente com a tradução para todos os idiomas-alvo
-
----
-
-## Começando
-
-Inicie sua jornada de localização com nosso guia [Quickstart](/docs/quickstart) - você terá suas primeiras traduções funcionando em minutos.
-
-Explore nossa documentação abrangente para dominar as capacidades do Languine:
-
-- [Configuração](/docs/configuration) - Configure o Languine para as necessidades do seu projeto
-- [CLI](/docs/cli) - Domine nossa poderosa interface de linha de comando
-- [Github Actions](/docs/github-actions) - Automatize traduções com nossa Ação do Github
diff --git a/apps/web/src/markdown/docs/pt/ios.mdx b/apps/web/src/markdown/docs/pt/ios.mdx
deleted file mode 100644
index fcf12bea..00000000
--- a/apps/web/src/markdown/docs/pt/ios.mdx
+++ /dev/null
@@ -1,39 +0,0 @@
-# iOS
-
-Languine suporta arquivos Localizable.strings do iOS, o formato padrão de localização para aplicativos iOS. Este formato lida com pares de chave-valor básicos e suporta comentários para fornecer contexto aos tradutores.
-
----
-
-## Configurando
-
-Primeiro, certifique-se de que você tem um arquivo de configuração languine.json na raiz do seu projeto. Aqui está um exemplo:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "ios": {
-      "include": ["[locale].lproj/Localizable.strings"]
-    }
-  }
-}
-```
-
-## Traduzindo
-
-Com sua configuração definida, execute:
-
-```bash
-npx languine@latest translate
-```
-
-Quando você executar este comando, Languine irá:
-
-- Carregar seu arquivo Localizable.strings de origem (por exemplo, en.lproj/Localizable.strings)
-- Detectar quaisquer novas ou modificadas strings de tradução
-- Gerar traduções para seus idiomas-alvo
-- Criar ou atualizar os arquivos de idioma-alvo (por exemplo, sv.lproj/Localizable.strings)
-- Preservar quaisquer comentários e formatação existentes
diff --git a/apps/web/src/markdown/docs/pt/js.mdx b/apps/web/src/markdown/docs/pt/js.mdx
deleted file mode 100644
index 249bb2f6..00000000
--- a/apps/web/src/markdown/docs/pt/js.mdx
+++ /dev/null
@@ -1,42 +0,0 @@
-# JavaScript
-
-Languine suporta arquivos de localização JavaScript/TypeScript, perfeito para aplicações web modernas. Este formato lida tanto com literais de objeto quanto com exportações de módulo, suportando estruturas aninhadas e conteúdo dinâmico.
-
----
-
-## Configurando
-
-Primeiro, certifique-se de que você tem um arquivo de configuração languine.json na raiz do seu projeto. Aqui está um exemplo:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "js": {
-      "include": ["src/locales/[locale].js"]
-    }
-  }
-}
-```
-
-## Traduzindo
-
-Com sua configuração definida, execute:
-
-```bash
-npx languine@latest translate
-```
-
-Quando você executar este comando, Languine irá:
-
-- Carregar seus arquivos JavaScript de origem (por exemplo, src/locales/en.js)
-- Detectar quaisquer novas ou modificadas strings de tradução
-- Gerar traduções para seus idiomas-alvo
-- Criar ou atualizar os arquivos de idioma-alvo (por exemplo, src/locales/sv.js)
-- Preservar a estrutura do módulo e as exportações
-- Lidar com objetos e arrays aninhados
-- Manter a formatação do código e os comentários
-- Gerar tipos TypeScript se habilitado
diff --git a/apps/web/src/markdown/docs/pt/json.mdx b/apps/web/src/markdown/docs/pt/json.mdx
deleted file mode 100644
index 090d4218..00000000
--- a/apps/web/src/markdown/docs/pt/json.mdx
+++ /dev/null
@@ -1,41 +0,0 @@
-# JSON
-
-Languine suporta arquivos JSON como um formato de origem com os requisitos comuns para pluralização e interpolação. Este formato é utilizado em muitos frameworks como React, Vue, Ruby on Rails, e mais.
-
-
----
-
-
-## Configurando
-
-Primeiro, certifique-se de que você tem um arquivo de configuração languine.json na raiz do seu projeto. Aqui está um exemplo:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "json": {
-      "include": ["locales/[locale].json"]
-    }
-  }
-}
-
-```
-
-## Traduzindo
-
-Com sua configuração definida, execute:
-
-```bash
-npx languine@latest translate
-```
-
-Quando você executar este comando, Languine irá:
-
-- Carregar seu arquivo JSON de origem (por exemplo, locales/en.json)
-- Detectar quaisquer novas ou modificadas strings de tradução
-- Gerar traduções para seus idiomas-alvo
-- Criar ou atualizar os arquivos JSON dos idiomas-alvo (por exemplo, locales/sv.json, locales/de.json, locales/fr.json)
diff --git a/apps/web/src/markdown/docs/pt/md.mdx b/apps/web/src/markdown/docs/pt/md.mdx
deleted file mode 100644
index 3c211846..00000000
--- a/apps/web/src/markdown/docs/pt/md.mdx
+++ /dev/null
@@ -1,43 +0,0 @@
-# Markdown
-
-Languine suporta a localização de arquivos Markdown, perfeito para documentação, postagens de blog e sites com muito conteúdo. Este formato preserva a sintaxe Markdown enquanto traduz o conteúdo, incluindo suporte para front matter.
-
----
-
-## Configurando
-
-Primeiro, certifique-se de que você tem um arquivo de configuração languine.json na raiz do seu projeto. Aqui está um exemplo:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "md": {
-      "include": ["content/[locale]/**/*.md"]
-    }
-  }
-}
-```
-
-## Traduzindo
-
-Com sua configuração definida, execute:
-
-```bash
-npx languine@latest translate
-```
-
-Quando você executar este comando, o Languine irá:
-
-- Carregar seus arquivos Markdown de origem (por exemplo, content/en/*.md)
-- Detectar qualquer conteúdo novo ou modificado
-- Gerar traduções para seus idiomas-alvo
-- Criar ou atualizar os arquivos de idioma-alvo (por exemplo, content/sv/*.md)
-- Preservar a formatação e a estrutura do Markdown
-- Lidar com traduções de front matter
-- Manter links e referências
-- Manter blocos de código não traduzidos
-- Preservar HTML dentro do Markdown
diff --git a/apps/web/src/markdown/docs/pt/mdx.mdx b/apps/web/src/markdown/docs/pt/mdx.mdx
deleted file mode 100644
index 7505a4bb..00000000
--- a/apps/web/src/markdown/docs/pt/mdx.mdx
+++ /dev/null
@@ -1,43 +0,0 @@
-# Markdown (MDX)
-
-Languine suporta a localização de arquivos Markdown (MDX), perfeito para documentação, postagens de blog e sites com muito conteúdo. Este formato preserva a sintaxe Markdown enquanto traduz o conteúdo, incluindo suporte a front matter.
-
----
-
-## Configurando
-
-Primeiro, certifique-se de que você tem um arquivo de configuração languine.json na raiz do seu projeto. Aqui está um exemplo:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "mdx": {
-      "include": ["content/[locale]/**/*.mdx"]
-    }
-  }
-}
-```
-
-## Traduzindo
-
-Com sua configuração definida, execute:
-
-```bash
-npx languine@latest translate
-```
-
-Quando você executar este comando, Languine irá:
-
-- Carregar seus arquivos Markdown de origem (por exemplo, content/en/*.mdx)
-- Detectar qualquer conteúdo novo ou modificado
-- Gerar traduções para seus idiomas-alvo
-- Criar ou atualizar os arquivos de idioma-alvo (por exemplo, content/sv/*.mdx)
-- Preservar a formatação e a estrutura do Markdown
-- Lidar com traduções de front matter
-- Manter links e referências
-- Manter blocos de código não traduzidos
-- Preservar HTML dentro do Markdown
diff --git a/apps/web/src/markdown/docs/pt/overrides.mdx b/apps/web/src/markdown/docs/pt/overrides.mdx
deleted file mode 100644
index e7afe98e..00000000
--- a/apps/web/src/markdown/docs/pt/overrides.mdx
+++ /dev/null
@@ -1,7 +0,0 @@
-# Substituições
-
-O Languine permite que você substitua traduções para chaves específicas. Isso é útil quando você deseja garantir que uma tradução específica seja usada para uma chave particular, independentemente da tradução padrão.
-
-## Como funciona
-
-No painel, você pode criar substituições para chaves específicas. Você também pode criar substituições para idiomas específicos.
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/pt/po.mdx b/apps/web/src/markdown/docs/pt/po.mdx
deleted file mode 100644
index f9d9b89e..00000000
--- a/apps/web/src/markdown/docs/pt/po.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# PO (Gettext)
-
-Languine suporta arquivos PO, o formato de localização Gettext amplamente utilizado. Este formato é popular em muitos ambientes de programação, particularmente em aplicações Linux e frameworks PHP, oferecendo suporte para contexto, plurais e comentários de tradutores.
-
----
-
-## Configurando
-
-Primeiro, certifique-se de que você tem um arquivo de configuração languine.json na raiz do seu projeto. Aqui está um exemplo:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "po": {
-      "include": ["locales/[locale]/LC_MESSAGES/messages.po"]
-    }
-  }
-}
-```
-
-## Traduzindo
-
-Com sua configuração definida, execute:
-
-```bash
-npx languine@latest translate
-```
-
-Quando você executar este comando, Languine irá:
-
-- Carregar seu arquivo PO de origem (por exemplo, locales/en/LC_MESSAGES/messages.po)
-- Detectar quaisquer novas ou modificadas strings de tradução
-- Gerar traduções para seus idiomas-alvo
-- Criar ou atualizar os arquivos PO do idioma-alvo (por exemplo, locales/sv/LC_MESSAGES/messages.po)
-- Preservar metadados, contextos e formas plurais
-- Manter comentários de tradutores e informações de referência
diff --git a/apps/web/src/markdown/docs/pt/prettier.mdx b/apps/web/src/markdown/docs/pt/prettier.mdx
deleted file mode 100644
index cec91aec..00000000
--- a/apps/web/src/markdown/docs/pt/prettier.mdx
+++ /dev/null
@@ -1,22 +0,0 @@
-# Prettier
-
-O Languine pode trabalhar em conjunto com o [Prettier](https://prettier.io/) para garantir que seus arquivos de tradução estejam formatados de maneira consistente. Isso é particularmente útil ao trabalhar com arquivos de tradução JSON que precisam manter um estilo consistente em todo o seu projeto.
-
-## Usando com Languine
-
-A maneira recomendada de usar o Prettier com o Languine é formatar seus arquivos de tradução após serem gerados. Você pode configurar isso em seu `package.json`:
-
-```json title="package.json"
-{
-  "scripts": {
-    "translate": "languine translate",
-    "format": "prettier --write \"locales/**/*.json\"",
-    "translate:format": "npm run translate && npm run format"
-  }
-}
-```
-
-Agora você pode:
-- Executar `npm run translate` para gerar apenas traduções
-- Executar `npm run format` para formatar apenas os arquivos de tradução existentes
-- Executar `npm run translate:format` para gerar traduções e formatá-las em sequência
diff --git a/apps/web/src/markdown/docs/pt/properties.mdx b/apps/web/src/markdown/docs/pt/properties.mdx
deleted file mode 100644
index 1e031992..00000000
--- a/apps/web/src/markdown/docs/pt/properties.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# Propriedades
-
-Languine suporta arquivos de Propriedades Java, o formato padrão de localização para aplicações Java. Este formato lida com escape de Unicode e suporta tanto pares chave-valor quanto comentários.
-
----
-
-## Configurando
-
-Primeiro, certifique-se de que você tem um arquivo de configuração languine.json na raiz do seu projeto. Aqui está um exemplo:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "properties": {
-      "include": ["src/main/resources/messages_[locale].properties"]
-    }
-  }
-}
-```
-
-## Traduzindo
-
-Com sua configuração definida, execute:
-
-```bash
-npx languine@latest translate
-```
-
-Quando você executar este comando, Languine irá:
-
-- Carregar seu arquivo de propriedades de origem (por exemplo, messages_en.properties)
-- Detectar quaisquer novas ou modificadas strings de tradução
-- Gerar traduções para seus idiomas-alvo
-- Criar ou atualizar os arquivos de propriedades do idioma-alvo (por exemplo, messages_sv.properties)
-- Lidar com escape de Unicode automaticamente
-- Preservar comentários e formatação
diff --git a/apps/web/src/markdown/docs/pt/quickstart.mdx b/apps/web/src/markdown/docs/pt/quickstart.mdx
deleted file mode 100644
index adfe9766..00000000
--- a/apps/web/src/markdown/docs/pt/quickstart.mdx
+++ /dev/null
@@ -1,65 +0,0 @@
-# Introdução Rápida
-
-Comece instalando o Languine.
-
-Em seguida, execute o seguinte comando para inicializar o Languine.
-
-```bash title="Terminal"
-npx languine@latest init
-```
-
-Siga os passos para configurar seu projeto.
-
----
-
-## Primeira Tradução
-
-Agora você está pronto para traduzir seu código.
-
-Comece adicionando uma chave ao seu arquivo de origem, por exemplo, se você escolher usar `en.json` como seu arquivo de origem, adicione uma chave a ele.
-
-```json title="src/locales/en.json"
-{
-  "welcome": "Bem-vindo ao nosso aplicativo!",
-  "user": {
-    "greeting": "Oi, {{name}}!",
-    "profile": {
-      "title": "Seu perfil",
-      "edit": "Editar perfil"
-    }
-  },
-  "notifications": {
-    "messages": "Você tem {{count}} nova(s) mensagem(ns).",
-    "empty": "Sem novas notificações."
-  }
-}
-
-```
-
----
-
-## Traduzir
-
-Execute o seguinte comando para traduzir seu conteúdo:
-
-```bash title="Terminal"
-npx languine@latest translate
-```
-
-## Isso irá:
-1. Criar arquivos de tradução para cada idioma de destino
-2. Gerar traduções de alta qualidade com o Languine Engine
-3. Criar um arquivo `languine.lock` para rastrear os estados de tradução
-
-O arquivo de bloqueio ajuda o Languine a identificar quais traduções precisam de atualizações quando seu conteúdo de origem muda. Certifique-se de commitar este arquivo em seu repositório.
-
----
-
-## Próximos Passos
-
-Agora que você configurou o Languine, você pode:
-- Adicionar mais idiomas em seu arquivo `languine.json`
-- Integrar o Languine em seu pipeline de CI/CD
-- Usar nossa API para traduções programáticas
-
-Confira nossos outros guias para aprender mais sobre os recursos avançados do Languine.
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/pt/react-email.mdx b/apps/web/src/markdown/docs/pt/react-email.mdx
deleted file mode 100644
index 8bc8c3c8..00000000
--- a/apps/web/src/markdown/docs/pt/react-email.mdx
+++ /dev/null
@@ -1,41 +0,0 @@
-# Email React
-
-Languine suporta templates de Email React, permitindo que você gerencie traduções para seus templates de email construídos com Email React. Esta integração lida tanto com o conteúdo de texto quanto com atributos HTML, preservando a estrutura do componente React.
-
----
-
-## Configurando
-
-Primeiro, certifique-se de que você tem um arquivo de configuração languine.json na raiz do seu projeto. Aqui está um exemplo:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "react-email": {
-      "include": ["emails/[locale]/*.tsx"]
-    }
-  }
-}
-```
-
-## Traduzindo
-
-Com sua configuração definida, execute:
-
-```bash
-npx languine@latest translate
-```
-
-Quando você executar este comando, Languine irá:
-
-- Carregar seus templates de Email React de origem (por exemplo, emails/en/*.tsx)
-- Detectar quaisquer novas ou modificadas strings de tradução
-- Gerar traduções para seus idiomas-alvo
-- Criar ou atualizar os templates de email do idioma-alvo (por exemplo, emails/sv/*.tsx)
-- Preservar a estrutura e as props do componente React
-- Manter a formatação e o estilo HTML
-- Lidar com interpolação e conteúdo dinâmico
diff --git a/apps/web/src/markdown/docs/pt/ts.mdx b/apps/web/src/markdown/docs/pt/ts.mdx
deleted file mode 100644
index 4e6fed1b..00000000
--- a/apps/web/src/markdown/docs/pt/ts.mdx
+++ /dev/null
@@ -1,42 +0,0 @@
-# TypeScript
-
-Languine suporta arquivos de localização TypeScript com total segurança de tipo. Este formato estende o suporte ao JavaScript com recursos adicionais específicos do TypeScript e capacidades de geração de tipos.
-
----
-
-## Configurando
-
-Primeiro, certifique-se de que você tem um arquivo de configuração languine.json na raiz do seu projeto. Aqui está um exemplo:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "ts": {
-      "include": ["src/locales/[locale].ts"]
-    }
-  }
-}
-```
-
-## Traduzindo
-
-Com sua configuração definida, execute:
-
-```bash
-npx languine@latest translate
-```
-
-Quando você executar este comando, o Languine irá:
-
-- Carregar seus arquivos TypeScript de origem (por exemplo, src/locales/en.ts)
-- Detectar quaisquer novas ou modificadas strings de tradução
-- Gerar traduções para seus idiomas-alvo
-- Criar ou atualizar os arquivos de idioma-alvo (por exemplo, src/locales/sv.ts)
-- Preservar anotações de tipo e interfaces
-- Lidar com objetos aninhados com tipagem adequada
-- Manter a formatação do código e comentários de documentação
-- Suportar tipos literais e tipos de união
diff --git a/apps/web/src/markdown/docs/pt/xcode-stringsdict.mdx b/apps/web/src/markdown/docs/pt/xcode-stringsdict.mdx
deleted file mode 100644
index be9d9782..00000000
--- a/apps/web/src/markdown/docs/pt/xcode-stringsdict.mdx
+++ /dev/null
@@ -1,44 +0,0 @@
-# Xcode Stringsdict
-
-Languine suporta o formato Stringsdict do Xcode, utilizado para regras complexas de pluralização em aplicativos iOS e macOS. Este formato lida com formas plurais, substituições de variáveis e regras de plural específicas para cada idioma.
-
----
-
-## Configurando
-
-Primeiro, certifique-se de que você tem um arquivo de configuração languine.json na raiz do seu projeto. Aqui está um exemplo:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "stringsdict": {
-      "include": ["MyApp/Localizable.stringsdict"]
-    }
-  }
-}
-```
-
-## Traduzindo
-
-Com sua configuração definida, execute:
-
-```bash
-npx languine@latest translate
-```
-
-Quando você executar este comando, o Languine irá:
-
-- Carregar seus arquivos Stringsdict
-- Detectar quaisquer novas regras de plural ou modificações
-- Gerar traduções para seus idiomas-alvo
-- Atualizar os arquivos Stringsdict com novas traduções
-- Lidar com regras de plural complexas para cada idioma
-- Manter substituições de variáveis
-- Preservar a estrutura do dicionário
-- Suportar formas plurais específicas para cada idioma
-- Validar a consistência das regras de plural
-- Manter os especificadores de formatação
diff --git a/apps/web/src/markdown/docs/pt/xcode-xcstrings.mdx b/apps/web/src/markdown/docs/pt/xcode-xcstrings.mdx
deleted file mode 100644
index b72b8b67..00000000
--- a/apps/web/src/markdown/docs/pt/xcode-xcstrings.mdx
+++ /dev/null
@@ -1,44 +0,0 @@
-# Strings do Xcode (XCStrings)
-
-O Languine suporta o formato XCStrings do Xcode, o formato moderno de localização para aplicativos iOS e macOS. Este formato lida com catálogos de strings com suporte para variações, pluralização e comentários de desenvolvedores.
-
----
-
-## Configurando
-
-Primeiro, certifique-se de que você tem um arquivo de configuração languine.json na raiz do seu projeto. Aqui está um exemplo:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "xcstrings": {
-      "include": ["MyApp/Localizable.xcstrings"]
-    }
-  }
-}
-```
-
-## Traduzindo
-
-Com sua configuração definida, execute:
-
-```bash
-npx languine@latest translate
-```
-
-Quando você executar este comando, o Languine irá:
-
-- Carregar seu catálogo de XCStrings
-- Detectar quaisquer strings novas ou modificadas
-- Gerar traduções para seus idiomas-alvo
-- Atualizar o catálogo de strings com novas traduções
-- Preservar variações de strings e regras de pluralização
-- Manter comentários de desenvolvedores e contexto
-- Lidar com substituições de variáveis
-- Suportar strings adaptativas
-- Manter especificadores de formatação
-- Validar a estrutura do catálogo de strings
diff --git a/apps/web/src/markdown/docs/pt/xliff.mdx b/apps/web/src/markdown/docs/pt/xliff.mdx
deleted file mode 100644
index 96eb4dc2..00000000
--- a/apps/web/src/markdown/docs/pt/xliff.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# XLIFF
-
-Languine suporta XLIFF (Formato de Intercâmbio de Localização em XML), um formato baseado em XML projetado para trocar dados de localização. Este formato é amplamente utilizado em fluxos de trabalho de tradução profissional e suporta as versões XLIFF 1.2 e 2.0.
-
----
-
-## Configurando
-
-Primeiro, certifique-se de que você tem um arquivo de configuração languine.json na raiz do seu projeto. Aqui está um exemplo:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "xliff": {
-      "include": ["locales/[locale].xlf"]
-    }
-  }
-}
-```
-
-## Traduzindo
-
-Com sua configuração definida, execute:
-
-```bash
-npx languine@latest translate
-```
-
-Quando você executar este comando, Languine irá:
-
-- Carregar seu arquivo XLIFF de origem (por exemplo, locales/en.xlf)
-- Detectar quaisquer unidades de tradução novas ou modificadas
-- Gerar traduções para seus idiomas-alvo
-- Criar ou atualizar os arquivos XLIFF do idioma-alvo (por exemplo, locales/sv.xlf)
-- Preservar notas, informações de contexto e atributos de estado
-- Manter compatibilidade com ferramentas de CAT (Tradução Assistida por Computador)
diff --git a/apps/web/src/markdown/docs/pt/xml.mdx b/apps/web/src/markdown/docs/pt/xml.mdx
deleted file mode 100644
index b6d55b27..00000000
--- a/apps/web/src/markdown/docs/pt/xml.mdx
+++ /dev/null
@@ -1,44 +0,0 @@
-# XML
-
-Languine suporta a localização de arquivos XML, adequada para vários arquivos de configuração e conteúdo baseados em XML. Este formato lida com estruturas XML complexas enquanto preserva a formatação e os atributos.
-
----
-
-## Configurando
-
-Primeiro, certifique-se de que você tem um arquivo de configuração languine.json na raiz do seu projeto. Aqui está um exemplo:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "xml": {
-      "include": ["resources/[locale]/*.xml"]
-    }
-  }
-}
-```
-
-## Traduzindo
-
-Com sua configuração definida, execute:
-
-```bash
-npx languine@latest translate
-```
-
-Quando você executar este comando, o Languine irá:
-
-- Carregar seus arquivos XML de origem (por exemplo, resources/en/*.xml)
-- Detectar qualquer conteúdo novo ou modificado
-- Gerar traduções para seus idiomas-alvo
-- Criar ou atualizar os arquivos de idioma-alvo (por exemplo, resources/sv/*.xml)
-- Preservar a estrutura e a formatação XML
-- Lidar com traduções de atributos
-- Manter seções CDATA
-- Manter comentários XML
-- Suportar namespaces XML
-- Validar a estrutura XML
diff --git a/apps/web/src/markdown/docs/pt/yaml.mdx b/apps/web/src/markdown/docs/pt/yaml.mdx
deleted file mode 100644
index dba0866d..00000000
--- a/apps/web/src/markdown/docs/pt/yaml.mdx
+++ /dev/null
@@ -1,39 +0,0 @@
-# YAML
-
-Languine suporta arquivos YAML como um formato de origem, que é comumente utilizado em Ruby on Rails, Laravel e outros frameworks. Este formato suporta estruturas aninhadas, arrays e tipos de dados complexos.
-
----
-
-## Configurando
-
-Primeiro, certifique-se de que você tem um arquivo de configuração languine.json na raiz do seu projeto. Aqui está um exemplo:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "yaml": {
-      "include": ["config/locales/[locale].yml"]
-    }
-  }
-}
-```
-
-## Traduzindo
-
-Com sua configuração definida, execute:
-
-```bash
-npx languine@latest translate
-```
-
-Quando você executar este comando, Languine irá:
-
-- Carregar seu arquivo YAML de origem (por exemplo, config/locales/en.yml)
-- Detectar quaisquer novas ou modificadas strings de tradução
-- Gerar traduções para seus idiomas-alvo
-- Criar ou atualizar os arquivos YAML do idioma-alvo (por exemplo, config/locales/sv.yml)
-- Preservar estruturas aninhadas e formatação
diff --git a/apps/web/src/markdown/docs/sv/android.mdx b/apps/web/src/markdown/docs/sv/android.mdx
deleted file mode 100644
index 92def690..00000000
--- a/apps/web/src/markdown/docs/sv/android.mdx
+++ /dev/null
@@ -1,39 +0,0 @@
-# Android
-
-Languine stöder Android-strängresurser (strings.xml) som ett källformat, och hanterar pluralformer, strängarrayer och formaterade strängar. Detta format är det standardiserade sättet att hantera översättningar i Android-applikationer.
-
----
-
-## Installera
-
-Först, se till att du har en languine.json-konfigurationsfil i roten av ditt projekt. Här är ett exempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "android": {
-      "include": ["app/src/main/res/values-[locale]/strings.xml"]
-    }
-  }
-}
-```
-
-## Översätta
-
-När din konfiguration är inställd, kör:
-
-```bash
-npx languine@latest translate
-```
-
-När du kör det här kommandot kommer Languine att:
-
-- Ladda din källstrings.xml-fil (t.ex. values/strings.xml)
-- Upptäcka eventuella nya eller modifierade översättningssträngar
-- Generera översättningar för dina målspråk
-- Skapa eller uppdatera målspråkens XML-filer (t.ex. values-sv/strings.xml, values-de/strings.xml, values-fr/strings.xml)
-- Bevara eventuell befintlig formatering av strängarrayer och pluralformer
diff --git a/apps/web/src/markdown/docs/sv/arb.mdx b/apps/web/src/markdown/docs/sv/arb.mdx
deleted file mode 100644
index b122d01b..00000000
--- a/apps/web/src/markdown/docs/sv/arb.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# ARB (Application Resource Bundle)
-
-Languine stöder ARB-filer, den standardiserade lokaliseringsformatet för Flutter-applikationer. Detta format hanterar pluralformer, platshållare och valuttryck samtidigt som det bibehåller kompatibilitet med Flutters intl-paket.
-
----
-
-## Installation
-
-Först, se till att du har en languine.json konfigurationsfil i projektets rot. Här är ett exempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "arb": {
-      "include": ["lib/l10n/intl_[locale].arb"]
-    }
-  }
-}
-```
-
-## Översättning
-
-Med din konfiguration inställd, kör:
-
-```bash
-npx languine@latest translate
-```
-
-När du kör det här kommandot kommer Languine att:
-
-- Ladda din käll-ARB-fil (t.ex. lib/l10n/intl_en.arb)
-- Detektera eventuella nya eller ändrade översättningssträngar
-- Generera översättningar för dina målspråk
-- Skapa eller uppdatera målspråkens ARB-filer (t.ex. lib/l10n/intl_sv.arb)
-- Bevara metadata, platshållare och plural-/valuttryck
-
diff --git a/apps/web/src/markdown/docs/sv/authentication.mdx b/apps/web/src/markdown/docs/sv/authentication.mdx
deleted file mode 100644
index 40878c3c..00000000
--- a/apps/web/src/markdown/docs/sv/authentication.mdx
+++ /dev/null
@@ -1,48 +0,0 @@
-# Autentisering
-
-För att använda Languine behöver du autentisera dig med vår motor, det tar bara några sekunder att komma igång.
-
----
-
-## Logga in
-
-Du kan logga in direkt på [Languine Dashboard](https://languine.ai/login) eller köra följande kommando:
-
-```bash title="Terminal"
-npx languine@latest auth login
-```
-
-
-Om du redan har ett konto kommer du automatiskt att loggas in och en session kommer att sparas på din maskin.
-
----
-
-## Logga ut
-
-Du kan logga ut genom att köra följande kommando:
-
-```bash title="Terminal"
-npx languine@latest auth logout
-```
-
----
-
-## Användarsession
-
-Du kan kontrollera om du är inloggad genom att köra följande kommando:
-
-```bash title="Terminal"
-npx languine@latest auth whoami
-```
-
----
-
-
-# Miljövariabler
-
-Du kan ställa in följande miljövariabler för att konfigurera Languine:
-
-- `LANGUINE_API_KEY`: API-nyckeln som ska användas för autentisering.
-- `LANGUINE_PROJECT_ID`: Projekt-ID:t som ska användas för projektet.
-
-Du hittar dem i [Languine Dashboard](https://languine.ai/login).
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/sv/biome.mdx b/apps/web/src/markdown/docs/sv/biome.mdx
deleted file mode 100644
index c6441108..00000000
--- a/apps/web/src/markdown/docs/sv/biome.mdx
+++ /dev/null
@@ -1,24 +0,0 @@
-# Biome
-
-Languine kan samarbeta med [Biome](https://biomejs.dev/) för att säkerställa att dina översättningsfiler är konsekvent formaterade. Detta är särskilt användbart när du arbetar med JSON-översättningsfiler som behöver upprätthålla en konsekvent stil genom hela ditt projekt.
-
-## Använda med Languine
-
-Det rekommenderade sättet att använda Biome med Languine är att formatera dina översättningsfiler efter att de har genererats. Du kan ställa in detta i din `package.json`:
-
-```json title="package.json"
-{
-  "scripts": {
-    "translate": "languine translate",
-    "format": "biome format \"locales/**/*.json\"",
-    "translate:format": "npm run translate && npm run format"
-  }
-}
-```
-
-Nu kan du:
-- Köra `npm run translate` för att endast generera översättningar
-- Köra `npm run format` för att endast formatera befintliga översättningsfiler
-- Köra `npm run translate:format` för att generera översättningar och formatera dem i följd
-
-Denna konfiguration kommer att säkerställa att dina översättningsfiler är formaterade konsekvent med 2-blankstegs indragning och en maximal radbredd på 80 tecken.
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/sv/ci.mdx b/apps/web/src/markdown/docs/sv/ci.mdx
deleted file mode 100644
index b8d5d62b..00000000
--- a/apps/web/src/markdown/docs/sv/ci.mdx
+++ /dev/null
@@ -1,96 +0,0 @@
-# CI/CD
-
-Languine erbjuder en CI/CD-integration för att hjälpa dig översätta din applikation.
-
----
-
-## Hur det fungerar
-
-CI/CD-arbetsflödet i Languine följer en strukturerad process för att automatisera översättningsuppdateringar i din applikation:
-
-### 1. Åtgärdsinitialisering
-- Arbetsflödet börjar när åtgärden utlöses
-- Ställer in nödvändig Git-konfiguration och autentiseringsuppgifter
-
-### 2. Languine-motorns bearbetning
-- Languine-motorn bearbetar innehållet i din applikation
-- Hanterar översättningsuppgifterna med hjälp av de konfigurerade inställningarna
-
-### 3. Ändringsdetektering
-Systemet kontrollerar om det finns några översättningsändringar och följer en av två vägar:
-
-**När ändringar hittas:**
-- Ändringar åtar sig till förvaret
-- Ändringar trycks till den angivna grenen
-- En Pull Request (PR) skapas
-
-**När inga ändringar hittas:**
-- Arbetsflödet avslutas utan att skapa en PR
-
-### 4. Skapande av Pull Request
-När ändringar upptäckts skapas en Pull Request med:
-
-**PR-innehåll:**
-- Tydlig titel som indikerar översättningsuppdateringar
-- Detaljerad beskrivning av ändringar
-- Bekräftelser på kvalitetskontroller
-- Instruktioner för granskning
-- Länkar till dokumentation och support
-
-**PR-beskrivningen inkluderar:**
-- Sammanfattning av översättningsuppdateringar
-- Lista över vad som ändrats (uppdaterade översättningar, terminologikonsistens)
-- Nästa steg för granskare
-- Länkar till dokumentations- och supportresurser
-
----
-
-## Arbetsflödesdiagram
-
-<div className="flex flex-col items-center justify-center p-4 h-[400px] sm:h-[500px] md:h-[650px]">
-  <pre
-    className="p-4 text-sm leading-5 mb-4 scale-[0.5] sm:scale-[0.65] md:scale-90 transform-gpu"
-    style={{
-      fontFamily: "monospace",
-      whiteSpace: "pre",
-      textAlign: "left",
-    }}
-  >
-    {`
-                    ┌─────────────────────┐
-                    │   Åtgärden startar   │
-                    └──────────┬──────────┘
-                               │
-                    ┌──────────▼──────────┐
-                    │    Ställ in Git &   │
-                    │    autentisering     │
-                    └──────────┬──────────┘
-                               │
-┌─────────────────────────────────────────────────────────┐
-│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-│░░░░░░░░░░░░░░░░░░░░ Languine-motorn ░░░░░░░░░░░░░░░░░░░░│
-│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-└─────────────────────────────────────────────────────────┘
-                               │
-                    ┌──────────▼──────────┐
-                    │   Kontrollera ändringar │───────┐
-                    └──────────┬──────────┘       │
-                               │                  │
-                               │ [Ändringar]        │ [Inga ändringar]
-                               │                  │
-                    ┌──────────▼──────────┐       │
-                    │   Åta och tryck     │       │
-                    └──────────┬──────────┘       │
-                               │                  │
-                    ┌──────────▼──────────┐       │
-                    │    Skapa PR         │       │
-                    └──────────┬──────────┘       │
-                               │                  │
-                    ┌──────────▼──────────┐       │
-                    │        Klar         │◄──────┘
-                    └─────────────────────┘
-`}
-  </pre>
-</div>
-
-Arbetsflödet är utformat för att vara automatiserat samtidigt som det fortfarande tillåter mänsklig granskning och kvalitetskontroll innan ändringar slås samman i din kodbas. Det upprätthåller bästa praxis för versionskontroll och säkerställer att översättningar spåras och dokumenteras korrekt genom Git-historiken.
diff --git a/apps/web/src/markdown/docs/sv/cli.mdx b/apps/web/src/markdown/docs/sv/cli.mdx
deleted file mode 100644
index 92956de8..00000000
--- a/apps/web/src/markdown/docs/sv/cli.mdx
+++ /dev/null
@@ -1,65 +0,0 @@
-# CLI
-
-Languine tillhandahåller en CLI för att hjälpa dig att översätta din applikation.
-
----
-
-## Kommandon Översikt
-
-### Översätt
-
-Kommandot `translate` används för att översätta din applikation.
-
-```bash title="Terminal"
-    npx languine@latest translate
-```
-
----
-
-### Initiera
-
-Kommandot `init` används för att initiera ett nytt Languine-projekt.
-
-```bash title="Terminal"
-    npx languine@latest init
-```
-
----
-
-### Autentisera
-
-Kommandot `auth` används för att autentisera med Languine.
-
-```bash title="Terminal"
-    npx languine@latest auth
-```
-
----
-
-### Synkronisera
-
-Kommandot `sync` används för att synkronisera din applikation med Languine.
-
-```bash title="Terminal"
-    npx languine@latest sync
-```
-
----
-
-### Lägg till Språk
-
-Kommandot `locale` används för att hantera din applikations språk.
-
-```bash title="Terminal"
-    npx languine@latest locale add pt,fr
-```
-
----
-
-### Ta Bort Språk
-
-Kommandot `locale remove` används för att ta bort ett språk från din applikation.
-
-```bash title="Terminal"
-    npx languine@latest locale remove pt,fr
-```
diff --git a/apps/web/src/markdown/docs/sv/configuration.mdx b/apps/web/src/markdown/docs/sv/configuration.mdx
deleted file mode 100644
index 2562db00..00000000
--- a/apps/web/src/markdown/docs/sv/configuration.mdx
+++ /dev/null
@@ -1,180 +0,0 @@
-# Konfiguration
-
-Languine använder en JSON-konfigurationsfil (languine.json) för att hantera din översättningsinställning. Denna fil definierar dina käll- och målspråk, samt de filer som behöver översättas.
-
----
-
-## Grundläggande Konfiguration
-
-Här är ett grundläggande exempel i båda formaten:
-
-```json title="languine.json"
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "fr", "de"]
-  },
-  "files": {
-    "json": {
-      "include": ["locales/[locale].json"]
-    }
-  }
-}
-```
-
-Låt oss bryta ner de olika sektionerna i konfigurationsfilen.
-
----
-
-## Språkkonfiguration
-
-Språksektionen definierar dina översättningsspråk:
-
-- source: Ditt primära språk för innehållsskapande (t.ex. "en" för engelska)
-- targets: En array av språk som du vill översätta till (t.ex. ["sv", "fr", "de"] för svenska, franska och tyska)
-
-Languine stöder ett brett spektrum av språkkoder, inklusive:
-- Enkla koder: en, sv, fr, de
-- Regionsspecifika koder: pt-BR, zh-CN, zh-TW
-
-## Filkonfiguration
-
-Filersektionen definierar vilka filer Languine ska översätta. Du kan konfigurera flera filtyper och mönster:
-
----
-
-### JSON-filer
-```json
-files: {
-  json: {
-    include: ["locales/[locale].json"],
-  },
-}
-```
-
----
-
-### Markdown/MDX-filer
-```json
-files: {
-  md: {
-    include: ["docs/[locale]/*.md"],
-  },
-  mdx: {
-    include: ["blog/[locale]/*.mdx"],
-  },
-}
-```
-
----
-
-### Mobilplattformfiler
-
-För iOS (Xcode):
-```json
-files: {
-  "xcode-xcstrings": {
-    include: ["Example/Localizable.xcstrings"],
-  },
-  // Eller för traditionella .strings-filer
-  "xcode-strings": {
-    include: ["Example/[locale].lproj/Localizable.strings"],
-  },
-}
-```
-
----
-
-För Android:
-```json
-files: {
-  android: {
-    include: ["locales/[locale].xml"],
-  },
-}
-```
-
----
-
-### Andra format
-
-Här är en komplett lista över filformat som stöds av Languine:
-
-- [JSON](/docs/json) - Standard JSON-översättningsfiler
-- [YAML](/docs/yaml) - YAML-översättningsfiler
-- [Properties](/docs/properties) - Java properties-filer
-- [Android](/docs/android) - Android XML-resursfiler
-- [iOS](/docs/ios) - iOS lokaliseringsfiler
-- [iOS Stringsdict](/docs/xcode-stringsdict) - iOS pluraliseringsfiler
-- [iOS XCStrings](/docs/xcode-xcstrings) - Moderna Xcode-strängkataloger
-- [Markdown](/docs/md) - Dokumentationsfiler
-- [MDX](/docs/mdx) - Dokumentation med JSX
-- [HTML](/docs/html) - HTML-filer
-- [JavaScript](/docs/js) - JavaScript-filer
-- [TypeScript](/docs/ts) - TypeScript-filer
-- [Gettext PO](/docs/po) - GetText-översättningsfiler
-- [XLIFF](/docs/xliff) - XML Localization Interchange File Format
-- [CSV](/docs/csv) - Kalkylbladsbaserade översättningar
-- [XML](/docs/xml) - XML-resursfiler
-- [Flutter ARB](/docs/arb) - Application Resource Bundle-filer
-
----
-
-## Filmönster
-
-[locale]-platshållaren i filmmönster ersätts automatiskt med den lämpliga språkkoden under översättning. Till exempel:
-
-- locales/[locale].json blir:
-  - locales/en.json
-  - locales/sv.json
-  - locales/fr.json
-
-Du kan inkludera flera mönster för varje filtyp och använda globmönster:
-```json
-files: {
-  json: {
-    include: [
-      "src/locales/[locale].json",
-      "src/components/[locale]/*.json"
-    ],
-  },
-}
-```
-
----
-
-## Projekt-ID (Valfritt)
-
-Om du använder Languines molntjänster kan du inkludera ditt projekt-ID i konfigurationen:
-
-```json
-{
-  "projectId": "prj_ditt_projekt_id",
-  "locale": {
-    // ... språkkonfiguration
-  },
-  files: {
-    // ... filkonfiguration
-  },
-}
-```
-
----
-
-## Spårning av översättningsstatus
-
-Languine skapar automatiskt och underhåller en languine.lock-fil för att spåra statusen för dina översättningar. Denna fil:
-
-- Spårar vilket innehåll som har översatts
-- Hjälper till att identifiera vad som behöver uppdateras när källinnehållet ändras
-- Bör åtagas i ditt versionshanteringssystem
-
-Du behöver inte manuellt redigera låsfilen - Languine hanterar den automatiskt när du kör översättningskommandon.
-
-## Bästa praxis
-
-1. **Versionshantering**: Åtag alltid både languine.json och languine.lock till ditt arkiv
-2. **Filorganisation**: Håll dina översättningsfiler organiserade i en konsekvent katalogstruktur
-3. **Språkkoder**: Använd standard språkkoder för att säkerställa kompatibilitet
-4. **Mönster**: Använd specifika inkluderingsmönster för att undvika att översätta onödiga filer
-5. **Projekt-ID**: Håll ditt projekt-ID säkert och dela det inte offentligt om du använder molntjänster, använd istället miljövariabeln `LANGUINE_PROJECT_ID`.
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/sv/csv.mdx b/apps/web/src/markdown/docs/sv/csv.mdx
deleted file mode 100644
index e262997f..00000000
--- a/apps/web/src/markdown/docs/sv/csv.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# CSV
-
-Languine stödjer CSV (komma-separerade värden) filer för enkel översättningshantering. Detta format är idealiskt för arbetsflöden baserade på kalkylblad och enkel integration med externa översättningsverktyg.
-
----
-
-## Installera
-
-Först, se till att du har en languine.json konfigurationsfil i rotmappen av ditt projekt. Här är ett exempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "csv": {
-      "include": ["translations/[locale].csv"]
-    }
-  }
-}
-```
-
-## Översätta
-
-Med din konfiguration inställd, kör:
-
-```bash
-npx languine@latest translate
-```
-
-När du kör detta kommando kommer Languine att:
-
-- Ladda din käll-CSV-fil (t.ex. translations/en.csv)
-- Upptäcka eventuella nya eller modifierade översättningssträngar
-- Generera översättningar för dina målspråk
-- Skapa eller uppdatera målspråkens CSV-filer (t.ex. translations/sv.csv)
-- Bibehålla kolumnstruktur och formatering
-- Bevara eventuella ytterligare metadata-kolumner
diff --git a/apps/web/src/markdown/docs/sv/expo.mdx b/apps/web/src/markdown/docs/sv/expo.mdx
deleted file mode 100644
index 9d7301b1..00000000
--- a/apps/web/src/markdown/docs/sv/expo.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# Expo
-
-Languine stöder Expo-lokalisering och integreras sömlöst med Expos i18n-system. Detta format fungerar med både JavaScript- och TypeScript-projekt och stöder nästlade strukturer och pluralisering.
-
----
-
-## Installation
-
-Först, se till att du har en languine.json-konfigurationsfil i rotmappen för ditt projekt. Här är ett exempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "expo": {
-      "include": ["assets/locales/[locale].json"]
-    }
-  }
-}
-```
-
-## Översättning
-
-Med din konfiguration inställd, kör:
-
-```bash
-npx languine@latest translate
-```
-
-När du kör det här kommandot kommer Languine att:
-
-- Ladda din källöversättningsfil (t.ex. assets/locales/en.json)
-- Upptäcka eventuella nya eller modifierade översättningssträngar
-- Generera översättningar för dina målspråk
-- Skapa eller uppdatera målspråksfiler (t.ex. assets/locales/sv.json)
-- Bevara nästlad struktur och pluraliseringsregler
-- Upprätthålla kompatibilitet med expo-localization
diff --git a/apps/web/src/markdown/docs/sv/github-actions.mdx b/apps/web/src/markdown/docs/sv/github-actions.mdx
deleted file mode 100644
index e69d0217..00000000
--- a/apps/web/src/markdown/docs/sv/github-actions.mdx
+++ /dev/null
@@ -1,147 +0,0 @@
-# GitHub Actions
-
-Med GitHub-actionen kan du enkelt översätta din kod genom att bara trycka på din kod till lagret, så kommer GitHub-actionen att översätta dina nya nycklar, antingen skapa en pull-begäran eller begå dina ändringar.
-Detta sparar dig mycket tid och ansträngning samtidigt som högkvalitativa översättningar bibehålls.
-
----
-
-## Hur det fungerar
-
-
-
-<div className="flex flex-col items-center justify-center p-4 mb-8 h-[400px] sm:h-[500px] md:h-[650px]">
-        <pre
-          className="p-4 text-sm leading-5 scale-[0.5] sm:scale-[0.65] md:scale-90 transform-gpu"
-          style={{
-            fontFamily: "monospace",
-            whiteSpace: "pre",
-            textAlign: "left",
-          }}
-        >
-          {`
-                                  ┌───────────────┐
-                                  │   Git Push    │
-                                  └───────────────┘
-                                          │
-                                          ▼
-             ┌─────────────────────────────────────────────────────────┐
-             │░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-             │░░░░░░░░░░░░░░░░░░░░ Languine Engine ░░░░░░░░░░░░░░░░░░░░│
-             │░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│
-             └─────────────────────────────────────────────────────────┘
-                                          │
-                                          ▼
-                                          │
-            ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┼ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─
-           │                              │                              │
-           ▼                              ▼                              ▼
- ╔═══════════════════╗          ╔═══════════════════╗          ╔═══════════════════╗
- ║                   ║          ║                   ║          ║                   ║
- ║      Engelska     ║          ║      Spanska      ║          ║      Japanska     ║
- ║    Översättning    ║          ║    Översättning    ║          ║     Översättning   ║
- ║                   ║          ║                   ║          ║                   ║
- ╚═══════════════════╝          ╚═══════════════════╝          ╚═══════════════════╝
-           │                              │                              │
-           └──────────────────────────────┼──────────────────────────────┘
-                                          ▼
-                                  ┌───────────────┐
-                                  │     Sammanfoga  │
-                                  │ Pull-begäran   │
-                                  └───────────────┘
-                                          │
-                                          ▼
-                              ┌─────────────────────┐
-                              │      Avslutad       │
-                              │      (Distribuera)  │
-                              └─────────────────────┘
-`}
-        </pre>
-      </div>
-
----
-
-## Installation
-
-För att använda Languine GitHub Action i ditt lager behöver du:
-
-1. Ställa in dina lagers hemligheter med dina Languine-uppgifter
-2. Skapa en arbetsflödesfil i ditt lager
-
-### Ställa in Lagers Hemligheter
-
-Lägg till följande hemligheter i dina lagers inställningar (Inställningar > Hemligheter och variabler > Åtgärder):
-
-- `LANGUINE_API_KEY`: Din Languine API-nyckel
-- `LANGUINE_PROJECT_ID`: Ditt Languine projekt-ID
-
-Du kan hitta dessa värden i din Languine-instrumentpanel under Projektinställningar.
-
-
-
-### Miljövariabler
-
-GitHub-actionen använder följande miljövariabler:
-- `LANGUINE_API_KEY` (Obligatorisk): Din Languine API-nyckel för autentisering
-- `LANGUINE_PROJECT_ID` (Obligatorisk): Ditt Languine projekt-ID 
-- `GITHUB_TOKEN` (Obligatorisk): Tillhandahålls automatiskt av GitHub, används för att skapa PR:er
-
-### Exempel på Arbetsflöde
-
-Skapa en ny fil .github/workflows/languine.yml i ditt lager med följande innehåll:
-
-```ts title=".github/workflows/release.yml"
-name: Distribuera Webbplats
-
-on:
-  push:
-    branches:
-      - '**'
-    paths:
-      - apps/web/**
-
-jobs:
-  translate:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-      pull-requests: write
-    steps:
-      - uses: actions/checkout@v4
-      
-      - name: Languine Action
-        uses: languine/languine-action@v1
-        env:
-           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          api-key: ${{ secrets.LANGUINE_API_KEY }}
-          project-id: ${{ secrets.LANGUINE_PROJECT_ID }}
-```
- 
- Detta arbetsflöde kommer att:
-- Körs vid tryck på huvudgrenen
-- Körs vid pull-begärningar till huvudgrenen
-- Kan utlösas manuellt från Åtgärder-fliken
-- Hämta din kod och köra Languine översättningsprocess
-- Skapa en pull-begäran med eventuella nya översättningar (konfigurerbar)
-
-#### Arbetskatalogalternativ
-
-Alternativet `working-directory` låter dig specificera var dina översättningsfiler finns. Detta är särskilt användbart i monorepos där dina översättningar kan finnas i en specifik paket- eller appkatalog. Till exempel:
-
-#### Pull-begäran alternativ (kommer snart)
-
-Alternativet `create-pull-request` styr huruvida åtgärden skapar en pull-begäran med ändringarna eller begår dem direkt till grenen:
-
-```typescript title=".github/workflows/languine.yml"
-with:
-  create-pull-request: true # skapa en pull-begäran med ändringarna
-```
-
-När det är inställt på `true`, kommer åtgärden att:
-- Skapa en ny gren med ändringarna
-- Skapa en pull-begäran för granskning
-- Lägga till lämpliga etiketter och beskrivning
-
-När det är inställt på `false` (standard), kommer åtgärden att:
-- Begå ändringarna direkt till den aktuella grenen
-- Trycka ändringarna utan att skapa en pull-begäran
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/sv/html.mdx b/apps/web/src/markdown/docs/sv/html.mdx
deleted file mode 100644
index a10363da..00000000
--- a/apps/web/src/markdown/docs/sv/html.mdx
+++ /dev/null
@@ -1,41 +0,0 @@
-# HTML
-
-Languine stöder lokalisering av HTML-filer och hanterar både textinnehåll och attribut. Detta format är idealiskt för statiska webbplatser och HTML-mallar, med stöd för att bevara HTML-struktur och formatering.
-
----
-
-## Installera
-
-Först, se till att du har en languine.json-konfigurationsfil i projektets rot. Här är ett exempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "html": {
-      "include": ["pages/[locale]/*.html"]
-    }
-  }
-}
-```
-
-## Översättning
-
-Med din konfiguration inställd, kör:
-
-```bash
-npx languine@latest translate
-```
-
-När du kör det här kommandot kommer Languine att:
-
-- Ladda dina käll-HTML-filer (t.ex. pages/en/*.html)
-- Upptäcka eventuella nya eller ändrade översättningssträngar
-- Generera översättningar för dina målspråk
-- Skapa eller uppdatera målspråkets HTML-filer (t.ex. pages/sv/*.html)
-- Bevara HTML-struktur och formatering
-- Hantera specificerade attributöversättningar
-- Bevara kommentarer och specialtaggar
diff --git a/apps/web/src/markdown/docs/sv/introduction.mdx b/apps/web/src/markdown/docs/sv/introduction.mdx
deleted file mode 100644
index 3abc7075..00000000
--- a/apps/web/src/markdown/docs/sv/introduction.mdx
+++ /dev/null
@@ -1,34 +0,0 @@
-# Introduktion
-
-Languine automatiserar lokalisering inom din utvecklingsarbetsflöde och pipeline, vilket säkerställer att översättningar aldrig sätter stopp för dig.
-
-Transformera din applikation till en flerspråkig upplevelse på några minuter. Medan du fokuserar på att bygga funktioner, hanterar Languine alla aspekter av översättning med precision och tillförlitlighet.
-
----
-
-## Nyckelfunktioner
-
-- **Översättningsmotor**: Utnyttja kontextmedvetna, högkvalitativa översättningar som behåller din varumärkesröst
-- **CI/CD-integration**: Automatisera översättningsuppdateringar genom dina befintliga arbetsflöden
-- **Format**: Hantera vilket filformat som helst med vårt utbyggbara parser-system
-- **Öppen källkod**: Få tillgång till, inspektera och bidra till vår kodbas på GitHub - inga svarta lådor, fullständig transparens
-
----
-
-## Hur det fungerar
-
-1. **Snabb installation**: Kom igång på några minuter med vår intuitiva CLI och guidad initiering
-2. **Enkel konfiguration**: Definiera dina översättningsbehov med en tydlig, enkel konfigurationsfil
-3. **Automatiserad översättning**: Skicka ditt innehåll en gång och låt Languine automatiskt hantera översättning till alla målspråk
-
----
-
-## Kom igång
-
-Börja din lokaliseringresa med vår [Snabbstart](/docs/quickstart) guide - du kommer att ha dina första översättningar igång på några minuter.
-
-Utforska vår omfattande dokumentation för att bemästra Languines kapabiliteter:
-
-- [Konfiguration](/docs/configuration) - Konfigurera Languine efter ditt projekts behov
-- [CLI](/docs/cli) - Bemästra vårt kraftfulla kommandoradsgränssnitt
-- [Github Actions](/docs/github-actions) - Automatisera översättningar med vår Github Action
diff --git a/apps/web/src/markdown/docs/sv/ios.mdx b/apps/web/src/markdown/docs/sv/ios.mdx
deleted file mode 100644
index 9a7e6f2c..00000000
--- a/apps/web/src/markdown/docs/sv/ios.mdx
+++ /dev/null
@@ -1,39 +0,0 @@
-# iOS
-
-Languine stöder iOS Localizable.strings-filer, det standardiserade lokaliseringsformatet för iOS-appar. Detta format hanterar grundläggande nyckel-värde-strängpar och stöder kommentarer för att ge kontext till översättare.
-
----
-
-## Installation
-
-Först, se till att du har en languine.json-konfigurationsfil i projektets rot. Här är ett exempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "ios": {
-      "include": ["[locale].lproj/Localizable.strings"]
-    }
-  }
-}
-```
-
-## Översättning
-
-Med din konfiguration inställd, kör:
-
-```bash
-npx languine@latest translate
-```
-
-När du kör det här kommandot kommer Languine att:
-
-- Ladda din källfil Localizable.strings (t.ex. en.lproj/Localizable.strings)
-- Upptäcka eventuella nya eller ändrade översättningssträngar
-- Generera översättningar för dina målspråk
-- Skapa eller uppdatera målspråksfiler (t.ex. sv.lproj/Localizable.strings)
-- Bevara eventuella befintliga kommentarer och formatering
diff --git a/apps/web/src/markdown/docs/sv/js.mdx b/apps/web/src/markdown/docs/sv/js.mdx
deleted file mode 100644
index 3eb60cb7..00000000
--- a/apps/web/src/markdown/docs/sv/js.mdx
+++ /dev/null
@@ -1,42 +0,0 @@
-# JavaScript
-
-Languine stöder JavaScript/TypeScript lokaliseringsfiler, perfekt för moderna webbapplikationer. Detta format hanterar både objektliteraler och modulexporter, och stöder nästlade strukturer och dynamiskt innehåll.
-
----
-
-## Installera
-
-Först, se till att du har en languine.json konfigurationsfil i rotmappen av ditt projekt. Här är ett exempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "js": {
-      "include": ["src/locales/[locale].js"]
-    }
-  }
-}
-```
-
-## Översättning
-
-När din konfiguration är inställd, kör:
-
-```bash
-npx languine@latest translate
-```
-
-När du kör det här kommandot kommer Languine att:
-
-- Ladda dina käll JavaScript-filer (t.ex. src/locales/en.js)
-- Upptäcka eventuella nya eller modifierade översättningssträngar
-- Generera översättningar för dina målspråk
-- Skapa eller uppdatera målspråksfiler (t.ex. src/locales/sv.js)
-- Bevara modulstruktur och exporter
-- Hantera nästlade objekt och arrayer
-- Upprätthålla kodformatering och kommentarer
-- Generera TypeScript-typer om det är aktiverat
diff --git a/apps/web/src/markdown/docs/sv/json.mdx b/apps/web/src/markdown/docs/sv/json.mdx
deleted file mode 100644
index cdb90f11..00000000
--- a/apps/web/src/markdown/docs/sv/json.mdx
+++ /dev/null
@@ -1,41 +0,0 @@
-# JSON
-
-Languine stöder JSON-filer som ett källformat med de vanliga kraven för pluralisering och interpolering. Detta format används i många ramverk som React, Vue, Ruby on Rails och mer.
-
-
----
-
-
-## Inställning
-
-Först, se till att du har en languine.json-konfigurationsfil i rotmappen av ditt projekt. Här är ett exempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "json": {
-      "include": ["locales/[locale].json"]
-    }
-  }
-}
-
-```
-
-## Översättning
-
-Med din konfiguration inställd, kör:
-
-```bash
-npx languine@latest translate
-```
-
-När du kör detta kommando kommer Languine att:
-
-- Ladda din käll-JSON-fil (t.ex. locales/en.json)
-- Upptäcka eventuella nya eller ändrade översättningssträngar
-- Generera översättningar för dina målspråk
-- Skapa eller uppdatera målspråkens JSON-filer (t.ex. locales/sv.json, locales/de.json, locales/fr.json)
diff --git a/apps/web/src/markdown/docs/sv/md.mdx b/apps/web/src/markdown/docs/sv/md.mdx
deleted file mode 100644
index 97c8707d..00000000
--- a/apps/web/src/markdown/docs/sv/md.mdx
+++ /dev/null
@@ -1,43 +0,0 @@
-# Markdown
-
-Languine stödjer lokalisering av Markdown-filer, perfekt för dokumentation, blogginlägg och innehållsrika webbplatser. Detta format bevarar Markdown-syntaxen samtidigt som innehållet översätts, inklusive stöd för front matter.
-
----
-
-## Installera
-
-Först, se till att du har en languine.json-konfigurationsfil i rotmappen av ditt projekt. Här är ett exempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "md": {
-      "include": ["content/[locale]/**/*.md"]
-    }
-  }
-}
-```
-
-## Översättning
-
-Med din konfiguration inställd, kör:
-
-```bash
-npx languine@latest translate
-```
-
-När du kör det här kommandot kommer Languine att:
-
-- Ladda dina käll-Mardown-filer (t.ex. content/en/*.md)
-- Upptäcka nytt eller ändrat innehåll
-- Generera översättningar för dina målspråk
-- Skapa eller uppdatera målspråksfiler (t.ex. content/sv/*.md)
-- Bevara Markdown-formattering och struktur
-- Hantera översättningar av front matter
-- Bevara länkar och referenser
-- Hålla kodblock oöversatta
-- Bevara HTML inom Markdown
diff --git a/apps/web/src/markdown/docs/sv/mdx.mdx b/apps/web/src/markdown/docs/sv/mdx.mdx
deleted file mode 100644
index 6ae236c8..00000000
--- a/apps/web/src/markdown/docs/sv/mdx.mdx
+++ /dev/null
@@ -1,43 +0,0 @@
-# Markdown (MDX)
-
-Languine stödjer lokalisering av Markdown (MDX) filer, perfekt för dokumentation, blogginlägg och innehållsrika webbplatser. Detta format bevarar Markdown-syntaxen samtidigt som innehållet översätts, inklusive stöd för front matter.
-
----
-
-## Installera
-
-Först, se till att du har en languine.json konfigurationsfil i rotmappen av ditt projekt. Här är ett exempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "mdx": {
-      "include": ["content/[locale]/**/*.mdx"]
-    }
-  }
-}
-```
-
-## Översätta
-
-Med din konfiguration inställd, kör:
-
-```bash
-npx languine@latest translate
-```
-
-När du kör det här kommandot kommer Languine att:
-
-- Ladda dina käll Markdown-filer (t.ex. content/en/*.mdx)
-- Upptäcka nytt eller ändrat innehåll
-- Generera översättningar för dina målspråk
-- Skapa eller uppdatera målspråksfiler (t.ex. content/sv/*.mdx)
-- Bevara Markdown-format och struktur
-- Hantera översättningar av front matter
-- Bevara länkar och referenser
-- Hålla kodblock oförändrade
-- Bevara HTML inom Markdown
diff --git a/apps/web/src/markdown/docs/sv/overrides.mdx b/apps/web/src/markdown/docs/sv/overrides.mdx
deleted file mode 100644
index e4bec260..00000000
--- a/apps/web/src/markdown/docs/sv/overrides.mdx
+++ /dev/null
@@ -1,7 +0,0 @@
-# Överskrivningar
-
-Languine gör det möjligt att överskriva översättningar för specifika nycklar. Detta är användbart när du vill säkerställa att en specifik översättning används för en viss nyckel, oavsett den standardöversättning som finns.
-
-## Hur det fungerar
-
-I instrumentpanelen kan du skapa överskrivningar för specifika nycklar. Du kan också skapa överskrivningar för specifika språk.
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/sv/po.mdx b/apps/web/src/markdown/docs/sv/po.mdx
deleted file mode 100644
index 627040ac..00000000
--- a/apps/web/src/markdown/docs/sv/po.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# PO (Gettext)
-
-Languine stöder PO-filer, det allmänt använda Gettext-lokaliseringsformatet. Detta format är populärt i många programmeringsmiljöer, särskilt i Linux-applikationer och PHP-ramverk, och erbjuder stöd för kontext, pluralformer och översättarkommentarer.
-
----
-
-## Installera
-
-Först, se till att du har en languine.json-konfigurationsfil i projektets rot. Här är ett exempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "po": {
-      "include": ["locales/[locale]/LC_MESSAGES/messages.po"]
-    }
-  }
-}
-```
-
-## Översätta
-
-När din konfiguration är inställd, kör:
-
-```bash
-npx languine@latest translate
-```
-
-När du kör detta kommando kommer Languine att:
-
-- Ladda din käll-PO-fil (t.ex. locales/en/LC_MESSAGES/messages.po)
-- Upptäcka eventuella nya eller ändrade översättningssträngar
-- Generera översättningar för dina målspråk
-- Skapa eller uppdatera målspråkets PO-filer (t.ex. locales/sv/LC_MESSAGES/messages.po)
-- Bevara metadata, kontexter och pluralformer
-- Upprätthålla översättarkommentarer och referensinformation
diff --git a/apps/web/src/markdown/docs/sv/prettier.mdx b/apps/web/src/markdown/docs/sv/prettier.mdx
deleted file mode 100644
index 0a717b85..00000000
--- a/apps/web/src/markdown/docs/sv/prettier.mdx
+++ /dev/null
@@ -1,22 +0,0 @@
-# Prettier
-
-Languine kan samarbeta med [Prettier](https://prettier.io/) för att säkerställa att dina översättningsfiler är konsekvent formaterade. Detta är särskilt användbart när du arbetar med JSON-översättningsfiler som behöver upprätthålla en konsekvent stil i ditt projekt.
-
-## Använda med Languine
-
-Det rekommenderade sättet att använda Prettier med Languine är att formatera dina översättningsfiler efter att de har genererats. Du kan ställa in detta i din `package.json`:
-
-```json title="package.json"
-{
-  "scripts": {
-    "translate": "languine translate",
-    "format": "prettier --write \"locales/**/*.json\"",
-    "translate:format": "npm run translate && npm run format"
-  }
-}
-```
-
-Nu kan du:
-- Köra `npm run translate` för att endast generera översättningar
-- Köra `npm run format` för att endast formatera befintliga översättningsfiler
-- Köra `npm run translate:format` för att generera översättningar och formatera dem i följd
diff --git a/apps/web/src/markdown/docs/sv/properties.mdx b/apps/web/src/markdown/docs/sv/properties.mdx
deleted file mode 100644
index d913d377..00000000
--- a/apps/web/src/markdown/docs/sv/properties.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# Egenskaper
-
-Languine stöder Java Properties-filer, den standardiserade lokaliseringsformatet för Java-applikationer. Detta format hanterar Unicode-escapning och stöder både nyckel-värde-par och kommentarer.
-
----
-
-## Installation
-
-Först, se till att du har en languine.json-konfigurationsfil i roten av ditt projekt. Här är ett exempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "properties": {
-      "include": ["src/main/resources/messages_[locale].properties"]
-    }
-  }
-}
-```
-
-## Översättning
-
-Med din konfiguration inställd, kör:
-
-```bash
-npx languine@latest translate
-```
-
-När du kör detta kommando kommer Languine att:
-
-- Ladda din källpropertiesfil (t.ex. messages_en.properties)
-- Upptäcka eventuella nya eller ändrade översättningssträngar
-- Generera översättningar för dina målspråk
-- Skapa eller uppdatera målspråkets propertiesfiler (t.ex. messages_sv.properties)
-- Hantera Unicode-escapning automatiskt
-- Bevara kommentarer och formatering
diff --git a/apps/web/src/markdown/docs/sv/quickstart.mdx b/apps/web/src/markdown/docs/sv/quickstart.mdx
deleted file mode 100644
index 247c0c24..00000000
--- a/apps/web/src/markdown/docs/sv/quickstart.mdx
+++ /dev/null
@@ -1,65 +0,0 @@
-# Snabbstart
-
-Börja med att installera Languine.
-
-Kör sedan följande kommando för att initiera Languine.
-
-```bash title="Terminal"
-npx languine@latest init
-```
-
-Följ stegen för att ställa in ditt projekt.
-
----
-
-## Första översättningen
-
-Nu är du redo att översätta din kod.
-
-Börja med att lägga till en nyckel i din källfil, till exempel om du väljer att använda `en.json` som din källfil, lägg till en nyckel i den.
-
-```json title="src/locales/en.json"
-{
-  "welcome": "Välkommen till vår applikation!",
-  "user": {
-    "greeting": "Hej, {{name}}!",
-    "profile": {
-      "title": "Din profil",
-      "edit": "Redigera profil"
-    }
-  },
-  "notifications": {
-    "messages": "Du har {{count}} nya meddelande(n).",
-    "empty": "Inga nya meddelanden."
-  }
-}
-
-```
-
----
-
-## Översätt
-
-Kör följande kommando för att översätta ditt innehåll:
-
-```bash title="Terminal"
-npx languine@latest translate
-```
-
-## Detta kommer att:
-1. Skapa översättningsfiler för varje målspråk
-2. Generera högkvalitativa översättningar med Languine Engine
-3. Skapa en `languine.lock`-fil för att spåra översättningsstatus
-
-Låsfiler hjälper Languine att identifiera vilka översättningar som behöver uppdateringar när ditt källinnehåll ändras. Se till att committa denna fil till ditt repository.
-
----
-
-## Nästa steg
-
-Nu när du har ställt in Languine kan du:
-- Lägga till fler språk i din `languine.json`-fil
-- Integrera Languine i din CI/CD-pipeline
-- Använda vårt API för programmerade översättningar
-
-Kolla in våra andra guider för att lära dig mer om Languines avancerade funktioner.
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/sv/react-email.mdx b/apps/web/src/markdown/docs/sv/react-email.mdx
deleted file mode 100644
index 3ecafb6f..00000000
--- a/apps/web/src/markdown/docs/sv/react-email.mdx
+++ /dev/null
@@ -1,41 +0,0 @@
-# React Email
-
-Languine stödjer React Email-mallar, vilket gör att du kan hantera översättningar för dina e-postmallar byggda med React Email. Denna integration hanterar både textinnehåll och HTML-attribut samtidigt som den bevarar strukturen för React-komponenter.
-
----
-
-## Installation
-
-Först, se till att du har en languine.json-konfigurationsfil i roten av ditt projekt. Här är ett exempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "react-email": {
-      "include": ["emails/[locale]/*.tsx"]
-    }
-  }
-}
-```
-
-## Översättning
-
-Med din konfiguration inställd, kör:
-
-```bash
-npx languine@latest translate
-```
-
-När du kör det här kommandot kommer Languine att:
-
-- Ladda dina källor för React Email-mallar (t.ex. emails/en/*.tsx)
-- Upptäcka eventuella nya eller modifierade översättningssträngar
-- Generera översättningar för dina målspråk
-- Skapa eller uppdatera e-postmallarna för målspråket (t.ex. emails/sv/*.tsx)
-- Bevara strukturen för React-komponenter och props
-- Upprätthålla HTML-formattering och stil
-- Hantera interpolering och dynamiskt innehåll
diff --git a/apps/web/src/markdown/docs/sv/ts.mdx b/apps/web/src/markdown/docs/sv/ts.mdx
deleted file mode 100644
index 3b8c869d..00000000
--- a/apps/web/src/markdown/docs/sv/ts.mdx
+++ /dev/null
@@ -1,42 +0,0 @@
-# TypeScript
-
-Languine stödjer TypeScript-lokaliseringsfiler med full typ-säkerhet. Detta format utökar JavaScript-stödet med ytterligare TypeScript-specifika funktioner och typgenereringsmöjligheter.
-
----
-
-## Installation
-
-Först, se till att du har en languine.json-konfigurationsfil i rotmappen av ditt projekt. Här är ett exempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "ts": {
-      "include": ["src/locales/[locale].ts"]
-    }
-  }
-}
-```
-
-## Översättning
-
-Med din konfiguration inställd, kör:
-
-```bash
-npx languine@latest translate
-```
-
-När du kör detta kommando kommer Languine att:
-
-- Ladda dina käll-TypeScript-filer (t.ex. src/locales/en.ts)
-- Upptäcka eventuella nya eller ändrade översättningssträngar
-- Generera översättningar för dina målspråk
-- Skapa eller uppdatera målspråksfiler (t.ex. src/locales/sv.ts)
-- Bevara typannoteringar och gränssnitt
-- Hantera nästlade objekt med korrekt typning
-- Upprätthålla kodformatering och dokumentationskommentarer
-- Stödja litterala typer och unionstyper
diff --git a/apps/web/src/markdown/docs/sv/xcode-stringsdict.mdx b/apps/web/src/markdown/docs/sv/xcode-stringsdict.mdx
deleted file mode 100644
index 9c5fdaa6..00000000
--- a/apps/web/src/markdown/docs/sv/xcode-stringsdict.mdx
+++ /dev/null
@@ -1,44 +0,0 @@
-# Xcode Stringsdict
-
-Languine stöder Xcodes Stringsdict-format, som används för komplexa pluraliseringsregler i iOS- och macOS-appar. Detta format hanterar pluralformer, variabelsubstitutioner och språk-specifika pluralregler.
-
----
-
-## Konfigurera
-
-Först, se till att du har en languine.json-konfigurationsfil i projektets rot. Här är ett exempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "stringsdict": {
-      "include": ["MyApp/Localizable.stringsdict"]
-    }
-  }
-}
-```
-
-## Översätta
-
-Med din konfiguration inställd, kör:
-
-```bash
-npx languine@latest translate
-```
-
-När du kör det här kommandot kommer Languine att:
-
-- Ladda dina Stringsdict-filer
-- Upptäcka eventuella nya eller ändrade pluralregler
-- Generera översättningar för dina målspråk
-- Uppdatera Stringsdict-filerna med nya översättningar
-- Hantera komplexa pluralregler för varje språk
-- Bevara variabelsubstitutioner
-- Bevara ordboksstrukturen
-- Stötta språk-specifika pluralformer
-- Validera konsistensen i pluralregler
-- Bevara formateringsspecifikationer
diff --git a/apps/web/src/markdown/docs/sv/xcode-xcstrings.mdx b/apps/web/src/markdown/docs/sv/xcode-xcstrings.mdx
deleted file mode 100644
index 9310ed85..00000000
--- a/apps/web/src/markdown/docs/sv/xcode-xcstrings.mdx
+++ /dev/null
@@ -1,44 +0,0 @@
-# Xcode Strängar (XCStrings)
-
-Languine stöder Xcodes XCStrings-format, det moderna lokaliseringsformatet för iOS- och macOS-applikationer. Detta format hanterar strängkataloger med stöd för variationer, pluralisering och utvecklarkommentarer.
-
----
-
-## Installera
-
-Först, se till att du har en languine.json-konfigurationsfil i din projektrot. Här är ett exempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "xcstrings": {
-      "include": ["MyApp/Localizable.xcstrings"]
-    }
-  }
-}
-```
-
-## Översätta
-
-Med din konfiguration inställd, kör:
-
-```bash
-npx languine@latest translate
-```
-
-När du kör detta kommando kommer Languine att:
-
-- Ladda din XCStrings-katalog
-- Upptäcka eventuella nya eller ändrade strängar
-- Generera översättningar för dina målspråk
-- Uppdatera strängkatalogen med nya översättningar
-- Bevara strängvariationer och pluraliseringsregler
-- Upprätthålla utvecklarkommentarer och kontext
-- Hantera variabelsubstitutioner
-- Stötta adaptiva strängar
-- Bevara formateringsspecifikationer
-- Validera strängkatalogens struktur
diff --git a/apps/web/src/markdown/docs/sv/xliff.mdx b/apps/web/src/markdown/docs/sv/xliff.mdx
deleted file mode 100644
index 05cf5ced..00000000
--- a/apps/web/src/markdown/docs/sv/xliff.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# XLIFF
-
-Languine stöder XLIFF (XML Localization Interchange File Format), ett XML-baserat format som är utformat för att utbyta lokaliseringsdata. Detta format används i stor utsträckning i professionella översättningsarbetsflöden och stöder både XLIFF 1.2 och 2.0 versioner.
-
----
-
-## Installera
-
-Först, se till att du har en languine.json konfigurationsfil i roten av ditt projekt. Här är ett exempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "xliff": {
-      "include": ["locales/[locale].xlf"]
-    }
-  }
-}
-```
-
-## Översätta
-
-Med din konfiguration inställd, kör:
-
-```bash
-npx languine@latest translate
-```
-
-När du kör det här kommandot kommer Languine att:
-
-- Ladda din käll XLIFF-fil (t.ex. locales/en.xlf)
-- Upptäcka eventuella nya eller ändrade översättningsenheter
-- Generera översättningar för dina målspråk
-- Skapa eller uppdatera målspråkets XLIFF-filer (t.ex. locales/sv.xlf)
-- Bevara anteckningar, kontextinformation och tillståndsattribut
-- Upprätthålla kompatibilitet med CAT (Computer-Aided Translation) verktyg
diff --git a/apps/web/src/markdown/docs/sv/xml.mdx b/apps/web/src/markdown/docs/sv/xml.mdx
deleted file mode 100644
index a1b61b16..00000000
--- a/apps/web/src/markdown/docs/sv/xml.mdx
+++ /dev/null
@@ -1,44 +0,0 @@
-# XML
-
-Languine stödjer lokalisering av XML-filer, lämplig för olika XML-baserade konfigurations- och innehållsfiler. Detta format hanterar komplexa XML-strukturer samtidigt som det bevarar formatering och attribut.
-
----
-
-## Installera
-
-Först, se till att du har en languine.json konfigurationsfil i rotmappen av ditt projekt. Här är ett exempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "xml": {
-      "include": ["resources/[locale]/*.xml"]
-    }
-  }
-}
-```
-
-## Översätta
-
-När din konfiguration är inställd, kör:
-
-```bash
-npx languine@latest translate
-```
-
-När du kör detta kommando kommer Languine att:
-
-- Ladda dina käll-XML-filer (t.ex. resources/en/*.xml)
-- Upptäcka nytt eller ändrat innehåll
-- Generera översättningar för dina målspråk
-- Skapa eller uppdatera målspråksfiler (t.ex. resources/sv/*.xml)
-- Bevara XML-struktur och formatering
-- Hantera översättningar av attribut
-- Upprätthålla CDATA-sektioner
-- Bevara XML-kommentarer
-- Stötta XML-namnrymder
-- Validera XML-struktur
diff --git a/apps/web/src/markdown/docs/sv/yaml.mdx b/apps/web/src/markdown/docs/sv/yaml.mdx
deleted file mode 100644
index bc1d0ef7..00000000
--- a/apps/web/src/markdown/docs/sv/yaml.mdx
+++ /dev/null
@@ -1,39 +0,0 @@
-# YAML
-
-Languine stöder YAML-filer som ett källformat, vilket är vanligt förekommande i Ruby on Rails, Laravel och andra ramverk. Detta format stöder nästlade strukturer, arrayer och komplexa datatyper.
-
----
-
-## Installera
-
-Först, se till att du har en languine.json-konfigurationsfil i projektets rot. Här är ett exempel:
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "yaml": {
-      "include": ["config/locales/[locale].yml"]
-    }
-  }
-}
-```
-
-## Översättning
-
-Med din konfiguration inställd, kör:
-
-```bash
-npx languine@latest translate
-```
-
-När du kör detta kommando kommer Languine att:
-
-- Ladda din käll-YAML-fil (t.ex. config/locales/en.yml)
-- Upptäcka eventuella nya eller ändrade översättningssträngar
-- Generera översättningar för dina målspråk
-- Skapa eller uppdatera målspråkens YAML-filer (t.ex. config/locales/sv.yml)
-- Bevara nästlade strukturer och formatering
diff --git a/apps/web/src/markdown/docs/zh-CN/csv.mdx b/apps/web/src/markdown/docs/zh-CN/csv.mdx
deleted file mode 100644
index d7f77dcc..00000000
--- a/apps/web/src/markdown/docs/zh-CN/csv.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# CSV
-
-Languine 支持 CSV（逗号分隔值）文件，以便于简单的翻译管理。此格式非常适合基于电子表格的工作流程，并且可以轻松与外部翻译工具集成。
-
----
-
-## 设置
-
-首先，请确保在项目根目录中有一个 languine.config.json 或 languine.config.ts 配置文件。以下是一个示例：
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "csv": {
-      "include": ["translations/[locale].csv"]
-    }
-  }
-}
-```
-
-## 翻译
-
-配置完成后，运行：
-
-```bash
-npx languine@latest translate
-```
-
-当您运行此命令时，Languine 将：
-
-- 加载您的源 CSV 文件（例如，translations/en.csv）
-- 检测任何新的或修改过的翻译字符串
-- 为目标语言生成翻译
-- 创建或更新目标语言的 CSV 文件（例如，translations/sv.csv）
-- 保持列结构和格式
-- 保留任何额外的元数据列
diff --git a/apps/web/src/markdown/docs/zh-CN/ios.mdx b/apps/web/src/markdown/docs/zh-CN/ios.mdx
deleted file mode 100644
index 135de690..00000000
--- a/apps/web/src/markdown/docs/zh-CN/ios.mdx
+++ /dev/null
@@ -1,39 +0,0 @@
-# iOS
-
-Languine 支持 iOS Localizable.strings 文件，这是 iOS 应用程序的标准本地化格式。该格式处理基本的键值字符串对，并支持注释以为翻译者提供上下文。
-
----
-
-## 设置
-
-首先，确保在项目根目录中有一个 languine.config.json 或 languine.config.ts 配置文件。以下是一个示例：
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "ios": {
-      "include": ["[locale].lproj/Localizable.strings"]
-    }
-  }
-}
-```
-
-## 翻译
-
-配置完成后，运行：
-
-```bash
-npx languine@latest translate
-```
-
-当您运行此命令时，Languine 将：
-
-- 加载您的源 Localizable.strings 文件（例如，en.lproj/Localizable.strings）
-- 检测任何新的或修改过的翻译字符串
-- 为您的目标语言生成翻译
-- 创建或更新目标语言文件（例如，sv.lproj/Localizable.strings）
-- 保留任何现有的注释和格式
diff --git a/apps/web/src/markdown/docs/zh-CN/quickstart.mdx b/apps/web/src/markdown/docs/zh-CN/quickstart.mdx
deleted file mode 100644
index b59af13b..00000000
--- a/apps/web/src/markdown/docs/zh-CN/quickstart.mdx
+++ /dev/null
@@ -1,60 +0,0 @@
-# 快速入门
-
-首先安装 Languine。
-
-然后，运行以下命令来初始化 Languine。
-
-```bash title="终端"
-npx languine@latest init
-```
-
-按照步骤设置您的项目。
-
-## 第一次翻译
-
-现在您准备好翻译您的代码了。
-
-首先在您的源文件中添加一个键，例如如果您选择使用 `en.json` 作为源文件，请向其中添加一个键。
-
-```json title="src/locales/en.json"
-{
-  "welcome": "欢迎使用我们的应用程序！",
-  "user": {
-    "greeting": "嗨，{{name}}！",
-    "profile": {
-      "title": "您的个人资料",
-      "edit": "编辑个人资料"
-    }
-  },
-  "notifications": {
-    "messages": "您有 {{count}} 条新消息。",
-    "empty": "没有新的通知。"
-  }
-}
-
-```
-
-
-## 翻译
-
-运行以下命令以翻译您的内容：
-
-```bash title="终端"
-npx languine@latest translate
-```
-
-## 这将：
-1. 为每种目标语言创建翻译文件
-2. 生成高质量的翻译 Languine 引擎
-3. 创建一个 `languine.lock` 文件以跟踪翻译状态
-
-锁定文件帮助 Languine 确定在源内容更改时哪些翻译需要更新。确保将此文件提交到您的代码库。
-
-## 下一步
-
-现在您已经设置好 Languine，您可以：
-- 在您的 `languine.config.json` 文件中添加更多语言
-- 将 Languine 集成到您的 CI/CD 管道中
-- 使用我们的 API 进行程序化翻译
-
-查看我们的其他指南以了解更多关于 Languine 高级功能的信息。
\ No newline at end of file
diff --git a/apps/web/src/markdown/docs/zh-TW/csv.mdx b/apps/web/src/markdown/docs/zh-TW/csv.mdx
deleted file mode 100644
index d98b604f..00000000
--- a/apps/web/src/markdown/docs/zh-TW/csv.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
-# CSV
-
-Languine 支援 CSV（逗號分隔值）檔案，以簡化翻譯管理。此格式非常適合基於電子表格的工作流程，並能輕鬆與外部翻譯工具整合。
-
----
-
-## 設定
-
-首先，請確保您在專案根目錄中擁有 languine.config.json 或 languine.config.ts 設定檔。以下是一個範例：
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "csv": {
-      "include": ["translations/[locale].csv"]
-    }
-  }
-}
-```
-
-## 翻譯
-
-設定完成後，執行：
-
-```bash
-npx languine@latest translate
-```
-
-當您執行此命令時，Languine 將：
-
-- 載入您的來源 CSV 檔案（例如，translations/en.csv）
-- 偵測任何新的或已修改的翻譯字串
-- 為您的目標語言生成翻譯
-- 創建或更新目標語言的 CSV 檔案（例如，translations/sv.csv）
-- 維持欄位結構和格式
-- 保留任何額外的元數據欄位
diff --git a/apps/web/src/markdown/docs/zh-TW/ios.mdx b/apps/web/src/markdown/docs/zh-TW/ios.mdx
deleted file mode 100644
index 7b985bc4..00000000
--- a/apps/web/src/markdown/docs/zh-TW/ios.mdx
+++ /dev/null
@@ -1,39 +0,0 @@
-# iOS
-
-Languine 支援 iOS Localizable.strings 檔案，這是 iOS 應用程式的標準本地化格式。此格式處理基本的鍵值字串對，並支援提供上下文的註解，以便翻譯者理解。
-
----
-
-## 設定
-
-首先，請確保您的專案根目錄中有一個 languine.config.json 或 languine.config.ts 配置檔。以下是一個範例：
-
-```json
-{
-  "locale": {
-    "source": "en",
-    "targets": ["sv", "de", "fr"]
-  },
-  "files": {
-    "ios": {
-      "include": ["[locale].lproj/Localizable.strings"]
-    }
-  }
-}
-```
-
-## 翻譯
-
-配置完成後，執行：
-
-```bash
-npx languine@latest translate
-```
-
-當您執行此命令時，Languine 將：
-
-- 載入您的來源 Localizable.strings 檔案（例如，en.lproj/Localizable.strings）
-- 偵測任何新的或已修改的翻譯字串
-- 為您的目標語言生成翻譯
-- 創建或更新目標語言檔案（例如，sv.lproj/Localizable.strings）
-- 保留任何現有的註解和格式
diff --git a/apps/web/src/markdown/docs/zh-TW/quickstart.mdx b/apps/web/src/markdown/docs/zh-TW/quickstart.mdx
deleted file mode 100644
index 305234c6..00000000
--- a/apps/web/src/markdown/docs/zh-TW/quickstart.mdx
+++ /dev/null
@@ -1,60 +0,0 @@
-# 快速入門
-
-首先安裝 Languine。
-
-然後，運行以下命令來初始化 Languine。
-
-```bash title="終端機"
-npx languine@latest init
-```
-
-按照步驟設置您的項目。
-
-## 首次翻譯
-
-現在您已準備好翻譯您的代碼。
-
-首先在您的源文件中添加一個鍵，例如如果您選擇使用 `en.json` 作為源文件，則在其中添加一個鍵。
-
-```json title="src/locales/en.json"
-{
-  "welcome": "歡迎使用我們的應用程式！",
-  "user": {
-    "greeting": "嗨，{{name}}！",
-    "profile": {
-      "title": "您的個人資料",
-      "edit": "編輯個人資料"
-    }
-  },
-  "notifications": {
-    "messages": "您有 {{count}} 梙新訊息。",
-    "empty": "沒有新的通知。"
-  }
-}
-
-```
-
-
-## 翻譯
-
-運行以下命令以翻譯您的內容：
-
-```bash title="終端機"
-npx languine@latest translate
-```
-
-## 這將：
-1. 為每個目標語言創建翻譯文件
-2. 生成高質量的翻譯 Languine 引擎
-3. 創建一個 `languine.lock` 文件以跟踪翻譯狀態
-
-鎖定文件幫助 Languine 確定當您的源內容更改時哪些翻譯需要更新。請確保將此文件提交到您的存儲庫。
-
-## 下一步
-
-現在您已經設置了 Languine，您可以：
-- 在您的 `languine.config.json` 文件中添加更多語言
-- 將 Languine 集成到您的 CI/CD 管道中
-- 使用我們的 API 進行程式化翻譯
-
-查看我們的其他指南以了解有關 Languine 高級功能的更多信息。
\ No newline at end of file
diff --git a/apps/web/src/mdx-components.tsx b/apps/web/src/mdx-components.tsx
index 22a9c516..27d0b0ae 100644
--- a/apps/web/src/mdx-components.tsx
+++ b/apps/web/src/mdx-components.tsx
@@ -200,7 +200,7 @@ export function useMDXComponents(components: MDXComponents): MDXComponents {
       if (isInline) {
         return (
           <code
-            className={`rounded border-b-2 border-gray-200 border-dashed px-[0.3rem] py-[0.2rem] font-mono text-sm ${className}`}
+            className={`rounded border-b-2 border-gray-200 border-dashed px-[0.3rem] py-[0.2rem] font-mono text-xs ${className}`}
             {...props}
           >
             {children}
@@ -284,7 +284,7 @@ export function useMDXComponents(components: MDXComponents): MDXComponents {
         lang === "bash" ? getPackageManagerCommandType(code) : null;
 
       return (
-        <div className="px-4 ">
+        <div className="px-4">
           <div className="absolute right-3" style={{ top: "-38px" }}>
             <CopyButton code={code} />
           </div>
@@ -297,7 +297,8 @@ export function useMDXComponents(components: MDXComponents): MDXComponents {
             />
           ) : (
             <div
-              className={`${className} font-mono text-sm`}
+              className={`${className} font-mono`}
+              style={{ fontSize: 12 }}
               // biome-ignore lint/security/noDangerouslySetInnerHtml: markdown
               dangerouslySetInnerHTML={{ __html: html }}
             />
diff --git a/apps/web/src/messages/de.json b/apps/web/src/messages/de.json
index d9d807bf..c332435a 100644
--- a/apps/web/src/messages/de.json
+++ b/apps/web/src/messages/de.json
@@ -6,8 +6,8 @@
     "goToApp": "Zur App gehen"
   },
   "hero": {
-    "title": "Lokalisierungsinfrastruktur für Entwickler",
-    "description": "Languine automatisiert die Lokalisierung in Ihrem Entwicklungsworkflow und Ihrer Pipeline, sodass Übersetzungen Sie nie aufhalten."
+    "title": "Lokalisierungsinfrastruktur für schnelllebige Startups.",
+    "description": "Languine automatisiert die Lokalisierung in Ihrem Entwickler-Workflow und Ihrer Pipeline, sodass Übersetzungen Sie nie aufhalten."
   },
   "navigation": {
     "dashboard": "Dashboard",
@@ -20,8 +20,8 @@
   },
   "getStarted": {
     "heading": "Loslegen",
-    "title": "Lokalisierungsinfrastruktur für Entwickler",
-    "description": "Languine automatisiert die Lokalisierung in Ihrem Entwicklungsworkflow und Ihrer Pipeline, sodass Übersetzungen Sie nie aufhalten.",
+    "title": "Lokalisierungsinfrastruktur für schnelllebige Startups.",
+    "description": "Languine automatisiert die Lokalisierung in Ihrem Entwickler-Workflow und Ihrer Pipeline, sodass Übersetzungen Sie nie aufhalten.",
     "button": {
       "startAutomating": "Automatisierung starten",
       "readDocumentation": "Dokumentation lesen"
diff --git a/apps/web/src/messages/en.json b/apps/web/src/messages/en.json
index 4a5925ac..52e6b486 100644
--- a/apps/web/src/messages/en.json
+++ b/apps/web/src/messages/en.json
@@ -6,8 +6,8 @@
     "goToApp": "Go to app"
   },
   "hero": {
-    "title": "Localization infrastructure made for developers",
-    "description": "Languine automates localization within your development workflow and pipeline, ensuring translations never hold you up."
+    "title": "Localization infrastructure made for fast-paced startups.",
+    "description": "Languine automates localization within your developer workflow and pipeline, ensuring translations never hold you up."
   },
   "navigation": {
     "dashboard": "Dashboard",
@@ -20,8 +20,8 @@
   },
   "getStarted": {
     "heading": "Get started",
-    "title": "Localization infrastructure made for developers",
-    "description": "Languine automates localization within your development workflow and pipeline, ensuring translations never hold you up.",
+    "title": "Localization infrastructure made for fast-paced startups.",
+    "description": "Languine automates localization within your developer workflow and pipeline, ensuring translations never hold you up.",
     "button": {
       "startAutomating": "Start automating",
       "readDocumentation": "Read documentation"
diff --git a/apps/web/src/messages/es.json b/apps/web/src/messages/es.json
index cc20bbe1..f49dc7ce 100644
--- a/apps/web/src/messages/es.json
+++ b/apps/web/src/messages/es.json
@@ -6,8 +6,8 @@
     "goToApp": "Ir a la aplicación"
   },
   "hero": {
-    "title": "Infraestructura de localización hecha para desarrolladores",
-    "description": "Languine automatiza la localización dentro de tu flujo de trabajo y pipeline de desarrollo, asegurando que las traducciones nunca te detengan."
+    "title": "Infraestructura de localización diseñada para startups de ritmo acelerado.",
+    "description": "Languine automatiza la localización dentro de tu flujo de trabajo y pipeline de desarrollo, asegurando que las traducciones nunca te retrasen."
   },
   "navigation": {
     "dashboard": "Tablero",
@@ -20,8 +20,8 @@
   },
   "getStarted": {
     "heading": "Comenzar",
-    "title": "Infraestructura de localización hecha para desarrolladores",
-    "description": "Languine automatiza la localización dentro de tu flujo de trabajo y pipeline de desarrollo, asegurando que las traducciones nunca te detengan.",
+    "title": "Infraestructura de localización diseñada para startups de ritmo acelerado.",
+    "description": "Languine automatiza la localización dentro de tu flujo de trabajo y pipeline de desarrollo, asegurando que las traducciones nunca te retrasen.",
     "button": {
       "startAutomating": "Comenzar a automatizar",
       "readDocumentation": "Leer documentación"
diff --git a/apps/web/src/messages/fi.json b/apps/web/src/messages/fi.json
index 7a21d886..ce7407de 100644
--- a/apps/web/src/messages/fi.json
+++ b/apps/web/src/messages/fi.json
@@ -6,8 +6,8 @@
     "goToApp": "Siirry sovellukseen"
   },
   "hero": {
-    "title": "Kehittäjille suunniteltu lokalisaatioinfrastruktuuri",
-    "description": "Languine automatisoi lokalisaation kehitysprosessissasi ja putkessasi, varmistaen että käännökset eivät hidasta sinua."
+    "title": "Paikannusinfra, joka on suunniteltu nopeille startup-yrityksille.",
+    "description": "Languine automatisoi paikannuksen kehittäjätyöskentelyssäsi ja prosessissasi, varmistaen, että käännökset eivät koskaan hidasta sinua."
   },
   "navigation": {
     "dashboard": "Ohjaamo",
@@ -20,8 +20,8 @@
   },
   "getStarted": {
     "heading": "Aloita",
-    "title": "Kehittäjille suunniteltu lokalisaatioinfrastruktuuri",
-    "description": "Languine automatisoi lokalisaation kehitysprosessissasi ja putkessasi, varmistaen että käännökset eivät hidasta sinua.",
+    "title": "Paikannusinfra, joka on suunniteltu nopeille startup-yrityksille.",
+    "description": "Languine automatisoi paikannuksen kehittäjätyöskentelyssäsi ja prosessissasi, varmistaen, että käännökset eivät koskaan hidasta sinua.",
     "button": {
       "startAutomating": "Aloita automaatio",
       "readDocumentation": "Lue dokumentaatio"
diff --git a/apps/web/src/messages/fr.json b/apps/web/src/messages/fr.json
index 5d433bbc..a5c5b738 100644
--- a/apps/web/src/messages/fr.json
+++ b/apps/web/src/messages/fr.json
@@ -6,7 +6,7 @@
     "goToApp": "Aller à l'application"
   },
   "hero": {
-    "title": "Infrastructure de localisation conçue pour les développeurs",
+    "title": "Infrastructure de localisation conçue pour les startups dynamiques.",
     "description": "Languine automatise la localisation dans votre flux de travail et votre pipeline de développement, garantissant que les traductions ne vous ralentissent jamais."
   },
   "navigation": {
@@ -20,7 +20,7 @@
   },
   "getStarted": {
     "heading": "Commencer",
-    "title": "Infrastructure de localisation conçue pour les développeurs",
+    "title": "Infrastructure de localisation conçue pour les startups dynamiques.",
     "description": "Languine automatise la localisation dans votre flux de travail et votre pipeline de développement, garantissant que les traductions ne vous ralentissent jamais.",
     "button": {
       "startAutomating": "Commencer à automatiser",
diff --git a/apps/web/src/messages/it.json b/apps/web/src/messages/it.json
index a41bd6e3..e0ef0eab 100644
--- a/apps/web/src/messages/it.json
+++ b/apps/web/src/messages/it.json
@@ -6,8 +6,8 @@
     "goToApp": "Vai all'app"
   },
   "hero": {
-    "title": "Infrastruttura di localizzazione creata per sviluppatori",
-    "description": "Languine automatizza la localizzazione all'interno del tuo flusso di lavoro e pipeline di sviluppo, assicurando che le traduzioni non ti rallentino mai."
+    "title": "Infrastruttura di localizzazione progettata per startup dinamiche.",
+    "description": "Languine automatizza la localizzazione all'interno del tuo flusso di lavoro e pipeline per sviluppatori, garantendo che le traduzioni non ti rallentino mai."
   },
   "navigation": {
     "dashboard": "Cruscotto",
@@ -20,8 +20,8 @@
   },
   "getStarted": {
     "heading": "Inizia",
-    "title": "Infrastruttura di localizzazione creata per sviluppatori",
-    "description": "Languine automatizza la localizzazione all'interno del tuo flusso di lavoro e pipeline di sviluppo, assicurando che le traduzioni non ti rallentino mai.",
+    "title": "Infrastruttura di localizzazione progettata per startup dinamiche.",
+    "description": "Languine automatizza la localizzazione all'interno del tuo flusso di lavoro e pipeline per sviluppatori, garantendo che le traduzioni non ti rallentino mai.",
     "button": {
       "startAutomating": "Inizia ad automatizzare",
       "readDocumentation": "Leggi la documentazione"
diff --git a/apps/web/src/messages/ko.json b/apps/web/src/messages/ko.json
index 2fb9b34f..3dc3e653 100644
--- a/apps/web/src/messages/ko.json
+++ b/apps/web/src/messages/ko.json
@@ -6,8 +6,8 @@
     "goToApp": "앱으로 가기"
   },
   "hero": {
-    "title": "개발자를 위한 로컬라이제이션 인프라",
-    "description": "Languine은 개발 워크플로우와 파이프라인 내에서 로컬라이제이션을 자동화하여 번역이 지연되지 않도록 보장합니다."
+    "title": "빠르게 성장하는 스타트업을 위한 현지화 인프라.",
+    "description": "Languine은 개발자 워크플로우와 파이프라인 내에서 현지화를 자동화하여 번역이 지연되지 않도록 보장합니다."
   },
   "navigation": {
     "dashboard": "대시보드",
@@ -20,8 +20,8 @@
   },
   "getStarted": {
     "heading": "시작하기",
-    "title": "개발자를 위한 로컬라이제이션 인프라",
-    "description": "Languine은 개발 워크플로우와 파이프라인 내에서 로컬라이제이션을 자동화하여 번역이 지연되지 않도록 보장합니다.",
+    "title": "빠르게 성장하는 스타트업을 위한 현지화 인프라.",
+    "description": "Languine은 개발자 워크플로우와 파이프라인 내에서 현지화를 자동화하여 번역이 지연되지 않도록 보장합니다.",
     "button": {
       "startAutomating": "자동화 시작하기",
       "readDocumentation": "문서 읽기"
diff --git a/apps/web/src/messages/nl.json b/apps/web/src/messages/nl.json
index 2079e7f0..eca25e42 100644
--- a/apps/web/src/messages/nl.json
+++ b/apps/web/src/messages/nl.json
@@ -6,8 +6,8 @@
     "goToApp": "Ga naar app"
   },
   "hero": {
-    "title": "Lokalisatie-infrastructuur gemaakt voor ontwikkelaars",
-    "description": "Languine automatiseert lokalisatie binnen uw ontwikkelingsworkflow en pipeline, zodat vertalingen u nooit ophouden."
+    "title": "Lokalisatie-infrastructuur gemaakt voor snelgroeiende startups.",
+    "description": "Languine automatiseert lokalisatie binnen uw ontwikkelaarsworkflow en -pipeline, zodat vertalingen u nooit vertragen."
   },
   "navigation": {
     "dashboard": "Dashboard",
@@ -20,8 +20,8 @@
   },
   "getStarted": {
     "heading": "Aan de slag",
-    "title": "Lokalisatie-infrastructuur gemaakt voor ontwikkelaars",
-    "description": "Languine automatiseert lokalisatie binnen uw ontwikkelingsworkflow en pipeline, zodat vertalingen u nooit ophouden.",
+    "title": "Lokalisatie-infrastructuur gemaakt voor snelgroeiende startups.",
+    "description": "Languine automatiseert lokalisatie binnen uw ontwikkelaarsworkflow en -pipeline, zodat vertalingen u nooit vertragen.",
     "button": {
       "startAutomating": "Begin met automatiseren",
       "readDocumentation": "Lees documentatie"
diff --git a/apps/web/src/messages/no.json b/apps/web/src/messages/no.json
index a7657c99..e57ddea9 100644
--- a/apps/web/src/messages/no.json
+++ b/apps/web/src/messages/no.json
@@ -6,8 +6,8 @@
     "goToApp": "Gå til app"
   },
   "hero": {
-    "title": "Lokalisering infrastruktur laget for utviklere",
-    "description": "Languine automatiserer lokalisering innen din utviklingsarbeidsflyt og pipeline, og sikrer at oversettelser aldri holder deg tilbake."
+    "title": "Lokaliseringinfrastruktur laget for raske oppstartsselskaper.",
+    "description": "Languine automatiserer lokalisering innenfor utviklerarbeidsflyten og -pipen din, og sikrer at oversettelser aldri forsinker deg."
   },
   "navigation": {
     "dashboard": "Dashbord",
@@ -20,8 +20,8 @@
   },
   "getStarted": {
     "heading": "Kom i gang",
-    "title": "Lokalisering infrastruktur laget for utviklere",
-    "description": "Languine automatiserer lokalisering innen din utviklingsarbeidsflyt og pipeline, og sikrer at oversettelser aldri holder deg tilbake.",
+    "title": "Lokaliseringinfrastruktur laget for raske oppstartsselskaper.",
+    "description": "Languine automatiserer lokalisering innenfor utviklerarbeidsflyten og -pipen din, og sikrer at oversettelser aldri forsinker deg.",
     "button": {
       "startAutomating": "Start automatisering",
       "readDocumentation": "Les dokumentasjon"
diff --git a/apps/web/src/messages/pl.json b/apps/web/src/messages/pl.json
index 47c0f51a..6f4fe4e2 100644
--- a/apps/web/src/messages/pl.json
+++ b/apps/web/src/messages/pl.json
@@ -6,8 +6,8 @@
     "goToApp": "Przejdź do aplikacji"
   },
   "hero": {
-    "title": "Infrastruktura lokalizacyjna stworzona dla deweloperów",
-    "description": "Languine automatyzuje lokalizację w Twoim procesie rozwoju i pipeline, zapewniając, że tłumaczenia nigdy nie będą Cię spowalniać."
+    "title": "Infrastruktura lokalizacyjna stworzona dla dynamicznych startupów.",
+    "description": "Languine automatyzuje lokalizację w Twoim procesie deweloperskim i pipeline, zapewniając, że tłumaczenia nigdy nie będą Cię spowalniać."
   },
   "navigation": {
     "dashboard": "Panel",
@@ -20,8 +20,8 @@
   },
   "getStarted": {
     "heading": "Rozpocznij",
-    "title": "Infrastruktura lokalizacyjna stworzona dla deweloperów",
-    "description": "Languine automatyzuje lokalizację w Twoim procesie rozwoju i pipeline, zapewniając, że tłumaczenia nigdy nie będą Cię spowalniać.",
+    "title": "Infrastruktura lokalizacyjna stworzona dla dynamicznych startupów.",
+    "description": "Languine automatyzuje lokalizację w Twoim procesie deweloperskim i pipeline, zapewniając, że tłumaczenia nigdy nie będą Cię spowalniać.",
     "button": {
       "startAutomating": "Rozpocznij automatyzację",
       "readDocumentation": "Przeczytaj dokumentację"
diff --git a/apps/web/src/messages/pt.json b/apps/web/src/messages/pt.json
index 25db63df..b8df7cbe 100644
--- a/apps/web/src/messages/pt.json
+++ b/apps/web/src/messages/pt.json
@@ -6,8 +6,8 @@
     "goToApp": "Ir para o aplicativo"
   },
   "hero": {
-    "title": "Infraestrutura de localização feita para desenvolvedores",
-    "description": "O Languine automatiza a localização dentro do seu fluxo de trabalho e pipeline de desenvolvimento, garantindo que as traduções nunca o atrasem."
+    "title": "Infraestrutura de localização feita para startups ágeis.",
+    "description": "A Languine automatiza a localização dentro do seu fluxo de trabalho e pipeline de desenvolvimento, garantindo que as traduções nunca atrasem você."
   },
   "navigation": {
     "dashboard": "Painel",
@@ -20,8 +20,8 @@
   },
   "getStarted": {
     "heading": "Comece agora",
-    "title": "Infraestrutura de localização feita para desenvolvedores",
-    "description": "O Languine automatiza a localização dentro do seu fluxo de trabalho e pipeline de desenvolvimento, garantindo que as traduções nunca o atrasem.",
+    "title": "Infraestrutura de localização feita para startups ágeis.",
+    "description": "A Languine automatiza a localização dentro do seu fluxo de trabalho e pipeline de desenvolvimento, garantindo que as traduções nunca atrasem você.",
     "button": {
       "startAutomating": "Começar a automatizar",
       "readDocumentation": "Ler documentação"
diff --git a/apps/web/src/messages/sv.json b/apps/web/src/messages/sv.json
index 03004ebc..1b5ba5e2 100644
--- a/apps/web/src/messages/sv.json
+++ b/apps/web/src/messages/sv.json
@@ -26,13 +26,13 @@
     "account": "Konto"
   },
   "hero": {
-    "title": "Lokalisering infrastruktur skapad för utvecklare",
-    "description": "Languine automatiserar lokalisering inom din utvecklingsarbetsflöde och pipeline, vilket säkerställer att översättningar aldrig hindrar dig."
+    "title": "Lokalisering infrastruktur skapad för snabbrörliga startups.",
+    "description": "Languine automatiserar lokalisering inom din utvecklararbetsflöde och pipeline, vilket säkerställer att översättningar aldrig sätter stopp för dig."
   },
   "getStarted": {
     "heading": "Kom igång",
-    "title": "Lokalisering infrastruktur skapad för utvecklare",
-    "description": "Languine automatiserar lokalisering inom din utvecklingsarbetsflöde och pipeline, vilket säkerställer att översättningar aldrig hindrar dig.",
+    "title": "Lokalisering infrastruktur skapad för snabbrörliga startups.",
+    "description": "Languine automatiserar lokalisering inom din utvecklararbetsflöde och pipeline, vilket säkerställer att översättningar aldrig sätter stopp för dig.",
     "button": {
       "startAutomating": "Börja automatisera",
       "readDocumentation": "Läs dokumentation"