@better-translate/nextjs 1.0.0

package/dist/proxy.cjs

@@ -0,0 +1,318 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/proxy.ts
+var proxy_exports = {};
+__export(proxy_exports, {
+  createProxy: () => createProxy,
+  defaultProxyMatcher: () => defaultProxyMatcher,
+  getProxyMatcher: () => getProxyMatcher,
+  withBetterTranslate: () => withBetterTranslate
+});
+module.exports = __toCommonJS(proxy_exports);
+var import_intl_localematcher = require("@formatjs/intl-localematcher");
+var import_negotiator = __toESM(require("negotiator"), 1);
+var import_server = require("next/server");
+
+// src/shared.ts
+var DEFAULT_ROUTE_TEMPLATE = "/[lang]";
+function hasLocale(locales, value) {
+  return locales.includes(value);
+}
+function normalizePathname(pathname) {
+  if (!pathname) {
+    return "/";
+  }
+  return pathname.startsWith("/") ? pathname : `/${pathname}`;
+}
+function getPathnameLocale(pathname, routing) {
+  const parsedTemplate = parseRouteTemplate(routing.routeTemplate);
+  const pathnameSegments = splitPathname(pathname);
+  if (pathnameSegments.length < parsedTemplate.localizedSegments.length) {
+    return void 0;
+  }
+  for (let index = 0; index < parsedTemplate.localizedSegments.length; index += 1) {
+    const templateSegment = parsedTemplate.localizedSegments[index];
+    const pathnameSegment = pathnameSegments[index];
+    if (index === parsedTemplate.localeSegmentIndex) {
+      if (!pathnameSegment || !hasLocale(routing.locales, pathnameSegment)) {
+        return void 0;
+      }
+      continue;
+    }
+    if (pathnameSegment !== templateSegment) {
+      return void 0;
+    }
+  }
+  return pathnameSegments[parsedTemplate.localeSegmentIndex];
+}
+function isPathnameInScope(pathname, routing) {
+  if (getPathnameLocale(pathname, routing)) {
+    return true;
+  }
+  const parsedTemplate = parseRouteTemplate(routing.routeTemplate);
+  const pathnameSegments = splitPathname(pathname);
+  if (pathnameSegments.length < parsedTemplate.deLocalizedSegments.length) {
+    return false;
+  }
+  for (let index = 0; index < parsedTemplate.deLocalizedSegments.length; index += 1) {
+    if (pathnameSegments[index] !== parsedTemplate.deLocalizedSegments[index]) {
+      return false;
+    }
+  }
+  return true;
+}
+function stripLocaleFromPathname(pathname, routing) {
+  const locale = getPathnameLocale(pathname, routing);
+  if (!locale) {
+    return normalizePathname(pathname);
+  }
+  const parsedTemplate = parseRouteTemplate(routing.routeTemplate);
+  const pathnameSegments = splitPathname(pathname);
+  pathnameSegments.splice(parsedTemplate.localeSegmentIndex, 1);
+  return joinPathname(pathnameSegments);
+}
+function localizePathname(pathname, locale, routing) {
+  const normalizedPathname = normalizePathname(pathname);
+  const deLocalizedPathname = stripLocaleFromPathname(
+    normalizedPathname,
+    routing
+  );
+  if (!isPathnameInScope(deLocalizedPathname, routing)) {
+    return normalizedPathname;
+  }
+  const parsedTemplate = parseRouteTemplate(routing.routeTemplate);
+  const pathnameSegments = splitPathname(deLocalizedPathname);
+  const localizedSegments = [...pathnameSegments];
+  localizedSegments.splice(parsedTemplate.localeSegmentIndex, 0, locale);
+  return joinPathname(localizedSegments);
+}
+function splitHrefString(href) {
+  const hashIndex = href.indexOf("#");
+  const searchIndex = href.indexOf("?");
+  const pathnameEnd = hashIndex === -1 ? searchIndex === -1 ? href.length : searchIndex : searchIndex === -1 ? hashIndex : Math.min(searchIndex, hashIndex);
+  const pathname = href.slice(0, pathnameEnd) || "/";
+  const search = searchIndex === -1 ? "" : href.slice(searchIndex, hashIndex === -1 ? href.length : hashIndex);
+  const hash = hashIndex === -1 ? "" : href.slice(hashIndex);
+  return {
+    pathname: normalizePathname(pathname),
+    search,
+    hash
+  };
+}
+function isAbsoluteHref(href) {
+  return /^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(href) || href.startsWith("//");
+}
+function normalizeHost(host) {
+  return host.toLowerCase().replace(/:\d+$/, "");
+}
+function getDomainForLocale(routing, locale) {
+  return routing.domains?.find(
+    (domain) => getDomainLocales(domain).includes(locale)
+  );
+}
+function getLocaleFromDomain(routing, host) {
+  const normalizedHost = normalizeHost(host);
+  return routing.domains?.find(
+    (domain) => normalizeHost(domain.domain) === normalizedHost
+  )?.defaultLocale;
+}
+function buildDomainAwareHref(routing, href, locale, options) {
+  if (isAbsoluteHref(href)) {
+    return {
+      href,
+      external: true
+    };
+  }
+  const { hash, pathname, search } = splitHrefString(href);
+  const isScopedPath = isPathnameInScope(pathname, routing);
+  if (!isScopedPath) {
+    return {
+      href: `${pathname}${search}${hash}`,
+      external: false
+    };
+  }
+  const localizedPathname = localizePathname(pathname, locale, routing);
+  const localizedHref = `${localizedPathname}${search}${hash}`;
+  const targetDomain = getDomainForLocale(routing, locale);
+  if (!targetDomain) {
+    return {
+      href: localizedHref,
+      external: false
+    };
+  }
+  const targetHost = normalizeHost(targetDomain.domain);
+  const currentHost = options?.currentHost ? normalizeHost(options.currentHost) : void 0;
+  const shouldUseAbsolute = options?.forceAbsolute === true || currentHost === void 0 || currentHost !== targetHost;
+  if (!shouldUseAbsolute) {
+    return {
+      href: localizedHref,
+      external: false
+    };
+  }
+  const protocol = targetDomain.protocol ?? options?.protocol ?? "https";
+  return {
+    href: `${protocol}://${targetHost}${localizedHref}`,
+    external: currentHost === void 0 ? true : currentHost !== targetHost
+  };
+}
+function parseRouteTemplate(routeTemplate) {
+  const normalizedRouteTemplate = normalizePathname(
+    routeTemplate ?? DEFAULT_ROUTE_TEMPLATE
+  );
+  const localizedSegments = splitPathname(normalizedRouteTemplate);
+  let localeSegmentIndex = -1;
+  let localeParamName = "";
+  for (let index = 0; index < localizedSegments.length; index += 1) {
+    const segment = localizedSegments[index];
+    const dynamicMatch = /^\[([^\]/]+)\]$/.exec(segment);
+    if (!dynamicMatch) {
+      continue;
+    }
+    if (localeSegmentIndex !== -1) {
+      throw new Error(
+        `Route template "${normalizedRouteTemplate}" must contain exactly one dynamic locale segment.`
+      );
+    }
+    localeSegmentIndex = index;
+    localeParamName = dynamicMatch[1];
+  }
+  if (localeSegmentIndex === -1) {
+    throw new Error(
+      `Route template "${normalizedRouteTemplate}" must contain one dynamic locale segment like "[lang]".`
+    );
+  }
+  const deLocalizedSegments = localizedSegments.filter(
+    (_, index) => index !== localeSegmentIndex
+  );
+  const scopePrefixSegments = localizedSegments.slice(0, localeSegmentIndex);
+  return {
+    deLocalizedSegments,
+    localeParamName,
+    localeSegmentIndex,
+    localizedSegments,
+    routeTemplate: normalizedRouteTemplate,
+    scopePrefix: joinPathname(scopePrefixSegments)
+  };
+}
+function splitPathname(pathname) {
+  return normalizePathname(pathname).split("/").filter(Boolean);
+}
+function joinPathname(segments) {
+  if (segments.length === 0) {
+    return "/";
+  }
+  return `/${segments.join("/")}`;
+}
+function getDomainLocales(domain) {
+  if (!domain.locales || domain.locales.length === 0) {
+    return [domain.defaultLocale];
+  }
+  if (!domain.locales.includes(domain.defaultLocale)) {
+    return [...domain.locales, domain.defaultLocale];
+  }
+  return domain.locales;
+}
+
+// src/proxy.ts
+var defaultProxyMatcher = [
+  "/((?!api|_next|_vercel|.*\\..*).*)"
+];
+function createProxy(routing, _options) {
+  return function proxy(request) {
+    const pathname = request.nextUrl.pathname;
+    if (!isPathnameInScope(pathname, routing)) {
+      return void 0;
+    }
+    const pathnameLocale = getPathnameLocale(pathname, routing);
+    const host = request.headers.get("x-forwarded-host") ?? request.headers.get("host") ?? request.nextUrl.host;
+    const locale = pathnameLocale ?? (host ? getLocaleFromDomain(routing, host) : void 0) ?? getPreferredLocale(
+      request.headers.get("accept-language"),
+      routing.locales,
+      routing.defaultLocale
+    );
+    const targetHref = buildDomainAwareHref(
+      routing,
+      `${pathname}${request.nextUrl.search}`,
+      locale,
+      {
+        currentHost: host ?? void 0,
+        forceAbsolute: !pathnameLocale,
+        protocol: request.nextUrl.protocol.replace(":", "")
+      }
+    );
+    const redirectUrl = targetHref.href.startsWith("/") ? new URL(targetHref.href, request.url).toString() : targetHref.href;
+    if (!pathnameLocale) {
+      return import_server.NextResponse.redirect(redirectUrl);
+    }
+    if (targetHref.external) {
+      return import_server.NextResponse.redirect(redirectUrl);
+    }
+    return void 0;
+  };
+}
+function withBetterTranslate(userProxy, routing, options) {
+  const betterTranslateProxy = createProxy(routing, options);
+  return async function composedProxy(request, event) {
+    const betterTranslateResult = await betterTranslateProxy(request, event);
+    if (betterTranslateResult) {
+      return betterTranslateResult;
+    }
+    return userProxy(request, event);
+  };
+}
+function getProxyMatcher(routing) {
+  const parsedTemplate = parseRouteTemplate(routing.routeTemplate);
+  if (parsedTemplate.scopePrefix === "/") {
+    return defaultProxyMatcher;
+  }
+  const escapedPrefix = escapeMatcherSegment(parsedTemplate.scopePrefix);
+  return [
+    parsedTemplate.scopePrefix,
+    `${escapedPrefix}/((?!.*\\..*).*)`
+  ];
+}
+function getPreferredLocale(acceptLanguageHeader, locales, defaultLocale) {
+  const negotiator = new import_negotiator.default({
+    headers: {
+      "accept-language": acceptLanguageHeader ?? ""
+    }
+  });
+  return (0, import_intl_localematcher.match)(negotiator.languages(), locales, defaultLocale);
+}
+function escapeMatcherSegment(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createProxy,
+  defaultProxyMatcher,
+  getProxyMatcher,
+  withBetterTranslate
+});

