@turnipxenon/pineapple 5.3.15 → 5.3.17

package/dist/external/paraglide/runtime.d.ts

@@ -1,3 +1,12 @@
+/**
+ * Returns the current server-side async local storage instance.
+ *
+ * Accessing the mutable value through a function keeps it observable when
+ * module interceptors wrap exported bindings and snapshot their initial value.
+ *
+ * @returns {ParaglideAsyncLocalStorage | undefined}
+ */
+export function getServerAsyncLocalStorage(): ParaglideAsyncLocalStorage | undefined;
 /**
  * Sets the server side async local storage.
  *
@@ -10,7 +19,36 @@
  */
 export function overwriteServerAsyncLocalStorage(value: ParaglideAsyncLocalStorage | undefined): void;
 /**
- * Check if something is an available locale.
+ * Resolve locale for a given URL using route-aware strategies.
+ *
+ * @param {string | URL} url
+ * @returns {Locale}
+ */
+export function getLocaleForUrl(url: string | URL): Locale;
+/**
+ * Get writing direction for a locale.
+ *
+ * Uses `Intl.Locale` text info when available and falls back to a
+ * language-based RTL check for runtimes without `getTextInfo()`.
+ *
+ * @example
+ *   getTextDirection(); // "ltr" or "rtl" for current locale
+ *   getTextDirection("ar"); // "rtl"
+ *   getTextDirection("en"); // "ltr"
+ *
+ * @param {string} [locale] - Target locale. If not provided, uses `getLocale()`
+ * @returns {"ltr" | "rtl"}
+ */
+export function getTextDirection(locale?: string): "ltr" | "rtl";
+/**
+ * Coerces a locale-like string to the canonical locale value used by the runtime.
+ *
+ * @param {unknown} value
+ * @returns {Locale | undefined}
+ */
+export function toLocale(value: unknown): Locale | undefined;
+/**
+ * Check if something is an available locale with the canonical project casing.
  *
  * @example
  *   if (isLocale(params.locale)) {
@@ -19,32 +57,61 @@ export function overwriteServerAsyncLocalStorage(value: ParaglideAsyncLocalStora
  *     setLocale('en');
  *   }
  *
- * @param {any} locale
+ * Use `toLocale()` when you want case-insensitive matching and canonicalization.
+ *
+ * @param {unknown} locale
  * @returns {locale is Locale}
  */
-export function isLocale(locale: any): locale is Locale;
+export function isLocale(locale: unknown): locale is Locale;
 /**
- * Asserts that the input is a locale.
+ * Asserts that the input can be normalized to a locale.
  *
- * @param {any} input - The input to check.
- * @returns {Locale} The input if it is a locale.
+ * @param {unknown} input - The input to check.
+ * @returns {Locale} The input normalized to a Locale.
  * @throws {Error} If the input is not a locale.
  */
-export function assertIsLocale(input: any): Locale;
+export function assertIsLocale(input: unknown): Locale;
 /**
  * Extracts a cookie from the document.
  *
  * Will return undefined if the document is not available or if the cookie is not set.
  * The `document` object is not available in server-side rendering, so this function should not be called in that context.
  *
- * @returns {string | undefined}
+ * @returns {Locale | undefined}
+ */
+export function extractLocaleFromCookie(): Locale | undefined;
+/**
+ * Extracts a locale from the accept-language header.
+ *
+ * Use the function on the server to extract the locale
+ * from the accept-language header that is sent by the client.
+ *
+ * @example
+ *   const locale = extractLocaleFromHeader(request);
+ *
+ * @param {Request} request - The request object to extract the locale from.
+ * @returns {Locale | undefined} The negotiated preferred language.
+ */
+export function extractLocaleFromHeader(request: Request): Locale | undefined;
+/**
+ * Negotiates a preferred language from navigator.languages.
+ *
+ * Use the function on the client to extract the locale
+ * from the navigator.languages array.
+ *
+ * @example
+ *   const locale = extractLocaleFromNavigator();
+ *
+ * @returns {Locale | undefined}
  */
