@generaltranslation/react-core 1.8.16 → 1.8.18

package/dist/index.d.ts

@@ -1,36 +1,1385 @@
-import T from './translation/T';
-import useGT from './translation/hooks/useGT';
-import useTranslations from './translation/hooks/useTranslations';
-import useDefaultLocale from './hooks/useDefaultLocale';
-import useLocale from './hooks/useLocale';
-import useVersionId from './hooks/useVersionId';
-import useRegion from './hooks/useRegion';
-import GTProvider from './provider/GTProvider';
-import Var from './variables/Var';
-import Num from './variables/Num';
-import Currency from './variables/Currency';
-import DateTime from './variables/DateTime';
-import RelativeTime from './variables/RelativeTime';
-import { Static, Derive } from './variables/Derive';
-import Plural from './branches/plurals/Plural';
-import Branch from './branches/Branch';
-import useLocales from './hooks/useLocales';
-import useSetLocale from './hooks/useSetLocale';
-import LocaleSelector from './ui/LocaleSelector';
-import useLocaleSelector from './hooks/useLocaleSelector';
-import RegionSelector from './ui/RegionSelector';
-import type { DictionaryTranslationOptions, InlineTranslationOptions, RuntimeTranslationOptions } from './types-dir/types';
-import { useGTClass, useLocaleProperties } from './hooks/useGTClass';
-import { useRegionSelector } from './hooks/useRegionSelector';
-import { useLocaleDirection } from './hooks/useLocaleDirection';
-import { msg, decodeMsg, decodeOptions } from './messages/messages';
-import useMessages from './translation/hooks/useMessages';
-import { GTContext } from './provider/GTContext';
-import useRuntimeTranslation from './provider/hooks/useRuntimeTranslation';
-import useCreateInternalUseGTFunction from './provider/hooks/translation/useCreateInternalUseGTFunction';
-import useCreateInternalUseTranslationsFunction from './provider/hooks/translation/useCreateInternalUseTranslationsFunction';
-import { useCreateInternalUseTranslationsObjFunction } from './provider/hooks/translation/useCreateInternalUseTranslationsObjFunction';
-export * from 'gt-i18n/fallbacks';
-export { declareStatic, derive, declareVar, decodeVars } from 'gt-i18n';
-export { Var, Num, Currency, DateTime, RelativeTime, Static, Derive, T, GTProvider, Plural, Branch, useGT, useTranslations, useDefaultLocale, useLocale, useLocales, useSetLocale, useLocaleSelector, useRegion, useRegionSelector, useGTClass, useLocaleProperties, useLocaleDirection, useVersionId, LocaleSelector, RegionSelector, DictionaryTranslationOptions, InlineTranslationOptions, RuntimeTranslationOptions, msg, decodeMsg, decodeOptions, useMessages, GTContext, useRuntimeTranslation, useCreateInternalUseGTFunction, useCreateInternalUseTranslationsFunction, useCreateInternalUseTranslationsObjFunction, };
+import * as _$react from "react";
+import React$1, { ReactNode } from "react";
+import * as _$react_jsx_runtime0 from "react/jsx-runtime";
+import * as _$generaltranslation from "generaltranslation";
+import { GT } from "generaltranslation";
+
+//#region src/translation/T.d.ts
+/**
+ * Build-time translation component that renders its children in the user's given locale.
+ *
+ * @example
+ * ```jsx
+ * // Basic usage:
+ * <T id="welcome_message">
+ *  Hello, <Var>{name}</Var>!
+ * </T>
+ * ```
+ *
+ * @example
+ * ```jsx
+ * // Translating a plural
+ * <T id="item_count">
+ *  <Plural n={3} singular={<>You have <Num children={n}/> item.</>}>
+ *      You have <Num children={n}/> items.
+ *  </Plural>
+ * </T>
+ * ```
+ *
+ * @param {React.ReactNode} children - The content to be translated or displayed.
+ * @param {string} [id] - Optional identifier for the translation string. If not provided, a hash will be generated from the content.
+ * @param {any} [context] - Additional context for translation key generation.
+ *
+ * @returns {JSX.Element} The rendered translation or fallback content based on the provided configuration.
+ *
+ * @throws {Error} If a plural translation is requested but the `n` option is not provided.
+ */
+declare function T({
+  children,
+  id,
+  context,
+  _hash,
+  ...options
+}: {
+  children: React$1.ReactNode;
+  id?: string;
+  context?: string;
+  _hash?: string;
+  $id?: string;
+  $context?: string;
+  $maxChars?: number;
+  [key: string]: unknown;
+}): React$1.JSX.Element | undefined;
+declare namespace T {
+  var _gtt: string;
+}
+//#endregion
+//#region ../format/dist/types-UnF22q9r.d.cts
+//#region src/locales/customLocaleMapping.d.ts
+type CustomMapping = Record<string, string | Partial<LocaleProperties>>; //#endregion
+//#region src/locales/getLocaleProperties.d.ts
+type LocaleProperties = {
+  code: string;
+  name: string;
+  nativeName: string;
+  languageCode: string;
+  languageName: string;
+  nativeLanguageName: string;
+  nameWithRegionCode: string;
+  nativeNameWithRegionCode: string;
+  regionCode: string;
+  regionName: string;
+  nativeRegionName: string;
+  scriptCode: string;
+  scriptName: string;
+  nativeScriptName: string;
+  maximizedCode: string;
+  maximizedName: string;
+  nativeMaximizedName: string;
+  minimizedCode: string;
+  minimizedName: string;
+  nativeMinimizedName: string;
+  emoji: string;
+}; //#endregion
+//#region src/locales/getRegionProperties.d.ts
+//#endregion
+//#region src/types-dir/jsx/variables.d.ts
+type VariableType = 'v' | 'n' | 'd' | 'c' | 'rt';
+/**
+ * Variables are used to store the variable name and type.
+ */
+type Variable = {
+  k: string;
+  i?: number;
+  v?: VariableType;
+}; //#endregion
+//#region src/types-dir/jsx/content.d.ts
+/**
+ * Map of data-_gt properties to their corresponding React props
+ */
+declare const HTML_CONTENT_PROPS: {
+  readonly pl: "placeholder";
+  readonly ti: "title";
+  readonly alt: "alt";
+  readonly arl: "aria-label";
+  readonly arb: "aria-labelledby";
+  readonly ard: "aria-describedby";
+};
+type HtmlContentPropKeysRecord = Partial<Record<keyof typeof HTML_CONTENT_PROPS, string>>;
+/**
+ * GTProp is an internal property used to contain data for translating and rendering elements.
+ * note, transformations are only read on the server side if they are 'plural' or 'branch'
+ */
+type GTProp = {
+  b?: Record<string, JsxChildren>;
+  t?: 'p' | 'b';
+} & HtmlContentPropKeysRecord;
+type JsxElement = {
+  t?: string;
+  i?: number;
+  d?: GTProp;
+  c?: JsxChildren;
+};
+type JsxChild = string | JsxElement | Variable;
+/**
+ * The format of the string content
+ */
+type StringFormat = 'ICU' | 'I18NEXT' | 'STRING';
+/**
+ * The format of the content.
+ */
+type DataFormat = 'JSX' | StringFormat;
+/**
+ * String format content.
+ */
+/**
+ * A content type representing JSX elements.
+ */
+type JsxChildren = JsxChild | JsxChild[];
+/**
+ * A content type representing ICU messages.
+ */
+//#endregion
+//#region ../i18n/dist/options-D0Lnxv2X.d.cts
+//#region src/translation-functions/types/options.d.ts
+type BaseTranslationOptions = Record<string, unknown>;
+type DictionaryTranslationOptions = BaseTranslationOptions;
+/**
+ * Options for string resolution
+ * Used by the gt() function
+ */
+type InlineTranslationOptions = BaseTranslationOptions & {
+  $context?: string;
+  $id?: string; /** The data format for the message (e.g., 'ICU', 'STRING'). Defaults to 'ICU'. */
+  $format?: StringFormat; /** The locale to use for formatting the message. */
+  $locale?: string;
+  /**
+   * @deprecated use {@link $locale} instead
+   */
+  $_locales?: string | string[];
+  $_hash?: string;
+  $maxChars?: number; /** @deprecated use {@link EncodedTranslationOptions} instead */
+  $_source?: string;
+};
+/**
+ * Options for string resolution
+ * Used by the m() function
+ */
+/**
+ * Options for runtime translation
+ * Used by the tx() function
+ */
+type RuntimeTranslationOptions = {
+  $locale?: string;
+  $format?: DataFormat;
+} & Omit<InlineTranslationOptions, '$id' | '$format'>;
+/**
+ * Options for JSX translation
+ * Used by the resolveJsxTranslation() function
+ */
+//#endregion
+//#region ../i18n/dist/functions-DI1QpQoC.d.cts
+/**
+ * Synchronous resolution function type
+ * @param {string} message - The message to translate.
+ * @param {InlineTranslationOptions} options - The options for the translation.
+ * @returns {string} The translated message.
+ *
+ * @important This is base type for user API
+ *
+ * TODO: next major version, this should be <T extends string | null | undefined>(message: T, options?: InlineTranslationOptions) => T extends string ? string : T;
+ */
+type SyncResolutionFunctionWithFallback = (message: string, options?: InlineTranslationOptions) => string;
+/**
+ * Type for the gt() function
+ * @param {string} message - The message to translate
+ * @param {InlineTranslationOptions} options - The options for the translation
+ * @returns {string} The translated message
+ * TODO: next major version, remove the "...type" suffix, it's redundant
+ */
+type GTFunctionType = SyncResolutionFunctionWithFallback;
+/**
+ * Type for the m() function
+ * @param {string | null | undefined} encodedMsg - The encoded message to decode and interpolate.
+ * @param {InlineTranslationOptions} options - The options to interpolate.
+ * @returns {string | null | undefined} The decoded and interpolated message.
+ * TODO: next major version, this should be <T extends string | null | undefined>(message: T, options?: InlineTranslationOptions) => T extends string ? string : T;
+ * TODO: next major version, remove the "...type" suffix, it's redundant
+ */
+type MFunctionType = <T extends string | null | undefined>(encodedMsg: T, options?: Record<string, any>) => T extends string ? string : T;
+/**
+ * Type for the t() function
+ * @param {string} id - The id of the translation to translate.
+ * @param {DictionaryTranslationOptions} options - The options for the translation.
+ * @returns {string} The translated message.
+ * TODO: next major version, remove the "...type" suffix, it's redundant
+ */
+//#endregion
+//#region ../i18n/dist/message-C62MTLwE.d.cts
+//#region src/translation-functions/types/message.d.ts
+/**
+ * Valid types for messages that can be registered.
+ * msg('Hello, World!')
+ * msg(['Hello, World!', 'Welcome, {user}!'])
+ */
+type RegisterableMessages = string | string[] | readonly string[]; //#endregion
+//#endregion
+//#region src/types-dir/types.d.ts
+/**
+ * For dictionaries, we have Entry and MetaEntry
+ */
+type Entry = string;
+type MetaEntry = {
+  $context?: string;
+  $maxChars?: number;
+  $_hash?: string;
+  [key: string]: unknown;
+};
+type DictionaryEntry = Entry | [Entry] | [Entry, MetaEntry];
+type Dictionary = {
+  [key: string]: Dictionary | DictionaryEntry;
+} | (Dictionary | DictionaryEntry)[];
+/**
+ * Translated content types
+ * TODO: move these types to JsxElement etc from generaltranslation/types
+ * remember to omit the t property (tag name) from the translated element
+ */
+type TranslatedElement = {
+  i?: number;
+  d?: GTProp;
+  c?: TranslatedChildren;
+};
+type TranslatedChild = TranslatedElement | string | Variable;
+type TranslatedChildren = TranslatedChild | TranslatedChild[];
+type Translations = {
+  [hash: string]: TranslatedChildren | null;
+};
+type CustomLoader = (locale: string) => Promise<unknown>;
+type RenderMethod = 'skeleton' | 'replace' | 'default';
+type _Message = {
+  message: string;
+  $id?: string;
+  $context?: string;
+  $maxChars?: number;
+  $_hash?: string;
+};
+type _Messages = _Message[];
+//#endregion
+//#region src/translation/hooks/useGT.d.ts
+/**
+ * Gets the translation function `gt` provided by `<GTProvider>`.
+ *
+ * @returns {Function} A translation function that accepts an ICU message format string and returns the translation of that string.
+ *
+ * @example
+ * const gt = useGT();
+ * console.log(gt('To be or not to be...'));
+ *
+ * @example
+ * const gt = useGT();
+ * gt('My name is {customName}', { customName: "Brian", id: 'my-name', context: 'a proper noun' } )
+ */
+declare function useGT(_messages?: _Messages): (string: string, options?: Record<string, unknown> & {
+  $id?: string;
+  $context?: string;
+  $maxChars?: number;
+  $_hash?: string;
+}) => string;
+//#endregion
+//#region src/translation/hooks/useTranslations.d.ts
+/**
+ * Gets the dictionary access function `t` provided by `<GTProvider>`.
+ *
+ * @param {string} [id] - Optional prefix to prepend to the translation keys.
+ * @returns {Function} A translation function that accepts a key string and returns the translated value.
+ *
+ * @example
+ * const t = useTranslations('user');
+ * console.log(t('name')); // Translates item 'user.name'
+ *
+ * const t = useTranslations();
+ * console.log(t('hello')); // Translates item 'hello'
+ */
+declare function useTranslations(id?: string): ((id: string, options?: Record<string, unknown>) => string) & {
+  obj: (id: string, options?: Record<string, unknown>) => unknown | undefined;
+};
+//#endregion
+//#region src/hooks/useDefaultLocale.d.ts
+/**
+ * Retrieves the application's default locale from the `<GTProvider>` context.
+ *
+ * If no default locale is passed to the `<GTProvider>`, it defaults to providing 'en'.
+ *
+ * @returns {string} The application's default locale, e.g., 'en-US'.
+ *
+ * @example
+ * const locale = useDefaultLocale();
+ * console.log(locale); // 'en-US'
+ */
+declare function useDefaultLocale(): string;
+//#endregion
+//#region src/hooks/useLocale.d.ts
+/**
+ * Retrieves the user's locale from the `<GTProvider>` context.
+ *
+ * @returns {string} The user's locale, e.g., 'en-US'.
+ *
+ * @example
+ * const locale = useLocale();
+ * console.log(locale); // 'en-US'
+ */
+declare function useLocale(): string;
+//#endregion
+//#region src/hooks/useVersionId.d.ts
+/**
+ * Retrieves the version ID from the `<GTProvider>` context.
+ *
+ * @returns {string | undefined} The version ID for the current source, if set.
+ *
+ * @example
+ * const versionId = useVersionId();
+ * console.log(versionId); // 'abc123'
+ */
+declare function useVersionId(): string | undefined;
+//#endregion
+//#region src/hooks/useRegion.d.ts
+/**
+ * A React hook that retrieves the user's currently selected region from the `<GTProvider>` context.
+ *
+ * Returns the `region` value as a string (e.g., `"US"`, `"CA"`) or `undefined` if no region has been set.
+ *
+ * @returns {string | undefined} The currently active region code, or `undefined` if not set.
+ *
+ * @example
+ * ```tsx
+ * const region = useRegion();
+ *
+ * if (!region) {
+ *   console.log("No region set yet");
+ * } else {
+ *   console.log(`Current region: ${region}`);
+ * }
+ * ```
+ */
+declare function useRegion(): string | undefined;
+//#endregion
+//#region src/utils/types.d.ts
+type AuthFromEnvParams = {
+  projectId?: string;
+  devApiKey?: string;
+};
+type AuthFromEnvReturn = {
+  projectId: string;
+  devApiKey?: string;
+};
+//#endregion
+//#region src/provider/hooks/locales/types.d.ts
+type UseDetermineLocaleParams = {
+  defaultLocale: string;
+  locales: string[];
+  enableI18n: boolean;
+  locale?: string;
+  localeCookieName?: string;
+  ssr?: boolean;
+  customMapping?: CustomMapping;
+  reloadOnLocaleUpdate?: boolean;
+};
+type UseDetermineLocaleReturn = [string, (locale: string) => void];
+//#endregion
+//#region src/provider/hooks/types.d.ts
+type UseRegionStateParams = {
+  _region: string | undefined;
+  ssr: boolean;
+  regionCookieName: string;
+};
+type UseRegionStateReturn = {
+  region: string | undefined;
+  setRegion: (region: string | undefined) => void;
+};
+type UseEnableI18nParams = {
+  enableI18n: boolean;
+  enableI18nCookieName: string;
+  enableI18nLoaded?: boolean;
+  ssr: boolean;
+};
+type UseEnableI18nReturn = {
+  enableI18n: boolean;
+};
+//#endregion
+//#region src/types-dir/config.d.ts
+type GTConfig = {
+  projectId?: string;
+  devApiKey?: string;
+  locales?: string[];
+  defaultLocale?: string;
+  dictionary?: string;
+  runtimeUrl?: string | null;
+  cacheUrl?: string | null;
+  renderSettings?: {
+    method: RenderMethod;
+    timeout?: number;
+  };
+  _versionId?: string;
+  ssr?: boolean;
+  localeCookieName?: string;
+  customMapping?: CustomMapping;
+  modelProvider?: string;
+  enableI18n?: boolean;
+};
+type InternalGTProviderProps = {
+  children?: React$1.ReactNode;
+  projectId?: string;
+  devApiKey?: string;
+  dictionary?: Dictionary;
+  locales?: string[];
+  defaultLocale?: string;
+  locale?: string;
+  region?: string;
+  cacheUrl?: string | null;
+  runtimeUrl?: string | null;
+  renderSettings?: {
+    method: RenderMethod;
+    timeout?: number;
+  };
+  _versionId?: string;
+  ssr?: boolean;
+  localeCookieName?: string;
+  translations?: Translations | null;
+  loadDictionary?: CustomLoader;
+  loadTranslations?: CustomLoader;
+  config?: GTConfig;
+  fallback?: React$1.ReactNode;
+  customMapping?: CustomMapping;
+  modelProvider?: string;
+  environment: 'development' | 'production' | 'test';
+  enableI18n?: boolean; /** Flag to indicate if the enableI18n flag is finished loading asynchronously */
+  enableI18nLoaded?: boolean;
+  readAuthFromEnv: (params: AuthFromEnvParams) => AuthFromEnvReturn;
+  useDetermineLocale: (params: UseDetermineLocaleParams) => UseDetermineLocaleReturn;
+  useRegionState: (params: UseRegionStateParams) => UseRegionStateReturn;
+  useEnableI18n?: (params: UseEnableI18nParams) => UseEnableI18nReturn;
+  reloadOnLocaleUpdate?: boolean;
+  [key: string]: unknown;
+};
+//#endregion
+//#region src/provider/GTProvider.d.ts
+declare function GTProvider({
+  children,
+  config,
+  environment,
+  projectId: _projectId,
+  devApiKey: _devApiKey,
+  _versionId,
+  dictionary: _dictionary,
+  locales,
+  defaultLocale,
+  cacheUrl,
+  runtimeUrl,
+  renderSettings,
+  ssr,
+  localeCookieName,
+  locale: _locale,
+  region: _region,
+  loadDictionary,
+  loadTranslations,
+  fallback,
+  translations: _translations,
+  customMapping,
+  enableI18n: _enableI18n,
+  enableI18nLoaded,
+  reloadOnLocaleUpdate,
+  useEnableI18n,
+  readAuthFromEnv,
+  useDetermineLocale,
+  useRegionState,
+  ...metadata
+}: InternalGTProviderProps): _$react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/variables/Var.d.ts
+/**
+ * The `<Var>` component renders a variable value, which can either be passed as `children` or a `value`.
+ * If `children` is provided, it will be used; otherwise, the `value` is rendered.
+ *
+ * @example Inline usage:
+ * ```jsx
+ *  function MyComponent() {
+ *     const name = 'Archie';
+ *     return (
+ *          <T>
+ *              <p>
+ *                  Hello, <Var> {name} </Var>!
+ *              </p>
+ *          </T>
+ *      );
+ *  }
+ * ```
+ *
+ *
+ * @param {any} [children] - The content to render inside the component. If provided, it will take precedence over `value`.
+ * @returns {JSX.Element} The rendered variable component with either `children` or `value`.
+ */
+declare function Var({
+  children
+}: {
+  children?: unknown;
+  name?: string;
+}): React$1.JSX.Element | null;
+declare namespace Var {
+  var _gtt: string;
+}
+//#endregion
+//#region src/variables/Num.d.ts
+/**
+ * The `<Num>` component renders a formatted number string, allowing customization of the name, default value, and formatting options.
+ * It formats the number according to the current locale and optionally passed formatting options.
+ * Must be used inside a `<GTProvider>`.
+ *
+ * @example
+ * ```jsx
+ * <Num
+ *    options={{ style: "decimal", maximumFractionDigits: 2 }}
+ * >
+ *    1000
+ * </Num>
+ * ```
+ *
+ * @param {number | string | null | undefined} children - Content to render inside the number component.
+ * @param {string[]} [locales] - Optional locales to use for number formatting. If wrapped in a `<GTProvider>`, the user's locale is used.
+ * @param {Intl.NumberFormatOptions} [options={}] - Optional formatting options for the number, following `Intl.NumberFormatOptions` specifications.
+ * @returns {React.JSX.Element} The formatted number component.
+ */
+declare function Num({
+  children,
+  locales,
+  options
+}: {
+  children: number | string | null | undefined;
+  name?: string;
+  locales?: string[];
+  options?: Intl.NumberFormatOptions;
+}): React$1.JSX.Element | null;
+declare namespace Num {
+  var _gtt: string;
+}
+//#endregion
+//#region src/variables/Currency.d.ts
+/**
+ * The `<Currency>` component renders a formatted currency string, allowing customization of name, default value, currency type, and formatting options.
+ * Must be used inside a `<GTProvider>`.
+ *
+ * @example
+ * ```jsx
+ * <Currency currency="USD">
+ *    1000
+ * </Currency>
+ * ```
+ *
+ * @param {number | string | null | undefined} children - Content to render inside the currency component.
+ * @param {string} [currency="USD"] - The currency type (e.g., USD, EUR, etc.).
+ * @param {string[]} [locales] - Optional locales to use for currency formatting. If wrapped in a `<GTProvider>`, the user's locale is used.
+ * @param {Intl.NumberFormatOptions} [options={}] - Optional formatting options to customize how the currency is displayed.
+ * @returns {JSX.Element} The formatted currency component.
+ */
+declare function Currency({
+  children,
+  currency,
+  locales,
+  options
+}: {
+  children: number | string | null | undefined;
+  currency?: string;
+  name?: string;
+  locales?: string[];
+  options?: Intl.NumberFormatOptions;
+}): React$1.JSX.Element | null;
+declare namespace Currency {
+  var _gtt: string;
+}
+//#endregion
+//#region src/variables/DateTime.d.ts
+/**
+ * The `<DateTime>` component renders a formatted date or time string, allowing customization of the name, default value, and formatting options.
+ * It utilizes the current locale and optional format settings to display the date.
+ * Must be used inside a `<GTProvider>`.
+ *
+ * @example
+ * ```jsx
+ * <DateTime>
+ *    {new Date()}
+ * </DateTime>
+ * ```
+ *
+ * @param {Date} children - Content to render inside the date component.
+ * @param {string[]} [locales] - Optional locales to use for date formatting. If wrapped in a `<GTProvider>`, the user's locale is used.
+ * @param {Intl.DateTimeFormatOptions} [options={}] - Optional formatting options for the date, following `Intl.DateTimeFormatOptions` specifications.
+ * @returns {JSX.Element} The formatted date or time component.
+ */
+declare function DateTime({
+  children,
+  locales,
+  options
+}: {
+  children: Date | null | undefined;
+  name?: string;
+  locales?: string[];
+  options?: Intl.DateTimeFormatOptions;
+}): React$1.JSX.Element | null;
+declare namespace DateTime {
+  var _gtt: string;
+}
+//#endregion
+//#region src/variables/RelativeTime.d.ts
+/**
+ * The `<RelativeTime>` component renders a localized relative time string
+ * (e.g., "2 hours ago", "in 3 days") using `Intl.RelativeTimeFormat`.
+ * Must be used inside a `<GTProvider>`.
+ *
+ * @example
+ * ```jsx
+ * // Auto-select unit from a Date
+ * <RelativeTime date={someDate} />
+ * // → "2 hours ago"
+ * ```
+ *
+ * @example
+ * ```jsx
+ * // Explicit value and unit
+ * <RelativeTime value={-1} unit="day" />
+ * // → "yesterday"
+ * ```
+ *
+ * @param {Date} [date] - A date to compute relative time from now. Mutually exclusive with `value`/`unit`.
+ * @param {number} [value] - Explicit numeric value for relative time. Requires `unit`.
+ * @param {Intl.RelativeTimeFormatUnit} [unit] - The unit of time (e.g., 'second', 'minute', 'hour', 'day', 'week', 'month', 'year'). Required when using `value`.
+ * @param {string} [name] - Optional name for the variable, used by the GT CLI for additional context during extraction.
+ * @param {string[]} [locales] - Optional locales for formatting. If wrapped in a `<GTProvider>`, the user's locale is used.
+ * @param {Intl.RelativeTimeFormatOptions} [options={}] - Optional formatting options following `Intl.RelativeTimeFormatOptions`.
+ * @returns {JSX.Element | null} The formatted relative time string.
+ */
+declare function RelativeTime({
+  date,
+  children,
+  value,
+  unit,
+  baseDate,
+  locales,
+  options
+}: {
+  date?: Date | null | undefined;
+  children?: Date | null | undefined; /** Used by the GT CLI for additional context during extraction. */
+  name?: string;
+  value?: number;
+  unit?: Intl.RelativeTimeFormatUnit; /** Base date for computing relative time. Defaults to `new Date()` at render time. Required for hydration safety. */
+  baseDate?: Date;
+  locales?: string[];
+  options?: Intl.RelativeTimeFormatOptions;
+}): React$1.JSX.Element | null;
+declare namespace RelativeTime {
+  var _gtt: string;
+}
+//#endregion
+//#region src/variables/Derive.d.ts
+/**
+ * Marks JSX children as derivable by the GT compiler and CLI.
+ *
+ * Use `<Derive>` inside translated JSX when child content is computed from
+ * source code, but should still be discovered during extraction instead of
+ * treated as a runtime interpolation variable. The CLI attempts to resolve the
+ * derivable children into every possible static value and includes those values
+ * in the source content that gets translated.
+ *
+ * `<Derive>` renders its children unchanged at runtime.
+ *
+ * Run `gt validate` after adding or changing `<Derive>` usage to verify that
+ * each derivable expression can be resolved by the CLI before translating or
+ * building.
+ *
+ * @example
+ * ```jsx
+ * function getSubject() {
+ *   return (Math.random() > 0.5) ? "Alice" : "Brian";
+ * }
+ * ...
+ * <T>
+ *   <Derive>
+ *      {getSubject()}
+ *   </Derive>
+ *   is going to school today.
+ * </T>
+ * ```
+ *
+ * @param {T extends React.ReactNode} children - JSX content to derive for translation extraction.
+ * @returns {T} The same children, unchanged at runtime.
+ */
+declare function Derive<T extends React$1.ReactNode>({
+  children
+}: {
+  children: T;
+}): T;
+declare namespace Derive {
+  var _gtt: string;
+}
+/**
+ * @deprecated Use `<Derive>` instead.
+ *
+ * Marks JSX children as derivable by the GT compiler and CLI.
+ *
+ * Use `<Derive>` instead of `<Static>` for new code. This alias is kept for
+ * backwards compatibility and renders its children unchanged at runtime.
+ *
+ * Run `gt validate` after adding or changing derived JSX content to verify that
+ * each derivable expression can be resolved by the CLI before translating or
+ * building.
+ *
+ * @example
+ * ```jsx
+ * function getSubject() {
+ *   return (Math.random() > 0.5) ? "Alice" : "Brian";
+ * }
+ * ...
+ * <T>
+ *   <Static>
+ *      {getSubject()}
+ *   </Static>
+ *   is going to school today.
+ * </T>
+ * ```
+ *
+ * @param {T extends React.ReactNode} children - JSX content to derive for translation extraction.
+ * @returns {T} The same children, unchanged at runtime.
+ */
+declare function Static<T extends React$1.ReactNode>(props: {
+  children: T;
+}): T;
+declare namespace Static {
+  var _gtt: string;
+}
+//#endregion
+//#region src/branches/plurals/Plural.d.ts
+/**
+ * The `<Plural>` component dynamically renders content based on the plural form of the given number (`n`).
+ * It determines which content to display by matching the value of `n` to the appropriate pluralization branch,
+ * based on the current locale or a default locale. If no matching plural branch is found, the component renders
+ * the fallback `children` content.
+ *
+ * @example
+ * ```jsx
+ * <Plural
+ *  n={1}
+ *  one="There is 1 item"
+ *  other="There are {n} items"
+ * />
+ * ```
+ * In this example, if `n` is 1, it renders `"There is 1 item"`. If `n` is a different number, it renders
+ * `"There are {n} items"`.
+ *
+ * @param {any} [children] - Fallback content to render if no matching plural branch is found.
+ * @param {number} [n] - The number used to determine the plural form. This is required for pluralization to work.
+ * @param {string} [locales] - Optional parameter, the locale to use for pluralization format. If not provided and wrapped
+ *  in <GTProvider> will automatically populate this value as user's current locale. If not provided and not wrapped in
+ *  <GTProvider>, will use the library default locale (en-US).
+ * @param {...{[key: string]: any}} [branches] - A spread object containing possible plural branches, typically including `one` for singular
+ * and `other` for plural forms, but it may vary depending on the locale.
+ * @returns {React.JSX.Element} The rendered content corresponding to the plural form of `n`, or the fallback content.
+ * @throws {Error} If `n` is not provided or not a valid number.
+ */
+declare function Plural({
+  children,
+  n,
+  locales,
+  ...branches
+}: {
+  children?: React.ReactNode;
+  n?: number;
+  locales?: string;
+  [key: string]: unknown;
+}): React.JSX.Element;
+declare namespace Plural {
+  var _gtt: string;
+}
+//#endregion
+//#region src/branches/Branch.d.ts
+/**
+ * The `<Branch>` component dynamically renders a specified branch of content or a fallback child component.
+ * It allows for flexible content switching based on the `branch` prop and an object of possible branches (`...branches`).
+ * If the specified `branch` is present in the `branches` object, it renders the content of that branch.
+ * If the `branch` is not found, it renders the provided `children` as fallback content.
+ *
+ * @example
+ * ```jsx
+ * <Branch
+ *  branch="summary"
+ * summary={<p>This is a summary</p>}
+ * details={<p>Details here</p>}
+ * >
+ *   <p>Fallback content</p>
+ * </Branch>
+ * ```
+ * If the `branch` prop is set to `"summary"`, it will render `<p>This is a summary</p>`. If the `branch` is not set or does not match any keys in the branches object, it renders the fallback content `<p>Fallback content</p>`.
+ *
+ * @param {any} [children] - Fallback content to render if no matching branch is found.
+ * @param {any} [name="branch"] - Optional name for the component, used for metadata or tracking purposes.
+ * @param {string} [branch] - The name of the branch to render. The component looks for this key in the `...branches` object.
+ * @param {...{[key: string]: any}} [branches] - A spread object containing possible branches as keys and their corresponding content as values.
+ * @returns {React.JSX.Element} The rendered branch or fallback content.
+ */
+declare function Branch({
+  children,
+  branch,
+  ...branches
+}: {
+  children?: unknown;
+  branch?: string | number | boolean;
+  [key: string]: unknown;
+}): React.JSX.Element;
+declare namespace Branch {
+  var _gtt: string;
+}
+//#endregion
+//#region src/hooks/useLocales.d.ts
+/**
+ * Retrieves the user's list of supported locales from the `<GTProvider>` context.
+ *
+ * @returns {string[]} The user's locales, e.g., ['en-US', 'fr', 'jp'].
+ *
+ * @example
+ * const locales = useLocales();
+ * console.log(locale); // ['en-US', 'fr', 'jp]
+ */
+declare function useLocales(): string[];
+//#endregion
+//#region src/hooks/useSetLocale.d.ts
+/**
+ * Sets the user's locale in the `<GTProvider>` context.
+ * If the locale passed is not supported, will fallback on current locale and then defaultLocale if necessary.
+ * @note Unless a locale has explicitly been passed to the `<GTProvider>`, this will override the user's browser preferences. The locale passed to `<GTProvider>` will always take priority.
+ *
+ * @returns {(locale: string) => void} A function that sets the user's locale.
+ *
+ * @example
+ * setLocale('en-US');
+ */
+declare function useSetLocale(): (locale: string) => void;
+//#endregion
+//#region src/ui/types.d.ts
+type LocaleSelectorProps = {
+  locales?: string[];
+  customNames?: {
+    [key: string]: string;
+  };
+  customMapping?: CustomMapping;
+  [key: string]: unknown;
+};
+type RegionSelectorProps<Regions extends string[]> = {
+  regions?: Regions;
+  placeholder?: ReactNode;
+  customMapping?: CustomMapping;
+  prioritizeCurrentLocaleRegion?: boolean;
+  sortRegionsAlphabetically?: boolean;
+};
+//#endregion
+//#region src/ui/LocaleSelector.d.ts
+/**
+ * @deprecated - this function is to always be overridden by a wrapper react package
+ */
+declare function LocaleSelector(_props: LocaleSelectorProps): React$1.JSX.Element | null;
+//#endregion
+//#region src/hooks/useLocaleSelector.d.ts
+/**
+ *
+ * Gets the list of properties for using a locale selector.
+ * Provides locale management utilities for the application.
+ * @param locales an optional list of locales to use for the drop down. These locales must be a subset of the locales provided by the `<GTProvider>` context. When not provided, the list of locales from the `<GTProvider>` context is used.
+ *
+ * @returns {Object} An object containing locale-related utilities:
+ * @returns {string} return.locale - The currently selected locale.
+ * @returns {string[]} return.locales - The list of all available locales.
+ * @returns {(locale: string) => void} return.setLocale - Function to update the current locale.
+ * @returns {(locale: string) => LocaleProperties} return.getLocaleProperties - Function to retrieve properties for a given locale.
+ */
+declare function useLocaleSelector(locales?: string[]): {
+  locale: string;
+  locales: string[];
+  setLocale: (locale: string) => void;
+  getLocaleProperties: (locale: string) => LocaleProperties;
+};
+//#endregion
+//#region src/ui/RegionSelector.d.ts
+/**
+ * @deprecated - this function is to always be overridden by a wrapper react package
+ */
+declare function RegionSelector<Regions extends string[]>(_props: RegionSelectorProps<Regions>): React$1.JSX.Element | null;
+//#endregion
+//#region src/hooks/useGTClass.d.ts
+/**
+ * Returns the configured GT class instance.
+ *
+ * @returns {GT} The configured GT class instance.
+ *
+ * @example
+ * const gt = useGTClass();
+ * console.log(gt.getLocaleProperties('en-US'));
+ */
+declare function useGTClass(): _$generaltranslation.GT;
+/**
+ * Returns the locale properties for the given locale.
+ *
+ * @param {string} locale - The locale to get the properties for.
+ * @returns {LocaleProperties} The locale properties for the given locale.
+ *
+ * @example
+ * const localeProperties = useLocaleProperties('en-US');
+ * console.log(localeProperties);
+ */
+declare function useLocaleProperties(locale: string): LocaleProperties;
+//#endregion
+//#region src/hooks/useRegionSelector.d.ts
+type RegionData = {
+  code: string;
+  name: string;
+  emoji: string;
+  locale: string;
+};
+/**
+ * React hook for managing region selection logic in applications supporting multiple regions.
+ *
+ * This hook provides the necessary data and handlers to implement a region selector UI component.
+ * It returns the current region, a list of available regions, region metadata, and functions to update the region or associated locale.
+ *
+ * ### Parameters
+ * @param {Object} [options] - Optional configuration object.
+ * @param {string[]} [options.regions] - An optional array of ISO 3166 region codes to display. If not provided, regions are inferred from supported locales.
+ * @param {Object.<string, string|{name?: string, emoji?: string, locale?: string}>} [options.customMapping] - Optional mapping to override region display names, emojis, or associated locales.
+ * @param {boolean} [options.prioritizeCurrentLocaleRegion=true] - If true, the region corresponding to the current locale is prioritized in the list.
+ * @param {boolean} [options.sortRegionsAlphabetically=true] - If true, regions are sorted alphabetically by display name.
+ *
+ * ### Returns
+ * @returns {{
+ *   region: string | undefined,
+ *   setRegion: (region: string) => void,
+ *   regions: string[],
+ *   regionData: Map<string, { code: string, name: string, emoji: string, locale: string }>,
+ *   locale: string,
+ *   setLocale: (locale: string) => void
+ * }} An object containing:
+ *   - `region`: The currently selected region code.
+ *   - `setRegion`: Function to update the selected region.
+ *   - `regions`: Array of available region codes.
+ *   - `regionData`: Map of region codes to their display data (name, emoji, locale).
+ *   - `locale`: The current locale.
+ *   - `setLocale`: Function to update the locale.
+ *
+ * ### Example
+ * ```tsx
+ * const {
+ *   region,
+ *   setRegion,
+ *   regions,
+ *   regionData,
+ *   locale,
+ *   setLocale
+ * } = useRegionSelector({
+ *   customMapping: { US: { name: "United States", emoji: "🇺🇸" } }
+ * });
+ *
+ * return (
+ *   <select value={region} onChange={e => setRegion(e.target.value)}>
+ *     {regions.map(r => (
+ *       <option key={r} value={r}>
+ *         {regionData.get(r)?.name}
+ *       </option>
+ *     ))}
+ *   </select>
+ * );
+ * ```
+ */
+declare function useRegionSelector({
+  regions: _regions,
+  customMapping,
+  prioritizeCurrentLocaleRegion,
+  sortRegionsAlphabetically
+}?: {
+  regions?: string[];
+  customMapping?: {
+    [region: string]: string | {
+      name?: string;
+      emoji?: string;
+      locale?: string;
+    };
+  };
+  prioritizeCurrentLocaleRegion?: boolean;
+  sortRegionsAlphabetically?: boolean;
+}): {
+  region: string | undefined;
+  setRegion: (region: string | undefined) => void;
+  regions: string[];
+  regionData: Map<string, RegionData>;
+  locales: string[];
+  locale: string;
+  localeRegion: string;
+  setLocale: (locale: string) => void;
+};
+//#endregion
+//#region src/hooks/useLocaleDirection.d.ts
+/**
+ * Retrieves the text direction ('ltr' or 'rtl') for the current or specified locale from the `<GTProvider>` context.
+ *
+ * If no locale is provided, the direction for the current user's locale is returned.
+ *
+ * @param {string} [locale] - Optional locale code (e.g., 'ar', 'en-US'). If omitted, uses the current locale from context.
+ * @returns {'ltr' | 'rtl'} The text direction for the locale: 'rtl' for right-to-left languages, otherwise 'ltr'.
+ *
+ * @example
+ * const dir = useLocaleDirection(); // e.g., 'ltr'
+ * const arabicDir = useLocaleDirection('ar'); // 'rtl'
+ */
+declare function useLocaleDirection(locale?: string): 'ltr' | 'rtl';
+//#endregion
+//#region ../i18n/dist/index-BLWcN0wI.d.cts
+//#region src/translation-functions/fallbacks/gtFallback.d.ts
+/**
+ * A fallback function for the gt() function that decodes and interpolates.
+ * @param {string | null | undefined} message - The ICU formatted message to interpolate.
+ * @param {InlineTranslationOptions} options - The options to interpolate.
+ * @returns - The decoded and interpolated message.
+ *
+ * @note This function is useful as a placeholder when for incrementally migrating to the m() function.
+ * @example
+ * // A backwards compatible translation function
+ * function getMessage(gt: GTFunctionType = gtFallback) {
+ *   return gt('Hello, world!');
+ * }
+ *
+ * // Here i18n has been implemented
+ * function WithTranslation() {
+ *   const gt = useGT();
+ *   return <>{getMessage(gt)}</>;
+ * }
+ *
+ *
+ * // i18n has not yet been implemented yet
+ * function WithoutTranslations() {
+ *   return <>{getMessage()}</>;
+ * }
+ */
+declare const gtFallback: GTFunctionType; //#endregion
+//#region src/translation-functions/fallbacks/mFallback.d.ts
+/**
+ * A fallback function for the m() function that decodes and interpolates.
+ * @param {string | null | undefined} encodedMsg - The encoded message to decode and interpolate.
+ * @param {InlineTranslationOptions} options - The options to interpolate.
+ * @returns - The decoded and interpolated message.
+ *
+ * @note This function is useful as a placeholder when for incrementally migrating to the m() function.
+ * @example
+ * // A backwards compatible translation function
+ * function getMessage(m: MFunctionType = mFallback) {
+ *   return m(msg('Hello, world!'));
+ * }
+ *
+ * // Here i18n has been implemented
+ * function WithTranslation() {
+ *   const m = useMessages();
+ *   return <>{getMessage(m)}</>;
+ * }
+ *
+ *
+ * // i18n has not yet been implemented yet
+ * function WithoutTranslations() {
+ *   return <>{getMessage()}</>;
+ * }
+ */
+declare const mFallback: MFunctionType; //#endregion
+//#endregion
+//#region ../core/dist/internal.d.cts
+//#endregion
+//#region src/derive/decodeVars.d.ts
+/**
+ * Given an encoded ICU string, interpolate only _gt_ variables that have been marked with declareVar()
+ * @example
+ * const encodedIcu = "Hi" + declareVar("Brian") + ", my name is {name}"
+ * // 'Hi {_gt_, select, other {Brian}}, my name is {name}'
+ * decodeVars(encodedIcu)
+ * // 'Hi Brian, my name is {name}'
+ */
+declare function decodeVars(icuString: string): string; //#endregion
+//#region src/derive/declareVar.d.ts
+/**
+ * Mark as a non-translatable string. Use within a derive() call to mark content as not derivable (e.g., not possible to statically analyze).
+ *
+ * @example
+ * function nonDerivableFunction() {
+ *   return Math.random();
+ * }
+ *
+ * function derivableFunction() {
+ *   if (condition) {
+ *     return declareVar(nonDerivableFunction())
+ *   }
+ *   return 'John Doe';
+ * }
+ *
+ * const gt = useGT();
+ * gt(`My name is ${derive(derivableFunction())}`);
+ *
+ * @param {string | number | boolean | null | undefined} variable - The variable to sanitize.
+ * @param {Object} [options] - The options for the sanitization.
+ * @param {string} [options.$name] - The name of the variable.
+ * @returns {string} The sanitized value.
+ */
+declare function declareVar(variable: string | number | boolean | null | undefined, options?: {
+  $name?: string;
+}): string; //#endregion
+//#region src/derive/derive.d.ts
+/**
+ * Marks content as derivable by the GT compiler and CLI.
+ *
+ * Use `derive()` when a translation string or context needs content that is
+ * computed from source code, but should still be discovered during extraction
+ * instead of treated as a runtime interpolation variable. The CLI attempts to
+ * resolve the derivable expression into every possible static value and
+ * includes those values in the source content that gets translated.
+ *
+ * `derive()` returns its argument unchanged at runtime.
+ *
+ * Run `gt validate` after adding or changing `derive()` calls to verify that
+ * each derivable expression can be resolved by the CLI before translating or
+ * building.
+ *
+ * @example
+ * ```jsx
+ * function getSubject() {
+ *   return (Math.random() > 0.5) ? "Alice" : "Brian";
+ * }
+ * ...
+ * gt(`My name is ${derive(getSubject())}`);
+ * ```
+ *
+ * @param {T extends string | boolean | number | null | undefined} content - Content to derive for translation extraction.
+ * @returns {T} The same content, unchanged at runtime.
+ */
+declare function derive<T extends string | boolean | number | null | undefined>(content: T): T;
+/**
+ * @deprecated Use derive() instead.
+ *
+ * Marks content as derivable by the GT compiler and CLI.
+ *
+ * Use `derive()` instead of `declareStatic()` for new code. This alias is kept
+ * for backwards compatibility and returns its argument unchanged at runtime.
+ *
+ * Run `gt validate` after adding or changing derived content to verify that
+ * each derivable expression can be resolved by the CLI before translating or
+ * building.
+ *
+ * @example
+ * ```jsx
+ * function getSubject() {
+ *   return (Math.random() > 0.5) ? "Alice" : "Brian";
+ * }
+ * ...
+ * gt(`My name is ${declareStatic(getSubject())}`);
+ * ```
+ *
+ * @param {T extends string | boolean | number | null | undefined} content - Content to derive for translation extraction.
+ * @returns {T} The same content, unchanged at runtime.
+ */
+declare const declareStatic: typeof derive; //#endregion
+//#region src/derive/indexVars.d.ts
+/**
+ * Given an ICU string adds identifiers to each _gt_ placeholder
+ * indexVars('Hello {_gt_} {_gt_} World') => 'Hello {_gt_1_} {_gt_2_} World'
+ */
+//#endregion
+//#region ../i18n/dist/index.d.cts
+//#endregion
+//#region src/translation-functions/msg/msg.d.ts
+/**
+ * Registers a message to be translated. Returns the message unchanged if no options are provided.
+ * @param {string | string[]} message The message to encode.
+ * @param {InlineTranslationOptions} [options] The options to encode.
+ * @returns The message or array of messages.
+ *
+ * @note - This function registers the message before the build process. The actual translation does not
+ * occur until the m() function is invoked.
+ *
+ * @note - Message format
+ * A message is broken into two parts separated by colons:
+ * - interpolated content - the content with interpolated variables
+ * - hash + options - a unique identifier for the source content and options for the translation
+ *
+ * @example - Basic usage
+ *
+ * const message1 = msg('Hello, World!');
+ * console.log(message1); // "Hello, World!"
+ *
+ * const message2 = msg('Hello, {name}!', { name: 'Brian' });
+ * console.log(message2); // "Hello, Brian:eyIkX2hhc2giOiAiMHgxMjMiLCAiJF9zb3VyY2UiOiAiSGVsbG8sIHtuYW1lfSEiLCAibmFtZSI6ICJCcmlhbiJ9"
+ *
+ * @example - Array usage
+ *
+ * const messages = msg(['Hello, Alice!', 'Hello, Bob!']);
+ * console.log(messages); // ["Hello, Alice!", "Hello, Bob!"]
+ *
+ * @example - When specifying an id for an array, each message will have a unique id of `${id}.${index}`
+ * const messages = msg(['Hello, Alice!', 'Hello, Bob!'], { $id: 'greetings' });
+ * // "Hello, Alice!" id: "greetings.0"
+ * // "Hello, Bob!" id: "greetings.1"
+ *
+ * @important Internal note: until other packages are updated to use i18n-context practices, msg cannot use any functions that use i18nManager at all!
+ */
+declare function msg<T extends RegisterableMessages = string>(message: T): T;
+declare function msg<T extends RegisterableMessages = string>(message: T, options?: InlineTranslationOptions): T extends string ? string : string[]; //#endregion
+//#region src/translation-functions/msg/decodeMsg.d.ts
+/**
+ * Extracts the original interpolated message string.
+ * If the message cannot be decoded (i.e., it does not contain a colon separator),
+ * the input is returned as-is.
+ * @param encodedMsg The message to decode.
+ * @returns The decoded message, or the input if it cannot be decoded.
+ */
+declare function decodeMsg(encodedMsg: string): string;
+declare function decodeMsg<T extends null | undefined>(encodedMsg: T): T;
+declare function decodeMsg<T extends string | null | undefined>(encodedMsg: T): T extends string ? string : T; //#endregion
+//#region src/translation-functions/msg/decodeOptions.d.ts
+/**
+ * Decodes the options from an encoded message.
+ * @param encodedMsg The message to decode.
+ * @returns The decoded options.
+ */
+declare function decodeOptions(encodedMsg: string): InlineTranslationOptions | null; //#endregion
+//#endregion
+//#region src/translation/hooks/useMessages.d.ts
+/**
+ * Gets the message decoding and translation function `m` provided by `<GTProvider>`.
+ *
+ * @returns {Function} A translation function that accepts an encoded message, decodes it, and returns the translated value.
+ *
+ * @example
+ * const encodedMessage = msg("Hello, world")
+ * const m = useMessages();
+ * m(encodedMessage) // returns "Hello, world" translated
+ *
+ * @example
+ * const encodedMessage = msg("My name is {name}", { name: "Brian" });
+ * const m = useMessages();
+ * m(encodedMessage) // returns "My name is Brian" translated
+ */
+declare function useMessages(_messages?: _Messages): MFunctionType;
+//#endregion
+//#region src/types-dir/runtime.d.ts
+type TranslateIcuCallback = (params: {
+  source: string;
+  targetLocale: string;
+  metadata: {
+    hash: string;
+    context?: string;
+    maxChars?: number;
+  } & Record<string, unknown>;
+}) => Promise<TranslatedChildren>;
+type TranslateChildrenCallback = (params: {
+  source: JsxChildren | undefined;
+  targetLocale: string;
+  metadata: {
+    hash: string;
+    context?: string;
+    maxChars?: number;
+  } & Record<string, unknown>;
+}) => Promise<TranslatedChildren>;
+//#endregion
+//#region src/types-dir/context.d.ts
+type GTContextType = {
+  gt: GT;
+  registerIcuForTranslation: TranslateIcuCallback;
+  registerJsxForTranslation: TranslateChildrenCallback;
+  _gtFunction: (message: string, options?: InlineTranslationOptions, preloadedTranslations?: Translations) => string;
+  _mFunction: <T extends string | null | undefined>(encodedMsg: T, options?: Record<string, unknown>, preloadedTranslations?: Translations) => T extends string ? string : T;
+  _filterMessagesForPreload: (_messages: _Messages) => _Messages;
+  _preloadMessages: (_messages: _Messages) => Promise<Translations>;
+  _dictionaryFunction: (id: string, options?: DictionaryTranslationOptions) => string;
+  _dictionaryObjFunction: (id: string, idWithParent: string, options?: DictionaryTranslationOptions) => Dictionary | DictionaryEntry | string | undefined;
+  developmentApiEnabled: boolean;
+  locale: string;
+  locales: string[];
+  setLocale: (locale: string) => void;
+  defaultLocale: string;
+  region: string | undefined;
+  setRegion: (region: string | undefined) => void;
+  translations: Translations | null;
+  translationRequired: boolean;
+  dialectTranslationRequired: boolean;
+  renderSettings: {
+    method: RenderMethod;
+    timeout?: number;
+  };
+  projectId?: string;
+  _versionId?: string;
+};
+//#endregion
+//#region src/provider/GTContext.d.ts
+declare const GTContext: _$react.Context<GTContextType | undefined>;
+//#endregion
+//#region src/provider/hooks/useRuntimeTranslation.d.ts
+declare function useRuntimeTranslation({
+  gt,
+  locale,
+  versionId: _versionId,
+  // kept for API compatibility (not used)
+  defaultLocale,
+  runtimeUrl,
+  renderSettings,
+  setTranslations,
+  environment,
+  ...additionalMetadata
+}: {
+  gt: GT;
+  locale: string;
+  versionId?: string;
+  defaultLocale?: string;
+  runtimeUrl?: string | null;
+  renderSettings: {
+    method: RenderMethod;
+    timeout?: number;
+  };
+  environment: 'development' | 'production' | 'test';
+  setTranslations: _$react.Dispatch<_$react.SetStateAction<Translations | null>>;
+  [key: string]: unknown;
+}): {
+  registerIcuForTranslation: TranslateIcuCallback;
+  registerJsxForTranslation: TranslateChildrenCallback;
+  developmentApiEnabled: boolean;
+};
+//#endregion
+//#region src/provider/hooks/translation/useCreateInternalUseGTFunction.d.ts
+declare function useCreateInternalUseGTFunction({
+  gt,
+  translations,
+  locale,
+  defaultLocale,
+  translationRequired,
+  developmentApiEnabled,
+  registerIcuForTranslation,
+  environment
+}: {
+  gt: GT;
+  translations: Translations | null;
+  locale: string;
+  defaultLocale: string;
+  translationRequired: boolean;
+  developmentApiEnabled: boolean;
+  registerIcuForTranslation: TranslateIcuCallback;
+  environment: 'development' | 'production' | 'test';
+}): {
+  _gtFunction: (message: string, options?: InlineTranslationOptions, preloadedTranslations?: Translations) => string;
+  _mFunction: <T extends string | null | undefined>(message: T, options?: Record<string, unknown>, preloadedTranslations?: Translations) => T extends string ? string : T;
+  _filterMessagesForPreload: (_messages: _Messages) => _Messages;
+  _preloadMessages: (_messages: _Messages) => Promise<Translations>;
+};
+//#endregion
+//#region src/provider/hooks/translation/useCreateInternalUseTranslationsFunction.d.ts
+declare function useCreateInternalUseTranslationsFunction(gt: GT, dictionary: Dictionary | undefined, dictionaryTranslations: Dictionary | undefined, translations: Translations | null, locale: string, defaultLocale: string, translationRequired: boolean, dialectTranslationRequired: boolean, developmentApiEnabled: boolean, registerIcuForTranslation: TranslateIcuCallback, environment: 'development' | 'production' | 'test'): (id: string, options?: DictionaryTranslationOptions) => string;
+//#endregion
+//#region src/provider/hooks/translation/useCreateInternalUseTranslationsObjFunction.d.ts
+declare function useCreateInternalUseTranslationsObjFunction(dictionary: Dictionary, dictionaryTranslations: Dictionary, setDictionary: Function, setDictionaryTranslations: Function, translations: Translations | null, locale: string, defaultLocale: string, translationRequired: boolean, dialectTranslationRequired: boolean, developmentApiEnabled: boolean, registerIcuForTranslation: TranslateIcuCallback, gtFunction: (id: string, options: DictionaryTranslationOptions) => string): (id: string, idWithParent: string, options?: DictionaryTranslationOptions) => Dictionary | DictionaryEntry | undefined;
+//#endregion
+export { Branch, Currency, DateTime, Derive, type DictionaryTranslationOptions, GTContext, GTProvider, type InlineTranslationOptions, LocaleSelector, Num, Plural, RegionSelector, RelativeTime, type RuntimeTranslationOptions, Static, T, Var, declareStatic, declareVar, decodeMsg, decodeOptions, decodeVars, derive, gtFallback, mFallback, msg, useCreateInternalUseGTFunction, useCreateInternalUseTranslationsFunction, useCreateInternalUseTranslationsObjFunction, useDefaultLocale, useGT, useGTClass, useLocale, useLocaleDirection, useLocaleProperties, useLocaleSelector, useLocales, useMessages, useRegion, useRegionSelector, useRuntimeTranslation, useSetLocale, useTranslations, useVersionId };
 //# sourceMappingURL=index.d.ts.map