package/dist/proxy.d.cts

@@ -0,0 +1,11 @@
+import { RoutingConfig } from './index.cjs';
+import { NextProxy } from 'next/server';
+
+interface CreateProxyOptions {
+}
+declare const defaultProxyMatcher: readonly ["/((?!api|_next|_vercel|.*\\..*).*)"];
+declare function createProxy<TLocale extends string>(routing: RoutingConfig<TLocale>, _options?: CreateProxyOptions): NextProxy;
+declare function withBetterTranslate<TLocale extends string>(userProxy: NextProxy, routing: RoutingConfig<TLocale>, options?: CreateProxyOptions): NextProxy;
+declare function getProxyMatcher<TLocale extends string>(routing: RoutingConfig<TLocale>): readonly string[];
+
+export { type CreateProxyOptions, createProxy, defaultProxyMatcher, getProxyMatcher, withBetterTranslate };

package/dist/proxy.d.ts

@@ -0,0 +1,11 @@
+import { RoutingConfig } from './index.js';
+import { NextProxy } from 'next/server';
+
+interface CreateProxyOptions {
+}
+declare const defaultProxyMatcher: readonly ["/((?!api|_next|_vercel|.*\\..*).*)"];
+declare function createProxy<TLocale extends string>(routing: RoutingConfig<TLocale>, _options?: CreateProxyOptions): NextProxy;
+declare function withBetterTranslate<TLocale extends string>(userProxy: NextProxy, routing: RoutingConfig<TLocale>, options?: CreateProxyOptions): NextProxy;
+declare function getProxyMatcher<TLocale extends string>(routing: RoutingConfig<TLocale>): readonly string[];
+
+export { type CreateProxyOptions, createProxy, defaultProxyMatcher, getProxyMatcher, withBetterTranslate };