-export function extractLocaleFromCookie(): string | undefined;
-export function extractLocaleFromHeader(request: Request): Locale;
 export function extractLocaleFromNavigator(): Locale | undefined;
 /**
  * Extracts the locale from a given URL using native URLPattern.
  *
+ * The built-in default `/:locale/...` routing is case-insensitive because it
+ * canonicalizes the first path segment with `toLocale()`. Custom `urlPatterns`
+ * keep URLPattern's normal exact matching semantics for path segments.
+ *
  * @param {URL|string} url - The full URL from which to extract the locale.
  * @returns {Locale|undefined} The extracted locale, or undefined if no locale is found.
  */
@@ -59,6 +126,8 @@ export function extractLocaleFromUrl(url: URL | string): Locale | undefined;
  * For client-side UI components, use `localizeHref()` instead, which provides
  * a more convenient API with relative paths and automatic locale detection.
  *
+ * @see https://paraglidejs.com/i18n-routing
+ *
  * @example
  * ```typescript
  * // Server middleware example
@@ -87,12 +156,12 @@ export function extractLocaleFromUrl(url: URL | string): Locale | undefined;
  * ```
  *
  * @param {string | URL} url - The URL to localize. If string, must be absolute.
- * @param {Object} [options] - Options for localization
- * @param {string} [options.locale] - Target locale. If not provided, uses getLocale()
+ * @param {object} [options] - Options for localization
+ * @param {Locale} [options.locale] - Target locale. If not provided, uses getLocale()
  * @returns {URL} The localized URL, always absolute
  */
 export function localizeUrl(url: string | URL, options?: {
-    locale?: string | undefined;
+    locale?: "en" | "fr" | "tl" | undefined;
 }): URL;
 /**
  * Low-level URL de-localization function, primarily used in server contexts.
@@ -104,6 +173,8 @@ export function localizeUrl(url: string | URL, options?: {
  * For client-side UI components, use `deLocalizeHref()` instead, which provides
  * a more convenient API with relative paths.
  *
+ * @see https://paraglidejs.com/i18n-routing
+ *
  * @example
  * ```typescript
  * // Server middleware example
@@ -132,23 +203,61 @@ export function localizeUrl(url: string | URL, options?: {
  * @returns {URL} The de-localized URL, always absolute
  */
 export function deLocalizeUrl(url: string | URL): URL;
+/**
+ * Aggregates named groups from various parts of the URLPattern match result.
+ *
+ *
+ * @param {any} match - The URLPattern match result object.
+ * @returns {Record<string, string | null | undefined>} An object containing all named groups from the match.
+ */
 export function aggregateGroups(match: any): Record<string, string | null | undefined>;
