Chungus

.dockerignore

@@ -28,4 +28,5 @@ LICENSE
 CONTRIBUTING.md
 dist
 .git
+migrations/
 config/

.github/workflows/test.yml

@@ -26,6 +26,9 @@ jobs:
       - name: Create database index.ts
         run: echo 'export * from "./sqlite";' > server/db/index.ts
 
+      - name: Create build file
+        run: echo 'export const build = 'oss' as any;' > server/build.ts
+
       - name: Generate database migrations
         run: npm run db:sqlite:generate
 

.gitignore

@@ -25,7 +25,10 @@ next-env.d.ts
 *-audit.json
 migrations
 tsconfig.tsbuildinfo
-config/config.yml
+config/config.saas.yml
+config/config.oss.yml
+config/config.enterprise.yml
+config/privateConfig.yml
 config/postgres
 config/postgres*
 config/openapi.yaml
@@ -44,3 +47,4 @@ server/build.ts
 postgres/
 dynamic/
 certificates/ 
+*.mmdb

Dockerfile

@@ -40,7 +40,6 @@ COPY ./cli/wrapper.sh /usr/local/bin/pangctl
 RUN chmod +x /usr/local/bin/pangctl ./dist/cli.mjs
 
 COPY server/db/names.json ./dist/names.json
-
 COPY public ./public
 
 CMD ["npm", "run", "start"]

LICENSE

@@ -1,3 +1,34 @@
+Copyright (c) 2025 Fossorial, Inc.
+
+Portions of this software are licensed as follows:
+
+* All files that include a header specifying they are licensed under the
+  "Fossorial Commercial License" are governed by the Fossorial Commercial
+  License terms. The specific terms applicable to each customer depend on the
+  commercial license tier agreed upon in writing with Fossorial, Inc.
+  Unauthorized use, copying, modification, or distribution is strictly
+  prohibited.
+
+* All files that include a header specifying they are licensed under the GNU
+  Affero General Public License, Version 3 ("AGPL-3"), are governed by the
+  AGPL-3 terms. A full copy of the AGPL-3 license is provided below. However,
+  these files are also available under the Fossorial Commercial License if a
+  separate commercial license agreement has been executed between the customer
+  and Fossorial, Inc.
+
+* All files without a license header are, by default, licensed under the GNU
+  Affero General Public License, Version 3 (AGPL-3). These files may also be
+  made available under the Fossorial Commercial License upon agreement with
+  Fossorial, Inc.
+
+* All third-party components included in this repository are licensed under
+  their respective original licenses, as provided by their authors.
+
+Please consult the header of each individual file to determine the applicable
+license. For AGPL-3 licensed files, dual-licensing under the Fossorial
+Commercial License is available subject to written agreement with Fossorial,
+Inc.
+
                     GNU AFFERO GENERAL PUBLIC LICENSE
                        Version 3, 19 November 2007
 

bruno/API Keys/Create API Key.bru

@@ -0,0 +1,17 @@
+meta {
+  name: Create API Key
+  type: http
+  seq: 1
+}
+
+put {
+  url: http://localhost:3000/api/v1/api-key
+  body: json
+  auth: inherit
+}
+
+body:json {
+  {
+    "isRoot": true
+  }
+}

bruno/API Keys/Delete API Key.bru

@@ -0,0 +1,11 @@
+meta {
+  name: Delete API Key
+  type: http
+  seq: 2
+}
+
+delete {
+  url: http://localhost:3000/api/v1/api-key/dm47aacqxxn3ubj
+  body: none
+  auth: inherit
+}

bruno/API Keys/List API Key Actions.bru

@@ -0,0 +1,11 @@
+meta {
+  name: List API Key Actions
+  type: http
+  seq: 6
+}
+
+get {
+  url: http://localhost:3000/api/v1/api-key/ex0izu2c37fjz9x/actions
+  body: none
+  auth: inherit
+}

bruno/API Keys/List Org API Keys.bru

@@ -0,0 +1,11 @@
+meta {
+  name: List Org API Keys
+  type: http
+  seq: 4
+}
+
+get {
+  url: http://localhost:3000/api/v1/org/home-lab/api-keys
+  body: none
+  auth: inherit
+}

bruno/API Keys/List Root API Keys.bru

@@ -0,0 +1,11 @@
+meta {
+  name: List Root API Keys
+  type: http
+  seq: 3
+}
+
+get {
+  url: http://localhost:3000/api/v1/root/api-keys
+  body: none
+  auth: inherit
+}

bruno/API Keys/Set API Key Actions.bru

@@ -0,0 +1,17 @@
+meta {
+  name: Set API Key Actions
+  type: http
+  seq: 5
+}
+
+post {
+  url: http://localhost:3000/api/v1/api-key/ex0izu2c37fjz9x/actions
+  body: json
+  auth: inherit
+}
+
+body:json {
+  {
+    "actionIds": ["listSites"]
+  }
+}

bruno/API Keys/Set API Key Orgs.bru

@@ -0,0 +1,17 @@
+meta {
+  name: Set API Key Orgs
+  type: http
+  seq: 7
+}
+
+post {
+  url: http://localhost:3000/api/v1/api-key/ex0izu2c37fjz9x/orgs
+  body: json
+  auth: inherit
+}
+
+body:json {
+  {
+    "orgIds": ["home-lab"]
+  }
+}

bruno/API Keys/folder.bru

@@ -0,0 +1,3 @@
+meta {
+  name: API Keys
+}

bruno/Auth/login.bru

@@ -5,14 +5,14 @@ meta {
 }
 
 post {
-  url: http://localhost:3000/api/v1/auth/login
+  url: http://localhost:4000/api/v1/auth/login
   body: json
   auth: none
 }
 
 body:json {
   {
-    "email": "admin@fosrl.io",
+    "email": "owen@fossorial.io",
     "password": "Password123!"
   }
 }

bruno/Auth/logout.bru

@@ -5,7 +5,7 @@ meta {
 }
 
 post {
-  url: http://localhost:3000/api/v1/auth/logout
+  url: http://localhost:4000/api/v1/auth/logout
   body: none
   auth: none
 }

bruno/IDP/Create OIDC Provider.bru

@@ -0,0 +1,22 @@
+meta {
+  name: Create OIDC Provider
+  type: http
+  seq: 1
+}
+
+put {
+  url: http://localhost:3000/api/v1/org/home-lab/idp/oidc
+  body: json
+  auth: inherit
+}
+
+body:json {
+  {
+    "clientId": "JJoSvHCZcxnXT2sn6CObj6a21MuKNRXs3kN5wbys",
+    "clientSecret": "2SlGL2wOGgMEWLI9yUuMAeFxre7qSNJVnXMzyepdNzH1qlxYnC4lKhhQ6a157YQEkYH3vm40KK4RCqbYiF8QIweuPGagPX3oGxEj2exwutoXFfOhtq4hHybQKoFq01Z3",
+    "authUrl": "http://localhost:9000/application/o/authorize/",
+    "tokenUrl": "http://localhost:9000/application/o/token/",
+    "scopes": ["email", "openid", "profile"],
+    "userIdentifier": "email"
+  }
+}

bruno/IDP/Generate OIDC URL.bru

@@ -0,0 +1,11 @@
+meta {
+  name: Generate OIDC URL
+  type: http
+  seq: 2
+}
+
+get {
+  url: http://localhost:3000/api/v1
+  body: none
+  auth: inherit
+}

bruno/IDP/folder.bru

@@ -0,0 +1,3 @@
+meta {
+  name: IDP
+}

bruno/Internal/Traefik Config.bru

@@ -0,0 +1,11 @@
+meta {
+  name: Traefik Config
+  type: http
+  seq: 1
+}
+
+get {
+  url: http://localhost:3001/api/v1/traefik-config
+  body: none
+  auth: inherit
+}

bruno/Internal/folder.bru

@@ -0,0 +1,3 @@
+meta {
+  name: Internal
+}

bruno/Remote Exit Node/createRemoteExitNode.bru

@@ -0,0 +1,11 @@
+meta {
+  name: createRemoteExitNode
+  type: http
+  seq: 1
+}
+
+put {
+  url: http://localhost:4000/api/v1/org/org_i21aifypnlyxur2/remote-exit-node
+  body: none
+  auth: none
+}

bruno/Test.bru

@@ -0,0 +1,11 @@
+meta {
+  name: Test
+  type: http
+  seq: 2
+}
+
+get {
+  url: http://localhost:3000/api/v1
+  body: none
+  auth: inherit
+}

bruno/bruno.json

@@ -1,6 +1,6 @@
 {
   "version": "1",
-  "name": "Pangolin",
+  "name": "Pangolin Saas",
   "type": "collection",
   "ignore": [
     "node_modules",

config/config.yml

@@ -0,0 +1,39 @@
+app:
+  dashboard_url: "https://pangolin.internal"
+  log_level: debug
+server:
+  cors:
+    origins:
+        - "https://pangolin.internal"
+    methods:
+        - "GET"
+        - "POST"
+        - "PUT"
+        - "DELETE"
+        - "PATCH"
+    allowed_headers:
+        - "X-CSRF-Token"
+        - "Content-Type"
+    credentials: true
+  secret: 1b5f55122e7611f0bf624bafe52c91daadsfjhksd234
+gerbil:
+  base_endpoint: pangolin.fosrl.io
+flags:
+  require_email_verification: true
+  disable_signup_without_invite: false
+  disable_user_create_org: true
+  allow_base_domain_resources: false
+  disable_local_sites: false
+  disable_basic_wireguard_sites: true
+  enable_integration_api: true
+  disable_config_managed_domains: true
+  hide_supporter_key: true
+  enable_redis: true
+  enable_clients: true
+  allow_raw_resources: true
+email:
+  smtp_host: "email-smtp.us-east-1.amazonaws.com"
+  smtp_port: 587
+  smtp_user: "AKIATFBMPNE6PKLOK4MK"
+  smtp_pass: "BHStM/Nz9B9Crt3YePtsVDnjEp4MZmXqoQvZXWk0MQTC"
+  no_reply: no-reply@fossorial.io

docker-compose.pgr.yml

@@ -11,4 +11,11 @@ services:
       - ./config/postgres:/var/lib/postgresql/data
     ports:
       - "5432:5432" # Map host port 5432 to container port 5432
+    restart: no 
+
+  redis:
+    image: redis:latest # Use the latest Redis image
+    container_name: dev_redis # Name your Redis container
+    ports:
+      - "6379:6379" # Map host port 6379 to container port 6379
     restart: no

docker-compose.t.yml

@@ -1,32 +0,0 @@
-name: pangolin
-services:
-  gerbil:
-    image: gerbil
-    container_name: gerbil
-    network_mode: host
-    restart: unless-stopped
-    command:
-      - --reachableAt=http://localhost:3003
-      - --generateAndSaveKeyTo=/var/config/key
-      - --remoteConfig=http://localhost:3001/api/v1/
-      - --sni-port=443
-    volumes:
-      - ./config/:/var/config
-    cap_add:
-      - NET_ADMIN
-      - SYS_MODULE
-
-  traefik:
-    image: docker.io/traefik:v3.4.1
-    container_name: traefik
-    restart: unless-stopped
-    network_mode: host
-    command:
-      - --configFile=/etc/traefik/traefik_config.yml
-    volumes:
-      - ./config/traefik:/etc/traefik:ro # Volume to store the Traefik configuration
-      - ./config/letsencrypt:/letsencrypt # Volume to store the Let's Encrypt certificates
-      - ./config/traefik/logs:/var/log/traefik # Volume to store Traefik logs
-      - ./certificates:/var/certificates:ro
-      - ./dynamic:/var/dynamic:ro
-

drizzle.pg.config.ts

@@ -1,9 +1,20 @@
 import { defineConfig } from "drizzle-kit";
 import path from "path";
+import { build } from "@server/build";
+
+let schema;
+if (build === "oss") {
+    schema = [path.join("server", "db", "pg", "schema.ts")];
+} else {
+    schema = [
+        path.join("server", "db", "pg", "schema.ts"),
+        path.join("server", "db", "pg", "privateSchema.ts")
+    ];
+}
 
 export default defineConfig({
     dialect: "postgresql",
-    schema: [path.join("server", "db", "pg", "schema.ts")],
+    schema: schema,
     out: path.join("server", "migrations"),
     verbose: true,
     dbCredentials: {

drizzle.sqlite.config.ts

@@ -1,10 +1,21 @@
+import { build } from "@server/build";
 import { APP_PATH } from "@server/lib/consts";
 import { defineConfig } from "drizzle-kit";
 import path from "path";
 
+let schema;
+if (build === "oss") {
+    schema = [path.join("server", "db", "sqlite", "schema.ts")];
+} else {
+    schema = [
+        path.join("server", "db", "sqlite", "schema.ts"),
+        path.join("server", "db", "sqlite", "privateSchema.ts")
+    ];
+}
+
 export default defineConfig({
     dialect: "sqlite",
-    schema: path.join("server", "db", "sqlite", "schema.ts"),
+    schema: schema,
     out: path.join("server", "migrations"),
     verbose: true,
     dbCredentials: {

messages/cs-CZ.json

@@ -168,6 +168,9 @@
     "siteSelect": "Vybrat lokalitu",
     "siteSearch": "Hledat lokalitu",
     "siteNotFound": "Nebyla nalezena žádná lokalita.",
+    "selectCountry": "Vyberte zemi",
+    "searchCountries": "Hledat země...",
+    "noCountryFound": "Nebyla nalezena žádná země.",
     "siteSelectionDescription": "Tato lokalita poskytne připojení k cíli.",
     "resourceType": "Typ zdroje",
     "resourceTypeDescription": "Určete, jak chcete přistupovat ke svému zdroji",
@@ -1257,6 +1260,48 @@
     "domainPickerSubdomain": "Subdoména: {subdomain}",
     "domainPickerNamespace": "Jmenný prostor: {namespace}",
     "domainPickerShowMore": "Zobrazit více",
+    "regionSelectorTitle": "Vybrat region",
+    "regionSelectorInfo": "Výběr regionu nám pomáhá poskytovat lepší výkon pro vaši polohu. Nemusíte být ve stejném regionu jako váš server.",
+    "regionSelectorPlaceholder": "Vyberte region",
+    "regionSelectorComingSoon": "Již brzy",
+    "billingLoadingSubscription": "Načítání odběru...",
+    "billingFreeTier": "Volná úroveň",
+    "billingWarningOverLimit": "Upozornění: Překročili jste jeden nebo více omezení používání. Vaše stránky se nepřipojí dokud nezměníte předplatné nebo neupravíte své používání.",
+    "billingUsageLimitsOverview": "Přehled omezení použití",
+    "billingMonitorUsage": "Sledujte vaše využití pomocí nastavených limitů. Pokud potřebujete zvýšit limity, kontaktujte nás prosím support@fossorial.io.",
+    "billingDataUsage": "Využití dat",
+    "billingOnlineTime": "Stránka online čas",
+    "billingUsers": "Aktivní uživatelé",
+    "billingDomains": "Aktivní domény",
+    "billingRemoteExitNodes": "Aktivní Samostatně hostované uzly",
+    "billingNoLimitConfigured": "Žádný limit nenastaven",
+    "billingEstimatedPeriod": "Odhadované období fakturace",
+    "billingIncludedUsage": "Zahrnuto využití",
+    "billingIncludedUsageDescription": "Využití zahrnované s aktuálním plánem předplatného",
+    "billingFreeTierIncludedUsage": "Povolenky bezplatné úrovně využití",
+    "billingIncluded": "zahrnuto",
+    "billingEstimatedTotal": "Odhadovaný celkem:",
+    "billingNotes": "Poznámky",
+    "billingEstimateNote": "Toto je odhad založený na aktuálním využití.",
+    "billingActualChargesMayVary": "Skutečné náklady se mohou lišit.",
+    "billingBilledAtEnd": "Budete účtováni na konci fakturační doby.",
+    "billingModifySubscription": "Upravit předplatné",
+    "billingStartSubscription": "Začít předplatné",
+    "billingRecurringCharge": "Opakované nabití",
+    "billingManageSubscriptionSettings": "Spravovat nastavení a nastavení předplatného",
+    "billingNoActiveSubscription": "Nemáte aktivní předplatné. Začněte předplatné, abyste zvýšili omezení používání.",
+    "billingFailedToLoadSubscription": "Nepodařilo se načíst odběr",
+    "billingFailedToLoadUsage": "Nepodařilo se načíst využití",
+    "billingFailedToGetCheckoutUrl": "Nepodařilo se získat adresu URL pokladny",
+    "billingPleaseTryAgainLater": "Zkuste to prosím znovu později.",
+    "billingCheckoutError": "Chyba pokladny",
+    "billingFailedToGetPortalUrl": "Nepodařilo se získat URL portálu",
+    "billingPortalError": "Chyba portálu",
+    "billingDataUsageInfo": "Pokud jste připojeni k cloudu, jsou vám účtována všechna data přenášená prostřednictvím zabezpečených tunelů. To zahrnuje příchozí i odchozí provoz na všech vašich stránkách. Jakmile dosáhnete svého limitu, vaše stránky se odpojí, dokud neaktualizujete svůj tarif nebo nezmenšíte jeho používání. Data nejsou nabírána při používání uzlů.",
+    "billingOnlineTimeInfo": "Platíte na základě toho, jak dlouho budou vaše stránky připojeny k cloudu. Například, 44,640 minut se rovná jedné stránce 24/7 po celý měsíc. Jakmile dosáhnete svého limitu, vaše stránky se odpojí, dokud neaktualizujete svůj tarif nebo nezkrátíte jeho používání. Čas není vybírán při používání uzlů.",
+    "billingUsersInfo": "Obdrželi jste platbu za každého uživatele ve vaší organizaci. Fakturace je počítána denně na základě počtu aktivních uživatelských účtů ve vašem org.",
+    "billingDomainInfo": "Platba je účtována za každou doménu ve vaší organizaci. Fakturace je počítána denně na základě počtu aktivních doménových účtů na Vašem org.",
+    "billingRemoteExitNodesInfo": "Za každý spravovaný uzel ve vaší organizaci se vám účtuje denně. Fakturace je počítána na základě počtu aktivních spravovaných uzlů ve vašem org.",
     "domainNotFound": "Doména nenalezena",
     "domainNotFoundDescription": "Tento dokument je zakázán, protože doména již neexistuje náš systém. Nastavte prosím novou doménu pro tento dokument.",
     "failed": "Selhalo",
@@ -1320,6 +1365,7 @@
     "createDomainDnsPropagationDescription": "Změna DNS může trvat nějakou dobu, než se šíří po internetu. To může trvat kdekoli od několika minut do 48 hodin v závislosti na poskytovateli DNS a nastavení TTL.",
     "resourcePortRequired": "Pro neHTTP zdroje je vyžadováno číslo portu",
     "resourcePortNotAllowed": "Číslo portu by nemělo být nastaveno pro HTTP zdroje",
+    "billingPricingCalculatorLink": "Cenová kalkulačka",
     "signUpTerms": {
         "IAgreeToThe": "Souhlasím s",
         "termsOfService": "podmínky služby",
@@ -1368,6 +1414,41 @@
     "addNewTarget": "Add New Target",
     "targetsList": "Seznam cílů",
     "targetErrorDuplicateTargetFound": "Byl nalezen duplicitní cíl",
+    "healthCheckHealthy": "Zdravé",
+    "healthCheckUnhealthy": "Nezdravé",
+    "healthCheckUnknown": "Neznámý",
+    "healthCheck": "Kontrola stavu",
+    "configureHealthCheck": "Konfigurace kontroly stavu",
+    "configureHealthCheckDescription": "Nastavit sledování zdravotního stavu pro {target}",
+    "enableHealthChecks": "Povolit kontrolu stavu",
+    "enableHealthChecksDescription": "Sledujte zdraví tohoto cíle. V případě potřeby můžete sledovat jiný cílový bod, než je cíl.",
+    "healthScheme": "Způsob",
+    "healthSelectScheme": "Vybrat metodu",
+    "healthCheckPath": "Cesta",
+    "healthHostname": "IP / Hostitel",
+    "healthPort": "Přístav",
+    "healthCheckPathDescription": "Cesta ke kontrole zdravotního stavu.",
+    "healthyIntervalSeconds": "Interval zdraví",
+    "unhealthyIntervalSeconds": "Nezdravý interval",
+    "IntervalSeconds": "Interval zdraví",
+    "timeoutSeconds": "Časový limit",
+    "timeIsInSeconds": "Čas je v sekundách",
+    "retryAttempts": "Opakovat pokusy",
+    "expectedResponseCodes": "Očekávané kódy odezvy",
+    "expectedResponseCodesDescription": "HTTP kód stavu, který označuje zdravý stav. Ponecháte-li prázdné, 200-300 je považováno za zdravé.",
+    "customHeaders": "Vlastní záhlaví",
+    "customHeadersDescription": "Záhlaví oddělená nová řádka: hodnota",
+    "headersValidationError": "Headers must be in the format: Header-Name: value.",
+    "saveHealthCheck": "Uložit kontrolu stavu",
+    "healthCheckSaved": "Kontrola stavu uložena",
+    "healthCheckSavedDescription": "Nastavení kontroly stavu bylo úspěšně uloženo",
+    "healthCheckError": "Chyba kontroly stavu",
+    "healthCheckErrorDescription": "Došlo k chybě při ukládání konfigurace kontroly stavu",
+    "healthCheckPathRequired": "Je vyžadována cesta kontroly stavu",
+    "healthCheckMethodRequired": "HTTP metoda je povinná",
+    "healthCheckIntervalMin": "Interval kontroly musí být nejméně 5 sekund",
+    "healthCheckTimeoutMin": "Časový limit musí být nejméně 1 sekunda",
+    "healthCheckRetryMin": "Pokusy opakovat musí být alespoň 1",
     "httpMethod": "HTTP metoda",
     "selectHttpMethod": "Vyberte HTTP metodu",
     "domainPickerSubdomainLabel": "Subdoména",
@@ -1381,6 +1462,7 @@
     "domainPickerEnterSubdomainToSearch": "Zadejte subdoménu pro hledání a výběr z dostupných domén zdarma.",
     "domainPickerFreeDomains": "Volné domény",
     "domainPickerSearchForAvailableDomains": "Hledat dostupné domény",
+    "domainPickerNotWorkSelfHosted": "Poznámka: Poskytnuté domény nejsou momentálně k dispozici pro vlastní hostované instance.",
     "resourceDomain": "Doména",
     "resourceEditDomain": "Upravit doménu",
     "siteName": "Název webu",
@@ -1463,6 +1545,72 @@
     "autoLoginError": "Automatická chyba přihlášení",
     "autoLoginErrorNoRedirectUrl": "Od poskytovatele identity nebyla obdržena žádná adresa URL.",
     "autoLoginErrorGeneratingUrl": "Nepodařilo se vygenerovat ověřovací URL.",
+    "remoteExitNodeManageRemoteExitNodes": "Spravovat vlastní hostování",
+    "remoteExitNodeDescription": "Spravujte uzly pro rozšíření připojení k síti",
+    "remoteExitNodes": "Nodes",
+    "searchRemoteExitNodes": "Hledat uzly...",
+    "remoteExitNodeAdd": "Přidat uzel",
+    "remoteExitNodeErrorDelete": "Chyba při odstraňování uzlu",
+    "remoteExitNodeQuestionRemove": "Jste si jisti, že chcete odstranit uzel {selectedNode} z organizace?",
+    "remoteExitNodeMessageRemove": "Po odstranění uzel již nebude přístupný.",
+    "remoteExitNodeMessageConfirm": "Pro potvrzení zadejte název uzlu níže.",
+    "remoteExitNodeConfirmDelete": "Potvrdit odstranění uzlu",
+    "remoteExitNodeDelete": "Odstranit uzel",
+    "sidebarRemoteExitNodes": "Nodes",
+    "remoteExitNodeCreate": {
+        "title": "Vytvořit uzel",
+        "description": "Vytvořit nový uzel pro rozšíření síťového připojení",
+        "viewAllButton": "Zobrazit všechny uzly",
+        "strategy": {
+            "title": "Strategie tvorby",
+            "description": "Vyberte pro manuální konfiguraci vašeho uzlu nebo vygenerujte nové přihlašovací údaje.",
+            "adopt": {
+                "title": "Přijmout uzel",
+                "description": "Zvolte tuto možnost, pokud již máte přihlašovací údaje k uzlu."
+            },
+            "generate": {
+                "title": "Generovat klíče",
+                "description": "Vyberte tuto možnost, pokud chcete vygenerovat nové klíče pro uzel"
+            }
+        },
+        "adopt": {
+            "title": "Přijmout existující uzel",
+            "description": "Zadejte přihlašovací údaje existujícího uzlu, který chcete přijmout",
+            "nodeIdLabel": "ID uzlu",
+            "nodeIdDescription": "ID existujícího uzlu, který chcete přijmout",
+            "secretLabel": "Tajný klíč",
+            "secretDescription": "Tajný klíč existujícího uzlu",
+            "submitButton": "Přijmout uzel"
+        },
+        "generate": {
+            "title": "Vygenerovaná pověření",
+            "description": "Použijte tyto generované přihlašovací údaje pro nastavení vašeho uzlu",
+            "nodeIdTitle": "ID uzlu",
+            "secretTitle": "Tajný klíč",
+            "saveCredentialsTitle": "Přidat přihlašovací údaje do konfigurace",
+            "saveCredentialsDescription": "Přidejte tyto přihlašovací údaje do vlastního konfiguračního souboru Pangolin uzlu pro dokončení připojení.",
+            "submitButton": "Vytvořit uzel"
+        },
+        "validation": {
+            "adoptRequired": "ID uzlu a tajný klíč jsou vyžadovány při přijetí existujícího uzlu"
+        },
+        "errors": {
+            "loadDefaultsFailed": "Nepodařilo se načíst výchozí hodnoty",
+            "defaultsNotLoaded": "Výchozí hodnoty nebyly načteny",
+            "createFailed": "Nepodařilo se vytvořit uzel"
+        },
+        "success": {
+            "created": "Uzel byl úspěšně vytvořen"
+        }
+    },
+    "remoteExitNodeSelection": "Výběr uzlu",
+    "remoteExitNodeSelectionDescription": "Vyberte uzel pro směrování provozu přes tuto lokální stránku",
+    "remoteExitNodeRequired": "Pro lokální stránky musí být vybrán uzel",
+    "noRemoteExitNodesAvailable": "Nejsou k dispozici žádné uzly",
+    "noRemoteExitNodesAvailableDescription": "Pro tuto organizaci nejsou k dispozici žádné uzly. Nejprve vytvořte uzel pro použití lokálních stránek.",
+    "exitNode": "Ukončit uzel",
+    "country": "L 343, 22.12.2009, s. 1).",
+    "rulesMatchCountry": "Aktuálně založené na zdrojové IP adrese",
     "managedSelfHosted": {
         "title": "Spravované vlastní hostování",
         "description": "Spolehlivější a nízko udržovaný Pangolinův server s dalšími zvony a bičkami",
@@ -1501,11 +1649,51 @@
     },
     "internationaldomaindetected": "Zjištěna mezinárodní doména",
     "willbestoredas": "Bude uloženo jako:",
+    "roleMappingDescription": "Určete, jak jsou role přiřazeny uživatelům, když se přihlásí, když je povoleno automatické poskytnutí služby.",
+    "selectRole": "Vyberte roli",
+    "roleMappingExpression": "Výraz",
+    "selectRolePlaceholder": "Vyberte roli",
+    "selectRoleDescription": "Vyberte roli pro přiřazení všem uživatelům od tohoto poskytovatele identity",
+    "roleMappingExpressionDescription": "Zadejte výraz JMESPath pro získání informací o roli z ID token",
+    "idpTenantIdRequired": "ID nájemce je povinné",
+    "invalidValue": "Neplatná hodnota",
+    "idpTypeLabel": "Typ poskytovatele identity",
+    "roleMappingExpressionPlaceholder": "např. obsahuje(skupiny, 'admin') && 'Admin' || 'Member'",
+    "idpGoogleConfiguration": "Konfigurace Google",
+    "idpGoogleConfigurationDescription": "Konfigurace přihlašovacích údajů Google OAuth2",
+    "idpGoogleClientIdDescription": "Vaše ID klienta Google OAuth2",
+    "idpGoogleClientSecretDescription": "Tajný klíč klienta Google OAuth2",
+    "idpAzureConfiguration": "Nastavení Azure Entra ID",
+    "idpAzureConfigurationDescription": "Nastavte vaše Azure Entra ID OAuth2",
+    "idpTenantId": "Tenant ID",
+    "idpTenantIdPlaceholder": "vaše-tenant-id",
+    "idpAzureTenantIdDescription": "Vaše Azure nájemce ID (nalezeno v přehledu Azure Active Directory – Azure)",
+    "idpAzureClientIdDescription": "Vaše ID registrace aplikace Azure",
+    "idpAzureClientSecretDescription": "Tajný klíč registrace aplikace Azure",
+    "idpGoogleTitle": "Google",
+    "idpAzureTitle": "Azure Entra ID",
+    "idpGoogleConfigurationTitle": "Konfigurace Google",
+    "idpAzureConfigurationTitle": "Nastavení Azure Entra ID",
+    "idpTenantIdLabel": "Tenant ID",
+    "idpAzureClientIdDescription2": "Vaše ID registrace aplikace Azure",
+    "idpAzureClientSecretDescription2": "Tajný klíč registrace aplikace Azure",
+    "subnet": "Podsíť",
+    "subnetDescription": "Podsíť pro konfiguraci sítě této organizace.",
+    "authPage": "Auth stránka",
+    "authPageDescription": "Konfigurace autentizační stránky vaší organizace",
+    "authPageDomain": "Doména ověření stránky",
+    "noDomainSet": "Není nastavena žádná doména",
+    "changeDomain": "Změnit doménu",
+    "selectDomain": "Vybrat doménu",
+    "restartCertificate": "Restartovat certifikát",
+    "editAuthPageDomain": "Upravit doménu autentizační stránky",
+    "setAuthPageDomain": "Nastavit doménu autentické stránky",
+    "failedToFetchCertificate": "Nepodařilo se načíst certifikát",
+    "failedToRestartCertificate": "Restartování certifikátu se nezdařilo",
+    "addDomainToEnableCustomAuthPages": "Přidejte doménu pro povolení vlastních ověřovacích stránek pro vaši organizaci",
+    "selectDomainForOrgAuthPage": "Vyberte doménu pro ověřovací stránku organizace",
     "idpGoogleDescription": "Poskytovatel Google OAuth2/OIDC",
     "idpAzureDescription": "Microsoft Azure OAuth2/OIDC provider",
-    "customHeaders": "Vlastní záhlaví",
-    "customHeadersDescription": "Add custom headers to be sent when proxying requests. One per line in the format Header-Name: value",
-    "headersValidationError": "Záhlaví musí být ve formátu: název záhlaví: hodnota.",
     "domainPickerProvidedDomain": "Poskytnutá doména",
     "domainPickerFreeProvidedDomain": "Zdarma poskytnutá doména",
     "domainPickerVerified": "Ověřeno",
@@ -1519,10 +1707,16 @@
     "domainPickerInvalidSubdomainCannotMakeValid": "\"{sub}\" nemohl být platný pro {domain}.",
     "domainPickerSubdomainSanitized": "Upravená subdoména",
     "domainPickerSubdomainCorrected": "\"{sub}\" bylo opraveno na \"{sanitized}\"",
+    "orgAuthSignInTitle": "Přihlaste se do vaší organizace",
+    "orgAuthChooseIdpDescription": "Chcete-li pokračovat, vyberte svého poskytovatele identity",
+    "orgAuthNoIdpConfigured": "Tato organizace nemá nakonfigurovány žádné poskytovatele identity. Místo toho se můžete přihlásit s vaší Pangolinovou identitou.",
+    "orgAuthSignInWithPangolin": "Přihlásit se pomocí Pangolinu",
+    "subscriptionRequiredToUse": "Pro použití této funkce je vyžadováno předplatné.",
+    "idpDisabled": "Poskytovatelé identit jsou zakázáni.",
+    "orgAuthPageDisabled": "Ověřovací stránka organizace je zakázána.",
+    "domainRestartedDescription": "Ověření domény bylo úspěšně restartováno",
     "resourceAddEntrypointsEditFile": "Upravit soubor: config/traefik/traefik_config.yml",
     "resourceExposePortsEditFile": "Upravit soubor: docker-compose.yml",
     "emailVerificationRequired": "Je vyžadováno ověření e-mailu. Přihlaste se znovu pomocí {dashboardUrl}/auth/login dokončete tento krok. Poté se vraťte zde.",
-    "twoFactorSetupRequired": "Je vyžadováno nastavení dvoufaktorového ověřování. Přihlaste se znovu pomocí {dashboardUrl}/autentizace/přihlášení dokončí tento krok. Poté se vraťte zde.",
-    "rewritePath": "Rewrite Path",
-    "rewritePathDescription": "Optionally rewrite the path before forwarding to the target."
+    "twoFactorSetupRequired": "Je vyžadováno nastavení dvoufaktorového ověřování. Přihlaste se znovu pomocí {dashboardUrl}/autentizace/přihlášení dokončí tento krok. Poté se vraťte zde."
 }

messages/de-DE.json

@@ -168,6 +168,9 @@
     "siteSelect": "Standort auswählen",
     "siteSearch": "Standorte durchsuchen",
     "siteNotFound": "Keinen Standort gefunden.",
+    "selectCountry": "Land auswählen",
+    "searchCountries": "Länder suchen...",
+    "noCountryFound": "Kein Land gefunden.",
     "siteSelectionDescription": "Dieser Standort wird die Verbindung zum Ziel herstellen.",
     "resourceType": "Ressourcentyp",
     "resourceTypeDescription": "Legen Sie fest, wie Sie auf Ihre Ressource zugreifen möchten",
@@ -914,8 +917,6 @@
     "idpConnectingToFinished": "Verbunden",
     "idpErrorConnectingTo": "Es gab ein Problem bei der Verbindung zu {name}. Bitte kontaktieren Sie Ihren Administrator.",
     "idpErrorNotFound": "IdP nicht gefunden",
-    "idpGoogleAlt": "Google",
-    "idpAzureAlt": "Azure",
     "inviteInvalid": "Ungültige Einladung",
     "inviteInvalidDescription": "Der Einladungslink ist ungültig.",
     "inviteErrorWrongUser": "Einladung ist nicht für diesen Benutzer",
@@ -1139,8 +1140,8 @@
     "sidebarAllUsers": "Alle Benutzer",
     "sidebarIdentityProviders": "Identitätsanbieter",
     "sidebarLicense": "Lizenz",
-    "sidebarClients": "Clients (Beta)",
-    "sidebarDomains": "Domains",
+    "sidebarClients": "Kunden (Beta)",
+    "sidebarDomains": "Domänen",
     "enableDockerSocket": "Docker Blaupause aktivieren",
     "enableDockerSocketDescription": "Aktiviere Docker-Socket-Label-Scraping für Blaupausenbeschriftungen. Der Socket-Pfad muss neu angegeben werden.",
     "enableDockerSocketLink": "Mehr erfahren",
@@ -1188,7 +1189,7 @@
     "certificateStatus": "Zertifikatsstatus",
     "loading": "Laden",
     "restart": "Neustart",
-    "domains": "Domains",
+    "domains": "Domänen",
     "domainsDescription": "Domains für Ihre Organisation verwalten",
     "domainsSearch": "Domains durchsuchen...",
     "domainAdd": "Domain hinzufügen",
@@ -1201,7 +1202,7 @@
     "domainMessageConfirm": "Um zu bestätigen, geben Sie bitte den Domainnamen unten ein.",
     "domainConfirmDelete": "Domain-Löschung bestätigen",
     "domainDelete": "Domain löschen",
-    "domain": "Domain",
+    "domain": "Domäne",
     "selectDomainTypeNsName": "Domain-Delegation (NS)",
     "selectDomainTypeNsDescription": "Diese Domain und alle ihre Subdomains. Verwenden Sie dies, wenn Sie eine gesamte Domainzone kontrollieren möchten.",
     "selectDomainTypeCnameName": "Einzelne Domain (CNAME)",
@@ -1241,7 +1242,7 @@
     "sidebarExpand": "Erweitern",
     "newtUpdateAvailable": "Update verfügbar",
     "newtUpdateAvailableInfo": "Eine neue Version von Newt ist verfügbar. Bitte aktualisieren Sie auf die neueste Version für das beste Erlebnis.",
-    "domainPickerEnterDomain": "Domain",
+    "domainPickerEnterDomain": "Domäne",
     "domainPickerPlaceholder": "myapp.example.com",
     "domainPickerDescription": "Geben Sie die vollständige Domäne der Ressource ein, um verfügbare Optionen zu sehen.",
     "domainPickerDescriptionSaas": "Geben Sie eine vollständige Domäne, Subdomäne oder einfach einen Namen ein, um verfügbare Optionen zu sehen",
@@ -1257,6 +1258,48 @@
     "domainPickerSubdomain": "Subdomain: {subdomain}",
     "domainPickerNamespace": "Namespace: {namespace}",
     "domainPickerShowMore": "Mehr anzeigen",
+    "regionSelectorTitle": "Region auswählen",
+    "regionSelectorInfo": "Das Auswählen einer Region hilft uns, eine bessere Leistung für Ihren Standort bereitzustellen. Sie müssen sich nicht in derselben Region wie Ihr Server befinden.",
+    "regionSelectorPlaceholder": "Wähle eine Region",
+    "regionSelectorComingSoon": "Kommt bald",
+    "billingLoadingSubscription": "Abonnement wird geladen...",
+    "billingFreeTier": "Kostenlose Stufe",
+    "billingWarningOverLimit": "Warnung: Sie haben ein oder mehrere Nutzungslimits überschritten. Ihre Webseiten werden nicht verbunden, bis Sie Ihr Abonnement ändern oder Ihren Verbrauch anpassen.",
+    "billingUsageLimitsOverview": "Übersicht über Nutzungsgrenzen",
+    "billingMonitorUsage": "Überwachen Sie Ihren Verbrauch im Vergleich zu konfigurierten Grenzwerten. Wenn Sie eine Erhöhung der Limits benötigen, kontaktieren Sie uns bitte support@fossorial.io.",
+    "billingDataUsage": "Datenverbrauch",
+    "billingOnlineTime": "Online-Zeit der Seite",
+    "billingUsers": "Aktive Benutzer",
+    "billingDomains": "Aktive Domänen",
+    "billingRemoteExitNodes": "Aktive selbstgehostete Nodes",
+    "billingNoLimitConfigured": "Kein Limit konfiguriert",
+    "billingEstimatedPeriod": "Geschätzter Abrechnungszeitraum",
+    "billingIncludedUsage": "Inklusive Nutzung",
+    "billingIncludedUsageDescription": "Nutzung, die in Ihrem aktuellen Abonnementplan enthalten ist",
+    "billingFreeTierIncludedUsage": "Nutzungskontingente der kostenlosen Stufe",
+    "billingIncluded": "inbegriffen",
+    "billingEstimatedTotal": "Geschätzte Gesamtsumme:",
+    "billingNotes": "Notizen",
+    "billingEstimateNote": "Dies ist eine Schätzung basierend auf Ihrem aktuellen Verbrauch.",
+    "billingActualChargesMayVary": "Tatsächliche Kosten können variieren.",
+    "billingBilledAtEnd": "Sie werden am Ende des Abrechnungszeitraums in Rechnung gestellt.",
+    "billingModifySubscription": "Abonnement ändern",
+    "billingStartSubscription": "Abonnement starten",
+    "billingRecurringCharge": "Wiederkehrende Kosten",
+    "billingManageSubscriptionSettings": "Verwalten Sie Ihre Abonnement-Einstellungen und Präferenzen",
+    "billingNoActiveSubscription": "Sie haben kein aktives Abonnement. Starten Sie Ihr Abonnement, um Nutzungslimits zu erhöhen.",
+    "billingFailedToLoadSubscription": "Fehler beim Laden des Abonnements",
+    "billingFailedToLoadUsage": "Fehler beim Laden der Nutzung",
+    "billingFailedToGetCheckoutUrl": "Fehler beim Abrufen der Checkout-URL",
+    "billingPleaseTryAgainLater": "Bitte versuchen Sie es später noch einmal.",
+    "billingCheckoutError": "Checkout-Fehler",
+    "billingFailedToGetPortalUrl": "Fehler beim Abrufen der Portal-URL",
+    "billingPortalError": "Portalfehler",
+    "billingDataUsageInfo": "Wenn Sie mit der Cloud verbunden sind, werden alle Daten über Ihre sicheren Tunnel belastet. Dies schließt eingehenden und ausgehenden Datenverkehr über alle Ihre Websites ein. Wenn Sie Ihr Limit erreichen, werden Ihre Seiten die Verbindung trennen, bis Sie Ihr Paket upgraden oder die Nutzung verringern. Daten werden nicht belastet, wenn Sie Knoten verwenden.",
+    "billingOnlineTimeInfo": "Sie werden belastet, abhängig davon, wie lange Ihre Seiten mit der Cloud verbunden bleiben. Zum Beispiel 44.640 Minuten entspricht einer Site, die 24 Stunden am Tag des Monats läuft. Wenn Sie Ihr Limit erreichen, werden Ihre Seiten die Verbindung trennen, bis Sie Ihr Paket upgraden oder die Nutzung verringern. Die Zeit wird nicht belastet, wenn Sie Knoten verwenden.",
+    "billingUsersInfo": "Ihnen wird für jeden Benutzer in Ihrer Organisation berechnet. Die Abrechnung erfolgt täglich basierend auf der Anzahl der aktiven Benutzerkonten in Ihrer Organisation.",
+    "billingDomainInfo": "Ihnen wird für jede Domäne in Ihrer Organisation berechnet. Die Abrechnung erfolgt täglich basierend auf der Anzahl der aktiven Domänenkonten in Ihrer Organisation.",
+    "billingRemoteExitNodesInfo": "Ihnen wird für jeden verwalteten Node in Ihrer Organisation berechnet. Die Abrechnung erfolgt täglich basierend auf der Anzahl der aktiven verwalteten Nodes in Ihrer Organisation.",
     "domainNotFound": "Domain nicht gefunden",
     "domainNotFoundDescription": "Diese Ressource ist deaktiviert, weil die Domain nicht mehr in unserem System existiert. Bitte setzen Sie eine neue Domain für diese Ressource.",
     "failed": "Fehlgeschlagen",
@@ -1320,6 +1363,7 @@
     "createDomainDnsPropagationDescription": "Es kann einige Zeit dauern, bis DNS-Änderungen im Internet verbreitet werden. Dies kann je nach Ihrem DNS-Provider und den TTL-Einstellungen von einigen Minuten bis zu 48 Stunden dauern.",
     "resourcePortRequired": "Portnummer ist für nicht-HTTP-Ressourcen erforderlich",
     "resourcePortNotAllowed": "Portnummer sollte für HTTP-Ressourcen nicht gesetzt werden",
+    "billingPricingCalculatorLink": "Preisrechner",
     "signUpTerms": {
         "IAgreeToThe": "Ich stimme den",
         "termsOfService": "Nutzungsbedingungen zu",
@@ -1327,7 +1371,7 @@
         "privacyPolicy": "Datenschutzrichtlinie"
     },
     "siteRequired": "Standort ist erforderlich.",
-    "olmTunnel": "Olm Tunnel",
+    "olmTunnel": "Olm-Tunnel",
     "olmTunnelDescription": "Nutzen Sie Olm für die Kundenverbindung",
     "errorCreatingClient": "Fehler beim Erstellen des Clients",
     "clientDefaultsNotFound": "Kundenvorgaben nicht gefunden",
@@ -1368,6 +1412,41 @@
     "addNewTarget": "Neues Ziel hinzufügen",
     "targetsList": "Ziel-Liste",
     "targetErrorDuplicateTargetFound": "Doppeltes Ziel gefunden",
+    "healthCheckHealthy": "Gesund",
+    "healthCheckUnhealthy": "Ungesund",
+    "healthCheckUnknown": "Unbekannt",
+    "healthCheck": "Gesundheits-Check",
+    "configureHealthCheck": "Gesundheits-Check konfigurieren",
+    "configureHealthCheckDescription": "Richten Sie die Gesundheitsüberwachung für {target} ein",
+    "enableHealthChecks": "Gesundheits-Checks aktivieren",
+    "enableHealthChecksDescription": "Überwachen Sie die Gesundheit dieses Ziels. Bei Bedarf können Sie einen anderen Endpunkt als das Ziel überwachen.",
+    "healthScheme": "Methode",
+    "healthSelectScheme": "Methode auswählen",
+    "healthCheckPath": "Pfad",
+    "healthHostname": "IP / Host",
+    "healthPort": "Port",
+    "healthCheckPathDescription": "Der Pfad zum Überprüfen des Gesundheitszustands.",
+    "healthyIntervalSeconds": "Gesunder Intervall",
+    "unhealthyIntervalSeconds": "Ungesunder Intervall",
+    "IntervalSeconds": "Gesunder Intervall",
+    "timeoutSeconds": "Timeout",
+    "timeIsInSeconds": "Zeit ist in Sekunden",
+    "retryAttempts": "Wiederholungsversuche",
+    "expectedResponseCodes": "Erwartete Antwortcodes",
+    "expectedResponseCodesDescription": "HTTP-Statuscode, der einen gesunden Zustand anzeigt. Wenn leer gelassen, wird 200-300 als gesund angesehen.",
+    "customHeaders": "Eigene Kopfzeilen",
+    "customHeadersDescription": "Header neue Zeile getrennt: Header-Name: Wert",
+    "headersValidationError": "Header müssen im Format Header-Name: Wert sein.",
+    "saveHealthCheck": "Gesundheits-Check speichern",
+    "healthCheckSaved": "Gesundheits-Check gespeichert",
+    "healthCheckSavedDescription": "Die Konfiguration des Gesundheits-Checks wurde erfolgreich gespeichert",
+    "healthCheckError": "Fehler beim Gesundheits-Check",
+    "healthCheckErrorDescription": "Beim Speichern der Gesundheits-Check-Konfiguration ist ein Fehler aufgetreten",
+    "healthCheckPathRequired": "Gesundheits-Check-Pfad ist erforderlich",
+    "healthCheckMethodRequired": "HTTP-Methode ist erforderlich",
+    "healthCheckIntervalMin": "Prüfintervall muss mindestens 5 Sekunden betragen",
+    "healthCheckTimeoutMin": "Timeout muss mindestens 1 Sekunde betragen",
+    "healthCheckRetryMin": "Wiederholungsversuche müssen mindestens 1 betragen",
     "httpMethod": "HTTP-Methode",
     "selectHttpMethod": "HTTP-Methode auswählen",
     "domainPickerSubdomainLabel": "Subdomain",
@@ -1381,7 +1460,8 @@
     "domainPickerEnterSubdomainToSearch": "Geben Sie eine Subdomain ein, um verfügbare freie Domains zu suchen und auszuwählen.",
     "domainPickerFreeDomains": "Freie Domains",
     "domainPickerSearchForAvailableDomains": "Verfügbare Domains suchen",
-    "resourceDomain": "Domain",
+    "domainPickerNotWorkSelfHosted": "Hinweis: Kostenlose bereitgestellte Domains sind derzeit nicht für selbstgehostete Instanzen verfügbar.",
+    "resourceDomain": "Domäne",
     "resourceEditDomain": "Domain bearbeiten",
     "siteName": "Site-Name",
     "proxyPort": "Port",
@@ -1463,6 +1543,72 @@
     "autoLoginError": "Fehler bei der automatischen Anmeldung",
     "autoLoginErrorNoRedirectUrl": "Keine Weiterleitungs-URL vom Identitätsanbieter erhalten.",
     "autoLoginErrorGeneratingUrl": "Fehler beim Generieren der Authentifizierungs-URL.",
+    "remoteExitNodeManageRemoteExitNodes": "Selbst-Hosted verwalten",
+    "remoteExitNodeDescription": "Knoten verwalten, um die Netzwerkverbindung zu erweitern",
+    "remoteExitNodes": "Nodes",
+    "searchRemoteExitNodes": "Knoten suchen...",
+    "remoteExitNodeAdd": "Knoten hinzufügen",
+    "remoteExitNodeErrorDelete": "Fehler beim Löschen des Knotens",
+    "remoteExitNodeQuestionRemove": "Sind Sie sicher, dass Sie den Knoten {selectedNode} aus der Organisation entfernen möchten?",
+    "remoteExitNodeMessageRemove": "Einmal entfernt, wird der Knoten nicht mehr zugänglich sein.",
+    "remoteExitNodeMessageConfirm": "Um zu bestätigen, geben Sie bitte den Namen des Knotens unten ein.",
+    "remoteExitNodeConfirmDelete": "Löschknoten bestätigen",
+    "remoteExitNodeDelete": "Knoten löschen",
+    "sidebarRemoteExitNodes": "Nodes",
+    "remoteExitNodeCreate": {
+        "title": "Knoten erstellen",
+        "description": "Erstellen Sie einen neuen Knoten, um Ihre Netzwerkverbindung zu erweitern",
+        "viewAllButton": "Alle Knoten anzeigen",
+        "strategy": {
+            "title": "Erstellungsstrategie",
+            "description": "Wählen Sie diese Option, um Ihren Knoten manuell zu konfigurieren oder neue Zugangsdaten zu generieren.",
+            "adopt": {
+                "title": "Node übernehmen",
+                "description": "Wählen Sie dies, wenn Sie bereits die Anmeldedaten für den Knoten haben."
+            },
+            "generate": {
+                "title": "Schlüssel generieren",
+                "description": "Wählen Sie dies, wenn Sie neue Schlüssel für den Knoten generieren möchten"
+            }
+        },
+        "adopt": {
+            "title": "Vorhandenen Node übernehmen",
+            "description": "Geben Sie die Zugangsdaten des vorhandenen Knotens ein, den Sie übernehmen möchten",
+            "nodeIdLabel": "Knoten-ID",
+            "nodeIdDescription": "Die ID des vorhandenen Knotens, den Sie übernehmen möchten",
+            "secretLabel": "Geheimnis",
+            "secretDescription": "Der geheime Schlüssel des vorhandenen Knotens",
+            "submitButton": "Node übernehmen"
+        },
+        "generate": {
+            "title": "Generierte Anmeldedaten",
+            "description": "Verwenden Sie diese generierten Anmeldeinformationen, um Ihren Knoten zu konfigurieren",
+            "nodeIdTitle": "Knoten-ID",
+            "secretTitle": "Geheimnis",
+            "saveCredentialsTitle": "Anmeldedaten zur Konfiguration hinzufügen",
+            "saveCredentialsDescription": "Fügen Sie diese Anmeldedaten zu Ihrer selbst-gehosteten Pangolin Node-Konfigurationsdatei hinzu, um die Verbindung abzuschließen.",
+            "submitButton": "Knoten erstellen"
+        },
+        "validation": {
+            "adoptRequired": "Knoten-ID und Geheimnis sind erforderlich, wenn ein existierender Knoten angenommen wird"
+        },
+        "errors": {
+            "loadDefaultsFailed": "Fehler beim Laden der Standardeinstellungen",
+            "defaultsNotLoaded": "Standardeinstellungen nicht geladen",
+            "createFailed": "Knoten konnte nicht erstellt werden"
+        },
+        "success": {
+            "created": "Knoten erfolgreich erstellt"
+        }
+    },
+    "remoteExitNodeSelection": "Knotenauswahl",
+    "remoteExitNodeSelectionDescription": "Wählen Sie einen Knoten aus, durch den Traffic für diese lokale Seite geleitet werden soll",
+    "remoteExitNodeRequired": "Ein Knoten muss für lokale Seiten ausgewählt sein",
+    "noRemoteExitNodesAvailable": "Keine Knoten verfügbar",
+    "noRemoteExitNodesAvailableDescription": "Für diese Organisation sind keine Knoten verfügbar. Erstellen Sie zuerst einen Knoten, um lokale Sites zu verwenden.",
+    "exitNode": "Exit-Node",
+    "country": "Land",
+    "rulesMatchCountry": "Derzeit basierend auf der Quell-IP",
     "managedSelfHosted": {
         "title": "Verwaltetes Selbsthosted",
         "description": "Zuverlässiger und wartungsarmer Pangolin Server mit zusätzlichen Glocken und Pfeifen",
@@ -1501,11 +1647,53 @@
     },
     "internationaldomaindetected": "Internationale Domain erkannt",
     "willbestoredas": "Wird gespeichert als:",
+    "roleMappingDescription": "Legen Sie fest, wie den Benutzern Rollen zugewiesen werden, wenn sie sich anmelden, wenn Auto Provision aktiviert ist.",
+    "selectRole": "Wählen Sie eine Rolle",
+    "roleMappingExpression": "Ausdruck",
+    "selectRolePlaceholder": "Rolle auswählen",
+    "selectRoleDescription": "Wählen Sie eine Rolle aus, die allen Benutzern von diesem Identitätsprovider zugewiesen werden soll",
+    "roleMappingExpressionDescription": "Geben Sie einen JMESPath-Ausdruck ein, um Rolleninformationen aus dem ID-Token zu extrahieren",
+    "idpTenantIdRequired": "Mandant ID ist erforderlich",
+    "invalidValue": "Ungültiger Wert",
+    "idpTypeLabel": "Identitätsanbietertyp",
+    "roleMappingExpressionPlaceholder": "z. B. enthalten(Gruppen, 'admin') && 'Admin' || 'Mitglied'",
+    "idpGoogleConfiguration": "Google-Konfiguration",
+    "idpGoogleConfigurationDescription": "Konfigurieren Sie Ihre Google OAuth2 Zugangsdaten",
+    "idpGoogleClientIdDescription": "Ihre Google OAuth2 Client-ID",
+    "idpGoogleClientSecretDescription": "Ihr Google OAuth2 Client Secret",
+    "idpAzureConfiguration": "Azure Entra ID Konfiguration",
+    "idpAzureConfigurationDescription": "Konfigurieren Sie Ihre Azure Entra ID OAuth2 Zugangsdaten",
+    "idpTenantId": "Tenant ID",
+    "idpTenantIdPlaceholder": "deine Mandant-ID",
+    "idpAzureTenantIdDescription": "Ihre Azure Mieter-ID (gefunden in Azure Active Directory Übersicht)",
+    "idpAzureClientIdDescription": "Ihre Azure App Registration Client ID",
+    "idpAzureClientSecretDescription": "Ihr Azure App Registration Client Secret",
+    "idpGoogleTitle": "Google",
+    "idpGoogleAlt": "Google",
+    "idpAzureTitle": "Azure Entra ID",
+    "idpAzureAlt": "Azure",
+    "idpGoogleConfigurationTitle": "Google-Konfiguration",
+    "idpAzureConfigurationTitle": "Azure Entra ID Konfiguration",
+    "idpTenantIdLabel": "Tenant ID",
+    "idpAzureClientIdDescription2": "Ihre Azure App Registration Client ID",
+    "idpAzureClientSecretDescription2": "Ihr Azure App Registration Client Secret",
     "idpGoogleDescription": "Google OAuth2/OIDC Provider",
     "idpAzureDescription": "Microsoft Azure OAuth2/OIDC provider",
-    "customHeaders": "Eigene Kopfzeilen",
-    "customHeadersDescription": "Add custom headers to be sent when proxying requests. One per line in the format Header-Name: value",
-    "headersValidationError": "Header müssen im Format Header-Name: Wert sein.",
+    "subnet": "Subnetz",
+    "subnetDescription": "Das Subnetz für die Netzwerkkonfiguration dieser Organisation.",
+    "authPage": "Auth Seite",
+    "authPageDescription": "Konfigurieren Sie die Auth-Seite für Ihre Organisation",
+    "authPageDomain": "Domain der Auth Seite",
+    "noDomainSet": "Keine Domäne gesetzt",
+    "changeDomain": "Domain ändern",
+    "selectDomain": "Domain auswählen",
+    "restartCertificate": "Zertifikat neu starten",
+    "editAuthPageDomain": "Auth Page Domain bearbeiten",
+    "setAuthPageDomain": "Domain der Auth Seite festlegen",
+    "failedToFetchCertificate": "Zertifikat konnte nicht abgerufen werden",
+    "failedToRestartCertificate": "Zertifikat konnte nicht neu gestartet werden",
+    "addDomainToEnableCustomAuthPages": "Fügen Sie eine Domain hinzu, um benutzerdefinierte Authentifizierungsseiten für Ihre Organisation zu aktivieren",
+    "selectDomainForOrgAuthPage": "Wählen Sie eine Domain für die Authentifizierungsseite der Organisation",
     "domainPickerProvidedDomain": "Angegebene Domain",
     "domainPickerFreeProvidedDomain": "Kostenlose Domain",
     "domainPickerVerified": "Verifiziert",
@@ -1519,10 +1707,16 @@
     "domainPickerInvalidSubdomainCannotMakeValid": "\"{sub}\" konnte nicht für {domain} gültig gemacht werden.",
     "domainPickerSubdomainSanitized": "Subdomain bereinigt",
     "domainPickerSubdomainCorrected": "\"{sub}\" wurde korrigiert zu \"{sanitized}\"",
+    "orgAuthSignInTitle": "Bei Ihrer Organisation anmelden",
+    "orgAuthChooseIdpDescription": "Wähle deinen Identitätsanbieter um fortzufahren",
+    "orgAuthNoIdpConfigured": "Diese Organisation hat keine Identitätsanbieter konfiguriert. Sie können sich stattdessen mit Ihrer Pangolin-Identität anmelden.",
+    "orgAuthSignInWithPangolin": "Mit Pangolin anmelden",
+    "subscriptionRequiredToUse": "Um diese Funktion nutzen zu können, ist ein Abonnement erforderlich.",
+    "idpDisabled": "Identitätsanbieter sind deaktiviert.",
+    "orgAuthPageDisabled": "Organisations-Authentifizierungsseite ist deaktiviert.",
+    "domainRestartedDescription": "Domain-Verifizierung erfolgreich neu gestartet",
     "resourceAddEntrypointsEditFile": "Datei bearbeiten: config/traefik/traefik_config.yml",
     "resourceExposePortsEditFile": "Datei bearbeiten: docker-compose.yml",
     "emailVerificationRequired": "E-Mail-Verifizierung ist erforderlich. Bitte melden Sie sich erneut über {dashboardUrl}/auth/login an. Kommen Sie dann wieder hierher.",
-    "twoFactorSetupRequired": "Die Zwei-Faktor-Authentifizierung ist erforderlich. Bitte melden Sie sich erneut über {dashboardUrl}/auth/login an. Dann kommen Sie hierher zurück.",
-    "rewritePath": "Rewrite Path",
-    "rewritePathDescription": "Optionally rewrite the path before forwarding to the target."
+    "twoFactorSetupRequired": "Die Zwei-Faktor-Authentifizierung ist erforderlich. Bitte melden Sie sich erneut über {dashboardUrl}/auth/login an. Dann kommen Sie hierher zurück."
 }

messages/en-US.json

@@ -1,3 +1,4 @@
+
 {
     "setupCreate": "Create your organization, site, and resources",
     "setupNewOrg": "New Organization",
@@ -94,9 +95,9 @@
     "siteNewtTunnelDescription": "Easiest way to create an entrypoint into your network. No extra setup.",
     "siteWg": "Basic WireGuard",
     "siteWgDescription": "Use any WireGuard client to establish a tunnel. Manual NAT setup required.",
-    "siteWgDescriptionSaas": "Use any WireGuard client to establish a tunnel. Manual NAT setup required. ONLY WORKS ON SELF HOSTED NODES",
+    "siteWgDescriptionSaas": "Use any WireGuard client to establish a tunnel. Manual NAT setup required.",
     "siteLocalDescription": "Local resources only. No tunneling.",
-    "siteLocalDescriptionSaas": "Local resources only. No tunneling. ONLY WORKS ON SELF HOSTED NODES",
+    "siteLocalDescriptionSaas": "Local resources only. No tunneling.",
     "siteSeeAll": "See All Sites",
     "siteTunnelDescription": "Determine how you want to connect to your site",
     "siteNewtCredentials": "Newt Credentials",
@@ -159,7 +160,7 @@
     "resourceHTTP": "HTTPS Resource",
     "resourceHTTPDescription": "Proxy requests to your app over HTTPS using a subdomain or base domain.",
     "resourceRaw": "Raw TCP/UDP Resource",
-    "resourceRawDescription": "Proxy requests to your app over TCP/UDP using a port number.",
+    "resourceRawDescription": "Proxy requests to your app over TCP/UDP using a port number. This only works when sites are connected to nodes.",
     "resourceCreate": "Create Resource",
     "resourceCreateDescription": "Follow the steps below to create a new resource",
     "resourceSeeAll": "See All Resources",
@@ -168,6 +169,9 @@
     "siteSelect": "Select site",
     "siteSearch": "Search site",
     "siteNotFound": "No site found.",
+    "selectCountry": "Select country",
+    "searchCountries": "Search countries...",
+    "noCountryFound": "No country found.",
     "siteSelectionDescription": "This site will provide connectivity to the target.",
     "resourceType": "Resource Type",
     "resourceTypeDescription": "Determine how you want to access your resource",
@@ -914,8 +918,6 @@
     "idpConnectingToFinished": "Connected",
     "idpErrorConnectingTo": "There was a problem connecting to {name}. Please contact your administrator.",
     "idpErrorNotFound": "IdP not found",
-    "idpGoogleAlt": "Google",
-    "idpAzureAlt": "Azure",
     "inviteInvalid": "Invalid Invite",
     "inviteInvalidDescription": "The invite link is invalid.",
     "inviteErrorWrongUser": "Invite is not for this user",
@@ -1257,6 +1259,48 @@
     "domainPickerSubdomain": "Subdomain: {subdomain}",
     "domainPickerNamespace": "Namespace: {namespace}",
     "domainPickerShowMore": "Show More",
+    "regionSelectorTitle": "Select Region",
+    "regionSelectorInfo": "Selecting a region helps us provide better performance for your location. You do not have to be in the same region as your server.",
+    "regionSelectorPlaceholder": "Choose a region",
+    "regionSelectorComingSoon": "Coming Soon",
+    "billingLoadingSubscription": "Loading subscription...",
+    "billingFreeTier": "Free Tier",
+    "billingWarningOverLimit": "Warning: You have exceeded one or more usage limits. Your sites will not connect until you modify your subscription or adjust your usage.",
+    "billingUsageLimitsOverview": "Usage Limits Overview",
+    "billingMonitorUsage": "Monitor your usage against configured limits. If you need limits increased please contact us support@fossorial.io.",
+    "billingDataUsage": "Data Usage",
+    "billingOnlineTime": "Site Online Time",
+    "billingUsers": "Active Users",
+    "billingDomains": "Active Domains",
+    "billingRemoteExitNodes": "Active Self-hosted Nodes",
+    "billingNoLimitConfigured": "No limit configured",
+    "billingEstimatedPeriod": "Estimated Billing Period",
+    "billingIncludedUsage": "Included Usage",
+    "billingIncludedUsageDescription": "Usage included with your current subscription plan",
+    "billingFreeTierIncludedUsage": "Free tier usage allowances",
+    "billingIncluded": "included",
+    "billingEstimatedTotal": "Estimated Total:",
+    "billingNotes": "Notes",
+    "billingEstimateNote": "This is an estimate based on your current usage.",
+    "billingActualChargesMayVary": "Actual charges may vary.",
+    "billingBilledAtEnd": "You will be billed at the end of the billing period.",
+    "billingModifySubscription": "Modify Subscription",
+    "billingStartSubscription": "Start Subscription",
+    "billingRecurringCharge": "Recurring Charge",
+    "billingManageSubscriptionSettings": "Manage your subscription settings and preferences",
+    "billingNoActiveSubscription": "You don't have an active subscription. Start your subscription to increase usage limits.",
+    "billingFailedToLoadSubscription": "Failed to load subscription",
+    "billingFailedToLoadUsage": "Failed to load usage",
+    "billingFailedToGetCheckoutUrl": "Failed to get checkout URL",
+    "billingPleaseTryAgainLater": "Please try again later.",
+    "billingCheckoutError": "Checkout Error",
+    "billingFailedToGetPortalUrl": "Failed to get portal URL",
+    "billingPortalError": "Portal Error",
+    "billingDataUsageInfo": "You're charged for all data transferred through your secure tunnels when connected to the cloud. This includes both incoming and outgoing traffic across all your sites. When you reach your limit, your sites will disconnect until you upgrade your plan or reduce usage. Data is not charged when using nodes.",
+    "billingOnlineTimeInfo": "You're charged based on how long your sites stay connected to the cloud. For example, 44,640 minutes equals one site running 24/7 for a full month. When you reach your limit, your sites will disconnect until you upgrade your plan or reduce usage. Time is not charged when using nodes.",
+    "billingUsersInfo": "You're charged for each user in your organization. Billing is calculated daily based on the number of active user accounts in your org.",
+    "billingDomainInfo": "You're charged for each domain in your organization. Billing is calculated daily based on the number of active domain accounts in your org.",
+    "billingRemoteExitNodesInfo": "You're charged for each managed Node in your organization. Billing is calculated daily based on the number of active managed Nodes in your org.",
     "domainNotFound": "Domain Not Found",
     "domainNotFoundDescription": "This resource is disabled because the domain no longer exists our system. Please set a new domain for this resource.",
     "failed": "Failed",
@@ -1320,6 +1364,7 @@
     "createDomainDnsPropagationDescription": "DNS changes may take some time to propagate across the internet. This can take anywhere from a few minutes to 48 hours, depending on your DNS provider and TTL settings.",
     "resourcePortRequired": "Port number is required for non-HTTP resources",
     "resourcePortNotAllowed": "Port number should not be set for HTTP resources",
+    "billingPricingCalculatorLink": "Pricing Calculator",
     "signUpTerms": {
         "IAgreeToThe": "I agree to the",
         "termsOfService": "terms of service",
@@ -1368,6 +1413,41 @@
     "addNewTarget": "Add New Target",
     "targetsList": "Targets List",
     "targetErrorDuplicateTargetFound": "Duplicate target found",
+    "healthCheckHealthy": "Healthy",
+    "healthCheckUnhealthy": "Unhealthy",
+    "healthCheckUnknown": "Unknown",
+    "healthCheck": "Health Check",
+    "configureHealthCheck": "Configure Health Check",
+    "configureHealthCheckDescription": "Set up health monitoring for {target}",
+    "enableHealthChecks": "Enable Health Checks",
+    "enableHealthChecksDescription": "Monitor the health of this target. You can monitor a different endpoint than the target if required.",
+    "healthScheme": "Method",
+    "healthSelectScheme": "Select Method",
+    "healthCheckPath": "Path",
+    "healthHostname": "IP / Host",
+    "healthPort": "Port",
+    "healthCheckPathDescription": "The path to check for health status.",
+    "healthyIntervalSeconds": "Healthy Interval",
+    "unhealthyIntervalSeconds": "Unhealthy Interval",
+    "IntervalSeconds": "Healthy Interval",
+    "timeoutSeconds": "Timeout",
+    "timeIsInSeconds": "Time is in seconds",
+    "retryAttempts": "Retry Attempts",
+    "expectedResponseCodes": "Expected Response Codes",
+    "expectedResponseCodesDescription": "HTTP status code that indicates healthy status. If left blank, 200-300 is considered healthy.",
+    "customHeaders": "Custom Headers",
+    "customHeadersDescription": "Headers new line separated: Header-Name: value",
+    "headersValidationError": "Headers must be in the format: Header-Name: value",
+    "saveHealthCheck": "Save Health Check",
+    "healthCheckSaved": "Health Check Saved",
+    "healthCheckSavedDescription": "Health check configuration has been saved successfully",
+    "healthCheckError": "Health Check Error",
+    "healthCheckErrorDescription": "An error occurred while saving the health check configuration",
+    "healthCheckPathRequired": "Health check path is required",
+    "healthCheckMethodRequired": "HTTP method is required",
+    "healthCheckIntervalMin": "Check interval must be at least 5 seconds",
+    "healthCheckTimeoutMin": "Timeout must be at least 1 second",
+    "healthCheckRetryMin": "Retry attempts must be at least 1",
     "httpMethod": "HTTP Method",
     "selectHttpMethod": "Select HTTP method",
     "domainPickerSubdomainLabel": "Subdomain",
@@ -1381,6 +1461,7 @@
     "domainPickerEnterSubdomainToSearch": "Enter a subdomain to search and select from available free domains.",
     "domainPickerFreeDomains": "Free Domains",
     "domainPickerSearchForAvailableDomains": "Search for available domains",
+    "domainPickerNotWorkSelfHosted": "Note: Free provided domains are not available for self-hosted instances right now.",
     "resourceDomain": "Domain",
     "resourceEditDomain": "Edit Domain",
     "siteName": "Site Name",
@@ -1463,6 +1544,72 @@
     "autoLoginError": "Auto Login Error",
     "autoLoginErrorNoRedirectUrl": "No redirect URL received from the identity provider.",
     "autoLoginErrorGeneratingUrl": "Failed to generate authentication URL.",
+    "remoteExitNodeManageRemoteExitNodes": "Manage Self-Hosted",
+    "remoteExitNodeDescription": "Manage nodes to extend your network connectivity",
+    "remoteExitNodes": "Nodes",
+    "searchRemoteExitNodes": "Search nodes...",
+    "remoteExitNodeAdd": "Add Node",
+    "remoteExitNodeErrorDelete": "Error deleting node",
+    "remoteExitNodeQuestionRemove": "Are you sure you want to remove the node {selectedNode} from the organization?",
+    "remoteExitNodeMessageRemove": "Once removed, the node will no longer be accessible.",
+    "remoteExitNodeMessageConfirm": "To confirm, please type the name of the node below.",
+    "remoteExitNodeConfirmDelete": "Confirm Delete Node",
+    "remoteExitNodeDelete": "Delete Node",
+    "sidebarRemoteExitNodes": "Nodes",
+    "remoteExitNodeCreate": {
+        "title": "Create Node",
+        "description": "Create a new node to extend your network connectivity",
+        "viewAllButton": "View All Nodes",
+        "strategy": {
+            "title": "Creation Strategy",
+            "description": "Choose this to manually configure your node or generate new credentials.",
+            "adopt": {
+                "title": "Adopt Node",
+                "description": "Choose this if you already have the credentials for the node."
+            },
+            "generate": {
+                "title": "Generate Keys",
+                "description": "Choose this if you want to generate new keys for the node"
+            }
+        },
+        "adopt": {
+            "title": "Adopt Existing Node",
+            "description": "Enter the credentials of the existing node you want to adopt",
+            "nodeIdLabel": "Node ID",
+            "nodeIdDescription": "The ID of the existing node you want to adopt",
+            "secretLabel": "Secret",
+            "secretDescription": "The secret key of the existing node",
+            "submitButton": "Adopt Node"
+        },
+        "generate": {
+            "title": "Generated Credentials",
+            "description": "Use these generated credentials to configure your node",
+            "nodeIdTitle": "Node ID",
+            "secretTitle": "Secret",
+            "saveCredentialsTitle": "Add Credentials to Config",
+            "saveCredentialsDescription": "Add these credentials to your self-hosted Pangolin node configuration file to complete the connection.",
+            "submitButton": "Create Node"
+        },
+        "validation": {
+            "adoptRequired": "Node ID and Secret are required when adopting an existing node"
+        },
+        "errors": {
+            "loadDefaultsFailed": "Failed to load defaults",
+            "defaultsNotLoaded": "Defaults not loaded",
+            "createFailed": "Failed to create node"
+        },
+        "success": {
+            "created": "Node created successfully"
+        }
+    },
+    "remoteExitNodeSelection": "Node Selection",
+    "remoteExitNodeSelectionDescription": "Select a node to route traffic through for this local site",
+    "remoteExitNodeRequired": "A node must be selected for local sites",
+    "noRemoteExitNodesAvailable": "No Nodes Available",
+    "noRemoteExitNodesAvailableDescription": "No nodes are available for this organization. Create a node first to use local sites.",
+    "exitNode": "Exit Node",
+    "country": "Country",
+    "rulesMatchCountry": "Currently based on source IP",
     "managedSelfHosted": {
         "title": "Managed Self-Hosted",
         "description": "More reliable and low-maintenance self-hosted Pangolin server with extra bells and whistles",
@@ -1501,11 +1648,53 @@
     },
     "internationaldomaindetected": "International Domain Detected",
     "willbestoredas": "Will be stored as:",
+    "roleMappingDescription": "Determine how roles are assigned to users when they sign in when Auto Provision is enabled.",
+    "selectRole": "Select a Role",
+    "roleMappingExpression": "Expression",
+    "selectRolePlaceholder": "Choose a role",
+    "selectRoleDescription": "Select a role to assign to all users from this identity provider",
+    "roleMappingExpressionDescription": "Enter a JMESPath expression to extract role information from the ID token",
+    "idpTenantIdRequired": "Tenant ID is required",
+    "invalidValue": "Invalid value",
+    "idpTypeLabel": "Identity Provider Type",
+    "roleMappingExpressionPlaceholder": "e.g., contains(groups, 'admin') && 'Admin' || 'Member'",
+    "idpGoogleConfiguration": "Google Configuration",
+    "idpGoogleConfigurationDescription": "Configure your Google OAuth2 credentials",
+    "idpGoogleClientIdDescription": "Your Google OAuth2 Client ID",
+    "idpGoogleClientSecretDescription": "Your Google OAuth2 Client Secret",
+    "idpAzureConfiguration": "Azure Entra ID Configuration",
+    "idpAzureConfigurationDescription": "Configure your Azure Entra ID OAuth2 credentials",
+    "idpTenantId": "Tenant ID",
+    "idpTenantIdPlaceholder": "your-tenant-id",
+    "idpAzureTenantIdDescription": "Your Azure tenant ID (found in Azure Active Directory overview)",
+    "idpAzureClientIdDescription": "Your Azure App Registration Client ID",
+    "idpAzureClientSecretDescription": "Your Azure App Registration Client Secret",
+    "idpGoogleTitle": "Google",
+    "idpGoogleAlt": "Google",
+    "idpAzureTitle": "Azure Entra ID",
+    "idpAzureAlt": "Azure",
+    "idpGoogleConfigurationTitle": "Google Configuration",
+    "idpAzureConfigurationTitle": "Azure Entra ID Configuration",
+    "idpTenantIdLabel": "Tenant ID",
+    "idpAzureClientIdDescription2": "Your Azure App Registration Client ID",
+    "idpAzureClientSecretDescription2": "Your Azure App Registration Client Secret",
     "idpGoogleDescription": "Google OAuth2/OIDC provider",
     "idpAzureDescription": "Microsoft Azure OAuth2/OIDC provider",
-    "customHeaders": "Custom Headers",
-    "customHeadersDescription": "Add custom headers to be sent when proxying requests. One per line in the format Header-Name: value",
-    "headersValidationError": "Headers must be in the format: Header-Name: value.",
+    "subnet": "Subnet",
+    "subnetDescription": "The subnet for this organization's network configuration.",
+    "authPage": "Auth Page",
+    "authPageDescription": "Configure the auth page for your organization",
+    "authPageDomain": "Auth Page Domain",
+    "noDomainSet": "No domain set",
+    "changeDomain": "Change Domain",
+    "selectDomain": "Select Domain",
+    "restartCertificate": "Restart Certificate",
+    "editAuthPageDomain": "Edit Auth Page Domain",
+    "setAuthPageDomain": "Set Auth Page Domain",
+    "failedToFetchCertificate": "Failed to fetch certificate",
+    "failedToRestartCertificate": "Failed to restart certificate",
+    "addDomainToEnableCustomAuthPages": "Add a domain to enable custom authentication pages for your organization",
+    "selectDomainForOrgAuthPage": "Select a domain for the organization's authentication page",
     "domainPickerProvidedDomain": "Provided Domain",
     "domainPickerFreeProvidedDomain": "Free Provided Domain",
     "domainPickerVerified": "Verified",
@@ -1519,10 +1708,21 @@
     "domainPickerInvalidSubdomainCannotMakeValid": "\"{sub}\" could not be made valid for {domain}.",
     "domainPickerSubdomainSanitized": "Subdomain sanitized",
     "domainPickerSubdomainCorrected": "\"{sub}\" was corrected to \"{sanitized}\"",
+    "orgAuthSignInTitle": "Sign in to your organization",
+    "orgAuthChooseIdpDescription": "Choose your identity provider to continue",
+    "orgAuthNoIdpConfigured": "This organization doesn't have any identity providers configured. You can log in with your Pangolin identity instead.",
+    "orgAuthSignInWithPangolin": "Sign in with Pangolin",
+    "subscriptionRequiredToUse": "A subscription is required to use this feature.",
+    "idpDisabled": "Identity providers are disabled.",
+    "orgAuthPageDisabled": "Organization auth page is disabled.",
+    "domainRestartedDescription": "Domain verification restarted successfully",
     "resourceAddEntrypointsEditFile": "Edit file: config/traefik/traefik_config.yml",
     "resourceExposePortsEditFile": "Edit file: docker-compose.yml",
     "emailVerificationRequired": "Email verification is required. Please log in again via {dashboardUrl}/auth/login complete this step. Then, come back here.",
     "twoFactorSetupRequired": "Two-factor authentication setup is required. Please log in again via {dashboardUrl}/auth/login complete this step. Then, come back here.",
+    "authPageErrorUpdateMessage": "An error occurred while updating the auth page settings",
+    "authPageUpdated": "Auth page updated successfully",
+    "healthCheckNotAvailable": "Local",
     "rewritePath": "Rewrite Path",
     "rewritePathDescription": "Optionally rewrite the path before forwarding to the target."
 }

messages/es-ES.json

@@ -67,7 +67,7 @@
     "siteDocker": "Expandir para detalles de despliegue de Docker",
     "toggle": "Cambiar",
     "dockerCompose": "Componer Docker",
-    "dockerRun": "Docker Run",
+    "dockerRun": "Ejecutar Docker",
     "siteLearnLocal": "Los sitios locales no tienen túnel, aprender más",
     "siteConfirmCopy": "He copiado la configuración",
     "searchSitesProgress": "Buscar sitios...",
@@ -168,6 +168,9 @@
     "siteSelect": "Seleccionar sitio",
     "siteSearch": "Buscar sitio",
     "siteNotFound": "Sitio no encontrado.",
+    "selectCountry": "Seleccionar país",
+    "searchCountries": "Buscar países...",
+    "noCountryFound": "Ningún país encontrado.",
     "siteSelectionDescription": "Este sitio proporcionará conectividad al objetivo.",
     "resourceType": "Tipo de recurso",
     "resourceTypeDescription": "Determina cómo quieres acceder a tu recurso",
@@ -814,7 +817,7 @@
     "redirectUrl": "URL de redirección",
     "redirectUrlAbout": "Acerca de la URL de redirección",
     "redirectUrlAboutDescription": "Esta es la URL a la que los usuarios serán redireccionados después de la autenticación. Necesitas configurar esta URL en la configuración de tu proveedor de identidad.",
-    "pangolinAuth": "Auth - Pangolin",
+    "pangolinAuth": "Autenticación - Pangolin",
     "verificationCodeLengthRequirements": "Tu código de verificación debe tener 8 caracteres.",
     "errorOccurred": "Se ha producido un error",
     "emailErrorVerify": "No se pudo verificar el email:",
@@ -914,8 +917,6 @@
     "idpConnectingToFinished": "Conectado",
     "idpErrorConnectingTo": "Hubo un problema al conectar con {name}. Por favor, póngase en contacto con su administrador.",
     "idpErrorNotFound": "IdP no encontrado",
-    "idpGoogleAlt": "Google",
-    "idpAzureAlt": "Azure",
     "inviteInvalid": "Invitación inválida",
     "inviteInvalidDescription": "El enlace de invitación no es válido.",
     "inviteErrorWrongUser": "La invitación no es para este usuario",
@@ -1219,7 +1220,7 @@
     "billing": "Facturación",
     "orgBillingDescription": "Gestiona tu información de facturación y suscripciones",
     "github": "GitHub",
-    "pangolinHosted": "Pangolin Hosted",
+    "pangolinHosted": "Pangolin Alojado",
     "fossorial": "Fossorial",
     "completeAccountSetup": "Completar configuración de cuenta",
     "completeAccountSetupDescription": "Establece tu contraseña para comenzar",
@@ -1257,6 +1258,48 @@
     "domainPickerSubdomain": "Subdominio: {subdomain}",
     "domainPickerNamespace": "Espacio de nombres: {namespace}",
     "domainPickerShowMore": "Mostrar más",
+    "regionSelectorTitle": "Seleccionar Región",
+    "regionSelectorInfo": "Seleccionar una región nos ayuda a brindar un mejor rendimiento para tu ubicación. No tienes que estar en la misma región que tu servidor.",
+    "regionSelectorPlaceholder": "Elige una región",
+    "regionSelectorComingSoon": "Próximamente",
+    "billingLoadingSubscription": "Cargando suscripción...",
+    "billingFreeTier": "Nivel Gratis",
+    "billingWarningOverLimit": "Advertencia: Has excedido uno o más límites de uso. Tus sitios no se conectarán hasta que modifiques tu suscripción o ajustes tu uso.",
+    "billingUsageLimitsOverview": "Descripción general de los límites de uso",
+    "billingMonitorUsage": "Monitorea tu uso comparado con los límites configurados. Si necesitas que aumenten los límites, contáctanos a soporte@fossorial.io.",
+    "billingDataUsage": "Uso de datos",
+    "billingOnlineTime": "Tiempo en línea del sitio",
+    "billingUsers": "Usuarios activos",
+    "billingDomains": "Dominios activos",
+    "billingRemoteExitNodes": "Nodos autogestionados activos",
+    "billingNoLimitConfigured": "No se ha configurado ningún límite",
+    "billingEstimatedPeriod": "Período de facturación estimado",
+    "billingIncludedUsage": "Uso incluido",
+    "billingIncludedUsageDescription": "Uso incluido con su plan de suscripción actual",
+    "billingFreeTierIncludedUsage": "Permisos de uso del nivel gratuito",
+    "billingIncluded": "incluido",
+    "billingEstimatedTotal": "Total Estimado:",
+    "billingNotes": "Notas",
+    "billingEstimateNote": "Esta es una estimación basada en tu uso actual.",
+    "billingActualChargesMayVary": "Los cargos reales pueden variar.",
+    "billingBilledAtEnd": "Se te facturará al final del período de facturación.",
+    "billingModifySubscription": "Modificar Suscripción",
+    "billingStartSubscription": "Iniciar Suscripción",
+    "billingRecurringCharge": "Cargo Recurrente",
+    "billingManageSubscriptionSettings": "Administra la configuración y preferencias de tu suscripción",
+    "billingNoActiveSubscription": "No tienes una suscripción activa. Inicia tu suscripción para aumentar los límites de uso.",
+    "billingFailedToLoadSubscription": "Error al cargar la suscripción",
+    "billingFailedToLoadUsage": "Error al cargar el uso",
+    "billingFailedToGetCheckoutUrl": "Error al obtener la URL de pago",
+    "billingPleaseTryAgainLater": "Por favor, inténtelo de nuevo más tarde.",
+    "billingCheckoutError": "Error de pago",
+    "billingFailedToGetPortalUrl": "Error al obtener la URL del portal",
+    "billingPortalError": "Error del portal",
+    "billingDataUsageInfo": "Se le cobran todos los datos transferidos a través de sus túneles seguros cuando se conectan a la nube. Esto incluye tanto tráfico entrante como saliente a través de todos sus sitios. Cuando alcance su límite, sus sitios se desconectarán hasta que actualice su plan o reduzca el uso. Los datos no se cargan cuando se usan nodos.",
+    "billingOnlineTimeInfo": "Se te cobrará en función del tiempo que tus sitios permanezcan conectados a la nube. Por ejemplo, 44.640 minutos equivale a un sitio que funciona 24/7 durante un mes completo. Cuando alcance su límite, sus sitios se desconectarán hasta que mejore su plan o reduzca el uso. No se cargará el tiempo al usar nodos.",
+    "billingUsersInfo": "Se te cobra por cada usuario en tu organización. La facturación se calcula diariamente según la cantidad de cuentas de usuario activas en tu organización.",
+    "billingDomainInfo": "Se te cobra por cada dominio en tu organización. La facturación se calcula diariamente según la cantidad de cuentas de dominio activas en tu organización.",
+    "billingRemoteExitNodesInfo": "Se te cobra por cada nodo gestionado en tu organización. La facturación se calcula diariamente según la cantidad de nodos gestionados activos en tu organización.",
     "domainNotFound": "Dominio no encontrado",
     "domainNotFoundDescription": "Este recurso está deshabilitado porque el dominio ya no existe en nuestro sistema. Por favor, establece un nuevo dominio para este recurso.",
     "failed": "Fallido",
@@ -1320,6 +1363,7 @@
     "createDomainDnsPropagationDescription": "Los cambios de DNS pueden tardar un tiempo en propagarse a través de internet. Esto puede tardar desde unos pocos minutos hasta 48 horas, dependiendo de tu proveedor de DNS y la configuración de TTL.",
     "resourcePortRequired": "Se requiere número de puerto para recursos no HTTP",
     "resourcePortNotAllowed": "El número de puerto no debe establecerse para recursos HTTP",
+    "billingPricingCalculatorLink": "Calculadora de Precios",
     "signUpTerms": {
         "IAgreeToThe": "Estoy de acuerdo con los",
         "termsOfService": "términos del servicio",
@@ -1368,6 +1412,41 @@
     "addNewTarget": "Agregar nuevo destino",
     "targetsList": "Lista de destinos",
     "targetErrorDuplicateTargetFound": "Se encontró un destino duplicado",
+    "healthCheckHealthy": "Saludable",
+    "healthCheckUnhealthy": "No saludable",
+    "healthCheckUnknown": "Desconocido",
+    "healthCheck": "Chequeo de salud",
+    "configureHealthCheck": "Configurar Chequeo de Salud",
+    "configureHealthCheckDescription": "Configura la monitorización de salud para {target}",
+    "enableHealthChecks": "Activar Chequeos de Salud",
+    "enableHealthChecksDescription": "Controlar la salud de este objetivo. Puedes supervisar un punto final diferente al objetivo si es necesario.",
+    "healthScheme": "Método",
+    "healthSelectScheme": "Seleccionar método",
+    "healthCheckPath": "Ruta",
+    "healthHostname": "IP / Host",
+    "healthPort": "Puerto",
+    "healthCheckPathDescription": "La ruta para comprobar el estado de salud.",
+    "healthyIntervalSeconds": "Intervalo Saludable",
+    "unhealthyIntervalSeconds": "Intervalo No Saludable",
+    "IntervalSeconds": "Intervalo Saludable",
+    "timeoutSeconds": "Tiempo de Espera",
+    "timeIsInSeconds": "El tiempo está en segundos",
+    "retryAttempts": "Intentos de Reintento",
+    "expectedResponseCodes": "Códigos de respuesta esperados",
+    "expectedResponseCodesDescription": "Código de estado HTTP que indica un estado saludable. Si se deja en blanco, se considera saludable de 200 a 300.",
+    "customHeaders": "Cabeceras personalizadas",
+    "customHeadersDescription": "Nueva línea de cabeceras separada: Nombre de cabecera: valor",
+    "headersValidationError": "Los encabezados deben estar en el formato: Nombre de cabecera: valor.",
+    "saveHealthCheck": "Guardar Chequeo de Salud",
+    "healthCheckSaved": "Chequeo de Salud Guardado",
+    "healthCheckSavedDescription": "La configuración del chequeo de salud se ha guardado correctamente",
+    "healthCheckError": "Error en el Chequeo de Salud",
+    "healthCheckErrorDescription": "Ocurrió un error al guardar la configuración del chequeo de salud",
+    "healthCheckPathRequired": "Se requiere la ruta del chequeo de salud",
+    "healthCheckMethodRequired": "Se requiere el método HTTP",
+    "healthCheckIntervalMin": "El intervalo de comprobación debe ser de al menos 5 segundos",
+    "healthCheckTimeoutMin": "El tiempo de espera debe ser de al menos 1 segundo",
+    "healthCheckRetryMin": "Los intentos de reintento deben ser de al menos 1",
     "httpMethod": "Método HTTP",
     "selectHttpMethod": "Seleccionar método HTTP",
     "domainPickerSubdomainLabel": "Subdominio",
@@ -1381,6 +1460,7 @@
     "domainPickerEnterSubdomainToSearch": "Ingrese un subdominio para buscar y seleccionar entre dominios gratuitos disponibles.",
     "domainPickerFreeDomains": "Dominios gratuitos",
     "domainPickerSearchForAvailableDomains": "Buscar dominios disponibles",
+    "domainPickerNotWorkSelfHosted": "Nota: Los dominios gratuitos proporcionados no están disponibles para instancias autogestionadas por ahora.",
     "resourceDomain": "Dominio",
     "resourceEditDomain": "Editar dominio",
     "siteName": "Nombre del sitio",
@@ -1463,6 +1543,72 @@
     "autoLoginError": "Error de inicio de sesión automático",
     "autoLoginErrorNoRedirectUrl": "No se recibió URL de redirección del proveedor de identidad.",
     "autoLoginErrorGeneratingUrl": "Error al generar URL de autenticación.",
+    "remoteExitNodeManageRemoteExitNodes": "Administrar Nodos Autogestionados",
+    "remoteExitNodeDescription": "Administrar nodos para extender la conectividad de red",
+    "remoteExitNodes": "Nodes",
+    "searchRemoteExitNodes": "Buscar nodos...",
+    "remoteExitNodeAdd": "Añadir Nodo",
+    "remoteExitNodeErrorDelete": "Error al eliminar el nodo",
+    "remoteExitNodeQuestionRemove": "¿Está seguro de que desea eliminar el nodo {selectedNode} de la organización?",
+    "remoteExitNodeMessageRemove": "Una vez eliminado, el nodo ya no será accesible.",
+    "remoteExitNodeMessageConfirm": "Para confirmar, por favor escriba el nombre del nodo a continuación.",
+    "remoteExitNodeConfirmDelete": "Confirmar eliminar nodo",
+    "remoteExitNodeDelete": "Eliminar Nodo",
+    "sidebarRemoteExitNodes": "Nodes",
+    "remoteExitNodeCreate": {
+        "title": "Crear Nodo",
+        "description": "Crear un nuevo nodo para extender la conectividad de red",
+        "viewAllButton": "Ver todos los nodos",
+        "strategy": {
+            "title": "Estrategia de Creación",
+            "description": "Elija esto para configurar manualmente su nodo o generar nuevas credenciales.",
+            "adopt": {
+                "title": "Adoptar Nodo",
+                "description": "Elija esto si ya tiene las credenciales para el nodo."
+            },
+            "generate": {
+                "title": "Generar Claves",
+                "description": "Elija esto si desea generar nuevas claves para el nodo"
+            }
+        },
+        "adopt": {
+            "title": "Adoptar Nodo Existente",
+            "description": "Introduzca las credenciales del nodo existente que desea adoptar",
+            "nodeIdLabel": "ID del nodo",
+            "nodeIdDescription": "El ID del nodo existente que desea adoptar",
+            "secretLabel": "Secreto",
+            "secretDescription": "La clave secreta del nodo existente",
+            "submitButton": "Adoptar Nodo"
+        },
+        "generate": {
+            "title": "Credenciales Generadas",
+            "description": "Utilice estas credenciales generadas para configurar su nodo",
+            "nodeIdTitle": "ID del nodo",
+            "secretTitle": "Secreto",
+            "saveCredentialsTitle": "Agregar Credenciales a la Configuración",
+            "saveCredentialsDescription": "Agrega estas credenciales a tu archivo de configuración del nodo Pangolin autogestionado para completar la conexión.",
+            "submitButton": "Crear Nodo"
+        },
+        "validation": {
+            "adoptRequired": "El ID del nodo y el secreto son necesarios al adoptar un nodo existente"
+        },
+        "errors": {
+            "loadDefaultsFailed": "Falló al cargar los valores predeterminados",
+            "defaultsNotLoaded": "Valores predeterminados no cargados",
+            "createFailed": "Error al crear el nodo"
+        },
+        "success": {
+            "created": "Nodo creado correctamente"
+        }
+    },
+    "remoteExitNodeSelection": "Selección de nodo",
+    "remoteExitNodeSelectionDescription": "Seleccione un nodo a través del cual enrutar el tráfico para este sitio local",
+    "remoteExitNodeRequired": "Un nodo debe ser seleccionado para sitios locales",
+    "noRemoteExitNodesAvailable": "No hay nodos disponibles",
+    "noRemoteExitNodesAvailableDescription": "No hay nodos disponibles para esta organización. Crea un nodo primero para usar sitios locales.",
+    "exitNode": "Nodo de Salida",
+    "country": "País",
+    "rulesMatchCountry": "Actualmente basado en IP de origen",
     "managedSelfHosted": {
         "title": "Autogestionado",
         "description": "Servidor Pangolin autoalojado más fiable y de bajo mantenimiento con campanas y silbidos extra",
@@ -1501,11 +1647,53 @@
     },
     "internationaldomaindetected": "Dominio Internacional detectado",
     "willbestoredas": "Se almacenará como:",
+    "roleMappingDescription": "Determinar cómo se asignan los roles a los usuarios cuando se registran cuando está habilitada la provisión automática.",
+    "selectRole": "Seleccione un rol",
+    "roleMappingExpression": "Expresión",
+    "selectRolePlaceholder": "Elija un rol",
+    "selectRoleDescription": "Seleccione un rol para asignar a todos los usuarios de este proveedor de identidad",
+    "roleMappingExpressionDescription": "Introduzca una expresión JMESPath para extraer información de rol del token de ID",
+    "idpTenantIdRequired": "El ID del cliente es obligatorio",
+    "invalidValue": "Valor inválido",
+    "idpTypeLabel": "Tipo de proveedor de identidad",
+    "roleMappingExpressionPlaceholder": "e.g., contiene(grupos, 'administrador') && 'administrador' || 'miembro'",
+    "idpGoogleConfiguration": "Configuración de Google",
+    "idpGoogleConfigurationDescription": "Configura tus credenciales de Google OAuth2",
+    "idpGoogleClientIdDescription": "Tu ID de cliente de Google OAuth2",
+    "idpGoogleClientSecretDescription": "Tu secreto de cliente de Google OAuth2",
+    "idpAzureConfiguration": "Configuración de Azure Entra ID",
+    "idpAzureConfigurationDescription": "Configure sus credenciales de Azure Entra ID OAuth2",
+    "idpTenantId": "Tenant ID",
+    "idpTenantIdPlaceholder": "su-inquilino-id",
+    "idpAzureTenantIdDescription": "Su ID de inquilino de Azure (encontrado en el resumen de Azure Active Directory)",
+    "idpAzureClientIdDescription": "Tu ID de Cliente de Registro de Azure App",
+    "idpAzureClientSecretDescription": "Tu Azure App Registro Cliente secreto",
+    "idpGoogleTitle": "Google",
+    "idpGoogleAlt": "Google",
+    "idpAzureTitle": "Azure Entra ID",
+    "idpAzureAlt": "Azure",
+    "idpGoogleConfigurationTitle": "Configuración de Google",
+    "idpAzureConfigurationTitle": "Configuración de Azure Entra ID",
+    "idpTenantIdLabel": "Tenant ID",
+    "idpAzureClientIdDescription2": "Tu ID de Cliente de Registro de Azure App",
+    "idpAzureClientSecretDescription2": "Tu Azure App Registro Cliente secreto",
     "idpGoogleDescription": "Proveedor OAuth2/OIDC de Google",
     "idpAzureDescription": "Microsoft Azure OAuth2/OIDC provider",
-    "customHeaders": "Cabeceras personalizadas",
-    "customHeadersDescription": "Add custom headers to be sent when proxying requests. One per line in the format Header-Name: value",
-    "headersValidationError": "Los encabezados deben estar en el formato: Nombre de cabecera: valor.",
+    "subnet": "Subred",
+    "subnetDescription": "La subred para la configuración de red de esta organización.",
+    "authPage": "Página Auth",
+    "authPageDescription": "Configurar la página de autenticación de su organización",
+    "authPageDomain": "Auth Page Domain",
+    "noDomainSet": "Ningún dominio establecido",
+    "changeDomain": "Cambiar dominio",
+    "selectDomain": "Seleccionar dominio",
+    "restartCertificate": "Reiniciar certificado",
+    "editAuthPageDomain": "Editar dominio Auth Page",
+    "setAuthPageDomain": "Establecer dominio Auth Page",
+    "failedToFetchCertificate": "Error al obtener el certificado",
+    "failedToRestartCertificate": "Error al reiniciar el certificado",
+    "addDomainToEnableCustomAuthPages": "Añadir un dominio para habilitar páginas de autenticación personalizadas para su organización",
+    "selectDomainForOrgAuthPage": "Seleccione un dominio para la página de autenticación de la organización",
     "domainPickerProvidedDomain": "Dominio proporcionado",
     "domainPickerFreeProvidedDomain": "Dominio proporcionado gratis",
     "domainPickerVerified": "Verificado",
@@ -1519,10 +1707,16 @@
     "domainPickerInvalidSubdomainCannotMakeValid": "No se ha podido hacer válido \"{sub}\" para {domain}.",
     "domainPickerSubdomainSanitized": "Subdominio saneado",
     "domainPickerSubdomainCorrected": "\"{sub}\" fue corregido a \"{sanitized}\"",
+    "orgAuthSignInTitle": "Inicia sesión en tu organización",
+    "orgAuthChooseIdpDescription": "Elige tu proveedor de identidad para continuar",
+    "orgAuthNoIdpConfigured": "Esta organización no tiene ningún proveedor de identidad configurado. En su lugar puedes iniciar sesión con tu identidad de Pangolin.",
+    "orgAuthSignInWithPangolin": "Iniciar sesión con Pangolin",
+    "subscriptionRequiredToUse": "Se requiere una suscripción para utilizar esta función.",
+    "idpDisabled": "Los proveedores de identidad están deshabilitados.",
+    "orgAuthPageDisabled": "La página de autenticación de la organización está deshabilitada.",
+    "domainRestartedDescription": "Verificación de dominio reiniciada con éxito",
     "resourceAddEntrypointsEditFile": "Editar archivo: config/traefik/traefik_config.yml",
     "resourceExposePortsEditFile": "Editar archivo: docker-compose.yml",
     "emailVerificationRequired": "Se requiere verificación de correo electrónico. Por favor, inicie sesión de nuevo a través de {dashboardUrl}/auth/login complete este paso. Luego, vuelva aquí.",
-    "twoFactorSetupRequired": "La configuración de autenticación de doble factor es requerida. Por favor, inicia sesión de nuevo a través de {dashboardUrl}/auth/login completa este paso. Luego, vuelve aquí.",
-    "rewritePath": "Rewrite Path",
-    "rewritePathDescription": "Optionally rewrite the path before forwarding to the target."
+    "twoFactorSetupRequired": "La configuración de autenticación de doble factor es requerida. Por favor, inicia sesión de nuevo a través de {dashboardUrl}/auth/login completa este paso. Luego, vuelve aquí."
 }

messages/fr-FR.json

@@ -168,6 +168,9 @@
     "siteSelect": "Sélectionner un site",
     "siteSearch": "Chercher un site",
     "siteNotFound": "Aucun site trouvé.",
+    "selectCountry": "Sélectionnez un pays",
+    "searchCountries": "Recherchez des pays...",
+    "noCountryFound": "Aucun pays trouvé.",
     "siteSelectionDescription": "Ce site fournira la connectivité à la cible.",
     "resourceType": "Type de ressource",
     "resourceTypeDescription": "Déterminer comment vous voulez accéder à votre ressource",
@@ -914,8 +917,6 @@
     "idpConnectingToFinished": "Connecté",
     "idpErrorConnectingTo": "Un problème est survenu lors de la connexion à {name}. Veuillez contacter votre administrateur.",
     "idpErrorNotFound": "IdP introuvable",
-    "idpGoogleAlt": "Google",
-    "idpAzureAlt": "Azure",
     "inviteInvalid": "Invitation invalide",
     "inviteInvalidDescription": "Le lien d'invitation n'est pas valide.",
     "inviteErrorWrongUser": "L'invitation n'est pas pour cet utilisateur",
@@ -1257,6 +1258,48 @@
     "domainPickerSubdomain": "Sous-domaine : {subdomain}",
     "domainPickerNamespace": "Espace de noms : {namespace}",
     "domainPickerShowMore": "Afficher plus",
+    "regionSelectorTitle": "Sélectionner Région",
+    "regionSelectorInfo": "Sélectionner une région nous aide à offrir de meilleures performances pour votre localisation. Vous n'avez pas besoin d'être dans la même région que votre serveur.",
+    "regionSelectorPlaceholder": "Choisissez une région",
+    "regionSelectorComingSoon": "Bientôt disponible",
+    "billingLoadingSubscription": "Chargement de l'abonnement...",
+    "billingFreeTier": "Niveau gratuit",
+    "billingWarningOverLimit": "Attention : Vous avez dépassé une ou plusieurs limites d'utilisation. Vos sites ne se connecteront pas tant que vous n'avez pas modifié votre abonnement ou ajusté votre utilisation.",
+    "billingUsageLimitsOverview": "Vue d'ensemble des limites d'utilisation",
+    "billingMonitorUsage": "Surveillez votre consommation par rapport aux limites configurées. Si vous avez besoin d'une augmentation des limites, veuillez nous contacter à support@fossorial.io.",
+    "billingDataUsage": "Utilisation des données",
+    "billingOnlineTime": "Temps en ligne du site",
+    "billingUsers": "Utilisateurs actifs",
+    "billingDomains": "Domaines actifs",
+    "billingRemoteExitNodes": "Nœuds auto-hébergés actifs",
+    "billingNoLimitConfigured": "Aucune limite configurée",
+    "billingEstimatedPeriod": "Période de facturation estimée",
+    "billingIncludedUsage": "Utilisation incluse",
+    "billingIncludedUsageDescription": "Utilisation incluse dans votre plan d'abonnement actuel",
+    "billingFreeTierIncludedUsage": "Tolérances d'utilisation du niveau gratuit",
+    "billingIncluded": "inclus",
+    "billingEstimatedTotal": "Total estimé :",
+    "billingNotes": "Notes",
+    "billingEstimateNote": "Ceci est une estimation basée sur votre utilisation actuelle.",
+    "billingActualChargesMayVary": "Les frais réels peuvent varier.",
+    "billingBilledAtEnd": "Vous serez facturé à la fin de la période de facturation.",
+    "billingModifySubscription": "Modifier l'abonnement",
+    "billingStartSubscription": "Démarrer l'abonnement",
+    "billingRecurringCharge": "Frais récurrents",
+    "billingManageSubscriptionSettings": "Gérez les paramètres et préférences de votre abonnement",
+    "billingNoActiveSubscription": "Vous n'avez pas d'abonnement actif. Commencez votre abonnement pour augmenter les limites d'utilisation.",
+    "billingFailedToLoadSubscription": "Échec du chargement de l'abonnement",
+    "billingFailedToLoadUsage": "Échec du chargement de l'utilisation",
+    "billingFailedToGetCheckoutUrl": "Échec pour obtenir l'URL de paiement",
+    "billingPleaseTryAgainLater": "Veuillez réessayer plus tard.",
+    "billingCheckoutError": "Erreur de paiement",
+    "billingFailedToGetPortalUrl": "Échec pour obtenir l'URL du portail",
+    "billingPortalError": "Erreur du portail",
+    "billingDataUsageInfo": "Vous êtes facturé pour toutes les données transférées via vos tunnels sécurisés lorsque vous êtes connecté au cloud. Cela inclut le trafic entrant et sortant sur tous vos sites. Lorsque vous atteignez votre limite, vos sites se déconnecteront jusqu'à ce que vous mettiez à niveau votre plan ou réduisiez l'utilisation. Les données ne sont pas facturées lors de l'utilisation de nœuds.",
+    "billingOnlineTimeInfo": "Vous êtes facturé en fonction de la durée de connexion de vos sites au cloud. Par exemple, 44 640 minutes équivaut à un site fonctionnant 24/7 pendant un mois complet. Lorsque vous atteignez votre limite, vos sites se déconnecteront jusqu'à ce que vous mettiez à niveau votre forfait ou réduisiez votre consommation. Le temps n'est pas facturé lors de l'utilisation de nœuds.",
+    "billingUsersInfo": "Vous êtes facturé pour chaque utilisateur dans votre organisation. La facturation est calculée quotidiennement en fonction du nombre de comptes utilisateurs actifs dans votre organisation.",
+    "billingDomainInfo": "Vous êtes facturé pour chaque domaine dans votre organisation. La facturation est calculée quotidiennement en fonction du nombre de comptes de domaine actifs dans votre organisation.",
+    "billingRemoteExitNodesInfo": "Vous êtes facturé pour chaque nœud géré dans votre organisation. La facturation est calculée quotidiennement en fonction du nombre de nœuds gérés actifs dans votre organisation.",
     "domainNotFound": "Domaine introuvable",
     "domainNotFoundDescription": "Cette ressource est désactivée car le domaine n'existe plus dans notre système. Veuillez définir un nouveau domaine pour cette ressource.",
     "failed": "Échec",
@@ -1320,6 +1363,7 @@
     "createDomainDnsPropagationDescription": "Les modifications DNS peuvent mettre du temps à se propager sur internet. Cela peut prendre de quelques minutes à 48 heures selon votre fournisseur DNS et les réglages TTL.",
     "resourcePortRequired": "Le numéro de port est requis pour les ressources non-HTTP",
     "resourcePortNotAllowed": "Le numéro de port ne doit pas être défini pour les ressources HTTP",
+    "billingPricingCalculatorLink": "Calculateur de prix",
     "signUpTerms": {
         "IAgreeToThe": "Je suis d'accord avec",
         "termsOfService": "les conditions d'utilisation",
@@ -1368,6 +1412,41 @@
     "addNewTarget": "Ajouter une nouvelle cible",
     "targetsList": "Liste des cibles",
     "targetErrorDuplicateTargetFound": "Cible en double trouvée",
+    "healthCheckHealthy": "Sain",
+    "healthCheckUnhealthy": "En mauvaise santé",
+    "healthCheckUnknown": "Inconnu",
+    "healthCheck": "Vérification de l'état de santé",
+    "configureHealthCheck": "Configurer la vérification de l'état de santé",
+    "configureHealthCheckDescription": "Configurer la surveillance de la santé pour {target}",
+    "enableHealthChecks": "Activer les vérifications de santé",
+    "enableHealthChecksDescription": "Surveiller la vie de cette cible. Vous pouvez surveiller un point de terminaison différent de la cible si nécessaire.",
+    "healthScheme": "Méthode",
+    "healthSelectScheme": "Sélectionnez la méthode",
+    "healthCheckPath": "Chemin d'accès",
+    "healthHostname": "IP / Hôte",
+    "healthPort": "Port",
+    "healthCheckPathDescription": "Le chemin à vérifier pour le statut de santé.",
+    "healthyIntervalSeconds": "Intervalle sain",
+    "unhealthyIntervalSeconds": "Intervalle en mauvaise santé",
+    "IntervalSeconds": "Intervalle sain",
+    "timeoutSeconds": "Délai",
+    "timeIsInSeconds": "Le temps est exprimé en secondes",
+    "retryAttempts": "Tentatives de réessai",
+    "expectedResponseCodes": "Codes de réponse attendus",
+    "expectedResponseCodesDescription": "Code de statut HTTP indiquant un état de santé satisfaisant. Si non renseigné, 200-300 est considéré comme satisfaisant.",
+    "customHeaders": "En-têtes personnalisés",
+    "customHeadersDescription": "En-têtes séparés par une nouvelle ligne: En-nom: valeur",
+    "headersValidationError": "Les entêtes doivent être au format : Header-Name: valeur.",
+    "saveHealthCheck": "Sauvegarder la vérification de l'état de santé",
+    "healthCheckSaved": "Vérification de l'état de santé enregistrée",
+    "healthCheckSavedDescription": "La configuration de la vérification de l'état de santé a été enregistrée avec succès",
+    "healthCheckError": "Erreur de vérification de l'état de santé",
+    "healthCheckErrorDescription": "Une erreur s'est produite lors de l'enregistrement de la configuration de la vérification de l'état de santé",
+    "healthCheckPathRequired": "Le chemin de vérification de l'état de santé est requis",
+    "healthCheckMethodRequired": "La méthode HTTP est requise",
+    "healthCheckIntervalMin": "L'intervalle de vérification doit être d'au moins 5 secondes",
+    "healthCheckTimeoutMin": "Le délai doit être d'au moins 1 seconde",
+    "healthCheckRetryMin": "Les tentatives de réessai doivent être d'au moins 1",
     "httpMethod": "Méthode HTTP",
     "selectHttpMethod": "Sélectionnez la méthode HTTP",
     "domainPickerSubdomainLabel": "Sous-domaine",
@@ -1381,6 +1460,7 @@
     "domainPickerEnterSubdomainToSearch": "Entrez un sous-domaine pour rechercher et sélectionner parmi les domaines gratuits disponibles.",
     "domainPickerFreeDomains": "Domaines gratuits",
     "domainPickerSearchForAvailableDomains": "Rechercher des domaines disponibles",
+    "domainPickerNotWorkSelfHosted": "Remarque : Les domaines fournis gratuitement ne sont pas disponibles pour les instances auto-hébergées pour le moment.",
     "resourceDomain": "Domaine",
     "resourceEditDomain": "Modifier le domaine",
     "siteName": "Nom du site",
@@ -1463,6 +1543,72 @@
     "autoLoginError": "Erreur de connexion automatique",
     "autoLoginErrorNoRedirectUrl": "Aucune URL de redirection reçue du fournisseur d'identité.",
     "autoLoginErrorGeneratingUrl": "Échec de la génération de l'URL d'authentification.",
+    "remoteExitNodeManageRemoteExitNodes": "Gérer auto-hébergé",
+    "remoteExitNodeDescription": "Gérer les nœuds pour étendre votre connectivité réseau",
+    "remoteExitNodes": "Nodes",
+    "searchRemoteExitNodes": "Rechercher des nœuds...",
+    "remoteExitNodeAdd": "Ajouter un noeud",
+    "remoteExitNodeErrorDelete": "Erreur lors de la suppression du noeud",
+    "remoteExitNodeQuestionRemove": "Êtes-vous sûr de vouloir supprimer le noeud {selectedNode} de l'organisation ?",
+    "remoteExitNodeMessageRemove": "Une fois supprimé, le noeud ne sera plus accessible.",
+    "remoteExitNodeMessageConfirm": "Pour confirmer, veuillez saisir le nom du noeud ci-dessous.",
+    "remoteExitNodeConfirmDelete": "Confirmer la suppression du noeud",
+    "remoteExitNodeDelete": "Supprimer le noeud",
+    "sidebarRemoteExitNodes": "Nodes",
+    "remoteExitNodeCreate": {
+        "title": "Créer un noeud",
+        "description": "Créer un nouveau nœud pour étendre votre connectivité réseau",
+        "viewAllButton": "Voir tous les nœuds",
+        "strategy": {
+            "title": "Stratégie de création",
+            "description": "Choisissez ceci pour configurer manuellement votre nœud ou générer de nouveaux identifiants.",
+            "adopt": {
+                "title": "Adopter un nœud",
+                "description": "Choisissez ceci si vous avez déjà les identifiants pour le noeud."
+            },
+            "generate": {
+                "title": "Générer des clés",
+                "description": "Choisissez ceci si vous voulez générer de nouvelles clés pour le noeud"
+            }
+        },
+        "adopt": {
+            "title": "Adopter un nœud existant",
+            "description": "Entrez les identifiants du noeud existant que vous souhaitez adopter",
+            "nodeIdLabel": "Nœud ID",
+            "nodeIdDescription": "L'ID du noeud existant que vous voulez adopter",
+            "secretLabel": "Secret",
+            "secretDescription": "La clé secrète du noeud existant",
+            "submitButton": "Noeud d'Adopt"
+        },
+        "generate": {
+            "title": "Informations d'identification générées",
+            "description": "Utilisez ces identifiants générés pour configurer votre noeud",
+            "nodeIdTitle": "Nœud ID",
+            "secretTitle": "Secret",
+            "saveCredentialsTitle": "Ajouter des identifiants à la config",
+            "saveCredentialsDescription": "Ajoutez ces informations d'identification à votre fichier de configuration du nœud Pangolin auto-hébergé pour compléter la connexion.",
+            "submitButton": "Créer un noeud"
+        },
+        "validation": {
+            "adoptRequired": "ID de nœud et secret sont requis lors de l'adoption d'un noeud existant"
+        },
+        "errors": {
+            "loadDefaultsFailed": "Échec du chargement des valeurs par défaut",
+            "defaultsNotLoaded": "Valeurs par défaut non chargées",
+            "createFailed": "Impossible de créer le noeud"
+        },
+        "success": {
+            "created": "Noeud créé avec succès"
+        }
+    },
+    "remoteExitNodeSelection": "Sélection du noeud",
+    "remoteExitNodeSelectionDescription": "Sélectionnez un nœud pour acheminer le trafic pour ce site local",
+    "remoteExitNodeRequired": "Un noeud doit être sélectionné pour les sites locaux",
+    "noRemoteExitNodesAvailable": "Aucun noeud disponible",
+    "noRemoteExitNodesAvailableDescription": "Aucun noeud n'est disponible pour cette organisation. Créez d'abord un noeud pour utiliser des sites locaux.",
+    "exitNode": "Nœud de sortie",
+    "country": "Pays",
+    "rulesMatchCountry": "Actuellement basé sur l'IP source",
     "managedSelfHosted": {
         "title": "Gestion autonome",
         "description": "Serveur Pangolin auto-hébergé avec des cloches et des sifflets supplémentaires",
@@ -1501,11 +1647,53 @@
     },
     "internationaldomaindetected": "Domaine international détecté",
     "willbestoredas": "Sera stocké comme :",
+    "roleMappingDescription": "Détermine comment les rôles sont assignés aux utilisateurs lorsqu'ils se connectent lorsque la fourniture automatique est activée.",
+    "selectRole": "Sélectionnez un rôle",
+    "roleMappingExpression": "Expression",
+    "selectRolePlaceholder": "Choisir un rôle",
+    "selectRoleDescription": "Sélectionnez un rôle à assigner à tous les utilisateurs de ce fournisseur d'identité",
+    "roleMappingExpressionDescription": "Entrez une expression JMESPath pour extraire les informations du rôle du jeton ID",
+    "idpTenantIdRequired": "L'ID du locataire est requis",
+    "invalidValue": "Valeur non valide",
+    "idpTypeLabel": "Type de fournisseur d'identité",
+    "roleMappingExpressionPlaceholder": "ex: contenu(groupes) && 'admin' || 'membre'",
+    "idpGoogleConfiguration": "Configuration Google",
+    "idpGoogleConfigurationDescription": "Configurer vos identifiants Google OAuth2",
+    "idpGoogleClientIdDescription": "Votre identifiant client Google OAuth2",
+    "idpGoogleClientSecretDescription": "Votre secret client Google OAuth2",
+    "idpAzureConfiguration": "Configuration de l'entra ID Azure",
+    "idpAzureConfigurationDescription": "Configurer vos identifiants OAuth2 Azure Entra",
+    "idpTenantId": "Tenant ID",
+    "idpTenantIdPlaceholder": "votre-locataire-id",
+    "idpAzureTenantIdDescription": "Votre ID de locataire Azure (trouvé dans l'aperçu Azure Active Directory)",
+    "idpAzureClientIdDescription": "Votre ID client d'enregistrement de l'application Azure",
+    "idpAzureClientSecretDescription": "Le secret de votre client d'enregistrement Azure App",
+    "idpGoogleTitle": "Google",
+    "idpGoogleAlt": "Google",
+    "idpAzureTitle": "Azure Entra ID",
+    "idpAzureAlt": "Azure",
+    "idpGoogleConfigurationTitle": "Configuration Google",
+    "idpAzureConfigurationTitle": "Configuration de l'entra ID Azure",
+    "idpTenantIdLabel": "Tenant ID",
+    "idpAzureClientIdDescription2": "Votre ID client d'enregistrement de l'application Azure",
+    "idpAzureClientSecretDescription2": "Le secret de votre client d'enregistrement Azure App",
     "idpGoogleDescription": "Fournisseur Google OAuth2/OIDC",
     "idpAzureDescription": "Microsoft Azure OAuth2/OIDC provider",
-    "customHeaders": "En-têtes personnalisés",
-    "customHeadersDescription": "Add custom headers to be sent when proxying requests. One per line in the format Header-Name: value",
-    "headersValidationError": "Les entêtes doivent être au format : Header-Name: valeur.",
+    "subnet": "Sous-réseau",
+    "subnetDescription": "Le sous-réseau de la configuration réseau de cette organisation.",
+    "authPage": "Page d'authentification",
+    "authPageDescription": "Configurer la page d'authentification de votre organisation",
+    "authPageDomain": "Domaine de la page d'authentification",
+    "noDomainSet": "Aucun domaine défini",
+    "changeDomain": "Changer de domaine",
+    "selectDomain": "Sélectionner un domaine",
+    "restartCertificate": "Redémarrer le certificat",
+    "editAuthPageDomain": "Modifier le domaine de la page d'authentification",
+    "setAuthPageDomain": "Définir le domaine de la page d'authentification",
+    "failedToFetchCertificate": "Impossible de récupérer le certificat",
+    "failedToRestartCertificate": "Échec du redémarrage du certificat",
+    "addDomainToEnableCustomAuthPages": "Ajouter un domaine pour activer les pages d'authentification personnalisées pour votre organisation",
+    "selectDomainForOrgAuthPage": "Sélectionnez un domaine pour la page d'authentification de l'organisation",
     "domainPickerProvidedDomain": "Domaine fourni",
     "domainPickerFreeProvidedDomain": "Domaine fourni gratuitement",
     "domainPickerVerified": "Vérifié",
@@ -1519,10 +1707,16 @@
     "domainPickerInvalidSubdomainCannotMakeValid": "La «{sub}» n'a pas pu être validée pour {domain}.",
     "domainPickerSubdomainSanitized": "Sous-domaine nettoyé",
     "domainPickerSubdomainCorrected": "\"{sub}\" a été corrigé à \"{sanitized}\"",
+    "orgAuthSignInTitle": "Connectez-vous à votre organisation",
+    "orgAuthChooseIdpDescription": "Choisissez votre fournisseur d'identité pour continuer",
+    "orgAuthNoIdpConfigured": "Cette organisation n'a aucun fournisseur d'identité configuré. Vous pouvez vous connecter avec votre identité Pangolin à la place.",
+    "orgAuthSignInWithPangolin": "Se connecter avec Pangolin",
+    "subscriptionRequiredToUse": "Un abonnement est requis pour utiliser cette fonctionnalité.",
+    "idpDisabled": "Les fournisseurs d'identité sont désactivés.",
+    "orgAuthPageDisabled": "La page d'authentification de l'organisation est désactivée.",
+    "domainRestartedDescription": "La vérification du domaine a été redémarrée avec succès",
     "resourceAddEntrypointsEditFile": "Modifier le fichier : config/traefik/traefik_config.yml",
     "resourceExposePortsEditFile": "Modifier le fichier : docker-compose.yml",
     "emailVerificationRequired": "La vérification de l'e-mail est requise. Veuillez vous reconnecter via {dashboardUrl}/auth/login terminé cette étape. Puis revenez ici.",
-    "twoFactorSetupRequired": "La configuration d'authentification à deux facteurs est requise. Veuillez vous reconnecter via {dashboardUrl}/auth/login terminé cette étape. Puis revenez ici.",
-    "rewritePath": "Rewrite Path",
-    "rewritePathDescription": "Optionally rewrite the path before forwarding to the target."
+    "twoFactorSetupRequired": "La configuration d'authentification à deux facteurs est requise. Veuillez vous reconnecter via {dashboardUrl}/auth/login terminé cette étape. Puis revenez ici."
 }

messages/it-IT.json

@@ -36,8 +36,8 @@
     "viewSettings": "Visualizza impostazioni",
     "delete": "Elimina",
     "name": "Nome",
-    "online": "Online",
-    "offline": "Offline",
+    "online": "In linea",
+    "offline": "Non in linea",
     "site": "Sito",
     "dataIn": "Dati In",
     "dataOut": "Dati Fuori",
@@ -168,6 +168,9 @@
     "siteSelect": "Seleziona sito",
     "siteSearch": "Cerca sito",
     "siteNotFound": "Nessun sito trovato.",
+    "selectCountry": "Seleziona paese",
+    "searchCountries": "Cerca paesi...",
+    "noCountryFound": "Nessun paese trovato.",
     "siteSelectionDescription": "Questo sito fornirà connettività all'obiettivo.",
     "resourceType": "Tipo Di Risorsa",
     "resourceTypeDescription": "Determina come vuoi accedere alla tua risorsa",
@@ -914,8 +917,6 @@
     "idpConnectingToFinished": "Connesso",
     "idpErrorConnectingTo": "Si è verificato un problema durante la connessione a {name}. Contatta il tuo amministratore.",
     "idpErrorNotFound": "IdP non trovato",
-    "idpGoogleAlt": "Google",
-    "idpAzureAlt": "Azure",
     "inviteInvalid": "Invito Non Valido",
     "inviteInvalidDescription": "Il link di invito non è valido.",
     "inviteErrorWrongUser": "L'invito non è per questo utente",
@@ -1220,7 +1221,7 @@
     "orgBillingDescription": "Gestisci le tue informazioni di fatturazione e abbonamenti",
     "github": "GitHub",
     "pangolinHosted": "Pangolin Hosted",
-    "fossorial": "Fossorial",
+    "fossorial": "Fossoriale",
     "completeAccountSetup": "Completa la Configurazione dell'Account",
     "completeAccountSetupDescription": "Imposta la tua password per iniziare",
     "accountSetupSent": "Invieremo un codice di configurazione dell'account a questo indirizzo email.",
@@ -1257,6 +1258,48 @@
     "domainPickerSubdomain": "Sottodominio: {subdomain}",
     "domainPickerNamespace": "Namespace: {namespace}",
     "domainPickerShowMore": "Mostra Altro",
+    "regionSelectorTitle": "Seleziona regione",
+    "regionSelectorInfo": "Selezionare una regione ci aiuta a fornire migliori performance per la tua posizione. Non devi necessariamente essere nella stessa regione del tuo server.",
+    "regionSelectorPlaceholder": "Scegli una regione",
+    "regionSelectorComingSoon": "Prossimamente",
+    "billingLoadingSubscription": "Caricamento abbonamento...",
+    "billingFreeTier": "Piano Gratuito",
+    "billingWarningOverLimit": "Avviso: Hai superato uno o più limiti di utilizzo. I tuoi siti non si connetteranno finché non modifichi il tuo abbonamento o non adegui il tuo utilizzo.",
+    "billingUsageLimitsOverview": "Panoramica dei Limiti di Utilizzo",
+    "billingMonitorUsage": "Monitora il tuo utilizzo rispetto ai limiti configurati. Se hai bisogno di aumentare i limiti, contattaci all'indirizzo support@fossorial.io.",
+    "billingDataUsage": "Utilizzo dei Dati",
+    "billingOnlineTime": "Tempo Online del Sito",
+    "billingUsers": "Utenti Attivi",
+    "billingDomains": "Domini Attivi",
+    "billingRemoteExitNodes": "Nodi Self-hosted Attivi",
+    "billingNoLimitConfigured": "Nessun limite configurato",
+    "billingEstimatedPeriod": "Periodo di Fatturazione Stimato",
+    "billingIncludedUsage": "Utilizzo Incluso",
+    "billingIncludedUsageDescription": "Utilizzo incluso nel tuo piano di abbonamento corrente",
+    "billingFreeTierIncludedUsage": "Elenchi di utilizzi inclusi nel piano gratuito",
+    "billingIncluded": "incluso",
+    "billingEstimatedTotal": "Totale Stimato:",
+    "billingNotes": "Note",
+    "billingEstimateNote": "Questa è una stima basata sul tuo utilizzo attuale.",
+    "billingActualChargesMayVary": "I costi effettivi possono variare.",
+    "billingBilledAtEnd": "Sarai fatturato alla fine del periodo di fatturazione.",
+    "billingModifySubscription": "Modifica Abbonamento",
+    "billingStartSubscription": "Inizia Abbonamento",
+    "billingRecurringCharge": "Addebito Ricorrente",
+    "billingManageSubscriptionSettings": "Gestisci impostazioni e preferenze dell'abbonamento",
+    "billingNoActiveSubscription": "Non hai un abbonamento attivo. Avvia il tuo abbonamento per aumentare i limiti di utilizzo.",
+    "billingFailedToLoadSubscription": "Caricamento abbonamento fallito",
+    "billingFailedToLoadUsage": "Caricamento utilizzo fallito",
+    "billingFailedToGetCheckoutUrl": "Errore durante l'ottenimento dell'URL di pagamento",
+    "billingPleaseTryAgainLater": "Per favore, riprova più tardi.",
+    "billingCheckoutError": "Errore di Pagamento",
+    "billingFailedToGetPortalUrl": "Errore durante l'ottenimento dell'URL del portale",
+    "billingPortalError": "Errore del Portale",
+    "billingDataUsageInfo": "Hai addebitato tutti i dati trasferiti attraverso i tunnel sicuri quando sei connesso al cloud. Questo include sia il traffico in entrata e in uscita attraverso tutti i siti. Quando si raggiunge il limite, i siti si disconnetteranno fino a quando non si aggiorna il piano o si riduce l'utilizzo. I dati non vengono caricati quando si utilizzano nodi.",
+    "billingOnlineTimeInfo": "Ti viene addebitato in base al tempo in cui i tuoi siti rimangono connessi al cloud. Ad esempio, 44,640 minuti è uguale a un sito in esecuzione 24/7 per un mese intero. Quando raggiungi il tuo limite, i tuoi siti si disconnetteranno fino a quando non aggiorni il tuo piano o riduci l'utilizzo. Il tempo non viene caricato quando si usano i nodi.",
+    "billingUsersInfo": "Sei addebitato per ogni utente nella tua organizzazione. La fatturazione viene calcolata giornalmente in base al numero di account utente attivi nella tua organizzazione.",
+    "billingDomainInfo": "Sei addebitato per ogni dominio nella tua organizzazione. La fatturazione viene calcolata giornalmente in base al numero di account dominio attivi nella tua organizzazione.",
+    "billingRemoteExitNodesInfo": "Sei addebitato per ogni nodo gestito nella tua organizzazione. La fatturazione viene calcolata giornalmente in base al numero di nodi gestiti attivi nella tua organizzazione.",
     "domainNotFound": "Domini Non Trovati",
     "domainNotFoundDescription": "Questa risorsa è disabilitata perché il dominio non esiste più nel nostro sistema. Si prega di impostare un nuovo dominio per questa risorsa.",
     "failed": "Fallito",
@@ -1320,6 +1363,7 @@
     "createDomainDnsPropagationDescription": "Le modifiche DNS possono richiedere del tempo per propagarsi in Internet. Questo può richiedere da pochi minuti a 48 ore, a seconda del tuo provider DNS e delle impostazioni TTL.",
     "resourcePortRequired": "Numero di porta richiesto per risorse non-HTTP",
     "resourcePortNotAllowed": "Il numero di porta non deve essere impostato per risorse HTTP",
+    "billingPricingCalculatorLink": "Calcolatore di Prezzi",
     "signUpTerms": {
         "IAgreeToThe": "Accetto i",
         "termsOfService": "termini di servizio",
@@ -1327,7 +1371,7 @@
         "privacyPolicy": "informativa sulla privacy"
     },
     "siteRequired": "Il sito è richiesto.",
-    "olmTunnel": "Olm Tunnel",
+    "olmTunnel": "Tunnel Olm",
     "olmTunnelDescription": "Usa Olm per la connettività client",
     "errorCreatingClient": "Errore nella creazione del client",
     "clientDefaultsNotFound": "Impostazioni predefinite del client non trovate",
@@ -1368,6 +1412,41 @@
     "addNewTarget": "Aggiungi Nuovo Target",
     "targetsList": "Elenco dei Target",
     "targetErrorDuplicateTargetFound": "Target duplicato trovato",
+    "healthCheckHealthy": "Sano",
+    "healthCheckUnhealthy": "Non Sano",
+    "healthCheckUnknown": "Sconosciuto",
+    "healthCheck": "Controllo Salute",
+    "configureHealthCheck": "Configura Controllo Salute",
+    "configureHealthCheckDescription": "Imposta il monitoraggio della salute per {target}",
+    "enableHealthChecks": "Abilita i Controlli di Salute",
+    "enableHealthChecksDescription": "Monitorare lo stato di salute di questo obiettivo. Se necessario, è possibile monitorare un endpoint diverso da quello del bersaglio.",
+    "healthScheme": "Metodo",
+    "healthSelectScheme": "Seleziona Metodo",
+    "healthCheckPath": "Percorso",
+    "healthHostname": "IP / Host",
+    "healthPort": "Porta",
+    "healthCheckPathDescription": "Percorso per verificare lo stato di salute.",
+    "healthyIntervalSeconds": "Intervallo Sano",
+    "unhealthyIntervalSeconds": "Intervallo Non Sano",
+    "IntervalSeconds": "Intervallo Sano",
+    "timeoutSeconds": "Timeout",
+    "timeIsInSeconds": "Il tempo è in secondi",
+    "retryAttempts": "Tentativi di Riprova",
+    "expectedResponseCodes": "Codici di Risposta Attesi",
+    "expectedResponseCodesDescription": "Codice di stato HTTP che indica lo stato di salute. Se lasciato vuoto, considerato sano è compreso tra 200-300.",
+    "customHeaders": "Intestazioni Personalizzate",
+    "customHeadersDescription": "Intestazioni nuova riga separate: Intestazione-Nome: valore",
+    "headersValidationError": "Le intestazioni devono essere nel formato: Intestazione-Nome: valore.",
+    "saveHealthCheck": "Salva Controllo Salute",
+    "healthCheckSaved": "Controllo Salute Salvato",
+    "healthCheckSavedDescription": "La configurazione del controllo salute è stata salvata con successo",
+    "healthCheckError": "Errore Controllo Salute",
+    "healthCheckErrorDescription": "Si è verificato un errore durante il salvataggio della configurazione del controllo salute.",
+    "healthCheckPathRequired": "Il percorso del controllo salute è richiesto",
+    "healthCheckMethodRequired": "Metodo HTTP richiesto",
+    "healthCheckIntervalMin": "L'intervallo del controllo deve essere almeno di 5 secondi",
+    "healthCheckTimeoutMin": "Il timeout deve essere di almeno 1 secondo",
+    "healthCheckRetryMin": "I tentativi di riprova devono essere almeno 1",
     "httpMethod": "Metodo HTTP",
     "selectHttpMethod": "Seleziona metodo HTTP",
     "domainPickerSubdomainLabel": "Sottodominio",
@@ -1381,6 +1460,7 @@
     "domainPickerEnterSubdomainToSearch": "Inserisci un sottodominio per cercare e selezionare dai domini gratuiti disponibili.",
     "domainPickerFreeDomains": "Domini Gratuiti",
     "domainPickerSearchForAvailableDomains": "Cerca domini disponibili",
+    "domainPickerNotWorkSelfHosted": "Nota: I domini forniti gratuitamente non sono disponibili per le istanze self-hosted al momento.",
     "resourceDomain": "Dominio",
     "resourceEditDomain": "Modifica Dominio",
     "siteName": "Nome del Sito",
@@ -1463,6 +1543,72 @@
     "autoLoginError": "Errore di Accesso Automatico",
     "autoLoginErrorNoRedirectUrl": "Nessun URL di reindirizzamento ricevuto dal provider di identità.",
     "autoLoginErrorGeneratingUrl": "Impossibile generare l'URL di autenticazione.",
+    "remoteExitNodeManageRemoteExitNodes": "Gestisci Self-Hosted",
+    "remoteExitNodeDescription": "Gestisci i nodi per estendere la connettività di rete",
+    "remoteExitNodes": "Nodes",
+    "searchRemoteExitNodes": "Cerca nodi...",
+    "remoteExitNodeAdd": "Aggiungi Nodo",
+    "remoteExitNodeErrorDelete": "Errore nell'eliminare il nodo",
+    "remoteExitNodeQuestionRemove": "Sei sicuro di voler rimuovere il nodo {selectedNode} dall'organizzazione?",
+    "remoteExitNodeMessageRemove": "Una volta rimosso, il nodo non sarà più accessibile.",
+    "remoteExitNodeMessageConfirm": "Per confermare, digita il nome del nodo qui sotto.",
+    "remoteExitNodeConfirmDelete": "Conferma Eliminazione Nodo",
+    "remoteExitNodeDelete": "Elimina Nodo",
+    "sidebarRemoteExitNodes": "Nodes",
+    "remoteExitNodeCreate": {
+        "title": "Crea Nodo",
+        "description": "Crea un nuovo nodo per estendere la connettività di rete",
+        "viewAllButton": "Visualizza Tutti I Nodi",
+        "strategy": {
+            "title": "Strategia di Creazione",
+            "description": "Scegli questa opzione per configurare manualmente il nodo o generare nuove credenziali.",
+            "adopt": {
+                "title": "Adotta Nodo",
+                "description": "Scegli questo se hai già le credenziali per il nodo."
+            },
+            "generate": {
+                "title": "Genera Chiavi",
+                "description": "Scegli questa opzione se vuoi generare nuove chiavi per il nodo"
+            }
+        },
+        "adopt": {
+            "title": "Adotta Nodo Esistente",
+            "description": "Inserisci le credenziali del nodo esistente che vuoi adottare",
+            "nodeIdLabel": "ID Nodo",
+            "nodeIdDescription": "L'ID del nodo esistente che si desidera adottare",
+            "secretLabel": "Segreto",
+            "secretDescription": "La chiave segreta del nodo esistente",
+            "submitButton": "Adotta Nodo"
+        },
+        "generate": {
+            "title": "Credenziali Generate",
+            "description": "Usa queste credenziali generate per configurare il nodo",
+            "nodeIdTitle": "ID Nodo",
+            "secretTitle": "Segreto",
+            "saveCredentialsTitle": "Aggiungi Credenziali alla Configurazione",
+            "saveCredentialsDescription": "Aggiungi queste credenziali al tuo file di configurazione del nodo self-hosted Pangolin per completare la connessione.",
+            "submitButton": "Crea Nodo"
+        },
+        "validation": {
+            "adoptRequired": "L'ID del nodo e il segreto sono necessari quando si adotta un nodo esistente"
+        },
+        "errors": {
+            "loadDefaultsFailed": "Caricamento impostazioni predefinite fallito",
+            "defaultsNotLoaded": "Impostazioni predefinite non caricate",
+            "createFailed": "Impossibile creare il nodo"
+        },
+        "success": {
+            "created": "Nodo creato con successo"
+        }
+    },
+    "remoteExitNodeSelection": "Selezione Nodo",
+    "remoteExitNodeSelectionDescription": "Seleziona un nodo per instradare il traffico per questo sito locale",
+    "remoteExitNodeRequired": "Un nodo deve essere selezionato per i siti locali",
+    "noRemoteExitNodesAvailable": "Nessun Nodo Disponibile",
+    "noRemoteExitNodesAvailableDescription": "Non ci sono nodi disponibili per questa organizzazione. Crea un nodo prima per usare i siti locali.",
+    "exitNode": "Nodo di Uscita",
+    "country": "Paese",
+    "rulesMatchCountry": "Attualmente basato sull'IP di origine",
     "managedSelfHosted": {
         "title": "Gestito Auto-Ospitato",
         "description": "Server Pangolin self-hosted più affidabile e a bassa manutenzione con campanelli e fischietti extra",
@@ -1501,11 +1647,53 @@
     },
     "internationaldomaindetected": "Dominio Internazionale Rilevato",
     "willbestoredas": "Verrà conservato come:",
+    "roleMappingDescription": "Determinare come i ruoli sono assegnati agli utenti quando accedono quando è abilitata la fornitura automatica.",
+    "selectRole": "Seleziona un ruolo",
+    "roleMappingExpression": "Espressione",
+    "selectRolePlaceholder": "Scegli un ruolo",
+    "selectRoleDescription": "Seleziona un ruolo da assegnare a tutti gli utenti da questo provider di identità",
+    "roleMappingExpressionDescription": "Inserire un'espressione JMESPath per estrarre le informazioni sul ruolo dal token ID",
+    "idpTenantIdRequired": "L'ID dell'inquilino è obbligatorio",
+    "invalidValue": "Valore non valido",
+    "idpTypeLabel": "Tipo Provider Identità",
+    "roleMappingExpressionPlaceholder": "es. contiene(gruppi, 'admin') && 'Admin' <unk> <unk> 'Membro'",
+    "idpGoogleConfiguration": "Configurazione Google",
+    "idpGoogleConfigurationDescription": "Configura le tue credenziali di Google OAuth2",
+    "idpGoogleClientIdDescription": "Il Tuo Client Id Google OAuth2",
+    "idpGoogleClientSecretDescription": "Il Tuo Client Google OAuth2 Secret",
+    "idpAzureConfiguration": "Configurazione Azure Entra ID",
+    "idpAzureConfigurationDescription": "Configura le credenziali OAuth2 di Azure Entra ID",
+    "idpTenantId": "Tenant ID",
+    "idpTenantIdPlaceholder": "iltuo-inquilino-id",
+    "idpAzureTenantIdDescription": "Il tuo ID del tenant Azure (trovato nella panoramica di Azure Active Directory)",
+    "idpAzureClientIdDescription": "Il Tuo Id Client Registrazione App Azure",
+    "idpAzureClientSecretDescription": "Il Tuo Client Di Registrazione App Azure Secret",
+    "idpGoogleTitle": "Google",
+    "idpGoogleAlt": "Google",
+    "idpAzureTitle": "Azure Entra ID",
+    "idpAzureAlt": "Azure",
+    "idpGoogleConfigurationTitle": "Configurazione Google",
+    "idpAzureConfigurationTitle": "Configurazione Azure Entra ID",
+    "idpTenantIdLabel": "Tenant ID",
+    "idpAzureClientIdDescription2": "Il Tuo Id Client Registrazione App Azure",
+    "idpAzureClientSecretDescription2": "Il Tuo Client Di Registrazione App Azure Secret",
     "idpGoogleDescription": "Google OAuth2/OIDC provider",
     "idpAzureDescription": "Microsoft Azure OAuth2/OIDC provider",
-    "customHeaders": "Intestazioni Personalizzate",
-    "customHeadersDescription": "Add custom headers to be sent when proxying requests. One per line in the format Header-Name: value",
-    "headersValidationError": "Le intestazioni devono essere nel formato: Intestazione-Nome: valore.",
+    "subnet": "Sottorete",
+    "subnetDescription": "La sottorete per la configurazione di rete di questa organizzazione.",
+    "authPage": "Pagina Autenticazione",
+    "authPageDescription": "Configura la pagina di autenticazione per la tua organizzazione",
+    "authPageDomain": "Dominio Pagina Auth",
+    "noDomainSet": "Nessun dominio impostato",
+    "changeDomain": "Cambia Dominio",
+    "selectDomain": "Seleziona Dominio",
+    "restartCertificate": "Riavvia Certificato",
+    "editAuthPageDomain": "Modifica Dominio Pagina Auth",
+    "setAuthPageDomain": "Imposta Dominio Pagina Autenticazione",
+    "failedToFetchCertificate": "Recupero del certificato non riuscito",
+    "failedToRestartCertificate": "Riavvio del certificato non riuscito",
+    "addDomainToEnableCustomAuthPages": "Aggiungi un dominio per abilitare le pagine di autenticazione personalizzate per la tua organizzazione",
+    "selectDomainForOrgAuthPage": "Seleziona un dominio per la pagina di autenticazione dell'organizzazione",
     "domainPickerProvidedDomain": "Dominio Fornito",
     "domainPickerFreeProvidedDomain": "Dominio Fornito Gratuito",
     "domainPickerVerified": "Verificato",
@@ -1519,10 +1707,16 @@
     "domainPickerInvalidSubdomainCannotMakeValid": "\"{sub}\" non può essere reso valido per {domain}.",
     "domainPickerSubdomainSanitized": "Sottodominio igienizzato",
     "domainPickerSubdomainCorrected": "\"{sub}\" è stato corretto in \"{sanitized}\"",
+    "orgAuthSignInTitle": "Accedi alla tua organizzazione",
+    "orgAuthChooseIdpDescription": "Scegli il tuo provider di identità per continuare",
+    "orgAuthNoIdpConfigured": "Questa organizzazione non ha nessun provider di identità configurato. Puoi accedere con la tua identità Pangolin.",
+    "orgAuthSignInWithPangolin": "Accedi con Pangolino",
+    "subscriptionRequiredToUse": "Per utilizzare questa funzionalità è necessario un abbonamento.",
+    "idpDisabled": "I provider di identità sono disabilitati.",
+    "orgAuthPageDisabled": "La pagina di autenticazione dell'organizzazione è disabilitata.",
+    "domainRestartedDescription": "Verifica del dominio riavviata con successo",
     "resourceAddEntrypointsEditFile": "Modifica file: config/traefik/traefik_config.yml",
     "resourceExposePortsEditFile": "Modifica file: docker-compose.yml",
     "emailVerificationRequired": "Verifica via email. Effettua nuovamente il login via {dashboardUrl}/auth/login completa questo passaggio. Quindi, torna qui.",
-    "twoFactorSetupRequired": "È richiesta la configurazione di autenticazione a due fattori. Effettua nuovamente l'accesso tramite {dashboardUrl}/auth/login completa questo passaggio. Quindi, torna qui.",
-    "rewritePath": "Rewrite Path",
-    "rewritePathDescription": "Optionally rewrite the path before forwarding to the target."
+    "twoFactorSetupRequired": "È richiesta la configurazione di autenticazione a due fattori. Effettua nuovamente l'accesso tramite {dashboardUrl}/auth/login completa questo passaggio. Quindi, torna qui."
 }

messages/ko-KR.json

@@ -168,6 +168,9 @@
     "siteSelect": "사이트 선택",
     "siteSearch": "사이트 검색",
     "siteNotFound": "사이트를 찾을 수 없습니다.",
+    "selectCountry": "국가 선택하기",
+    "searchCountries": "국가 검색...",
+    "noCountryFound": "국가를 찾을 수 없습니다.",
     "siteSelectionDescription": "이 사이트는 대상에 대한 연결을 제공합니다.",
     "resourceType": "리소스 유형",
     "resourceTypeDescription": "리소스에 접근하는 방법을 결정하세요",
@@ -914,8 +917,6 @@
     "idpConnectingToFinished": "연결됨",
     "idpErrorConnectingTo": "{name}에 연결하는 데 문제가 발생했습니다. 관리자에게 문의하십시오.",
     "idpErrorNotFound": "IdP를 찾을 수 없습니다.",
-    "idpGoogleAlt": "구글",
-    "idpAzureAlt": "애저",
     "inviteInvalid": "유효하지 않은 초대",
     "inviteInvalidDescription": "초대 링크가 유효하지 않습니다.",
     "inviteErrorWrongUser": "이 초대는 이 사용자에게 해당되지 않습니다",
@@ -1257,6 +1258,48 @@
     "domainPickerSubdomain": "서브도메인: {subdomain}",
     "domainPickerNamespace": "이름 공간: {namespace}",
     "domainPickerShowMore": "더보기",
+    "regionSelectorTitle": "지역 선택",
+    "regionSelectorInfo": "지역을 선택하면 위치에 따라 더 나은 성능이 제공됩니다. 서버와 같은 지역에 있을 필요는 없습니다.",
+    "regionSelectorPlaceholder": "지역 선택",
+    "regionSelectorComingSoon": "곧 출시 예정",
+    "billingLoadingSubscription": "구독 불러오는 중...",
+    "billingFreeTier": "무료 티어",
+    "billingWarningOverLimit": "경고: 하나 이상의 사용 한도를 초과했습니다. 구독을 수정하거나 사용량을 조정하기 전까지 사이트는 연결되지 않습니다.",
+    "billingUsageLimitsOverview": "사용 한도 개요",
+    "billingMonitorUsage": "설정된 한도에 대한 사용량을 모니터링합니다. 한도를 늘려야 하는 경우 support@fossorial.io로 연락하십시오.",
+    "billingDataUsage": "데이터 사용량",
+    "billingOnlineTime": "사이트 온라인 시간",
+    "billingUsers": "활성 사용자",
+    "billingDomains": "활성 도메인",
+    "billingRemoteExitNodes": "활성 자체 호스팅 노드",
+    "billingNoLimitConfigured": "구성된 한도가 없습니다.",
+    "billingEstimatedPeriod": "예상 청구 기간",
+    "billingIncludedUsage": "포함 사용량",
+    "billingIncludedUsageDescription": "현재 구독 계획에 포함된 사용량",
+    "billingFreeTierIncludedUsage": "무료 티어 사용 허용량",
+    "billingIncluded": "포함됨",
+    "billingEstimatedTotal": "예상 총액:",
+    "billingNotes": "노트",
+    "billingEstimateNote": "현재 사용량을 기반으로 한 추정치입니다.",
+    "billingActualChargesMayVary": "실제 청구 금액은 다를 수 있습니다.",
+    "billingBilledAtEnd": "청구 기간이 끝난 후 청구됩니다.",
+    "billingModifySubscription": "구독 수정",
+    "billingStartSubscription": "구독 시작",
+    "billingRecurringCharge": "반복 요금",
+    "billingManageSubscriptionSettings": "구독 설정 및 기본 설정을 관리합니다",
+    "billingNoActiveSubscription": "활성 구독이 없습니다. 사용 한도를 늘리려면 구독을 시작하십시오.",
+    "billingFailedToLoadSubscription": "구독을 불러오는 데 실패했습니다.",
+    "billingFailedToLoadUsage": "사용량을 불러오는 데 실패했습니다.",
+    "billingFailedToGetCheckoutUrl": "체크아웃 URL을 가져오는 데 실패했습니다.",
+    "billingPleaseTryAgainLater": "나중에 다시 시도하십시오.",
+    "billingCheckoutError": "체크아웃 오류",
+    "billingFailedToGetPortalUrl": "포털 URL을 가져오는 데 실패했습니다.",
+    "billingPortalError": "포털 오류",
+    "billingDataUsageInfo": "클라우드에 연결할 때 보안 터널을 통해 전송된 모든 데이터에 대해 비용이 청구됩니다. 여기에는 모든 사이트의 들어오고 나가는 트래픽이 포함됩니다. 사용량 한도에 도달하면 플랜을 업그레이드하거나 사용량을 줄일 때까지 사이트가 연결 해제됩니다. 노드를 사용하는 경우 데이터는 요금이 청구되지 않습니다.",
+    "billingOnlineTimeInfo": "사이트가 클라우드에 연결된 시간에 따라 요금이 청구됩니다. 예를 들어, 44,640분은 사이트가 한 달 내내 24시간 작동하는 것과 같습니다. 사용량 한도에 도달하면 플랜을 업그레이드하거나 사용량을 줄일 때까지 사이트가 연결 해제됩니다. 노드를 사용할 때 시간은 요금이 청구되지 않습니다.",
+    "billingUsersInfo": "조직의 사용자마다 요금이 청구됩니다. 청구는 조직의 활성 사용자 계정 수에 따라 매일 계산됩니다.",
+    "billingDomainInfo": "조직의 도메인마다 요금이 청구됩니다. 청구는 조직의 활성 도메인 계정 수에 따라 매일 계산됩니다.",
+    "billingRemoteExitNodesInfo": "조직의 관리 노드마다 요금이 청구됩니다. 청구는 조직의 활성 관리 노드 수에 따라 매일 계산됩니다.",
     "domainNotFound": "도메인을 찾을 수 없습니다",
     "domainNotFoundDescription": "이 리소스는 도메인이 더 이상 시스템에 존재하지 않아 비활성화되었습니다. 이 리소스에 대한 새 도메인을 설정하세요.",
     "failed": "실패",
@@ -1320,6 +1363,7 @@
     "createDomainDnsPropagationDescription": "DNS 변경 사항은 인터넷 전체에 전파되는 데 시간이 걸립니다. DNS 제공자와 TTL 설정에 따라 몇 분에서 48시간까지 걸릴 수 있습니다.",
     "resourcePortRequired": "HTTP 리소스가 아닌 경우 포트 번호가 필요합니다",
     "resourcePortNotAllowed": "HTTP 리소스에 대해 포트 번호를 설정하지 마세요",
+    "billingPricingCalculatorLink": "가격 계산기",
     "signUpTerms": {
         "IAgreeToThe": "동의합니다",
         "termsOfService": "서비스 약관",
@@ -1368,6 +1412,41 @@
     "addNewTarget": "새 대상 추가",
     "targetsList": "대상 목록",
     "targetErrorDuplicateTargetFound": "중복 대상 발견",
+    "healthCheckHealthy": "정상",
+    "healthCheckUnhealthy": "비정상",
+    "healthCheckUnknown": "알 수 없음",
+    "healthCheck": "상태 확인",
+    "configureHealthCheck": "상태 확인 설정",
+    "configureHealthCheckDescription": "{target}에 대한 상태 모니터링 설정",
+    "enableHealthChecks": "상태 확인 활성화",
+    "enableHealthChecksDescription": "이 대상을 모니터링하여 건강 상태를 확인하세요. 필요에 따라 대상과 다른 엔드포인트를 모니터링할 수 있습니다.",
+    "healthScheme": "방법",
+    "healthSelectScheme": "방법 선택",
+    "healthCheckPath": "경로",
+    "healthHostname": "IP / 호스트",
+    "healthPort": "포트",
+    "healthCheckPathDescription": "상태 확인을 위한 경로입니다.",
+    "healthyIntervalSeconds": "정상 간격",
+    "unhealthyIntervalSeconds": "비정상 간격",
+    "IntervalSeconds": "정상 간격",
+    "timeoutSeconds": "시간 초과",
+    "timeIsInSeconds": "시간은 초 단위입니다",
+    "retryAttempts": "재시도 횟수",
+    "expectedResponseCodes": "예상 응답 코드",
+    "expectedResponseCodesDescription": "정상 상태를 나타내는 HTTP 상태 코드입니다. 비워 두면 200-300이 정상으로 간주됩니다.",
+    "customHeaders": "사용자 정의 헤더",
+    "customHeadersDescription": "헤더는 새 줄로 구분됨: Header-Name: value",
+    "headersValidationError": "헤더는 형식이어야 합니다: 헤더명: 값.",
+    "saveHealthCheck": "상태 확인 저장",
+    "healthCheckSaved": "상태 확인이 저장되었습니다.",
+    "healthCheckSavedDescription": "상태 확인 구성이 성공적으로 저장되었습니다",
+    "healthCheckError": "상태 확인 오류",
+    "healthCheckErrorDescription": "상태 확인 구성을 저장하는 동안 오류가 발생했습니다",
+    "healthCheckPathRequired": "상태 확인 경로는 필수입니다.",
+    "healthCheckMethodRequired": "HTTP 방법은 필수입니다.",
+    "healthCheckIntervalMin": "확인 간격은 최소 5초여야 합니다.",
+    "healthCheckTimeoutMin": "시간 초과는 최소 1초여야 합니다.",
+    "healthCheckRetryMin": "재시도 횟수는 최소 1회여야 합니다.",
     "httpMethod": "HTTP 메소드",
     "selectHttpMethod": "HTTP 메소드 선택",
     "domainPickerSubdomainLabel": "서브도메인",
@@ -1381,6 +1460,7 @@
     "domainPickerEnterSubdomainToSearch": "사용 가능한 무료 도메인에서 검색 및 선택할 서브도메인 입력.",
     "domainPickerFreeDomains": "무료 도메인",
     "domainPickerSearchForAvailableDomains": "사용 가능한 도메인 검색",
+    "domainPickerNotWorkSelfHosted": "참고: 무료 제공 도메인은 현재 자체 호스팅 인스턴스에 사용할 수 없습니다.",
     "resourceDomain": "도메인",
     "resourceEditDomain": "도메인 수정",
     "siteName": "사이트 이름",
@@ -1463,6 +1543,72 @@
     "autoLoginError": "자동 로그인 오류",
     "autoLoginErrorNoRedirectUrl": "ID 공급자로부터 리디렉션 URL을 받지 못했습니다.",
     "autoLoginErrorGeneratingUrl": "인증 URL 생성 실패.",
+    "remoteExitNodeManageRemoteExitNodes": "관리 자체 호스팅",
+    "remoteExitNodeDescription": "네트워크 연결성을 확장하기 위해 노드를 관리하세요",
+    "remoteExitNodes": "노드",
+    "searchRemoteExitNodes": "노드 검색...",
+    "remoteExitNodeAdd": "노드 추가",
+    "remoteExitNodeErrorDelete": "노드 삭제 오류",
+    "remoteExitNodeQuestionRemove": "조직에서 노드 {selectedNode}를 제거하시겠습니까?",
+    "remoteExitNodeMessageRemove": "한 번 제거되면 더 이상 노드에 접근할 수 없습니다.",
+    "remoteExitNodeMessageConfirm": "확인을 위해 아래에 노드 이름을 입력해 주세요.",
+    "remoteExitNodeConfirmDelete": "노드 삭제 확인",
+    "remoteExitNodeDelete": "노드 삭제",
+    "sidebarRemoteExitNodes": "노드",
+    "remoteExitNodeCreate": {
+        "title": "노드 생성",
+        "description": "네트워크 연결성을 확장하기 위해 새 노드를 생성하세요",
+        "viewAllButton": "모든 노드 보기",
+        "strategy": {
+            "title": "생성 전략",
+            "description": "노드를 직접 구성하거나 새 자격 증명을 생성하려면 이것을 선택하세요.",
+            "adopt": {
+                "title": "노드 채택",
+                "description": "이미 노드의 자격 증명이 있는 경우 이것을 선택하세요."
+            },
+            "generate": {
+                "title": "키 생성",
+                "description": "노드에 대한 새 키를 생성하려면 이것을 선택하세요"
+            }
+        },
+        "adopt": {
+            "title": "기존 노드 채택",
+            "description": "채택하려는 기존 노드의 자격 증명을 입력하세요",
+            "nodeIdLabel": "노드 ID",
+            "nodeIdDescription": "채택하려는 기존 노드의 ID",
+            "secretLabel": "비밀",
+            "secretDescription": "기존 노드의 비밀 키",
+            "submitButton": "노드 채택"
+        },
+        "generate": {
+            "title": "생성된 자격 증명",
+            "description": "생성된 자격 증명을 사용하여 노드를 구성하세요",
+            "nodeIdTitle": "노드 ID",
+            "secretTitle": "비밀",
+            "saveCredentialsTitle": "구성에 자격 증명 추가",
+            "saveCredentialsDescription": "연결을 완료하려면 이러한 자격 증명을 자체 호스팅 Pangolin 노드 구성 파일에 추가하십시오.",
+            "submitButton": "노드 생성"
+        },
+        "validation": {
+            "adoptRequired": "기존 노드를 채택하려면 노드 ID와 비밀 키가 필요합니다"
+        },
+        "errors": {
+            "loadDefaultsFailed": "기본값 로드 실패",
+            "defaultsNotLoaded": "기본값 로드되지 않음",
+            "createFailed": "노드 생성 실패"
+        },
+        "success": {
+            "created": "노드가 성공적으로 생성되었습니다"
+        }
+    },
+    "remoteExitNodeSelection": "노드 선택",
+    "remoteExitNodeSelectionDescription": "이 로컬 사이트에서 트래픽을 라우팅할 노드를 선택하세요",
+    "remoteExitNodeRequired": "로컬 사이트에 노드를 선택해야 합니다",
+    "noRemoteExitNodesAvailable": "사용 가능한 노드가 없습니다",
+    "noRemoteExitNodesAvailableDescription": "이 조직에 사용 가능한 노드가 없습니다. 로컬 사이트를 사용하려면 먼저 노드를 생성하세요.",
+    "exitNode": "종단 노드",
+    "country": "국가",
+    "rulesMatchCountry": "현재 소스 IP를 기반으로 합니다",
     "managedSelfHosted": {
         "title": "관리 자체 호스팅",
         "description": "더 신뢰할 수 있고 낮은 유지보수의 자체 호스팅 팡골린 서버, 추가 기능 포함",
@@ -1501,11 +1647,53 @@
     },
     "internationaldomaindetected": "국제 도메인 감지됨",
     "willbestoredas": "다음으로 저장됩니다:",
+    "roleMappingDescription": "자동 프로비저닝이 활성화되면 사용자가 로그인할 때 역할이 할당되는 방법을 결정합니다.",
+    "selectRole": "역할 선택",
+    "roleMappingExpression": "표현식",
+    "selectRolePlaceholder": "역할 선택",
+    "selectRoleDescription": "이 신원 공급자로부터 모든 사용자에게 할당할 역할을 선택하십시오.",
+    "roleMappingExpressionDescription": "ID 토큰에서 역할 정보를 추출하기 위한 JMESPath 표현식을 입력하세요.",
+    "idpTenantIdRequired": "테넌트 ID가 필요합니다",
+    "invalidValue": "잘못된 값",
+    "idpTypeLabel": "신원 공급자 유형",
+    "roleMappingExpressionPlaceholder": "예: contains(groups, 'admin') && 'Admin' || 'Member'",
+    "idpGoogleConfiguration": "Google 구성",
+    "idpGoogleConfigurationDescription": "Google OAuth2 자격 증명을 구성합니다.",
+    "idpGoogleClientIdDescription": "Google OAuth2 클라이언트 ID",
+    "idpGoogleClientSecretDescription": "Google OAuth2 클라이언트 비밀",
+    "idpAzureConfiguration": "Azure Entra ID 구성",
+    "idpAzureConfigurationDescription": "Azure Entra ID OAuth2 자격 증명을 구성합니다.",
+    "idpTenantId": "테넌트 ID",
+    "idpTenantIdPlaceholder": "your-tenant-id",
+    "idpAzureTenantIdDescription": "Azure 액티브 디렉터리 개요에서 찾은 Azure 테넌트 ID",
+    "idpAzureClientIdDescription": "Azure 앱 등록 클라이언트 ID",
+    "idpAzureClientSecretDescription": "Azure 앱 등록 클라이언트 비밀",
+    "idpGoogleTitle": "Google",
+    "idpGoogleAlt": "구글",
+    "idpAzureTitle": "Azure Entra ID",
+    "idpAzureAlt": "애저",
+    "idpGoogleConfigurationTitle": "Google 구성",
+    "idpAzureConfigurationTitle": "Azure Entra ID 구성",
+    "idpTenantIdLabel": "테넌트 ID",
+    "idpAzureClientIdDescription2": "Azure 앱 등록 클라이언트 ID",
+    "idpAzureClientSecretDescription2": "Azure 앱 등록 클라이언트 비밀",
     "idpGoogleDescription": "Google OAuth2/OIDC 공급자",
     "idpAzureDescription": "Microsoft Azure OAuth2/OIDC 공급자",
-    "customHeaders": "사용자 정의 헤더",
-    "customHeadersDescription": "Add custom headers to be sent when proxying requests. One per line in the format Header-Name: value",
-    "headersValidationError": "헤더는 형식이어야 합니다: 헤더명: 값.",
+    "subnet": "서브넷",
+    "subnetDescription": "이 조직의 네트워크 구성에 대한 서브넷입니다.",
+    "authPage": "인증 페이지",
+    "authPageDescription": "조직에 대한 인증 페이지를 구성합니다.",
+    "authPageDomain": "인증 페이지 도메인",
+    "noDomainSet": "도메인 설정 없음",
+    "changeDomain": "도메인 변경",
+    "selectDomain": "도메인 선택",
+    "restartCertificate": "인증서 재시작",
+    "editAuthPageDomain": "인증 페이지 도메인 편집",
+    "setAuthPageDomain": "인증 페이지 도메인 설정",
+    "failedToFetchCertificate": "인증서 가져오기 실패",
+    "failedToRestartCertificate": "인증서 재시작 실패",
+    "addDomainToEnableCustomAuthPages": "조직의 맞춤 인증 페이지를 활성화하려면 도메인을 추가하세요.",
+    "selectDomainForOrgAuthPage": "조직 인증 페이지에 대한 도메인을 선택하세요.",
     "domainPickerProvidedDomain": "제공된 도메인",
     "domainPickerFreeProvidedDomain": "무료 제공된 도메인",
     "domainPickerVerified": "검증됨",
@@ -1519,10 +1707,16 @@
     "domainPickerInvalidSubdomainCannotMakeValid": "\"{sub}\"을(를) {domain}에 대해 유효하게 만들 수 없습니다.",
     "domainPickerSubdomainSanitized": "하위 도메인 정리됨",
     "domainPickerSubdomainCorrected": "\"{sub}\"이(가) \"{sanitized}\"로 수정되었습니다",
+    "orgAuthSignInTitle": "조직에 로그인",
+    "orgAuthChooseIdpDescription": "계속하려면 신원 공급자를 선택하세요.",
+    "orgAuthNoIdpConfigured": "이 조직은 구성된 신원 공급자가 없습니다. 대신 Pangolin 아이덴티티로 로그인할 수 있습니다.",
+    "orgAuthSignInWithPangolin": "Pangolin으로 로그인",
+    "subscriptionRequiredToUse": "이 기능을 사용하려면 구독이 필요합니다.",
+    "idpDisabled": "신원 공급자가 비활성화되었습니다.",
+    "orgAuthPageDisabled": "조직 인증 페이지가 비활성화되었습니다.",
+    "domainRestartedDescription": "도메인 인증이 성공적으로 재시작되었습니다.",
     "resourceAddEntrypointsEditFile": "파일 편집: config/traefik/traefik_config.yml",
     "resourceExposePortsEditFile": "파일 편집: docker-compose.yml",
     "emailVerificationRequired": "이메일 인증이 필요합니다. 이 단계를 완료하려면 {dashboardUrl}/auth/login 통해 다시 로그인하십시오. 그런 다음 여기로 돌아오세요.",
-    "twoFactorSetupRequired": "이중 인증 설정이 필요합니다. 이 단계를 완료하려면 {dashboardUrl}/auth/login 통해 다시 로그인하십시오. 그런 다음 여기로 돌아오세요.",
-    "rewritePath": "Rewrite Path",
-    "rewritePathDescription": "Optionally rewrite the path before forwarding to the target."
+    "twoFactorSetupRequired": "이중 인증 설정이 필요합니다. 이 단계를 완료하려면 {dashboardUrl}/auth/login 통해 다시 로그인하십시오. 그런 다음 여기로 돌아오세요."
 }

messages/nb-NO.json

@@ -118,7 +118,7 @@
     "usageExamples": "Brukseksempler",
     "tokenId": "Token-ID",
     "requestHeades": "Request Headers",
-    "queryParameter": "Query Parameter",
+    "queryParameter": "Forespørsel Params",
     "importantNote": "Viktig merknad",
     "shareImportantDescription": "Av sikkerhetsgrunner anbefales det å bruke headere fremfor query parametere der det er mulig, da query parametere kan logges i serverlogger eller nettleserhistorikk.",
     "token": "Token",
@@ -168,6 +168,9 @@
     "siteSelect": "Velg område",
     "siteSearch": "Søk i område",
     "siteNotFound": "Ingen område funnet.",
+    "selectCountry": "Velg land",
+    "searchCountries": "Søk land...",
+    "noCountryFound": "Ingen land funnet.",
     "siteSelectionDescription": "Dette området vil gi tilkobling til mål.",
     "resourceType": "Ressurstype",
     "resourceTypeDescription": "Bestem hvordan du vil få tilgang til ressursen din",
@@ -914,8 +917,6 @@
     "idpConnectingToFinished": "Tilkoblet",
     "idpErrorConnectingTo": "Det oppstod et problem med å koble til {name}. Vennligst kontakt din administrator.",
     "idpErrorNotFound": "IdP ikke funnet",
-    "idpGoogleAlt": "Google",
-    "idpAzureAlt": "Azure",
     "inviteInvalid": "Ugyldig invitasjon",
     "inviteInvalidDescription": "Invitasjonslenken er ugyldig.",
     "inviteErrorWrongUser": "Invitasjonen er ikke for denne brukeren",
@@ -1257,6 +1258,48 @@
     "domainPickerSubdomain": "Underdomene: {subdomain}",
     "domainPickerNamespace": "Navnerom: {namespace}",
     "domainPickerShowMore": "Vis mer",
+    "regionSelectorTitle": "Velg Region",
+    "regionSelectorInfo": "Å velge en region hjelper oss med å gi bedre ytelse for din lokasjon. Du trenger ikke være i samme region som serveren.",
+    "regionSelectorPlaceholder": "Velg en region",
+    "regionSelectorComingSoon": "Kommer snart",
+    "billingLoadingSubscription": "Laster abonnement...",
+    "billingFreeTier": "Gratis nivå",
+    "billingWarningOverLimit": "Advarsel: Du har overskredet en eller flere bruksgrenser. Nettstedene dine vil ikke koble til før du endrer abonnementet ditt eller justerer bruken.",
+    "billingUsageLimitsOverview": "Oversikt over bruksgrenser",
+    "billingMonitorUsage": "Overvåk bruken din i forhold til konfigurerte grenser. Hvis du trenger økte grenser, vennligst kontakt support@fossorial.io.",
+    "billingDataUsage": "Databruk",
+    "billingOnlineTime": "Online tid for nettsteder",
+    "billingUsers": "Aktive brukere",
+    "billingDomains": "Aktive domener",
+    "billingRemoteExitNodes": "Aktive selvstyrte noder",
+    "billingNoLimitConfigured": "Ingen grense konfigurert",
+    "billingEstimatedPeriod": "Estimert faktureringsperiode",
+    "billingIncludedUsage": "Inkludert Bruk",
+    "billingIncludedUsageDescription": "Bruk inkludert i din nåværende abonnementsplan",
+    "billingFreeTierIncludedUsage": "Gratis nivå bruksgrenser",
+    "billingIncluded": "inkludert",
+    "billingEstimatedTotal": "Estimert Totalt:",
+    "billingNotes": "Notater",
+    "billingEstimateNote": "Dette er et estimat basert på din nåværende bruk.",
+    "billingActualChargesMayVary": "Faktiske kostnader kan variere.",
+    "billingBilledAtEnd": "Du vil bli fakturert ved slutten av faktureringsperioden.",
+    "billingModifySubscription": "Endre abonnement",
+    "billingStartSubscription": "Start abonnement",
+    "billingRecurringCharge": "Innkommende Avgift",
+    "billingManageSubscriptionSettings": "Administrer abonnementsinnstillinger og preferanser",
+    "billingNoActiveSubscription": "Du har ikke et aktivt abonnement. Start abonnementet ditt for å øke bruksgrensene.",
+    "billingFailedToLoadSubscription": "Klarte ikke å laste abonnement",
+    "billingFailedToLoadUsage": "Klarte ikke å laste bruksdata",
+    "billingFailedToGetCheckoutUrl": "Mislyktes å få betalingslenke",
+    "billingPleaseTryAgainLater": "Vennligst prøv igjen senere.",
+    "billingCheckoutError": "Kasserror",
+    "billingFailedToGetPortalUrl": "Mislyktes å hente portal URL",
+    "billingPortalError": "Portal Error",
+    "billingDataUsageInfo": "Du er ladet for all data som overføres gjennom dine sikre tunneler når du er koblet til skyen. Dette inkluderer både innkommende og utgående trafikk på alle dine nettsteder. Når du når grensen din, vil sidene koble fra til du oppgraderer planen eller reduserer bruken. Data belastes ikke ved bruk av EK-grupper.",
+    "billingOnlineTimeInfo": "Du er ladet på hvor lenge sidene dine forblir koblet til skyen. For eksempel tilsvarer 44,640 minutter ett nettsted som går 24/7 i en hel måned. Når du når grensen din, vil sidene koble fra til du oppgraderer planen eller reduserer bruken. Tid belastes ikke når du bruker noder.",
+    "billingUsersInfo": "Du belastes for hver bruker i organisasjonen din. Faktureringen beregnes daglig basert på antall aktive brukerkontoer i organisasjonen din.",
+    "billingDomainInfo": "Du belastes for hvert domene i organisasjonen din. Faktureringen beregnes daglig basert på antall aktive domenekontoer i organisasjonen din.",
+    "billingRemoteExitNodesInfo": "Du belastes for hver styrt node i organisasjonen din. Faktureringen beregnes daglig basert på antall aktive styrte noder i organisasjonen din.",
     "domainNotFound": "Domene ikke funnet",
     "domainNotFoundDescription": "Denne ressursen er deaktivert fordi domenet ikke lenger eksisterer i systemet vårt. Vennligst angi et nytt domene for denne ressursen.",
     "failed": "Mislyktes",
@@ -1320,6 +1363,7 @@
     "createDomainDnsPropagationDescription": "DNS-endringer kan ta litt tid å propagere over internett. Dette kan ta fra noen få minutter til 48 timer, avhengig av din DNS-leverandør og TTL-innstillinger.",
     "resourcePortRequired": "Portnummer er påkrevd for ikke-HTTP-ressurser",
     "resourcePortNotAllowed": "Portnummer skal ikke angis for HTTP-ressurser",
+    "billingPricingCalculatorLink": "Pris Kalkulator",
     "signUpTerms": {
         "IAgreeToThe": "Jeg godtar",
         "termsOfService": "brukervilkårene",
@@ -1368,6 +1412,41 @@
     "addNewTarget": "Legg til nytt mål",
     "targetsList": "Liste over mål",
     "targetErrorDuplicateTargetFound": "Duplikat av mål funnet",
+    "healthCheckHealthy": "Sunn",
+    "healthCheckUnhealthy": "Usunn",
+    "healthCheckUnknown": "Ukjent",
+    "healthCheck": "Helsekontroll",
+    "configureHealthCheck": "Konfigurer Helsekontroll",
+    "configureHealthCheckDescription": "Sett opp helsekontroll for {target}",
+    "enableHealthChecks": "Aktiver Helsekontroller",
+    "enableHealthChecksDescription": "Overvåk helsen til dette målet. Du kan overvåke et annet endepunkt enn målet hvis nødvendig.",
+    "healthScheme": "Metode",
+    "healthSelectScheme": "Velg metode",
+    "healthCheckPath": "Sti",
+    "healthHostname": "IP / Vert",
+    "healthPort": "Port",
+    "healthCheckPathDescription": "Stien for å sjekke helsestatus.",
+    "healthyIntervalSeconds": "Sunt intervall",
+    "unhealthyIntervalSeconds": "Usunt intervall",
+    "IntervalSeconds": "Sunt intervall",
+    "timeoutSeconds": "Timeout",
+    "timeIsInSeconds": "Tid er i sekunder",
+    "retryAttempts": "Forsøk på nytt",
+    "expectedResponseCodes": "Forventede svarkoder",
+    "expectedResponseCodesDescription": "HTTP-statuskode som indikerer sunn status. Hvis den blir stående tom, regnes 200-300 som sunn.",
+    "customHeaders": "Egendefinerte topptekster",
+    "customHeadersDescription": "Overskrifter som er adskilt med linje: Overskriftsnavn: verdi",
+    "headersValidationError": "Topptekst må være i formatet: header-navn: verdi.",
+    "saveHealthCheck": "Lagre Helsekontroll",
+    "healthCheckSaved": "Helsekontroll Lagret",
+    "healthCheckSavedDescription": "Helsekontrollkonfigurasjonen ble lagret",
+    "healthCheckError": "Helsekontrollfeil",
+    "healthCheckErrorDescription": "Det oppstod en feil under lagring av helsekontrollkonfigurasjonen",
+    "healthCheckPathRequired": "Helsekontrollsti er påkrevd",
+    "healthCheckMethodRequired": "HTTP-metode er påkrevd",
+    "healthCheckIntervalMin": "Sjekkeintervallet må være minst 5 sekunder",
+    "healthCheckTimeoutMin": "Timeout må være minst 1 sekund",
+    "healthCheckRetryMin": "Forsøk på nytt må være minst 1",
     "httpMethod": "HTTP-metode",
     "selectHttpMethod": "Velg HTTP-metode",
     "domainPickerSubdomainLabel": "Underdomene",
@@ -1381,6 +1460,7 @@
     "domainPickerEnterSubdomainToSearch": "Skriv inn et underdomene for å søke og velge blant tilgjengelige gratis domener.",
     "domainPickerFreeDomains": "Gratis domener",
     "domainPickerSearchForAvailableDomains": "Søk etter tilgjengelige domener",
+    "domainPickerNotWorkSelfHosted": "Merk: Gratis tilbudte domener er ikke tilgjengelig for selv-hostede instanser akkurat nå.",
     "resourceDomain": "Domene",
     "resourceEditDomain": "Rediger domene",
     "siteName": "Områdenavn",
@@ -1463,6 +1543,72 @@
     "autoLoginError": "Feil ved automatisk innlogging",
     "autoLoginErrorNoRedirectUrl": "Ingen omdirigerings-URL mottatt fra identitetsleverandøren.",
     "autoLoginErrorGeneratingUrl": "Kunne ikke generere autentiserings-URL.",
+    "remoteExitNodeManageRemoteExitNodes": "Administrer Selv-Hostet",
+    "remoteExitNodeDescription": "Administrer noder for å forlenge nettverkstilkoblingen din",
+    "remoteExitNodes": "Nodes",
+    "searchRemoteExitNodes": "Søk noder...",
+    "remoteExitNodeAdd": "Legg til Node",
+    "remoteExitNodeErrorDelete": "Feil ved sletting av node",
+    "remoteExitNodeQuestionRemove": "Er du sikker på at du vil fjerne noden {selectedNode} fra organisasjonen?",
+    "remoteExitNodeMessageRemove": "Når noden er fjernet, vil ikke lenger være tilgjengelig.",
+    "remoteExitNodeMessageConfirm": "For å bekrefte, skriv inn navnet på noden nedenfor.",
+    "remoteExitNodeConfirmDelete": "Bekreft sletting av Node",
+    "remoteExitNodeDelete": "Slett Node",
+    "sidebarRemoteExitNodes": "Nodes",
+    "remoteExitNodeCreate": {
+        "title": "Opprett node",
+        "description": "Opprett en ny node for å utvide nettverkstilkoblingen din",
+        "viewAllButton": "Vis alle koder",
+        "strategy": {
+            "title": "Opprettelsesstrategi",
+            "description": "Velg denne for manuelt å konfigurere noden eller generere nye legitimasjoner.",
+            "adopt": {
+                "title": "Adopter Node",
+                "description": "Velg dette hvis du allerede har legitimasjon til noden."
+            },
+            "generate": {
+                "title": "Generer Nøkler",
+                "description": "Velg denne hvis du vil generere nye nøkler for noden"
+            }
+        },
+        "adopt": {
+            "title": "Adopter Eksisterende Node",
+            "description": "Skriv inn opplysningene til den eksisterende noden du vil adoptere",
+            "nodeIdLabel": "Node ID",
+            "nodeIdDescription": "ID-en til den eksisterende noden du vil adoptere",
+            "secretLabel": "Sikkerhetsnøkkel",
+            "secretDescription": "Den hemmelige nøkkelen til en eksisterende node",
+            "submitButton": "Adopt Node"
+        },
+        "generate": {
+            "title": "Genererte Legitimasjoner",
+            "description": "Bruk disse genererte opplysningene for å konfigurere noden din",
+            "nodeIdTitle": "Node ID",
+            "secretTitle": "Sikkerhet",
+            "saveCredentialsTitle": "Legg til Legitimasjoner til Config",
+            "saveCredentialsDescription": "Legg til disse legitimasjonene i din selv-hostede Pangolin node-konfigurasjonsfil for å fullføre koblingen.",
+            "submitButton": "Opprett node"
+        },
+        "validation": {
+            "adoptRequired": "Node ID og Secret er påkrevd når du adopterer en eksisterende node"
+        },
+        "errors": {
+            "loadDefaultsFailed": "Feil ved lasting av standarder",
+            "defaultsNotLoaded": "Standarder ikke lastet",
+            "createFailed": "Kan ikke opprette node"
+        },
+        "success": {
+            "created": "Node opprettet"
+        }
+    },
+    "remoteExitNodeSelection": "Noden utvalg",
+    "remoteExitNodeSelectionDescription": "Velg en node for å sende trafikk gjennom for dette lokale nettstedet",
+    "remoteExitNodeRequired": "En node må velges for lokale nettsteder",
+    "noRemoteExitNodesAvailable": "Ingen noder tilgjengelig",
+    "noRemoteExitNodesAvailableDescription": "Ingen noder er tilgjengelige for denne organisasjonen. Opprett en node først for å bruke lokale nettsteder.",
+    "exitNode": "Utgangsnode",
+    "country": "Land",
+    "rulesMatchCountry": "For tiden basert på kilde IP",
     "managedSelfHosted": {
         "title": "Administrert selv-hostet",
         "description": "Sikre og lavvedlikeholdsservere, selvbetjente Pangolin med ekstra klokker, og understell",
@@ -1501,11 +1647,53 @@
     },
     "internationaldomaindetected": "Internasjonalt domene oppdaget",
     "willbestoredas": "Vil bli lagret som:",
+    "roleMappingDescription": "Bestem hvordan roller tilordnes brukere når innloggingen er aktivert når autog-rapportering er aktivert.",
+    "selectRole": "Velg en rolle",
+    "roleMappingExpression": "Uttrykk",
+    "selectRolePlaceholder": "Velg en rolle",
+    "selectRoleDescription": "Velg en rolle å tilordne alle brukere fra denne identitet leverandøren",
+    "roleMappingExpressionDescription": "Skriv inn et JMESPath uttrykk for å hente rolleinformasjon fra ID-nøkkelen",
+    "idpTenantIdRequired": "Bedriftens ID kreves",
+    "invalidValue": "Ugyldig verdi",
+    "idpTypeLabel": "Identitet leverandør type",
+    "roleMappingExpressionPlaceholder": "F.eks. inneholder(grupper, 'admin') && 'Admin' ⋅'Medlem'",
+    "idpGoogleConfiguration": "Google Konfigurasjon",
+    "idpGoogleConfigurationDescription": "Konfigurer din Google OAuth2 legitimasjon",
+    "idpGoogleClientIdDescription": "Din Google OAuth2-klient-ID",
+    "idpGoogleClientSecretDescription": "Google OAuth2-klienten din hemmelig",
+    "idpAzureConfiguration": "Azure Entra ID konfigurasjon",
+    "idpAzureConfigurationDescription": "Konfigurere din Azure Entra ID OAuth2 legitimasjon",
+    "idpTenantId": "Tenant ID",
+    "idpTenantIdPlaceholder": "din-tenant-id",
+    "idpAzureTenantIdDescription": "Din Azure leie-ID (funnet i Azure Active Directory-oversikten)",
+    "idpAzureClientIdDescription": "Din Azure App registrerings klient-ID",
+    "idpAzureClientSecretDescription": "Din Azure App registrerings klient hemmelig",
+    "idpGoogleTitle": "Google",
+    "idpGoogleAlt": "Google",
+    "idpAzureTitle": "Azure Entra ID",
+    "idpAzureAlt": "Azure",
+    "idpGoogleConfigurationTitle": "Google Konfigurasjon",
+    "idpAzureConfigurationTitle": "Azure Entra ID konfigurasjon",
+    "idpTenantIdLabel": "Tenant ID",
+    "idpAzureClientIdDescription2": "Din Azure App registrerings klient-ID",
+    "idpAzureClientSecretDescription2": "Din Azure App registrerings klient hemmelig",
     "idpGoogleDescription": "Google OAuth2/OIDC leverandør",
     "idpAzureDescription": "Microsoft Azure OAuth2/OIDC provider",
-    "customHeaders": "Egendefinerte topptekster",
-    "customHeadersDescription": "Add custom headers to be sent when proxying requests. One per line in the format Header-Name: value",
-    "headersValidationError": "Topptekst må være i formatet: header-navn: verdi.",
+    "subnet": "Subnett",
+    "subnetDescription": "Undernettverket for denne organisasjonens nettverkskonfigurasjon.",
+    "authPage": "Autentiseringsside",
+    "authPageDescription": "Konfigurer autoriseringssiden for din organisasjon",
+    "authPageDomain": "Autentiseringsside domene",
+    "noDomainSet": "Ingen domene valgt",
+    "changeDomain": "Endre domene",
+    "selectDomain": "Velg domene",
+    "restartCertificate": "Omstart sertifikat",
+    "editAuthPageDomain": "Rediger auth sidedomene",
+    "setAuthPageDomain": "Angi autoriseringsside domene",
+    "failedToFetchCertificate": "Kunne ikke hente sertifikat",
+    "failedToRestartCertificate": "Kan ikke starte sertifikat",
+    "addDomainToEnableCustomAuthPages": "Legg til et domene for å aktivere egendefinerte autentiseringssider for organisasjonen din",
+    "selectDomainForOrgAuthPage": "Velg et domene for organisasjonens autentiseringsside",
     "domainPickerProvidedDomain": "Gitt domene",
     "domainPickerFreeProvidedDomain": "Gratis oppgitt domene",
     "domainPickerVerified": "Bekreftet",
@@ -1519,10 +1707,16 @@
     "domainPickerInvalidSubdomainCannotMakeValid": "\"{sub}\" kunne ikke gjøres gyldig for {domain}.",
     "domainPickerSubdomainSanitized": "Underdomenet som ble sanivert",
     "domainPickerSubdomainCorrected": "\"{sub}\" var korrigert til \"{sanitized}\"",
+    "orgAuthSignInTitle": "Logg inn på din organisasjon",
+    "orgAuthChooseIdpDescription": "Velg din identitet leverandør for å fortsette",
+    "orgAuthNoIdpConfigured": "Denne organisasjonen har ikke noen identitetstjeneste konfigurert. Du kan i stedet logge inn med Pangolin identiteten din.",
+    "orgAuthSignInWithPangolin": "Logg inn med Pangolin",
+    "subscriptionRequiredToUse": "Et abonnement er påkrevd for å bruke denne funksjonen.",
+    "idpDisabled": "Identitetsleverandører er deaktivert.",
+    "orgAuthPageDisabled": "Informasjons-siden for organisasjon er deaktivert.",
+    "domainRestartedDescription": "Domene-verifiseringen ble startet på nytt",
     "resourceAddEntrypointsEditFile": "Rediger fil: config/traefik/traefik_config.yml",
     "resourceExposePortsEditFile": "Rediger fil: docker-compose.yml",
     "emailVerificationRequired": "E-postbekreftelse er nødvendig. Logg inn på nytt via {dashboardUrl}/auth/login og fullfør dette trinnet. Kom deretter tilbake her.",
-    "twoFactorSetupRequired": "To-faktor autentiseringsoppsett er nødvendig. Vennligst logg inn igjen via {dashboardUrl}/auth/login og fullfør dette steget. Kom deretter tilbake her.",
-    "rewritePath": "Rewrite Path",
-    "rewritePathDescription": "Optionally rewrite the path before forwarding to the target."
+    "twoFactorSetupRequired": "To-faktor autentiseringsoppsett er nødvendig. Vennligst logg inn igjen via {dashboardUrl}/auth/login og fullfør dette steget. Kom deretter tilbake her."
 }

messages/nl-NL.json

@@ -10,7 +10,7 @@
     "setupErrorIdentifier": "Organisatie-ID is al in gebruik. Kies een andere.",
     "componentsErrorNoMemberCreate": "U bent momenteel geen lid van een organisatie. Maak een organisatie aan om aan de slag te gaan.",
     "componentsErrorNoMember": "U bent momenteel geen lid van een organisatie.",
-    "welcome": "Welkom bij Pangolin!",
+    "welcome": "Welkom bij Pangolin",
     "welcomeTo": "Welkom bij",
     "componentsCreateOrg": "Maak een Organisatie",
     "componentsMember": "Je bent lid van {count, plural, =0 {geen organisatie} one {één organisatie} other {# organisaties}}.",
@@ -22,7 +22,7 @@
     "inviteErrorUser": "Het spijt ons, maar de uitnodiging die u probeert te gebruiken is niet voor deze gebruiker.",
     "inviteLoginUser": "Controleer of je bent aangemeld als de juiste gebruiker.",
     "inviteErrorNoUser": "Het spijt ons, maar de uitnodiging die u probeert te gebruiken is niet voor een bestaande gebruiker.",
-    "inviteCreateUser": "U moet eerst een account aanmaken.",
+    "inviteCreateUser": "U moet eerst een account aanmaken",
     "goHome": "Ga naar huis",
     "inviteLogInOtherUser": "Log in als een andere gebruiker",
     "createAnAccount": "Account aanmaken",
@@ -38,12 +38,12 @@
     "name": "Naam",
     "online": "Online",
     "offline": "Offline",
-    "site": "Referentie",
-    "dataIn": "Dataverbruik inkomend",
-    "dataOut": "Dataverbruik uitgaand",
+    "site": "Website",
+    "dataIn": "Gegevens in",
+    "dataOut": "Data Uit",
     "connectionType": "Type verbinding",
     "tunnelType": "Tunnel type",
-    "local": "Lokaal",
+    "local": "lokaal",
     "edit": "Bewerken",
     "siteConfirmDelete": "Verwijderen van site bevestigen",
     "siteDelete": "Site verwijderen",
@@ -55,7 +55,7 @@
     "siteCreate": "Site maken",
     "siteCreateDescription2": "Volg de onderstaande stappen om een nieuwe site aan te maken en te verbinden",
     "siteCreateDescription": "Maak een nieuwe site aan om verbinding te maken met uw bronnen",
-    "close": "Sluiten",
+    "close": "Afsluiten",
     "siteErrorCreate": "Fout bij maken site",
     "siteErrorCreateKeyPair": "Key pair of site standaard niet gevonden",
     "siteErrorCreateDefaults": "Standaardinstellingen niet gevonden",
@@ -90,21 +90,21 @@
     "siteGeneralDescription": "Algemene instellingen voor deze site configureren",
     "siteSettingDescription": "Configureer de instellingen op uw site",
     "siteSetting": "{siteName} instellingen",
-    "siteNewtTunnel": "Newttunnel (Aanbevolen)",
+    "siteNewtTunnel": "Nieuwstunnel (Aanbevolen)",
     "siteNewtTunnelDescription": "Gemakkelijkste manier om een ingangspunt in uw netwerk te maken. Geen extra opzet.",
     "siteWg": "Basis WireGuard",
     "siteWgDescription": "Gebruik een WireGuard client om een tunnel te bouwen. Handmatige NAT installatie vereist.",
     "siteWgDescriptionSaas": "Gebruik elke WireGuard-client om een tunnel op te zetten. Handmatige NAT-instelling vereist. WERKT ALLEEN OP SELF HOSTED NODES",
     "siteLocalDescription": "Alleen lokale bronnen. Geen tunneling.",
     "siteLocalDescriptionSaas": "Alleen lokale bronnen. Geen tunneling. WERKT ALLEEN OP SELF HOSTED NODES",
-    "siteSeeAll": "Alle sites bekijken",
+    "siteSeeAll": "Alle werkruimtes bekijken",
     "siteTunnelDescription": "Bepaal hoe u verbinding wilt maken met uw site",
     "siteNewtCredentials": "Nieuwste aanmeldgegevens",
     "siteNewtCredentialsDescription": "Dit is hoe Newt zich zal verifiëren met de server",
     "siteCredentialsSave": "Uw referenties opslaan",
     "siteCredentialsSaveDescription": "Je kunt dit slechts één keer zien. Kopieer het naar een beveiligde plek.",
     "siteInfo": "Site informatie",
-    "status": "Status",
+    "status": "status",
     "shareTitle": "Beheer deellinks",
     "shareDescription": "Maak deelbare links aan om tijdelijke of permanente toegang tot uw bronnen te verlenen",
     "shareSearch": "Zoek share links...",
@@ -146,19 +146,19 @@
     "never": "Nooit",
     "shareErrorSelectResource": "Selecteer een bron",
     "resourceTitle": "Bronnen beheren",
-    "resourceDescription": "Veilige proxy's voor uw privéapplicaties maken",
+    "resourceDescription": "Veilige proxy's voor uw privé applicaties maken",
     "resourcesSearch": "Zoek bronnen...",
     "resourceAdd": "Bron toevoegen",
     "resourceErrorDelte": "Fout bij verwijderen document",
     "authentication": "Authenticatie",
     "protected": "Beschermd",
-    "notProtected": "Niet beveiligd",
+    "notProtected": "Niet beschermd",
     "resourceMessageRemove": "Eenmaal verwijderd, zal het bestand niet langer toegankelijk zijn. Alle doelen die gekoppeld zijn aan het hulpbron, zullen ook verwijderd worden.",
     "resourceMessageConfirm": "Om te bevestigen, typ de naam van de bron hieronder.",
     "resourceQuestionRemove": "Weet u zeker dat u de resource {selectedResource} uit de organisatie wilt verwijderen?",
     "resourceHTTP": "HTTPS bron",
     "resourceHTTPDescription": "Proxy verzoeken aan uw app via HTTPS via een subdomein of basisdomein.",
-    "resourceRaw": "TCP/UDP bron",
+    "resourceRaw": "Ruwe TCP/UDP bron",
     "resourceRawDescription": "Proxy verzoeken naar je app via TCP/UDP met behulp van een poortnummer.",
     "resourceCreate": "Bron maken",
     "resourceCreateDescription": "Volg de onderstaande stappen om een nieuwe bron te maken",
@@ -168,6 +168,9 @@
     "siteSelect": "Selecteer site",
     "siteSearch": "Zoek site",
     "siteNotFound": "Geen site gevonden.",
+    "selectCountry": "Selecteer land",
+    "searchCountries": "Zoek landen...",
+    "noCountryFound": "Geen land gevonden.",
     "siteSelectionDescription": "Deze site zal connectiviteit met het doelwit bieden.",
     "resourceType": "Type bron",
     "resourceTypeDescription": "Bepaal hoe u toegang wilt krijgen tot uw bron",
@@ -183,7 +186,7 @@
     "protocolSelect": "Selecteer een protocol",
     "resourcePortNumber": "Nummer van poort",
     "resourcePortNumberDescription": "Het externe poortnummer naar proxyverzoeken.",
-    "cancel": "Annuleren",
+    "cancel": "annuleren",
     "resourceConfig": "Configuratie tekstbouwstenen",
     "resourceConfigDescription": "Kopieer en plak deze configuratie-snippets om je TCP/UDP-bron in te stellen",
     "resourceAddEntrypoints": "Traefik: Entrypoints toevoegen",
@@ -212,7 +215,7 @@
     "saveGeneralSettings": "Algemene instellingen opslaan",
     "saveSettings": "Instellingen opslaan",
     "orgDangerZone": "Gevaarlijke zone",
-    "orgDangerZoneDescription": "Deze instantie verwijderen is onomkeerbaar. Bevestig alstublieft dat u wilt doorgaan.",
+    "orgDangerZoneDescription": "Als u deze instantie verwijdert, is er geen weg terug. Wees het alstublieft zeker.",
     "orgDelete": "Verwijder organisatie",
     "orgDeleteConfirm": "Bevestig Verwijderen Organisatie",
     "orgMessageRemove": "Deze actie is onomkeerbaar en zal alle bijbehorende gegevens verwijderen.",
@@ -265,7 +268,7 @@
     "apiKeysGeneralSettingsDescription": "Bepaal wat deze API-sleutel kan doen",
     "apiKeysList": "Uw API-sleutel",
     "apiKeysSave": "Uw API-sleutel opslaan",
-    "apiKeysSaveDescription": "Je kunt dit slechts één keer zien. Kopieer het naar een beveiligde plek.",
+    "apiKeysSaveDescription": "Je kunt dit slechts één keer zien. Kopieer het naar een veilige plek.",
     "apiKeysInfo": "Uw API-sleutel is:",
     "apiKeysConfirmCopy": "Ik heb de API-sleutel gekopieerd",
     "generate": "Genereren",
@@ -501,7 +504,7 @@
     "targetStickySessionsDescription": "Behoud verbindingen op hetzelfde backend doel voor hun hele sessie.",
     "methodSelect": "Selecteer methode",
     "targetSubmit": "Doelwit toevoegen",
-    "targetNoOne": "Geen doel toegevoegd. Voeg deze toe via dit formulier.",
+    "targetNoOne": "Geen doelwitten. Voeg een doel toe via het formulier.",
     "targetNoOneDescription": "Het toevoegen van meer dan één doel hierboven zal de load balancering mogelijk maken.",
     "targetsSubmit": "Doelstellingen opslaan",
     "proxyAdditional": "Extra Proxy-instellingen",
@@ -572,7 +575,7 @@
     "domainsErrorFetchDescription": "Er is een fout opgetreden bij het ophalen van de domeinen",
     "none": "geen",
     "unknown": "onbekend",
-    "resources": "Bronnen",
+    "resources": "Hulpmiddelen",
     "resourcesDescription": "Bronnen zijn proxies voor applicaties die op uw privénetwerk worden uitgevoerd. Maak een bron aan voor elke HTTP/HTTPS of onbewerkte TCP/UDP-service op uw privénetwerk. Elke bron moet verbonden zijn met een site om private, beveiligde verbinding mogelijk te maken via een versleutelde WireGuard tunnel.",
     "resourcesWireGuardConnect": "Beveiligde verbinding met WireGuard versleuteling",
     "resourcesMultipleAuthenticationMethods": "Meerdere verificatiemethoden configureren",
@@ -598,7 +601,7 @@
     "newtId": "Newt-ID",
     "newtSecretKey": "Nieuwe geheime sleutel",
     "architecture": "Architectuur",
-    "sites": "Sites",
+    "sites": "Werkruimtes",
     "siteWgAnyClients": "Gebruik een willekeurige WireGuard client om verbinding te maken. Je moet je interne bronnen aanspreken met behulp van de peer IP.",
     "siteWgCompatibleAllClients": "Compatibel met alle WireGuard clients",
     "siteWgManualConfigurationRequired": "Handmatige configuratie vereist",
@@ -727,22 +730,22 @@
     "idpQuestionRemove": "Weet u zeker dat u de identiteitsprovider {name} permanent wilt verwijderen?",
     "idpMessageRemove": "Dit zal de identiteitsprovider en alle bijbehorende configuraties verwijderen. Gebruikers die via deze provider authenticeren, kunnen niet langer inloggen.",
     "idpMessageConfirm": "Om dit te bevestigen, typt u de naam van onderstaande identiteitsprovider.",
-    "idpConfirmDelete": "Bevestig verwijderen identiteit provider",
-    "idpDelete": "Identiteit provider verwijderen",
-    "idp": "Identiteitsproviders",
-    "idpSearch": "Identiteitsproviders zoeken...",
-    "idpAdd": "Identiteit provider toevoegen",
-    "idpClientIdRequired": "Client ID is vereist.",
-    "idpClientSecretRequired": "Client geheim is vereist.",
-    "idpErrorAuthUrlInvalid": "Authenticatie URL moet een geldige URL zijn.",
-    "idpErrorTokenUrlInvalid": "Token URL moet een geldige URL zijn.",
+    "idpConfirmDelete": "Bevestig verwijderen Identity Provider",
+    "idpDelete": "Identity Provider verwijderen",
+    "idp": "Identiteit aanbieders",
+    "idpSearch": "Identiteitsaanbieders zoeken...",
+    "idpAdd": "Identity Provider toevoegen",
+    "idpClientIdRequired": "Client-ID is vereist.",
+    "idpClientSecretRequired": "Clientgeheim is vereist.",
+    "idpErrorAuthUrlInvalid": "Authenticatie-URL moet een geldige URL zijn.",
+    "idpErrorTokenUrlInvalid": "Token-URL moet een geldige URL zijn.",
     "idpPathRequired": "ID-pad is vereist.",
     "idpScopeRequired": "Toepassingsgebieden zijn vereist.",
-    "idpOidcDescription": "Een OpenID Connect identiteitsprovider configureren",
-    "idpCreatedDescription": "Identiteitsprovider succesvol aangemaakt",
-    "idpCreate": "Identiteitsprovider aanmaken",
-    "idpCreateDescription": "Een nieuwe identiteitsprovider voor authenticatie configureren",
-    "idpSeeAll": "Zie alle Identiteitsproviders",
+    "idpOidcDescription": "Een OpenID Connect identity provider configureren",
+    "idpCreatedDescription": "Identity provider succesvol aangemaakt",
+    "idpCreate": "Identity Provider aanmaken",
+    "idpCreateDescription": "Een nieuwe identiteitsprovider voor gebruikersauthenticatie configureren",
+    "idpSeeAll": "Zie alle identiteitsaanbieders",
     "idpSettingsDescription": "Configureer de basisinformatie voor uw identiteitsprovider",
     "idpDisplayName": "Een weergavenaam voor deze identiteitsprovider",
     "idpAutoProvisionUsers": "Auto Provisie Gebruikers",
@@ -752,10 +755,10 @@
     "idpTypeDescription": "Selecteer het type identiteitsprovider dat u wilt configureren",
     "idpOidcConfigure": "OAuth2/OIDC configuratie",
     "idpOidcConfigureDescription": "Configureer de eindpunten van de OAuth2/OIDC provider en referenties",
-    "idpClientId": "Client ID",
-    "idpClientIdDescription": "De OAuth2 client ID van uw identiteitsprovider",
-    "idpClientSecret": "Client Secret",
-    "idpClientSecretDescription": "Het OAuth2 Client Secret van je identiteitsprovider",
+    "idpClientId": "Klant ID",
+    "idpClientIdDescription": "De OAuth2-client-ID van uw identiteitsprovider",
+    "idpClientSecret": "Clientgeheim",
+    "idpClientSecretDescription": "Het OAuth2-clientgeheim van je identiteitsprovider",
     "idpAuthUrl": "URL autorisatie",
     "idpAuthUrlDescription": "De URL voor autorisatie OAuth2",
     "idpTokenUrl": "URL token",
@@ -801,7 +804,7 @@
     "defaultMappingsOrgDescription": "Deze expressie moet de org-ID teruggeven of waar om de gebruiker toegang te geven tot de organisatie.",
     "defaultMappingsSubmit": "Standaard toewijzingen opslaan",
     "orgPoliciesEdit": "Organisatie beleid bewerken",
-    "org": "Organisatie",
+    "org": "Rekening",
     "orgSelect": "Selecteer organisatie",
     "orgSearch": "Zoek in org",
     "orgNotFound": "Geen org gevonden.",
@@ -914,8 +917,6 @@
     "idpConnectingToFinished": "Verbonden",
     "idpErrorConnectingTo": "Er was een probleem bij het verbinden met {name}. Neem contact op met uw beheerder.",
     "idpErrorNotFound": "IdP niet gevonden",
-    "idpGoogleAlt": "Google",
-    "idpAzureAlt": "Azure",
     "inviteInvalid": "Ongeldige uitnodiging",
     "inviteInvalidDescription": "Uitnodigingslink is ongeldig.",
     "inviteErrorWrongUser": "Uitnodiging is niet voor deze gebruiker",
@@ -924,7 +925,7 @@
     "inviteErrorExpired": "De uitnodiging is mogelijk verlopen",
     "inviteErrorRevoked": "De uitnodiging is mogelijk ingetrokken",
     "inviteErrorTypo": "Er kan een typefout zijn in de uitnodigingslink",
-    "pangolinSetup": "Setup - Pangolin",
+    "pangolinSetup": "Instellen - Pangolin",
     "orgNameRequired": "Organisatienaam is vereist",
     "orgIdRequired": "Organisatie-ID is vereist",
     "orgErrorCreate": "Fout opgetreden tijdens het aanmaken org",
@@ -976,10 +977,10 @@
     "supportKeyEnterDescription": "Ontmoet je eigen huisdier Pangolin!",
     "githubUsername": "GitHub-gebruikersnaam",
     "supportKeyInput": "Supporter Sleutel",
-    "supportKeyBuy": "Koop supportersleutel",
+    "supportKeyBuy": "Koop Supportersleutel",
     "logoutError": "Fout bij uitloggen",
     "signingAs": "Ingelogd als",
-    "serverAdmin": "Server beheer",
+    "serverAdmin": "Server Beheerder",
     "managedSelfhosted": "Beheerde Self-Hosted",
     "otpEnable": "Twee-factor inschakelen",
     "otpDisable": "Tweestapsverificatie uitschakelen",
@@ -994,12 +995,12 @@
     "actionGetUser": "Gebruiker ophalen",
     "actionGetOrgUser": "Krijg organisatie-gebruiker",
     "actionListOrgDomains": "Lijst organisatie domeinen",
-    "actionCreateSite": "Site maken",
+    "actionCreateSite": "Site aanmaken",
     "actionDeleteSite": "Site verwijderen",
     "actionGetSite": "Site ophalen",
     "actionListSites": "Sites weergeven",
     "actionApplyBlueprint": "Blauwdruk toepassen",
-    "setupToken": "Setup Token",
+    "setupToken": "Instel Token",
     "setupTokenDescription": "Voer het setup-token in vanaf de serverconsole.",
     "setupTokenRequired": "Setup-token is vereist",
     "actionUpdateSite": "Site bijwerken",
@@ -1128,7 +1129,7 @@
     "sidebarOverview": "Overzicht.",
     "sidebarHome": "Startpagina",
     "sidebarSites": "Werkruimtes",
-    "sidebarResources": "Bronnen",
+    "sidebarResources": "Hulpmiddelen",
     "sidebarAccessControl": "Toegangs controle",
     "sidebarUsers": "Gebruikers",
     "sidebarInvitations": "Uitnodigingen",
@@ -1255,8 +1256,50 @@
     "domainPickerOrganizationDomains": "Organisatiedomeinen",
     "domainPickerProvidedDomains": "Aangeboden domeinen",
     "domainPickerSubdomain": "Subdomein: {subdomain}",
-    "domainPickerNamespace": "Namespace: {namespace}",
+    "domainPickerNamespace": "Naamruimte: {namespace}",
     "domainPickerShowMore": "Meer weergeven",
+    "regionSelectorTitle": "Selecteer Regio",
+    "regionSelectorInfo": "Het selecteren van een regio helpt ons om betere prestaties te leveren voor uw locatie. U hoeft niet in dezelfde regio als uw server te zijn.",
+    "regionSelectorPlaceholder": "Kies een regio",
+    "regionSelectorComingSoon": "Komt binnenkort",
+    "billingLoadingSubscription": "Abonnement laden...",
+    "billingFreeTier": "Gratis Niveau",
+    "billingWarningOverLimit": "Waarschuwing: U hebt een of meer gebruikslimieten overschreden. Uw sites maken geen verbinding totdat u uw abonnement aanpast of uw gebruik aanpast.",
+    "billingUsageLimitsOverview": "Overzicht gebruikslimieten",
+    "billingMonitorUsage": "Houd uw gebruik in de gaten ten opzichte van de ingestelde limieten. Als u verhoogde limieten nodig heeft, neem dan contact met ons op support@fossorial.io.",
+    "billingDataUsage": "Gegevensgebruik",
+    "billingOnlineTime": "Site Online Tijd",
+    "billingUsers": "Actieve Gebruikers",
+    "billingDomains": "Actieve Domeinen",
+    "billingRemoteExitNodes": "Actieve Zelfgehoste Nodes",
+    "billingNoLimitConfigured": "Geen limiet ingesteld",
+    "billingEstimatedPeriod": "Geschatte Facturatie Periode",
+    "billingIncludedUsage": "Opgenomen Gebruik",
+    "billingIncludedUsageDescription": "Gebruik inbegrepen in uw huidige abonnementsplan",
+    "billingFreeTierIncludedUsage": "Gratis niveau gebruikstoelagen",
+    "billingIncluded": "inbegrepen",
+    "billingEstimatedTotal": "Geschat Totaal:",
+    "billingNotes": "Notities",
+    "billingEstimateNote": "Dit is een schatting gebaseerd op uw huidige gebruik.",
+    "billingActualChargesMayVary": "Facturering kan variëren.",
+    "billingBilledAtEnd": "U wordt aan het einde van de factureringsperiode gefactureerd.",
+    "billingModifySubscription": "Abonnementsaanpassing",
+    "billingStartSubscription": "Abonnement Starten",
+    "billingRecurringCharge": "Terugkerende Kosten",
+    "billingManageSubscriptionSettings": "Beheer uw abonnementsinstellingen en voorkeuren",
+    "billingNoActiveSubscription": "U heeft geen actief abonnement. Start uw abonnement om gebruikslimieten te verhogen.",
+    "billingFailedToLoadSubscription": "Fout bij laden van abonnement",
+    "billingFailedToLoadUsage": "Niet gelukt om gebruik te laden",
+    "billingFailedToGetCheckoutUrl": "Niet gelukt om checkout URL te krijgen",
+    "billingPleaseTryAgainLater": "Probeer het later opnieuw.",
+    "billingCheckoutError": "Checkout Fout",
+    "billingFailedToGetPortalUrl": "Niet gelukt om portal URL te krijgen",
+    "billingPortalError": "Portal Fout",
+    "billingDataUsageInfo": "U bent in rekening gebracht voor alle gegevens die via uw beveiligde tunnels via de cloud worden verzonden. Dit omvat zowel inkomende als uitgaande verkeer over al uw sites. Wanneer u uw limiet bereikt zullen uw sites de verbinding verbreken totdat u uw abonnement upgradet of het gebruik vermindert. Gegevens worden niet in rekening gebracht bij het gebruik van knooppunten.",
+    "billingOnlineTimeInfo": "U wordt in rekening gebracht op basis van hoe lang uw sites verbonden blijven met de cloud. Bijvoorbeeld 44,640 minuten is gelijk aan één site met 24/7 voor een volledige maand. Wanneer u uw limiet bereikt, zal de verbinding tussen uw sites worden verbroken totdat u een upgrade van uw abonnement uitvoert of het gebruik vermindert. Tijd wordt niet belast bij het gebruik van knooppunten.",
+    "billingUsersInfo": "U wordt gefactureerd voor elke gebruiker in uw organisatie. Facturering wordt dagelijks berekend op basis van het aantal actieve gebruikersaccounts in uw organisatie.",
+    "billingDomainInfo": "U wordt gefactureerd voor elk domein in uw organisatie. Facturering wordt dagelijks berekend op basis van het aantal actieve domeinaccounts in uw organisatie.",
+    "billingRemoteExitNodesInfo": "U wordt gefactureerd voor elke beheerde Node in uw organisatie. Facturering wordt dagelijks berekend op basis van het aantal actieve beheerde Nodes in uw organisatie.",
     "domainNotFound": "Domein niet gevonden",
     "domainNotFoundDescription": "Deze bron is uitgeschakeld omdat het domein niet langer in ons systeem bestaat. Stel een nieuw domein in voor deze bron.",
     "failed": "Mislukt",
@@ -1320,6 +1363,7 @@
     "createDomainDnsPropagationDescription": "DNS-wijzigingen kunnen enige tijd duren om over het internet te worden verspreid. Dit kan enkele minuten tot 48 uur duren, afhankelijk van je DNS-provider en TTL-instellingen.",
     "resourcePortRequired": "Poortnummer is vereist voor niet-HTTP-bronnen",
     "resourcePortNotAllowed": "Poortnummer mag niet worden ingesteld voor HTTP-bronnen",
+    "billingPricingCalculatorLink": "Prijs Calculator",
     "signUpTerms": {
         "IAgreeToThe": "Ik ga akkoord met de",
         "termsOfService": "servicevoorwaarden",
@@ -1368,6 +1412,41 @@
     "addNewTarget": "Voeg nieuw doelwit toe",
     "targetsList": "Lijst met doelen",
     "targetErrorDuplicateTargetFound": "Dubbel doelwit gevonden",
+    "healthCheckHealthy": "Gezond",
+    "healthCheckUnhealthy": "Ongezond",
+    "healthCheckUnknown": "Onbekend",
+    "healthCheck": "Gezondheidscontrole",
+    "configureHealthCheck": "Configureer Gezondheidscontrole",
+    "configureHealthCheckDescription": "Stel gezondheid monitor voor {target} in",
+    "enableHealthChecks": "Inschakelen Gezondheidscontroles",
+    "enableHealthChecksDescription": "Controleer de gezondheid van dit doel. U kunt een ander eindpunt monitoren dan het doel indien vereist.",
+    "healthScheme": "Methode",
+    "healthSelectScheme": "Selecteer methode",
+    "healthCheckPath": "Pad",
+    "healthHostname": "IP / Host",
+    "healthPort": "Poort",
+    "healthCheckPathDescription": "Het pad om de gezondheid status te controleren.",
+    "healthyIntervalSeconds": "Gezonde Interval",
+    "unhealthyIntervalSeconds": "Ongezonde Interval",
+    "IntervalSeconds": "Gezonde Interval",
+    "timeoutSeconds": "Timeout",
+    "timeIsInSeconds": "Tijd is in seconden",
+    "retryAttempts": "Herhaal Pogingen",
+    "expectedResponseCodes": "Verwachte Reactiecodes",
+    "expectedResponseCodesDescription": "HTTP-statuscode die gezonde status aangeeft. Indien leeg wordt 200-300 als gezond beschouwd.",
+    "customHeaders": "Aangepaste headers",
+    "customHeadersDescription": "Kopregeleinde: Header-Naam: waarde",
+    "headersValidationError": "Headers moeten in het formaat zijn: Header-Naam: waarde.",
+    "saveHealthCheck": "Opslaan Gezondheidscontrole",
+    "healthCheckSaved": "Gezondheidscontrole Opgeslagen",
+    "healthCheckSavedDescription": "Gezondheidscontrole configuratie succesvol opgeslagen",
+    "healthCheckError": "Gezondheidscontrole Fout",
+    "healthCheckErrorDescription": "Er is een fout opgetreden bij het opslaan van de configuratie van de gezondheidscontrole.",
+    "healthCheckPathRequired": "Gezondheidscontrole pad is vereist",
+    "healthCheckMethodRequired": "HTTP methode is vereist",
+    "healthCheckIntervalMin": "Controle interval moet minimaal 5 seconden zijn",
+    "healthCheckTimeoutMin": "Timeout moet minimaal 1 seconde zijn",
+    "healthCheckRetryMin": "Herhaal pogingen moet minimaal 1 zijn",
     "httpMethod": "HTTP-methode",
     "selectHttpMethod": "Selecteer HTTP-methode",
     "domainPickerSubdomainLabel": "Subdomein",
@@ -1381,6 +1460,7 @@
     "domainPickerEnterSubdomainToSearch": "Voer een subdomein in om te zoeken en te selecteren uit beschikbare gratis domeinen.",
     "domainPickerFreeDomains": "Gratis Domeinen",
     "domainPickerSearchForAvailableDomains": "Zoek naar beschikbare domeinen",
+    "domainPickerNotWorkSelfHosted": "Opmerking: Gratis aangeboden domeinen zijn momenteel niet beschikbaar voor zelf-gehoste instanties.",
     "resourceDomain": "Domein",
     "resourceEditDomain": "Domein bewerken",
     "siteName": "Site Naam",
@@ -1463,6 +1543,72 @@
     "autoLoginError": "Auto Login Fout",
     "autoLoginErrorNoRedirectUrl": "Geen redirect URL ontvangen van de identity provider.",
     "autoLoginErrorGeneratingUrl": "Genereren van authenticatie-URL mislukt.",
+    "remoteExitNodeManageRemoteExitNodes": "Beheer Zelf-Gehoste",
+    "remoteExitNodeDescription": "Beheer knooppunten om uw netwerkverbinding uit te breiden",
+    "remoteExitNodes": "Nodes",
+    "searchRemoteExitNodes": "Knooppunten zoeken...",
+    "remoteExitNodeAdd": "Voeg node toe",
+    "remoteExitNodeErrorDelete": "Fout bij verwijderen node",
+    "remoteExitNodeQuestionRemove": "Weet u zeker dat u het node {selectedNode} uit de organisatie wilt verwijderen?",
+    "remoteExitNodeMessageRemove": "Eenmaal verwijderd, zal het knooppunt niet langer toegankelijk zijn.",
+    "remoteExitNodeMessageConfirm": "Om te bevestigen, typ de naam van het knooppunt hieronder.",
+    "remoteExitNodeConfirmDelete": "Bevestig verwijderen node",
+    "remoteExitNodeDelete": "Knoop verwijderen",
+    "sidebarRemoteExitNodes": "Nodes",
+    "remoteExitNodeCreate": {
+        "title": "Maak node",
+        "description": "Maak een nieuwe node aan om uw netwerkverbinding uit te breiden",
+        "viewAllButton": "Alle nodes weergeven",
+        "strategy": {
+            "title": "Creatie Strategie",
+            "description": "Kies dit om uw node handmatig te configureren of nieuwe referenties te genereren.",
+            "adopt": {
+                "title": "Adopteer Node",
+                "description": "Kies dit als u al de referenties voor deze node heeft"
+            },
+            "generate": {
+                "title": "Genereer Sleutels",
+                "description": "Kies dit als u nieuwe sleutels voor het knooppunt wilt genereren"
+            }
+        },
+        "adopt": {
+            "title": "Adopteer Bestaande Node",
+            "description": "Voer de referenties in van het bestaande knooppunt dat u wilt adopteren",
+            "nodeIdLabel": "Knooppunt ID",
+            "nodeIdDescription": "De ID van het knooppunt dat u wilt adopteren",
+            "secretLabel": "Geheim",
+            "secretDescription": "De geheime sleutel van de bestaande node",
+            "submitButton": "Knooppunt adopteren"
+        },
+        "generate": {
+            "title": "Gegeneerde Inloggegevens",
+            "description": "Gebruik deze gegenereerde inloggegevens om uw node te configureren",
+            "nodeIdTitle": "Knooppunt ID",
+            "secretTitle": "Geheim",
+            "saveCredentialsTitle": "Voeg Inloggegevens toe aan Config",
+            "saveCredentialsDescription": "Voeg deze inloggegevens toe aan uw zelf-gehoste Pangolin-node configuratiebestand om de verbinding te voltooien.",
+            "submitButton": "Maak node"
+        },
+        "validation": {
+            "adoptRequired": "Node ID en Secret zijn verplicht bij het overnemen van een bestaand knooppunt"
+        },
+        "errors": {
+            "loadDefaultsFailed": "Niet gelukt om standaarden te laden",
+            "defaultsNotLoaded": "Standaarden niet geladen",
+            "createFailed": "Fout bij het maken van node"
+        },
+        "success": {
+            "created": "Node succesvol aangemaakt"
+        }
+    },
+    "remoteExitNodeSelection": "Knooppunt selectie",
+    "remoteExitNodeSelectionDescription": "Selecteer een node om het verkeer door te leiden voor deze lokale site",
+    "remoteExitNodeRequired": "Een node moet worden geselecteerd voor lokale sites",
+    "noRemoteExitNodesAvailable": "Geen knooppunten beschikbaar",
+    "noRemoteExitNodesAvailableDescription": "Er zijn geen knooppunten beschikbaar voor deze organisatie. Maak eerst een knooppunt aan om lokale sites te gebruiken.",
+    "exitNode": "Exit Node",
+    "country": "Land",
+    "rulesMatchCountry": "Momenteel gebaseerd op bron IP",
     "managedSelfHosted": {
         "title": "Beheerde Self-Hosted",
         "description": "betrouwbaardere en slecht onderhouden Pangolin server met extra klokken en klokkenluiders",
@@ -1501,11 +1647,53 @@
     },
     "internationaldomaindetected": "Internationaal Domein Gedetecteerd",
     "willbestoredas": "Zal worden opgeslagen als:",
+    "roleMappingDescription": "Bepaal hoe rollen worden toegewezen aan gebruikers wanneer ze inloggen wanneer Auto Provision is ingeschakeld.",
+    "selectRole": "Selecteer een rol",
+    "roleMappingExpression": "Expressie",
+    "selectRolePlaceholder": "Kies een rol",
+    "selectRoleDescription": "Selecteer een rol om toe te wijzen aan alle gebruikers van deze identiteitsprovider",
+    "roleMappingExpressionDescription": "Voer een JMESPath expressie in om rolinformatie van de ID-token te extraheren",
+    "idpTenantIdRequired": "Tenant ID is vereist",
+    "invalidValue": "Ongeldige waarde",
+    "idpTypeLabel": "Identiteit provider type",
+    "roleMappingExpressionPlaceholder": "bijvoorbeeld bevat (groepen, 'admin') && 'Admin' ½ 'Member'",
+    "idpGoogleConfiguration": "Google Configuratie",
+    "idpGoogleConfigurationDescription": "Configureer uw Google OAuth2-referenties",
+    "idpGoogleClientIdDescription": "Uw Google OAuth2-client-ID",
+    "idpGoogleClientSecretDescription": "Uw Google OAuth2 Clientgeheim",
+    "idpAzureConfiguration": "Azure Entra ID configuratie",
+    "idpAzureConfigurationDescription": "Configureer uw Azure Entra ID OAuth2 referenties",
+    "idpTenantId": "Tenant ID",
+    "idpTenantIdPlaceholder": "jouw-tenant-id",
+    "idpAzureTenantIdDescription": "Uw Azure tenant ID (gevonden in Azure Active Directory overzicht)",
+    "idpAzureClientIdDescription": "Uw Azure App registratie Client ID",
+    "idpAzureClientSecretDescription": "Uw Azure App registratie Client Secret",
+    "idpGoogleTitle": "Google",
+    "idpGoogleAlt": "Google",
+    "idpAzureTitle": "Azure Entra ID",
+    "idpAzureAlt": "Azure",
+    "idpGoogleConfigurationTitle": "Google Configuratie",
+    "idpAzureConfigurationTitle": "Azure Entra ID configuratie",
+    "idpTenantIdLabel": "Tenant ID",
+    "idpAzureClientIdDescription2": "Uw Azure App registratie Client ID",
+    "idpAzureClientSecretDescription2": "Uw Azure App registratie Client Secret",
     "idpGoogleDescription": "Google OAuth2/OIDC provider",
     "idpAzureDescription": "Microsoft Azure OAuth2/OIDC provider",
-    "customHeaders": "Aangepaste headers",
-    "customHeadersDescription": "Voeg aangepaste headers toe die met proxyverzoeken worden meegestuurd. Gebruik één regel per header in het formaat 'Header-naam: waarde'",
-    "headersValidationError": "Headers moeten in het formaat zijn: Header-Naam: waarde.",
+    "subnet": "Subnet",
+    "subnetDescription": "Het subnet van de netwerkconfiguratie van deze organisatie.",
+    "authPage": "Authenticatie pagina",
+    "authPageDescription": "De autorisatiepagina voor uw organisatie configureren",
+    "authPageDomain": "Authenticatie pagina domein",
+    "noDomainSet": "Geen domein ingesteld",
+    "changeDomain": "Domein wijzigen",
+    "selectDomain": "Domein selecteren",
+    "restartCertificate": "Certificaat opnieuw starten",
+    "editAuthPageDomain": "Authenticatiepagina domein bewerken",
+    "setAuthPageDomain": "Authenticatiepagina domein instellen",
+    "failedToFetchCertificate": "Certificaat ophalen mislukt",
+    "failedToRestartCertificate": "Kon certificaat niet opnieuw opstarten",
+    "addDomainToEnableCustomAuthPages": "Voeg een domein toe om aangepaste authenticatiepagina's voor uw organisatie in te schakelen",
+    "selectDomainForOrgAuthPage": "Selecteer een domein voor de authenticatiepagina van de organisatie",
     "domainPickerProvidedDomain": "Opgegeven domein",
     "domainPickerFreeProvidedDomain": "Gratis verstrekt domein",
     "domainPickerVerified": "Geverifieerd",
@@ -1519,10 +1707,16 @@
     "domainPickerInvalidSubdomainCannotMakeValid": "\"{sub}\" kon niet geldig worden gemaakt voor {domain}.",
     "domainPickerSubdomainSanitized": "Subdomein gesaniseerd",
     "domainPickerSubdomainCorrected": "\"{sub}\" was gecorrigeerd op \"{sanitized}\"",
+    "orgAuthSignInTitle": "Meld je aan bij je organisatie",
+    "orgAuthChooseIdpDescription": "Kies uw identiteitsprovider om door te gaan",
+    "orgAuthNoIdpConfigured": "Deze organisatie heeft geen identiteitsproviders geconfigureerd. Je kunt in plaats daarvan inloggen met je Pangolin-identiteit.",
+    "orgAuthSignInWithPangolin": "Log in met Pangolin",
+    "subscriptionRequiredToUse": "Een abonnement is vereist om deze functie te gebruiken.",
+    "idpDisabled": "Identiteitsaanbieders zijn uitgeschakeld.",
+    "orgAuthPageDisabled": "Pagina voor organisatie-authenticatie is uitgeschakeld.",
+    "domainRestartedDescription": "Domeinverificatie met succes opnieuw gestart",
     "resourceAddEntrypointsEditFile": "Bestand bewerken: config/traefik/traefik_config.yml",
     "resourceExposePortsEditFile": "Bestand bewerken: docker-compose.yml",
     "emailVerificationRequired": "E-mail verificatie is vereist. Log opnieuw in via {dashboardUrl}/auth/login voltooide deze stap. Kom daarna hier terug.",
-    "twoFactorSetupRequired": "Tweestapsverificatie instellen is vereist. Log opnieuw in via {dashboardUrl}/auth/login voltooide deze stap. Kom daarna hier terug.",
-    "rewritePath": "Rewrite Path",
-    "rewritePathDescription": "Optionally rewrite the path before forwarding to the target."
+    "twoFactorSetupRequired": "Tweestapsverificatie instellen is vereist. Log opnieuw in via {dashboardUrl}/auth/login voltooide deze stap. Kom daarna hier terug."
 }

messages/pl-PL.json

@@ -168,6 +168,9 @@
     "siteSelect": "Wybierz witrynę",
     "siteSearch": "Szukaj witryny",
     "siteNotFound": "Nie znaleziono witryny.",
+    "selectCountry": "Wybierz kraj",
+    "searchCountries": "Szukaj krajów...",
+    "noCountryFound": "Nie znaleziono kraju.",
     "siteSelectionDescription": "Ta strona zapewni połączenie z celem.",
     "resourceType": "Typ zasobu",
     "resourceTypeDescription": "Określ jak chcesz uzyskać dostęp do swojego zasobu",
@@ -914,8 +917,6 @@
     "idpConnectingToFinished": "Połączono",
     "idpErrorConnectingTo": "Wystąpił problem z połączeniem z {name}. Skontaktuj się z administratorem.",
     "idpErrorNotFound": "Nie znaleziono IdP",
-    "idpGoogleAlt": "Google",
-    "idpAzureAlt": "Azure",
     "inviteInvalid": "Nieprawidłowe zaproszenie",
     "inviteInvalidDescription": "Link zapraszający jest nieprawidłowy.",
     "inviteErrorWrongUser": "Zaproszenie nie jest dla tego użytkownika",
@@ -1155,7 +1156,7 @@
     "containerLabels": "Etykiety",
     "containerLabelsCount": "{count, plural, one {# etykieta} few {# etykiety} many {# etykiet} other {# etykiet}}",
     "containerLabelsTitle": "Etykiety kontenera",
-    "containerLabelEmpty": "<empty>",
+    "containerLabelEmpty": "<pusty>",
     "containerPorts": "Porty",
     "containerPortsMore": "+{count} więcej",
     "containerActions": "Akcje",
@@ -1257,6 +1258,48 @@
     "domainPickerSubdomain": "Subdomena: {subdomain}",
     "domainPickerNamespace": "Przestrzeń nazw: {namespace}",
     "domainPickerShowMore": "Pokaż więcej",
+    "regionSelectorTitle": "Wybierz region",
+    "regionSelectorInfo": "Wybór regionu pomaga nam zapewnić lepszą wydajność dla Twojej lokalizacji. Nie musisz być w tym samym regionie co Twój serwer.",
+    "regionSelectorPlaceholder": "Wybierz region",
+    "regionSelectorComingSoon": "Wkrótce dostępne",
+    "billingLoadingSubscription": "Ładowanie subskrypcji...",
+    "billingFreeTier": "Darmowy pakiet",
+    "billingWarningOverLimit": "Ostrzeżenie: Przekroczyłeś jeden lub więcej limitów użytkowania. Twoje witryny nie połączą się, dopóki nie zmienisz subskrypcji lub nie dostosujesz użytkowania.",
+    "billingUsageLimitsOverview": "Przegląd Limitów Użytkowania",
+    "billingMonitorUsage": "Monitoruj swoje wykorzystanie w porównaniu do skonfigurowanych limitów. Jeśli potrzebujesz zwiększenia limitów, skontaktuj się z nami pod adresem support@fossorial.io.",
+    "billingDataUsage": "Użycie danych",
+    "billingOnlineTime": "Czas Online Strony",
+    "billingUsers": "Aktywni użytkownicy",
+    "billingDomains": "Aktywne domeny",
+    "billingRemoteExitNodes": "Aktywne samodzielnie-hostowane węzły",
+    "billingNoLimitConfigured": "Nie skonfigurowano limitu",
+    "billingEstimatedPeriod": "Szacowany Okres Rozliczeniowy",
+    "billingIncludedUsage": "Zawarte użycie",
+    "billingIncludedUsageDescription": "Użycie zawarte w obecnym planie subskrypcji",
+    "billingFreeTierIncludedUsage": "Limity użycia dla darmowego pakietu",
+    "billingIncluded": "zawarte",
+    "billingEstimatedTotal": "Szacowana Całkowita:",
+    "billingNotes": "Notatki",
+    "billingEstimateNote": "To jest szacunkowe, oparte na Twoim obecnym użyciu.",
+    "billingActualChargesMayVary": "Rzeczywiste opłaty mogą się różnić.",
+    "billingBilledAtEnd": "Zostaniesz obciążony na koniec okresu rozliczeniowego.",
+    "billingModifySubscription": "Modyfikuj Subskrypcję",
+    "billingStartSubscription": "Rozpocznij Subskrypcję",
+    "billingRecurringCharge": "Opłata Cyklowa",
+    "billingManageSubscriptionSettings": "Zarządzaj ustawieniami i preferencjami subskrypcji",
+    "billingNoActiveSubscription": "Nie masz aktywnej subskrypcji. Rozpocznij subskrypcję, aby zwiększyć limity użytkowania.",
+    "billingFailedToLoadSubscription": "Nie udało się załadować subskrypcji",
+    "billingFailedToLoadUsage": "Nie udało się załadować użycia",
+    "billingFailedToGetCheckoutUrl": "Nie udało się uzyskać adresu URL zakupu",
+    "billingPleaseTryAgainLater": "Spróbuj ponownie później.",
+    "billingCheckoutError": "Błąd przy kasie",
+    "billingFailedToGetPortalUrl": "Nie udało się uzyskać adresu URL portalu",
+    "billingPortalError": "Błąd Portalu",
+    "billingDataUsageInfo": "Jesteś obciążony za wszystkie dane przesyłane przez bezpieczne tunele, gdy jesteś podłączony do chmury. Obejmuje to zarówno ruch przychodzący, jak i wychodzący we wszystkich Twoich witrynach. Gdy osiągniesz swój limit, twoje strony zostaną rozłączone, dopóki nie zaktualizujesz planu lub nie ograniczysz użycia. Dane nie będą naliczane przy użyciu węzłów.",
+    "billingOnlineTimeInfo": "Opłata zależy od tego, jak długo twoje strony pozostają połączone z chmurą. Na przykład 44,640 minut oznacza jedną stronę działającą 24/7 przez cały miesiąc. Kiedy osiągniesz swój limit, twoje strony zostaną rozłączone, dopóki nie zaktualizujesz planu lub nie zmniejsz jego wykorzystania. Czas nie będzie naliczany przy użyciu węzłów.",
+    "billingUsersInfo": "Jesteś obciążany za każdego użytkownika w twojej organizacji. Rozliczenia są obliczane codziennie na podstawie liczby aktywnych kont użytkowników w twojej organizacji.",
+    "billingDomainInfo": "Jesteś obciążany za każdą domenę w twojej organizacji. Rozliczenia są obliczane codziennie na podstawie liczby aktywnych kont domen w twojej organizacji.",
+    "billingRemoteExitNodesInfo": "Jesteś obciążany za każdy zarządzany węzeł w twojej organizacji. Rozliczenia są obliczane codziennie na podstawie liczby aktywnych zarządzanych węzłów w twojej organizacji.",
     "domainNotFound": "Nie znaleziono domeny",
     "domainNotFoundDescription": "Zasób jest wyłączony, ponieważ domena nie istnieje już w naszym systemie. Proszę ustawić nową domenę dla tego zasobu.",
     "failed": "Niepowodzenie",
@@ -1320,6 +1363,7 @@
     "createDomainDnsPropagationDescription": "Zmiany DNS mogą zająć trochę czasu na rozpropagowanie się w Internecie. Może to potrwać od kilku minut do 48 godzin, w zależności od dostawcy DNS i ustawień TTL.",
     "resourcePortRequired": "Numer portu jest wymagany dla zasobów non-HTTP",
     "resourcePortNotAllowed": "Numer portu nie powinien być ustawiony dla zasobów HTTP",
+    "billingPricingCalculatorLink": "Kalkulator Cen",
     "signUpTerms": {
         "IAgreeToThe": "Zgadzam się z",
         "termsOfService": "warunkami usługi",
@@ -1368,6 +1412,41 @@
     "addNewTarget": "Dodaj nowy cel",
     "targetsList": "Lista celów",
     "targetErrorDuplicateTargetFound": "Znaleziono duplikat celu",
+    "healthCheckHealthy": "Zdrowy",
+    "healthCheckUnhealthy": "Niezdrowy",
+    "healthCheckUnknown": "Nieznany",
+    "healthCheck": "Kontrola Zdrowia",
+    "configureHealthCheck": "Skonfiguruj Kontrolę Zdrowia",
+    "configureHealthCheckDescription": "Skonfiguruj monitorowanie zdrowia dla {target}",
+    "enableHealthChecks": "Włącz Kontrole Zdrowia",
+    "enableHealthChecksDescription": "Monitoruj zdrowie tego celu. Możesz monitorować inny punkt końcowy niż docelowy w razie potrzeby.",
+    "healthScheme": "Metoda",
+    "healthSelectScheme": "Wybierz metodę",
+    "healthCheckPath": "Ścieżka",
+    "healthHostname": "IP / Host",
+    "healthPort": "Port",
+    "healthCheckPathDescription": "Ścieżka do sprawdzania stanu zdrowia.",
+    "healthyIntervalSeconds": "Interwał Zdrowy",
+    "unhealthyIntervalSeconds": "Interwał Niezdrowy",
+    "IntervalSeconds": "Interwał Zdrowy",
+    "timeoutSeconds": "Limit Czasu",
+    "timeIsInSeconds": "Czas w sekundach",
+    "retryAttempts": "Próby Ponowienia",
+    "expectedResponseCodes": "Oczekiwane Kody Odpowiedzi",
+    "expectedResponseCodesDescription": "Kod statusu HTTP, który wskazuje zdrowy status. Jeśli pozostanie pusty, uznaje się 200-300 za zdrowy.",
+    "customHeaders": "Niestandardowe nagłówki",
+    "customHeadersDescription": "Nagłówki oddzielone: Nazwa nagłówka: wartość",
+    "headersValidationError": "Nagłówki muszą być w formacie: Nazwa nagłówka: wartość.",
+    "saveHealthCheck": "Zapisz Kontrolę Zdrowia",
+    "healthCheckSaved": "Kontrola Zdrowia Zapisana",
+    "healthCheckSavedDescription": "Konfiguracja kontroli zdrowia została zapisana pomyślnie",
+    "healthCheckError": "Błąd Kontroli Zdrowia",
+    "healthCheckErrorDescription": "Wystąpił błąd podczas zapisywania konfiguracji kontroli zdrowia",
+    "healthCheckPathRequired": "Ścieżka kontroli zdrowia jest wymagana",
+    "healthCheckMethodRequired": "Metoda HTTP jest wymagana",
+    "healthCheckIntervalMin": "Interwał sprawdzania musi wynosić co najmniej 5 sekund",
+    "healthCheckTimeoutMin": "Limit czasu musi wynosić co najmniej 1 sekundę",
+    "healthCheckRetryMin": "Liczba prób ponowienia musi wynosić co najmniej 1",
     "httpMethod": "Metoda HTTP",
     "selectHttpMethod": "Wybierz metodę HTTP",
     "domainPickerSubdomainLabel": "Poddomena",
@@ -1381,6 +1460,7 @@
     "domainPickerEnterSubdomainToSearch": "Wprowadź poddomenę, aby wyszukać i wybrać z dostępnych darmowych domen.",
     "domainPickerFreeDomains": "Darmowe domeny",
     "domainPickerSearchForAvailableDomains": "Szukaj dostępnych domen",
+    "domainPickerNotWorkSelfHosted": "Uwaga: Darmowe domeny nie są obecnie dostępne dla instancji samodzielnie-hostowanych.",
     "resourceDomain": "Domena",
     "resourceEditDomain": "Edytuj domenę",
     "siteName": "Nazwa strony",
@@ -1463,6 +1543,72 @@
     "autoLoginError": "Błąd automatycznego logowania",
     "autoLoginErrorNoRedirectUrl": "Nie otrzymano URL przekierowania od dostawcy tożsamości.",
     "autoLoginErrorGeneratingUrl": "Nie udało się wygenerować URL uwierzytelniania.",
+    "remoteExitNodeManageRemoteExitNodes": "Zarządzaj Samodzielnie-Hostingowane",
+    "remoteExitNodeDescription": "Zarządzaj węzłami w celu rozszerzenia połączenia z siecią",
+    "remoteExitNodes": "Nodes",
+    "searchRemoteExitNodes": "Szukaj węzłów...",
+    "remoteExitNodeAdd": "Dodaj węzeł",
+    "remoteExitNodeErrorDelete": "Błąd podczas usuwania węzła",
+    "remoteExitNodeQuestionRemove": "Czy na pewno chcesz usunąć węzeł {selectedNode} z organizacji?",
+    "remoteExitNodeMessageRemove": "Po usunięciu, węzeł nie będzie już dostępny.",
+    "remoteExitNodeMessageConfirm": "Aby potwierdzić, wpisz nazwę węzła poniżej.",
+    "remoteExitNodeConfirmDelete": "Potwierdź usunięcie węzła",
+    "remoteExitNodeDelete": "Usuń węzeł",
+    "sidebarRemoteExitNodes": "Nodes",
+    "remoteExitNodeCreate": {
+        "title": "Utwórz węzeł",
+        "description": "Utwórz nowy węzeł, aby rozszerzyć połączenie z siecią",
+        "viewAllButton": "Zobacz wszystkie węzły",
+        "strategy": {
+            "title": "Strategia Tworzenia",
+            "description": "Wybierz to, aby ręcznie skonfigurować węzeł lub wygenerować nowe poświadczenia.",
+            "adopt": {
+                "title": "Zaadoptuj Węzeł",
+                "description": "Wybierz to, jeśli masz już dane logowania dla węzła."
+            },
+            "generate": {
+                "title": "Generuj Klucze",
+                "description": "Wybierz to, jeśli chcesz wygenerować nowe klucze dla węzła"
+            }
+        },
+        "adopt": {
+            "title": "Zaadoptuj Istniejący Węzeł",
+            "description": "Wprowadź dane logowania istniejącego węzła, który chcesz przyjąć",
+            "nodeIdLabel": "ID węzła",
+            "nodeIdDescription": "ID istniejącego węzła, który chcesz przyjąć",
+            "secretLabel": "Sekret",
+            "secretDescription": "Sekretny klucz istniejącego węzła",
+            "submitButton": "Przyjmij węzeł"
+        },
+        "generate": {
+            "title": "Wygenerowane Poświadczenia",
+            "description": "Użyj tych danych logowania, aby skonfigurować węzeł",
+            "nodeIdTitle": "ID węzła",
+            "secretTitle": "Sekret",
+            "saveCredentialsTitle": "Dodaj Poświadczenia do Konfiguracji",
+            "saveCredentialsDescription": "Dodaj te poświadczenia do pliku konfiguracyjnego swojego samodzielnie-hostowanego węzła Pangolin, aby zakończyć połączenie.",
+            "submitButton": "Utwórz węzeł"
+        },
+        "validation": {
+            "adoptRequired": "Identyfikator węzła i sekret są wymagane podczas przyjmowania istniejącego węzła"
+        },
+        "errors": {
+            "loadDefaultsFailed": "Nie udało się załadować domyślnych ustawień",
+            "defaultsNotLoaded": "Domyślne ustawienia nie zostały załadowane",
+            "createFailed": "Nie udało się utworzyć węzła"
+        },
+        "success": {
+            "created": "Węzeł utworzony pomyślnie"
+        }
+    },
+    "remoteExitNodeSelection": "Wybór węzła",
+    "remoteExitNodeSelectionDescription": "Wybierz węzeł do przekierowania ruchu dla tej lokalnej witryny",
+    "remoteExitNodeRequired": "Węzeł musi być wybrany dla lokalnych witryn",
+    "noRemoteExitNodesAvailable": "Brak dostępnych węzłów",
+    "noRemoteExitNodesAvailableDescription": "Węzły nie są dostępne dla tej organizacji. Utwórz węzeł, aby używać lokalnych witryn.",
+    "exitNode": "Węzeł Wyjściowy",
+    "country": "Kraj",
+    "rulesMatchCountry": "Obecnie bazuje na adresie IP źródła",
     "managedSelfHosted": {
         "title": "Zarządzane Samodzielnie-Hostingowane",
         "description": "Większa niezawodność i niska konserwacja serwera Pangolin z dodatkowymi dzwonkami i sygnałami",
@@ -1501,11 +1647,53 @@
     },
     "internationaldomaindetected": "Wykryto międzynarodową domenę",
     "willbestoredas": "Będą przechowywane jako:",
+    "roleMappingDescription": "Określ jak role są przypisywane do użytkowników podczas logowania się, gdy automatyczne świadczenie jest włączone.",
+    "selectRole": "Wybierz rolę",
+    "roleMappingExpression": "Wyrażenie",
+    "selectRolePlaceholder": "Wybierz rolę",
+    "selectRoleDescription": "Wybierz rolę do przypisania wszystkim użytkownikom od tego dostawcy tożsamości",
+    "roleMappingExpressionDescription": "Wprowadź wyrażenie JMESŚcieżki, aby wyodrębnić informacje o roli z tokenu ID",
+    "idpTenantIdRequired": "ID lokatora jest wymagane",
+    "invalidValue": "Nieprawidłowa wartość",
+    "idpTypeLabel": "Typ dostawcy tożsamości",
+    "roleMappingExpressionPlaceholder": "np. zawiera(grupy, 'admin') && 'Admin' || 'Członek'",
+    "idpGoogleConfiguration": "Konfiguracja Google",
+    "idpGoogleConfigurationDescription": "Skonfiguruj swoje poświadczenia Google OAuth2",
+    "idpGoogleClientIdDescription": "Twój identyfikator klienta Google OAuth2",
+    "idpGoogleClientSecretDescription": "Twój klucz klienta Google OAuth2",
+    "idpAzureConfiguration": "Konfiguracja Azure Entra ID",
+    "idpAzureConfigurationDescription": "Skonfiguruj swoje dane logowania OAuth2 Azure Entra",
+    "idpTenantId": "Tenant ID",
+    "idpTenantIdPlaceholder": "twoj-lokator",
+    "idpAzureTenantIdDescription": "Twój identyfikator dzierżawcy Azure (znaleziony w Podglądzie Azure Active Directory",
+    "idpAzureClientIdDescription": "Twój identyfikator klienta rejestracji aplikacji Azure",
+    "idpAzureClientSecretDescription": "Klucz tajny Twojego klienta rejestracji aplikacji Azure",
+    "idpGoogleTitle": "Google",
+    "idpGoogleAlt": "Google",
+    "idpAzureTitle": "Azure Entra ID",
+    "idpAzureAlt": "Azure",
+    "idpGoogleConfigurationTitle": "Konfiguracja Google",
+    "idpAzureConfigurationTitle": "Konfiguracja Azure Entra ID",
+    "idpTenantIdLabel": "Tenant ID",
+    "idpAzureClientIdDescription2": "Twój identyfikator klienta rejestracji aplikacji Azure",
+    "idpAzureClientSecretDescription2": "Klucz tajny Twojego klienta rejestracji aplikacji Azure",
     "idpGoogleDescription": "Dostawca Google OAuth2/OIDC",
     "idpAzureDescription": "Microsoft Azure OAuth2/OIDC provider",
-    "customHeaders": "Niestandardowe nagłówki",
-    "customHeadersDescription": "Add custom headers to be sent when proxying requests. One per line in the format Header-Name: value",
-    "headersValidationError": "Nagłówki muszą być w formacie: Nazwa nagłówka: wartość.",
+    "subnet": "Podsieć",
+    "subnetDescription": "Podsieć dla konfiguracji sieci tej organizacji.",
+    "authPage": "Strona uwierzytelniania",
+    "authPageDescription": "Skonfiguruj stronę uwierzytelniania dla swojej organizacji",
+    "authPageDomain": "Domena strony uwierzytelniania",
+    "noDomainSet": "Nie ustawiono domeny",
+    "changeDomain": "Zmień domenę",
+    "selectDomain": "Wybierz domenę",
+    "restartCertificate": "Uruchom ponownie certyfikat",
+    "editAuthPageDomain": "Edytuj domenę strony uwierzytelniania",
+    "setAuthPageDomain": "Ustaw domenę strony uwierzytelniania",
+    "failedToFetchCertificate": "Nie udało się pobrać certyfikatu",
+    "failedToRestartCertificate": "Nie udało się ponownie uruchomić certyfikatu",
+    "addDomainToEnableCustomAuthPages": "Dodaj domenę, aby włączyć niestandardowe strony uwierzytelniania dla Twojej organizacji",
+    "selectDomainForOrgAuthPage": "Wybierz domenę dla strony uwierzytelniania organizacji",
     "domainPickerProvidedDomain": "Dostarczona domena",
     "domainPickerFreeProvidedDomain": "Darmowa oferowana domena",
     "domainPickerVerified": "Zweryfikowano",
@@ -1519,10 +1707,16 @@
     "domainPickerInvalidSubdomainCannotMakeValid": "\"{sub}\" nie może być poprawne dla {domain}.",
     "domainPickerSubdomainSanitized": "Poddomena oczyszczona",
     "domainPickerSubdomainCorrected": "\"{sub}\" został skorygowany do \"{sanitized}\"",
+    "orgAuthSignInTitle": "Zaloguj się do swojej organizacji",
+    "orgAuthChooseIdpDescription": "Wybierz swojego dostawcę tożsamości, aby kontynuować",
+    "orgAuthNoIdpConfigured": "Ta organizacja nie ma skonfigurowanych żadnych dostawców tożsamości. Zamiast tego możesz zalogować się za pomocą swojej tożsamości Pangolin.",
+    "orgAuthSignInWithPangolin": "Zaloguj się używając Pangolin",
+    "subscriptionRequiredToUse": "Do korzystania z tej funkcji wymagana jest subskrypcja.",
+    "idpDisabled": "Dostawcy tożsamości są wyłączeni",
+    "orgAuthPageDisabled": "Strona autoryzacji organizacji jest wyłączona.",
+    "domainRestartedDescription": "Weryfikacja domeny zrestartowana pomyślnie",
     "resourceAddEntrypointsEditFile": "Edytuj plik: config/traefik/traefik_config.yml",
     "resourceExposePortsEditFile": "Edytuj plik: docker-compose.yml",
     "emailVerificationRequired": "Weryfikacja adresu e-mail jest wymagana. Zaloguj się ponownie przez {dashboardUrl}/auth/login zakończył ten krok. Następnie wróć tutaj.",
-    "twoFactorSetupRequired": "Konfiguracja uwierzytelniania dwuskładnikowego jest wymagana. Zaloguj się ponownie przez {dashboardUrl}/auth/login dokończ ten krok. Następnie wróć tutaj.",
-    "rewritePath": "Rewrite Path",
-    "rewritePathDescription": "Optionally rewrite the path before forwarding to the target."
+    "twoFactorSetupRequired": "Konfiguracja uwierzytelniania dwuskładnikowego jest wymagana. Zaloguj się ponownie przez {dashboardUrl}/auth/login dokończ ten krok. Następnie wróć tutaj."
 }

messages/pt-PT.json

@@ -8,25 +8,25 @@
     "orgId": "ID da organização",
     "setupIdentifierMessage": "Este é o identificador exclusivo para sua organização. Isso é separado do nome de exibição.",
     "setupErrorIdentifier": "O ID da organização já existe. Por favor, escolha um diferente.",
-    "componentsErrorNoMemberCreate": "Você não é atualmente um membro de nenhuma organização. Crie uma organização para começar.",
-    "componentsErrorNoMember": "Você não é atualmente um membro de nenhuma organização.",
+    "componentsErrorNoMemberCreate": "Não é atualmente um membro de nenhuma organização. Crie uma organização para começar.",
+    "componentsErrorNoMember": "Não é atualmente um membro de nenhuma organização.",
     "welcome": "Bem-vindo ao Pangolin",
     "welcomeTo": "Bem-vindo ao",
     "componentsCreateOrg": "Criar uma organização",
-    "componentsMember": "Você é membro de {count, plural, =0 {nenhuma organização} one {uma organização} other {# organizações}}.",
+    "componentsMember": "É membro de {count, plural, =0 {nenhuma organização} one {uma organização} other {# organizações}}.",
     "componentsInvalidKey": "Chaves de licença inválidas ou expiradas detectadas. Siga os termos da licença para continuar usando todos os recursos.",
-    "dismiss": "Descartar",
+    "dismiss": "Rejeitar",
     "componentsLicenseViolation": "Violação de Licença: Este servidor está usando sites {usedSites} que excedem o limite licenciado de sites {maxSites} . Siga os termos da licença para continuar usando todos os recursos.",
     "componentsSupporterMessage": "Obrigado por apoiar o Pangolin como um {tier}!",
-    "inviteErrorNotValid": "Desculpe, mas parece que o convite que você está tentando acessar não foi aceito ou não é mais válido.",
-    "inviteErrorUser": "Lamentamos, mas parece que o convite que você está tentando acessar não é para este usuário.",
-    "inviteLoginUser": "Verifique se você está logado como o usuário correto.",
-    "inviteErrorNoUser": "Desculpe, mas parece que o convite que você está tentando acessar não é para um usuário que existe.",
+    "inviteErrorNotValid": "Desculpe, mas parece que o convite que está a tentar aceder não foi aceito ou não é mais válido.",
+    "inviteErrorUser": "Lamentamos, mas parece que o convite que está a tentar aceder não é para este utilizador.",
+    "inviteLoginUser": "Verifique se você está logado como o utilizador correto.",
+    "inviteErrorNoUser": "Desculpe, mas parece que o convite que está a tentar aceder não é para um utilizador que existe.",
     "inviteCreateUser": "Por favor, crie uma conta primeiro.",
-    "goHome": "Ir para casa",
-    "inviteLogInOtherUser": "Fazer login como um usuário diferente",
+    "goHome": "Voltar ao inicio",
+    "inviteLogInOtherUser": "Fazer login como um utilizador diferente",
     "createAnAccount": "Crie uma conta",
-    "inviteNotAccepted": "Convite não aceito",
+    "inviteNotAccepted": "Convite não aceite",
     "authCreateAccount": "Crie uma conta para começar",
     "authNoAccount": "Não possui uma conta?",
     "email": "e-mail",
@@ -34,23 +34,23 @@
     "confirmPassword": "Confirmar senha",
     "createAccount": "Criar conta",
     "viewSettings": "Visualizar configurações",
-    "delete": "excluir",
+    "delete": "apagar",
     "name": "Nome:",
     "online": "Disponível",
     "offline": "Desconectado",
     "site": "site",
-    "dataIn": "Dados em",
+    "dataIn": "Dados de entrada",
     "dataOut": "Dados de saída",
     "connectionType": "Tipo de conexão",
     "tunnelType": "Tipo de túnel",
     "local": "Localização",
     "edit": "Alterar",
-    "siteConfirmDelete": "Confirmar exclusão do site",
+    "siteConfirmDelete": "Confirmar que pretende apagar o site",
     "siteDelete": "Excluir site",
     "siteMessageRemove": "Uma vez removido, o site não estará mais acessível. Todos os recursos e alvos associados ao site também serão removidos.",
     "siteMessageConfirm": "Para confirmar, por favor, digite o nome do site abaixo.",
     "siteQuestionRemove": "Você tem certeza que deseja remover o site {selectedSite} da organização?",
-    "siteManageSites": "Gerenciar sites",
+    "siteManageSites": "Gerir sites",
     "siteDescription": "Permitir conectividade à sua rede através de túneis seguros",
     "siteCreate": "Criar site",
     "siteCreateDescription2": "Siga os passos abaixo para criar e conectar um novo site",
@@ -79,10 +79,10 @@
     "operatingSystem": "Sistema operacional",
     "commands": "Comandos",
     "recommended": "Recomendados",
-    "siteNewtDescription": "Para a melhor experiência do usuário, utilize Novo. Ele usa o WireGuard sob o capuz e permite que você aborde seus recursos privados através dos endereços LAN em sua rede privada do painel do Pangolin.",
+    "siteNewtDescription": "Para a melhor experiência do utilizador, utilize Novo. Ele usa o WireGuard sob o capuz e permite que você aborde seus recursos privados através dos endereços LAN em sua rede privada do painel do Pangolin.",
     "siteRunsInDocker": "Executa no Docker",
     "siteRunsInShell": "Executa na shell no macOS, Linux e Windows",
-    "siteErrorDelete": "Erro ao excluir site",
+    "siteErrorDelete": "Erro ao apagar site",
     "siteErrorUpdate": "Falha ao atualizar site",
     "siteErrorUpdateDescription": "Ocorreu um erro ao atualizar o site.",
     "siteUpdated": "Site atualizado",
@@ -105,12 +105,12 @@
     "siteCredentialsSaveDescription": "Você só será capaz de ver esta vez. Certifique-se de copiá-lo para um lugar seguro.",
     "siteInfo": "Informações do Site",
     "status": "SItuação",
-    "shareTitle": "Gerenciar links de compartilhamento",
+    "shareTitle": "Gerir links partilhados",
     "shareDescription": "Criar links compartilháveis para conceder acesso temporário ou permanente aos seus recursos",
     "shareSearch": "Pesquisar links de compartilhamento...",
     "shareCreate": "Criar Link de Compartilhamento",
-    "shareErrorDelete": "Falha ao excluir o link",
-    "shareErrorDeleteMessage": "Ocorreu um erro ao excluir o link",
+    "shareErrorDelete": "Falha ao apagar o link",
+    "shareErrorDeleteMessage": "Ocorreu um erro ao apagar o link",
     "shareDeleted": "Link excluído",
     "shareDeletedDescription": "O link foi eliminado",
     "shareTokenDescription": "Seu token de acesso pode ser passado de duas maneiras: como um parâmetro de consulta ou nos cabeçalhos da solicitação. Estes devem ser passados do cliente em todas as solicitações para acesso autenticado.",
@@ -127,13 +127,13 @@
     "shareErrorFetchResourceDescription": "Ocorreu um erro ao obter os recursos",
     "shareErrorCreate": "Falha ao criar link de compartilhamento",
     "shareErrorCreateDescription": "Ocorreu um erro ao criar o link de compartilhamento",
-    "shareCreateDescription": "Qualquer um com este link pode acessar o recurso",
+    "shareCreateDescription": "Qualquer um com este link pode aceder o recurso",
     "shareTitleOptional": "Título (opcional)",
     "expireIn": "Expira em",
     "neverExpire": "Nunca expirar",
-    "shareExpireDescription": "Tempo de expiração é quanto tempo o link será utilizável e oferecerá acesso ao recurso. Após este tempo, o link não funcionará mais, e os usuários que usaram este link perderão acesso ao recurso.",
+    "shareExpireDescription": "Tempo de expiração é quanto tempo o link será utilizável e oferecerá acesso ao recurso. Após este tempo, o link não funcionará mais, e os utilizadores que usaram este link perderão acesso ao recurso.",
     "shareSeeOnce": "Você só poderá ver este link uma vez. Certifique-se de copiá-lo.",
-    "shareAccessHint": "Qualquer um com este link pode acessar o recurso. Compartilhe com cuidado.",
+    "shareAccessHint": "Qualquer um com este link pode aceder o recurso. Compartilhe com cuidado.",
     "shareTokenUsage": "Ver Uso do Token de Acesso",
     "createLink": "Criar Link",
     "resourcesNotFound": "Nenhum recurso encontrado",
@@ -145,11 +145,11 @@
     "expires": "Expira",
     "never": "nunca",
     "shareErrorSelectResource": "Por favor, selecione um recurso",
-    "resourceTitle": "Gerenciar Recursos",
+    "resourceTitle": "Gerir Recursos",
     "resourceDescription": "Crie proxies seguros para seus aplicativos privados",
     "resourcesSearch": "Procurar recursos...",
     "resourceAdd": "Adicionar Recurso",
-    "resourceErrorDelte": "Erro ao excluir recurso",
+    "resourceErrorDelte": "Erro ao apagar recurso",
     "authentication": "Autenticação",
     "protected": "Protegido",
     "notProtected": "Não Protegido",
@@ -168,9 +168,12 @@
     "siteSelect": "Selecionar site",
     "siteSearch": "Procurar no site",
     "siteNotFound": "Nenhum site encontrado.",
+    "selectCountry": "Selecionar país",
+    "searchCountries": "Buscar países...",
+    "noCountryFound": "Nenhum país encontrado.",
     "siteSelectionDescription": "Este site fornecerá conectividade ao destino.",
     "resourceType": "Tipo de Recurso",
-    "resourceTypeDescription": "Determine como você deseja acessar seu recurso",
+    "resourceTypeDescription": "Determine como você deseja aceder seu recurso",
     "resourceHTTPSSettings": "Configurações de HTTPS",
     "resourceHTTPSSettingsDescription": "Configure como seu recurso será acessado por HTTPS",
     "domainType": "Tipo de domínio",
@@ -192,7 +195,7 @@
     "resourceBack": "Voltar aos recursos",
     "resourceGoTo": "Ir para o Recurso",
     "resourceDelete": "Excluir Recurso",
-    "resourceDeleteConfirm": "Confirmar exclusão de recurso",
+    "resourceDeleteConfirm": "Confirmar que pretende apagar o  recurso",
     "visibility": "Visibilidade",
     "enabled": "Ativado",
     "disabled": "Desabilitado",
@@ -208,14 +211,14 @@
     "passToAuth": "Passar para Autenticação",
     "orgSettingsDescription": "Configurar as configurações gerais da sua organização",
     "orgGeneralSettings": "Configurações da organização",
-    "orgGeneralSettingsDescription": "Gerencie os detalhes e a configuração da sua organização",
-    "saveGeneralSettings": "Salvar configurações gerais",
-    "saveSettings": "Salvar Configurações",
+    "orgGeneralSettingsDescription": "Gerir os detalhes e a configuração da sua organização",
+    "saveGeneralSettings": "Guardar configurações gerais",
+    "saveSettings": "Guardar Configurações",
     "orgDangerZone": "Zona de Perigo",
     "orgDangerZoneDescription": "Uma vez que você exclui esta organização, não há volta. Por favor, tenha certeza.",
     "orgDelete": "Excluir Organização",
-    "orgDeleteConfirm": "Confirmar exclusão da organização",
-    "orgMessageRemove": "Esta ação é irreversível e excluirá todos os dados associados.",
+    "orgDeleteConfirm": "Confirmar que pretende apagar a organização",
+    "orgMessageRemove": "Esta ação é irreversível e apagará todos os dados associados.",
     "orgMessageConfirm": "Para confirmar, digite o nome da organização abaixo.",
     "orgQuestionRemove": "Tem certeza que deseja remover a organização {selectedOrg}?",
     "orgUpdated": "Organização atualizada",
@@ -224,29 +227,29 @@
     "orgErrorUpdateMessage": "Ocorreu um erro ao atualizar a organização.",
     "orgErrorFetch": "Falha ao buscar organizações",
     "orgErrorFetchMessage": "Ocorreu um erro ao listar suas organizações",
-    "orgErrorDelete": "Falha ao excluir organização",
-    "orgErrorDeleteMessage": "Ocorreu um erro ao excluir a organização.",
+    "orgErrorDelete": "Falha ao apagar organização",
+    "orgErrorDeleteMessage": "Ocorreu um erro ao apagar a organização.",
     "orgDeleted": "Organização excluída",
     "orgDeletedMessage": "A organização e seus dados foram excluídos.",
     "orgMissing": "ID da Organização Ausente",
     "orgMissingMessage": "Não é possível regenerar o convite sem um ID de organização.",
-    "accessUsersManage": "Gerenciar Usuários",
-    "accessUsersDescription": "Convidar usuários e adicioná-los a funções para gerenciar o acesso à sua organização",
-    "accessUsersSearch": "Procurar usuários...",
+    "accessUsersManage": "Gerir Utilizadores",
+    "accessUsersDescription": "Convidar utilizadores e adicioná-los a funções para gerir o acesso à sua organização",
+    "accessUsersSearch": "Procurar utilizadores...",
     "accessUserCreate": "Criar Usuário",
-    "accessUserRemove": "Remover usuário",
+    "accessUserRemove": "Remover utilizador",
     "username": "Usuário:",
     "identityProvider": "Provedor de Identidade",
     "role": "Funções",
     "nameRequired": "O nome é obrigatório",
-    "accessRolesManage": "Gerenciar Funções",
-    "accessRolesDescription": "Configurar funções para gerenciar o acesso à sua organização",
+    "accessRolesManage": "Gerir Funções",
+    "accessRolesDescription": "Configurar funções para gerir o acesso à sua organização",
     "accessRolesSearch": "Pesquisar funções...",
     "accessRolesAdd": "Adicionar função",
     "accessRoleDelete": "Excluir Papel",
     "description": "Descrição:",
     "inviteTitle": "Convites Abertos",
-    "inviteDescription": "Gerencie seus convites para outros usuários",
+    "inviteDescription": "Gerir seus convites para outros utilizadores",
     "inviteSearch": "Procurar convites...",
     "minutes": "minutos",
     "hours": "horas",
@@ -264,7 +267,7 @@
     "apiKeysGeneralSettings": "Permissões",
     "apiKeysGeneralSettingsDescription": "Determine o que esta chave API pode fazer",
     "apiKeysList": "Sua Chave API",
-    "apiKeysSave": "Salvar Sua Chave API",
+    "apiKeysSave": "Guardar Sua Chave API",
     "apiKeysSaveDescription": "Você só poderá ver isto uma vez. Certifique-se de copiá-la para um local seguro.",
     "apiKeysInfo": "Sua chave API é:",
     "apiKeysConfirmCopy": "Eu copiei a chave API",
@@ -277,33 +280,33 @@
     "apiKeysPermissionsUpdatedDescription": "As permissões foram atualizadas.",
     "apiKeysPermissionsGeneralSettings": "Permissões",
     "apiKeysPermissionsGeneralSettingsDescription": "Determine o que esta chave API pode fazer",
-    "apiKeysPermissionsSave": "Salvar Permissões",
+    "apiKeysPermissionsSave": "Guardar Permissões",
     "apiKeysPermissionsTitle": "Permissões",
     "apiKeys": "Chaves API",
     "searchApiKeys": "Pesquisar chaves API...",
     "apiKeysAdd": "Gerar Chave API",
-    "apiKeysErrorDelete": "Erro ao excluir chave API",
-    "apiKeysErrorDeleteMessage": "Erro ao excluir chave API",
+    "apiKeysErrorDelete": "Erro ao apagar chave API",
+    "apiKeysErrorDeleteMessage": "Erro ao apagar chave API",
     "apiKeysQuestionRemove": "Tem certeza que deseja remover a chave API {selectedApiKey} da organização?",
     "apiKeysMessageRemove": "Uma vez removida, a chave API não poderá mais ser utilizada.",
     "apiKeysMessageConfirm": "Para confirmar, por favor digite o nome da chave API abaixo.",
     "apiKeysDeleteConfirm": "Confirmar Exclusão da Chave API",
     "apiKeysDelete": "Excluir Chave API",
-    "apiKeysManage": "Gerenciar Chaves API",
+    "apiKeysManage": "Gerir Chaves API",
     "apiKeysDescription": "As chaves API são usadas para autenticar com a API de integração",
     "apiKeysSettings": "Configurações de {apiKeyName}",
-    "userTitle": "Gerenciar Todos os Usuários",
-    "userDescription": "Visualizar e gerenciar todos os usuários no sistema",
+    "userTitle": "Gerir Todos os Utilizadores",
+    "userDescription": "Visualizar e gerir todos os utilizadores no sistema",
     "userAbount": "Sobre a Gestão de Usuário",
-    "userAbountDescription": "Esta tabela exibe todos os objetos root do usuário. Cada usuário pode pertencer a várias organizações. Remover um usuário de uma organização não exclui seu objeto de usuário raiz - ele permanecerá no sistema. Para remover completamente um usuário do sistema, você deve excluir seu objeto raiz usando a ação de excluir nesta tabela.",
-    "userServer": "Usuários do Servidor",
-    "userSearch": "Pesquisar usuários do servidor...",
-    "userErrorDelete": "Erro ao excluir usuário",
+    "userAbountDescription": "Esta tabela exibe todos os objetos root do utilizador. Cada utilizador pode pertencer a várias organizações. Remover um utilizador de uma organização não exclui seu objeto de utilizador raiz - ele permanecerá no sistema. Para remover completamente um utilizador do sistema, você deve apagar seu objeto raiz usando a ação de apagar nesta tabela.",
+    "userServer": "Utilizadores do Servidor",
+    "userSearch": "Pesquisar utilizadores do servidor...",
+    "userErrorDelete": "Erro ao apagar utilizador",
     "userDeleteConfirm": "Confirmar Exclusão do Usuário",
-    "userDeleteServer": "Excluir usuário do servidor",
-    "userMessageRemove": "O usuário será removido de todas as organizações e será completamente removido do servidor.",
-    "userMessageConfirm": "Para confirmar, por favor digite o nome do usuário abaixo.",
-    "userQuestionRemove": "Tem certeza que deseja excluir o {selectedUser} permanentemente do servidor?",
+    "userDeleteServer": "Excluir utilizador do servidor",
+    "userMessageRemove": "O utilizador será removido de todas as organizações e será completamente removido do servidor.",
+    "userMessageConfirm": "Para confirmar, por favor digite o nome do utilizador abaixo.",
+    "userQuestionRemove": "Tem certeza que deseja apagar o {selectedUser} permanentemente do servidor?",
     "licenseKey": "Chave de Licença",
     "valid": "Válido",
     "numberOfSites": "Número de sites",
@@ -314,8 +317,8 @@
     "licenseTermsAgree": "Você deve concordar com os termos da licença",
     "licenseErrorKeyLoad": "Falha ao carregar chaves de licença",
     "licenseErrorKeyLoadDescription": "Ocorreu um erro ao carregar a chave da licença.",
-    "licenseErrorKeyDelete": "Falha ao excluir chave de licença",
-    "licenseErrorKeyDeleteDescription": "Ocorreu um erro ao excluir a chave de licença.",
+    "licenseErrorKeyDelete": "Falha ao apagar chave de licença",
+    "licenseErrorKeyDeleteDescription": "Ocorreu um erro ao apagar a chave de licença.",
     "licenseKeyDeleted": "Chave da licença excluída",
     "licenseKeyDeletedDescription": "A chave da licença foi excluída.",
     "licenseErrorKeyActivate": "Falha ao ativar a chave de licença",
@@ -336,13 +339,13 @@
     "fossorialLicense": "Ver Termos e Condições de Assinatura e Licença Fossorial",
     "licenseMessageRemove": "Isto irá remover a chave da licença e todas as permissões associadas concedidas por ela.",
     "licenseMessageConfirm": "Para confirmar, por favor, digite a chave de licença abaixo.",
-    "licenseQuestionRemove": "Tem certeza que deseja excluir a chave de licença {selectedKey}?",
+    "licenseQuestionRemove": "Tem certeza que deseja apagar a chave de licença {selectedKey}?",
     "licenseKeyDelete": "Excluir Chave de Licença",
-    "licenseKeyDeleteConfirm": "Confirmar exclusão da chave de licença",
-    "licenseTitle": "Gerenciar Status da Licença",
-    "licenseTitleDescription": "Visualizar e gerenciar chaves de licença no sistema",
+    "licenseKeyDeleteConfirm": "Confirmar que pretende apagar a chave de licença",
+    "licenseTitle": "Gerir Status da Licença",
+    "licenseTitleDescription": "Visualizar e gerir chaves de licença no sistema",
     "licenseHost": "Licença do host",
-    "licenseHostDescription": "Gerenciar a chave de licença principal do host.",
+    "licenseHostDescription": "Gerir a chave de licença principal do host.",
     "licensedNot": "Não Licenciado",
     "hostId": "ID do host",
     "licenseReckeckAll": "Verifique novamente todas as chaves",
@@ -370,37 +373,37 @@
     "inviteRemoved": "Convite removido",
     "inviteRemovedDescription": "O convite para {email} foi removido.",
     "inviteQuestionRemove": "Tem certeza de que deseja remover o convite {email}?",
-    "inviteMessageRemove": "Uma vez removido, este convite não será mais válido. Você sempre pode convidar o usuário novamente mais tarde.",
+    "inviteMessageRemove": "Uma vez removido, este convite não será mais válido. Você sempre pode convidar o utilizador novamente mais tarde.",
     "inviteMessageConfirm": "Para confirmar, digite o endereço de e-mail do convite abaixo.",
     "inviteQuestionRegenerate": "Tem certeza que deseja regenerar o convite{email, plural, ='' {}, other { para #}}? Isso irá revogar o convite anterior.",
     "inviteRemoveConfirm": "Confirmar Remoção do Convite",
     "inviteRegenerated": "Convite Regenerado",
     "inviteSent": "Um novo convite foi enviado para {email}.",
-    "inviteSentEmail": "Enviar notificação por e-mail ao usuário",
+    "inviteSentEmail": "Enviar notificação por e-mail ao utilizador",
     "inviteGenerate": "Um novo convite foi gerado para {email}.",
     "inviteDuplicateError": "Convite Duplicado",
-    "inviteDuplicateErrorDescription": "Já existe um convite para este usuário.",
+    "inviteDuplicateErrorDescription": "Já existe um convite para este utilizador.",
     "inviteRateLimitError": "Limite de Taxa Excedido",
-    "inviteRateLimitErrorDescription": "Você excedeu o limite de 3 regenerações por hora. Por favor, tente novamente mais tarde.",
+    "inviteRateLimitErrorDescription": "Excedeu o limite de 3 regenerações por hora. Por favor, tente novamente mais tarde.",
     "inviteRegenerateError": "Falha ao Regenerar Convite",
     "inviteRegenerateErrorDescription": "Ocorreu um erro ao regenerar o convite.",
     "inviteValidityPeriod": "Período de Validade",
     "inviteValidityPeriodSelect": "Selecione o período de validade",
-    "inviteRegenerateMessage": "O convite foi regenerado. O usuário deve acessar o link abaixo para aceitar o convite.",
+    "inviteRegenerateMessage": "O convite foi regenerado. O utilizador deve aceder o link abaixo para aceitar o convite.",
     "inviteRegenerateButton": "Regenerar",
     "expiresAt": "Expira em",
     "accessRoleUnknown": "Função Desconhecida",
     "placeholder": "Espaço reservado",
-    "userErrorOrgRemove": "Falha ao remover usuário",
-    "userErrorOrgRemoveDescription": "Ocorreu um erro ao remover o usuário.",
+    "userErrorOrgRemove": "Falha ao remover utilizador",
+    "userErrorOrgRemoveDescription": "Ocorreu um erro ao remover o utilizador.",
     "userOrgRemoved": "Usuário removido",
-    "userOrgRemovedDescription": "O usuário {email} foi removido da organização.",
+    "userOrgRemovedDescription": "O utilizador {email} foi removido da organização.",
     "userQuestionOrgRemove": "Tem certeza que deseja remover {email} da organização?",
-    "userMessageOrgRemove": "Uma vez removido, este usuário não terá mais acesso à organização. Você sempre pode reconvidá-lo depois, mas eles precisarão aceitar o convite novamente.",
-    "userMessageOrgConfirm": "Para confirmar, digite o nome do usuário abaixo.",
+    "userMessageOrgRemove": "Uma vez removido, este utilizador não terá mais acesso à organização. Você sempre pode reconvidá-lo depois, mas eles precisarão aceitar o convite novamente.",
+    "userMessageOrgConfirm": "Para confirmar, digite o nome do utilizador abaixo.",
     "userRemoveOrgConfirm": "Confirmar Remoção do Usuário",
     "userRemoveOrg": "Remover Usuário da Organização",
-    "users": "Usuários",
+    "users": "Utilizadores",
     "accessRoleMember": "Membro",
     "accessRoleOwner": "Proprietário",
     "userConfirmed": "Confirmado",
@@ -408,7 +411,7 @@
     "emailInvalid": "Endereço de email inválido",
     "inviteValidityDuration": "Por favor, selecione uma duração",
     "accessRoleSelectPlease": "Por favor, selecione uma função",
-    "usernameRequired": "Nome de usuário é obrigatório",
+    "usernameRequired": "Nome de utilizador é obrigatório",
     "idpSelectPlease": "Por favor, selecione um provedor de identidade",
     "idpGenericOidc": "Provedor genérico OAuth2/OIDC.",
     "accessRoleErrorFetch": "Falha ao buscar funções",
@@ -416,51 +419,51 @@
     "idpErrorFetch": "Falha ao buscar provedores de identidade",
     "idpErrorFetchDescription": "Ocorreu um erro ao buscar provedores de identidade",
     "userErrorExists": "Usuário já existe",
-    "userErrorExistsDescription": "Este usuário já é membro da organização.",
-    "inviteError": "Falha ao convidar usuário",
-    "inviteErrorDescription": "Ocorreu um erro ao convidar o usuário",
+    "userErrorExistsDescription": "Este utilizador já é membro da organização.",
+    "inviteError": "Falha ao convidar utilizador",
+    "inviteErrorDescription": "Ocorreu um erro ao convidar o utilizador",
     "userInvited": "Usuário convidado",
-    "userInvitedDescription": "O usuário foi convidado com sucesso.",
-    "userErrorCreate": "Falha ao criar usuário",
-    "userErrorCreateDescription": "Ocorreu um erro ao criar o usuário",
+    "userInvitedDescription": "O utilizador foi convidado com sucesso.",
+    "userErrorCreate": "Falha ao criar utilizador",
+    "userErrorCreateDescription": "Ocorreu um erro ao criar o utilizador",
     "userCreated": "Usuário criado",
-    "userCreatedDescription": "O usuário foi criado com sucesso.",
+    "userCreatedDescription": "O utilizador foi criado com sucesso.",
     "userTypeInternal": "Usuário Interno",
-    "userTypeInternalDescription": "Convidar um usuário para se juntar à sua organização diretamente.",
+    "userTypeInternalDescription": "Convidar um utilizador para se juntar à sua organização diretamente.",
     "userTypeExternal": "Usuário Externo",
-    "userTypeExternalDescription": "Criar um usuário com um provedor de identidade externo.",
-    "accessUserCreateDescription": "Siga os passos abaixo para criar um novo usuário",
-    "userSeeAll": "Ver Todos os Usuários",
+    "userTypeExternalDescription": "Criar um utilizador com um provedor de identidade externo.",
+    "accessUserCreateDescription": "Siga os passos abaixo para criar um novo utilizador",
+    "userSeeAll": "Ver Todos os Utilizadores",
     "userTypeTitle": "Tipo de Usuário",
-    "userTypeDescription": "Determine como você deseja criar o usuário",
+    "userTypeDescription": "Determine como você deseja criar o utilizador",
     "userSettings": "Informações do Usuário",
-    "userSettingsDescription": "Insira os detalhes para o novo usuário",
-    "inviteEmailSent": "Enviar e-mail de convite para o usuário",
+    "userSettingsDescription": "Insira os detalhes para o novo utilizador",
+    "inviteEmailSent": "Enviar e-mail de convite para o utilizador",
     "inviteValid": "Válido Por",
     "selectDuration": "Selecionar duração",
     "accessRoleSelect": "Selecionar função",
-    "inviteEmailSentDescription": "Um e-mail foi enviado ao usuário com o link de acesso abaixo. Eles devem acessar o link para aceitar o convite.",
-    "inviteSentDescription": "O usuário foi convidado. Eles devem acessar o link abaixo para aceitar o convite.",
+    "inviteEmailSentDescription": "Um e-mail foi enviado ao utilizador com o link de acesso abaixo. Eles devem aceder ao link para aceitar o convite.",
+    "inviteSentDescription": "O utilizador foi convidado. Eles devem aceder ao link abaixo para aceitar o convite.",
     "inviteExpiresIn": "O convite expirará em {days, plural, one {# dia} other {# dias}}.",
     "idpTitle": "Informações Gerais",
-    "idpSelect": "Selecione o provedor de identidade para o usuário externo",
-    "idpNotConfigured": "Nenhum provedor de identidade está configurado. Configure um provedor de identidade antes de criar usuários externos.",
-    "usernameUniq": "Isto deve corresponder ao nome de usuário único que existe no provedor de identidade selecionado.",
+    "idpSelect": "Selecione o provedor de identidade para o utilizador externo",
+    "idpNotConfigured": "Nenhum provedor de identidade está configurado. Configure um provedor de identidade antes de criar utilizadores externos.",
+    "usernameUniq": "Isto deve corresponder ao nome de utilizador único que existe no provedor de identidade selecionado.",
     "emailOptional": "E-mail (Opcional)",
     "nameOptional": "Nome (Opcional)",
-    "accessControls": "Controles de Acesso",
-    "userDescription2": "Gerenciar as configurações deste usuário",
-    "accessRoleErrorAdd": "Falha ao adicionar usuário à função",
-    "accessRoleErrorAddDescription": "Ocorreu um erro ao adicionar usuário à função.",
+    "accessControls": "Controlos de Acesso",
+    "userDescription2": "Gerir as configurações deste utilizador",
+    "accessRoleErrorAdd": "Falha ao adicionar utilizador à função",
+    "accessRoleErrorAddDescription": "Ocorreu um erro ao adicionar utilizador à função.",
     "userSaved": "Usuário salvo",
-    "userSavedDescription": "O usuário foi atualizado.",
+    "userSavedDescription": "O utilizador foi atualizado.",
     "autoProvisioned": "Auto provisionado",
-    "autoProvisionedDescription": "Permitir que este usuário seja gerenciado automaticamente pelo provedor de identidade",
-    "accessControlsDescription": "Gerencie o que este usuário pode acessar e fazer na organização",
-    "accessControlsSubmit": "Salvar Controles de Acesso",
+    "autoProvisionedDescription": "Permitir que este utilizador seja gerido automaticamente pelo provedor de identidade",
+    "accessControlsDescription": "Gerir o que este utilizador pode aceder e fazer na organização",
+    "accessControlsSubmit": "Guardar Controlos de Acesso",
     "roles": "Funções",
-    "accessUsersRoles": "Gerenciar Usuários e Funções",
-    "accessUsersRolesDescription": "Convide usuários e adicione-os a funções para gerenciar o acesso à sua organização",
+    "accessUsersRoles": "Gerir Utilizadores e Funções",
+    "accessUsersRolesDescription": "Convide utilizadores e adicione-os a funções para gerir o acesso à sua organização",
     "key": "Chave",
     "createdAt": "Criado Em",
     "proxyErrorInvalidHeader": "Valor do cabeçalho Host personalizado inválido. Use o formato de nome de domínio ou salve vazio para remover o cabeçalho Host personalizado.",
@@ -494,7 +497,7 @@
     "targetTlsSettingsAdvanced": "Configurações TLS Avançadas",
     "targetTlsSni": "Nome do Servidor TLS (SNI)",
     "targetTlsSniDescription": "O Nome do Servidor TLS para usar para SNI. Deixe vazio para usar o padrão.",
-    "targetTlsSubmit": "Salvar Configurações",
+    "targetTlsSubmit": "Guardar Configurações",
     "targets": "Configuração de Alvos",
     "targetsDescription": "Configure alvos para rotear tráfego para seus serviços de backend",
     "targetStickySessions": "Ativar Sessões Persistentes",
@@ -503,12 +506,12 @@
     "targetSubmit": "Adicionar Alvo",
     "targetNoOne": "Sem alvos. Adicione um alvo usando o formulário.",
     "targetNoOneDescription": "Adicionar mais de um alvo acima habilitará o balanceamento de carga.",
-    "targetsSubmit": "Salvar Alvos",
+    "targetsSubmit": "Guardar Alvos",
     "proxyAdditional": "Configurações Adicionais de Proxy",
     "proxyAdditionalDescription": "Configure como seu recurso lida com configurações de proxy",
     "proxyCustomHeader": "Cabeçalho Host Personalizado",
     "proxyCustomHeaderDescription": "O cabeçalho host para definir ao fazer proxy de requisições. Deixe vazio para usar o padrão.",
-    "proxyAdditionalSubmit": "Salvar Configurações de Proxy",
+    "proxyAdditionalSubmit": "Guardar Configurações de Proxy",
     "subnetMaskErrorInvalid": "Máscara de subnet inválida. Deve estar entre 0 e 32.",
     "ipAddressErrorInvalidFormat": "Formato de endereço IP inválido",
     "ipAddressErrorInvalidOctet": "Octeto de endereço IP inválido",
@@ -561,7 +564,7 @@
     "ruleSubmit": "Adicionar Regra",
     "rulesNoOne": "Sem regras. Adicione uma regra usando o formulário.",
     "rulesOrder": "As regras são avaliadas por prioridade em ordem ascendente.",
-    "rulesSubmit": "Salvar Regras",
+    "rulesSubmit": "Guardar Regras",
     "resourceErrorCreate": "Erro ao criar recurso",
     "resourceErrorCreateDescription": "Ocorreu um erro ao criar o recurso",
     "resourceErrorCreateMessage": "Erro ao criar recurso:",
@@ -576,7 +579,7 @@
     "resourcesDescription": "Recursos são proxies para aplicações executando em sua rede privada. Crie um recurso para qualquer serviço HTTP/HTTPS ou TCP/UDP bruto em sua rede privada. Cada recurso deve estar conectado a um site para habilitar conectividade privada e segura através de um túnel WireGuard criptografado.",
     "resourcesWireGuardConnect": "Conectividade segura com criptografia WireGuard",
     "resourcesMultipleAuthenticationMethods": "Configure múltiplos métodos de autenticação",
-    "resourcesUsersRolesAccess": "Controle de acesso baseado em usuários e funções",
+    "resourcesUsersRolesAccess": "Controle de acesso baseado em utilizadores e funções",
     "resourcesErrorUpdate": "Falha ao alternar recurso",
     "resourcesErrorUpdateDescription": "Ocorreu um erro ao atualizar o recurso",
     "access": "Acesso",
@@ -606,7 +609,7 @@
     "pangolinSettings": "Configurações - Pangolin",
     "accessRoleYour": "Sua função:",
     "accessRoleSelect2": "Selecionar uma função",
-    "accessUserSelect": "Selecionar um usuário",
+    "accessUserSelect": "Selecionar um utilizador",
     "otpEmailEnter": "Digite um e-mail",
     "otpEmailEnterDescription": "Pressione enter para adicionar um e-mail após digitá-lo no campo de entrada.",
     "otpEmailErrorInvalid": "Endereço de e-mail inválido. O caractere curinga (*) deve ser a parte local inteira.",
@@ -616,8 +619,8 @@
     "otpEmailTitleDescription": "Requer autenticação baseada em e-mail para acesso ao recurso",
     "otpEmailWhitelist": "Lista de E-mails Permitidos",
     "otpEmailWhitelistList": "E-mails na Lista Permitida",
-    "otpEmailWhitelistListDescription": "Apenas usuários com estes endereços de e-mail poderão acessar este recurso. Eles serão solicitados a inserir uma senha única enviada para seu e-mail. Caracteres curinga (*@example.com) podem ser usados para permitir qualquer endereço de e-mail de um domínio.",
-    "otpEmailWhitelistSave": "Salvar Lista Permitida",
+    "otpEmailWhitelistListDescription": "Apenas utilizadores com estes endereços de e-mail poderão aceder este recurso. Eles serão solicitados a inserir uma senha única enviada para seu e-mail. Caracteres curinga (*@example.com) podem ser usados para permitir qualquer endereço de e-mail de um domínio.",
+    "otpEmailWhitelistSave": "Guardar Lista Permitida",
     "passwordAdd": "Adicionar Senha",
     "passwordRemove": "Remover Senha",
     "pincodeAdd": "Adicionar Código PIN",
@@ -657,14 +660,14 @@
     "resourcePincodeSetupDescription": "O código PIN do recurso foi definido com sucesso",
     "resourcePincodeSetupTitle": "Definir Código PIN",
     "resourcePincodeSetupTitleDescription": "Defina um código PIN para proteger este recurso",
-    "resourceRoleDescription": "Administradores sempre podem acessar este recurso.",
-    "resourceUsersRoles": "Usuários e Funções",
-    "resourceUsersRolesDescription": "Configure quais usuários e funções podem visitar este recurso",
-    "resourceUsersRolesSubmit": "Salvar Usuários e Funções",
+    "resourceRoleDescription": "Administradores sempre podem aceder este recurso.",
+    "resourceUsersRoles": "Utilizadores e Funções",
+    "resourceUsersRolesDescription": "Configure quais utilizadores e funções podem visitar este recurso",
+    "resourceUsersRolesSubmit": "Guardar Utilizadores e Funções",
     "resourceWhitelistSave": "Salvo com sucesso",
     "resourceWhitelistSaveDescription": "As configurações da lista permitida foram salvas",
     "ssoUse": "Usar SSO da Plataforma",
-    "ssoUseDescription": "Os usuários existentes só precisarão fazer login uma vez para todos os recursos que tiverem isso habilitado.",
+    "ssoUseDescription": "Os utilizadores existentes só precisarão fazer login uma vez para todos os recursos que tiverem isso habilitado.",
     "proxyErrorInvalidPort": "Número da porta inválido",
     "subdomainErrorInvalid": "Subdomínio inválido",
     "domainErrorFetch": "Erro ao buscar domínios",
@@ -690,7 +693,7 @@
     "siteDestination": "Site de Destino",
     "searchSites": "Pesquisar sites",
     "accessRoleCreate": "Criar Função",
-    "accessRoleCreateDescription": "Crie uma nova função para agrupar usuários e gerenciar suas permissões.",
+    "accessRoleCreateDescription": "Crie uma nova função para agrupar utilizadores e gerir suas permissões.",
     "accessRoleCreateSubmit": "Criar Função",
     "accessRoleCreated": "Função criada",
     "accessRoleCreatedDescription": "A função foi criada com sucesso.",
@@ -700,13 +703,13 @@
     "accessRoleErrorRemove": "Falha ao remover função",
     "accessRoleErrorRemoveDescription": "Ocorreu um erro ao remover a função.",
     "accessRoleName": "Nome da Função",
-    "accessRoleQuestionRemove": "Você está prestes a excluir a função {name}. Você não pode desfazer esta ação.",
+    "accessRoleQuestionRemove": "Você está prestes a apagar a função {name}. Você não pode desfazer esta ação.",
     "accessRoleRemove": "Remover Função",
     "accessRoleRemoveDescription": "Remover uma função da organização",
     "accessRoleRemoveSubmit": "Remover Função",
     "accessRoleRemoved": "Função removida",
     "accessRoleRemovedDescription": "A função foi removida com sucesso.",
-    "accessRoleRequiredRemove": "Antes de excluir esta função, selecione uma nova função para transferir os membros existentes.",
+    "accessRoleRequiredRemove": "Antes de apagar esta função, selecione uma nova função para transferir os membros existentes.",
     "manage": "Gerir",
     "sitesNotFound": "Nenhum site encontrado.",
     "pangolinServerAdmin": "Administrador do Servidor - Pangolin",
@@ -914,12 +917,10 @@
     "idpConnectingToFinished": "Conectado",
     "idpErrorConnectingTo": "Ocorreu um problema ao ligar a {name}. Por favor, contacte o seu administrador.",
     "idpErrorNotFound": "IdP não encontrado",
-    "idpGoogleAlt": "Google",
-    "idpAzureAlt": "Azure",
     "inviteInvalid": "Convite Inválido",
     "inviteInvalidDescription": "O link do convite é inválido.",
-    "inviteErrorWrongUser": "O convite não é para este usuário",
-    "inviteErrorUserNotExists": "O usuário não existe. Por favor, crie uma conta primeiro.",
+    "inviteErrorWrongUser": "O convite não é para este utilizador",
+    "inviteErrorUserNotExists": "O utilizador não existe. Por favor, crie uma conta primeiro.",
     "inviteErrorLoginRequired": "Você deve estar logado para aceitar um convite",
     "inviteErrorExpired": "O convite pode ter expirado",
     "inviteErrorRevoked": "O convite pode ter sido revogado",
@@ -934,7 +935,7 @@
     "home": "Início",
     "accessControl": "Controle de Acesso",
     "settings": "Configurações",
-    "usersAll": "Todos os Usuários",
+    "usersAll": "Todos os Utilizadores",
     "license": "Licença",
     "pangolinDashboard": "Painel - Pangolin",
     "noResults": "Nenhum resultado encontrado.",
@@ -987,8 +988,8 @@
     "licenseTierProfessionalRequired": "Edição Profissional Necessária",
     "licenseTierProfessionalRequiredDescription": "Esta funcionalidade só está disponível na Edição Profissional.",
     "actionGetOrg": "Obter Organização",
-    "updateOrgUser": "Atualizar usuário Org",
-    "createOrgUser": "Criar usuário Org",
+    "updateOrgUser": "Atualizar utilizador Org",
+    "createOrgUser": "Criar utilizador Org",
     "actionUpdateOrg": "Atualizar Organização",
     "actionUpdateUser": "Atualizar Usuário",
     "actionGetUser": "Obter Usuário",
@@ -1135,8 +1136,8 @@
     "sidebarRoles": "Papéis",
     "sidebarShareableLinks": "Links compartilháveis",
     "sidebarApiKeys": "Chaves API",
-    "sidebarSettings": "Confirgurações",
-    "sidebarAllUsers": "Todos os usuários",
+    "sidebarSettings": "Configurações",
+    "sidebarAllUsers": "Todos os utilizadores",
     "sidebarIdentityProviders": "Provedores de identidade",
     "sidebarLicense": "Tipo:",
     "sidebarClients": "Clientes (Beta)",
@@ -1189,7 +1190,7 @@
     "loading": "Carregando",
     "restart": "Reiniciar",
     "domains": "Domínios",
-    "domainsDescription": "Gerencie domínios para sua organização",
+    "domainsDescription": "Gerir domínios para sua organização",
     "domainsSearch": "Pesquisar domínios...",
     "domainAdd": "Adicionar Domínio",
     "domainAddDescription": "Registre um novo domínio com sua organização",
@@ -1217,7 +1218,7 @@
     "pending": "Pendente",
     "sidebarBilling": "Faturamento",
     "billing": "Faturamento",
-    "orgBillingDescription": "Gerencie suas informações de faturamento e assinaturas",
+    "orgBillingDescription": "Gerir suas informações de faturação e assinaturas",
     "github": "GitHub",
     "pangolinHosted": "Hospedagem Pangolin",
     "fossorial": "Fossorial",
@@ -1232,7 +1233,7 @@
     "completeSetup": "Configuração Completa",
     "accountSetupSuccess": "Configuração da conta concluída! Bem-vindo ao Pangolin!",
     "documentation": "Documentação",
-    "saveAllSettings": "Salvar Todas as Configurações",
+    "saveAllSettings": "Guardar Todas as Configurações",
     "settingsUpdated": "Configurações atualizadas",
     "settingsUpdatedDescription": "Todas as configurações foram atualizadas com sucesso",
     "settingsErrorUpdate": "Falha ao atualizar configurações",
@@ -1257,13 +1258,55 @@
     "domainPickerSubdomain": "Subdomínio: {subdomain}",
     "domainPickerNamespace": "Namespace: {namespace}",
     "domainPickerShowMore": "Mostrar Mais",
+    "regionSelectorTitle": "Selecionar Região",
+    "regionSelectorInfo": "Selecionar uma região nos ajuda a fornecer melhor desempenho para sua localização. Você não precisa estar na mesma região que seu servidor.",
+    "regionSelectorPlaceholder": "Escolher uma região",
+    "regionSelectorComingSoon": "Em breve",
+    "billingLoadingSubscription": "Carregando assinatura...",
+    "billingFreeTier": "Plano Gratuito",
+    "billingWarningOverLimit": "Aviso: Você ultrapassou um ou mais limites de uso. Seus sites não se conectarão até você modificar sua assinatura ou ajustar seu uso.",
+    "billingUsageLimitsOverview": "Visão Geral dos Limites de Uso",
+    "billingMonitorUsage": "Monitore seu uso em relação aos limites configurados. Se precisar aumentar esses limites, entre em contato conosco support@fossorial.io.",
+    "billingDataUsage": "Uso de Dados",
+    "billingOnlineTime": "Tempo Online do Site",
+    "billingUsers": "Usuários Ativos",
+    "billingDomains": "Domínios Ativos",
+    "billingRemoteExitNodes": "Nodos Auto-Hospedados Ativos",
+    "billingNoLimitConfigured": "Nenhum limite configurado",
+    "billingEstimatedPeriod": "Período Estimado de Cobrança",
+    "billingIncludedUsage": "Uso Incluído",
+    "billingIncludedUsageDescription": "Uso incluído no seu plano de assinatura atual",
+    "billingFreeTierIncludedUsage": "Limites de uso do plano gratuito",
+    "billingIncluded": "incluído",
+    "billingEstimatedTotal": "Total Estimado:",
+    "billingNotes": "Notas",
+    "billingEstimateNote": "Esta é uma estimativa baseada no seu uso atual.",
+    "billingActualChargesMayVary": "As cobranças reais podem variar.",
+    "billingBilledAtEnd": "Sua cobrança será feita ao final do período de cobrança.",
+    "billingModifySubscription": "Modificar Assinatura",
+    "billingStartSubscription": "Iniciar Assinatura",
+    "billingRecurringCharge": "Cobrança Recorrente",
+    "billingManageSubscriptionSettings": "Gerenciar as configurações e preferências da sua assinatura",
+    "billingNoActiveSubscription": "Você não tem uma assinatura ativa. Inicie sua assinatura para aumentar os limites de uso.",
+    "billingFailedToLoadSubscription": "Falha ao carregar assinatura",
+    "billingFailedToLoadUsage": "Falha ao carregar uso",
+    "billingFailedToGetCheckoutUrl": "Falha ao obter URL de checkout",
+    "billingPleaseTryAgainLater": "Por favor, tente novamente mais tarde.",
+    "billingCheckoutError": "Erro de Checkout",
+    "billingFailedToGetPortalUrl": "Falha ao obter URL do portal",
+    "billingPortalError": "Erro do Portal",
+    "billingDataUsageInfo": "Você é cobrado por todos os dados transferidos através de seus túneis seguros quando conectado à nuvem. Isso inclui o tráfego de entrada e saída em todos os seus sites. Quando você atingir o seu limite, seus sites desconectarão até que você atualize seu plano ou reduza o uso. Os dados não serão cobrados ao usar os nós.",
+    "billingOnlineTimeInfo": "Cobrança de acordo com o tempo em que seus sites permanecem conectados à nuvem. Por exemplo, 44,640 minutos é igual a um site que roda 24/7 para um mês inteiro. Quando você atinge o seu limite, seus sites desconectarão até que você faça o upgrade do seu plano ou reduza o uso. O tempo não é cobrado ao usar nós.",
+    "billingUsersInfo": "Você será cobrado por cada usuário em sua organização. A cobrança é calculada diariamente com base no número de contas de usuário ativas em sua organização.",
+    "billingDomainInfo": "Você será cobrado por cada domínio em sua organização. A cobrança é calculada diariamente com base no número de contas de domínio ativas em sua organização.",
+    "billingRemoteExitNodesInfo": "Você será cobrado por cada Nodo gerenciado em sua organização. A cobrança é calculada diariamente com base no número de Nodos gerenciados ativos em sua organização.",
     "domainNotFound": "Domínio Não Encontrado",
     "domainNotFoundDescription": "Este recurso está desativado porque o domínio não existe mais em nosso sistema. Defina um novo domínio para este recurso.",
     "failed": "Falhou",
     "createNewOrgDescription": "Crie uma nova organização",
     "organization": "Organização",
     "port": "Porta",
-    "securityKeyManage": "Gerenciar chaves de segurança",
+    "securityKeyManage": "Gerir chaves de segurança",
     "securityKeyDescription": "Adicionar ou remover chaves de segurança para autenticação sem senha",
     "securityKeyRegister": "Registrar nova chave de segurança",
     "securityKeyList": "Suas chaves de segurança",
@@ -1314,12 +1357,13 @@
     "createDomainARecords": "Registros A",
     "createDomainRecordNumber": "Registrar {number}",
     "createDomainTxtRecords": "Registros TXT",
-    "createDomainSaveTheseRecords": "Salvar Esses Registros",
+    "createDomainSaveTheseRecords": "Guardar Esses Registros",
     "createDomainSaveTheseRecordsDescription": "Certifique-se de salvar esses registros DNS, pois você não os verá novamente.",
     "createDomainDnsPropagation": "Propagação DNS",
     "createDomainDnsPropagationDescription": "Alterações no DNS podem levar algum tempo para se propagar pela internet. Pode levar de alguns minutos a 48 horas, dependendo do seu provedor de DNS e das configurações de TTL.",
     "resourcePortRequired": "Número da porta é obrigatório para recursos não-HTTP",
     "resourcePortNotAllowed": "Número da porta não deve ser definido para recursos HTTP",
+    "billingPricingCalculatorLink": "Calculadora de Preços",
     "signUpTerms": {
         "IAgreeToThe": "Concordo com",
         "termsOfService": "os termos de serviço",
@@ -1368,6 +1412,41 @@
     "addNewTarget": "Adicionar Novo Alvo",
     "targetsList": "Lista de Alvos",
     "targetErrorDuplicateTargetFound": "Alvo duplicado encontrado",
+    "healthCheckHealthy": "Saudável",
+    "healthCheckUnhealthy": "Não Saudável",
+    "healthCheckUnknown": "Desconhecido",
+    "healthCheck": "Verificação de Saúde",
+    "configureHealthCheck": "Configurar Verificação de Saúde",
+    "configureHealthCheckDescription": "Configure a monitorização de saúde para {target}",
+    "enableHealthChecks": "Ativar Verificações de Saúde",
+    "enableHealthChecksDescription": "Monitore a saúde deste alvo. Você pode monitorar um ponto de extremidade diferente do alvo, se necessário.",
+    "healthScheme": "Método",
+    "healthSelectScheme": "Selecione o Método",
+    "healthCheckPath": "Caminho",
+    "healthHostname": "IP / Host",
+    "healthPort": "Porta",
+    "healthCheckPathDescription": "O caminho para verificar o estado de saúde.",
+    "healthyIntervalSeconds": "Intervalo Saudável",
+    "unhealthyIntervalSeconds": "Intervalo Não Saudável",
+    "IntervalSeconds": "Intervalo Saudável",
+    "timeoutSeconds": "Tempo Limite",
+    "timeIsInSeconds": "O tempo está em segundos",
+    "retryAttempts": "Tentativas de Repetição",
+    "expectedResponseCodes": "Códigos de Resposta Esperados",
+    "expectedResponseCodesDescription": "Código de status HTTP que indica estado saudável. Se deixado em branco, 200-300 é considerado saudável.",
+    "customHeaders": "Cabeçalhos Personalizados",
+    "customHeadersDescription": "Separados por cabeçalhos da nova linha: Nome do Cabeçalho: valor",
+    "headersValidationError": "Cabeçalhos devem estar no formato: Nome do Cabeçalho: valor.",
+    "saveHealthCheck": "Salvar Verificação de Saúde",
+    "healthCheckSaved": "Verificação de Saúde Salva",
+    "healthCheckSavedDescription": "Configuração de verificação de saúde salva com sucesso",
+    "healthCheckError": "Erro de Verificação de Saúde",
+    "healthCheckErrorDescription": "Ocorreu um erro ao salvar a configuração de verificação de saúde",
+    "healthCheckPathRequired": "O caminho de verificação de saúde é obrigatório",
+    "healthCheckMethodRequired": "O método HTTP é obrigatório",
+    "healthCheckIntervalMin": "O intervalo de verificação deve ser de pelo menos 5 segundos",
+    "healthCheckTimeoutMin": "O tempo limite deve ser de pelo menos 1 segundo",
+    "healthCheckRetryMin": "As tentativas de repetição devem ser pelo menos 1",
     "httpMethod": "Método HTTP",
     "selectHttpMethod": "Selecionar método HTTP",
     "domainPickerSubdomainLabel": "Subdomínio",
@@ -1381,6 +1460,7 @@
     "domainPickerEnterSubdomainToSearch": "Digite um subdomínio para buscar e selecionar entre os domínios gratuitos disponíveis.",
     "domainPickerFreeDomains": "Domínios Gratuitos",
     "domainPickerSearchForAvailableDomains": "Pesquise por domínios disponíveis",
+    "domainPickerNotWorkSelfHosted": "Nota: Domínios gratuitos fornecidos não estão disponíveis para instâncias auto-hospedadas no momento.",
     "resourceDomain": "Domínio",
     "resourceEditDomain": "Editar Domínio",
     "siteName": "Nome do Site",
@@ -1401,7 +1481,7 @@
     "editInternalResourceDialogSitePort": "Porta do Site",
     "editInternalResourceDialogTargetConfiguration": "Configuração do Alvo",
     "editInternalResourceDialogCancel": "Cancelar",
-    "editInternalResourceDialogSaveResource": "Salvar Recurso",
+    "editInternalResourceDialogSaveResource": "Guardar Recurso",
     "editInternalResourceDialogSuccess": "Sucesso",
     "editInternalResourceDialogInternalResourceUpdatedSuccessfully": "Recurso interno atualizado com sucesso",
     "editInternalResourceDialogError": "Erro",
@@ -1428,7 +1508,7 @@
     "createInternalResourceDialogTcp": "TCP",
     "createInternalResourceDialogUdp": "UDP",
     "createInternalResourceDialogSitePort": "Porta do Site",
-    "createInternalResourceDialogSitePortDescription": "Use esta porta para acessar o recurso no site quando conectado com um cliente.",
+    "createInternalResourceDialogSitePortDescription": "Use esta porta para aceder o recurso no site quando conectado com um cliente.",
     "createInternalResourceDialogTargetConfiguration": "Configuração do Alvo",
     "createInternalResourceDialogDestinationIPDescription": "O IP ou endereço do hostname do recurso na rede do site.",
     "createInternalResourceDialogDestinationPortDescription": "A porta no IP de destino onde o recurso está acessível.",
@@ -1452,7 +1532,7 @@
     "siteAddress": "Endereço do Site",
     "siteAddressDescription": "Especificar o endereço IP do host para que os clientes se conectem. Este é o endereço interno do site na rede Pangolin para os clientes endereçarem. Deve estar dentro da sub-rede da Organização.",
     "autoLoginExternalIdp": "Login Automático com IDP Externo",
-    "autoLoginExternalIdpDescription": "Redirecionar imediatamente o usuário para o IDP externo para autenticação.",
+    "autoLoginExternalIdpDescription": "Redirecionar imediatamente o utilizador para o IDP externo para autenticação.",
     "selectIdp": "Selecionar IDP",
     "selectIdpPlaceholder": "Escolher um IDP...",
     "selectIdpRequired": "Por favor, selecione um IDP quando o login automático estiver ativado.",
@@ -1463,6 +1543,72 @@
     "autoLoginError": "Erro de Login Automático",
     "autoLoginErrorNoRedirectUrl": "Nenhum URL de redirecionamento recebido do provedor de identidade.",
     "autoLoginErrorGeneratingUrl": "Falha ao gerar URL de autenticação.",
+    "remoteExitNodeManageRemoteExitNodes": "Gerenciar Auto-Hospedados",
+    "remoteExitNodeDescription": "Gerencie os nós para estender sua conectividade de rede",
+    "remoteExitNodes": "Nodes",
+    "searchRemoteExitNodes": "Buscar nós...",
+    "remoteExitNodeAdd": "Adicionar node",
+    "remoteExitNodeErrorDelete": "Erro ao excluir nó",
+    "remoteExitNodeQuestionRemove": "Tem certeza que deseja remover o nó {selectedNode} da organização?",
+    "remoteExitNodeMessageRemove": "Uma vez removido, o nó não estará mais acessível.",
+    "remoteExitNodeMessageConfirm": "Para confirmar, por favor, digite o nome do nó abaixo.",
+    "remoteExitNodeConfirmDelete": "Confirmar exclusão do nó",
+    "remoteExitNodeDelete": "Excluir nó",
+    "sidebarRemoteExitNodes": "Nodes",
+    "remoteExitNodeCreate": {
+        "title": "Criar nó",
+        "description": "Crie um novo nó para estender sua conectividade de rede",
+        "viewAllButton": "Ver Todos os Nós",
+        "strategy": {
+            "title": "Estratégia de Criação",
+            "description": "Escolha isto para configurar o seu nó manualmente ou gerar novas credenciais.",
+            "adopt": {
+                "title": "Adotar Nodo",
+                "description": "Escolha isto se você já tem credenciais para o nó."
+            },
+            "generate": {
+                "title": "Gerar Chaves",
+                "description": "Escolha esta opção se você quer gerar novas chaves para o nó"
+            }
+        },
+        "adopt": {
+            "title": "Adotar Nodo Existente",
+            "description": "Digite as credenciais do nó existente que deseja adoptar",
+            "nodeIdLabel": "Nó ID",
+            "nodeIdDescription": "O ID do nó existente que você deseja adoptar",
+            "secretLabel": "Chave Secreta",
+            "secretDescription": "A chave secreta do nó existente",
+            "submitButton": "Nó Adotado"
+        },
+        "generate": {
+            "title": "Credenciais Geradas",
+            "description": "Use estas credenciais geradas para configurar o seu nó",
+            "nodeIdTitle": "Nó ID",
+            "secretTitle": "Chave Secreta",
+            "saveCredentialsTitle": "Adicionar Credenciais à Configuração",
+            "saveCredentialsDescription": "Adicione essas credenciais ao arquivo de configuração do seu nodo de Pangolin auto-hospedado para completar a conexão.",
+            "submitButton": "Criar nó"
+        },
+        "validation": {
+            "adoptRequired": "ID do nó e Segredo são necessários ao adotar um nó existente"
+        },
+        "errors": {
+            "loadDefaultsFailed": "Falha ao carregar padrões",
+            "defaultsNotLoaded": "Padrões não carregados",
+            "createFailed": "Falha ao criar nó"
+        },
+        "success": {
+            "created": "Nó criado com sucesso"
+        }
+    },
+    "remoteExitNodeSelection": "Seleção de nó",
+    "remoteExitNodeSelectionDescription": "Selecione um nó para encaminhar o tráfego para este site local",
+    "remoteExitNodeRequired": "Um nó deve ser seleccionado para sites locais",
+    "noRemoteExitNodesAvailable": "Nenhum nó disponível",
+    "noRemoteExitNodesAvailableDescription": "Nenhum nó está disponível para esta organização. Crie um nó primeiro para usar sites locais.",
+    "exitNode": "Nodo de Saída",
+    "country": "País",
+    "rulesMatchCountry": "Atualmente baseado no IP de origem",
     "managedSelfHosted": {
         "title": "Gerenciado Auto-Hospedado",
         "description": "Servidor Pangolin auto-hospedado mais confiável e com baixa manutenção com sinos extras e assobiamentos",
@@ -1479,7 +1625,7 @@
         },
         "benefitLessMaintenance": {
             "title": "Menos manutenção",
-            "description": "Sem migrações, backups ou infraestrutura extra para gerenciar. Lidamos com isso na nuvem."
+            "description": "Sem migrações, backups ou infraestrutura extra para gerir. Lidamos com isso na nuvem."
         },
         "benefitCloudFailover": {
             "title": "Falha na nuvem",
@@ -1501,11 +1647,53 @@
     },
     "internationaldomaindetected": "Domínio Internacional Detectado",
     "willbestoredas": "Será armazenado como:",
+    "roleMappingDescription": "Determinar como as funções são atribuídas aos usuários quando eles fazem login quando Auto Provisão está habilitada.",
+    "selectRole": "Selecione uma função",
+    "roleMappingExpression": "Expressão",
+    "selectRolePlaceholder": "Escolha uma função",
+    "selectRoleDescription": "Selecione uma função para atribuir a todos os usuários deste provedor de identidade",
+    "roleMappingExpressionDescription": "Insira uma expressão JMESPath para extrair informações da função do token de ID",
+    "idpTenantIdRequired": "ID do inquilino é necessária",
+    "invalidValue": "Valor Inválido",
+    "idpTypeLabel": "Tipo de provedor de identidade",
+    "roleMappingExpressionPlaceholder": "ex.: Contem (grupos, 'administrador') && 'Administrador' 「'Membro'",
+    "idpGoogleConfiguration": "Configuração do Google",
+    "idpGoogleConfigurationDescription": "Configurar suas credenciais do Google OAuth2",
+    "idpGoogleClientIdDescription": "Seu ID de Cliente OAuth2 do Google",
+    "idpGoogleClientSecretDescription": "Seu Segredo de Cliente OAuth2 do Google",
+    "idpAzureConfiguration": "Configuração de ID do Azure Entra",
+    "idpAzureConfigurationDescription": "Configure as suas credenciais do Azure Entra ID OAuth2",
+    "idpTenantId": "Tenant ID",
+    "idpTenantIdPlaceholder": "seu-tenente-id",
+    "idpAzureTenantIdDescription": "Seu ID do tenant Azure (encontrado na visão geral do diretório ativo Azure)",
+    "idpAzureClientIdDescription": "Seu ID de Cliente de Registro do App Azure",
+    "idpAzureClientSecretDescription": "Seu segredo de cliente de registro de aplicativos Azure",
+    "idpGoogleTitle": "Google",
+    "idpGoogleAlt": "Google",
+    "idpAzureTitle": "Azure Entra ID",
+    "idpAzureAlt": "Azure",
+    "idpGoogleConfigurationTitle": "Configuração do Google",
+    "idpAzureConfigurationTitle": "Configuração de ID do Azure Entra",
+    "idpTenantIdLabel": "Tenant ID",
+    "idpAzureClientIdDescription2": "Seu ID de Cliente de Registro do App Azure",
+    "idpAzureClientSecretDescription2": "Seu segredo de cliente de registro de aplicativos Azure",
     "idpGoogleDescription": "Provedor Google OAuth2/OIDC",
     "idpAzureDescription": "Microsoft Azure OAuth2/OIDC provider",
-    "customHeaders": "Cabeçalhos Personalizados",
-    "customHeadersDescription": "Add custom headers to be sent when proxying requests. One per line in the format Header-Name: value",
-    "headersValidationError": "Cabeçalhos devem estar no formato: Nome do Cabeçalho: valor.",
+    "subnet": "Sub-rede",
+    "subnetDescription": "A sub-rede para a configuração de rede dessa organização.",
+    "authPage": "Página de Autenticação",
+    "authPageDescription": "Configurar a página de autenticação para sua organização",
+    "authPageDomain": "Domínio de Página Autenticação",
+    "noDomainSet": "Nenhum domínio definido",
+    "changeDomain": "Alterar domínio",
+    "selectDomain": "Selecionar domínio",
+    "restartCertificate": "Reiniciar Certificado",
+    "editAuthPageDomain": "Editar Página de Autenticação",
+    "setAuthPageDomain": "Definir domínio da página de autenticação",
+    "failedToFetchCertificate": "Falha ao buscar o certificado",
+    "failedToRestartCertificate": "Falha ao reiniciar o certificado",
+    "addDomainToEnableCustomAuthPages": "Adicione um domínio para habilitar páginas de autenticação personalizadas para sua organização",
+    "selectDomainForOrgAuthPage": "Selecione um domínio para a página de autenticação da organização",
     "domainPickerProvidedDomain": "Domínio fornecido",
     "domainPickerFreeProvidedDomain": "Domínio fornecido grátis",
     "domainPickerVerified": "Verificada",
@@ -1519,10 +1707,16 @@
     "domainPickerInvalidSubdomainCannotMakeValid": "\"{sub}\" não pôde ser válido para {domain}.",
     "domainPickerSubdomainSanitized": "Subdomínio banalizado",
     "domainPickerSubdomainCorrected": "\"{sub}\" foi corrigido para \"{sanitized}\"",
+    "orgAuthSignInTitle": "Entrar na sua organização",
+    "orgAuthChooseIdpDescription": "Escolha o seu provedor de identidade para continuar",
+    "orgAuthNoIdpConfigured": "Esta organização não tem nenhum provedor de identidade configurado. Você pode entrar com a identidade do seu Pangolin.",
+    "orgAuthSignInWithPangolin": "Entrar com o Pangolin",
+    "subscriptionRequiredToUse": "Uma assinatura é necessária para usar esse recurso.",
+    "idpDisabled": "Provedores de identidade estão desabilitados.",
+    "orgAuthPageDisabled": "A página de autenticação da organização está desativada.",
+    "domainRestartedDescription": "Verificação de domínio reiniciado com sucesso",
     "resourceAddEntrypointsEditFile": "Editar arquivo: config/traefik/traefik_config.yml",
     "resourceExposePortsEditFile": "Editar arquivo: docker-compose.yml",
     "emailVerificationRequired": "Verificação de e-mail é necessária. Por favor, faça login novamente via {dashboardUrl}/auth/login conclui esta etapa. Em seguida, volte aqui.",
-    "twoFactorSetupRequired": "Configuração de autenticação de dois fatores é necessária. Por favor, entre novamente via {dashboardUrl}/auth/login conclua este passo. Em seguida, volte aqui.",
-    "rewritePath": "Rewrite Path",
-    "rewritePathDescription": "Optionally rewrite the path before forwarding to the target."
+    "twoFactorSetupRequired": "Configuração de autenticação de dois fatores é necessária. Por favor, entre novamente via {dashboardUrl}/auth/login conclua este passo. Em seguida, volte aqui."
 }

messages/ru-RU.json

@@ -168,6 +168,9 @@
     "siteSelect": "Выберите сайт",
     "siteSearch": "Поиск сайта",
     "siteNotFound": "Сайт не найден.",
+    "selectCountry": "Выберите страну",
+    "searchCountries": "Поиск стран...",
+    "noCountryFound": "Страна не найдена.",
     "siteSelectionDescription": "Этот сайт предоставит подключение к цели.",
     "resourceType": "Тип ресурса",
     "resourceTypeDescription": "Определите, как вы хотите получать доступ к вашему ресурсу",
@@ -236,7 +239,7 @@
     "accessUserCreate": "Создать пользователя",
     "accessUserRemove": "Удалить пользователя",
     "username": "Имя пользователя",
-    "identityProvider": "Identity Provider",
+    "identityProvider": "Поставщик удостоверений",
     "role": "Роль",
     "nameRequired": "Имя обязательно",
     "accessRolesManage": "Управление ролями",
@@ -914,8 +917,6 @@
     "idpConnectingToFinished": "Подключено",
     "idpErrorConnectingTo": "Возникла проблема при подключении к {name}. Пожалуйста, свяжитесь с вашим администратором.",
     "idpErrorNotFound": "IdP не найден",
-    "idpGoogleAlt": "Google",
-    "idpAzureAlt": "Azure",
     "inviteInvalid": "Недействительное приглашение",
     "inviteInvalidDescription": "Ссылка на приглашение недействительна.",
     "inviteErrorWrongUser": "Приглашение не для этого пользователя",
@@ -1257,6 +1258,48 @@
     "domainPickerSubdomain": "Поддомен: {subdomain}",
     "domainPickerNamespace": "Пространство имен: {namespace}",
     "domainPickerShowMore": "Показать еще",
+    "regionSelectorTitle": "Выберите регион",
+    "regionSelectorInfo": "Выбор региона помогает нам обеспечить лучшее качество обслуживания для вашего расположения. Вам необязательно находиться в том же регионе, что и ваш сервер.",
+    "regionSelectorPlaceholder": "Выбор региона",
+    "regionSelectorComingSoon": "Скоро будет",
+    "billingLoadingSubscription": "Загрузка подписки...",
+    "billingFreeTier": "Бесплатный уровень",
+    "billingWarningOverLimit": "Предупреждение: Вы превысили одну или несколько границ использования. Ваши сайты не подключатся, пока вы не измените подписку или не скорректируете использование.",
+    "billingUsageLimitsOverview": "Обзор лимитов использования",
+    "billingMonitorUsage": "Контролируйте использование в соответствии с установленными лимитами. Если вам требуется увеличение лимитов, пожалуйста, свяжитесь с нами support@fossorial.io.",
+    "billingDataUsage": "Использование данных",
+    "billingOnlineTime": "Время работы сайта",
+    "billingUsers": "Активные пользователи",
+    "billingDomains": "Активные домены",
+    "billingRemoteExitNodes": "Активные самоуправляемые узлы",
+    "billingNoLimitConfigured": "Лимит не установлен",
+    "billingEstimatedPeriod": "Предполагаемый период выставления счетов",
+    "billingIncludedUsage": "Включенное использование",
+    "billingIncludedUsageDescription": "Использование, включенное в ваш текущий план подписки",
+    "billingFreeTierIncludedUsage": "Бесплатное использование ограничений",
+    "billingIncluded": "включено",
+    "billingEstimatedTotal": "Предполагаемая сумма:",
+    "billingNotes": "Заметки",
+    "billingEstimateNote": "Это приблизительная оценка на основании вашего текущего использования.",
+    "billingActualChargesMayVary": "Фактические начисления могут отличаться.",
+    "billingBilledAtEnd": "С вас будет выставлен счет в конце периода выставления счетов.",
+    "billingModifySubscription": "Изменить подписку",
+    "billingStartSubscription": "Начать подписку",
+    "billingRecurringCharge": "Периодический взнос",
+    "billingManageSubscriptionSettings": "Управляйте настройками и предпочтениями вашей подписки",
+    "billingNoActiveSubscription": "У вас нет активной подписки. Начните подписку, чтобы увеличить лимиты использования.",
+    "billingFailedToLoadSubscription": "Не удалось загрузить подписку",
+    "billingFailedToLoadUsage": "Не удалось загрузить использование",
+    "billingFailedToGetCheckoutUrl": "Не удалось получить URL-адрес для оплаты",
+    "billingPleaseTryAgainLater": "Пожалуйста, повторите попытку позже.",
+    "billingCheckoutError": "Ошибка при оформлении заказа",
+    "billingFailedToGetPortalUrl": "Не удалось получить URL-адрес портала",
+    "billingPortalError": "Ошибка портала",
+    "billingDataUsageInfo": "Вы несете ответственность за все данные, переданные через безопасные туннели при подключении к облаку. Это включает как входящий, так и исходящий трафик на всех ваших сайтах. При достижении лимита ваши сайты будут отключаться до тех пор, пока вы не обновите план или не уменьшите его использование. При использовании узлов не взимается плата.",
+    "billingOnlineTimeInfo": "Вы тарифицируете на то, как долго ваши сайты будут подключены к облаку. Например, 44 640 минут равны одному сайту, работающему круглосуточно за весь месяц. Когда вы достигните лимита, ваши сайты будут отключаться до тех пор, пока вы не обновите тарифный план или не сократите нагрузку. При использовании узлов не тарифицируется.",
+    "billingUsersInfo": "С вас взимается плата за каждого пользователя в вашей организации. Оплата рассчитывается ежедневно исходя из количества активных учетных записей пользователей в вашей организации.",
+    "billingDomainInfo": "С вас взимается плата за каждый домен в вашей организации. Оплата рассчитывается ежедневно исходя из количества активных учетных записей доменов в вашей организации.",
+    "billingRemoteExitNodesInfo": "С вас взимается плата за каждый управляемый узел в вашей организации. Оплата рассчитывается ежедневно исходя из количества активных управляемых узлов в вашей организации.",
     "domainNotFound": "Домен не найден",
     "domainNotFoundDescription": "Этот ресурс отключен, так как домен больше не существует в нашей системе. Пожалуйста, установите новый домен для этого ресурса.",
     "failed": "Ошибка",
@@ -1320,6 +1363,7 @@
     "createDomainDnsPropagationDescription": "Изменения DNS могут занять некоторое время для распространения через интернет. Это может занять от нескольких минут до 48 часов в зависимости от вашего DNS провайдера и настроек TTL.",
     "resourcePortRequired": "Номер порта необходим для не-HTTP ресурсов",
     "resourcePortNotAllowed": "Номер порта не должен быть установлен для HTTP ресурсов",
+    "billingPricingCalculatorLink": "Калькулятор расценок",
     "signUpTerms": {
         "IAgreeToThe": "Я согласен с",
         "termsOfService": "условия использования",
@@ -1368,6 +1412,41 @@
     "addNewTarget": "Добавить новую цель",
     "targetsList": "Список целей",
     "targetErrorDuplicateTargetFound": "Обнаружена дублирующаяся цель",
+    "healthCheckHealthy": "Здоровый",
+    "healthCheckUnhealthy": "Нездоровый",
+    "healthCheckUnknown": "Неизвестно",
+    "healthCheck": "Проверка здоровья",
+    "configureHealthCheck": "Настроить проверку здоровья",
+    "configureHealthCheckDescription": "Настройте мониторинг состояния для {target}",
+    "enableHealthChecks": "Включить проверки здоровья",
+    "enableHealthChecksDescription": "Мониторинг здоровья этой цели. При необходимости можно контролировать другую конечную точку.",
+    "healthScheme": "Метод",
+    "healthSelectScheme": "Выберите метод",
+    "healthCheckPath": "Путь",
+    "healthHostname": "IP / хост",
+    "healthPort": "Порт",
+    "healthCheckPathDescription": "Путь к проверке состояния здоровья.",
+    "healthyIntervalSeconds": "Интервал здоровых состояний",
+    "unhealthyIntervalSeconds": "Интервал нездоровых состояний",
+    "IntervalSeconds": "Интервал здоровых состояний",
+    "timeoutSeconds": "Тайм-аут",
+    "timeIsInSeconds": "Время указано в секундах",
+    "retryAttempts": "Количество попыток повторного запроса",
+    "expectedResponseCodes": "Ожидаемые коды ответов",
+    "expectedResponseCodesDescription": "HTTP-код состояния, указывающий на здоровое состояние. Если оставить пустым, 200-300 считается здоровым.",
+    "customHeaders": "Пользовательские заголовки",
+    "customHeadersDescription": "Заголовки новой строки, разделённые: название заголовка: значение",
+    "headersValidationError": "Заголовки должны быть в формате: Название заголовка: значение.",
+    "saveHealthCheck": "Сохранить проверку здоровья",
+    "healthCheckSaved": "Проверка здоровья сохранена",
+    "healthCheckSavedDescription": "Конфигурация проверки состояния успешно сохранена",
+    "healthCheckError": "Ошибка проверки состояния",
+    "healthCheckErrorDescription": "Произошла ошибка при сохранении конфигурации проверки состояния",
+    "healthCheckPathRequired": "Требуется путь проверки состояния",
+    "healthCheckMethodRequired": "Требуется метод HTTP",
+    "healthCheckIntervalMin": "Интервал проверки должен составлять не менее 5 секунд",
+    "healthCheckTimeoutMin": "Тайм-аут должен составлять не менее 1 секунды",
+    "healthCheckRetryMin": "Количество попыток должно быть не менее 1",
     "httpMethod": "HTTP метод",
     "selectHttpMethod": "Выберите HTTP метод",
     "domainPickerSubdomainLabel": "Поддомен",
@@ -1381,6 +1460,7 @@
     "domainPickerEnterSubdomainToSearch": "Введите поддомен для поиска и выбора из доступных свободных доменов.",
     "domainPickerFreeDomains": "Свободные домены",
     "domainPickerSearchForAvailableDomains": "Поиск доступных доменов",
+    "domainPickerNotWorkSelfHosted": "Примечание: бесплатные предоставляемые домены в данный момент недоступны для самоуправляемых экземпляров.",
     "resourceDomain": "Домен",
     "resourceEditDomain": "Редактировать домен",
     "siteName": "Имя сайта",
@@ -1463,6 +1543,72 @@
     "autoLoginError": "Ошибка автоматического входа",
     "autoLoginErrorNoRedirectUrl": "URL-адрес перенаправления не получен от провайдера удостоверения.",
     "autoLoginErrorGeneratingUrl": "Не удалось сгенерировать URL-адрес аутентификации.",
+    "remoteExitNodeManageRemoteExitNodes": "Управление самоуправляемым",
+    "remoteExitNodeDescription": "Управляйте узлами для расширения сетевого подключения",
+    "remoteExitNodes": "Nodes",
+    "searchRemoteExitNodes": "Поиск узлов...",
+    "remoteExitNodeAdd": "Добавить узел",
+    "remoteExitNodeErrorDelete": "Ошибка удаления узла",
+    "remoteExitNodeQuestionRemove": "Вы уверены, что хотите удалить узел {selectedNode} из организации?",
+    "remoteExitNodeMessageRemove": "После удаления узел больше не будет доступен.",
+    "remoteExitNodeMessageConfirm": "Для подтверждения введите имя узла ниже.",
+    "remoteExitNodeConfirmDelete": "Подтвердите удаление узла",
+    "remoteExitNodeDelete": "Удалить узел",
+    "sidebarRemoteExitNodes": "Nodes",
+    "remoteExitNodeCreate": {
+        "title": "Создать узел",
+        "description": "Создайте новый узел, чтобы расширить сетевое подключение",
+        "viewAllButton": "Все узлы",
+        "strategy": {
+            "title": "Стратегия создания",
+            "description": "Выберите эту опцию для настройки вашего узла или создания новых учетных данных.",
+            "adopt": {
+                "title": "Принять узел",
+                "description": "Выберите это, если у вас уже есть учетные данные для узла."
+            },
+            "generate": {
+                "title": "Сгенерировать ключи",
+                "description": "Выберите это, если вы хотите создать новые ключи для узла"
+            }
+        },
+        "adopt": {
+            "title": "Принять существующий узел",
+            "description": "Введите учетные данные существующего узла, который вы хотите принять",
+            "nodeIdLabel": "ID узла",
+            "nodeIdDescription": "ID существующего узла, который вы хотите принять",
+            "secretLabel": "Секретный ключ",
+            "secretDescription": "Секретный ключ существующего узла",
+            "submitButton": "Принять узел"
+        },
+        "generate": {
+            "title": "Сгенерированные учетные данные",
+            "description": "Используйте эти учётные данные для настройки вашего узла",
+            "nodeIdTitle": "ID узла",
+            "secretTitle": "Секретный ключ",
+            "saveCredentialsTitle": "Добавить учетные данные в конфигурацию",
+            "saveCredentialsDescription": "Добавьте эти учетные данные в файл конфигурации вашего самоуправляемого узла Pangolin, чтобы завершить подключение.",
+            "submitButton": "Создать узел"
+        },
+        "validation": {
+            "adoptRequired": "ID узла и секрет требуются при установке существующего узла"
+        },
+        "errors": {
+            "loadDefaultsFailed": "Не удалось загрузить параметры по умолчанию",
+            "defaultsNotLoaded": "Параметры по умолчанию не загружены",
+            "createFailed": "Не удалось создать узел"
+        },
+        "success": {
+            "created": "Узел успешно создан"
+        }
+    },
+    "remoteExitNodeSelection": "Выбор узла",
+    "remoteExitNodeSelectionDescription": "Выберите узел для маршрутизации трафика для этого локального сайта",
+    "remoteExitNodeRequired": "Узел должен быть выбран для локальных сайтов",
+    "noRemoteExitNodesAvailable": "Нет доступных узлов",
+    "noRemoteExitNodesAvailableDescription": "Для этой организации узлы не доступны. Сначала создайте узел, чтобы использовать локальные сайты.",
+    "exitNode": "Узел выхода",
+    "country": "Страна",
+    "rulesMatchCountry": "В настоящее время основано на исходном IP",
     "managedSelfHosted": {
         "title": "Управляемый с самовывоза",
         "description": "Более надежный и низко обслуживаемый сервер Pangolin с дополнительными колокольнями и свистками",
@@ -1501,11 +1647,53 @@
     },
     "internationaldomaindetected": "Обнаружен международный домен",
     "willbestoredas": "Будет храниться как:",
+    "roleMappingDescription": "Определите, как роли, назначаемые пользователям, когда они войдут в систему автоматического профиля.",
+    "selectRole": "Выберите роль",
+    "roleMappingExpression": "Выражение",
+    "selectRolePlaceholder": "Выберите роль",
+    "selectRoleDescription": "Выберите роль, чтобы назначить всем пользователям этого поставщика идентификации",
+    "roleMappingExpressionDescription": "Введите выражение JMESPath, чтобы извлечь информацию о роли из ID токена",
+    "idpTenantIdRequired": "Требуется ID владельца",
+    "invalidValue": "Неверное значение",
+    "idpTypeLabel": "Тип поставщика удостоверений",
+    "roleMappingExpressionPlaceholder": "например, contains(groups, 'admin') && 'Admin' || 'Member'",
+    "idpGoogleConfiguration": "Конфигурация Google",
+    "idpGoogleConfigurationDescription": "Настройка учетных данных Google OAuth2",
+    "idpGoogleClientIdDescription": "Ваш Google OAuth2 ID клиента",
+    "idpGoogleClientSecretDescription": "Ваш Google OAuth2 Секрет",
+    "idpAzureConfiguration": "Конфигурация Azure Entra ID",
+    "idpAzureConfigurationDescription": "Настройте учетные данные Azure Entra ID OAuth2",
+    "idpTenantId": "Tenant ID",
+    "idpTenantIdPlaceholder": "ваш тенант-id",
+    "idpAzureTenantIdDescription": "Идентификатор арендатора Azure (найден в обзоре Active Directory Azure)",
+    "idpAzureClientIdDescription": "Ваш идентификатор клиента Azure App",
+    "idpAzureClientSecretDescription": "Секрет регистрации клиента Azure App",
+    "idpGoogleTitle": "Google",
+    "idpGoogleAlt": "Google",
+    "idpAzureTitle": "Azure Entra ID",
+    "idpAzureAlt": "Azure",
+    "idpGoogleConfigurationTitle": "Конфигурация Google",
+    "idpAzureConfigurationTitle": "Конфигурация Azure Entra ID",
+    "idpTenantIdLabel": "Tenant ID",
+    "idpAzureClientIdDescription2": "Ваш идентификатор клиента Azure App",
+    "idpAzureClientSecretDescription2": "Секрет регистрации клиента Azure App",
     "idpGoogleDescription": "Google OAuth2/OIDC провайдер",
     "idpAzureDescription": "Microsoft Azure OAuth2/OIDC provider",
-    "customHeaders": "Пользовательские заголовки",
-    "customHeadersDescription": "Add custom headers to be sent when proxying requests. One per line in the format Header-Name: value",
-    "headersValidationError": "Заголовки должны быть в формате: Название заголовка: значение.",
+    "subnet": "Подсеть",
+    "subnetDescription": "Подсеть для конфигурации сети этой организации.",
+    "authPage": "Страница авторизации",
+    "authPageDescription": "Настройка страницы авторизации для вашей организации",
+    "authPageDomain": "Домен страницы авторизации",
+    "noDomainSet": "Домен не установлен",
+    "changeDomain": "Изменить домен",
+    "selectDomain": "Выберите домен",
+    "restartCertificate": "Перезапустить сертификат",
+    "editAuthPageDomain": "Редактировать домен страницы авторизации",
+    "setAuthPageDomain": "Установить домен страницы авторизации",
+    "failedToFetchCertificate": "Не удалось получить сертификат",
+    "failedToRestartCertificate": "Не удалось перезапустить сертификат",
+    "addDomainToEnableCustomAuthPages": "Добавьте домен для включения пользовательских страниц аутентификации для вашей организации",
+    "selectDomainForOrgAuthPage": "Выберите домен для страницы аутентификации организации",
     "domainPickerProvidedDomain": "Домен предоставлен",
     "domainPickerFreeProvidedDomain": "Бесплатный домен",
     "domainPickerVerified": "Подтверждено",
@@ -1519,10 +1707,16 @@
     "domainPickerInvalidSubdomainCannotMakeValid": "\"{sub}\" не может быть действительным для {domain}.",
     "domainPickerSubdomainSanitized": "Субдомен очищен",
     "domainPickerSubdomainCorrected": "\"{sub}\" был исправлен на \"{sanitized}\"",
+    "orgAuthSignInTitle": "Войдите в свою организацию",
+    "orgAuthChooseIdpDescription": "Выберите своего поставщика удостоверений личности для продолжения",
+    "orgAuthNoIdpConfigured": "Эта организация не имеет настроенных поставщиков идентификационных данных. Вместо этого вы можете войти в свой Pangolin.",
+    "orgAuthSignInWithPangolin": "Войти через Pangolin",
+    "subscriptionRequiredToUse": "Для использования этой функции требуется подписка.",
+    "idpDisabled": "Провайдеры идентификации отключены.",
+    "orgAuthPageDisabled": "Страница авторизации организации отключена.",
+    "domainRestartedDescription": "Проверка домена успешно перезапущена",
     "resourceAddEntrypointsEditFile": "Редактировать файл: config/traefik/traefik_config.yml",
     "resourceExposePortsEditFile": "Редактировать файл: docker-compose.yml",
     "emailVerificationRequired": "Требуется подтверждение адреса электронной почты. Пожалуйста, войдите снова через {dashboardUrl}/auth/login завершить этот шаг. Затем вернитесь сюда.",
-    "twoFactorSetupRequired": "Требуется настройка двухфакторной аутентификации. Пожалуйста, войдите снова через {dashboardUrl}/auth/login завершить этот шаг. Затем вернитесь сюда.",
-    "rewritePath": "Rewrite Path",
-    "rewritePathDescription": "Optionally rewrite the path before forwarding to the target."
+    "twoFactorSetupRequired": "Требуется настройка двухфакторной аутентификации. Пожалуйста, войдите снова через {dashboardUrl}/auth/login завершить этот шаг. Затем вернитесь сюда."
 }

messages/tr-TR.json

@@ -168,6 +168,9 @@
     "siteSelect": "Site seç",
     "siteSearch": "Site ara",
     "siteNotFound": "Herhangi bir site bulunamadı.",
+    "selectCountry": "Ülke Seç",
+    "searchCountries": "Ülkeleri ara...",
+    "noCountryFound": "Ülke bulunamadı.",
     "siteSelectionDescription": "Bu site hedefe bağlantı sağlayacaktır.",
     "resourceType": "Kaynak Türü",
     "resourceTypeDescription": "Kaynağınıza nasıl erişmek istediğinizi belirleyin",
@@ -814,7 +817,7 @@
     "redirectUrl": "Yönlendirme URL'si",
     "redirectUrlAbout": "Yönlendirme URL'si Hakkında",
     "redirectUrlAboutDescription": "Bu, kimlik doğrulamasından sonra kullanıcıların yönlendirileceği URL'dir. Bu URL'yi kimlik sağlayıcınızın ayarlarında yapılandırmanız gerekir.",
-    "pangolinAuth": "Auth - Pangolin",
+    "pangolinAuth": "Yetkilendirme - Pangolin",
     "verificationCodeLengthRequirements": "Doğrulama kodunuz 8 karakter olmalıdır.",
     "errorOccurred": "Bir hata oluştu",
     "emailErrorVerify": "E-posta doğrulanamadı: ",
@@ -914,8 +917,6 @@
     "idpConnectingToFinished": "Bağlandı",
     "idpErrorConnectingTo": "{name} ile bağlantı kurarken bir sorun meydana geldi. Lütfen yöneticiye danışın.",
     "idpErrorNotFound": "IdP bulunamadı",
-    "idpGoogleAlt": "Google",
-    "idpAzureAlt": "Azure",
     "inviteInvalid": "Geçersiz Davet",
     "inviteInvalidDescription": "Davet bağlantısı geçersiz.",
     "inviteErrorWrongUser": "Davet bu kullanıcı için değil",
@@ -1241,7 +1242,7 @@
     "sidebarExpand": "Genişlet",
     "newtUpdateAvailable": "Güncelleme Mevcut",
     "newtUpdateAvailableInfo": "Newt'in yeni bir versiyonu mevcut. En iyi deneyim için lütfen en son sürüme güncelleyin.",
-    "domainPickerEnterDomain": "Domain",
+    "domainPickerEnterDomain": "Alan Adı",
     "domainPickerPlaceholder": "myapp.example.com",
     "domainPickerDescription": "Mevcut seçenekleri görmek için kaynağın tam etki alanını girin.",
     "domainPickerDescriptionSaas": "Mevcut seçenekleri görmek için tam etki alanı, alt etki alanı veya sadece bir isim girin",
@@ -1257,6 +1258,48 @@
     "domainPickerSubdomain": "Alt Alan: {subdomain}",
     "domainPickerNamespace": "Ad Alanı: {namespace}",
     "domainPickerShowMore": "Daha Fazla Göster",
+    "regionSelectorTitle": "Bölge Seç",
+    "regionSelectorInfo": "Bir bölge seçmek, konumunuz için daha iyi performans sağlamamıza yardımcı olur. Sunucunuzla aynı bölgede olmanıza gerek yoktur.",
+    "regionSelectorPlaceholder": "Bölge Seçin",
+    "regionSelectorComingSoon": "Yakında Geliyor",
+    "billingLoadingSubscription": "Abonelik yükleniyor...",
+    "billingFreeTier": "Ücretsiz Dilim",
+    "billingWarningOverLimit": "Uyarı: Bir veya daha fazla kullanım limitini aştınız. Aboneliğinizi değiştirmediğiniz veya kullanımı ayarlamadığınız sürece siteleriniz bağlanmayacaktır.",
+    "billingUsageLimitsOverview": "Kullanım Limitleri Genel Görünümü",
+    "billingMonitorUsage": "Kullanımınızı yapılandırılmış limitlerle karşılaştırın. Limitlerin artırılmasına ihtiyacınız varsa, lütfen support@fossorial.io adresinden bizimle iletişime geçin.",
+    "billingDataUsage": "Veri Kullanımı",
+    "billingOnlineTime": "Site Çevrimiçi Süresi",
+    "billingUsers": "Aktif Kullanıcılar",
+    "billingDomains": "Aktif Alanlar",
+    "billingRemoteExitNodes": "Aktif Öz-Host Düğümleri",
+    "billingNoLimitConfigured": "Hiçbir limit yapılandırılmadı",
+    "billingEstimatedPeriod": "Tahmini Fatura Dönemi",
+    "billingIncludedUsage": "Dahil Kullanım",
+    "billingIncludedUsageDescription": "Mevcut abonelik planınıza bağlı kullanım",
+    "billingFreeTierIncludedUsage": "Ücretsiz dilim kullanım hakları",
+    "billingIncluded": "dahil",
+    "billingEstimatedTotal": "Tahmini Toplam:",
+    "billingNotes": "Notlar",
+    "billingEstimateNote": "Bu, mevcut kullanımınıza dayalı bir tahmindir.",
+    "billingActualChargesMayVary": "Asıl ücretler farklılık gösterebilir.",
+    "billingBilledAtEnd": "Fatura döneminin sonunda fatura düzenlenecektir.",
+    "billingModifySubscription": "Aboneliği Düzenle",
+    "billingStartSubscription": "Aboneliği Başlat",
+    "billingRecurringCharge": "Yinelenen Ücret",
+    "billingManageSubscriptionSettings": "Abonelik ayarlarınızı ve tercihlerinizi yönetin",
+    "billingNoActiveSubscription": "Aktif bir aboneliğiniz yok. Kullanım limitlerini artırmak için aboneliğinizi başlatın.",
+    "billingFailedToLoadSubscription": "Abonelik yüklenemedi",
+    "billingFailedToLoadUsage": "Kullanım yüklenemedi",
+    "billingFailedToGetCheckoutUrl": "Ödeme URL'si alınamadı",
+    "billingPleaseTryAgainLater": "Lütfen daha sonra tekrar deneyin.",
+    "billingCheckoutError": "Ödeme Hatası",
+    "billingFailedToGetPortalUrl": "Portal URL'si alınamadı",
+    "billingPortalError": "Portal Hatası",
+    "billingDataUsageInfo": "Buluta bağlandığınızda, güvenli tünellerinizden aktarılan tüm verilerden ücret alınırsınız. Bu, tüm sitelerinizdeki gelen ve giden trafiği içerir. Limitinize ulaştığınızda, planınızı yükseltmeli veya kullanımı azaltmalısınız, aksi takdirde siteleriniz bağlantıyı keser. Düğümler kullanırken verilerden ücret alınmaz.",
+    "billingOnlineTimeInfo": "Sitelerinizin buluta ne kadar süre bağlı kaldığına göre ücretlendirilirsiniz. Örneğin, 44,640 dakika, bir sitenin 24/7 boyunca tam bir ay boyunca çalışması anlamına gelir. Limitinize ulaştığınızda, planınızı yükseltmeyip kullanımı azaltmazsanız siteleriniz bağlantıyı keser. Düğümler kullanırken zamandan ücret alınmaz.",
+    "billingUsersInfo": "Kuruluşunuzdaki her kullanıcı için ücretlendirilirsiniz. Faturalandırma, hesabınızdaki aktif kullanıcı hesaplarının sayısına göre günlük olarak hesaplanır.",
+    "billingDomainInfo": "Kuruluşunuzdaki her alan adı için ücretlendirilirsiniz. Faturalandırma, hesabınızdaki aktif alan adları hesaplarının sayısına göre günlük olarak hesaplanır.",
+    "billingRemoteExitNodesInfo": "Kuruluşunuzdaki her yönetilen Düğüm için ücretlendirilirsiniz. Faturalandırma, hesabınızdaki aktif yönetilen Düğümler sayısına göre günlük olarak hesaplanır.",
     "domainNotFound": "Alan Adı Bulunamadı",
     "domainNotFoundDescription": "Bu kaynak devre dışıdır çünkü alan adı sistemimizde artık mevcut değil. Bu kaynak için yeni bir alan adı belirleyin.",
     "failed": "Başarısız",
@@ -1320,6 +1363,7 @@
     "createDomainDnsPropagationDescription": "DNS değişikliklerinin internet genelinde yayılması zaman alabilir. DNS sağlayıcınız ve TTL ayarlarına bağlı olarak bu birkaç dakika ile 48 saat arasında değişebilir.",
     "resourcePortRequired": "HTTP dışı kaynaklar için bağlantı noktası numarası gereklidir",
     "resourcePortNotAllowed": "HTTP kaynakları için bağlantı noktası numarası ayarlanmamalı",
+    "billingPricingCalculatorLink": "Fiyat Hesaplayıcı",
     "signUpTerms": {
         "IAgreeToThe": "Kabul ediyorum",
         "termsOfService": "hizmet şartları",
@@ -1368,6 +1412,41 @@
     "addNewTarget": "Yeni Hedef Ekle",
     "targetsList": "Hedefler Listesi",
     "targetErrorDuplicateTargetFound": "Yinelenen hedef bulundu",
+    "healthCheckHealthy": "Sağlıklı",
+    "healthCheckUnhealthy": "Sağlıksız",
+    "healthCheckUnknown": "Bilinmiyor",
+    "healthCheck": "Sağlık Kontrolü",
+    "configureHealthCheck": "Sağlık Kontrolünü Yapılandır",
+    "configureHealthCheckDescription": "{hedef} için sağlık izleme kurun",
+    "enableHealthChecks": "Sağlık Kontrollerini Etkinleştir",
+    "enableHealthChecksDescription": "Bu hedefin sağlığını izleyin. Gerekirse hedef dışındaki bir son noktayı izleyebilirsiniz.",
+    "healthScheme": "Yöntem",
+    "healthSelectScheme": "Yöntem Seç",
+    "healthCheckPath": "Yol",
+    "healthHostname": "IP / Host",
+    "healthPort": "Port",
+    "healthCheckPathDescription": "Sağlık durumunu kontrol etmek için yol.",
+    "healthyIntervalSeconds": "Sağlıklı Aralık",
+    "unhealthyIntervalSeconds": "Sağlıksız Aralık",
+    "IntervalSeconds": "Sağlıklı Aralık",
+    "timeoutSeconds": "Zaman Aşımı",
+    "timeIsInSeconds": "Zaman saniye cinsindendir",
+    "retryAttempts": "Tekrar Deneme Girişimleri",
+    "expectedResponseCodes": "Beklenen Yanıt Kodları",
+    "expectedResponseCodesDescription": "Sağlıklı durumu gösteren HTTP durum kodu. Boş bırakılırsa, 200-300 arası sağlıklı kabul edilir.",
+    "customHeaders": "Özel Başlıklar",
+    "customHeadersDescription": "Başlıklar yeni satırla ayrılmış: Başlık-Adı: değer",
+    "headersValidationError": "Başlıklar şu formatta olmalıdır: Başlık-Adı: değer.",
+    "saveHealthCheck": "Sağlık Kontrolünü Kaydet",
+    "healthCheckSaved": "Sağlık Kontrolü Kaydedildi",
+    "healthCheckSavedDescription": "Sağlık kontrol yapılandırması başarıyla kaydedildi",
+    "healthCheckError": "Sağlık Kontrol Hatası",
+    "healthCheckErrorDescription": "Sağlık kontrol yapılandırması kaydedilirken bir hata oluştu",
+    "healthCheckPathRequired": "Sağlık kontrol yolu gereklidir",
+    "healthCheckMethodRequired": "HTTP yöntemi gereklidir",
+    "healthCheckIntervalMin": "Kontrol aralığı en az 5 saniye olmalıdır",
+    "healthCheckTimeoutMin": "Zaman aşımı en az 1 saniye olmalıdır",
+    "healthCheckRetryMin": "Tekrar deneme girişimleri en az 1 olmalıdır",
     "httpMethod": "HTTP Yöntemi",
     "selectHttpMethod": "HTTP yöntemini seçin",
     "domainPickerSubdomainLabel": "Alt Alan Adı",
@@ -1381,6 +1460,7 @@
     "domainPickerEnterSubdomainToSearch": "Mevcut ücretsiz alan adları arasından aramak ve seçmek için bir alt alan adı girin.",
     "domainPickerFreeDomains": "Ücretsiz Alan Adları",
     "domainPickerSearchForAvailableDomains": "Mevcut alan adlarını ara",
+    "domainPickerNotWorkSelfHosted": "Not: Ücretsiz sağlanan alan adları şu anda öz-host edilmiş örnekler için kullanılabilir değildir.",
     "resourceDomain": "Alan Adı",
     "resourceEditDomain": "Alan Adını Düzenle",
     "siteName": "Site Adı",
@@ -1463,6 +1543,72 @@
     "autoLoginError": "Otomatik Giriş Hatası",
     "autoLoginErrorNoRedirectUrl": "Kimlik sağlayıcıdan yönlendirme URL'si alınamadı.",
     "autoLoginErrorGeneratingUrl": "Kimlik doğrulama URL'si oluşturulamadı.",
+    "remoteExitNodeManageRemoteExitNodes": "Öz-Host Yönetim",
+    "remoteExitNodeDescription": "Ağ bağlantınızı genişletmek için düğümleri yönetin",
+    "remoteExitNodes": "Düğümler",
+    "searchRemoteExitNodes": "Düğüm ara...",
+    "remoteExitNodeAdd": "Düğüm Ekle",
+    "remoteExitNodeErrorDelete": "Düğüm silinirken hata oluştu",
+    "remoteExitNodeQuestionRemove": "{selectedNode} düğümünü organizasyondan kaldırmak istediğinizden emin misiniz?",
+    "remoteExitNodeMessageRemove": "Kaldırıldığında, düğüm artık erişilebilir olmayacaktır.",
+    "remoteExitNodeMessageConfirm": "Onaylamak için lütfen aşağıya düğümün adını yazın.",
+    "remoteExitNodeConfirmDelete": "Düğüm Silmeyi Onayla",
+    "remoteExitNodeDelete": "Düğümü Sil",
+    "sidebarRemoteExitNodes": "Düğümler",
+    "remoteExitNodeCreate": {
+        "title": "Düğüm Oluştur",
+        "description": "Ağ bağlantınızı genişletmek için yeni bir düğüm oluşturun",
+        "viewAllButton": "Tüm Düğümleri Gör",
+        "strategy": {
+            "title": "Oluşturma Stratejisi",
+            "description": "Düğümünüzü manuel olarak yapılandırmak veya yeni kimlik bilgileri oluşturmak için bunu seçin.",
+            "adopt": {
+                "title": "Düğüm Benimse",
+                "description": "Zaten düğüm için kimlik bilgilerine sahipseniz bunu seçin."
+            },
+            "generate": {
+                "title": "Anahtarları Oluştur",
+                "description": "Düğüm için yeni anahtarlar oluşturmak istiyorsanız bunu seçin"
+            }
+        },
+        "adopt": {
+            "title": "Mevcut Düğümü Benimse",
+            "description": "Adayacağınız mevcut düğümün kimlik bilgilerini girin",
+            "nodeIdLabel": "Düğüm ID",
+            "nodeIdDescription": "Adayacağınız mevcut düğümün ID'si",
+            "secretLabel": "Gizli",
+            "secretDescription": "Mevcut düğümün gizli anahtarı",
+            "submitButton": "Düğümü Benimse"
+        },
+        "generate": {
+            "title": "Oluşturulan Kimlik Bilgileri",
+            "description": "Düğümünüzü yapılandırmak için oluşturulan bu kimlik bilgilerini kullanın",
+            "nodeIdTitle": "Düğüm ID",
+            "secretTitle": "Gizli",
+            "saveCredentialsTitle": "Kimlik Bilgilerini Yapılandırmaya Ekle",
+            "saveCredentialsDescription": "Bağlantıyı tamamlamak için bu kimlik bilgilerini öz-host Pangolin düğüm yapılandırma dosyanıza ekleyin.",
+            "submitButton": "Düğüm Oluştur"
+        },
+        "validation": {
+            "adoptRequired": "Mevcut bir düğümü benimserken Düğüm ID ve Gizli anahtar gereklidir"
+        },
+        "errors": {
+            "loadDefaultsFailed": "Varsayılanlar yüklenemedi",
+            "defaultsNotLoaded": "Varsayılanlar yüklenmedi",
+            "createFailed": "Düğüm oluşturulamadı"
+        },
+        "success": {
+            "created": "Düğüm başarıyla oluşturuldu"
+        }
+    },
+    "remoteExitNodeSelection": "Düğüm Seçimi",
+    "remoteExitNodeSelectionDescription": "Yerel site için trafiği yönlendirecek düğümü seçin",
+    "remoteExitNodeRequired": "Yerel siteler için bir düğüm seçilmelidir",
+    "noRemoteExitNodesAvailable": "Düğüm Bulunamadı",
+    "noRemoteExitNodesAvailableDescription": "Bu organizasyon için düğüm mevcut değil. Yerel siteleri kullanmak için önce bir düğüm oluşturun.",
+    "exitNode": "Çıkış Düğümü",
+    "country": "Ülke",
+    "rulesMatchCountry": "Şu anda kaynak IP'ye dayanarak",
     "managedSelfHosted": {
         "title": "Yönetilen Self-Hosted",
         "description": "Daha güvenilir ve düşük bakım gerektiren, ekstra özelliklere sahip kendi kendine barındırabileceğiniz Pangolin sunucusu",
@@ -1501,11 +1647,53 @@
     },
     "internationaldomaindetected": "Uluslararası Alan Adı Tespit Edildi",
     "willbestoredas": "Şu şekilde depolanacak:",
+    "roleMappingDescription": "Otomatik Sağlama etkinleştirildiğinde kullanıcıların oturum açarken rollerin nasıl atandığını belirleyin.",
+    "selectRole": "Bir Rol Seçin",
+    "roleMappingExpression": "İfade",
+    "selectRolePlaceholder": "Bir rol seçin",
+    "selectRoleDescription": "Bu kimlik sağlayıcısından tüm kullanıcılara atanacak bir rol seçin",
+    "roleMappingExpressionDescription": "Rol bilgilerini ID tokeninden çıkarmak için bir JMESPath ifadesi girin",
+    "idpTenantIdRequired": "Kiracı Kimliği gereklidir",
+    "invalidValue": "Geçersiz değer",
+    "idpTypeLabel": "Kimlik Sağlayıcı Türü",
+    "roleMappingExpressionPlaceholder": "örn., contains(gruplar, 'yönetici') && 'Yönetici' || 'Üye'",
+    "idpGoogleConfiguration": "Google Yapılandırması",
+    "idpGoogleConfigurationDescription": "Google OAuth2 kimlik bilgilerinizi yapılandırın",
+    "idpGoogleClientIdDescription": "Google OAuth2 İstemci Kimliğiniz",
+    "idpGoogleClientSecretDescription": "Google OAuth2 İstemci Sırrınız",
+    "idpAzureConfiguration": "Azure Entra ID Yapılandırması",
+    "idpAzureConfigurationDescription": "Azure Entra ID OAuth2 kimlik bilgilerinizi yapılandırın",
+    "idpTenantId": "Kiracı Kimliği",
+    "idpTenantIdPlaceholder": "kiraci-kimliginiz",
+    "idpAzureTenantIdDescription": "Azure kiracı kimliğiniz (Azure Active Directory genel bakışında bulunur)",
+    "idpAzureClientIdDescription": "Azure Uygulama Kaydı İstemci Kimliğiniz",
+    "idpAzureClientSecretDescription": "Azure Uygulama Kaydı İstemci Sırrınız",
+    "idpGoogleTitle": "Google",
+    "idpGoogleAlt": "Google",
+    "idpAzureTitle": "Azure Entra ID",
+    "idpAzureAlt": "Azure",
+    "idpGoogleConfigurationTitle": "Google Yapılandırması",
+    "idpAzureConfigurationTitle": "Azure Entra ID Yapılandırması",
+    "idpTenantIdLabel": "Kiracı Kimliği",
+    "idpAzureClientIdDescription2": "Azure Uygulama Kaydı İstemci Kimliğiniz",
+    "idpAzureClientSecretDescription2": "Azure Uygulama Kaydı İstemci Sırrınız",
     "idpGoogleDescription": "Google OAuth2/OIDC sağlayıcısı",
     "idpAzureDescription": "Microsoft Azure OAuth2/OIDC sağlayıcısı",
-    "customHeaders": "Özel Başlıklar",
-    "customHeadersDescription": "Add custom headers to be sent when proxying requests. One per line in the format Header-Name: value",
-    "headersValidationError": "Başlıklar şu formatta olmalıdır: Başlık-Adı: değer.",
+    "subnet": "Alt ağ",
+    "subnetDescription": "Bu organizasyonun ağ yapılandırması için alt ağ.",
+    "authPage": "Yetkilendirme Sayfası",
+    "authPageDescription": "Kuruluşunuz için yetkilendirme sayfasını yapılandırın",
+    "authPageDomain": "Yetkilendirme Sayfası Alanı",
+    "noDomainSet": "Alan belirlenmedi",
+    "changeDomain": "Alanı Değiştir",
+    "selectDomain": "Alan Seçin",
+    "restartCertificate": "Sertifikayı Yenile",
+    "editAuthPageDomain": "Yetkilendirme Sayfası Alanını Düzenle",
+    "setAuthPageDomain": "Yetkilendirme Sayfası Alanını Ayarla",
+    "failedToFetchCertificate": "Sertifika getirilemedi",
+    "failedToRestartCertificate": "Sertifika yeniden başlatılamadı",
+    "addDomainToEnableCustomAuthPages": "Kuruluşunuz için özel kimlik doğrulama sayfalarını etkinleştirmek için bir alan ekleyin",
+    "selectDomainForOrgAuthPage": "Kuruluşun kimlik doğrulama sayfası için bir alan seçin",
     "domainPickerProvidedDomain": "Sağlanan Alan Adı",
     "domainPickerFreeProvidedDomain": "Ücretsiz Sağlanan Alan Adı",
     "domainPickerVerified": "Doğrulandı",
@@ -1519,10 +1707,16 @@
     "domainPickerInvalidSubdomainCannotMakeValid": "\"{sub}\" {domain} için geçerli yapılamadı.",
     "domainPickerSubdomainSanitized": "Alt alan adı temizlendi",
     "domainPickerSubdomainCorrected": "\"{sub}\" \"{sanitized}\" olarak düzeltildi",
+    "orgAuthSignInTitle": "Kuruluşunuza giriş yapın",
+    "orgAuthChooseIdpDescription": "Devam etmek için kimlik sağlayıcınızı seçin",
+    "orgAuthNoIdpConfigured": "Bu kuruluşta yapılandırılmış kimlik sağlayıcı yok. Bunun yerine Pangolin kimliğinizle giriş yapabilirsiniz.",
+    "orgAuthSignInWithPangolin": "Pangolin ile Giriş Yap",
+    "subscriptionRequiredToUse": "Bu özelliği kullanmak için abonelik gerekmektedir.",
+    "idpDisabled": "Kimlik sağlayıcılar devre dışı bırakılmıştır.",
+    "orgAuthPageDisabled": "Kuruluş kimlik doğrulama sayfası devre dışı bırakılmıştır.",
+    "domainRestartedDescription": "Alan doğrulaması başarıyla yeniden başlatıldı",
     "resourceAddEntrypointsEditFile": "Dosyayı düzenle: config/traefik/traefik_config.yml",
     "resourceExposePortsEditFile": "Dosyayı düzenle: docker-compose.yml",
     "emailVerificationRequired": "E-posta doğrulaması gereklidir. Bu adımı tamamlamak için lütfen tekrar {dashboardUrl}/auth/login üzerinden oturum açın. Sonra buraya geri dönün.",
-    "twoFactorSetupRequired": "İki faktörlü kimlik doğrulama ayarı gereklidir. Bu adımı tamamlamak için lütfen tekrar {dashboardUrl}/auth/login üzerinden oturum açın. Sonra buraya geri dönün.",
-    "rewritePath": "Rewrite Path",
-    "rewritePathDescription": "Optionally rewrite the path before forwarding to the target."
+    "twoFactorSetupRequired": "İki faktörlü kimlik doğrulama ayarı gereklidir. Bu adımı tamamlamak için lütfen tekrar {dashboardUrl}/auth/login üzerinden oturum açın. Sonra buraya geri dönün."
 }

messages/zh-CN.json

@@ -168,6 +168,9 @@
     "siteSelect": "选择站点",
     "siteSearch": "搜索站点",
     "siteNotFound": "未找到站点。",
+    "selectCountry": "选择国家",
+    "searchCountries": "搜索国家...",
+    "noCountryFound": "找不到国家。",
     "siteSelectionDescription": "此站点将为目标提供连接。",
     "resourceType": "资源类型",
     "resourceTypeDescription": "确定如何访问您的资源",
@@ -595,7 +598,7 @@
     "newtErrorFetchReleases": "无法获取版本信息: {err}",
     "newtErrorFetchLatest": "无法获取最新版信息: {err}",
     "newtEndpoint": "Newt 端点",
-    "newtId": "Newt ID",
+    "newtId": "Newt  ID",
     "newtSecretKey": "Newt 私钥",
     "architecture": "架构",
     "sites": "站点",
@@ -914,8 +917,6 @@
     "idpConnectingToFinished": "已连接",
     "idpErrorConnectingTo": "无法连接到 {name}，请联系管理员协助处理。",
     "idpErrorNotFound": "找不到 IdP",
-    "idpGoogleAlt": "Google",
-    "idpAzureAlt": "Azure",
     "inviteInvalid": "无效邀请",
     "inviteInvalidDescription": "邀请链接无效。",
     "inviteErrorWrongUser": "邀请不是该用户的",
@@ -1155,7 +1156,7 @@
     "containerLabels": "标签",
     "containerLabelsCount": "{count, plural, other {# 标签}}",
     "containerLabelsTitle": "容器标签",
-    "containerLabelEmpty": "<empty>",
+    "containerLabelEmpty": "<为空>",
     "containerPorts": "端口",
     "containerPortsMore": "+{count} 更多",
     "containerActions": "行动",
@@ -1257,6 +1258,48 @@
     "domainPickerSubdomain": "子域：{subdomain}",
     "domainPickerNamespace": "命名空间：{namespace}",
     "domainPickerShowMore": "显示更多",
+    "regionSelectorTitle": "选择区域",
+    "regionSelectorInfo": "选择区域以帮助提升您所在地的性能。您不必与服务器在相同的区域。",
+    "regionSelectorPlaceholder": "选择一个区域",
+    "regionSelectorComingSoon": "即将推出",
+    "billingLoadingSubscription": "正在加载订阅...",
+    "billingFreeTier": "免费层",
+    "billingWarningOverLimit": "警告：您已超出一个或多个使用限制。在您修改订阅或调整使用情况之前，您的站点将无法连接。",
+    "billingUsageLimitsOverview": "使用限制概览",
+    "billingMonitorUsage": "监控您的使用情况以对比已配置的限制。如需提高限制请联系我们 support@fossorial.io。",
+    "billingDataUsage": "数据使用情况",
+    "billingOnlineTime": "站点在线时间",
+    "billingUsers": "活跃用户",
+    "billingDomains": "活跃域",
+    "billingRemoteExitNodes": "活跃自托管节点",
+    "billingNoLimitConfigured": "未配置限制",
+    "billingEstimatedPeriod": "估计结算周期",
+    "billingIncludedUsage": "包含的使用量",
+    "billingIncludedUsageDescription": "您当前订阅计划中包含的使用量",
+    "billingFreeTierIncludedUsage": "免费层使用额度",
+    "billingIncluded": "包含",
+    "billingEstimatedTotal": "预计总额：",
+    "billingNotes": "备注",
+    "billingEstimateNote": "这是根据您当前使用情况的估算。",
+    "billingActualChargesMayVary": "实际费用可能会有变化。",
+    "billingBilledAtEnd": "您将在结算周期结束时被计费。",
+    "billingModifySubscription": "修改订阅",
+    "billingStartSubscription": "开始订阅",
+    "billingRecurringCharge": "周期性收费",
+    "billingManageSubscriptionSettings": "管理您的订阅设置和偏好",
+    "billingNoActiveSubscription": "您没有活跃的订阅。开始订阅以增加使用限制。",
+    "billingFailedToLoadSubscription": "无法加载订阅",
+    "billingFailedToLoadUsage": "无法加载使用情况",
+    "billingFailedToGetCheckoutUrl": "无法获取结账网址",
+    "billingPleaseTryAgainLater": "请稍后再试。",
+    "billingCheckoutError": "结账错误",
+    "billingFailedToGetPortalUrl": "无法获取门户网址",
+    "billingPortalError": "门户错误",
+    "billingDataUsageInfo": "当连接到云端时，您将为通过安全隧道传输的所有数据收取费用。 这包括您所有站点的进出流量。 当您达到上限时，您的站点将断开连接，直到您升级计划或减少使用。使用节点时不收取数据。",
+    "billingOnlineTimeInfo": "您要根据您的网站连接到云端的时间长短收取费用。 例如，44,640分钟等于一个24/7全月运行的网站。 当您达到上限时，您的站点将断开连接，直到您升级计划或减少使用。使用节点时不收取费用。",
+    "billingUsersInfo": "根据您组织中的活跃用户数量收费。按日计算账单。",
+    "billingDomainInfo": "根据组织中活跃域的数量收费。按日计算账单。",
+    "billingRemoteExitNodesInfo": "根据您组织中已管理节点的数量收费。按日计算账单。",
     "domainNotFound": "域未找到",
     "domainNotFoundDescription": "此资源已禁用，因为该域不再在我们的系统中存在。请为此资源设置一个新域。",
     "failed": "失败",
@@ -1320,6 +1363,7 @@
     "createDomainDnsPropagationDescription": "DNS 更改可能需要一些时间才能在互联网上传播。这可能需要从几分钟到 48 小时，具体取决于您的 DNS 提供商和 TTL 设置。",
     "resourcePortRequired": "非 HTTP 资源必须输入端口号",
     "resourcePortNotAllowed": "HTTP 资源不应设置端口号",
+    "billingPricingCalculatorLink": "价格计算器",
     "signUpTerms": {
         "IAgreeToThe": "我同意",
         "termsOfService": "服务条款",
@@ -1346,7 +1390,7 @@
     "clientOlmCredentials": "Olm 凭据",
     "clientOlmCredentialsDescription": "这是 Olm 服务器的身份验证方式",
     "olmEndpoint": "Olm 端点",
-    "olmId": "Olm ID",
+    "olmId": "Olm  ID",
     "olmSecretKey": "Olm 私钥",
     "clientCredentialsSave": "保存您的凭据",
     "clientCredentialsSaveDescription": "该信息仅会显示一次，请确保将其复制到安全位置。",
@@ -1368,6 +1412,41 @@
     "addNewTarget": "添加新目标",
     "targetsList": "目标列表",
     "targetErrorDuplicateTargetFound": "找到重复的目标",
+    "healthCheckHealthy": "正常",
+    "healthCheckUnhealthy": "不正常",
+    "healthCheckUnknown": "未知",
+    "healthCheck": "健康检查",
+    "configureHealthCheck": "配置健康检查",
+    "configureHealthCheckDescription": "为 {target} 设置健康监控",
+    "enableHealthChecks": "启用健康检查",
+    "enableHealthChecksDescription": "监视此目标的健康状况。如果需要，您可以监视一个不同的终点。",
+    "healthScheme": "方法",
+    "healthSelectScheme": "选择方法",
+    "healthCheckPath": "路径",
+    "healthHostname": "IP / 主机",
+    "healthPort": "端口",
+    "healthCheckPathDescription": "用于检查健康状态的路径。",
+    "healthyIntervalSeconds": "正常间隔",
+    "unhealthyIntervalSeconds": "不正常间隔",
+    "IntervalSeconds": "正常间隔",
+    "timeoutSeconds": "超时",
+    "timeIsInSeconds": "时间以秒为单位",
+    "retryAttempts": "重试次数",
+    "expectedResponseCodes": "期望响应代码",
+    "expectedResponseCodesDescription": "HTTP 状态码表示健康状态。如留空，200-300 被视为健康。",
+    "customHeaders": "自定义标题",
+    "customHeadersDescription": "头部新行分隔：头部名称：值",
+    "headersValidationError": "头部必须是格式：头部名称：值。",
+    "saveHealthCheck": "保存健康检查",
+    "healthCheckSaved": "健康检查已保存",
+    "healthCheckSavedDescription": "健康检查配置已成功保存。",
+    "healthCheckError": "健康检查错误",
+    "healthCheckErrorDescription": "保存健康检查配置时出错",
+    "healthCheckPathRequired": "健康检查路径为必填项",
+    "healthCheckMethodRequired": "HTTP 方法为必填项",
+    "healthCheckIntervalMin": "检查间隔必须至少为 5 秒",
+    "healthCheckTimeoutMin": "超时必须至少为 1 秒",
+    "healthCheckRetryMin": "重试次数必须至少为 1 次",
     "httpMethod": "HTTP 方法",
     "selectHttpMethod": "选择 HTTP 方法",
     "domainPickerSubdomainLabel": "子域名",
@@ -1381,6 +1460,7 @@
     "domainPickerEnterSubdomainToSearch": "输入一个子域名以搜索并从可用免费域名中选择。",
     "domainPickerFreeDomains": "免费域名",
     "domainPickerSearchForAvailableDomains": "搜索可用域名",
+    "domainPickerNotWorkSelfHosted": "注意：自托管实例当前不提供免费的域名。",
     "resourceDomain": "域名",
     "resourceEditDomain": "编辑域名",
     "siteName": "站点名称",
@@ -1463,6 +1543,72 @@
     "autoLoginError": "自动登录错误",
     "autoLoginErrorNoRedirectUrl": "未从身份提供商收到重定向URL。",
     "autoLoginErrorGeneratingUrl": "生成身份验证URL失败。",
+    "remoteExitNodeManageRemoteExitNodes": "管理自托管",
+    "remoteExitNodeDescription": "管理节点以扩展您的网络连接",
+    "remoteExitNodes": "Nodes",
+    "searchRemoteExitNodes": "搜索节点...",
+    "remoteExitNodeAdd": "添加节点",
+    "remoteExitNodeErrorDelete": "删除节点时出错",
+    "remoteExitNodeQuestionRemove": "您确定要从组织中删除 {selectedNode} 节点吗？",
+    "remoteExitNodeMessageRemove": "一旦删除，该节点将不再能够访问。",
+    "remoteExitNodeMessageConfirm": "要确认，请输入以下节点的名称。",
+    "remoteExitNodeConfirmDelete": "确认删除节点",
+    "remoteExitNodeDelete": "删除节点",
+    "sidebarRemoteExitNodes": "Nodes",
+    "remoteExitNodeCreate": {
+        "title": "创建节点",
+        "description": "创建一个新节点来扩展您的网络连接",
+        "viewAllButton": "查看所有节点",
+        "strategy": {
+            "title": "创建策略",
+            "description": "选择此选项以手动配置您的节点或生成新凭据。",
+            "adopt": {
+                "title": "采纳节点",
+                "description": "如果您已经拥有该节点的凭据，请选择此项。"
+            },
+            "generate": {
+                "title": "生成密钥",
+                "description": "如果您想为节点生成新密钥，请选择此选项"
+            }
+        },
+        "adopt": {
+            "title": "采纳现有节点",
+            "description": "输入您想要采用的现有节点的凭据",
+            "nodeIdLabel": "节点 ID",
+            "nodeIdDescription": "您想要采用的现有节点的 ID",
+            "secretLabel": "密钥",
+            "secretDescription": "现有节点的秘密密钥",
+            "submitButton": "采用节点"
+        },
+        "generate": {
+            "title": "生成的凭据",
+            "description": "使用这些生成的凭据来配置您的节点",
+            "nodeIdTitle": "节点 ID",
+            "secretTitle": "密钥",
+            "saveCredentialsTitle": "将凭据添加到配置中",
+            "saveCredentialsDescription": "将这些凭据添加到您的自托管 Pangolin 节点配置文件中以完成连接。",
+            "submitButton": "创建节点"
+        },
+        "validation": {
+            "adoptRequired": "在通过现有节点时需要节点ID和密钥"
+        },
+        "errors": {
+            "loadDefaultsFailed": "无法加载默认值",
+            "defaultsNotLoaded": "默认值未加载",
+            "createFailed": "创建节点失败"
+        },
+        "success": {
+            "created": "节点创建成功"
+        }
+    },
+    "remoteExitNodeSelection": "节点选择",
+    "remoteExitNodeSelectionDescription": "为此本地站点选择要路由流量的节点",
+    "remoteExitNodeRequired": "必须为本地站点选择节点",
+    "noRemoteExitNodesAvailable": "无可用节点",
+    "noRemoteExitNodesAvailableDescription": "此组织没有可用的节点。首先创建一个节点来使用本地站点。",
+    "exitNode": "出口节点",
+    "country": "国家",
+    "rulesMatchCountry": "当前基于源 IP",
     "managedSelfHosted": {
         "title": "托管自托管",
         "description": "更可靠和低维护自我托管的 Pangolin 服务器，带有额外的铃声和告密器",
@@ -1501,11 +1647,53 @@
     },
     "internationaldomaindetected": "检测到国际域",
     "willbestoredas": "储存为：",
+    "roleMappingDescription": "确定当用户启用自动配送时如何分配他们的角色。",
+    "selectRole": "选择角色",
+    "roleMappingExpression": "表达式",
+    "selectRolePlaceholder": "选择角色",
+    "selectRoleDescription": "选择一个角色，从此身份提供商分配给所有用户",
+    "roleMappingExpressionDescription": "输入一个 JMESPath 表达式来从 ID 令牌提取角色信息",
+    "idpTenantIdRequired": "租户ID是必需的",
+    "invalidValue": "无效的值",
+    "idpTypeLabel": "身份提供者类型",
+    "roleMappingExpressionPlaceholder": "例如: contains(group, 'admin' &'Admin' || 'Member'",
+    "idpGoogleConfiguration": "Google 配置",
+    "idpGoogleConfigurationDescription": "配置您的 Google OAuth2 凭据",
+    "idpGoogleClientIdDescription": "您的 Google OAuth2 客户端 ID",
+    "idpGoogleClientSecretDescription": "您的 Google OAuth2 客户端密钥",
+    "idpAzureConfiguration": "Azure Entra ID 配置",
+    "idpAzureConfigurationDescription": "配置您的 Azure Entra ID OAuth2 凭据",
+    "idpTenantId": "Tenant ID",
+    "idpTenantIdPlaceholder": "您的租户ID",
+    "idpAzureTenantIdDescription": "您的 Azure 租户ID (在 Azure Active Directory 概览中发现)",
+    "idpAzureClientIdDescription": "您的 Azure 应用程序注册客户端 ID",
+    "idpAzureClientSecretDescription": "您的 Azure 应用程序注册客户端密钥",
+    "idpGoogleTitle": "Google",
+    "idpGoogleAlt": "Google",
+    "idpAzureTitle": "Azure Entra ID",
+    "idpAzureAlt": "Azure",
+    "idpGoogleConfigurationTitle": "Google 配置",
+    "idpAzureConfigurationTitle": "Azure Entra ID 配置",
+    "idpTenantIdLabel": "Tenant ID",
+    "idpAzureClientIdDescription2": "您的 Azure 应用程序注册客户端 ID",
+    "idpAzureClientSecretDescription2": "您的 Azure 应用程序注册客户端密钥",
     "idpGoogleDescription": "Google OAuth2/OIDC 提供商",
     "idpAzureDescription": "Microsoft Azure OAuth2/OIDC provider",
-    "customHeaders": "自定义标题",
-    "customHeadersDescription": "Add custom headers to be sent when proxying requests. One per line in the format Header-Name: value",
-    "headersValidationError": "头部必须是格式：头部名称：值。",
+    "subnet": "子网",
+    "subnetDescription": "此组织网络配置的子网。",
+    "authPage": "认证页面",
+    "authPageDescription": "配置您的组织认证页面",
+    "authPageDomain": "认证页面域",
+    "noDomainSet": "没有域设置",
+    "changeDomain": "更改域",
+    "selectDomain": "选择域",
+    "restartCertificate": "重新启动证书",
+    "editAuthPageDomain": "编辑认证页面域",
+    "setAuthPageDomain": "设置认证页面域",
+    "failedToFetchCertificate": "获取证书失败",
+    "failedToRestartCertificate": "重新启动证书失败",
+    "addDomainToEnableCustomAuthPages": "为您的组织添加域名以启用自定义认证页面",
+    "selectDomainForOrgAuthPage": "选择组织认证页面的域",
     "domainPickerProvidedDomain": "提供的域",
     "domainPickerFreeProvidedDomain": "免费提供的域",
     "domainPickerVerified": "已验证",
@@ -1519,10 +1707,16 @@
     "domainPickerInvalidSubdomainCannotMakeValid": "\"{sub}\" 无法为 {domain} 变为有效。",
     "domainPickerSubdomainSanitized": "子域已净化",
     "domainPickerSubdomainCorrected": "\"{sub}\" 已被更正为 \"{sanitized}\"",
+    "orgAuthSignInTitle": "登录到您的组织",
+    "orgAuthChooseIdpDescription": "选择您的身份提供商以继续",
+    "orgAuthNoIdpConfigured": "此机构没有配置任何身份提供者。您可以使用您的 Pangolin 身份登录。",
+    "orgAuthSignInWithPangolin": "使用 Pangolin 登录",
+    "subscriptionRequiredToUse": "需要订阅才能使用此功能。",
+    "idpDisabled": "身份提供者已禁用。",
+    "orgAuthPageDisabled": "组织认证页面已禁用。",
+    "domainRestartedDescription": "域验证重新启动成功",
     "resourceAddEntrypointsEditFile": "编辑文件：config/traefik/traefik_config.yml",
     "resourceExposePortsEditFile": "编辑文件：docker-compose.yml",
     "emailVerificationRequired": "需要电子邮件验证。 请通过 {dashboardUrl}/auth/login 再次登录以完成此步骤。 然后，回到这里。",
-    "twoFactorSetupRequired": "需要设置双因素身份验证。 请通过 {dashboardUrl}/auth/login 再次登录以完成此步骤。 然后，回到这里。",
-    "rewritePath": "Rewrite Path",
-    "rewritePathDescription": "Optionally rewrite the path before forwarding to the target."
+    "twoFactorSetupRequired": "需要设置双因素身份验证。 请通过 {dashboardUrl}/auth/login 再次登录以完成此步骤。 然后，回到这里。"
 }

package.json

@@ -19,14 +19,21 @@
         "db:sqlite:studio": "drizzle-kit studio --config=./drizzle.sqlite.config.ts",
         "db:pg:studio": "drizzle-kit studio --config=./drizzle.pg.config.ts",
         "db:clear-migrations": "rm -rf server/migrations",
+        "set:oss": "echo 'export const build = \"oss\" as any;' > server/build.ts",
+        "set:saas": "echo 'export const build = \"saas\" as any;' > server/build.ts",
+        "set:enterprise": "echo 'export const build = \"enterprise\" as any;' > server/build.ts",
+        "set:sqlite": "echo 'export * from \"./sqlite\";' > server/db/index.ts",
+        "set:pg": "echo 'export * from \"./pg\";' > server/db/index.ts",
         "build:sqlite": "mkdir -p dist && next build && node esbuild.mjs -e server/index.ts -o dist/server.mjs && node esbuild.mjs -e server/setup/migrationsSqlite.ts -o dist/migrations.mjs",
         "build:pg": "mkdir -p dist && next build && node esbuild.mjs -e server/index.ts -o dist/server.mjs && node esbuild.mjs -e server/setup/migrationsPg.ts -o dist/migrations.mjs",
         "start": "ENVIRONMENT=prod node dist/migrations.mjs && ENVIRONMENT=prod NODE_ENV=development node --enable-source-maps dist/server.mjs",
         "email": "email dev --dir server/emails/templates --port 3005",
-        "build:cli": "node esbuild.mjs -e cli/index.ts -o dist/cli.mjs"
+        "build:cli": "node esbuild.mjs -e cli/index.ts -o dist/cli.mjs",
+        "db:sqlite:seed-exit-node": "sqlite3 config/db/db.sqlite \"INSERT INTO exitNodes (exitNodeId, name, address, endpoint, publicKey, listenPort, reachableAt, maxConnections, online, lastPing, type, region) VALUES (null, 'test', '10.0.0.1/24', 'localhost', 'MJ44MpnWGxMZURgxW/fWXDFsejhabnEFYDo60LQwK3A=', 1234, 'http://localhost:3003', 123, 1, null, 'gerbil', null);\""
     },
     "dependencies": {
         "@asteasolutions/zod-to-openapi": "^7.3.4",
+        "@aws-sdk/client-s3": "3.837.0",
         "@hookform/resolvers": "5.2.2",
         "@node-rs/argon2": "^2.0.2",
         "@oslojs/crypto": "1.0.1",
@@ -78,10 +85,12 @@
         "http-errors": "2.0.0",
         "i": "^0.3.7",
         "input-otp": "1.4.2",
+        "ioredis": "5.6.1",
         "jmespath": "^0.16.0",
         "js-yaml": "4.1.0",
         "jsonwebtoken": "^9.0.2",
         "lucide-react": "^0.544.0",
+        "maxmind": "5.0.0",
         "moment": "2.30.1",
         "next": "15.5.3",
         "next-intl": "^4.3.9",
@@ -100,7 +109,10 @@
         "react-hook-form": "7.62.0",
         "react-icons": "^5.5.0",
         "rebuild": "0.1.2",
+        "reodotdev": "^1.0.0",
+        "resend": "^6.1.1",
         "semver": "^7.7.2",
+        "stripe": "18.2.1",
         "swagger-ui-express": "^5.0.1",
         "tailwind-merge": "3.3.1",
         "tw-animate-css": "^1.3.8",
@@ -116,6 +128,7 @@
     "devDependencies": {
         "@dotenvx/dotenvx": "1.51.0",
         "@esbuild-plugins/tsconfig-paths": "0.1.2",
+        "@react-email/preview-server": "4.1.0",
         "@tailwindcss/postcss": "^4.1.13",
         "@types/better-sqlite3": "7.6.12",
         "@types/cookie-parser": "1.4.9",

server/apiServer.ts

@@ -7,16 +7,20 @@ import {
     errorHandlerMiddleware,
     notFoundMiddleware
 } from "@server/middlewares";
+import { corsWithLoginPageSupport } from "@server/middlewares/private/corsWithLoginPage";
 import { authenticated, unauthenticated } from "@server/routers/external";
 import { router as wsRouter, handleWSUpgrade } from "@server/routers/ws";
 import { logIncomingMiddleware } from "./middlewares/logIncoming";
 import { csrfProtectionMiddleware } from "./middlewares/csrfProtection";
 import helmet from "helmet";
+import { stripeWebhookHandler } from "@server/routers/private/billing/webhooks";
+import { build } from "./build";
 import rateLimit, { ipKeyGenerator } from "express-rate-limit";
 import createHttpError from "http-errors";
 import HttpCode from "./types/HttpCode";
 import requestTimeoutMiddleware from "./middlewares/requestTimeout";
-import { createStore } from "./lib/rateLimitStore";
+import { createStore } from "@server/lib/private/rateLimitStore";
+import hybridRouter from "@server/routers/private/hybrid";
 
 const dev = config.isDev;
 const externalPort = config.getRawConfig().server.external_port;
@@ -30,26 +34,39 @@ export function createApiServer() {
         apiServer.set("trust proxy", trustProxy);
     }
 
+    if (build == "saas") {
+        apiServer.post(
+            `${prefix}/billing/webhooks`,
+            express.raw({ type: "application/json" }),
+            stripeWebhookHandler
+        );
+    }
+
     const corsConfig = config.getRawConfig().server.cors;
 
-    const options = {
-        ...(corsConfig?.origins
-            ? { origin: corsConfig.origins }
-            : {
-                  origin: (origin: any, callback: any) => {
-                      callback(null, true);
-                  }
-              }),
-        ...(corsConfig?.methods && { methods: corsConfig.methods }),
-        ...(corsConfig?.allowed_headers && {
-            allowedHeaders: corsConfig.allowed_headers
-        }),
-        credentials: !(corsConfig?.credentials === false)
-    };
+    if (build == "oss") {
+        const options = {
+            ...(corsConfig?.origins
+                ? { origin: corsConfig.origins }
+                : {
+                      origin: (origin: any, callback: any) => {
+                          callback(null, true);
+                      }
+                  }),
+            ...(corsConfig?.methods && { methods: corsConfig.methods }),
+            ...(corsConfig?.allowed_headers && {
+                allowedHeaders: corsConfig.allowed_headers
+            }),
+            credentials: !(corsConfig?.credentials === false)
+        };
 
-    logger.debug("Using CORS options", options);
+        logger.debug("Using CORS options", options);
 
-    apiServer.use(cors(options));
+        apiServer.use(cors(options));
+    } else {
+        // Use the custom CORS middleware with loginPage support
+        apiServer.use(corsWithLoginPageSupport(corsConfig));
+    }
 
     if (!dev) {
         apiServer.use(helmet());
@@ -70,7 +87,8 @@ export function createApiServer() {
                     60 *
                     1000,
                 max: config.getRawConfig().rate_limits.global.max_requests,
-                keyGenerator: (req) => `apiServerGlobal:${ipKeyGenerator(req.ip || "")}:${req.path}`,
+                keyGenerator: (req) =>
+                    `apiServerGlobal:${ipKeyGenerator(req.ip || "")}:${req.path}`,
                 handler: (req, res, next) => {
                     const message = `Rate limit exceeded. You can make ${config.getRawConfig().rate_limits.global.max_requests} requests every ${config.getRawConfig().rate_limits.global.window_minutes} minute(s).`;
                     return next(
@@ -85,6 +103,9 @@ export function createApiServer() {
     // API routes
     apiServer.use(logIncomingMiddleware);
     apiServer.use(prefix, unauthenticated);
+    if (build !== "oss") {
+        apiServer.use(`${prefix}/hybrid`, hybridRouter);
+    }
     apiServer.use(prefix, authenticated);
 
     // WebSocket routes

server/auth/actions.ts

@@ -4,6 +4,7 @@ import { userActions, roleActions, userOrgs } from "@server/db";
 import { and, eq } from "drizzle-orm";
 import createHttpError from "http-errors";
 import HttpCode from "@server/types/HttpCode";
+import { sendUsageNotification } from "@server/routers/org";
 
 export enum ActionsEnum {
     createOrgUser = "createOrgUser",
@@ -98,10 +99,23 @@ export enum ActionsEnum {
     listApiKeyActions = "listApiKeyActions",
     listApiKeys = "listApiKeys",
     getApiKey = "getApiKey",
+    getCertificate = "getCertificate",
+    restartCertificate = "restartCertificate",
+    billing = "billing",
     createOrgDomain = "createOrgDomain",
     deleteOrgDomain = "deleteOrgDomain",
     restartOrgDomain = "restartOrgDomain",
+    sendUsageNotification = "sendUsageNotification",
+    createRemoteExitNode = "createRemoteExitNode",
+    updateRemoteExitNode = "updateRemoteExitNode",
+    getRemoteExitNode = "getRemoteExitNode",
+    listRemoteExitNode = "listRemoteExitNode",
+    deleteRemoteExitNode = "deleteRemoteExitNode",
     updateOrgUser = "updateOrgUser",
+    createLoginPage = "createLoginPage",
+    updateLoginPage = "updateLoginPage",
+    getLoginPage = "getLoginPage",
+    deleteLoginPage = "deleteLoginPage",
     applyBlueprint = "applyBlueprint"
 }
 

server/auth/sessions/app.ts

@@ -3,13 +3,7 @@ import {
     encodeHexLowerCase
 } from "@oslojs/encoding";
 import { sha256 } from "@oslojs/crypto/sha2";
-import {
-    resourceSessions,
-    Session,
-    sessions,
-    User,
-    users
-} from "@server/db";
+import { resourceSessions, Session, sessions, User, users } from "@server/db";
 import { db } from "@server/db";
 import { eq, inArray } from "drizzle-orm";
 import config from "@server/lib/config";
@@ -24,8 +18,9 @@ export const SESSION_COOKIE_EXPIRES =
     60 *
     60 *
     config.getRawConfig().server.dashboard_session_length_hours;
-export const COOKIE_DOMAIN = config.getRawConfig().app.dashboard_url ?
-    "." + new URL(config.getRawConfig().app.dashboard_url!).hostname : undefined;
+export const COOKIE_DOMAIN = config.getRawConfig().app.dashboard_url
+    ? new URL(config.getRawConfig().app.dashboard_url!).hostname
+    : undefined;
 
 export function generateSessionToken(): string {
     const bytes = new Uint8Array(20);
@@ -98,8 +93,8 @@ export async function invalidateSession(sessionId: string): Promise<void> {
     try {
         await db.transaction(async (trx) => {
             await trx
-            .delete(resourceSessions)
-            .where(eq(resourceSessions.userSessionId, sessionId));
+                .delete(resourceSessions)
+                .where(eq(resourceSessions.userSessionId, sessionId));
             await trx.delete(sessions).where(eq(sessions.sessionId, sessionId));
         });
     } catch (e) {
@@ -111,9 +106,9 @@ export async function invalidateAllSessions(userId: string): Promise<void> {
     try {
         await db.transaction(async (trx) => {
             const userSessions = await trx
-            .select()
-            .from(sessions)
-            .where(eq(sessions.userId, userId));
+                .select()
+                .from(sessions)
+                .where(eq(sessions.userId, userId));
             await trx.delete(resourceSessions).where(
                 inArray(
                     resourceSessions.userSessionId,

server/auth/sessions/privateRemoteExitNode.ts

@@ -0,0 +1,85 @@
+/*
+ * This file is part of a proprietary work.
+ *
+ * Copyright (c) 2025 Fossorial, Inc.
+ * All rights reserved.
+ *
+ * This file is licensed under the Fossorial Commercial License.
+ * You may not use this file except in compliance with the License.
+ * Unauthorized use, copying, modification, or distribution is strictly prohibited.
+ *
+ * This file is not licensed under the AGPLv3.
+ */
+
+import {
+    encodeHexLowerCase,
+} from "@oslojs/encoding";
+import { sha256 } from "@oslojs/crypto/sha2";
+import { RemoteExitNode, remoteExitNodes, remoteExitNodeSessions, RemoteExitNodeSession } from "@server/db";
+import { db } from "@server/db";
+import { eq } from "drizzle-orm";
+
+export const EXPIRES = 1000 * 60 * 60 * 24 * 30;
+
+export async function createRemoteExitNodeSession(
+    token: string,
+    remoteExitNodeId: string,
+): Promise<RemoteExitNodeSession> {
+    const sessionId = encodeHexLowerCase(
+        sha256(new TextEncoder().encode(token)),
+    );
+    const session: RemoteExitNodeSession = {
+        sessionId: sessionId,
+        remoteExitNodeId,
+        expiresAt: new Date(Date.now() + EXPIRES).getTime(),
+    };
+    await db.insert(remoteExitNodeSessions).values(session);
+    return session;
+}
+
+export async function validateRemoteExitNodeSessionToken(
+    token: string,
+): Promise<SessionValidationResult> {
+    const sessionId = encodeHexLowerCase(
+        sha256(new TextEncoder().encode(token)),
+    );
+    const result = await db
+        .select({ remoteExitNode: remoteExitNodes, session: remoteExitNodeSessions })
+        .from(remoteExitNodeSessions)
+        .innerJoin(remoteExitNodes, eq(remoteExitNodeSessions.remoteExitNodeId, remoteExitNodes.remoteExitNodeId))
+        .where(eq(remoteExitNodeSessions.sessionId, sessionId));
+    if (result.length < 1) {
+        return { session: null, remoteExitNode: null };
+    }
+    const { remoteExitNode, session } = result[0];
+    if (Date.now() >= session.expiresAt) {
+        await db
+            .delete(remoteExitNodeSessions)
+            .where(eq(remoteExitNodeSessions.sessionId, session.sessionId));
+        return { session: null, remoteExitNode: null };
+    }
+    if (Date.now() >= session.expiresAt - (EXPIRES / 2)) {
+        session.expiresAt = new Date(
+            Date.now() + EXPIRES,
+        ).getTime();
+        await db
+            .update(remoteExitNodeSessions)
+            .set({
+                expiresAt: session.expiresAt,
+            })
+            .where(eq(remoteExitNodeSessions.sessionId, session.sessionId));
+    }
+    return { session, remoteExitNode };
+}
+
+export async function invalidateRemoteExitNodeSession(sessionId: string): Promise<void> {
+    await db.delete(remoteExitNodeSessions).where(eq(remoteExitNodeSessions.sessionId, sessionId));
+}
+
+export async function invalidateAllRemoteExitNodeSessions(remoteExitNodeId: string): Promise<void> {
+    await db.delete(remoteExitNodeSessions).where(eq(remoteExitNodeSessions.remoteExitNodeId, remoteExitNodeId));
+}
+
+export type SessionValidationResult =
+    | { session: RemoteExitNodeSession; remoteExitNode: RemoteExitNode }
+    | { session: null; remoteExitNode: null };

server/auth/sessions/resource.ts

@@ -199,14 +199,14 @@ export function serializeResourceSessionCookie(
     const now = new Date().getTime();
     if (!isHttp) {
         if (expiresAt === undefined) {
-            return `${cookieName}_s.${now}=${token}; HttpOnly; SameSite=Lax; Path=/; Secure; Domain=${"." + domain}`;
+            return `${cookieName}_s.${now}=${token}; HttpOnly; SameSite=Lax; Path=/; Secure; Domain=${domain}`;
         }
-        return `${cookieName}_s.${now}=${token}; HttpOnly; SameSite=Lax; Expires=${expiresAt.toUTCString()}; Path=/; Secure; Domain=${"." + domain}`;
+        return `${cookieName}_s.${now}=${token}; HttpOnly; SameSite=Lax; Expires=${expiresAt.toUTCString()}; Path=/; Secure; Domain=${domain}`;
     } else {
         if (expiresAt === undefined) {
-            return `${cookieName}.${now}=${token}; HttpOnly; SameSite=Lax; Path=/; Domain=${"." + domain}`;
+            return `${cookieName}.${now}=${token}; HttpOnly; SameSite=Lax; Path=/; Domain=$domain}`;
         }
-        return `${cookieName}.${now}=${token}; HttpOnly; SameSite=Lax; Expires=${expiresAt.toUTCString()}; Path=/; Domain=${"." + domain}`;
+        return `${cookieName}.${now}=${token}; HttpOnly; SameSite=Lax; Expires=${expiresAt.toUTCString()}; Path=/; Domain=${domain}`;
     }
 }
 
@@ -216,9 +216,9 @@ export function createBlankResourceSessionTokenCookie(
     isHttp: boolean = false
 ): string {
     if (!isHttp) {
-        return `${cookieName}_s=; HttpOnly; SameSite=Lax; Max-Age=0; Path=/; Secure; Domain=${"." + domain}`;
+        return `${cookieName}_s=; HttpOnly; SameSite=Lax; Max-Age=0; Path=/; Secure; Domain=${domain}`;
     } else {
-        return `${cookieName}=; HttpOnly; SameSite=Lax; Max-Age=0; Path=/; Domain=${"." + domain}`;
+        return `${cookieName}=; HttpOnly; SameSite=Lax; Max-Age=0; Path=/; Domain=${domain}`;
     }
 }
 

server/build.ts

@@ -1 +0,0 @@
-export const build = "oss" as any;

server/db/maxmind.ts

@@ -0,0 +1,13 @@
+import maxmind, { CountryResponse, Reader } from "maxmind";
+import config from "@server/lib/config";
+
+let maxmindLookup: Reader<CountryResponse> | null;
+if (config.getRawConfig().server.maxmind_db_path) {
+    maxmindLookup = await maxmind.open<CountryResponse>(
+        config.getRawConfig().server.maxmind_db_path!
+    );
+} else {
+    maxmindLookup = null;
+}
+
+export { maxmindLookup };

server/db/pg/driver.ts

@@ -39,7 +39,7 @@ function createDb() {
         connectionString,
         max: 20,
         idleTimeoutMillis: 30000,
-        connectionTimeoutMillis: 2000,
+        connectionTimeoutMillis: 5000,
     });
 
     const replicas = [];
@@ -52,7 +52,7 @@ function createDb() {
                 connectionString: conn.connection_string,
                 max: 10,
                 idleTimeoutMillis: 30000,
-                connectionTimeoutMillis: 2000,
+                connectionTimeoutMillis: 5000,
             });
             replicas.push(DrizzlePostgres(replicaPool));
         }

server/db/pg/index.ts

@@ -1,2 +1,3 @@
 export * from "./driver";
-export * from "./schema";
+export * from "./schema";
+export * from "./privateSchema";

server/db/pg/privateSchema.ts

@@ -0,0 +1,245 @@
+/*
+ * This file is part of a proprietary work.
+ *
+ * Copyright (c) 2025 Fossorial, Inc.
+ * All rights reserved.
+ *
+ * This file is licensed under the Fossorial Commercial License.
+ * You may not use this file except in compliance with the License.
+ * Unauthorized use, copying, modification, or distribution is strictly prohibited.
+ *
+ * This file is not licensed under the AGPLv3.
+ */
+
+import {
+    pgTable,
+    serial,
+    varchar,
+    boolean,
+    integer,
+    bigint,
+    real,
+    text
+} from "drizzle-orm/pg-core";
+import { InferSelectModel } from "drizzle-orm";
+import { domains, orgs, targets, users, exitNodes, sessions } from "./schema";
+
+export const certificates = pgTable("certificates", {
+    certId: serial("certId").primaryKey(),
+    domain: varchar("domain", { length: 255 }).notNull().unique(),
+    domainId: varchar("domainId").references(() => domains.domainId, {
+        onDelete: "cascade"
+    }),
+    wildcard: boolean("wildcard").default(false),
+    status: varchar("status", { length: 50 }).notNull().default("pending"), // pending, requested, valid, expired, failed
+    expiresAt: bigint("expiresAt", { mode: "number" }),
+    lastRenewalAttempt: bigint("lastRenewalAttempt", { mode: "number" }),
+    createdAt: bigint("createdAt", { mode: "number" }).notNull(),
+    updatedAt: bigint("updatedAt", { mode: "number" }).notNull(),
+    orderId: varchar("orderId", { length: 500 }),
+    errorMessage: text("errorMessage"),
+    renewalCount: integer("renewalCount").default(0),
+    certFile: text("certFile"),
+    keyFile: text("keyFile")
+});
+
+export const dnsChallenge = pgTable("dnsChallenges", {
+    dnsChallengeId: serial("dnsChallengeId").primaryKey(),
+    domain: varchar("domain", { length: 255 }).notNull(),
+    token: varchar("token", { length: 255 }).notNull(),
+    keyAuthorization: varchar("keyAuthorization", { length: 1000 }).notNull(),
+    createdAt: bigint("createdAt", { mode: "number" }).notNull(),
+    expiresAt: bigint("expiresAt", { mode: "number" }).notNull(),
+    completed: boolean("completed").default(false)
+});
+
+export const account = pgTable("account", {
+    accountId: serial("accountId").primaryKey(),
+    userId: varchar("userId")
+        .notNull()
+        .references(() => users.userId, { onDelete: "cascade" })
+});
+
+export const customers = pgTable("customers", {
+    customerId: varchar("customerId", { length: 255 }).primaryKey().notNull(),
+    orgId: varchar("orgId", { length: 255 })
+        .notNull()
+        .references(() => orgs.orgId, { onDelete: "cascade" }),
+    // accountId: integer("accountId")
+    //     .references(() => account.accountId, { onDelete: "cascade" }), // Optional, if using accounts
+    email: varchar("email", { length: 255 }),
+    name: varchar("name", { length: 255 }),
+    phone: varchar("phone", { length: 50 }),
+    address: text("address"),
+    createdAt: bigint("createdAt", { mode: "number" }).notNull(),
+    updatedAt: bigint("updatedAt", { mode: "number" }).notNull()
+});
+
+export const subscriptions = pgTable("subscriptions", {
+    subscriptionId: varchar("subscriptionId", { length: 255 })
+        .primaryKey()
+        .notNull(),
+    customerId: varchar("customerId", { length: 255 })
+        .notNull()
+        .references(() => customers.customerId, { onDelete: "cascade" }),
+    status: varchar("status", { length: 50 }).notNull().default("active"), // active, past_due, canceled, unpaid
+    canceledAt: bigint("canceledAt", { mode: "number" }),
+    createdAt: bigint("createdAt", { mode: "number" }).notNull(),
+    updatedAt: bigint("updatedAt", { mode: "number" }),
+    billingCycleAnchor: bigint("billingCycleAnchor", { mode: "number" })
+});
+
+export const subscriptionItems = pgTable("subscriptionItems", {
+    subscriptionItemId: serial("subscriptionItemId").primaryKey(),
+    subscriptionId: varchar("subscriptionId", { length: 255 })
+        .notNull()
+        .references(() => subscriptions.subscriptionId, {
+            onDelete: "cascade"
+        }),
+    planId: varchar("planId", { length: 255 }).notNull(),
+    priceId: varchar("priceId", { length: 255 }),
+    meterId: varchar("meterId", { length: 255 }),
+    unitAmount: real("unitAmount"),
+    tiers: text("tiers"),
+    interval: varchar("interval", { length: 50 }),
+    currentPeriodStart: bigint("currentPeriodStart", { mode: "number" }),
+    currentPeriodEnd: bigint("currentPeriodEnd", { mode: "number" }),
+    name: varchar("name", { length: 255 })
+});
+
+export const accountDomains = pgTable("accountDomains", {
+    accountId: integer("accountId")
+        .notNull()
+        .references(() => account.accountId, { onDelete: "cascade" }),
+    domainId: varchar("domainId")
+        .notNull()
+        .references(() => domains.domainId, { onDelete: "cascade" })
+});
+
+export const usage = pgTable("usage", {
+    usageId: varchar("usageId", { length: 255 }).primaryKey(),
+    featureId: varchar("featureId", { length: 255 }).notNull(),
+    orgId: varchar("orgId")
+        .references(() => orgs.orgId, { onDelete: "cascade" })
+        .notNull(),
+    meterId: varchar("meterId", { length: 255 }),
+    instantaneousValue: real("instantaneousValue"),
+    latestValue: real("latestValue").notNull(),
+    previousValue: real("previousValue"),
+    updatedAt: bigint("updatedAt", { mode: "number" }).notNull(),
+    rolledOverAt: bigint("rolledOverAt", { mode: "number" }),
+    nextRolloverAt: bigint("nextRolloverAt", { mode: "number" })
+});
+
+export const limits = pgTable("limits", {
+    limitId: varchar("limitId", { length: 255 }).primaryKey(),
+    featureId: varchar("featureId", { length: 255 }).notNull(),
+    orgId: varchar("orgId")
+        .references(() => orgs.orgId, {
+            onDelete: "cascade"
+        })
+        .notNull(),
+    value: real("value"),
+    description: text("description")
+});
+
+export const usageNotifications = pgTable("usageNotifications", {
+    notificationId: serial("notificationId").primaryKey(),
+    orgId: varchar("orgId")
+        .notNull()
+        .references(() => orgs.orgId, { onDelete: "cascade" }),
+    featureId: varchar("featureId", { length: 255 }).notNull(),
+    limitId: varchar("limitId", { length: 255 }).notNull(),
+    notificationType: varchar("notificationType", { length: 50 }).notNull(),
+    sentAt: bigint("sentAt", { mode: "number" }).notNull()
+});
+
+export const domainNamespaces = pgTable("domainNamespaces", {
+    domainNamespaceId: varchar("domainNamespaceId", {
+        length: 255
+    }).primaryKey(),
+    domainId: varchar("domainId")
+        .references(() => domains.domainId, {
+            onDelete: "set null"
+        })
+        .notNull()
+});
+
+export const exitNodeOrgs = pgTable("exitNodeOrgs", {
+    exitNodeId: integer("exitNodeId")
+        .notNull()
+        .references(() => exitNodes.exitNodeId, { onDelete: "cascade" }),
+    orgId: text("orgId")
+        .notNull()
+        .references(() => orgs.orgId, { onDelete: "cascade" })
+});
+
+export const remoteExitNodes = pgTable("remoteExitNode", {
+    remoteExitNodeId: varchar("id").primaryKey(),
+    secretHash: varchar("secretHash").notNull(),
+    dateCreated: varchar("dateCreated").notNull(),
+    version: varchar("version"),
+    exitNodeId: integer("exitNodeId").references(() => exitNodes.exitNodeId, {
+        onDelete: "cascade"
+    })
+});
+
+export const remoteExitNodeSessions = pgTable("remoteExitNodeSession", {
+    sessionId: varchar("id").primaryKey(),
+    remoteExitNodeId: varchar("remoteExitNodeId")
+        .notNull()
+        .references(() => remoteExitNodes.remoteExitNodeId, {
+            onDelete: "cascade"
+        }),
+    expiresAt: bigint("expiresAt", { mode: "number" }).notNull()
+});
+
+export const loginPage = pgTable("loginPage", {
+    loginPageId: serial("loginPageId").primaryKey(),
+    subdomain: varchar("subdomain"),
+    fullDomain: varchar("fullDomain"),
+    exitNodeId: integer("exitNodeId").references(() => exitNodes.exitNodeId, {
+        onDelete: "set null"
+    }),
+    domainId: varchar("domainId").references(() => domains.domainId, {
+        onDelete: "set null"
+    })
+});
+
+export const loginPageOrg = pgTable("loginPageOrg", {
+    loginPageId: integer("loginPageId")
+        .notNull()
+        .references(() => loginPage.loginPageId, { onDelete: "cascade" }),
+    orgId: varchar("orgId")
+        .notNull()
+        .references(() => orgs.orgId, { onDelete: "cascade" })
+});
+
+export const sessionTransferToken = pgTable("sessionTransferToken", {
+    token: varchar("token").primaryKey(),
+    sessionId: varchar("sessionId")
+        .notNull()
+        .references(() => sessions.sessionId, {
+            onDelete: "cascade"
+        }),
+    encryptedSession: text("encryptedSession").notNull(),
+    expiresAt: bigint("expiresAt", { mode: "number" }).notNull()
+});
+
+export type Limit = InferSelectModel<typeof limits>;
+export type Account = InferSelectModel<typeof account>;
+export type Certificate = InferSelectModel<typeof certificates>;
+export type DnsChallenge = InferSelectModel<typeof dnsChallenge>;
+export type Customer = InferSelectModel<typeof customers>;
+export type Subscription = InferSelectModel<typeof subscriptions>;
+export type SubscriptionItem = InferSelectModel<typeof subscriptionItems>;
+export type Usage = InferSelectModel<typeof usage>;
+export type UsageLimit = InferSelectModel<typeof limits>;
+export type AccountDomain = InferSelectModel<typeof accountDomains>;
+export type UsageNotification = InferSelectModel<typeof usageNotifications>;
+export type RemoteExitNode = InferSelectModel<typeof remoteExitNodes>;
+export type RemoteExitNodeSession = InferSelectModel<
+    typeof remoteExitNodeSessions
+>;
+export type ExitNodeOrg = InferSelectModel<typeof exitNodeOrgs>;
+export type LoginPage = InferSelectModel<typeof loginPage>;

server/db/pg/schema.ts

@@ -128,6 +128,27 @@ export const targets = pgTable("targets", {
     rewritePathType: text("rewritePathType") // exact, prefix, regex, stripPrefix
 });
 
+export const targetHealthCheck = pgTable("targetHealthCheck", {
+    targetHealthCheckId: serial("targetHealthCheckId").primaryKey(),
+    targetId: integer("targetId")
+        .notNull()
+        .references(() => targets.targetId, { onDelete: "cascade" }),
+    hcEnabled: boolean("hcEnabled").notNull().default(false),
+    hcPath: varchar("hcPath"),
+    hcScheme: varchar("hcScheme"),
+    hcMode: varchar("hcMode").default("http"),
+    hcHostname: varchar("hcHostname"),
+    hcPort: integer("hcPort"),
+    hcInterval: integer("hcInterval").default(30), // in seconds
+    hcUnhealthyInterval: integer("hcUnhealthyInterval").default(30), // in seconds
+    hcTimeout: integer("hcTimeout").default(5), // in seconds
+    hcHeaders: varchar("hcHeaders"),
+    hcFollowRedirects: boolean("hcFollowRedirects").default(true),
+    hcMethod: varchar("hcMethod").default("GET"),
+    hcStatus: integer("hcStatus"), // http code
+    hcHealth: text("hcHealth").default("unknown") // "unknown", "healthy", "unhealthy"
+});
+
 export const exitNodes = pgTable("exitNodes", {
     exitNodeId: serial("exitNodeId").primaryKey(),
     name: varchar("name").notNull(),
@@ -689,3 +710,4 @@ export type OrgDomains = InferSelectModel<typeof orgDomains>;
 export type SiteResource = InferSelectModel<typeof siteResources>;
 export type SetupToken = InferSelectModel<typeof setupTokens>;
 export type HostMeta = InferSelectModel<typeof hostMeta>;
+export type TargetHealthCheck = InferSelectModel<typeof targetHealthCheck>;

server/db/private/rateLimit.test.ts

@@ -0,0 +1,202 @@
+/*
+ * This file is part of a proprietary work.
+ *
+ * Copyright (c) 2025 Fossorial, Inc.
+ * All rights reserved.
+ *
+ * This file is licensed under the Fossorial Commercial License.
+ * You may not use this file except in compliance with the License.
+ * Unauthorized use, copying, modification, or distribution is strictly prohibited.
+ *
+ * This file is not licensed under the AGPLv3.
+ */
+
+// Simple test file for the rate limit service with Redis
+// Run with: npx ts-node rateLimitService.test.ts
+
+import { RateLimitService } from './rateLimit';
+
+function generateClientId() {
+    return 'client-' + Math.random().toString(36).substring(2, 15);
+}
+
+async function runTests() {
+    console.log('Starting Rate Limit Service Tests...\n');
+    
+    const rateLimitService = new RateLimitService();
+    let testsPassed = 0;
+    let testsTotal = 0;
+
+    // Helper function to run a test
+    async function test(name: string, testFn: () => Promise<void>) {
+        testsTotal++;
+        try {
+            await testFn();
+            console.log(`✅ ${name}`);
+            testsPassed++;
+        } catch (error) {
+            console.log(`❌ ${name}: ${error}`);
+        }
+    }
+
+    // Helper function for assertions
+    function assert(condition: boolean, message: string) {
+        if (!condition) {
+            throw new Error(message);
+        }
+    }
+
+    // Test 1: Basic rate limiting
+    await test('Should allow requests under the limit', async () => {
+        const clientId = generateClientId();
+        const maxRequests = 5;
+
+        for (let i = 0; i < maxRequests - 1; i++) {
+            const result = await rateLimitService.checkRateLimit(clientId, undefined, maxRequests);
+            assert(!result.isLimited, `Request ${i + 1} should be allowed`);
+            assert(result.totalHits === i + 1, `Expected ${i + 1} hits, got ${result.totalHits}`);
+        }
+    });
+
+    // Test 2: Rate limit blocking
+    await test('Should block requests over the limit', async () => {
+        const clientId = generateClientId();
+        const maxRequests = 30;
+
+        // Use up all allowed requests
+        for (let i = 0; i < maxRequests - 1; i++) {
+            const result = await rateLimitService.checkRateLimit(clientId, undefined, maxRequests);
+            assert(!result.isLimited, `Request ${i + 1} should be allowed`);
+        }
+
+        // Next request should be blocked
+        const blockedResult = await rateLimitService.checkRateLimit(clientId, undefined, maxRequests);
+        assert(blockedResult.isLimited, 'Request should be blocked');
+        assert(blockedResult.reason === 'global', 'Should be blocked for global reason');
+    });
+
+    // Test 3: Message type limits
+    await test('Should handle message type limits', async () => {
+        const clientId = generateClientId();
+        const globalMax = 10;
+        const messageTypeMax = 2;
+
+        // Send messages of type 'ping' up to the limit
+        for (let i = 0; i < messageTypeMax - 1; i++) {
+            const result = await rateLimitService.checkRateLimit(
+                clientId, 
+                'ping', 
+                globalMax, 
+                messageTypeMax
+            );
+            assert(!result.isLimited, `Ping message ${i + 1} should be allowed`);
+        }
+
+        // Next 'ping' should be blocked
+        const blockedResult = await rateLimitService.checkRateLimit(
+            clientId, 
+            'ping', 
+            globalMax, 
+            messageTypeMax
+        );
+        assert(blockedResult.isLimited, 'Ping message should be blocked');
+        assert(blockedResult.reason === 'message_type:ping', 'Should be blocked for message type');
+
+        // Other message types should still work
+        const otherResult = await rateLimitService.checkRateLimit(
+            clientId, 
+            'pong', 
+            globalMax, 
+            messageTypeMax
+        );
+        assert(!otherResult.isLimited, 'Pong message should be allowed');
+    });
+
+    // Test 4: Reset functionality
+    await test('Should reset client correctly', async () => {
+        const clientId = generateClientId();
+        const maxRequests = 3;
+
+        // Use up some requests
+        await rateLimitService.checkRateLimit(clientId, undefined, maxRequests);
+        await rateLimitService.checkRateLimit(clientId, 'test', maxRequests);
+
+        // Reset the client
+        await rateLimitService.resetKey(clientId);
+
+        // Should be able to make fresh requests
+        const result = await rateLimitService.checkRateLimit(clientId, undefined, maxRequests);
+        assert(!result.isLimited, 'Request after reset should be allowed');
+        assert(result.totalHits === 1, 'Should have 1 hit after reset');
+    });
+
+    // Test 5: Different clients are independent
+    await test('Should handle different clients independently', async () => {
+        const client1 = generateClientId();
+        const client2 = generateClientId();
+        const maxRequests = 2;
+
+        // Client 1 uses up their limit
+        await rateLimitService.checkRateLimit(client1, undefined, maxRequests);
+        await rateLimitService.checkRateLimit(client1, undefined, maxRequests);
+        const client1Blocked = await rateLimitService.checkRateLimit(client1, undefined, maxRequests);
+        assert(client1Blocked.isLimited, 'Client 1 should be blocked');
+
+        // Client 2 should still be able to make requests
+        const client2Result = await rateLimitService.checkRateLimit(client2, undefined, maxRequests);
+        assert(!client2Result.isLimited, 'Client 2 should not be blocked');
+        assert(client2Result.totalHits === 1, 'Client 2 should have 1 hit');
+    });
+
+    // Test 6: Decrement functionality
+    await test('Should decrement correctly', async () => {
+        const clientId = generateClientId();
+        const maxRequests = 5;
+
+        // Make some requests
+        await rateLimitService.checkRateLimit(clientId, undefined, maxRequests);
+        await rateLimitService.checkRateLimit(clientId, undefined, maxRequests);
+        let result = await rateLimitService.checkRateLimit(clientId, undefined, maxRequests);
+        assert(result.totalHits === 3, 'Should have 3 hits before decrement');
+
+        // Decrement
+        await rateLimitService.decrementRateLimit(clientId);
+
+        // Next request should reflect the decrement
+        result = await rateLimitService.checkRateLimit(clientId, undefined, maxRequests);
+        assert(result.totalHits === 3, 'Should have 3 hits after decrement + increment');
+    });
+
+    // Wait a moment for any pending Redis operations
+    console.log('\nWaiting for Redis sync...');
+    await new Promise(resolve => setTimeout(resolve, 1000));
+
+    // Force sync to test Redis integration
+    await test('Should sync to Redis', async () => {
+        await rateLimitService.forceSyncAllPendingData();
+        // If this doesn't throw, Redis sync is working
+        assert(true, 'Redis sync completed');
+    });
+
+    // Cleanup
+    await rateLimitService.cleanup();
+
+    // Results
+    console.log(`\n--- Test Results ---`);
+    console.log(`✅ Passed: ${testsPassed}/${testsTotal}`);
+    console.log(`❌ Failed: ${testsTotal - testsPassed}/${testsTotal}`);
+    
+    if (testsPassed === testsTotal) {
+        console.log('\n🎉 All tests passed!');
+        process.exit(0);
+    } else {
+        console.log('\n💥 Some tests failed!');
+        process.exit(1);
+    }
+}
+
+// Run the tests
+runTests().catch(error => {
+    console.error('Test runner error:', error);
+    process.exit(1);
+});

server/db/private/rateLimit.ts

@@ -0,0 +1,458 @@
+/*
+ * This file is part of a proprietary work.
+ *
+ * Copyright (c) 2025 Fossorial, Inc.
+ * All rights reserved.
+ *
+ * This file is licensed under the Fossorial Commercial License.
+ * You may not use this file except in compliance with the License.
+ * Unauthorized use, copying, modification, or distribution is strictly prohibited.
+ *
+ * This file is not licensed under the AGPLv3.
+ */
+
+import logger from "@server/logger";
+import redisManager from "@server/db/private/redis";
+import { build } from "@server/build";
+
+// Rate limiting configuration
+export const RATE_LIMIT_WINDOW = 60; // 1 minute in seconds
+export const RATE_LIMIT_MAX_REQUESTS = 100;
+export const RATE_LIMIT_PER_MESSAGE_TYPE = 20; // Per message type limit within the window
+
+// Configuration for batched Redis sync
+export const REDIS_SYNC_THRESHOLD = 15; // Sync to Redis every N messages
+export const REDIS_SYNC_FORCE_INTERVAL = 30000; // Force sync every 30 seconds as backup
+
+interface RateLimitTracker {
+    count: number;
+    windowStart: number;
+    pendingCount: number;
+    lastSyncedCount: number;
+}
+
+interface RateLimitResult {
+    isLimited: boolean;
+    reason?: string;
+    totalHits?: number;
+    resetTime?: Date;
+}
+
+export class RateLimitService {
+    private localRateLimitTracker: Map<string, RateLimitTracker> = new Map();
+    private localMessageTypeRateLimitTracker: Map<string, RateLimitTracker> = new Map();
+    private cleanupInterval: NodeJS.Timeout | null = null;
+    private forceSyncInterval: NodeJS.Timeout | null = null;
+
+    constructor() {
+        if (build == "oss") {
+            return;
+        }
+
+        // Start cleanup and sync intervals
+        this.cleanupInterval = setInterval(() => {
+            this.cleanupLocalRateLimit().catch((error) => {
+                logger.error("Error during rate limit cleanup:", error);
+            });
+        }, 60000); // Run cleanup every minute
+
+        this.forceSyncInterval = setInterval(() => {
+            this.forceSyncAllPendingData().catch((error) => {
+                logger.error("Error during force sync:", error);
+            });
+        }, REDIS_SYNC_FORCE_INTERVAL);
+    }
+
+    // Redis keys
+    private getRateLimitKey(clientId: string): string {
+        return `ratelimit:${clientId}`;
+    }
+
+    private getMessageTypeRateLimitKey(clientId: string, messageType: string): string {
+        return `ratelimit:${clientId}:${messageType}`;
+    }
+
+    // Helper function to sync local rate limit data to Redis
+    private async syncRateLimitToRedis(
+        clientId: string,
+        tracker: RateLimitTracker
+    ): Promise<void> {
+        if (!redisManager.isRedisEnabled() || tracker.pendingCount === 0) return;
+
+        try {
+            const currentTime = Math.floor(Date.now() / 1000);
+            const globalKey = this.getRateLimitKey(clientId);
+
+            // Get current value and add pending count
+            const currentValue = await redisManager.hget(
+                globalKey,
+                currentTime.toString()
+            );
+            const newValue = (
+                parseInt(currentValue || "0") + tracker.pendingCount
+            ).toString();
+            await redisManager.hset(globalKey, currentTime.toString(), newValue);
+
+            // Set TTL using the client directly
+            if (redisManager.getClient()) {
+                await redisManager
+                    .getClient()
+                    .expire(globalKey, RATE_LIMIT_WINDOW + 10);
+            }
+
+            // Update tracking
+            tracker.lastSyncedCount = tracker.count;
+            tracker.pendingCount = 0;
+
+            logger.debug(`Synced global rate limit to Redis for client ${clientId}`);
+        } catch (error) {
+            logger.error("Failed to sync global rate limit to Redis:", error);
+        }
+    }
+
+    private async syncMessageTypeRateLimitToRedis(
+        clientId: string,
+        messageType: string,
+        tracker: RateLimitTracker
+    ): Promise<void> {
+        if (!redisManager.isRedisEnabled() || tracker.pendingCount === 0) return;
+
+        try {
+            const currentTime = Math.floor(Date.now() / 1000);
+            const messageTypeKey = this.getMessageTypeRateLimitKey(clientId, messageType);
+
+            // Get current value and add pending count
+            const currentValue = await redisManager.hget(
+                messageTypeKey,
+                currentTime.toString()
+            );
+            const newValue = (
+                parseInt(currentValue || "0") + tracker.pendingCount
+            ).toString();
+            await redisManager.hset(
+                messageTypeKey,
+                currentTime.toString(),
+                newValue
+            );
+
+            // Set TTL using the client directly
+            if (redisManager.getClient()) {
+                await redisManager
+                    .getClient()
+                    .expire(messageTypeKey, RATE_LIMIT_WINDOW + 10);
+            }
+
+            // Update tracking
+            tracker.lastSyncedCount = tracker.count;
+            tracker.pendingCount = 0;
+
+            logger.debug(
+                `Synced message type rate limit to Redis for client ${clientId}, type ${messageType}`
+            );
+        } catch (error) {
+            logger.error("Failed to sync message type rate limit to Redis:", error);
+        }
+    }
+
+    // Initialize local tracker from Redis data
+    private async initializeLocalTracker(clientId: string): Promise<RateLimitTracker> {
+        const currentTime = Math.floor(Date.now() / 1000);
+        const windowStart = currentTime - RATE_LIMIT_WINDOW;
+
+        if (!redisManager.isRedisEnabled()) {
+            return {
+                count: 0,
+                windowStart: currentTime,
+                pendingCount: 0,
+                lastSyncedCount: 0
+            };
+        }
+
+        try {
+            const globalKey = this.getRateLimitKey(clientId);
+            const globalRateLimitData = await redisManager.hgetall(globalKey);
+
+            let count = 0;
+            for (const [timestamp, countStr] of Object.entries(globalRateLimitData)) {
+                const time = parseInt(timestamp);
+                if (time >= windowStart) {
+                    count += parseInt(countStr);
+                }
+            }
+
+            return {
+                count,
+                windowStart: currentTime,
+                pendingCount: 0,
+                lastSyncedCount: count
+            };
+        } catch (error) {
+            logger.error("Failed to initialize global tracker from Redis:", error);
+            return {
+                count: 0,
+                windowStart: currentTime,
+                pendingCount: 0,
+                lastSyncedCount: 0
+            };
+        }
+    }
+
+    private async initializeMessageTypeTracker(
+        clientId: string,
+        messageType: string
+    ): Promise<RateLimitTracker> {
+        const currentTime = Math.floor(Date.now() / 1000);
+        const windowStart = currentTime - RATE_LIMIT_WINDOW;
+
+        if (!redisManager.isRedisEnabled()) {
+            return {
+                count: 0,
+                windowStart: currentTime,
+                pendingCount: 0,
+                lastSyncedCount: 0
+            };
+        }
+
+        try {
+            const messageTypeKey = this.getMessageTypeRateLimitKey(clientId, messageType);
+            const messageTypeRateLimitData = await redisManager.hgetall(messageTypeKey);
+
+            let count = 0;
+            for (const [timestamp, countStr] of Object.entries(messageTypeRateLimitData)) {
+                const time = parseInt(timestamp);
+                if (time >= windowStart) {
+                    count += parseInt(countStr);
+                }
+            }
+
+            return {
+                count,
+                windowStart: currentTime,
+                pendingCount: 0,
+                lastSyncedCount: count
+            };
+        } catch (error) {
+            logger.error("Failed to initialize message type tracker from Redis:", error);
+            return {
+                count: 0,
+                windowStart: currentTime,
+                pendingCount: 0,
+                lastSyncedCount: 0
+            };
+        }
+    }
+
+    // Main rate limiting function
+    async checkRateLimit(
+        clientId: string,
+        messageType?: string,
+        maxRequests: number = RATE_LIMIT_MAX_REQUESTS,
+        messageTypeLimit: number = RATE_LIMIT_PER_MESSAGE_TYPE,
+        windowMs: number = RATE_LIMIT_WINDOW * 1000
+    ): Promise<RateLimitResult> {
+        const currentTime = Math.floor(Date.now() / 1000);
+        const windowStart = currentTime - Math.floor(windowMs / 1000);
+
+        // Check global rate limit
+        let globalTracker = this.localRateLimitTracker.get(clientId);
+
+        if (!globalTracker || globalTracker.windowStart < windowStart) {
+            // New window or first request - initialize from Redis if available
+            globalTracker = await this.initializeLocalTracker(clientId);
+            globalTracker.windowStart = currentTime;
+            this.localRateLimitTracker.set(clientId, globalTracker);
+        }
+
+        // Increment global counters
+        globalTracker.count++;
+        globalTracker.pendingCount++;
+        this.localRateLimitTracker.set(clientId, globalTracker);
+
+        // Check if global limit would be exceeded
+        if (globalTracker.count >= maxRequests) {
+            return {
+                isLimited: true,
+                reason: "global",
+                totalHits: globalTracker.count,
+                resetTime: new Date((globalTracker.windowStart + Math.floor(windowMs / 1000)) * 1000)
+            };
+        }
+
+        // Sync to Redis if threshold reached
+        if (globalTracker.pendingCount >= REDIS_SYNC_THRESHOLD) {
+            this.syncRateLimitToRedis(clientId, globalTracker);
+        }
+
+        // Check message type specific rate limit if messageType is provided
+        if (messageType) {
+            const messageTypeKey = `${clientId}:${messageType}`;
+            let messageTypeTracker = this.localMessageTypeRateLimitTracker.get(messageTypeKey);
+
+            if (!messageTypeTracker || messageTypeTracker.windowStart < windowStart) {
+                // New window or first request for this message type - initialize from Redis if available
+                messageTypeTracker = await this.initializeMessageTypeTracker(clientId, messageType);
+                messageTypeTracker.windowStart = currentTime;
+                this.localMessageTypeRateLimitTracker.set(messageTypeKey, messageTypeTracker);
+            }
+
+            // Increment message type counters
+            messageTypeTracker.count++;
+            messageTypeTracker.pendingCount++;
+            this.localMessageTypeRateLimitTracker.set(messageTypeKey, messageTypeTracker);
+
+            // Check if message type limit would be exceeded
+            if (messageTypeTracker.count >= messageTypeLimit) {
+                return {
+                    isLimited: true,
+                    reason: `message_type:${messageType}`,
+                    totalHits: messageTypeTracker.count,
+                    resetTime: new Date((messageTypeTracker.windowStart + Math.floor(windowMs / 1000)) * 1000)
+                };
+            }
+
+            // Sync to Redis if threshold reached
+            if (messageTypeTracker.pendingCount >= REDIS_SYNC_THRESHOLD) {
+                this.syncMessageTypeRateLimitToRedis(clientId, messageType, messageTypeTracker);
+            }
+        }
+
+        return {
+            isLimited: false,
+            totalHits: globalTracker.count,
+            resetTime: new Date((globalTracker.windowStart + Math.floor(windowMs / 1000)) * 1000)
+        };
+    }
+
+    // Decrement function for skipSuccessfulRequests/skipFailedRequests functionality
+    async decrementRateLimit(clientId: string, messageType?: string): Promise<void> {
+        // Decrement global counter
+        const globalTracker = this.localRateLimitTracker.get(clientId);
+        if (globalTracker && globalTracker.count > 0) {
+            globalTracker.count--;
+            // We need to account for this in pending count to sync correctly
+            globalTracker.pendingCount--;
+        }
+
+        // Decrement message type counter if provided
+        if (messageType) {
+            const messageTypeKey = `${clientId}:${messageType}`;
+            const messageTypeTracker = this.localMessageTypeRateLimitTracker.get(messageTypeKey);
+            if (messageTypeTracker && messageTypeTracker.count > 0) {
+                messageTypeTracker.count--;
+                messageTypeTracker.pendingCount--;
+            }
+        }
+    }
+
+    // Reset key function
+    async resetKey(clientId: string): Promise<void> {
+        // Remove from local tracking
+        this.localRateLimitTracker.delete(clientId);
+        
+        // Remove all message type entries for this client
+        for (const [key] of this.localMessageTypeRateLimitTracker) {
+            if (key.startsWith(`${clientId}:`)) {
+                this.localMessageTypeRateLimitTracker.delete(key);
+            }
+        }
+
+        // Remove from Redis if enabled
+        if (redisManager.isRedisEnabled()) {
+            const globalKey = this.getRateLimitKey(clientId);
+            await redisManager.del(globalKey);
+
+            // Get all message type keys for this client and delete them
+            const client = redisManager.getClient();
+            if (client) {
+                const messageTypeKeys = await client.keys(`ratelimit:${clientId}:*`);
+                if (messageTypeKeys.length > 0) {
+                    await Promise.all(messageTypeKeys.map(key => redisManager.del(key)));
+                }
+            }
+        }
+    }
+
+    // Cleanup old local rate limit entries and force sync pending data
+    private async cleanupLocalRateLimit(): Promise<void> {
+        const currentTime = Math.floor(Date.now() / 1000);
+        const windowStart = currentTime - RATE_LIMIT_WINDOW;
+
+        // Clean up global rate limit tracking and sync pending data
+        for (const [clientId, tracker] of this.localRateLimitTracker.entries()) {
+            if (tracker.windowStart < windowStart) {
+                // Sync any pending data before cleanup
+                if (tracker.pendingCount > 0) {
+                    await this.syncRateLimitToRedis(clientId, tracker);
+                }
+                this.localRateLimitTracker.delete(clientId);
+            }
+        }
+
+        // Clean up message type rate limit tracking and sync pending data
+        for (const [key, tracker] of this.localMessageTypeRateLimitTracker.entries()) {
+            if (tracker.windowStart < windowStart) {
+                // Sync any pending data before cleanup
+                if (tracker.pendingCount > 0) {
+                    const [clientId, messageType] = key.split(":", 2);
+                    await this.syncMessageTypeRateLimitToRedis(clientId, messageType, tracker);
+                }
+                this.localMessageTypeRateLimitTracker.delete(key);
+            }
+        }
+    }
+
+    // Force sync all pending rate limit data to Redis
+    async forceSyncAllPendingData(): Promise<void> {
+        if (!redisManager.isRedisEnabled()) return;
+
+        logger.debug("Force syncing all pending rate limit data to Redis...");
+
+        // Sync all pending global rate limits
+        for (const [clientId, tracker] of this.localRateLimitTracker.entries()) {
+            if (tracker.pendingCount > 0) {
+                await this.syncRateLimitToRedis(clientId, tracker);
+            }
+        }
+
+        // Sync all pending message type rate limits
+        for (const [key, tracker] of this.localMessageTypeRateLimitTracker.entries()) {
+            if (tracker.pendingCount > 0) {
+                const [clientId, messageType] = key.split(":", 2);
+                await this.syncMessageTypeRateLimitToRedis(clientId, messageType, tracker);
+            }
+        }
+
+        logger.debug("Completed force sync of pending rate limit data");
+    }
+
+    // Cleanup function for graceful shutdown
+    async cleanup(): Promise<void> {
+        if (build == "oss") {
+            return;
+        }
+
+        // Clear intervals
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+        }
+        if (this.forceSyncInterval) {
+            clearInterval(this.forceSyncInterval);
+        }
+
+        // Force sync all pending data
+        await this.forceSyncAllPendingData();
+
+        // Clear local data
+        this.localRateLimitTracker.clear();
+        this.localMessageTypeRateLimitTracker.clear();
+
+        logger.info("Rate limit service cleanup completed");
+    }
+}
+
+// Export singleton instance
+export const rateLimitService = new RateLimitService();
+
+// Handle process termination
+process.on("SIGTERM", () => rateLimitService.cleanup());
+process.on("SIGINT", () => rateLimitService.cleanup());

server/db/private/redis.ts

@@ -0,0 +1,782 @@
+/*
+ * This file is part of a proprietary work.
+ *
+ * Copyright (c) 2025 Fossorial, Inc.
+ * All rights reserved.
+ *
+ * This file is licensed under the Fossorial Commercial License.
+ * You may not use this file except in compliance with the License.
+ * Unauthorized use, copying, modification, or distribution is strictly prohibited.
+ *
+ * This file is not licensed under the AGPLv3.
+ */
+
+import Redis, { RedisOptions } from "ioredis";
+import logger from "@server/logger";
+import config from "@server/lib/config";
+import { build } from "@server/build";
+
+class RedisManager {
+    public client: Redis | null = null;
+    private writeClient: Redis | null = null; // Master for writes
+    private readClient: Redis | null = null;  // Replica for reads
+    private subscriber: Redis | null = null;
+    private publisher: Redis | null = null;
+    private isEnabled: boolean = false;
+    private isHealthy: boolean = true;
+    private isWriteHealthy: boolean = true;
+    private isReadHealthy: boolean = true;
+    private lastHealthCheck: number = 0;
+    private healthCheckInterval: number = 30000; // 30 seconds
+    private connectionTimeout: number = 15000; // 15 seconds
+    private commandTimeout: number = 15000; // 15 seconds
+    private hasReplicas: boolean = false;
+    private maxRetries: number = 3;
+    private baseRetryDelay: number = 100; // 100ms
+    private maxRetryDelay: number = 2000; // 2 seconds
+    private backoffMultiplier: number = 2;
+    private subscribers: Map<
+        string,
+        Set<(channel: string, message: string) => void>
+    > = new Map();
+    private reconnectionCallbacks: Set<() => Promise<void>> = new Set();
+
+    constructor() {
+        if (build == "oss") {
+            this.isEnabled = false;
+            return
+        }
+        this.isEnabled = config.getRawPrivateConfig().flags?.enable_redis || false;
+        if (this.isEnabled) {
+            this.initializeClients();
+        }
+    }
+
+    // Register callback to be called when Redis reconnects
+    public onReconnection(callback: () => Promise<void>): void {
+        this.reconnectionCallbacks.add(callback);
+    }
+
+    // Unregister reconnection callback
+    public offReconnection(callback: () => Promise<void>): void {
+        this.reconnectionCallbacks.delete(callback);
+    }
+
+    private async triggerReconnectionCallbacks(): Promise<void> {
+        logger.info(`Triggering ${this.reconnectionCallbacks.size} reconnection callbacks`);
+        
+        const promises = Array.from(this.reconnectionCallbacks).map(async (callback) => {
+            try {
+                await callback();
+            } catch (error) {
+                logger.error("Error in reconnection callback:", error);
+            }
+        });
+
+        await Promise.allSettled(promises);
+    }
+
+    private async resubscribeToChannels(): Promise<void> {
+        if (!this.subscriber || this.subscribers.size === 0) return;
+
+        logger.info(`Re-subscribing to ${this.subscribers.size} channels after Redis reconnection`);
+        
+        try {
+            const channels = Array.from(this.subscribers.keys());
+            if (channels.length > 0) {
+                await this.subscriber.subscribe(...channels);
+                logger.info(`Successfully re-subscribed to channels: ${channels.join(', ')}`);
+            }
+        } catch (error) {
+            logger.error("Failed to re-subscribe to channels:", error);
+        }
+    }
+
+    private getRedisConfig(): RedisOptions {
+        const redisConfig = config.getRawPrivateConfig().redis!;
+        const opts: RedisOptions = {
+            host: redisConfig.host!,
+            port: redisConfig.port!,
+            password: redisConfig.password,
+            db: redisConfig.db,
+            // tls: {
+            //     rejectUnauthorized:
+            //         redisConfig.tls?.reject_unauthorized || false
+            // }
+        };
+        return opts;
+    }
+
+    private getReplicaRedisConfig(): RedisOptions | null {
+        const redisConfig = config.getRawPrivateConfig().redis!;
+        if (!redisConfig.replicas || redisConfig.replicas.length === 0) {
+            return null;
+        }
+        
+        // Use the first replica for simplicity
+        // In production, you might want to implement load balancing across replicas
+        const replica = redisConfig.replicas[0];
+        const opts: RedisOptions = {
+            host: replica.host!,
+            port: replica.port!,
+            password: replica.password,
+            db: replica.db || redisConfig.db,
+            // tls: {
+            //     rejectUnauthorized:
+            //         replica.tls?.reject_unauthorized || false
+            // }
+        };
+        return opts;
+    }
+
+    // Add reconnection logic in initializeClients
+    private initializeClients(): void {
+        const masterConfig = this.getRedisConfig();
+        const replicaConfig = this.getReplicaRedisConfig();
+        
+        this.hasReplicas = replicaConfig !== null;
+
+        try {
+            // Initialize master connection for writes
+            this.writeClient = new Redis({
+                ...masterConfig,
+                enableReadyCheck: false,
+                maxRetriesPerRequest: 3,
+                keepAlive: 30000,
+                connectTimeout: this.connectionTimeout,
+                commandTimeout: this.commandTimeout,
+            });
+
+            // Initialize replica connection for reads (if available)
+            if (this.hasReplicas) {
+                this.readClient = new Redis({
+                    ...replicaConfig!,
+                    enableReadyCheck: false,
+                    maxRetriesPerRequest: 3,
+                    keepAlive: 30000,
+                    connectTimeout: this.connectionTimeout,
+                    commandTimeout: this.commandTimeout,
+                });
+            } else {
+                // Fallback to master for reads if no replicas
+                this.readClient = this.writeClient;
+            }
+
+            // Backward compatibility - point to write client
+            this.client = this.writeClient;
+
+            // Publisher uses master (writes)
+            this.publisher = new Redis({
+                ...masterConfig,
+                enableReadyCheck: false,
+                maxRetriesPerRequest: 3,
+                keepAlive: 30000,
+                connectTimeout: this.connectionTimeout,
+                commandTimeout: this.commandTimeout,
+            });
+
+            // Subscriber uses replica if available (reads)
+            this.subscriber = new Redis({
+                ...(this.hasReplicas ? replicaConfig! : masterConfig),
+                enableReadyCheck: false,
+                maxRetriesPerRequest: 3,
+                keepAlive: 30000,
+                connectTimeout: this.connectionTimeout,
+                commandTimeout: this.commandTimeout,
+            });
+
+            // Add reconnection handlers for write client
+            this.writeClient.on("error", (err) => {
+                logger.error("Redis write client error:", err);
+                this.isWriteHealthy = false;
+                this.isHealthy = false;
+            });
+
+            this.writeClient.on("reconnecting", () => {
+                logger.info("Redis write client reconnecting...");
+                this.isWriteHealthy = false;
+                this.isHealthy = false;
+            });
+
+            this.writeClient.on("ready", () => {
+                logger.info("Redis write client ready");
+                this.isWriteHealthy = true;
+                this.updateOverallHealth();
+                
+                // Trigger reconnection callbacks when Redis comes back online
+                if (this.isHealthy) {
+                    this.triggerReconnectionCallbacks().catch(error => {
+                        logger.error("Error triggering reconnection callbacks:", error);
+                    });
+                }
+            });
+
+            this.writeClient.on("connect", () => {
+                logger.info("Redis write client connected");
+            });
+
+            // Add reconnection handlers for read client (if different from write)
+            if (this.hasReplicas && this.readClient !== this.writeClient) {
+                this.readClient.on("error", (err) => {
+                    logger.error("Redis read client error:", err);
+                    this.isReadHealthy = false;
+                    this.updateOverallHealth();
+                });
+
+                this.readClient.on("reconnecting", () => {
+                    logger.info("Redis read client reconnecting...");
+                    this.isReadHealthy = false;
+                    this.updateOverallHealth();
+                });
+
+                this.readClient.on("ready", () => {
+                    logger.info("Redis read client ready");
+                    this.isReadHealthy = true;
+                    this.updateOverallHealth();
+                    
+                    // Trigger reconnection callbacks when Redis comes back online
+                    if (this.isHealthy) {
+                        this.triggerReconnectionCallbacks().catch(error => {
+                            logger.error("Error triggering reconnection callbacks:", error);
+                        });
+                    }
+                });
+
+                this.readClient.on("connect", () => {
+                    logger.info("Redis read client connected");
+                });
+            } else {
+                // If using same client for reads and writes
+                this.isReadHealthy = this.isWriteHealthy;
+            }
+
+            this.publisher.on("error", (err) => {
+                logger.error("Redis publisher error:", err);
+            });
+
+            this.publisher.on("ready", () => {
+                logger.info("Redis publisher ready");
+            });
+
+            this.publisher.on("connect", () => {
+                logger.info("Redis publisher connected");
+            });
+
+            this.subscriber.on("error", (err) => {
+                logger.error("Redis subscriber error:", err);
+            });
+
+            this.subscriber.on("ready", () => {
+                logger.info("Redis subscriber ready");
+                // Re-subscribe to all channels after reconnection
+                this.resubscribeToChannels().catch((error: any) => {
+                    logger.error("Error re-subscribing to channels:", error);
+                });
+            });
+
+            this.subscriber.on("connect", () => {
+                logger.info("Redis subscriber connected");
+            });
+
+            // Set up message handler for subscriber
+            this.subscriber.on(
+                "message",
+                (channel: string, message: string) => {
+                    const channelSubscribers = this.subscribers.get(channel);
+                    if (channelSubscribers) {
+                        channelSubscribers.forEach((callback) => {
+                            try {
+                                callback(channel, message);
+                            } catch (error) {
+                                logger.error(
+                                    `Error in subscriber callback for channel ${channel}:`,
+                                    error
+                                );
+                            }
+                        });
+                    }
+                }
+            );
+
+            const setupMessage = this.hasReplicas 
+                ? "Redis clients initialized successfully with replica support" 
+                : "Redis clients initialized successfully (single instance)";
+            logger.info(setupMessage);
+
+            // Start periodic health monitoring
+            this.startHealthMonitoring();
+        } catch (error) {
+            logger.error("Failed to initialize Redis clients:", error);
+            this.isEnabled = false;
+        }
+    }
+
+    private updateOverallHealth(): void {
+        // Overall health is true if write is healthy and (read is healthy OR we don't have replicas)
+        this.isHealthy = this.isWriteHealthy && (this.isReadHealthy || !this.hasReplicas);
+    }
+
+    private async executeWithRetry<T>(
+        operation: () => Promise<T>,
+        operationName: string,
+        fallbackOperation?: () => Promise<T>
+    ): Promise<T> {
+        let lastError: Error | null = null;
+        
+        for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+            try {
+                return await operation();
+            } catch (error) {
+                lastError = error as Error;
+                
+                // If this is the last attempt, try fallback if available
+                if (attempt === this.maxRetries && fallbackOperation) {
+                    try {
+                        logger.warn(`${operationName} primary operation failed, trying fallback`);
+                        return await fallbackOperation();
+                    } catch (fallbackError) {
+                        logger.error(`${operationName} fallback also failed:`, fallbackError);
+                        throw lastError;
+                    }
+                }
+                
+                // Don't retry on the last attempt
+                if (attempt === this.maxRetries) {
+                    break;
+                }
+                
+                // Calculate delay with exponential backoff
+                const delay = Math.min(
+                    this.baseRetryDelay * Math.pow(this.backoffMultiplier, attempt),
+                    this.maxRetryDelay
+                );
+                
+                logger.warn(`${operationName} failed (attempt ${attempt + 1}/${this.maxRetries + 1}), retrying in ${delay}ms:`, error);
+                
+                // Wait before retrying
+                await new Promise(resolve => setTimeout(resolve, delay));
+            }
+        }
+        
+        logger.error(`${operationName} failed after ${this.maxRetries + 1} attempts:`, lastError);
+        throw lastError;
+    }
+
+    private startHealthMonitoring(): void {
+        if (!this.isEnabled) return;
+        
+        // Check health every 30 seconds
+        setInterval(async () => {
+            try {
+                await this.checkRedisHealth();
+            } catch (error) {
+                logger.error("Error during Redis health monitoring:", error);
+            }
+        }, this.healthCheckInterval);
+    }
+
+    public isRedisEnabled(): boolean {
+        return this.isEnabled && this.client !== null && this.isHealthy;
+    }
+
+    private async checkRedisHealth(): Promise<boolean> {
+        const now = Date.now();
+        
+        // Only check health every 30 seconds
+        if (now - this.lastHealthCheck < this.healthCheckInterval) {
+            return this.isHealthy;
+        }
+
+        this.lastHealthCheck = now;
+
+        if (!this.writeClient) {
+            this.isHealthy = false;
+            this.isWriteHealthy = false;
+            this.isReadHealthy = false;
+            return false;
+        }
+
+        try {
+            // Check write client (master) health
+            await Promise.race([
+                this.writeClient.ping(),
+                new Promise((_, reject) => 
+                    setTimeout(() => reject(new Error('Write client health check timeout')), 2000)
+                )
+            ]);
+            this.isWriteHealthy = true;
+
+            // Check read client health if it's different from write client
+            if (this.hasReplicas && this.readClient && this.readClient !== this.writeClient) {
+                try {
+                    await Promise.race([
+                        this.readClient.ping(),
+                        new Promise((_, reject) => 
+                            setTimeout(() => reject(new Error('Read client health check timeout')), 2000)
+                        )
+                    ]);
+                    this.isReadHealthy = true;
+                } catch (error) {
+                    logger.error("Redis read client health check failed:", error);
+                    this.isReadHealthy = false;
+                }
+            } else {
+                this.isReadHealthy = this.isWriteHealthy;
+            }
+
+            this.updateOverallHealth();
+            return this.isHealthy;
+        } catch (error) {
+            logger.error("Redis write client health check failed:", error);
+            this.isWriteHealthy = false;
+            this.isReadHealthy = false; // If write fails, consider read as failed too for safety
+            this.isHealthy = false;
+            return false;
+        }
+    }
+
+    public getClient(): Redis {
+        return this.client!;
+    }
+
+    public getWriteClient(): Redis | null {
+        return this.writeClient;
+    }
+
+    public getReadClient(): Redis | null {
+        return this.readClient;
+    }
+
+    public hasReplicaSupport(): boolean {
+        return this.hasReplicas;
+    }
+
+    public getHealthStatus(): {
+        isEnabled: boolean;
+        isHealthy: boolean;
+        isWriteHealthy: boolean;
+        isReadHealthy: boolean;
+        hasReplicas: boolean;
+    } {
+        return {
+            isEnabled: this.isEnabled,
+            isHealthy: this.isHealthy,
+            isWriteHealthy: this.isWriteHealthy,
+            isReadHealthy: this.isReadHealthy,
+            hasReplicas: this.hasReplicas
+        };
+    }
+
+    public async set(
+        key: string,
+        value: string,
+        ttl?: number
+    ): Promise<boolean> {
+        if (!this.isRedisEnabled() || !this.writeClient) return false;
+
+        try {
+            await this.executeWithRetry(
+                async () => {
+                    if (ttl) {
+                        await this.writeClient!.setex(key, ttl, value);
+                    } else {
+                        await this.writeClient!.set(key, value);
+                    }
+                },
+                "Redis SET"
+            );
+            return true;
+        } catch (error) {
+            logger.error("Redis SET error:", error);
+            return false;
+        }
+    }
+
+    public async get(key: string): Promise<string | null> {
+        if (!this.isRedisEnabled() || !this.readClient) return null;
+
+        try {
+            const fallbackOperation = (this.hasReplicas && this.writeClient && this.isWriteHealthy) 
+                ? () => this.writeClient!.get(key)
+                : undefined;
+
+            return await this.executeWithRetry(
+                () => this.readClient!.get(key),
+                "Redis GET",
+                fallbackOperation
+            );
+        } catch (error) {
+            logger.error("Redis GET error:", error);
+            return null;
+        }
+    }
+
+    public async del(key: string): Promise<boolean> {
+        if (!this.isRedisEnabled() || !this.writeClient) return false;
+
+        try {
+            await this.executeWithRetry(
+                () => this.writeClient!.del(key),
+                "Redis DEL"
+            );
+            return true;
+        } catch (error) {
+            logger.error("Redis DEL error:", error);
+            return false;
+        }
+    }
+
+    public async sadd(key: string, member: string): Promise<boolean> {
+        if (!this.isRedisEnabled() || !this.writeClient) return false;
+
+        try {
+            await this.executeWithRetry(
+                () => this.writeClient!.sadd(key, member),
+                "Redis SADD"
+            );
+            return true;
+        } catch (error) {
+            logger.error("Redis SADD error:", error);
+            return false;
+        }
+    }
+
+    public async srem(key: string, member: string): Promise<boolean> {
+        if (!this.isRedisEnabled() || !this.writeClient) return false;
+
+        try {
+            await this.executeWithRetry(
+                () => this.writeClient!.srem(key, member),
+                "Redis SREM"
+            );
+            return true;
+        } catch (error) {
+            logger.error("Redis SREM error:", error);
+            return false;
+        }
+    }
+
+    public async smembers(key: string): Promise<string[]> {
+        if (!this.isRedisEnabled() || !this.readClient) return [];
+
+        try {
+            const fallbackOperation = (this.hasReplicas && this.writeClient && this.isWriteHealthy) 
+                ? () => this.writeClient!.smembers(key)
+                : undefined;
+
+            return await this.executeWithRetry(
+                () => this.readClient!.smembers(key),
+                "Redis SMEMBERS",
+                fallbackOperation
+            );
+        } catch (error) {
+            logger.error("Redis SMEMBERS error:", error);
+            return [];
+        }
+    }
+
+    public async hset(
+        key: string,
+        field: string,
+        value: string
+    ): Promise<boolean> {
+        if (!this.isRedisEnabled() || !this.writeClient) return false;
+
+        try {
+            await this.executeWithRetry(
+                () => this.writeClient!.hset(key, field, value),
+                "Redis HSET"
+            );
+            return true;
+        } catch (error) {
+            logger.error("Redis HSET error:", error);
+            return false;
+        }
+    }
+
+    public async hget(key: string, field: string): Promise<string | null> {
+        if (!this.isRedisEnabled() || !this.readClient) return null;
+
+        try {
+            const fallbackOperation = (this.hasReplicas && this.writeClient && this.isWriteHealthy) 
+                ? () => this.writeClient!.hget(key, field)
+                : undefined;
+
+            return await this.executeWithRetry(
+                () => this.readClient!.hget(key, field),
+                "Redis HGET",
+                fallbackOperation
+            );
+        } catch (error) {
+            logger.error("Redis HGET error:", error);
+            return null;
+        }
+    }
+
+    public async hdel(key: string, field: string): Promise<boolean> {
+        if (!this.isRedisEnabled() || !this.writeClient) return false;
+
+        try {
+            await this.executeWithRetry(
+                () => this.writeClient!.hdel(key, field),
+                "Redis HDEL"
+            );
+            return true;
+        } catch (error) {
+            logger.error("Redis HDEL error:", error);
+            return false;
+        }
+    }
+
+    public async hgetall(key: string): Promise<Record<string, string>> {
+        if (!this.isRedisEnabled() || !this.readClient) return {};
+
+        try {
+            const fallbackOperation = (this.hasReplicas && this.writeClient && this.isWriteHealthy) 
+                ? () => this.writeClient!.hgetall(key)
+                : undefined;
+
+            return await this.executeWithRetry(
+                () => this.readClient!.hgetall(key),
+                "Redis HGETALL",
+                fallbackOperation
+            );
+        } catch (error) {
+            logger.error("Redis HGETALL error:", error);
+            return {};
+        }
+    }
+
+    public async publish(channel: string, message: string): Promise<boolean> {
+        if (!this.isRedisEnabled() || !this.publisher) return false;
+
+        // Quick health check before attempting to publish
+        const isHealthy = await this.checkRedisHealth();
+        if (!isHealthy) {
+            logger.warn("Skipping Redis publish due to unhealthy connection");
+            return false;
+        }
+
+        try {
+            await this.executeWithRetry(
+                async () => {
+                    // Add timeout to prevent hanging
+                    return Promise.race([
+                        this.publisher!.publish(channel, message),
+                        new Promise((_, reject) => 
+                            setTimeout(() => reject(new Error('Redis publish timeout')), 3000)
+                        )
+                    ]);
+                },
+                "Redis PUBLISH"
+            );
+            return true;
+        } catch (error) {
+            logger.error("Redis PUBLISH error:", error);
+            this.isHealthy = false; // Mark as unhealthy on error
+            return false;
+        }
+    }
+
+    public async subscribe(
+        channel: string,
+        callback: (channel: string, message: string) => void
+    ): Promise<boolean> {
+        if (!this.isRedisEnabled() || !this.subscriber) return false;
+
+        try {
+            // Add callback to subscribers map
+            if (!this.subscribers.has(channel)) {
+                this.subscribers.set(channel, new Set());
+                // Only subscribe to the channel if it's the first subscriber
+                await this.executeWithRetry(
+                    async () => {
+                        return Promise.race([
+                            this.subscriber!.subscribe(channel),
+                            new Promise((_, reject) => 
+                                setTimeout(() => reject(new Error('Redis subscribe timeout')), 5000)
+                            )
+                        ]);
+                    },
+                    "Redis SUBSCRIBE"
+                );
+            }
+
+            this.subscribers.get(channel)!.add(callback);
+            return true;
+        } catch (error) {
+            logger.error("Redis SUBSCRIBE error:", error);
+            this.isHealthy = false;
+            return false;
+        }
+    }
+
+    public async unsubscribe(
+        channel: string,
+        callback?: (channel: string, message: string) => void
+    ): Promise<boolean> {
+        if (!this.isRedisEnabled() || !this.subscriber) return false;
+
+        try {
+            const channelSubscribers = this.subscribers.get(channel);
+            if (!channelSubscribers) return true;
+
+            if (callback) {
+                // Remove specific callback
+                channelSubscribers.delete(callback);
+                if (channelSubscribers.size === 0) {
+                    this.subscribers.delete(channel);
+                    await this.executeWithRetry(
+                        () => this.subscriber!.unsubscribe(channel),
+                        "Redis UNSUBSCRIBE"
+                    );
+                }
+            } else {
+                // Remove all callbacks for this channel
+                this.subscribers.delete(channel);
+                await this.executeWithRetry(
+                    () => this.subscriber!.unsubscribe(channel),
+                    "Redis UNSUBSCRIBE"
+                );
+            }
+
+            return true;
+        } catch (error) {
+            logger.error("Redis UNSUBSCRIBE error:", error);
+            return false;
+        }
+    }
+
+    public async disconnect(): Promise<void> {
+        try {
+            if (this.client) {
+                await this.client.quit();
+                this.client = null;
+            }
+            if (this.writeClient) {
+                await this.writeClient.quit();
+                this.writeClient = null;
+            }
+            if (this.readClient && this.readClient !== this.writeClient) {
+                await this.readClient.quit();
+                this.readClient = null;
+            }
+            if (this.publisher) {
+                await this.publisher.quit();
+                this.publisher = null;
+            }
+            if (this.subscriber) {
+                await this.subscriber.quit();
+                this.subscriber = null;
+            }
+            this.subscribers.clear();
+            logger.info("Redis clients disconnected");
+        } catch (error) {
+            logger.error("Error disconnecting Redis clients:", error);
+        }
+    }
+}
+
+export const redisManager = new RedisManager();
+export const redis = redisManager.getClient();
+export default redisManager;

server/db/private/redisStore.ts

@@ -0,0 +1,223 @@
+/*
+ * This file is part of a proprietary work.
+ *
+ * Copyright (c) 2025 Fossorial, Inc.
+ * All rights reserved.
+ *
+ * This file is licensed under the Fossorial Commercial License.
+ * You may not use this file except in compliance with the License.
+ * Unauthorized use, copying, modification, or distribution is strictly prohibited.
+ *
+ * This file is not licensed under the AGPLv3.
+ */
+
+import { Store, Options, IncrementResponse } from 'express-rate-limit';
+import { rateLimitService } from './rateLimit';
+import logger from '@server/logger';
+
+/**
+ * A Redis-backed rate limiting store for express-rate-limit that optimizes
+ * for local read performance and batched writes to Redis.
+ *
+ * This store uses the same optimized rate limiting logic as the WebSocket
+ * implementation, providing:
+ * - Local caching for fast reads
+ * - Batched writes to Redis to reduce load
+ * - Automatic cleanup of expired entries
+ * - Graceful fallback when Redis is unavailable
+ */
+export default class RedisStore implements Store {
+    /**
+     * The duration of time before which all hit counts are reset (in milliseconds).
+     */
+    windowMs!: number;
+
+    /**
+     * Maximum number of requests allowed within the window.
+     */
+    max!: number;
+
+    /**
+     * Optional prefix for Redis keys to avoid collisions.
+     */
+    prefix: string;
+
+    /**
+     * Whether to skip incrementing on failed requests.
+     */
+    skipFailedRequests: boolean;
+
+    /**
+     * Whether to skip incrementing on successful requests.
+     */
+    skipSuccessfulRequests: boolean;
+
+    /**
+     * @constructor for RedisStore.
+     *
+     * @param options - Configuration options for the store.
+     */
+    constructor(options: {
+        prefix?: string;
+        skipFailedRequests?: boolean;
+        skipSuccessfulRequests?: boolean;
+    } = {}) {
+        this.prefix = options.prefix || 'express-rate-limit';
+        this.skipFailedRequests = options.skipFailedRequests || false;
+        this.skipSuccessfulRequests = options.skipSuccessfulRequests || false;
+    }
+
+    /**
+     * Method that actually initializes the store. Must be synchronous.
+     *
+     * @param options - The options used to setup express-rate-limit.
+     */
+    init(options: Options): void {
+        this.windowMs = options.windowMs;
+        this.max = options.max as number;
+
+        // logger.debug(`RedisStore initialized with windowMs: ${this.windowMs}, max: ${this.max}, prefix: ${this.prefix}`);
+    }
+
+    /**
+     * Method to increment a client's hit counter.
+     *
+     * @param key - The identifier for a client (usually IP address).
+     * @returns Promise resolving to the number of hits and reset time for that client.
+     */
+    async increment(key: string): Promise<IncrementResponse> {
+        try {
+            const clientId = `${this.prefix}:${key}`;
+
+            const result = await rateLimitService.checkRateLimit(
+                clientId,
+                undefined, // No message type for HTTP requests
+                this.max,
+                undefined, // No message type limit
+                this.windowMs
+            );
+
+            // logger.debug(`Incremented rate limit for key: ${key} with max: ${this.max}, totalHits: ${result.totalHits}`);
+
+            return {
+                totalHits: result.totalHits || 1,
+                resetTime: result.resetTime || new Date(Date.now() + this.windowMs)
+            };
+        } catch (error) {
+            logger.error(`RedisStore increment error for key ${key}:`, error);
+
+            // Return safe defaults on error to prevent blocking requests
+            return {
+                totalHits: 1,
+                resetTime: new Date(Date.now() + this.windowMs)
+            };
+        }
+    }
+
+    /**
+     * Method to decrement a client's hit counter.
+     * Used when skipSuccessfulRequests or skipFailedRequests is enabled.
+     *
+     * @param key - The identifier for a client.
+     */
+    async decrement(key: string): Promise<void> {
+        try {
+            const clientId = `${this.prefix}:${key}`;
+            await rateLimitService.decrementRateLimit(clientId);
+
+            // logger.debug(`Decremented rate limit for key: ${key}`);
+        } catch (error) {
+            logger.error(`RedisStore decrement error for key ${key}:`, error);
+            // Don't throw - decrement failures shouldn't block requests
+        }
+    }
+
+    /**
+     * Method to reset a client's hit counter.
+     *
+     * @param key - The identifier for a client.
+     */
+    async resetKey(key: string): Promise<void> {
+        try {
+            const clientId = `${this.prefix}:${key}`;
+            await rateLimitService.resetKey(clientId);
+
+            // logger.debug(`Reset rate limit for key: ${key}`);
+        } catch (error) {
+            logger.error(`RedisStore resetKey error for key ${key}:`, error);
+            // Don't throw - reset failures shouldn't block requests
+        }
+    }
+
+    /**
+     * Method to reset everyone's hit counter.
+     *
+     * This method is optional and is never called by express-rate-limit.
+     * We implement it for completeness but it's not recommended for production use
+     * as it could be expensive with large datasets.
+     */
+    async resetAll(): Promise<void> {
+        try {
+            logger.warn('RedisStore resetAll called - this operation can be expensive');
+
+            // Force sync all pending data first
+            await rateLimitService.forceSyncAllPendingData();
+
+            // Note: We don't actually implement full reset as it would require
+            // scanning all Redis keys with our prefix, which could be expensive.
+            // In production, it's better to let entries expire naturally.
+
+            logger.info('RedisStore resetAll completed (pending data synced)');
+        } catch (error) {
+            logger.error('RedisStore resetAll error:', error);
+            // Don't throw - this is an optional method
+        }
+    }
+
+    /**
+     * Get current hit count for a key without incrementing.
+     * This is a custom method not part of the Store interface.
+     *
+     * @param key - The identifier for a client.
+     * @returns Current hit count and reset time, or null if no data exists.
+     */
+    async getHits(key: string): Promise<{ totalHits: number; resetTime: Date } | null> {
+        try {
+            const clientId = `${this.prefix}:${key}`;
+
+            // Use checkRateLimit with max + 1 to avoid actually incrementing
+            // but still get the current count
+            const result = await rateLimitService.checkRateLimit(
+                clientId,
+                undefined,
+                this.max + 1000, // Set artificially high to avoid triggering limit
+                undefined,
+                this.windowMs
+            );
+
+            // Decrement since we don't actually want to count this check
+            await rateLimitService.decrementRateLimit(clientId);
+
+            return {
+                totalHits: Math.max(0, (result.totalHits || 0) - 1), // Adjust for the decrement
+                resetTime: result.resetTime || new Date(Date.now() + this.windowMs)
+            };
+        } catch (error) {
+            logger.error(`RedisStore getHits error for key ${key}:`, error);
+            return null;
+        }
+    }
+
+    /**
+     * Cleanup method for graceful shutdown.
+     * This is not part of the Store interface but is useful for cleanup.
+     */
+    async shutdown(): Promise<void> {
+        try {
+            // The rateLimitService handles its own cleanup
+            logger.info('RedisStore shutdown completed');
+        } catch (error) {
+            logger.error('RedisStore shutdown error:', error);
+        }
+    }
+}

server/db/queries/verifySessionQueries.ts

@@ -1,4 +1,4 @@
-import { db } from "@server/db";
+import { db, loginPage, LoginPage, loginPageOrg } from "@server/db";
 import {
     Resource,
     ResourcePassword,
@@ -39,7 +39,10 @@ export async function getResourceByDomain(
 ): Promise<ResourceWithAuth | null> {
     if (config.isManagedMode()) {
         try {
-            const response = await axios.get(`${config.getRawConfig().managed?.endpoint}/api/v1/hybrid/resource/domain/${domain}`, await tokenManager.getAuthHeader());
+            const response = await axios.get(
+                `${config.getRawConfig().managed?.endpoint}/api/v1/hybrid/resource/domain/${domain}`,
+                await tokenManager.getAuthHeader()
+            );
             return response.data.data;
         } catch (error) {
             if (axios.isAxiosError(error)) {
@@ -91,7 +94,10 @@ export async function getUserSessionWithUser(
 ): Promise<UserSessionWithUser | null> {
     if (config.isManagedMode()) {
         try {
-            const response = await axios.get(`${config.getRawConfig().managed?.endpoint}/api/v1/hybrid/session/${userSessionId}`, await tokenManager.getAuthHeader());
+            const response = await axios.get(
+                `${config.getRawConfig().managed?.endpoint}/api/v1/hybrid/session/${userSessionId}`,
+                await tokenManager.getAuthHeader()
+            );
             return response.data.data;
         } catch (error) {
             if (axios.isAxiosError(error)) {
@@ -132,7 +138,10 @@ export async function getUserSessionWithUser(
 export async function getUserOrgRole(userId: string, orgId: string) {
     if (config.isManagedMode()) {
         try {
-            const response = await axios.get(`${config.getRawConfig().managed?.endpoint}/api/v1/hybrid/user/${userId}/org/${orgId}/role`, await tokenManager.getAuthHeader());
+            const response = await axios.get(
+                `${config.getRawConfig().managed?.endpoint}/api/v1/hybrid/user/${userId}/org/${orgId}/role`,
+                await tokenManager.getAuthHeader()
+            );
             return response.data.data;
         } catch (error) {
             if (axios.isAxiosError(error)) {
@@ -154,12 +163,7 @@ export async function getUserOrgRole(userId: string, orgId: string) {
     const userOrgRole = await db
         .select()
         .from(userOrgs)
-        .where(
-            and(
-                eq(userOrgs.userId, userId),
-                eq(userOrgs.orgId, orgId)
-            )
-        )
+        .where(and(eq(userOrgs.userId, userId), eq(userOrgs.orgId, orgId)))
         .limit(1);
 
     return userOrgRole.length > 0 ? userOrgRole[0] : null;
@@ -168,10 +172,16 @@ export async function getUserOrgRole(userId: string, orgId: string) {
 /**
  * Check if role has access to resource
  */
-export async function getRoleResourceAccess(resourceId: number, roleId: number) {
+export async function getRoleResourceAccess(
+    resourceId: number,
+    roleId: number
+) {
     if (config.isManagedMode()) {
         try {
-            const response = await axios.get(`${config.getRawConfig().managed?.endpoint}/api/v1/hybrid/role/${roleId}/resource/${resourceId}/access`, await tokenManager.getAuthHeader());
+            const response = await axios.get(
+                `${config.getRawConfig().managed?.endpoint}/api/v1/hybrid/role/${roleId}/resource/${resourceId}/access`,
+                await tokenManager.getAuthHeader()
+            );
             return response.data.data;
         } catch (error) {
             if (axios.isAxiosError(error)) {
@@ -207,10 +217,16 @@ export async function getRoleResourceAccess(resourceId: number, roleId: number)
 /**
  * Check if user has direct access to resource
  */
-export async function getUserResourceAccess(userId: string, resourceId: number) {
+export async function getUserResourceAccess(
+    userId: string,
+    resourceId: number
+) {
     if (config.isManagedMode()) {
         try {
-            const response = await axios.get(`${config.getRawConfig().managed?.endpoint}/api/v1/hybrid/user/${userId}/resource/${resourceId}/access`, await tokenManager.getAuthHeader());
+            const response = await axios.get(
+                `${config.getRawConfig().managed?.endpoint}/api/v1/hybrid/user/${userId}/resource/${resourceId}/access`,
+                await tokenManager.getAuthHeader()
+            );
             return response.data.data;
         } catch (error) {
             if (axios.isAxiosError(error)) {
@@ -246,10 +262,15 @@ export async function getUserResourceAccess(userId: string, resourceId: number)
 /**
  * Get resource rules for a given resource
  */
-export async function getResourceRules(resourceId: number): Promise<ResourceRule[]> {
+export async function getResourceRules(
+    resourceId: number
+): Promise<ResourceRule[]> {
     if (config.isManagedMode()) {
         try {
-            const response = await axios.get(`${config.getRawConfig().managed?.endpoint}/api/v1/hybrid/resource/${resourceId}/rules`, await tokenManager.getAuthHeader());
+            const response = await axios.get(
+                `${config.getRawConfig().managed?.endpoint}/api/v1/hybrid/resource/${resourceId}/rules`,
+                await tokenManager.getAuthHeader()
+            );
             return response.data.data;
         } catch (error) {
             if (axios.isAxiosError(error)) {
@@ -275,3 +296,50 @@ export async function getResourceRules(resourceId: number): Promise<ResourceRule
 
     return rules;
 }
+
+/**
+ * Get organization login page
+ */
+export async function getOrgLoginPage(
+    orgId: string
+): Promise<LoginPage | null> {
+    if (config.isManagedMode()) {
+        try {
+            const response = await axios.get(
+                `${config.getRawConfig().managed?.endpoint}/api/v1/hybrid/org/${orgId}/login-page`,
+                await tokenManager.getAuthHeader()
+            );
+            return response.data.data;
+        } catch (error) {
+            if (axios.isAxiosError(error)) {
+                logger.error("Error fetching config in verify session:", {
+                    message: error.message,
+                    code: error.code,
+                    status: error.response?.status,
+                    statusText: error.response?.statusText,
+                    url: error.config?.url,
+                    method: error.config?.method
+                });
+            } else {
+                logger.error("Error fetching config in verify session:", error);
+            }
+            return null;
+        }
+    }
+
+    const [result] = await db
+        .select()
+        .from(loginPageOrg)
+        .where(eq(loginPageOrg.orgId, orgId))
+        .innerJoin(
+            loginPage,
+            eq(loginPageOrg.loginPageId, loginPage.loginPageId)
+        )
+        .limit(1);
+
+    if (!result) {
+        return null;
+    }
+
+    return result?.loginPage;
+}

server/db/sqlite/index.ts

@@ -1,2 +1,3 @@
 export * from "./driver";
 export * from "./schema";
+export * from "./privateSchema";

server/db/sqlite/privateSchema.ts

@@ -0,0 +1,239 @@
+/*
+ * This file is part of a proprietary work.
+ *
+ * Copyright (c) 2025 Fossorial, Inc.
+ * All rights reserved.
+ *
+ * This file is licensed under the Fossorial Commercial License.
+ * You may not use this file except in compliance with the License.
+ * Unauthorized use, copying, modification, or distribution is strictly prohibited.
+ *
+ * This file is not licensed under the AGPLv3.
+ */
+
+import {
+    sqliteTable,
+    integer,
+    text,
+    real
+} from "drizzle-orm/sqlite-core";
+import { InferSelectModel } from "drizzle-orm";
+import { domains, orgs, targets, users, exitNodes, sessions } from "./schema";
+
+export const certificates = sqliteTable("certificates", {
+    certId: integer("certId").primaryKey({ autoIncrement: true }),
+    domain: text("domain").notNull().unique(),
+    domainId: text("domainId").references(() => domains.domainId, {
+        onDelete: "cascade"
+    }),
+    wildcard: integer("wildcard", { mode: "boolean" }).default(false),
+    status: text("status").notNull().default("pending"), // pending, requested, valid, expired, failed
+    expiresAt: integer("expiresAt"),
+    lastRenewalAttempt: integer("lastRenewalAttempt"),
+    createdAt: integer("createdAt").notNull(),
+    updatedAt: integer("updatedAt").notNull(),
+    orderId: text("orderId"),
+    errorMessage: text("errorMessage"),
+    renewalCount: integer("renewalCount").default(0),
+    certFile: text("certFile"),
+    keyFile: text("keyFile")
+});
+
+export const dnsChallenge = sqliteTable("dnsChallenges", {
+    dnsChallengeId: integer("dnsChallengeId").primaryKey({ autoIncrement: true }),
+    domain: text("domain").notNull(),
+    token: text("token").notNull(),
+    keyAuthorization: text("keyAuthorization").notNull(),
+    createdAt: integer("createdAt").notNull(),
+    expiresAt: integer("expiresAt").notNull(),
+    completed: integer("completed", { mode: "boolean" }).default(false)
+});
+
+export const account = sqliteTable("account", {
+    accountId: integer("accountId").primaryKey({ autoIncrement: true }),
+    userId: text("userId")
+        .notNull()
+        .references(() => users.userId, { onDelete: "cascade" })
+});
+
+export const customers = sqliteTable("customers", {
+    customerId: text("customerId").primaryKey().notNull(),
+    orgId: text("orgId")
+        .notNull()
+        .references(() => orgs.orgId, { onDelete: "cascade" }),
+    // accountId: integer("accountId")
+    //     .references(() => account.accountId, { onDelete: "cascade" }), // Optional, if using accounts
+    email: text("email"),
+    name: text("name"),
+    phone: text("phone"),
+    address: text("address"),
+    createdAt: integer("createdAt").notNull(),
+    updatedAt: integer("updatedAt").notNull()
+});
+
+export const subscriptions = sqliteTable("subscriptions", {
+    subscriptionId: text("subscriptionId")
+        .primaryKey()
+        .notNull(),
+    customerId: text("customerId")
+        .notNull()
+        .references(() => customers.customerId, { onDelete: "cascade" }),
+    status: text("status").notNull().default("active"), // active, past_due, canceled, unpaid
+    canceledAt: integer("canceledAt"),
+    createdAt: integer("createdAt").notNull(),
+    updatedAt: integer("updatedAt"),
+    billingCycleAnchor: integer("billingCycleAnchor")
+});
+
+export const subscriptionItems = sqliteTable("subscriptionItems", {
+    subscriptionItemId: integer("subscriptionItemId").primaryKey({ autoIncrement: true }),
+    subscriptionId: text("subscriptionId")
+        .notNull()
+        .references(() => subscriptions.subscriptionId, {
+            onDelete: "cascade"
+        }),
+    planId: text("planId").notNull(),
+    priceId: text("priceId"),
+    meterId: text("meterId"),
+    unitAmount: real("unitAmount"),
+    tiers: text("tiers"),
+    interval: text("interval"),
+    currentPeriodStart: integer("currentPeriodStart"),
+    currentPeriodEnd: integer("currentPeriodEnd"),
+    name: text("name")
+});
+
+export const accountDomains = sqliteTable("accountDomains", {
+    accountId: integer("accountId")
+        .notNull()
+        .references(() => account.accountId, { onDelete: "cascade" }),
+    domainId: text("domainId")
+        .notNull()
+        .references(() => domains.domainId, { onDelete: "cascade" })
+});
+
+export const usage = sqliteTable("usage", {
+    usageId: text("usageId").primaryKey(),
+    featureId: text("featureId").notNull(),
+    orgId: text("orgId")
+        .references(() => orgs.orgId, { onDelete: "cascade" })
+        .notNull(),
+    meterId: text("meterId"),
+    instantaneousValue: real("instantaneousValue"),
+    latestValue: real("latestValue").notNull(),
+    previousValue: real("previousValue"),
+    updatedAt: integer("updatedAt").notNull(),
+    rolledOverAt: integer("rolledOverAt"),
+    nextRolloverAt: integer("nextRolloverAt")
+});
+
+export const limits = sqliteTable("limits", {
+    limitId: text("limitId").primaryKey(),
+    featureId: text("featureId").notNull(),
+    orgId: text("orgId")
+        .references(() => orgs.orgId, {
+            onDelete: "cascade"
+        })
+        .notNull(),
+    value: real("value"),
+    description: text("description")
+});
+
+export const usageNotifications = sqliteTable("usageNotifications", {
+    notificationId: integer("notificationId").primaryKey({ autoIncrement: true }),
+    orgId: text("orgId")
+        .notNull()
+        .references(() => orgs.orgId, { onDelete: "cascade" }),
+    featureId: text("featureId").notNull(),
+    limitId: text("limitId").notNull(),
+    notificationType: text("notificationType").notNull(),
+    sentAt: integer("sentAt").notNull()
+});
+
+export const domainNamespaces = sqliteTable("domainNamespaces", {
+    domainNamespaceId: text("domainNamespaceId").primaryKey(),
+    domainId: text("domainId")
+        .references(() => domains.domainId, {
+            onDelete: "set null"
+        })
+        .notNull()
+});
+
+export const exitNodeOrgs = sqliteTable("exitNodeOrgs", {
+    exitNodeId: integer("exitNodeId")
+        .notNull()
+        .references(() => exitNodes.exitNodeId, { onDelete: "cascade" }),
+    orgId: text("orgId")
+        .notNull()
+        .references(() => orgs.orgId, { onDelete: "cascade" })
+});
+
+export const remoteExitNodes = sqliteTable("remoteExitNode", {
+    remoteExitNodeId: text("id").primaryKey(),
+    secretHash: text("secretHash").notNull(),
+    dateCreated: text("dateCreated").notNull(),
+    version: text("version"),
+    exitNodeId: integer("exitNodeId").references(() => exitNodes.exitNodeId, {
+        onDelete: "cascade"
+    })
+});
+
+export const remoteExitNodeSessions = sqliteTable("remoteExitNodeSession", {
+    sessionId: text("id").primaryKey(),
+    remoteExitNodeId: text("remoteExitNodeId")
+        .notNull()
+        .references(() => remoteExitNodes.remoteExitNodeId, {
+            onDelete: "cascade"
+        }),
+    expiresAt: integer("expiresAt").notNull()
+});
+
+export const loginPage = sqliteTable("loginPage", {
+    loginPageId: integer("loginPageId").primaryKey({ autoIncrement: true }),
+    subdomain: text("subdomain"),
+    fullDomain: text("fullDomain"),
+    exitNodeId: integer("exitNodeId").references(() => exitNodes.exitNodeId, {
+        onDelete: "set null"
+    }),
+    domainId: text("domainId").references(() => domains.domainId, {
+        onDelete: "set null"
+    })
+});
+
+export const loginPageOrg = sqliteTable("loginPageOrg", {
+    loginPageId: integer("loginPageId")
+        .notNull()
+        .references(() => loginPage.loginPageId, { onDelete: "cascade" }),
+    orgId: text("orgId")
+        .notNull()
+        .references(() => orgs.orgId, { onDelete: "cascade" })
+});
+
+export const sessionTransferToken = sqliteTable("sessionTransferToken", {
+    token: text("token").primaryKey(),
+    sessionId: text("sessionId")
+        .notNull()
+        .references(() => sessions.sessionId, {
+            onDelete: "cascade"
+        }),
+    encryptedSession: text("encryptedSession").notNull(),
+    expiresAt: integer("expiresAt").notNull()
+});
+
+export type Limit = InferSelectModel<typeof limits>;
+export type Account = InferSelectModel<typeof account>;
+export type Certificate = InferSelectModel<typeof certificates>;
+export type DnsChallenge = InferSelectModel<typeof dnsChallenge>;
+export type Customer = InferSelectModel<typeof customers>;
+export type Subscription = InferSelectModel<typeof subscriptions>;
+export type SubscriptionItem = InferSelectModel<typeof subscriptionItems>;
+export type Usage = InferSelectModel<typeof usage>;
+export type UsageLimit = InferSelectModel<typeof limits>;
+export type AccountDomain = InferSelectModel<typeof accountDomains>;
+export type UsageNotification = InferSelectModel<typeof usageNotifications>;
+export type RemoteExitNode = InferSelectModel<typeof remoteExitNodes>;
+export type RemoteExitNodeSession = InferSelectModel<
+    typeof remoteExitNodeSessions
+>;
+export type ExitNodeOrg = InferSelectModel<typeof exitNodeOrgs>;
+export type LoginPage = InferSelectModel<typeof loginPage>;

server/db/sqlite/schema.ts

@@ -140,6 +140,27 @@ export const targets = sqliteTable("targets", {
     rewritePathType: text("rewritePathType") // exact, prefix, regex, stripPrefix
 });
 
+export const targetHealthCheck = sqliteTable("targetHealthCheck", {
+    targetHealthCheckId: integer("targetHealthCheckId").primaryKey({ autoIncrement: true }),
+    targetId: integer("targetId")
+        .notNull()
+        .references(() => targets.targetId, { onDelete: "cascade" }),
+    hcEnabled: integer("hcEnabled", { mode: "boolean" }).notNull().default(false),
+    hcPath: text("hcPath"),
+    hcScheme: text("hcScheme"),
+    hcMode: text("hcMode").default("http"),
+    hcHostname: text("hcHostname"),
+    hcPort: integer("hcPort"),
+    hcInterval: integer("hcInterval").default(30), // in seconds
+    hcUnhealthyInterval: integer("hcUnhealthyInterval").default(30), // in seconds
+    hcTimeout: integer("hcTimeout").default(5), // in seconds
+    hcHeaders: text("hcHeaders"),
+    hcFollowRedirects: integer("hcFollowRedirects", { mode: "boolean" }).default(true),
+    hcMethod: text("hcMethod").default("GET"),
+    hcStatus: integer("hcStatus"), // http code
+    hcHealth: text("hcHealth").default("unknown") // "unknown", "healthy", "unhealthy"
+});
+
 export const exitNodes = sqliteTable("exitNodes", {
     exitNodeId: integer("exitNodeId").primaryKey({ autoIncrement: true }),
     name: text("name").notNull(),
@@ -458,18 +479,6 @@ export const userResources = sqliteTable("userResources", {
         .references(() => resources.resourceId, { onDelete: "cascade" })
 });
 
-export const limitsTable = sqliteTable("limits", {
-    limitId: integer("limitId").primaryKey({ autoIncrement: true }),
-    orgId: text("orgId")
-        .references(() => orgs.orgId, {
-            onDelete: "cascade"
-        })
-        .notNull(),
-    name: text("name").notNull(),
-    value: integer("value").notNull(),
-    description: text("description")
-});
-
 export const userInvites = sqliteTable("userInvites", {
     inviteId: text("inviteId").primaryKey(),
     orgId: text("orgId")
@@ -714,7 +723,6 @@ export type RoleSite = InferSelectModel<typeof roleSites>;
 export type UserSite = InferSelectModel<typeof userSites>;
 export type RoleResource = InferSelectModel<typeof roleResources>;
 export type UserResource = InferSelectModel<typeof userResources>;
-export type Limit = InferSelectModel<typeof limitsTable>;
 export type UserInvite = InferSelectModel<typeof userInvites>;
 export type UserOrg = InferSelectModel<typeof userOrgs>;
 export type ResourceSession = InferSelectModel<typeof resourceSessions>;
@@ -739,3 +747,4 @@ export type SiteResource = InferSelectModel<typeof siteResources>;
 export type OrgDomains = InferSelectModel<typeof orgDomains>;
 export type SetupToken = InferSelectModel<typeof setupTokens>;
 export type HostMeta = InferSelectModel<typeof hostMeta>;
+export type TargetHealthCheck = InferSelectModel<typeof targetHealthCheck>;

server/emails/sendEmail.ts

@@ -11,7 +11,7 @@ export async function sendEmail(
         from: string | undefined;
         to: string | undefined;
         subject: string;
-    },
+    }
 ) {
     if (!emailClient) {
         logger.warn("Email client not configured, skipping email send");
@@ -25,16 +25,16 @@ export async function sendEmail(
 
     const emailHtml = await render(template);
 
-    const appName = "Pangolin";
+    const appName = config.getRawPrivateConfig().branding?.app_name || "Pangolin";
 
     await emailClient.sendMail({
         from: {
             name: opts.name || appName,
-            address: opts.from,
+            address: opts.from
         },
         to: opts.to,
         subject: opts.subject,
-        html: emailHtml,
+        html: emailHtml
     });
 }
 

server/emails/templates/PrivateNotifyUsageLimitApproaching.tsx

@@ -0,0 +1,82 @@
+/*
+ * This file is part of a proprietary work.
+ *
+ * Copyright (c) 2025 Fossorial, Inc.
+ * All rights reserved.
+ *
+ * This file is licensed under the Fossorial Commercial License.
+ * You may not use this file except in compliance with the License.
+ * Unauthorized use, copying, modification, or distribution is strictly prohibited.
+ *
+ * This file is not licensed under the AGPLv3.
+ */
+
+import React from "react";
+import { Body, Head, Html, Preview, Tailwind } from "@react-email/components";
+import { themeColors } from "./lib/theme";
+import {
+    EmailContainer,
+    EmailFooter,
+    EmailGreeting,
+    EmailHeading,
+    EmailLetterHead,
+    EmailSignature,
+    EmailText
+} from "./components/Email";
+
+interface Props {
+    email: string;
+    limitName: string;
+    currentUsage: number;
+    usageLimit: number;
+    billingLink: string; // Link to billing page
+}
+
+export const NotifyUsageLimitApproaching = ({ email, limitName, currentUsage, usageLimit, billingLink }: Props) => {
+    const previewText = `Your usage for ${limitName} is approaching the limit.`;
+    const usagePercentage = Math.round((currentUsage / usageLimit) * 100);
+
+    return (
+        <Html>
+            <Head />
+            <Preview>{previewText}</Preview>
+            <Tailwind config={themeColors}>
+                <Body className="font-sans bg-gray-50">
+                    <EmailContainer>
+                        <EmailLetterHead />
+
+                        <EmailHeading>Usage Limit Warning</EmailHeading>
+
+                        <EmailGreeting>Hi there,</EmailGreeting>
+
+                        <EmailText>
+                            We wanted to let you know that your usage for <strong>{limitName}</strong> is approaching your plan limit.
+                        </EmailText>
+
+                        <EmailText>
+                            <strong>Current Usage:</strong> {currentUsage} of {usageLimit} ({usagePercentage}%)
+                        </EmailText>
+
+                        <EmailText>
+                            Once you reach your limit, some functionality may be restricted or your sites may disconnect until you upgrade your plan or your usage resets.
+                        </EmailText>
+
+                        <EmailText>
+                            To avoid any interruption to your service, we recommend upgrading your plan or monitoring your usage closely. You can <a href={billingLink}>upgrade your plan here</a>.
+                        </EmailText>
+
+                        <EmailText>
+                            If you have any questions or need assistance, please don't hesitate to reach out to our support team.
+                        </EmailText>
+
+                        <EmailFooter>
+                            <EmailSignature />
+                        </EmailFooter>
+                    </EmailContainer>
+                </Body>
+            </Tailwind>
+        </Html>
+    );
+};
+
+export default NotifyUsageLimitApproaching;

server/emails/templates/PrivateNotifyUsageLimitReached.tsx

@@ -0,0 +1,84 @@
+/*
+ * This file is part of a proprietary work.
+ *
+ * Copyright (c) 2025 Fossorial, Inc.
+ * All rights reserved.
+ *
+ * This file is licensed under the Fossorial Commercial License.
+ * You may not use this file except in compliance with the License.
+ * Unauthorized use, copying, modification, or distribution is strictly prohibited.
+ *
+ * This file is not licensed under the AGPLv3.
+ */
+
+import React from "react";
+import { Body, Head, Html, Preview, Tailwind } from "@react-email/components";
+import { themeColors } from "./lib/theme";
+import {
+    EmailContainer,
+    EmailFooter,
+    EmailGreeting,
+    EmailHeading,
+    EmailLetterHead,
+    EmailSignature,
+    EmailText
+} from "./components/Email";
+
+interface Props {
+    email: string;
+    limitName: string;
+    currentUsage: number;
+    usageLimit: number;
+    billingLink: string; // Link to billing page
+}
+
+export const NotifyUsageLimitReached = ({ email, limitName, currentUsage, usageLimit, billingLink }: Props) => {
+    const previewText = `You've reached your ${limitName} usage limit - Action required`;
+    const usagePercentage = Math.round((currentUsage / usageLimit) * 100);
+
+    return (
+        <Html>
+            <Head />
+            <Preview>{previewText}</Preview>
+            <Tailwind config={themeColors}>
+                <Body className="font-sans bg-gray-50">
+                    <EmailContainer>
+                        <EmailLetterHead />
+
+                        <EmailHeading>Usage Limit Reached - Action Required</EmailHeading>
+
+                        <EmailGreeting>Hi there,</EmailGreeting>
+
+                        <EmailText>
+                            You have reached your usage limit for <strong>{limitName}</strong>.
+                        </EmailText>
+
+                        <EmailText>
+                            <strong>Current Usage:</strong> {currentUsage} of {usageLimit} ({usagePercentage}%)
+                        </EmailText>
+
+                        <EmailText>
+                            <strong>Important:</strong> Your functionality may now be restricted and your sites may disconnect until you either upgrade your plan or your usage resets. To prevent any service interruption, immediate action is recommended.
+                        </EmailText>
+
+                        <EmailText>
+                            <strong>What you can do:</strong>
+                            <br />• <a href={billingLink} style={{ color: '#2563eb', fontWeight: 'bold' }}>Upgrade your plan immediately</a> to restore full functionality
+                            <br />• Monitor your usage to stay within limits in the future
+                        </EmailText>
+
+                        <EmailText>
+                            If you have any questions or need immediate assistance, please contact our support team right away.
+                        </EmailText>
+
+                        <EmailFooter>
+                            <EmailSignature />
+                        </EmailFooter>
+                    </EmailContainer>
+                </Body>
+            </Tailwind>
+        </Html>
+    );
+};
+
+export default NotifyUsageLimitReached;

server/emails/templates/components/Email.tsx

@@ -17,7 +17,7 @@ export function EmailLetterHead() {
         <div className="px-6 pt-8 pb-2 text-center">
             <Img
                 src="https://fossorial-public-assets.s3.us-east-1.amazonaws.com/word_mark_black.png"
-                alt="Fossorial"
+                alt="Pangolin Logo"
                 width="120"
                 height="auto"
                 className="mx-auto"
@@ -107,7 +107,7 @@ export function EmailSignature() {
             <p className="mb-2">
                 Best regards,
                 <br />
-                <strong>The Fossorial Team</strong>
+                <strong>The Pangolin Team</strong>
             </p>
         </div>
     );

server/hybridServer.ts

@@ -3,7 +3,7 @@ import config from "@server/lib/config";
 import { createWebSocketClient } from "./routers/ws/client";
 import { addPeer, deletePeer } from "./routers/gerbil/peers";
 import { db, exitNodes } from "./db";
-import { TraefikConfigManager } from "./lib/traefikConfig";
+import { TraefikConfigManager } from "./lib/traefik/TraefikConfigManager";
 import { tokenManager } from "./lib/tokenManager";
 import { APP_VERSION } from "./lib/consts";
 import axios from "axios";

server/index.ts

@@ -5,13 +5,13 @@ import { runSetupFunctions } from "./setup";
 import { createApiServer } from "./apiServer";
 import { createNextServer } from "./nextServer";
 import { createInternalServer } from "./internalServer";
-import { ApiKey, ApiKeyOrg, Session, User, UserOrg } from "@server/db";
+import { ApiKey, ApiKeyOrg, RemoteExitNode, Session, User, UserOrg } from "@server/db";
 import { createIntegrationApiServer } from "./integrationApiServer";
 import { createHybridClientServer } from "./hybridServer";
 import config from "@server/lib/config";
 import { setHostMeta } from "@server/lib/hostMeta";
 import { initTelemetryClient } from "./lib/telemetry.js";
-import { TraefikConfigManager } from "./lib/traefikConfig.js";
+import { TraefikConfigManager } from "./lib/traefik/TraefikConfigManager.js";
 
 async function startServers() {
     await setHostMeta();
@@ -63,6 +63,7 @@ declare global {
             userOrgRoleId?: number;
             userOrgId?: string;
             userOrgIds?: string[];
+            remoteExitNode?: RemoteExitNode;
         }
     }
 }

server/integrationApiServer.ts

@@ -13,6 +13,10 @@ import helmet from "helmet";
 import swaggerUi from "swagger-ui-express";
 import { OpenApiGeneratorV3 } from "@asteasolutions/zod-to-openapi";
 import { registry } from "./openApi";
+import fs from "fs";
+import path from "path";
+import { APP_PATH } from "./lib/consts";
+import yaml from "js-yaml";
 
 const dev = process.env.ENVIRONMENT !== "prod";
 const externalPort = config.getRawConfig().server.integration_port;
@@ -92,7 +96,7 @@ function getOpenApiDocumentation() {
 
     const generator = new OpenApiGeneratorV3(registry.definitions);
 
-    return generator.generateDocument({
+    const generated = generator.generateDocument({
         openapi: "3.0.0",
         info: {
             version: "v1",
@@ -100,4 +104,12 @@ function getOpenApiDocumentation() {
         },
         servers: [{ url: "/v1" }]
     });
+
+    // convert to yaml and save to file
+    const outputPath = path.join(APP_PATH, "openapi.yaml");
+    const yamlOutput = yaml.dump(generated);
+    fs.writeFileSync(outputPath, yamlOutput, "utf8");
+    logger.info(`OpenAPI documentation saved to ${outputPath}`);
+
+    return generated;
 }

server/lib/blueprints/applyBlueprint.ts

@@ -69,9 +69,16 @@ export async function applyBlueprint(
                         `Updating target ${target.targetId} on site ${site.sites.siteId}`
                     );
 
+                    // see if you can find a matching target health check from the healthchecksToUpdate array
+                    const matchingHealthcheck =
+                        result.healthchecksToUpdate.find(
+                            (hc) => hc.targetId === target.targetId
+                        );
+
                     await addProxyTargets(
                         site.newt.newtId,
                         [target],
+                        matchingHealthcheck ? [matchingHealthcheck] : [],
                         result.proxyResource.protocol,
                         result.proxyResource.proxyPort
                     );

server/lib/blueprints/proxyResources.ts

@@ -8,6 +8,8 @@ import {
     roleResources,
     roles,
     Target,
+    TargetHealthCheck,
+    targetHealthCheck,
     Transaction,
     userOrgs,
     userResources,
@@ -22,6 +24,7 @@ import {
     TargetData
 } from "./types";
 import logger from "@server/logger";
+import { createCertificate } from "@server/routers/private/certificates/createCertificate";
 import { pickPort } from "@server/routers/target/helpers";
 import { resourcePassword } from "@server/db";
 import { hashPassword } from "@server/auth/password";
@@ -30,6 +33,7 @@ import { isValidCIDR, isValidIP, isValidUrlGlobPattern } from "../validators";
 export type ProxyResourcesResults = {
     proxyResource: Resource;
     targetsToUpdate: Target[];
+    healthchecksToUpdate: TargetHealthCheck[];
 }[];
 
 export async function updateProxyResources(
@@ -43,7 +47,8 @@ export async function updateProxyResources(
     for (const [resourceNiceId, resourceData] of Object.entries(
         config["proxy-resources"]
     )) {
-        const targetsToUpdate: Target[] = [];
+        let targetsToUpdate: Target[] = [];
+        let healthchecksToUpdate: TargetHealthCheck[] = [];
         let resource: Resource;
 
         async function createTarget( // reusable function to create a target
@@ -114,6 +119,33 @@ export async function updateProxyResources(
                 .returning();
 
             targetsToUpdate.push(newTarget);
+
+            const healthcheckData = targetData.healthcheck;
+
+            const hcHeaders = healthcheckData?.headers ? JSON.stringify(healthcheckData.headers) : null;
+
+            const [newHealthcheck] = await trx
+                .insert(targetHealthCheck)
+                .values({
+                    targetId: newTarget.targetId,
+                    hcEnabled: healthcheckData?.enabled || false,
+                    hcPath: healthcheckData?.path,
+                    hcScheme: healthcheckData?.scheme,
+                    hcMode: healthcheckData?.mode,
+                    hcHostname: healthcheckData?.hostname,
+                    hcPort: healthcheckData?.port,
+                    hcInterval: healthcheckData?.interval,
+                    hcUnhealthyInterval: healthcheckData?.unhealthyInterval,
+                    hcTimeout: healthcheckData?.timeout,
+                    hcHeaders: hcHeaders,
+                    hcFollowRedirects: healthcheckData?.followRedirects,
+                    hcMethod: healthcheckData?.method,
+                    hcStatus: healthcheckData?.status,
+                    hcHealth: "unknown"
+                })
+                .returning();
+
+            healthchecksToUpdate.push(newHealthcheck);
         }
 
         // Find existing resource by niceId and orgId
@@ -360,6 +392,64 @@ export async function updateProxyResources(
 
                         targetsToUpdate.push(finalUpdatedTarget);
                     }
+
+                    const healthcheckData = targetData.healthcheck;
+
+                    const [oldHealthcheck] = await trx
+                        .select()
+                        .from(targetHealthCheck)
+                        .where(
+                            eq(
+                                targetHealthCheck.targetId,
+                                existingTarget.targetId
+                            )
+                        )
+                        .limit(1);
+
+                    const hcHeaders = healthcheckData?.headers ? JSON.stringify(healthcheckData.headers) : null;
+
+                    const [newHealthcheck] = await trx
+                        .update(targetHealthCheck)
+                        .set({
+                            hcEnabled: healthcheckData?.enabled || false,
+                            hcPath: healthcheckData?.path,
+                            hcScheme: healthcheckData?.scheme,
+                            hcMode: healthcheckData?.mode,
+                            hcHostname: healthcheckData?.hostname,
+                            hcPort: healthcheckData?.port,
+                            hcInterval: healthcheckData?.interval,
+                            hcUnhealthyInterval:
+                                healthcheckData?.unhealthyInterval,
+                            hcTimeout: healthcheckData?.timeout,
+                            hcHeaders: hcHeaders,
+                            hcFollowRedirects: healthcheckData?.followRedirects,
+                            hcMethod: healthcheckData?.method,
+                            hcStatus: healthcheckData?.status
+                        })
+                        .where(
+                            eq(
+                                targetHealthCheck.targetId,
+                                existingTarget.targetId
+                            )
+                        )
+                        .returning();
+
+                    if (
+                        checkIfHealthcheckChanged(
+                            oldHealthcheck,
+                            newHealthcheck
+                        )
+                    ) {
+                        healthchecksToUpdate.push(newHealthcheck);
+                        // if the target is not already in the targetsToUpdate array, add it
+                        if (
+                            !targetsToUpdate.find(
+                                (t) => t.targetId === updatedTarget.targetId
+                            )
+                        ) {
+                            targetsToUpdate.push(updatedTarget);
+                        }
+                    }
                 } else {
                     await createTarget(existingResource.resourceId, targetData);
                 }
@@ -573,7 +663,8 @@ export async function updateProxyResources(
 
         results.push({
             proxyResource: resource,
-            targetsToUpdate
+            targetsToUpdate,
+            healthchecksToUpdate
         });
     }
 
@@ -783,6 +874,36 @@ async function syncWhitelistUsers(
     }
 }
 
+function checkIfHealthcheckChanged(
+    existing: TargetHealthCheck | undefined,
+    incoming: TargetHealthCheck | undefined
+) {
+    if (!existing && incoming) return true;
+    if (existing && !incoming) return true;
+    if (!existing || !incoming) return false;
+
+    if (existing.hcEnabled !== incoming.hcEnabled) return true;
+    if (existing.hcPath !== incoming.hcPath) return true;
+    if (existing.hcScheme !== incoming.hcScheme) return true;
+    if (existing.hcMode !== incoming.hcMode) return true;
+    if (existing.hcHostname !== incoming.hcHostname) return true;
+    if (existing.hcPort !== incoming.hcPort) return true;
+    if (existing.hcInterval !== incoming.hcInterval) return true;
+    if (existing.hcUnhealthyInterval !== incoming.hcUnhealthyInterval)
+        return true;
+    if (existing.hcTimeout !== incoming.hcTimeout) return true;
+    if (existing.hcFollowRedirects !== incoming.hcFollowRedirects) return true;
+    if (existing.hcMethod !== incoming.hcMethod) return true;
+    if (existing.hcStatus !== incoming.hcStatus) return true;
+    if (
+        JSON.stringify(existing.hcHeaders) !==
+        JSON.stringify(incoming.hcHeaders)
+    )
+        return true;
+
+    return false;
+}
+
 function checkIfTargetChanged(
     existing: Target | undefined,
     incoming: Target | undefined
@@ -832,6 +953,8 @@ async function getDomain(
         );
     }
 
+    await createCertificate(domain.domainId, fullDomain, trx);
+
     return domain;
 }
 

server/lib/blueprints/types.ts

@@ -5,6 +5,22 @@ export const SiteSchema = z.object({
     "docker-socket-enabled": z.boolean().optional().default(true)
 });
 
+export const TargetHealthCheckSchema = z.object({
+    hostname: z.string(),
+    port: z.number().int().min(1).max(65535),
+    enabled: z.boolean().optional().default(true),
+    path: z.string().optional(),
+    scheme: z.string().optional(),
+    mode: z.string().default("http"),
+    interval: z.number().int().default(30),
+    unhealthyInterval: z.number().int().default(30),
+    timeout: z.number().int().default(5),
+    headers: z.array(z.object({ name: z.string(), value: z.string() })).nullable().optional().default(null),
+    followRedirects: z.boolean().default(true),
+    method: z.string().default("GET"),
+    status: z.number().int().optional()
+});
+
 // Schema for individual target within a resource
 export const TargetSchema = z.object({
     site: z.string().optional(),
@@ -15,6 +31,7 @@ export const TargetSchema = z.object({
     "internal-port": z.number().int().min(1).max(65535).optional(),
     path: z.string().optional(),
     "path-match": z.enum(["exact", "prefix", "regex"]).optional().nullable(),
+    healthcheck: TargetHealthCheckSchema.optional(),
     rewritePath: z.string().optional(),
     "rewrite-match": z.enum(["exact", "prefix", "regex", "stripPrefix"]).optional().nullable()
 });

server/lib/colorsSchema.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+
+export const colorsSchema = z.object({
+    background: z.string().optional(),
+    foreground: z.string().optional(),
+    card: z.string().optional(),
+    "card-foreground": z.string().optional(),
+    popover: z.string().optional(),
+    "popover-foreground": z.string().optional(),
+    primary: z.string().optional(),
+    "primary-foreground": z.string().optional(),
+    secondary: z.string().optional(),
+    "secondary-foreground": z.string().optional(),
+    muted: z.string().optional(),
+    "muted-foreground": z.string().optional(),
+    accent: z.string().optional(),
+    "accent-foreground": z.string().optional(),
+    destructive: z.string().optional(),
+    "destructive-foreground": z.string().optional(),
+    border: z.string().optional(),
+    input: z.string().optional(),
+    ring: z.string().optional(),
+    radius: z.string().optional(),
+    "chart-1": z.string().optional(),
+    "chart-2": z.string().optional(),
+    "chart-3": z.string().optional(),
+    "chart-4": z.string().optional(),
+    "chart-5": z.string().optional()
+});

server/lib/config.ts

@@ -6,9 +6,16 @@ import { eq } from "drizzle-orm";
 import { license } from "@server/license/license";
 import { configSchema, readConfigFile } from "./readConfigFile";
 import { fromError } from "zod-validation-error";
+import {
+    privateConfigSchema,
+    readPrivateConfigFile
+} from "@server/lib/private/readConfigFile";
+import logger from "@server/logger";
+import { build } from "@server/build";
 
 export class Config {
     private rawConfig!: z.infer<typeof configSchema>;
+    private rawPrivateConfig!: z.infer<typeof privateConfigSchema>;
 
     supporterData: SupporterKey | null = null;
 
@@ -30,6 +37,19 @@ export class Config {
             throw new Error(`Invalid configuration file: ${errors}`);
         }
 
+        const privateEnvironment = readPrivateConfigFile();
+
+        const {
+            data: parsedPrivateConfig,
+            success: privateSuccess,
+            error: privateError
+        } = privateConfigSchema.safeParse(privateEnvironment);
+
+        if (!privateSuccess) {
+            const errors = fromError(privateError);
+            throw new Error(`Invalid private configuration file: ${errors}`);
+        }
+
         if (
             // @ts-ignore
             parsedConfig.users ||
@@ -89,7 +109,110 @@ export class Config {
             ? "true"
             : "false";
 
+        if (parsedPrivateConfig.branding?.colors) {
+            process.env.BRANDING_COLORS = JSON.stringify(
+                parsedPrivateConfig.branding?.colors
+            );
+        }
+
+        if (parsedPrivateConfig.branding?.logo?.light_path) {
+            process.env.BRANDING_LOGO_LIGHT_PATH =
+                parsedPrivateConfig.branding?.logo?.light_path;
+        }
+        if (parsedPrivateConfig.branding?.logo?.dark_path) {
+            process.env.BRANDING_LOGO_DARK_PATH =
+                parsedPrivateConfig.branding?.logo?.dark_path || undefined;
+        }
+
+        process.env.HIDE_SUPPORTER_KEY = parsedPrivateConfig.flags
+            ?.hide_supporter_key
+            ? "true"
+            : "false";
+
+        if (build != "oss") {
+            if (parsedPrivateConfig.branding?.logo?.light_path) {
+                process.env.BRANDING_LOGO_LIGHT_PATH =
+                    parsedPrivateConfig.branding?.logo?.light_path;
+            }
+            if (parsedPrivateConfig.branding?.logo?.dark_path) {
+                process.env.BRANDING_LOGO_DARK_PATH =
+                    parsedPrivateConfig.branding?.logo?.dark_path || undefined;
+            }
+
+            process.env.BRANDING_LOGO_AUTH_WIDTH = parsedPrivateConfig.branding
+                ?.logo?.auth_page?.width
+                ? parsedPrivateConfig.branding?.logo?.auth_page?.width.toString()
+                : undefined;
+            process.env.BRANDING_LOGO_AUTH_HEIGHT = parsedPrivateConfig.branding
+                ?.logo?.auth_page?.height
+                ? parsedPrivateConfig.branding?.logo?.auth_page?.height.toString()
+                : undefined;
+
+            process.env.BRANDING_LOGO_NAVBAR_WIDTH = parsedPrivateConfig
+                .branding?.logo?.navbar?.width
+                ? parsedPrivateConfig.branding?.logo?.navbar?.width.toString()
+                : undefined;
+            process.env.BRANDING_LOGO_NAVBAR_HEIGHT = parsedPrivateConfig
+                .branding?.logo?.navbar?.height
+                ? parsedPrivateConfig.branding?.logo?.navbar?.height.toString()
+                : undefined;
+
+            process.env.BRANDING_FAVICON_PATH =
+                parsedPrivateConfig.branding?.favicon_path;
+
+            process.env.BRANDING_APP_NAME =
+                parsedPrivateConfig.branding?.app_name || "Pangolin";
+
+            if (parsedPrivateConfig.branding?.footer) {
+                process.env.BRANDING_FOOTER = JSON.stringify(
+                    parsedPrivateConfig.branding?.footer
+                );
+            }
+
+            process.env.LOGIN_PAGE_TITLE_TEXT =
+                parsedPrivateConfig.branding?.login_page?.title_text || "";
+            process.env.LOGIN_PAGE_SUBTITLE_TEXT =
+                parsedPrivateConfig.branding?.login_page?.subtitle_text || "";
+
+            process.env.SIGNUP_PAGE_TITLE_TEXT =
+                parsedPrivateConfig.branding?.signup_page?.title_text || "";
+            process.env.SIGNUP_PAGE_SUBTITLE_TEXT =
+                parsedPrivateConfig.branding?.signup_page?.subtitle_text || "";
+
+            process.env.RESOURCE_AUTH_PAGE_HIDE_POWERED_BY =
+                parsedPrivateConfig.branding?.resource_auth_page
+                    ?.hide_powered_by === true
+                    ? "true"
+                    : "false";
+            process.env.RESOURCE_AUTH_PAGE_SHOW_LOGO =
+                parsedPrivateConfig.branding?.resource_auth_page?.show_logo ===
+                true
+                    ? "true"
+                    : "false";
+            process.env.RESOURCE_AUTH_PAGE_TITLE_TEXT =
+                parsedPrivateConfig.branding?.resource_auth_page?.title_text ||
+                "";
+            process.env.RESOURCE_AUTH_PAGE_SUBTITLE_TEXT =
+                parsedPrivateConfig.branding?.resource_auth_page
+                    ?.subtitle_text || "";
+
+            if (parsedPrivateConfig.branding?.background_image_path) {
+                process.env.BACKGROUND_IMAGE_PATH =
+                    parsedPrivateConfig.branding?.background_image_path;
+            }
+
+            if (parsedPrivateConfig.server.reo_client_id) {
+                process.env.REO_CLIENT_ID =
+                    parsedPrivateConfig.server.reo_client_id;
+            }
+        }
+
+        if (parsedConfig.server.maxmind_db_path) {
+            process.env.MAXMIND_DB_PATH = parsedConfig.server.maxmind_db_path;
+        }
+
         this.rawConfig = parsedConfig;
+        this.rawPrivateConfig = parsedPrivateConfig;
     }
 
     public async initServer() {
@@ -107,7 +230,11 @@ export class Config {
 
     private async checkKeyStatus() {
         const licenseStatus = await license.check();
-        if (!licenseStatus.isHostLicensed) {
+        if (
+            !this.rawPrivateConfig.flags?.hide_supporter_key &&
+            build != "oss" &&
+            !licenseStatus.isHostLicensed
+        ) {
             this.checkSupporterKey();
         }
     }
@@ -116,6 +243,10 @@ export class Config {
         return this.rawConfig;
     }
 
+    public getRawPrivateConfig() {
+        return this.rawPrivateConfig;
+    }
+
     public getNoReplyEmail(): string | undefined {
         return (
             this.rawConfig.email?.no_reply || this.rawConfig.email?.smtp_user

server/lib/consts.ts

@@ -11,3 +11,5 @@ export const APP_PATH = path.join("config");
 
 export const configFilePath1 = path.join(APP_PATH, "config.yml");
 export const configFilePath2 = path.join(APP_PATH, "config.yaml");
+
+export const privateConfigFilePath1 = path.join(APP_PATH, "privateConfig.yml");

server/lib/encryption.ts

@@ -0,0 +1,39 @@
+import crypto from 'crypto';
+
+export function encryptData(data: string, key: Buffer): string {
+  const algorithm = 'aes-256-gcm';
+  const iv = crypto.randomBytes(16);
+  const cipher = crypto.createCipheriv(algorithm, key, iv);
+  
+  let encrypted = cipher.update(data, 'utf8', 'hex');
+  encrypted += cipher.final('hex');
+  
+  const authTag = cipher.getAuthTag();
+  
+  // Combine IV, auth tag, and encrypted data
+  return iv.toString('hex') + ':' + authTag.toString('hex') + ':' + encrypted;
+}
+
+// Helper function to decrypt data (you'll need this to read certificates)
+export function decryptData(encryptedData: string, key: Buffer): string {
+  const algorithm = 'aes-256-gcm';
+  const parts = encryptedData.split(':');
+  
+  if (parts.length !== 3) {
+    throw new Error('Invalid encrypted data format');
+  }
+  
+  const iv = Buffer.from(parts[0], 'hex');
+  const authTag = Buffer.from(parts[1], 'hex');
+  const encrypted = parts[2];
+  
+  const decipher = crypto.createDecipheriv(algorithm, key, iv);
+  decipher.setAuthTag(authTag);
+  
+  let decrypted = decipher.update(encrypted, 'hex', 'utf8');
+  decrypted += decipher.final('utf8');
+  
+  return decrypted;
+}
+
+// openssl rand -hex 32 > config/encryption.key

server/lib/exitNodes/exitNodes.ts

@@ -16,7 +16,7 @@ export async function verifyExitNodeOrgAccess(
     return { hasAccess: true, exitNode };
 }
 
-export async function listExitNodes(orgId: string, filterOnline = false) {
+export async function listExitNodes(orgId: string, filterOnline = false, noCloud = false) {
     // TODO: pick which nodes to send and ping better than just all of them that are not remote
     const allExitNodes = await db
         .select({
@@ -57,4 +57,9 @@ export function selectBestExitNode(
 
 export async function checkExitNodeOrg(exitNodeId: number, orgId: string) {
     return false;
-}
+}
+
+export async function resolveExitNodes(hostname: string, publicKey: string) {
+    // OSS version: simple implementation that returns empty array
+    return [];
+}

server/lib/exitNodes/getCurrentExitNodeId.ts

@@ -0,0 +1,33 @@
+import { eq } from "drizzle-orm";
+import { db, exitNodes } from "@server/db";
+import config from "@server/lib/config";
+
+let currentExitNodeId: number; // we really only need to look this up once per instance
+export async function getCurrentExitNodeId(): Promise<number> {
+    if (!currentExitNodeId) {
+        if (config.getRawConfig().gerbil.exit_node_name) {
+            const exitNodeName = config.getRawConfig().gerbil.exit_node_name!;
+            const [exitNode] = await db
+                .select({
+                    exitNodeId: exitNodes.exitNodeId
+                })
+                .from(exitNodes)
+                .where(eq(exitNodes.name, exitNodeName));
+            if (exitNode) {
+                currentExitNodeId = exitNode.exitNodeId;
+            }
+        } else {
+            const [exitNode] = await db
+                .select({
+                    exitNodeId: exitNodes.exitNodeId
+                })
+                .from(exitNodes)
+                .limit(1);
+
+            if (exitNode) {
+                currentExitNodeId = exitNode.exitNodeId;
+            }
+        }
+    }
+    return currentExitNodeId;
+}

server/lib/exitNodes/index.ts

@@ -1,2 +1,33 @@
-export * from "./exitNodes";
-export * from "./shared";
+import { build } from "@server/build";
+
+// Import both modules
+import * as exitNodesModule from "./exitNodes";
+import * as privateExitNodesModule from "./privateExitNodes";
+
+// Conditionally export exit nodes implementation based on build type
+const exitNodesImplementation = build === "oss" ? exitNodesModule : privateExitNodesModule;
+
+// Re-export all items from the selected implementation
+export const {
+    verifyExitNodeOrgAccess,
+    listExitNodes,
+    selectBestExitNode,
+    checkExitNodeOrg,
+    resolveExitNodes
+} = exitNodesImplementation;
+
+// Import communications modules
+import * as exitNodeCommsModule from "./exitNodeComms";
+import * as privateExitNodeCommsModule from "./privateExitNodeComms";
+
+// Conditionally export communications implementation based on build type
+const exitNodeCommsImplementation = build === "oss" ? exitNodeCommsModule : privateExitNodeCommsModule;
+
+// Re-export communications functions from the selected implementation
+export const {
+    sendToExitNode
+} = exitNodeCommsImplementation;
+
+// Re-export shared modules
+export * from "./subnet";
+export * from "./getCurrentExitNodeId";

server/lib/exitNodes/privateExitNodeComms.ts

@@ -0,0 +1,145 @@
+/*
+ * This file is part of a proprietary work.
+ *
+ * Copyright (c) 2025 Fossorial, Inc.
+ * All rights reserved.
+ *
+ * This file is licensed under the Fossorial Commercial License.
+ * You may not use this file except in compliance with the License.
+ * Unauthorized use, copying, modification, or distribution is strictly prohibited.
+ *
+ * This file is not licensed under the AGPLv3.
+ */
+
+import axios from "axios";
+import logger from "@server/logger";
+import { db, ExitNode, remoteExitNodes } from "@server/db";
+import { eq } from "drizzle-orm";
+import { sendToClient } from "../../routers/ws";
+import { config } from "../config";
+
+interface ExitNodeRequest {
+    remoteType?: string;
+    localPath: string;
+    method?: "POST" | "DELETE" | "GET" | "PUT";
+    data?: any;
+    queryParams?: Record<string, string>;
+}
+
+/**
+ * Sends a request to an exit node, handling both remote and local exit nodes
+ * @param exitNode The exit node to send the request to
+ * @param request The request configuration
+ * @returns Promise<any> Response data for local nodes, undefined for remote nodes
+ */
+export async function sendToExitNode(
+    exitNode: ExitNode,
+    request: ExitNodeRequest
+): Promise<any> {
+    if (exitNode.type === "remoteExitNode" && request.remoteType) {
+        const [remoteExitNode] = await db
+            .select()
+            .from(remoteExitNodes)
+            .where(eq(remoteExitNodes.exitNodeId, exitNode.exitNodeId))
+            .limit(1);
+
+        if (!remoteExitNode) {
+            throw new Error(
+                `Remote exit node with ID ${exitNode.exitNodeId} not found`
+            );
+        }
+
+        return sendToClient(remoteExitNode.remoteExitNodeId, {
+            type: request.remoteType,
+            data: request.data
+        });
+    } else {
+        let hostname = exitNode.reachableAt;
+
+        logger.debug(`Exit node details:`, {
+            type: exitNode.type,
+            name: exitNode.name,
+            reachableAt: exitNode.reachableAt,
+        });
+
+        logger.debug(`Configured local exit node name: ${config.getRawConfig().gerbil.exit_node_name}`);
+
+        if (exitNode.name == config.getRawConfig().gerbil.exit_node_name) {
+            hostname = config.getRawPrivateConfig().gerbil.local_exit_node_reachable_at;
+        }
+
+        if (!hostname) {
+            throw new Error(
+                `Exit node with ID ${exitNode.exitNodeId} is not reachable`
+            );
+        }
+
+        logger.debug(`Sending request to exit node at ${hostname}`, {
+            type: request.remoteType,
+            data: request.data
+        });
+
+        // Handle local exit node with HTTP API
+        const method = request.method || "POST";
+        let url = `${hostname}${request.localPath}`;
+
+        // Add query parameters if provided
+        if (request.queryParams) {
+            const params = new URLSearchParams(request.queryParams);
+            url += `?${params.toString()}`;
+        }
+
+        try {
+            let response;
+
+            switch (method) {
+                case "POST":
+                    response = await axios.post(url, request.data, {
+                        headers: {
+                            "Content-Type": "application/json"
+                        },
+                        timeout: 8000
+                    });
+                    break;
+                case "DELETE":
+                    response = await axios.delete(url, {
+                        timeout: 8000
+                    });
+                    break;
+                case "GET":
+                    response = await axios.get(url, {
+                        timeout: 8000
+                    });
+                    break;
+                case "PUT":
+                    response = await axios.put(url, request.data, {
+                        headers: {
+                            "Content-Type": "application/json"
+                        },
+                        timeout: 8000
+                    });
+                    break;
+                default:
+                    throw new Error(`Unsupported HTTP method: ${method}`);
+            }
+
+            logger.debug(`Exit node request successful:`, {
+                method,
+                url,
+                status: response.data.status
+            });
+
+            return response.data;
+        } catch (error) {
+            if (axios.isAxiosError(error)) {
+                logger.error(
+                    `Error making ${method} request (can Pangolin see Gerbil HTTP API?) for exit node at ${hostname} (status: ${error.response?.status}): ${error.message}`
+                );
+            } else {
+                logger.error(
+                    `Error making ${method} request for exit node at ${hostname}: ${error}`
+                );
+            }
+        }
+    }
+}

server/lib/exitNodes/privateExitNodes.ts

@@ -0,0 +1,379 @@
+/*
+ * This file is part of a proprietary work.
+ *
+ * Copyright (c) 2025 Fossorial, Inc.
+ * All rights reserved.
+ *
+ * This file is licensed under the Fossorial Commercial License.
+ * You may not use this file except in compliance with the License.
+ * Unauthorized use, copying, modification, or distribution is strictly prohibited.
+ *
+ * This file is not licensed under the AGPLv3.
+ */
+
+import {
+    db,
+    exitNodes,
+    exitNodeOrgs,
+    resources,
+    targets,
+    sites,
+    targetHealthCheck
+} from "@server/db";
+import logger from "@server/logger";
+import { ExitNodePingResult } from "@server/routers/newt";
+import { eq, and, or, ne, isNull } from "drizzle-orm";
+import axios from "axios";
+import config from "../config";
+
+/**
+ * Checks if an exit node is actually online by making HTTP requests to its endpoint/ping
+ * Makes up to 3 attempts in parallel with small delays, returns as soon as one succeeds
+ */
+async function checkExitNodeOnlineStatus(
+    endpoint: string | undefined
+): Promise<boolean> {
+    if (!endpoint || endpoint == "") {
+        // the endpoint can start out as a empty string
+        return false;
+    }
+
+    const maxAttempts = 3;
+    const timeoutMs = 5000; // 5 second timeout per request
+    const delayBetweenAttempts = 100; // 100ms delay between starting each attempt
+
+    // Create promises for all attempts with staggered delays
+    const attemptPromises = Array.from({ length: maxAttempts }, async (_, index) => {
+        const attemptNumber = index + 1;
+        
+        // Add delay before each attempt (except the first)
+        if (index > 0) {
+            await new Promise((resolve) => setTimeout(resolve, delayBetweenAttempts * index));
+        }
+
+        try {
+            const response = await axios.get(`http://${endpoint}/ping`, {
+                timeout: timeoutMs,
+                validateStatus: (status) => status === 200
+            });
+
+            if (response.status === 200) {
+                logger.debug(
+                    `Exit node ${endpoint} is online (attempt ${attemptNumber}/${maxAttempts})`
+                );
+                return { success: true, attemptNumber };
+            }
+            return { success: false, attemptNumber, error: 'Non-200 status' };
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error";
+            logger.debug(
+                `Exit node ${endpoint} ping failed (attempt ${attemptNumber}/${maxAttempts}): ${errorMessage}`
+            );
+            return { success: false, attemptNumber, error: errorMessage };
+        }
+    });
+
+    try {
+        // Wait for the first successful response or all to fail
+        const results = await Promise.allSettled(attemptPromises);
+        
+        // Check if any attempt succeeded
+        for (const result of results) {
+            if (result.status === 'fulfilled' && result.value.success) {
+                return true;
+            }
+        }
+
+        // All attempts failed
+        logger.warn(
+            `Exit node ${endpoint} is offline after ${maxAttempts} parallel attempts`
+        );
+        return false;
+    } catch (error) {
+        logger.warn(
+            `Unexpected error checking exit node ${endpoint}: ${error instanceof Error ? error.message : "Unknown error"}`
+        );
+        return false;
+    }
+}
+
+export async function verifyExitNodeOrgAccess(
+    exitNodeId: number,
+    orgId: string
+) {
+    const [result] = await db
+        .select({
+            exitNode: exitNodes,
+            exitNodeOrgId: exitNodeOrgs.exitNodeId
+        })
+        .from(exitNodes)
+        .leftJoin(
+            exitNodeOrgs,
+            and(
+                eq(exitNodeOrgs.exitNodeId, exitNodes.exitNodeId),
+                eq(exitNodeOrgs.orgId, orgId)
+            )
+        )
+        .where(eq(exitNodes.exitNodeId, exitNodeId));
+
+    if (!result) {
+        return { hasAccess: false, exitNode: null };
+    }
+
+    const { exitNode } = result;
+
+    // If the exit node is type "gerbil", access is allowed
+    if (exitNode.type === "gerbil") {
+        return { hasAccess: true, exitNode };
+    }
+
+    // If the exit node is type "remoteExitNode", check if it has org access
+    if (exitNode.type === "remoteExitNode") {
+        return { hasAccess: !!result.exitNodeOrgId, exitNode };
+    }
+
+    // For any other type, deny access
+    return { hasAccess: false, exitNode };
+}
+
+export async function listExitNodes(orgId: string, filterOnline = false, noCloud = false) {
+    const allExitNodes = await db
+        .select({
+            exitNodeId: exitNodes.exitNodeId,
+            name: exitNodes.name,
+            address: exitNodes.address,
+            endpoint: exitNodes.endpoint,
+            publicKey: exitNodes.publicKey,
+            listenPort: exitNodes.listenPort,
+            reachableAt: exitNodes.reachableAt,
+            maxConnections: exitNodes.maxConnections,
+            online: exitNodes.online,
+            lastPing: exitNodes.lastPing,
+            type: exitNodes.type,
+            orgId: exitNodeOrgs.orgId,
+            region: exitNodes.region
+        })
+        .from(exitNodes)
+        .leftJoin(
+            exitNodeOrgs,
+            eq(exitNodes.exitNodeId, exitNodeOrgs.exitNodeId)
+        )
+        .where(
+            or(
+                // Include all exit nodes that are NOT of type remoteExitNode
+                and(
+                    eq(exitNodes.type, "gerbil"),
+                    or(
+                        // only choose nodes that are in the same region
+                        eq(exitNodes.region, config.getRawPrivateConfig().app.region),
+                        isNull(exitNodes.region) // or for enterprise where region is not set
+                    )
+                ),
+                // Include remoteExitNode types where the orgId matches the newt's organization
+                and(
+                    eq(exitNodes.type, "remoteExitNode"),
+                    eq(exitNodeOrgs.orgId, orgId)
+                )
+            )
+        );
+
+    // Filter the nodes. If there are NO remoteExitNodes then do nothing. If there are then remove all of the non-remoteExitNodes
+    if (allExitNodes.length === 0) {
+        logger.warn("No exit nodes found for ping request!");
+        return [];
+    }
+
+    // Enhanced online checking: consider node offline if either DB says offline OR HTTP ping fails
+    const nodesWithRealOnlineStatus = await Promise.all(
+        allExitNodes.map(async (node) => {
+            // If database says it's online, verify with HTTP ping
+            let online: boolean;
+            if (filterOnline && node.type == "remoteExitNode") {
+                try {
+                    const isActuallyOnline = await checkExitNodeOnlineStatus( 
+                        node.endpoint
+                    );
+
+                    // set the item in the database if it is offline
+                    if (isActuallyOnline != node.online) {
+                        await db
+                            .update(exitNodes)
+                            .set({ online: isActuallyOnline })
+                            .where(eq(exitNodes.exitNodeId, node.exitNodeId));
+                    }
+                    online = isActuallyOnline;
+                } catch (error) {
+                    logger.warn(
+                        `Failed to check online status for exit node ${node.name} (${node.endpoint}): ${error instanceof Error ? error.message : "Unknown error"}`
+                    );
+                    online = false;
+                }
+            } else {
+                online = node.online;
+            }
+
+            return {
+                ...node,
+                online
+            };
+        })
+    );
+
+    const remoteExitNodes = nodesWithRealOnlineStatus.filter(
+        (node) =>
+            node.type === "remoteExitNode" && (!filterOnline || node.online)
+    );
+    const gerbilExitNodes = nodesWithRealOnlineStatus.filter(
+        (node) => node.type === "gerbil" && (!filterOnline || node.online) && !noCloud
+    );
+
+    // THIS PROVIDES THE FALL
+    const exitNodesList =
+        remoteExitNodes.length > 0 ? remoteExitNodes : gerbilExitNodes;
+
+    return exitNodesList;
+}
+
+/**
+ * Selects the most suitable exit node from a list of ping results.
+ *
+ * The selection algorithm follows these steps:
+ *
+ * 1. **Filter Invalid Nodes**: Excludes nodes with errors or zero weight.
+ *
+ * 2. **Sort by Latency**: Sorts valid nodes in ascending order of latency.
+ *
+ * 3. **Preferred Selection**:
+ *    - If the lowest-latency node has sufficient capacity (≥10% weight),
+ *      check if a previously connected node is also acceptable.
+ *    - The previously connected node is preferred if its latency is within
+ *      30ms or 15% of the best node’s latency.
+ *
+ * 4. **Fallback to Next Best**:
+ *    - If the lowest-latency node is under capacity, find the next node
+ *      with acceptable capacity.
+ *
+ * 5. **Final Fallback**:
+ *    - If no nodes meet the capacity threshold, fall back to the node
+ *      with the highest weight (i.e., most available capacity).
+ *
+ */
+export function selectBestExitNode(
+    pingResults: ExitNodePingResult[]
+): ExitNodePingResult | null {
+    const MIN_CAPACITY_THRESHOLD = 0.1;
+    const LATENCY_TOLERANCE_MS = 30;
+    const LATENCY_TOLERANCE_PERCENT = 0.15;
+
+    // Filter out invalid nodes
+    const validNodes = pingResults.filter((n) => !n.error && n.weight > 0);
+
+    if (validNodes.length === 0) {
+        logger.error("No valid exit nodes available");
+        return null;
+    }
+
+    // Sort by latency (ascending)
+    const sortedNodes = validNodes
+        .slice()
+        .sort((a, b) => a.latencyMs - b.latencyMs);
+    const lowestLatencyNode = sortedNodes[0];
+
+    logger.debug(
+        `Lowest latency node: ${lowestLatencyNode.exitNodeName} (${lowestLatencyNode.latencyMs} ms, weight=${lowestLatencyNode.weight.toFixed(2)})`
+    );
+
+    // If lowest latency node has enough capacity, check if previously connected node is acceptable
+    if (lowestLatencyNode.weight >= MIN_CAPACITY_THRESHOLD) {
+        const previouslyConnectedNode = sortedNodes.find(
+            (n) =>
+                n.wasPreviouslyConnected && n.weight >= MIN_CAPACITY_THRESHOLD
+        );
+
+        if (previouslyConnectedNode) {
+            const latencyDiff =
+                previouslyConnectedNode.latencyMs - lowestLatencyNode.latencyMs;
+            const percentDiff = latencyDiff / lowestLatencyNode.latencyMs;
+
+            if (
+                latencyDiff <= LATENCY_TOLERANCE_MS ||
+                percentDiff <= LATENCY_TOLERANCE_PERCENT
+            ) {
+                logger.info(
+                    `Sticking with previously connected node: ${previouslyConnectedNode.exitNodeName} ` +
+                        `(${previouslyConnectedNode.latencyMs} ms), latency diff = ${latencyDiff.toFixed(1)}ms ` +
+                        `/ ${(percentDiff * 100).toFixed(1)}%.`
+                );
+                return previouslyConnectedNode;
+            }
+        }
+
+        return lowestLatencyNode;
+    }
+
+    // Otherwise, find the next node (after the lowest) that has enough capacity
+    for (let i = 1; i < sortedNodes.length; i++) {
+        const node = sortedNodes[i];
+        if (node.weight >= MIN_CAPACITY_THRESHOLD) {
+            logger.info(
+                `Lowest latency node under capacity. Using next best: ${node.exitNodeName} ` +
+                    `(${node.latencyMs} ms, weight=${node.weight.toFixed(2)})`
+            );
+            return node;
+        }
+    }
+
+    // Fallback: pick the highest weight node
+    const fallbackNode = validNodes.reduce((a, b) =>
+        a.weight > b.weight ? a : b
+    );
+    logger.warn(
+        `No nodes with ≥10% weight. Falling back to highest capacity node: ${fallbackNode.exitNodeName}`
+    );
+    return fallbackNode;
+}
+
+export async function checkExitNodeOrg(exitNodeId: number, orgId: string) {
+    const [exitNodeOrg] = await db
+        .select()
+        .from(exitNodeOrgs)
+        .where(
+            and(
+                eq(exitNodeOrgs.exitNodeId, exitNodeId),
+                eq(exitNodeOrgs.orgId, orgId)
+            )
+        )
+        .limit(1);
+
+    if (!exitNodeOrg) {
+        return true;
+    }
+
+    return false;
+}
+
+export async function resolveExitNodes(hostname: string, publicKey: string) {
+    const resourceExitNodes = await db
+        .select({
+            endpoint: exitNodes.endpoint,
+            publicKey: exitNodes.publicKey,
+            orgId: resources.orgId
+        })
+        .from(resources)
+        .innerJoin(targets, eq(resources.resourceId, targets.resourceId))
+        .leftJoin(
+            targetHealthCheck,
+            eq(targetHealthCheck.targetId, targets.targetId)
+        )
+        .innerJoin(sites, eq(targets.siteId, sites.siteId))
+        .innerJoin(exitNodes, eq(sites.exitNodeId, exitNodes.exitNodeId))
+        .where(
+            and(
+                eq(resources.fullDomain, hostname),
+                ne(exitNodes.publicKey, publicKey),
+                ne(targetHealthCheck.hcHealth, "unhealthy")
+            )
+        );
+
+    return resourceExitNodes;
+}

server/lib/geoip.ts

@@ -1,10 +1,42 @@
+import logger from "@server/logger";
+import { maxmindLookup } from "@server/db/maxmind";
 import axios from "axios";
 import config from "./config";
 import { tokenManager } from "./tokenManager";
-import logger from "@server/logger";
 
 export async function getCountryCodeForIp(
     ip: string
+): Promise<string | undefined> {
+    try {
+        if (!maxmindLookup) {
+            logger.warn(
+                "MaxMind DB path not configured, cannot perform GeoIP lookup"
+            );
+            return;
+        }
+
+        const result = maxmindLookup.get(ip);
+
+        if (!result || !result.country) {
+            return;
+        }
+
+        const { country } = result;
+
+        logger.debug(
+            `GeoIP lookup successful for IP ${ip}: ${country.iso_code}`
+        );
+
+        return country.iso_code;
+    } catch (error) {
+        logger.error("Error fetching config in verify session:", error);
+    }
+
+    return;
+}
+
+export async function remoteGetCountryCodeForIp(
+    ip: string
 ): Promise<string | undefined> {
     try {
         const response = await axios.get(

server/lib/idp/generateRedirectUrl.ts

@@ -1,8 +1,48 @@
+import { db, loginPage, loginPageOrg } from "@server/db";
 import config from "@server/lib/config";
+import { eq } from "drizzle-orm";
+
+export async function generateOidcRedirectUrl(
+    idpId: number,
+    orgId?: string,
+    loginPageId?: number
+): Promise<string> {
+    let baseUrl: string | undefined;
+
+    const secure = config.getRawConfig().app.dashboard_url?.startsWith("https");
+    const method = secure ? "https" : "http";
+
+    if (loginPageId) {
+        const [res] = await db
+            .select()
+            .from(loginPage)
+            .where(eq(loginPage.loginPageId, loginPageId))
+            .limit(1);
+
+        if (res && res.fullDomain) {
+            baseUrl = `${method}://${res.fullDomain}`;
+        }
+    } else if (orgId) {
+        const [res] = await db
+            .select()
+            .from(loginPageOrg)
+            .where(eq(loginPageOrg.orgId, orgId))
+            .innerJoin(
+                loginPage,
+                eq(loginPage.loginPageId, loginPageOrg.loginPageId)
+            )
+            .limit(1);
+
+        if (res?.loginPage && res.loginPage.domainId && res.loginPage.fullDomain) {
+            baseUrl = `${method}://${res.loginPage.fullDomain}`;
+        }
+    }
+
+    if (!baseUrl) {
+        baseUrl = config.getRawConfig().app.dashboard_url!;
+    }
 
-export function generateOidcRedirectUrl(idpId: number) {
-    const dashboardUrl = config.getRawConfig().app.dashboard_url;
     const redirectPath = `/auth/idp/${idpId}/oidc/callback`;
-    const redirectUrl = new URL(redirectPath, dashboardUrl).toString();
+    const redirectUrl = new URL(redirectPath, baseUrl!).toString();
     return redirectUrl;
 }

server/lib/index.ts

@@ -1,3 +0,0 @@
-export * from "./response";
-export { tokenManager, TokenManager } from "./tokenManager";
-export * from "./geoip";

server/lib/private/billing/features.ts

@@ -0,0 +1,85 @@
+/*
+ * This file is part of a proprietary work.
+ *
+ * Copyright (c) 2025 Fossorial, Inc.
+ * All rights reserved.
+ *
+ * This file is licensed under the Fossorial Commercial License.
+ * You may not use this file except in compliance with the License.
+ * Unauthorized use, copying, modification, or distribution is strictly prohibited.
+ *
+ * This file is not licensed under the AGPLv3.
+ */
+
+import Stripe from "stripe";
+
+export enum FeatureId {
+    SITE_UPTIME = "siteUptime",
+    USERS = "users",
+    EGRESS_DATA_MB = "egressDataMb",
+    DOMAINS = "domains",
+    REMOTE_EXIT_NODES = "remoteExitNodes"
+}
+
+export const FeatureMeterIds: Record<FeatureId, string> = {
+    [FeatureId.SITE_UPTIME]: "mtr_61Srrej5wUJuiTWgo41D3Ee2Ir7WmDLU",
+    [FeatureId.USERS]: "mtr_61SrreISyIWpwUNGR41D3Ee2Ir7WmQro",
+    [FeatureId.EGRESS_DATA_MB]: "mtr_61Srreh9eWrExDSCe41D3Ee2Ir7Wm5YW",
+    [FeatureId.DOMAINS]: "mtr_61Ss9nIKDNMw0LDRU41D3Ee2Ir7WmRPU",
+    [FeatureId.REMOTE_EXIT_NODES]: "mtr_61T86UXnfxTVXy9sD41D3Ee2Ir7WmFTE"
+};
+
+export const FeatureMeterIdsSandbox: Record<FeatureId, string> = {
+    [FeatureId.SITE_UPTIME]: "mtr_test_61Snh3cees4w60gv841DCpkOb237BDEu",
+    [FeatureId.USERS]: "mtr_test_61Sn5fLtq1gSfRkyA41DCpkOb237B6au",
+    [FeatureId.EGRESS_DATA_MB]: "mtr_test_61Snh2a2m6qome5Kv41DCpkOb237B3dQ",
+    [FeatureId.DOMAINS]: "mtr_test_61SsA8qrdAlgPpFRQ41DCpkOb237BGts",
+    [FeatureId.REMOTE_EXIT_NODES]: "mtr_test_61T86Vqmwa3D9ra3341DCpkOb237B94K"
+};
+
+export function getFeatureMeterId(featureId: FeatureId): string {
+    if (process.env.ENVIRONMENT == "prod" && process.env.SANDBOX_MODE !== "true") {
+        return FeatureMeterIds[featureId];
+    } else {
+        return FeatureMeterIdsSandbox[featureId];
+    }
+}
+
+export function getFeatureIdByMetricId(metricId: string): FeatureId | undefined {
+    return (Object.entries(FeatureMeterIds) as [FeatureId, string][])
+        .find(([_, v]) => v === metricId)?.[0];
+}
+
+export type FeaturePriceSet = {
+    [key in FeatureId]: string;
+};
+
+export const standardFeaturePriceSet: FeaturePriceSet = { // Free tier matches the freeLimitSet
+    [FeatureId.SITE_UPTIME]: "price_1RrQc4D3Ee2Ir7WmaJGZ3MtF",
+    [FeatureId.USERS]: "price_1RrQeJD3Ee2Ir7WmgveP3xea",
+    [FeatureId.EGRESS_DATA_MB]: "price_1RrQXFD3Ee2Ir7WmvGDlgxQk",
+    [FeatureId.DOMAINS]: "price_1Rz3tMD3Ee2Ir7Wm5qLeASzC",
+    [FeatureId.REMOTE_EXIT_NODES]: "price_1S46weD3Ee2Ir7Wm94KEHI4h"
+};
+
+export const standardFeaturePriceSetSandbox: FeaturePriceSet = { // Free tier matches the freeLimitSet
+    [FeatureId.SITE_UPTIME]: "price_1RefFBDCpkOb237BPrKZ8IEU",
+    [FeatureId.USERS]: "price_1ReNa4DCpkOb237Bc67G5muF",
+    [FeatureId.EGRESS_DATA_MB]: "price_1Rfp9LDCpkOb237BwuN5Oiu0",
+    [FeatureId.DOMAINS]: "price_1Ryi88DCpkOb237B2D6DM80b",
+    [FeatureId.REMOTE_EXIT_NODES]: "price_1RyiZvDCpkOb237BXpmoIYJL"
+};
+
+export function getStandardFeaturePriceSet(): FeaturePriceSet {
+    if (process.env.ENVIRONMENT == "prod" && process.env.SANDBOX_MODE !== "true") {
+        return standardFeaturePriceSet;
+    } else {
+        return standardFeaturePriceSetSandbox;
+    }
+}
+
+export function getLineItems(featurePriceSet: FeaturePriceSet): Stripe.Checkout.SessionCreateParams.LineItem[] {
+    return Object.entries(featurePriceSet).map(([featureId, priceId]) => ({
+        price: priceId,
+    }));
+}

server/lib/private/billing/index.ts

@@ -0,0 +1,16 @@
+/*
+ * This file is part of a proprietary work.
+ *
+ * Copyright (c) 2025 Fossorial, Inc.
+ * All rights reserved.
+ *
+ * This file is licensed under the Fossorial Commercial License.
+ * You may not use this file except in compliance with the License.
+ * Unauthorized use, copying, modification, or distribution is strictly prohibited.
+ *
+ * This file is not licensed under the AGPLv3.
+ */
+
+export * from "./limitSet";
+export * from "./features";
+export * from "./limitsService";

server/lib/private/billing/limitSet.ts

@@ -0,0 +1,63 @@
+/*
+ * This file is part of a proprietary work.
+ *
+ * Copyright (c) 2025 Fossorial, Inc.
+ * All rights reserved.
+ *
+ * This file is licensed under the Fossorial Commercial License.
+ * You may not use this file except in compliance with the License.
+ * Unauthorized use, copying, modification, or distribution is strictly prohibited.
+ *
+ * This file is not licensed under the AGPLv3.
+ */
+
+import { FeatureId } from "./features";
+
+export type LimitSet = {
+    [key in FeatureId]: {
+        value: number | null; // null indicates no limit
+        description?: string;
+    };
+};
+
+export const sandboxLimitSet: LimitSet = {
+    [FeatureId.SITE_UPTIME]: { value: 2880, description: "Sandbox limit" }, // 1 site up for 2 days
+    [FeatureId.USERS]: { value: 1, description: "Sandbox limit" },
+    [FeatureId.EGRESS_DATA_MB]: { value: 1000, description: "Sandbox limit" }, // 1 GB
+    [FeatureId.DOMAINS]: { value: 0, description: "Sandbox limit" },
+    [FeatureId.REMOTE_EXIT_NODES]: { value: 0, description: "Sandbox limit" },
+};
+
+export const freeLimitSet: LimitSet = {
+    [FeatureId.SITE_UPTIME]: { value: 46080, description: "Free tier limit" }, // 1 site up for 32 days
+    [FeatureId.USERS]: { value: 3, description: "Free tier limit" },
+    [FeatureId.EGRESS_DATA_MB]: {
+        value: 25000,
+        description: "Free tier limit"
+    }, // 25 GB
+    [FeatureId.DOMAINS]: { value: 3, description: "Free tier limit" },
+    [FeatureId.REMOTE_EXIT_NODES]: { value: 1, description: "Free tier limit" }
+};
+
+export const subscribedLimitSet: LimitSet = {
+    [FeatureId.SITE_UPTIME]: {
+        value: 2232000,
+        description: "Contact us to increase soft limit.",
+    }, // 50 sites up for 31 days
+    [FeatureId.USERS]: {
+        value: 150,
+        description: "Contact us to increase soft limit."
+    },
+    [FeatureId.EGRESS_DATA_MB]: {
+        value: 12000000,
+        description: "Contact us to increase soft limit."
+    }, // 12000 GB 
+    [FeatureId.DOMAINS]: {
+        value: 20,
+        description: "Contact us to increase soft limit."
+    },
+    [FeatureId.REMOTE_EXIT_NODES]: {
+        value: 5,
+        description: "Contact us to increase soft limit."
+    }
+};

server/lib/private/billing/limitsService.ts

@@ -0,0 +1,51 @@
+/*
+ * This file is part of a proprietary work.
+ *
+ * Copyright (c) 2025 Fossorial, Inc.
+ * All rights reserved.
+ *
+ * This file is licensed under the Fossorial Commercial License.
+ * You may not use this file except in compliance with the License.
+ * Unauthorized use, copying, modification, or distribution is strictly prohibited.
+ *
+ * This file is not licensed under the AGPLv3.
+ */
+
+import { db, limits } from "@server/db";
+import { and, eq } from "drizzle-orm";
+import { LimitSet } from "./limitSet";
+import { FeatureId } from "./features";
+
+class LimitService {
+    async applyLimitSetToOrg(orgId: string, limitSet: LimitSet): Promise<void> {
+        const limitEntries = Object.entries(limitSet);
+
+        // delete existing limits for the org
+        await db.transaction(async (trx) => {
+            await trx.delete(limits).where(eq(limits.orgId, orgId));
+            for (const [featureId, entry] of limitEntries) {
+                const limitId = `${orgId}-${featureId}`;
+                const { value, description } = entry;
+                await trx
+                    .insert(limits)
+                    .values({ limitId, orgId, featureId, value, description });
+            }
+        });
+    }
+
+    async getOrgLimit(
+        orgId: string,
+        featureId: FeatureId
+    ): Promise<number | null> {
+        const limitId = `${orgId}-${featureId}`;
+        const [limit] = await db
+            .select()
+            .from(limits)
+            .where(and(eq(limits.limitId, limitId)))
+            .limit(1);
+
+        return limit ? limit.value : null;
+    }
+}
+
+export const limitsService = new LimitService();

server/lib/private/billing/tiers.ts

@@ -0,0 +1,37 @@
+/*
+ * This file is part of a proprietary work.
+ *
+ * Copyright (c) 2025 Fossorial, Inc.
+ * All rights reserved.
+ *
+ * This file is licensed under the Fossorial Commercial License.
+ * You may not use this file except in compliance with the License.
+ * Unauthorized use, copying, modification, or distribution is strictly prohibited.
+ *
+ * This file is not licensed under the AGPLv3.
+ */
+
+export enum TierId {
+    STANDARD = "standard",
+}
+
+export type TierPriceSet = {
+    [key in TierId]: string;
+};
+
+export const tierPriceSet: TierPriceSet = { // Free tier matches the freeLimitSet
+    [TierId.STANDARD]: "price_1RrQ9cD3Ee2Ir7Wmqdy3KBa0",
+};
+
+export const tierPriceSetSandbox: TierPriceSet = { // Free tier matches the freeLimitSet
+    // when matching tier the keys closer to 0 index are matched first so list the tiers in descending order of value
+    [TierId.STANDARD]: "price_1RrAYJDCpkOb237By2s1P32m",
+};
+
+export function getTierPriceSet(environment?: string, sandbox_mode?: boolean): TierPriceSet {
+    if ((process.env.ENVIRONMENT == "prod" && process.env.SANDBOX_MODE !== "true") || (environment === "prod" && sandbox_mode !== true)) { // THIS GETS LOADED CLIENT SIDE AND SERVER SIDE
+        return tierPriceSet;
+    } else {
+        return tierPriceSetSandbox;
+    }
+}

server/lib/private/billing/usageService.ts

@@ -0,0 +1,889 @@
+/*
+ * This file is part of a proprietary work.
+ *
+ * Copyright (c) 2025 Fossorial, Inc.
+ * All rights reserved.
+ *
+ * This file is licensed under the Fossorial Commercial License.
+ * You may not use this file except in compliance with the License.
+ * Unauthorized use, copying, modification, or distribution is strictly prohibited.
+ *
+ * This file is not licensed under the AGPLv3.
+ */
+
+import { eq, sql, and } from "drizzle-orm";
+import NodeCache from "node-cache";
+import { v4 as uuidv4 } from "uuid";
+import { PutObjectCommand } from "@aws-sdk/client-s3";
+import { s3Client } from "../s3";
+import * as fs from "fs/promises";
+import * as path from "path";
+import {
+    db,
+    usage,
+    customers,
+    sites,
+    newts,
+    limits,
+    Usage,
+    Limit,
+    Transaction
+} from "@server/db";
+import { FeatureId, getFeatureMeterId } from "./features";
+import config from "@server/lib/config";
+import logger from "@server/logger";
+import { sendToClient } from "@server/routers/ws";
+import { build } from "@server/build";
+
+interface StripeEvent {
+    identifier?: string;
+    timestamp: number;
+    event_name: string;
+    payload: {
+        value: number;
+        stripe_customer_id: string;
+    };
+}
+
+export class UsageService {
+    private cache: NodeCache;
+    private bucketName: string | undefined;
+    private currentEventFile: string | null = null;
+    private currentFileStartTime: number = 0;
+    private eventsDir: string | undefined;
+    private uploadingFiles: Set<string> = new Set();
+
+    constructor() {
+        this.cache = new NodeCache({ stdTTL: 300 }); // 5 minute TTL
+        if (build !== "saas") {
+            return;
+        }
+        this.bucketName = config.getRawPrivateConfig().stripe?.s3Bucket;
+        this.eventsDir = config.getRawPrivateConfig().stripe?.localFilePath;
+
+        // Ensure events directory exists
+        this.initializeEventsDirectory().then(() => {
+            this.uploadPendingEventFilesOnStartup();
+        });
+
+        // Periodically check for old event files to upload
+        setInterval(() => {
+            this.uploadOldEventFiles().catch((err) => {
+                logger.error("Error in periodic event file upload:", err);
+            });
+        }, 30000); // every 30 seconds
+    }
+
+    /**
+     * Truncate a number to 11 decimal places to prevent precision issues
+     */
+    private truncateValue(value: number): number {
+        return Math.round(value * 100000000000) / 100000000000; // 11 decimal places
+    }
+
+    private async initializeEventsDirectory(): Promise<void> {
+        if (!this.eventsDir) {
+            logger.warn("Stripe local file path is not configured, skipping events directory initialization.");
+            return;
+        }
+        try {
+            await fs.mkdir(this.eventsDir, { recursive: true });
+        } catch (error) {
+            logger.error("Failed to create events directory:", error);
+        }
+    }
+
+    private async uploadPendingEventFilesOnStartup(): Promise<void> {
+        if (!this.eventsDir || !this.bucketName) {
+            logger.warn("Stripe local file path or bucket name is not configured, skipping leftover event file upload.");
+            return;
+        }
+        try {
+            const files = await fs.readdir(this.eventsDir);
+            for (const file of files) {
+                if (file.endsWith(".json")) {
+                    const filePath = path.join(this.eventsDir, file);
+                    try {
+                        const fileContent = await fs.readFile(
+                            filePath,
+                            "utf-8"
+                        );
+                        const events = JSON.parse(fileContent);
+                        if (Array.isArray(events) && events.length > 0) {
+                            // Upload to S3
+                            const uploadCommand = new PutObjectCommand({
+                                Bucket: this.bucketName,
+                                Key: file,
+                                Body: fileContent,
+                                ContentType: "application/json"
+                            });
+                            await s3Client.send(uploadCommand);
+                            
+                            // Check if file still exists before unlinking
+                            try {
+                                await fs.access(filePath);
+                                await fs.unlink(filePath);
+                            } catch (unlinkError) {
+                                logger.debug(`Startup file ${file} was already deleted`);
+                            }
+                            
+                            logger.info(
+                                `Uploaded leftover event file ${file} to S3 with ${events.length} events`
+                            );
+                        } else {
+                            // Remove empty file
+                            try {
+                                await fs.access(filePath);
+                                await fs.unlink(filePath);
+                            } catch (unlinkError) {
+                                logger.debug(`Empty startup file ${file} was already deleted`);
+                            }
+                        }
+                    } catch (err) {
+                        logger.error(
+                            `Error processing leftover event file ${file}:`,
+                            err
+                        );
+                    }
+                }
+            }
+        } catch (err) {
+            logger.error("Failed to scan for leftover event files:", err);
+        }
+    }
+
+    public async add(
+        orgId: string,
+        featureId: FeatureId,
+        value: number,
+        transaction: any = null
+    ): Promise<Usage | null> {
+        if (build !== "saas") {
+            return null;
+        }
+        
+        // Truncate value to 11 decimal places
+        value = this.truncateValue(value);
+        
+        // Implement retry logic for deadlock handling
+        const maxRetries = 3;
+        let attempt = 0;
+        
+        while (attempt <= maxRetries) {
+            try {
+                // Get subscription data for this org (with caching)
+                const customerId = await this.getCustomerId(orgId, featureId);
+
+                if (!customerId) {
+                    logger.warn(
+                        `No subscription data found for org ${orgId} and feature ${featureId}`
+                    );
+                    return null;
+                }
+
+                let usage;
+                if (transaction) {
+                    usage = await this.internalAddUsage(
+                        orgId,
+                        featureId,
+                        value,
+                        transaction
+                    );
+                } else {
+                    await db.transaction(async (trx) => {
+                        usage = await this.internalAddUsage(orgId, featureId, value, trx);
+                    });
+                }
+
+                // Log event for Stripe
+                await this.logStripeEvent(featureId, value, customerId);
+
+                return usage || null;
+            } catch (error: any) {
+                // Check if this is a deadlock error
+                const isDeadlock = error?.code === '40P01' || 
+                                 error?.cause?.code === '40P01' ||
+                                 (error?.message && error.message.includes('deadlock'));
+                
+                if (isDeadlock && attempt < maxRetries) {
+                    attempt++;
+                    // Exponential backoff with jitter: 50-150ms, 100-300ms, 200-600ms
+                    const baseDelay = Math.pow(2, attempt - 1) * 50;
+                    const jitter = Math.random() * baseDelay;
+                    const delay = baseDelay + jitter;
+                    
+                    logger.warn(
+                        `Deadlock detected for ${orgId}/${featureId}, retrying attempt ${attempt}/${maxRetries} after ${delay.toFixed(0)}ms`
+                    );
+                    
+                    await new Promise(resolve => setTimeout(resolve, delay));
+                    continue;
+                }
+                
+                logger.error(
+                    `Failed to add usage for ${orgId}/${featureId} after ${attempt} attempts:`,
+                    error
+                );
+                break;
+            }
+        }
+
+        return null;
+    }
+
+    private async internalAddUsage(
+        orgId: string,
+        featureId: FeatureId,
+        value: number,
+        trx: Transaction
+    ): Promise<Usage> {
+        // Truncate value to 11 decimal places
+        value = this.truncateValue(value);
+        
+        const usageId = `${orgId}-${featureId}`;
+        const meterId = getFeatureMeterId(featureId);
+        
+        // Use upsert: insert if not exists, otherwise increment
+        const [returnUsage] = await trx
+            .insert(usage)
+            .values({
+                usageId,
+                featureId,
+                orgId,
+                meterId,
+                latestValue: value,
+                updatedAt: Math.floor(Date.now() / 1000)
+            })
+            .onConflictDoUpdate({
+                target: usage.usageId,
+                set: {
+                    latestValue: sql`${usage.latestValue} + ${value}`
+                }
+            }).returning();
+
+        return returnUsage;
+    }
+
+    // Helper function to get today's date as string (YYYY-MM-DD)
+    getTodayDateString(): string {
+        return new Date().toISOString().split("T")[0];
+    }
+
+    // Helper function to get date string from Date object
+    getDateString(date: number): string {
+        return new Date(date * 1000).toISOString().split("T")[0];
+    }
+
+    async updateDaily(
+        orgId: string,
+        featureId: FeatureId,
+        value?: number,
+        customerId?: string
+    ): Promise<void> {
+        if (build !== "saas") {
+            return;
+        }
+        try {
+            if (!customerId) {
+                customerId =
+                    (await this.getCustomerId(orgId, featureId)) || undefined;
+                if (!customerId) {
+                    logger.warn(
+                        `No subscription data found for org ${orgId} and feature ${featureId}`
+                    );
+                    return;
+                }
+            }
+
+            // Truncate value to 11 decimal places if provided
+            if (value !== undefined && value !== null) {
+                value = this.truncateValue(value);
+            }
+
+            const today = this.getTodayDateString();
+
+            let currentUsage: Usage | null = null;
+
+            await db.transaction(async (trx) => {
+                // Get existing meter record
+                const usageId = `${orgId}-${featureId}`;
+                // Get current usage record
+                [currentUsage] = await trx
+                    .select()
+                    .from(usage)
+                    .where(eq(usage.usageId, usageId))
+                    .limit(1);
+
+                if (currentUsage) {
+                    const lastUpdateDate = this.getDateString(
+                        currentUsage.updatedAt
+                    );
+                    const currentRunningTotal = currentUsage.latestValue;
+                    const lastDailyValue = currentUsage.instantaneousValue || 0;
+
+                    if (value == undefined || value === null) {
+                        value = currentUsage.instantaneousValue || 0;
+                    }
+
+                    if (lastUpdateDate === today) {
+                        // Same day update: replace the daily value
+                        // Remove old daily value from running total, add new value
+                        const newRunningTotal = this.truncateValue(
+                            currentRunningTotal - lastDailyValue + value
+                        );
+
+                        await trx
+                            .update(usage)
+                            .set({
+                                latestValue: newRunningTotal,
+                                instantaneousValue: value,
+                                updatedAt: Math.floor(Date.now() / 1000)
+                            })
+                            .where(eq(usage.usageId, usageId));
+                    } else {
+                        // New day: add to running total
+                        const newRunningTotal = this.truncateValue(
+                            currentRunningTotal + value
+                        );
+
+                        await trx
+                            .update(usage)
+                            .set({
+                                latestValue: newRunningTotal,
+                                instantaneousValue: value,
+                                updatedAt: Math.floor(Date.now() / 1000) 
+                            })
+                            .where(eq(usage.usageId, usageId));
+                    }
+                } else {
+                    // First record for this meter
+                    const meterId = getFeatureMeterId(featureId);
+                    const truncatedValue = this.truncateValue(value || 0);
+                    await trx.insert(usage).values({
+                        usageId,
+                        featureId,
+                        orgId,
+                        meterId,
+                        instantaneousValue: truncatedValue,
+                        latestValue: truncatedValue,
+                        updatedAt: Math.floor(Date.now() / 1000) 
+                    });
+                }
+            });
+
+            await this.logStripeEvent(featureId, value || 0, customerId);
+        } catch (error) {
+            logger.error(
+                `Failed to update daily usage for ${orgId}/${featureId}:`,
+                error
+            );
+        }
+    }
+
+    private async getCustomerId(
+        orgId: string,
+        featureId: FeatureId
+    ): Promise<string | null> {
+        const cacheKey = `customer_${orgId}_${featureId}`;
+        const cached = this.cache.get<string>(cacheKey);
+
+        if (cached) {
+            return cached;
+        }
+
+        try {
+            // Query subscription data
+            const [customer] = await db
+                .select({
+                    customerId: customers.customerId
+                })
+                .from(customers)
+                .where(eq(customers.orgId, orgId))
+                .limit(1);
+
+            if (!customer) {
+                return null;
+            }
+
+            const customerId = customer.customerId;
+
+            // Cache the result
+            this.cache.set(cacheKey, customerId);
+
+            return customerId;
+        } catch (error) {
+            logger.error(
+                `Failed to get subscription data for ${orgId}/${featureId}:`,
+                error
+            );
+            return null;
+        }
+    }
+
+    private async logStripeEvent(
+        featureId: FeatureId,
+        value: number,
+        customerId: string
+    ): Promise<void> {
+        // Truncate value to 11 decimal places before sending to Stripe
+        const truncatedValue = this.truncateValue(value);
+        
+        const event: StripeEvent = {
+            identifier: uuidv4(),
+            timestamp: Math.floor(new Date().getTime() / 1000),
+            event_name: featureId,
+            payload: {
+                value: truncatedValue,
+                stripe_customer_id: customerId
+            }
+        };
+
+        await this.writeEventToFile(event);
+        await this.checkAndUploadFile();
+    }
+
+    private async writeEventToFile(event: StripeEvent): Promise<void> {
+        if (!this.eventsDir || !this.bucketName) {
+            logger.warn("Stripe local file path or bucket name is not configured, skipping event file write.");
+            return;
+        }
+        if (!this.currentEventFile) {
+            this.currentEventFile = this.generateEventFileName();
+            this.currentFileStartTime = Date.now();
+        }
+
+        const filePath = path.join(this.eventsDir, this.currentEventFile);
+
+        try {
+            let events: StripeEvent[] = [];
+
+            // Try to read existing file
+            try {
+                const fileContent = await fs.readFile(filePath, "utf-8");
+                events = JSON.parse(fileContent);
+            } catch (error) {
+                // File doesn't exist or is empty, start with empty array
+                events = [];
+            }
+
+            // Add new event
+            events.push(event);
+
+            // Write back to file
+            await fs.writeFile(filePath, JSON.stringify(events, null, 2));
+        } catch (error) {
+            logger.error("Failed to write event to file:", error);
+        }
+    }
+
+    private async checkAndUploadFile(): Promise<void> {
+        if (!this.currentEventFile) {
+            return;
+        }
+
+        const now = Date.now();
+        const fileAge = now - this.currentFileStartTime;
+
+        // Check if file is at least 1 minute old
+        if (fileAge >= 60000) {
+            // 60 seconds
+            await this.uploadFileToS3();
+        }
+    }
+
+    private async uploadFileToS3(): Promise<void> {
+        if (!this.bucketName || !this.eventsDir) {
+            logger.warn("Stripe local file path or bucket name is not configured, skipping S3 upload.");
+            return;
+        }
+        if (!this.currentEventFile) {
+            return;
+        }
+
+        const fileName = this.currentEventFile;
+        const filePath = path.join(this.eventsDir, fileName);
+
+        // Check if this file is already being uploaded
+        if (this.uploadingFiles.has(fileName)) {
+            logger.debug(`File ${fileName} is already being uploaded, skipping`);
+            return;
+        }
+
+        // Mark file as being uploaded
+        this.uploadingFiles.add(fileName);
+
+        try {
+            // Check if file exists before trying to read it
+            try {
+                await fs.access(filePath);
+            } catch (error) {
+                logger.debug(`File ${fileName} does not exist, may have been already processed`);
+                this.uploadingFiles.delete(fileName);
+                // Reset current file if it was this file
+                if (this.currentEventFile === fileName) {
+                    this.currentEventFile = null;
+                    this.currentFileStartTime = 0;
+                }
+                return;
+            }
+
+            // Check if file exists and has content
+            const fileContent = await fs.readFile(filePath, "utf-8");
+            const events = JSON.parse(fileContent);
+
+            if (events.length === 0) {
+                // No events to upload, just clean up
+                try {
+                    await fs.unlink(filePath);
+                } catch (unlinkError) {
+                    // File may have been already deleted
+                    logger.debug(`File ${fileName} was already deleted during cleanup`);
+                }
+                this.currentEventFile = null;
+                this.uploadingFiles.delete(fileName);
+                return;
+            }
+
+            // Upload to S3
+            const uploadCommand = new PutObjectCommand({
+                Bucket: this.bucketName,
+                Key: fileName,
+                Body: fileContent,
+                ContentType: "application/json"
+            });
+
+            await s3Client.send(uploadCommand);
+
+            // Clean up local file - check if it still exists before unlinking
+            try {
+                await fs.access(filePath);
+                await fs.unlink(filePath);
+            } catch (unlinkError) {
+                // File may have been already deleted by another process
+                logger.debug(`File ${fileName} was already deleted during upload`);
+            }
+
+            logger.info(
+                `Uploaded ${fileName} to S3 with ${events.length} events`
+            );
+
+            // Reset for next file
+            this.currentEventFile = null;
+            this.currentFileStartTime = 0;
+        } catch (error) {
+            logger.error(
+                `Failed to upload ${fileName} to S3:`,
+                error
+            );
+        } finally {
+            // Always remove from uploading set
+            this.uploadingFiles.delete(fileName);
+        }
+    }
+
+    private generateEventFileName(): string {
+        const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+        const uuid = uuidv4().substring(0, 8);
+        return `events-${timestamp}-${uuid}.json`;
+    }
+
+    public async getUsage(
+        orgId: string,
+        featureId: FeatureId
+    ): Promise<Usage | null> {
+        if (build !== "saas") {
+            return null;
+        }
+
+        const usageId = `${orgId}-${featureId}`;
+
+        try {
+            const [result] = await db
+                .select()
+                .from(usage)
+                .where(eq(usage.usageId, usageId))
+                .limit(1);
+
+            if (!result) {
+                // Lets create one if it doesn't exist using upsert to handle race conditions
+                logger.info(
+                    `Creating new usage record for ${orgId}/${featureId}`
+                );
+                const meterId = getFeatureMeterId(featureId);
+                
+                try {
+                    const [newUsage] = await db
+                        .insert(usage)
+                        .values({
+                            usageId,
+                            featureId,
+                            orgId,
+                            meterId,
+                            latestValue: 0,
+                            updatedAt: Math.floor(Date.now() / 1000)
+                        })
+                        .onConflictDoNothing()
+                        .returning();
+
+                    if (newUsage) {
+                        return newUsage;
+                    } else {
+                        // Record was created by another process, fetch it
+                        const [existingUsage] = await db
+                            .select()
+                            .from(usage)
+                            .where(eq(usage.usageId, usageId))
+                            .limit(1);
+                        return existingUsage || null;
+                    }
+                } catch (insertError) {
+                    // Fallback: try to fetch existing record in case of any insert issues
+                    logger.warn(
+                        `Insert failed for ${orgId}/${featureId}, attempting to fetch existing record:`,
+                        insertError
+                    );
+                    const [existingUsage] = await db
+                        .select()
+                        .from(usage)
+                        .where(eq(usage.usageId, usageId))
+                        .limit(1);
+                    return existingUsage || null;
+                }
+            }
+
+            return result
+        } catch (error) {
+            logger.error(
+                `Failed to get usage for ${orgId}/${featureId}:`,
+                error
+            );
+            throw error;
+        }
+    }
+
+    public async getUsageDaily(
+        orgId: string,
+        featureId: FeatureId
+    ): Promise<Usage | null> {
+        if (build !== "saas") {
+            return null;
+        }
+        await this.updateDaily(orgId, featureId); // Ensure daily usage is updated
+        return this.getUsage(orgId, featureId);
+    }
+
+    public async forceUpload(): Promise<void> {
+        await this.uploadFileToS3();
+    }
+
+    public clearCache(): void {
+        this.cache.flushAll();
+    }
+
+    /**
+     * Scan the events directory for files older than 1 minute and upload them if not empty.
+     */
+    private async uploadOldEventFiles(): Promise<void> {
+        if (!this.eventsDir || !this.bucketName) {
+            logger.warn("Stripe local file path or bucket name is not configured, skipping old event file upload.");
+            return;
+        }
+        try {
+            const files = await fs.readdir(this.eventsDir);
+            const now = Date.now();
+            for (const file of files) {
+                if (!file.endsWith(".json")) continue;
+                
+                // Skip files that are already being uploaded
+                if (this.uploadingFiles.has(file)) {
+                    logger.debug(`Skipping file ${file} as it's already being uploaded`);
+                    continue;
+                }
+
+                const filePath = path.join(this.eventsDir, file);
+                
+                try {
+                    // Check if file still exists before processing
+                    try {
+                        await fs.access(filePath);
+                    } catch (accessError) {
+                        logger.debug(`File ${file} does not exist, skipping`);
+                        continue;
+                    }
+
+                    const stat = await fs.stat(filePath);
+                    const age = now - stat.mtimeMs;
+                    if (age >= 90000) {
+                        // 1.5 minutes - Mark as being uploaded
+                        this.uploadingFiles.add(file);
+                        
+                        try {
+                            const fileContent = await fs.readFile(
+                                filePath,
+                                "utf-8"
+                            );
+                            const events = JSON.parse(fileContent);
+                            if (Array.isArray(events) && events.length > 0) {
+                                // Upload to S3
+                                const uploadCommand = new PutObjectCommand({
+                                    Bucket: this.bucketName,
+                                    Key: file,
+                                    Body: fileContent,
+                                    ContentType: "application/json"
+                                });
+                                await s3Client.send(uploadCommand);
+                                
+                                // Check if file still exists before unlinking
+                                try {
+                                    await fs.access(filePath);
+                                    await fs.unlink(filePath);
+                                } catch (unlinkError) {
+                                    logger.debug(`File ${file} was already deleted during interval upload`);
+                                }
+                                
+                                logger.info(
+                                    `Interval: Uploaded event file ${file} to S3 with ${events.length} events`
+                                );
+                                // If this was the current event file, reset it
+                                if (this.currentEventFile === file) {
+                                    this.currentEventFile = null;
+                                    this.currentFileStartTime = 0;
+                                }
+                            } else {
+                                // Remove empty file
+                                try {
+                                    await fs.access(filePath);
+                                    await fs.unlink(filePath);
+                                } catch (unlinkError) {
+                                    logger.debug(`Empty file ${file} was already deleted`);
+                                }
+                            }
+                        } finally {
+                            // Always remove from uploading set
+                            this.uploadingFiles.delete(file);
+                        }
+                    }
+                } catch (err) {
+                    logger.error(
+                        `Interval: Error processing event file ${file}:`,
+                        err
+                    );
+                    // Remove from uploading set on error
+                    this.uploadingFiles.delete(file);
+                }
+            }
+        } catch (err) {
+            logger.error("Interval: Failed to scan for event files:", err);
+        }
+    }
+
+    public async checkLimitSet(orgId: string, kickSites = false, featureId?: FeatureId, usage?: Usage): Promise<boolean> {
+        if (build !== "saas") {
+            return false;
+        }
+        // This method should check the current usage against the limits set for the organization
+        // and kick out all of the sites on the org 
+        let hasExceededLimits = false;
+
+        try {
+            let orgLimits: Limit[] = [];
+            if (featureId) {
+                // Get all limits set for this organization
+                orgLimits = await db
+                    .select()
+                    .from(limits)
+                    .where(
+                        and(
+                            eq(limits.orgId, orgId),
+                            eq(limits.featureId, featureId)
+                        )
+                    );
+            } else {
+                // Get all limits set for this organization
+                orgLimits = await db
+                    .select()
+                    .from(limits)
+                    .where(eq(limits.orgId, orgId));
+            }
+
+            if (orgLimits.length === 0) {
+                logger.debug(`No limits set for org ${orgId}`);
+                return false;
+            }
+
+            // Check each limit against current usage
+            for (const limit of orgLimits) {
+                let currentUsage: Usage | null;
+                if (usage) {
+                    currentUsage = usage;
+                } else {
+                    currentUsage = await this.getUsage(orgId, limit.featureId as FeatureId);
+                }
+
+                const usageValue = currentUsage?.instantaneousValue || currentUsage?.latestValue || 0;
+                logger.debug(`Current usage for org ${orgId} on feature ${limit.featureId}: ${usageValue}`);
+                logger.debug(`Limit for org ${orgId} on feature ${limit.featureId}: ${limit.value}`);
+                if (currentUsage && limit.value !== null && usageValue > limit.value) {
+                    logger.debug(
+                        `Org ${orgId} has exceeded limit for ${limit.featureId}: ` +
+                        `${usageValue} > ${limit.value}`
+                    );
+                    hasExceededLimits = true;
+                    break; // Exit early if any limit is exceeded
+                }
+            }
+
+            // If any limits are exceeded, disconnect all sites for this organization
+            if (hasExceededLimits && kickSites) {
+                logger.warn(`Disconnecting all sites for org ${orgId} due to exceeded limits`);
+
+                // Get all sites for this organization
+                const orgSites = await db
+                    .select()
+                    .from(sites)
+                    .where(eq(sites.orgId, orgId));
+
+                // Mark all sites as offline and send termination messages
+                const siteUpdates = orgSites.map(site => site.siteId);
+
+                if (siteUpdates.length > 0) {
+                    // Send termination messages to newt sites
+                    for (const site of orgSites) {
+                        if (site.type === "newt") {
+                            const [newt] = await db
+                                .select()
+                                .from(newts)
+                                .where(eq(newts.siteId, site.siteId))
+                                .limit(1);
+
+                            if (newt) {
+                                const payload = {
+                                    type: `newt/wg/terminate`,
+                                    data: {
+                                        reason: "Usage limits exceeded"
+                                    }
+                                };
+
+                                // Don't await to prevent blocking
+                                sendToClient(newt.newtId, payload).catch((error: any) => {
+                                    logger.error(
+                                        `Failed to send termination message to newt ${newt.newtId}:`,
+                                        error
+                                    );
+                                });
+                            }
+                        }
+                    }
+
+                    logger.info(`Disconnected ${orgSites.length} sites for org ${orgId} due to exceeded limits`);
+                }
+            }
+        } catch (error) {
+            logger.error(`Error checking limits for org ${orgId}:`, error);
+        }
+
+        return hasExceededLimits;
+    }
+}
+
+export const usageService = new UsageService();

server/lib/private/createUserAccountOrg.ts

@@ -0,0 +1,206 @@
+/*
+ * This file is part of a proprietary work.
+ *
+ * Copyright (c) 2025 Fossorial, Inc.
+ * All rights reserved.
+ *
+ * This file is licensed under the Fossorial Commercial License.
+ * You may not use this file except in compliance with the License.
+ * Unauthorized use, copying, modification, or distribution is strictly prohibited.
+ *
+ * This file is not licensed under the AGPLv3.
+ */
+
+import { isValidCIDR } from "@server/lib/validators";
+import { getNextAvailableOrgSubnet } from "@server/lib/ip";
+import {
+    actions,
+    apiKeyOrg,
+    apiKeys,
+    db,
+    domains,
+    Org,
+    orgDomains,
+    orgs,
+    roleActions,
+    roles,
+    userOrgs
+} from "@server/db";
+import { eq } from "drizzle-orm";
+import { defaultRoleAllowedActions } from "@server/routers/role";
+import { FeatureId, limitsService, sandboxLimitSet } from "@server/lib/private/billing";
+import { createCustomer } from "@server/routers/private/billing/createCustomer";
+import { usageService } from "@server/lib/private/billing/usageService";
+
+export async function createUserAccountOrg(
+    userId: string,
+    userEmail: string
+): Promise<{
+    success: boolean;
+    org?: {
+        orgId: string;
+        name: string;
+        subnet: string;
+    };
+    error?: string;
+}> {
+    // const subnet = await getNextAvailableOrgSubnet();
+    const orgId = "org_" + userId;
+    const name = `${userEmail}'s Organization`;
+
+    // if (!isValidCIDR(subnet)) {
+    //     return {
+    //         success: false,
+    //         error: "Invalid subnet format. Please provide a valid CIDR notation."
+    //     };
+    // }
+
+    // // make sure the subnet is unique
+    // const subnetExists = await db
+    //     .select()
+    //     .from(orgs)
+    //     .where(eq(orgs.subnet, subnet))
+    //     .limit(1);
+
+    // if (subnetExists.length > 0) {
+    //     return { success: false, error: `Subnet ${subnet} already exists` };
+    // }
+
+    // make sure the orgId is unique
+    const orgExists = await db
+        .select()
+        .from(orgs)
+        .where(eq(orgs.orgId, orgId))
+        .limit(1);
+
+    if (orgExists.length > 0) {
+        return {
+            success: false,
+            error: `Organization with ID ${orgId} already exists`
+        };
+    }
+
+    let error = "";
+    let org: Org | null = null;
+
+    await db.transaction(async (trx) => {
+        const allDomains = await trx
+            .select()
+            .from(domains)
+            .where(eq(domains.configManaged, true));
+
+        const newOrg = await trx
+            .insert(orgs)
+            .values({
+                orgId,
+                name,
+                // subnet
+                subnet: "100.90.128.0/24", // TODO: this should not be hardcoded - or can it be the same in all orgs?
+                createdAt: new Date().toISOString()
+            })
+            .returning();
+
+        if (newOrg.length === 0) {
+            error = "Failed to create organization";
+            trx.rollback();
+            return;
+        }
+
+        org = newOrg[0];
+
+        // Create admin role within the same transaction
+        const [insertedRole] = await trx
+            .insert(roles)
+            .values({
+                orgId: newOrg[0].orgId,
+                isAdmin: true,
+                name: "Admin",
+                description: "Admin role with the most permissions"
+            })
+            .returning({ roleId: roles.roleId });
+
+        if (!insertedRole || !insertedRole.roleId) {
+            error = "Failed to create Admin role";
+            trx.rollback();
+            return;
+        }
+
+        const roleId = insertedRole.roleId;
+
+        // Get all actions and create role actions
+        const actionIds = await trx.select().from(actions).execute();
+
+        if (actionIds.length > 0) {
+            await trx.insert(roleActions).values(
+                actionIds.map((action) => ({
+                    roleId,
+                    actionId: action.actionId,
+                    orgId: newOrg[0].orgId
+                }))
+            );
+        }
+
+        if (allDomains.length) {
+            await trx.insert(orgDomains).values(
+                allDomains.map((domain) => ({
+                    orgId: newOrg[0].orgId,
+                    domainId: domain.domainId
+                }))
+            );
+        }
+
+        await trx.insert(userOrgs).values({
+            userId,
+            orgId: newOrg[0].orgId,
+            roleId: roleId,
+            isOwner: true
+        });
+
+        const memberRole = await trx
+            .insert(roles)
+            .values({
+                name: "Member",
+                description: "Members can only view resources",
+                orgId
+            })
+            .returning();
+
+        await trx.insert(roleActions).values(
+            defaultRoleAllowedActions.map((action) => ({
+                roleId: memberRole[0].roleId,
+                actionId: action,
+                orgId
+            }))
+        );
+    });
+
+    await limitsService.applyLimitSetToOrg(orgId, sandboxLimitSet);
+
+    if (!org) {
+        return { success: false, error: "Failed to create org" };
+    }
+
+    if (error) {
+        return {
+            success: false,
+            error: `Failed to create org: ${error}`
+        };
+    }
+
+    // make sure we have the stripe customer
+    const customerId = await createCustomer(orgId, userEmail);
+
+    if (customerId) {
+        await usageService.updateDaily(orgId, FeatureId.USERS, 1, customerId); // Only 1 because we are crating the org
+    }
+
+    return {
+        org: {
+            orgId,
+            name,
+            // subnet
+            subnet: "100.90.128.0/24"
+        },
+        success: true
+    };
+}

server/lib/private/rateLimitStore.ts

@@ -0,0 +1,25 @@
+/*
+ * This file is part of a proprietary work.
+ *
+ * Copyright (c) 2025 Fossorial, Inc.
+ * All rights reserved.
+ *
+ * This file is licensed under the Fossorial Commercial License.
+ * You may not use this file except in compliance with the License.
+ * Unauthorized use, copying, modification, or distribution is strictly prohibited.
+ *
+ * This file is not licensed under the AGPLv3.
+ */
+
+import RedisStore from "@server/db/private/redisStore";
+import { MemoryStore, Store } from "express-rate-limit";
+
+export function createStore(): Store {
+    const rateLimitStore: Store = new RedisStore({
+        prefix: 'api-rate-limit', // Optional: customize Redis key prefix
+        skipFailedRequests: true, // Don't count failed requests
+        skipSuccessfulRequests: false, // Count successful requests
+    });
+
+    return rateLimitStore;
+}

server/lib/private/readConfigFile.ts

@@ -0,0 +1,192 @@
+/*
+ * This file is part of a proprietary work.
+ *
+ * Copyright (c) 2025 Fossorial, Inc.
+ * All rights reserved.
+ *
+ * This file is licensed under the Fossorial Commercial License.
+ * You may not use this file except in compliance with the License.
+ * Unauthorized use, copying, modification, or distribution is strictly prohibited.
+ *
+ * This file is not licensed under the AGPLv3.
+ */
+
+import fs from "fs";
+import yaml from "js-yaml";
+import { privateConfigFilePath1 } from "@server/lib/consts";
+import { z } from "zod";
+import { colorsSchema } from "@server/lib/colorsSchema";
+import { build } from "@server/build";
+
+const portSchema = z.number().positive().gt(0).lte(65535);
+
+export const privateConfigSchema = z
+    .object({
+        app: z.object({
+            region: z.string().optional().default("default"),
+            base_domain: z.string().optional()
+        }).optional().default({
+            region: "default"
+        }),
+        server: z.object({
+            encryption_key_path: z
+                .string()
+                .optional()
+                .default("./config/encryption.pem")
+                .pipe(z.string().min(8)),
+            resend_api_key: z.string().optional(),
+            reo_client_id: z.string().optional(),
+        }).optional().default({
+            encryption_key_path: "./config/encryption.pem"
+        }),
+        redis: z
+            .object({
+                host: z.string(),
+                port: portSchema,
+                password: z.string().optional(),
+                db: z.number().int().nonnegative().optional().default(0),
+                replicas: z
+                    .array(
+                        z.object({
+                            host: z.string(),
+                            port: portSchema,
+                            password: z.string().optional(),
+                            db: z.number().int().nonnegative().optional().default(0)
+                        })
+                    )
+                    .optional()
+                // tls: z
+                //     .object({
+                //         reject_unauthorized: z
+                //             .boolean()
+                //             .optional()
+                //             .default(true)
+                //     })
+                //     .optional()
+            })
+            .optional(),
+        gerbil: z
+            .object({
+                local_exit_node_reachable_at: z.string().optional().default("http://gerbil:3003")
+            })
+            .optional()
+            .default({}),
+        flags: z
+            .object({
+                enable_redis: z.boolean().optional(),
+                hide_supporter_key: z.boolean().optional()
+            })
+            .optional(),
+        branding: z
+            .object({
+                app_name: z.string().optional(),
+                background_image_path: z.string().optional(),
+                colors: z
+                    .object({
+                        light: colorsSchema.optional(),
+                        dark: colorsSchema.optional()
+                    })
+                    .optional(),
+                logo: z
+                    .object({
+                        light_path: z.string().optional(),
+                        dark_path: z.string().optional(),
+                        auth_page: z
+                            .object({
+                                width: z.number().optional(),
+                                height: z.number().optional()
+                            })
+                            .optional(),
+                        navbar: z
+                            .object({
+                                width: z.number().optional(),
+                                height: z.number().optional()
+                            })
+                            .optional()
+                    })
+                    .optional(),
+                favicon_path: z.string().optional(),
+                footer: z
+                    .array(
+                        z.object({
+                            text: z.string(),
+                            href: z.string().optional()
+                        })
+                    )
+                    .optional(),
+                login_page: z
+                    .object({
+                        subtitle_text: z.string().optional(),
+                        title_text: z.string().optional()
+                    })
+                    .optional(),
+                signup_page: z
+                    .object({
+                        subtitle_text: z.string().optional(),
+                        title_text: z.string().optional()
+                    })
+                    .optional(),
+                resource_auth_page: z
+                    .object({
+                        show_logo: z.boolean().optional(),
+                        hide_powered_by: z.boolean().optional(),
+                        title_text: z.string().optional(),
+                        subtitle_text: z.string().optional()
+                    })
+                    .optional(),
+                emails: z
+                    .object({
+                        signature: z.string().optional(),
+                        colors: z
+                            .object({
+                                primary: z.string().optional()
+                            })
+                            .optional()
+                    })
+                    .optional()
+            })
+            .optional(),
+        stripe: z
+            .object({
+                secret_key: z.string(),
+                webhook_secret: z.string(),
+                s3Bucket: z.string(),
+                s3Region: z.string().default("us-east-1"),
+                localFilePath: z.string()
+            })
+            .optional(),
+    })
+
+export function readPrivateConfigFile() {
+    if (build == "oss") {
+        return {};
+    }
+
+    const loadConfig = (configPath: string) => {
+        try {
+            const yamlContent = fs.readFileSync(configPath, "utf8");
+            const config = yaml.load(yamlContent);
+            return config;
+        } catch (error) {
+            if (error instanceof Error) {
+                throw new Error(
+                    `Error loading configuration file: ${error.message}`
+                );
+            }
+            throw error;
+        }
+    };
+
+    let environment: any;
+    if (fs.existsSync(privateConfigFilePath1)) {
+        environment = loadConfig(privateConfigFilePath1);
+    }
+
+    if (!environment) {
+        throw new Error(
+            "No private configuration file found."
+        );
+    }
+
+    return environment;
+}

server/lib/private/resend.ts

@@ -0,0 +1,124 @@
+/*
+ * This file is part of a proprietary work.
+ *
+ * Copyright (c) 2025 Fossorial, Inc.
+ * All rights reserved.
+ *
+ * This file is licensed under the Fossorial Commercial License.
+ * You may not use this file except in compliance with the License.
+ * Unauthorized use, copying, modification, or distribution is strictly prohibited.
+ *
+ * This file is not licensed under the AGPLv3.
+ */
+
+import { Resend } from "resend";
+import config from "../config";
+import logger from "@server/logger";
+
+export enum AudienceIds {
+    General = "5cfbf99b-c592-40a9-9b8a-577a4681c158",
+    Subscribed = "870b43fd-387f-44de-8fc1-707335f30b20",
+    Churned = "f3ae92bd-2fdb-4d77-8746-2118afd62549"
+}
+
+const resend = new Resend(
+    config.getRawPrivateConfig().server.resend_api_key || "missing"
+);
+
+export default resend;
+
+export async function moveEmailToAudience(
+    email: string,
+    audienceId: AudienceIds
+) {
+    if (process.env.ENVIRONMENT !== "prod") {
+        logger.debug(`Skipping moving email ${email} to audience ${audienceId} in non-prod environment`);
+        return;
+    }
+    const { error, data } = await retryWithBackoff(async () => {
+        const { data, error } = await resend.contacts.create({
+            email,
+            unsubscribed: false,
+            audienceId
+        });
+        if (error) {
+            throw new Error(
+                `Error adding email ${email} to audience ${audienceId}: ${error}`
+            );
+        }
+        return { error, data };
+    });
+
+    if (error) {
+        logger.error(
+            `Error adding email ${email} to audience ${audienceId}: ${error}`
+        );
+        return;
+    }
+
+    if (data) {
+        logger.debug(
+            `Added email ${email} to audience ${audienceId} with contact ID ${data.id}`
+        )
+    }
+
+    const otherAudiences = Object.values(AudienceIds).filter(
+        (id) => id !== audienceId
+    );
+
+    for (const otherAudienceId of otherAudiences) {
+        const { error, data } = await retryWithBackoff(async () => {
+            const { data, error } = await resend.contacts.remove({
+                email,
+                audienceId: otherAudienceId
+            });
+            if (error) {
+                throw new Error(
+                    `Error removing email ${email} from audience ${otherAudienceId}: ${error}`
+                );
+            }
+            return { error, data };
+        });
+
+        if (error) {
+            logger.error(
+                `Error removing email ${email} from audience ${otherAudienceId}: ${error}`
+            );
+        }
+
+        if (data) {
+            logger.info(
+                `Removed email ${email} from audience ${otherAudienceId}`
+            );
+        }
+    }
+}
+
+type RetryOptions = {
+    retries?: number;
+    initialDelayMs?: number;
+    factor?: number;
+};
+
+export async function retryWithBackoff<T>(
+    fn: () => Promise<T>,
+    options: RetryOptions = {}
+): Promise<T> {
+    const { retries = 5, initialDelayMs = 500, factor = 2 } = options;
+
+    let attempt = 0;
+    let delay = initialDelayMs;
+
+    while (true) {
+        try {
+            return await fn();
+        } catch (err) {
+            attempt++;
+
+            if (attempt > retries) throw err;
+
+            await new Promise((resolve) => setTimeout(resolve, delay));
+            delay *= factor;
+        }
+    }
+}

server/lib/private/s3.ts

@@ -0,0 +1,19 @@
+/*
+ * This file is part of a proprietary work.
+ *
+ * Copyright (c) 2025 Fossorial, Inc.
+ * All rights reserved.
+ *
+ * This file is licensed under the Fossorial Commercial License.
+ * You may not use this file except in compliance with the License.
+ * Unauthorized use, copying, modification, or distribution is strictly prohibited.
+ *
+ * This file is not licensed under the AGPLv3.
+ */
+
+import { S3Client } from "@aws-sdk/client-s3";
+import config from "@server/lib/config";
+
+export const s3Client = new S3Client({
+    region: config.getRawPrivateConfig().stripe?.s3Region || "us-east-1",
+});

server/lib/private/stripe.ts

@@ -0,0 +1,28 @@
+/*
+ * This file is part of a proprietary work.
+ *
+ * Copyright (c) 2025 Fossorial, Inc.
+ * All rights reserved.
+ *
+ * This file is licensed under the Fossorial Commercial License.
+ * You may not use this file except in compliance with the License.
+ * Unauthorized use, copying, modification, or distribution is strictly prohibited.
+ *
+ * This file is not licensed under the AGPLv3.
+ */
+
+import Stripe from "stripe";
+import config from "@server/lib/config";
+import logger from "@server/logger";
+import { build } from "@server/build";
+
+let stripe: Stripe | undefined = undefined;
+if (build == "saas") {
+    const stripeApiKey = config.getRawPrivateConfig().stripe?.secret_key;
+    if (!stripeApiKey) {
+        logger.error("Stripe secret key is not configured");
+    }
+    stripe = new Stripe(stripeApiKey!);
+}
+
+export default stripe;