package/dist/proxy.js

@@ -0,0 +1,86 @@
+import {
+  buildDomainAwareHref,
+  getLocaleFromDomain,
+  getPathnameLocale,
+  isPathnameInScope,
+  parseRouteTemplate
+} from "./chunk-VW2LUTE7.js";
+
+// src/proxy.ts
+import { match } from "@formatjs/intl-localematcher";
+import Negotiator from "negotiator";
+import { NextResponse } from "next/server";
+var defaultProxyMatcher = [
+  "/((?!api|_next|_vercel|.*\\..*).*)"
+];
+function createProxy(routing, _options) {
+  return function proxy(request) {
+    const pathname = request.nextUrl.pathname;
+    if (!isPathnameInScope(pathname, routing)) {
+      return void 0;
+    }
+    const pathnameLocale = getPathnameLocale(pathname, routing);
+    const host = request.headers.get("x-forwarded-host") ?? request.headers.get("host") ?? request.nextUrl.host;
+    const locale = pathnameLocale ?? (host ? getLocaleFromDomain(routing, host) : void 0) ?? getPreferredLocale(
+      request.headers.get("accept-language"),
+      routing.locales,
+      routing.defaultLocale
+    );
+    const targetHref = buildDomainAwareHref(
+      routing,
+      `${pathname}${request.nextUrl.search}`,
+      locale,
+      {
+        currentHost: host ?? void 0,
+        forceAbsolute: !pathnameLocale,
+        protocol: request.nextUrl.protocol.replace(":", "")
+      }
+    );
+    const redirectUrl = targetHref.href.startsWith("/") ? new URL(targetHref.href, request.url).toString() : targetHref.href;
+    if (!pathnameLocale) {
+      return NextResponse.redirect(redirectUrl);
+    }
+    if (targetHref.external) {
+      return NextResponse.redirect(redirectUrl);
+    }
+    return void 0;
+  };
+}
+function withBetterTranslate(userProxy, routing, options) {
+  const betterTranslateProxy = createProxy(routing, options);
+  return async function composedProxy(request, event) {
+    const betterTranslateResult = await betterTranslateProxy(request, event);
+    if (betterTranslateResult) {
+      return betterTranslateResult;
+    }
+    return userProxy(request, event);
+  };
+}
+function getProxyMatcher(routing) {
+  const parsedTemplate = parseRouteTemplate(routing.routeTemplate);
+  if (parsedTemplate.scopePrefix === "/") {
+    return defaultProxyMatcher;
+  }
+  const escapedPrefix = escapeMatcherSegment(parsedTemplate.scopePrefix);
+  return [
+    parsedTemplate.scopePrefix,
+    `${escapedPrefix}/((?!.*\\..*).*)`
+  ];
+}
+function getPreferredLocale(acceptLanguageHeader, locales, defaultLocale) {
+  const negotiator = new Negotiator({
+    headers: {
+      "accept-language": acceptLanguageHeader ?? ""
+    }
+  });
+  return match(negotiator.languages(), locales, defaultLocale);
+}
+function escapeMatcherSegment(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+export {
+  createProxy,
+  defaultProxyMatcher,
+  getProxyMatcher,
+  withBetterTranslate
+};

package/dist/server.cjs

@@ -0,0 +1,121 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/server.ts
+var server_exports = {};
+__export(server_exports, {
+  createServerHelpers: () => createServerHelpers,
+  getRequestConfig: () => getRequestConfig,
+  setRequestLocale: () => setRequestLocale
+});
+module.exports = __toCommonJS(server_exports);
+var import_react = require("react");
+var import_server = require("@better-translate/core/server");
+function getRequestConfig(factory) {
+  return factory;
+}
+function setRequestLocale(locale) {
+  (0, import_server.setRequestLocale)(locale);
+}
+function createServerHelpers(requestConfig) {
+  const readRequestConfig = (0, import_react.cache)(async () => {
+    const resolved = await requestConfig();
+    const translator = resolved.translator;
+    return {
+      locale: resolved.locale,
+      translator
+    };
+  });
+  async function getResolvedLocale(options) {
+    const { locale: configLocale, translator } = await readRequestConfig();
+    return (0, import_server.resolveRequestLocale)(translator, {
+      locale: options?.config?.locale ?? options?.locale,
+      requestLocale: (0, import_server.getRequestLocale)(),
+      configLocale
+    });
+  }
+  async function getDirection(options) {
+    const [{ translator }, locale] = await Promise.all([
+      readRequestConfig(),
+      getResolvedLocale(options)
+    ]);
+    return translator.getDirection({
+      config: typeof options?.config?.rtl === "boolean" ? {
+        rtl: options.config.rtl
+      } : void 0,
+      locale
+    });
+  }
+  async function isRtl(options) {
+    return await getDirection(options) === "rtl";
+  }
+  return {
+    async getAvailableLanguages() {
+      return (await readRequestConfig()).translator.getAvailableLanguages();
+    },
+    getDirection,
+    async getLocale() {
+      return getResolvedLocale();
+    },
+    async getMessages() {
+      const [{ translator }, locale] = await Promise.all([
+        readRequestConfig(),
+        getResolvedLocale()
+      ]);
+      const loadedMessages = await translator.loadLocale(locale);
+      const cachedMessages = translator.getMessages()[locale];
+      if (loadedMessages) {
+        return loadedMessages;
+      }
+      if (cachedMessages) {
+        return cachedMessages;
+      }
+      throw new Error(
+        `Locale "${locale}" messages are not available. Preload them or register a loader in your Better Translate core config.`
+      );
+    },
+    isRtl,
+    async getTranslations(options) {
+      const [{ translator }, locale] = await Promise.all([
+        readRequestConfig(),
+        getResolvedLocale(options)
+      ]);
+      await translator.loadLocale(locale);
+      return ((...args) => {
+        const [key, translateOptions] = args;
+        return translator.t(
+          key,
+          {
+            ...translateOptions ?? {},
+            locale
+          }
+        );
+      });
+    },
+    async getTranslator() {
+      return (await readRequestConfig()).translator;
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createServerHelpers,
+  getRequestConfig,
+  setRequestLocale
+});

package/dist/server.d.cts

@@ -0,0 +1,30 @@
+import { ConfiguredTranslator, TranslationMessages, TranslationLanguageMetadata, TranslationConfig, TranslationDirection, DeepPartialMessages } from '@better-translate/core';
+
+type AnyTranslator = ConfiguredTranslator<any, TranslationMessages>;
+type InferTranslatorLocale<TTranslator> = TTranslator extends ConfiguredTranslator<infer TLocale, TranslationMessages> ? TLocale : never;
+type InferTranslatorMessages<TTranslator> = TTranslator extends ConfiguredTranslator<string, infer TMessages> ? TMessages : TranslationMessages;
+interface BetterTranslateRequestConfig<TTranslator extends AnyTranslator, TLocale extends InferTranslatorLocale<TTranslator> = InferTranslatorLocale<TTranslator>> {
+    locale?: TLocale;
+    translator: TTranslator;
+}
+type RequestConfigFactory<TTranslator extends AnyTranslator, TLocale extends InferTranslatorLocale<TTranslator> = InferTranslatorLocale<TTranslator>> = () => BetterTranslateRequestConfig<TTranslator, TLocale> | Promise<BetterTranslateRequestConfig<TTranslator, TLocale>>;
+type RequestDirectionOptions<TLocale extends string> = {
+    locale?: TLocale;
+    config?: TranslationConfig<TLocale>;
+};
+interface ServerHelpers<TRequestLocale extends string, TTranslator extends AnyTranslator> {
+    getAvailableLanguages(): Promise<readonly TranslationLanguageMetadata<InferTranslatorLocale<TTranslator>>[]>;
+    getDirection(options?: RequestDirectionOptions<InferTranslatorLocale<TTranslator>>): Promise<TranslationDirection>;
+    getLocale(): Promise<TRequestLocale>;
+    getMessages(): Promise<DeepPartialMessages<InferTranslatorMessages<TTranslator>> | InferTranslatorMessages<TTranslator>>;
+    isRtl(options?: RequestDirectionOptions<InferTranslatorLocale<TTranslator>>): Promise<boolean>;
+    getTranslations(options?: {
+        locale?: InferTranslatorLocale<TTranslator>;
+    }): Promise<TTranslator["t"]>;
+    getTranslator(): Promise<TTranslator>;
+}
+declare function getRequestConfig<TTranslator extends AnyTranslator, TLocale extends InferTranslatorLocale<TTranslator> = InferTranslatorLocale<TTranslator>>(factory: RequestConfigFactory<TTranslator, TLocale>): RequestConfigFactory<TTranslator, TLocale>;
+declare function setRequestLocale<TLocale extends string>(locale: TLocale | undefined): void;
+declare function createServerHelpers<TTranslator extends AnyTranslator, TLocale extends InferTranslatorLocale<TTranslator> = InferTranslatorLocale<TTranslator>>(requestConfig: RequestConfigFactory<TTranslator, TLocale>): ServerHelpers<TLocale, TTranslator>;
+
+export { type BetterTranslateRequestConfig, type RequestConfigFactory, type ServerHelpers, createServerHelpers, getRequestConfig, setRequestLocale };

package/dist/server.d.ts

@@ -0,0 +1,30 @@
+import { ConfiguredTranslator, TranslationMessages, TranslationLanguageMetadata, TranslationConfig, TranslationDirection, DeepPartialMessages } from '@better-translate/core';
+
+type AnyTranslator = ConfiguredTranslator<any, TranslationMessages>;
+type InferTranslatorLocale<TTranslator> = TTranslator extends ConfiguredTranslator<infer TLocale, TranslationMessages> ? TLocale : never;
+type InferTranslatorMessages<TTranslator> = TTranslator extends ConfiguredTranslator<string, infer TMessages> ? TMessages : TranslationMessages;
+interface BetterTranslateRequestConfig<TTranslator extends AnyTranslator, TLocale extends InferTranslatorLocale<TTranslator> = InferTranslatorLocale<TTranslator>> {
+    locale?: TLocale;
+    translator: TTranslator;
+}
+type RequestConfigFactory<TTranslator extends AnyTranslator, TLocale extends InferTranslatorLocale<TTranslator> = InferTranslatorLocale<TTranslator>> = () => BetterTranslateRequestConfig<TTranslator, TLocale> | Promise<BetterTranslateRequestConfig<TTranslator, TLocale>>;
+type RequestDirectionOptions<TLocale extends string> = {
+    locale?: TLocale;
+    config?: TranslationConfig<TLocale>;
+};
+interface ServerHelpers<TRequestLocale extends string, TTranslator extends AnyTranslator> {
+    getAvailableLanguages(): Promise<readonly TranslationLanguageMetadata<InferTranslatorLocale<TTranslator>>[]>;
+    getDirection(options?: RequestDirectionOptions<InferTranslatorLocale<TTranslator>>): Promise<TranslationDirection>;
+    getLocale(): Promise<TRequestLocale>;
+    getMessages(): Promise<DeepPartialMessages<InferTranslatorMessages<TTranslator>> | InferTranslatorMessages<TTranslator>>;
+    isRtl(options?: RequestDirectionOptions<InferTranslatorLocale<TTranslator>>): Promise<boolean>;
+    getTranslations(options?: {
+        locale?: InferTranslatorLocale<TTranslator>;
+    }): Promise<TTranslator["t"]>;
+    getTranslator(): Promise<TTranslator>;
+}
+declare function getRequestConfig<TTranslator extends AnyTranslator, TLocale extends InferTranslatorLocale<TTranslator> = InferTranslatorLocale<TTranslator>>(factory: RequestConfigFactory<TTranslator, TLocale>): RequestConfigFactory<TTranslator, TLocale>;
+declare function setRequestLocale<TLocale extends string>(locale: TLocale | undefined): void;
+declare function createServerHelpers<TTranslator extends AnyTranslator, TLocale extends InferTranslatorLocale<TTranslator> = InferTranslatorLocale<TTranslator>>(requestConfig: RequestConfigFactory<TTranslator, TLocale>): ServerHelpers<TLocale, TTranslator>;
+
+export { type BetterTranslateRequestConfig, type RequestConfigFactory, type ServerHelpers, createServerHelpers, getRequestConfig, setRequestLocale };