+/**
+ * Match route policy against both the public URL and its canonical URL.
+ *
+ * The function is deliberately separate from variables.js: configuration is
+ * inert data, while canonicalization and route selection form a routing layer.
+ *
+ * @param {string | URL} url
+ * @returns {{ match: string; strategy?: typeof strategy; exclude?: boolean } | undefined}
+ */
+export function findMatchingRouteStrategy(url: string | URL): {
+    match: string;
+    strategy?: typeof strategy;
+    exclude?: boolean;
+} | undefined;
+/**
+ * Returns the strategy to use for a specific URL.
+ *
+ * If no route strategy matches (or the matching rule is `exclude: true`),
+ * the global strategy is returned.
+ *
+ * @param {string | URL} url
+ * @returns {typeof strategy}
+ */
+export function getStrategyForUrl(url: string | URL): typeof strategy;
+/**
+ * Returns whether the given URL is excluded from middleware i18n processing.
+ *
+ * @param {string | URL} url
+ * @returns {boolean}
+ */
+export function isExcludedByRouteStrategy(url: string | URL): boolean;
 /**
  * @typedef {object} ShouldRedirectServerInput
  * @property {Request} request
- * @property {string | URL} [url]
- * @property {ReturnType<typeof assertIsLocale>} [locale]
+ * @property {string | URL} [effectiveRequestUrl] - Effective request URL to use for route matching, locale detection with the URL strategy, and redirect targets.
+ * @property {Locale} [locale]
  *
  * @typedef {object} ShouldRedirectClientInput
  * @property {undefined} [request]
  * @property {string | URL} [url]
- * @property {ReturnType<typeof assertIsLocale>} [locale]
+ * @property {Locale} [locale]
  *
  * @typedef {ShouldRedirectServerInput | ShouldRedirectClientInput} ShouldRedirectInput
  *
  * @typedef {object} ShouldRedirectResult
  * @property {boolean} shouldRedirect - Indicates whether the consumer should perform a redirect.
- * @property {ReturnType<typeof assertIsLocale>} locale - Locale resolved using the configured strategies.
+ * @property {Locale} locale - Locale resolved using the configured strategies.
  * @property {URL | undefined} redirectUrl - Destination URL when a redirect is required.
  */
 /**
@@ -160,6 +269,8 @@ export function aggregateGroups(match: any): Record<string, string | null | unde
  *
  * When called in the browser without arguments, the current `window.location.href` is used.
  *
+ * @see https://paraglidejs.com/i18n-routing#redirects
+ *
  * @example
  * // Client side usage (e.g. TanStack Router beforeLoad hook)
  * async function beforeLoad({ location }) {
@@ -182,6 +293,23 @@ export function aggregateGroups(match: any): Record<string, string | null | unde
  *   return render(request, decision.locale);
  * }
  *
+ * @example
+ * // Server side usage behind a proxy where request.url is not public-facing
+ * export async function handle(request) {
+ *   const effectiveRequestUrl = new URL(request.url);
+ *   effectiveRequestUrl.protocol = "https:";
+ *   effectiveRequestUrl.host = "example.com";
+ *
+ *   const decision = await shouldRedirect({
+ *     request,
+ *     effectiveRequestUrl,
+ *   });
+ *
+ *   if (decision.shouldRedirect) {
+ *     return Response.redirect(decision.redirectUrl, 307);
+ *   }
+ * }
+ *
  * @param {ShouldRedirectInput} [input]
  * @returns {Promise<ShouldRedirectResult>}
  */
@@ -197,6 +325,8 @@ export function shouldRedirect(input?: ShouldRedirectInput): Promise<ShouldRedir
  * - Automatically detects current locale if not specified
  * - Handles string input/output instead of URL objects
  *
+ * @see https://paraglidejs.com/i18n-routing
+ *
  * @example
  * ```typescript
  * // In a React/Vue/Svelte component
@@ -220,12 +350,12 @@ export function shouldRedirect(input?: ShouldRedirectInput): Promise<ShouldRedir
  * which provides more precise control over URL handling.
  *
  * @param {string} href - The href to localize (can be relative or absolute)
- * @param {Object} [options] - Options for localization
- * @param {string} [options.locale] - Target locale. If not provided, uses `getLocale()`
+ * @param {object} [options] - Options for localization
+ * @param {Locale} [options.locale] - Target locale. If not provided, uses `getLocale()`
  * @returns {string} The localized href, relative if input was relative
  */
 export function localizeHref(href: string, options?: {
-    locale?: string | undefined;
+    locale?: "en" | "fr" | "tl" | undefined;
 }): string;
 /**
  * High-level URL de-localization function optimized for client-side UI usage.
@@ -237,6 +367,8 @@ export function localizeHref(href: string, options?: {
  * - Returns relative paths when possible
  * - Handles string input/output instead of URL objects
  *
+ * @see https://paraglidejs.com/i18n-routing
+ *
  * @example
  * ```typescript
  * // In a React/Vue/Svelte component
@@ -264,7 +396,6 @@ export function localizeHref(href: string, options?: {
  *
  * @param {string} href - The href to de-localize (can be relative or absolute)
  * @returns {string} The de-localized href, relative if input was relative
- * @see deLocalizeUrl - For low-level URL de-localization in server contexts
  */
 export function deLocalizeHref(href: string): string;
 /**
@@ -273,54 +404,79 @@ export function deLocalizeHref(href: string): string;
  */
 export function trackMessageCall(safeModuleId: string, locale: Locale): void;
 /**
- * Generates a list of localized URLs for all provided URLs.
+ * Generates localized URL variants for all provided URLs based on your configured locales and URL patterns.
  *
- * This is useful for SSG (Static Site Generation) and sitemap generation.
- * NextJS and other frameworks use this function for SSG.
+ * This function is essential for Static Site Generation (SSG) where you need to tell your framework
+ * which pages to pre-render at build time. It's also useful for generating sitemaps and
+ * `<link rel="alternate" hreflang>` tags for SEO.
+ *
+ * The function respects your `urlPatterns` configuration - if you have translated pathnames
+ * (e.g., `/about` → `/ueber-uns` for German), it will generate the correct localized paths.
+ *
+ * @see https://paraglidejs.com/static-site-generation
  *
  * @example
- * ```typescript
- * const urls = generateStaticLocalizedUrls([
- *   "https://example.com/about",
- *   "https://example.com/blog",
+ * // Basic usage - generate all locale variants for a list of paths
+ * const localizedUrls = generateStaticLocalizedUrls([
+ *   "/",
+ *   "/about",
+ *   "/blog/post-1",
  * ]);
- * urls[0].href // => "https://example.com/about"
- * urls[1].href // => "https://example.com/blog"
- * urls[2].href // => "https://example.com/de/about"
- * urls[3].href // => "https://example.com/de/blog"
- * ...
- * ```
+ * // Returns URL objects for each locale:
+ * // ["/en/", "/de/", "/en/about", "/de/about", "/en/blog/post-1", "/de/blog/post-1"]
  *
- * @param {(string | URL)[]} urls - List of URLs to generate localized versions for. Can be absolute URLs or paths.
- * @returns {URL[]} List of localized URLs as URL objects
+ * @example
+ * // Use with framework SSG APIs
+ * // SvelteKit
+ * export function entries() {
+ *   const paths = ["/", "/about", "/contact"];
+ *   return generateStaticLocalizedUrls(paths).map(url => ({
+ *     locale: extractLocaleFromUrl(url)
+ *   }));
+ * }
+ *
+ * @example
+ * // Sitemap generation
+ * const allPages = ["/", "/about", "/blog"];
+ * const sitemapUrls = generateStaticLocalizedUrls(allPages);
+ *
+ * @param {(string | URL)[]} urls - List of canonical URLs or paths to generate localized versions for.
+ *   Can be absolute URLs (`https://example.com/about`) or paths (`/about`).
+ *   Paths are resolved against `http://localhost` internally.
+ * @returns {URL[]} Array of URL objects representing all localized variants.
+ *   The order follows each input URL with all its locale variants before moving to the next URL.
  */
 export function generateStaticLocalizedUrls(urls: (string | URL)[]): URL[];
 /**
  * Checks if the given strategy is a custom strategy.
  *
- * @param {any} strategy The name of the custom strategy to validate.
+ * @param {unknown} strategy The name of the custom strategy to validate.
  * Must be a string that starts with "custom-" followed by alphanumeric characters, hyphens, or underscores.
  * @returns {boolean} Returns true if it is a custom strategy, false otherwise.
  */
-export function isCustomStrategy(strategy: any): boolean;
+export function isCustomStrategy(strategy: unknown): boolean;
 /**
  * Defines a custom strategy that is executed on the server.
  *
- * @param {any} strategy The name of the custom strategy to define. Must follow the pattern custom-name with alphanumeric characters, hyphens, or underscores.
+ * @see https://paraglidejs.com/strategy#write-your-own-strategy
+ *
+ * @param {string} strategy The name of the custom strategy to define. Must follow the pattern custom-name with alphanumeric characters, hyphens, or underscores.
  * @param {CustomServerStrategyHandler} handler The handler for the custom strategy, which should implement
  * the method getLocale.
  * @returns {void}
  */
-export function defineCustomServerStrategy(strategy: any, handler: CustomServerStrategyHandler): void;
+export function defineCustomServerStrategy(strategy: string, handler: CustomServerStrategyHandler): void;
 /**
  * Defines a custom strategy that is executed on the client.
  *
- * @param {any} strategy The name of the custom strategy to define. Must follow the pattern custom-name with alphanumeric characters, hyphens, or underscores.
+ * @see https://paraglidejs.com/strategy#write-your-own-strategy
+ *
+ * @param {string} strategy The name of the custom strategy to define. Must follow the pattern custom-name with alphanumeric characters, hyphens, or underscores.
  * @param {CustomClientStrategyHandler} handler The handler for the custom strategy, which should implement the
  * methods getLocale and setLocale.
  * @returns {void}
  */
-export function defineCustomClientStrategy(strategy: any, handler: CustomClientStrategyHandler): void;
+export function defineCustomClientStrategy(strategy: string, handler: CustomClientStrategyHandler): void;
 /**
  * The project's base locale.
  *
@@ -351,10 +507,26 @@ export const localStorageKey: string;
  * @type {Array<"cookie" | "baseLocale" | "globalVariable" | "url" | "preferredLanguage" | "localStorage" | `custom-${string}`>}
  */
 export const strategy: Array<"cookie" | "baseLocale" | "globalVariable" | "url" | "preferredLanguage" | "localStorage" | `custom-${string}`>;
+/**
+ * Route-level strategy overrides.
+ *
+ * `match` uses URLPattern syntax.
+ *
+ * @type {Array<{
+ *   match: string;
+ *   strategy?: Array<"cookie" | "baseLocale" | "globalVariable" | "url" | "preferredLanguage" | "localStorage" | `custom-${string}`>;
+ *   exclude?: boolean;
+ * }>}
+ */
+export const routeStrategies: Array<{
+    match: string;
+    strategy?: Array<"cookie" | "baseLocale" | "globalVariable" | "url" | "preferredLanguage" | "localStorage" | `custom-${string}`>;
+    exclude?: boolean;
+}>;
 /**
  * The used URL patterns.
  *
- * @type {Array<{ pattern: string, localized: Array<[Locale, string]> }> }
+ * @type {Array<{ pattern: string, localized: Array<[Locale, string]> }>}
  */
 export const urlPatterns: Array<{
     pattern: string;
@@ -383,48 +555,28 @@ export let serverAsyncLocalStorage: ParaglideAsyncLocalStorage | undefined;
 export const disableAsyncLocalStorage: false;
 export const experimentalMiddlewareLocaleSplitting: false;
 export const isServer: boolean;
-/**
- * Get the current locale.
- *
- * @example
- *   if (getLocale() === 'de') {
- *     console.log('Germany 🇩🇪');
- *   } else if (getLocale() === 'nl') {
- *     console.log('Netherlands 🇳🇱');
- *   }
- *
- * @type {() => Locale}
- */
-export let getLocale: () => Locale;
-/**
- * Overwrite the \`getLocale()\` function.
- *
- * Use this function to overwrite how the locale is resolved. For example,
- * you can resolve the locale from the browser's preferred language,
- * a cookie, env variable, or a user's preference.
- *
- * @example
- *   overwriteGetLocale(() => {
- *     // resolve the locale from a cookie. fallback to the base locale.
- *     return Cookies.get('locale') ?? baseLocale
- *   }
- *
- * @type {(fn: () => Locale) => void}
- */
-export const overwriteGetLocale: (fn: () => Locale) => void;
+/** @type {Locale | undefined} */
+export const experimentalStaticLocale: Locale | undefined;
+export function getLocale(): Locale;
+export function overwriteGetLocale(fn: () => Locale): void;
 /**
  * @typedef {(newLocale: Locale, options?: { reload?: boolean }) => void | Promise<void>} SetLocaleFn
  */
 /**
  * Set the locale.
  *
- * Set locale reloads the site by default on the client. Reloading
- * can be disabled by passing \`reload: false\` as an option. If
- * reloading is disabled, you need to ensure that the UI is updated
- * to reflect the new locale.
+ * Updates the locale using your configured strategies (cookie, localStorage, URL, etc.).
+ * By default, this navigates the client to the localized URL or reloads the current
+ * document to reflect the new locale. `reload: false` is a narrow browser-only escape
+ * hatch for a fully client-rendered, non-URL-routed surface that owns its reactive
+ * updates and document state. It does not re-render the UI or update the document.
+ * Do not use it for normal locale pickers, URL-routed pages, or switching an SSR,
+ * SSG, or hydrated document. It is incompatible with per-locale builds.
  *
- * If any custom strategy's \`setLocale\` function is async, then this
- * function will become async as well.
+ * If any custom strategy's `setLocale` function is async, then this function
+ * will become async as well.
+ *
+ * @see https://paraglidejs.com/strategy
  *
  * @example
  *   setLocale('en');
@@ -439,71 +591,19 @@ export function overwriteSetLocale(fn: SetLocaleFn): void;
 /**
  * The origin of the current URL.
  *
- * Defaults to "http://y.com" in non-browser environments. If this
+ * Defaults to "http://example.com" in non-browser environments. If this
  * behavior is not desired, the implementation can be overwritten
  * by `overwriteGetUrlOrigin()`.
  *
  * @type {() => string}
  */
 export let getUrlOrigin: () => string;
-/**
- * Overwrite the getUrlOrigin function.
- *
- * Use this function in server environments to
- * define how the URL origin is resolved.
- *
- * @type {(fn: () => string) => void}
- */
-export let overwriteGetUrlOrigin: (fn: () => string) => void;
-/**
- * Extracts a locale from a request.
- *
- * Use the function on the server to extract the locale
- * from a request.
- *
- * The function goes through the strategies in the order
- * they are defined. If a strategy returns an invalid locale,
- * it will fall back to the next strategy.
- *
- * Note: Custom server strategies are not supported in this synchronous version.
- * Use `extractLocaleFromRequestAsync` if you need custom server strategies with async getLocale methods.
- *
- * @example
- *   const locale = extractLocaleFromRequest(request);
- *
- * @type {(request: Request) => Locale}
- */
-export const extractLocaleFromRequest: (request: Request) => Locale;
-/**
- * Asynchronously extracts a locale from a request.
- *
- * This function supports async custom server strategies, unlike the synchronous
- * `extractLocaleFromRequest`. Use this function when you have custom server strategies
- * that need to perform asynchronous operations (like database calls) in their getLocale method.
- *
- * The function first processes any custom server strategies asynchronously, then falls back
- * to the synchronous `extractLocaleFromRequest` for all other strategies.
- *
- * @see {@link https://github.com/opral/inlang-paraglide-js/issues/527#issuecomment-2978151022}
- *
- * @example
- *   // Basic usage
- *   const locale = await extractLocaleFromRequestAsync(request);
- *
- * @example
- *   // With custom async server strategy
- *   defineCustomServerStrategy("custom-database", {
- *     getLocale: async (request) => {
- *       const userId = extractUserIdFromRequest(request);
- *       return await getUserLocaleFromDatabase(userId);
- *     }
- *   });
- *
- *   const locale = await extractLocaleFromRequestAsync(request);
- *
- * @type {(request: Request) => Promise<Locale>}
- */
-export const extractLocaleFromRequestAsync: (request: Request) => Promise<Locale>;
+export function overwriteGetUrlOrigin(fn: () => string): void;
+export function extractLocaleFromRequest(request: Request, options?: ExtractLocaleFromRequestOptions): Locale;
+export function extractLocaleFromRequestWithStrategies(request: Request, strategies: typeof strategy, url?: string | URL): Locale;
+export function extractLocaleFromRequestAsync(request: Request, options?: {
+    effectiveRequestUrl?: string | URL;
+}): Promise<Locale>;
 /**
  * @typedef {"cookie" | "baseLocale" | "globalVariable" | "url" | "preferredLanguage" | "localStorage"} BuiltInStrategy
  */
@@ -528,7 +628,10 @@ export const customServerStrategies: Map<string, CustomServerStrategyHandler>;
 export const customClientStrategies: Map<string, CustomClientStrategyHandler>;
 export type ShouldRedirectServerInput = {
     request: Request;
-    url?: string | URL | undefined;
+    /**
+     * - Effective request URL to use for route matching, locale detection with the URL strategy, and redirect targets.
+     */
+    effectiveRequestUrl?: string | URL | undefined;
     locale?: "en" | "fr" | "tl" | undefined;
 };
 export type ShouldRedirectClientInput = {
@@ -545,7 +648,7 @@ export type ShouldRedirectResult = {
     /**
      * - Locale resolved using the configured strategies.
      */
-    locale: ReturnType<typeof assertIsLocale>;
+    locale: Locale;
     /**
      * - Destination URL when a redirect is required.
      */
@@ -566,6 +669,12 @@ export type ParaglideAsyncLocalStorage = {
 export type SetLocaleFn = (newLocale: Locale, options?: {
     reload?: boolean;
 }) => void | Promise<void>;
+export type ExtractLocaleFromRequestOptions = {
+    /**
+     * - Effective request URL to use for route matching and locale detection with the URL strategy.
+     */
+    effectiveRequestUrl?: string | URL | undefined;
+};
 export type BuiltInStrategy = "cookie" | "baseLocale" | "globalVariable" | "url" | "preferredLanguage" | "localStorage";
 export type CustomStrategy = `custom_${string}`;
 export type Strategy = BuiltInStrategy | CustomStrategy;
@@ -581,4 +690,96 @@ export type CustomClientStrategyHandler = {
  * A locale that is available in the project.
  */
 export type Locale = (typeof locales)[number];
+/**
+ * A branded type representing a localized string.
+ *
+ * Message functions return this type instead of \`string\`, enabling TypeScript
+ * to distinguish translated strings from regular strings at compile time.
+ * This allows you to enforce that only properly localized content is used
+ * in your UI components.
+ *
+ * Since \`LocalizedString\` is a branded subtype of \`string\`, it remains fully
+ * backward compatible—you can pass it anywhere a \`string\` is expected.
+ */
+export type LocalizedString = string & {
+    readonly __brand: "LocalizedString";
+};
+/**
+ * A single markup option passed to a tag instance.
+ */
+export type MessageMarkupOption = {
+    name: string;
+    value: unknown;
+};
+/**
+ * A single static markup attribute attached to a tag instance.
+ */
+export type MessageMarkupAttribute = {
+    name: string;
+    value: string | true;
+};
+/**
+ * Record of markup options for a tag instance.
+ */
+export type MessageMarkupOptions = Record<string, unknown>;
+/**
+ * Record of markup attributes for a tag instance.
+ */
+export type MessageMarkupAttributes = Record<string, string | true>;
+/**
+ * Type-level schema for a single markup tag.
+ */
+export type MessageMarkupTag = {
+    options: MessageMarkupOptions;
+    attributes: MessageMarkupAttributes;
+    children: boolean;
+};
+/**
+ * Type-level schema for all markup tags in a message.
+ */
+export type MessageMarkupSchema = Record<string, MessageMarkupTag>;
+/**
+ * Type-only metadata attached to compiled message functions.
+ */
+export type MessageMetadata<Inputs, Options, Markup extends MessageMarkupSchema = MessageMarkupSchema> = {
+    readonly __paraglide?: {
+        inputs: Inputs;
+        options: Options;
+        markup: Markup;
+    };
+};
+/**
+ * A compiled, framework-neutral message part.
+ */
+export type MessagePart = {
+    type: "text";
+    value: string;
+} | {
+    type: "markup-start";
+    name: string;
+    options: MessageMarkupOptions;
+    attributes: MessageMarkupAttributes;
+} | {
+    type: "markup-end";
+    name: string;
+    options: MessageMarkupOptions;
+    attributes: MessageMarkupAttributes;
+} | {
+    type: "markup-standalone";
+    name: string;
+    options: MessageMarkupOptions;
+    attributes: MessageMarkupAttributes;
+};
+/**
+ * A message function is a message for a specific locale.
+ */
+export type MessageFunction = (inputs?: Record<string, never>) => LocalizedString;
+/**
+ * A message bundle function that selects the message to be returned.
+ *
+ * Uses `getLocale()` under the hood to determine the locale with an option.
+ */
+export type MessageBundleFunction<T extends string> = (params: Record<string, never>, options: {
+    locale: T;
+}) => LocalizedString;
 //# sourceMappingURL=runtime.d.ts.map