@generaltranslation/react-core 1.8.20 → 2.0.0-odysseus.0

package/dist/pure.d.ts

@@ -0,0 +1,677 @@
+import { declareVar, decodeMsg, decodeOptions, decodeVars, derive, getDefaultLocale, getGTClass, getLocaleProperties, getLocales, getVersionId, gtFallback, mFallback, msg } from "gt-i18n";
+import React, { ReactNode } from "react";
+import { Dictionary as Dictionary$1, DictionaryEntry as DictionaryEntry$1, DictionaryObject as DictionaryObject$1, DictionaryTranslationOptions, GTFunctionType, InlineTranslationOptions, InlineTranslationOptions as InlineTranslationOptions$1, LookupOptions, MFunctionType, RuntimeTranslationOptions, Translation } from "gt-i18n/types";
+import { GTServicesEnabledParams, Hash, I18nCacheConstructorParams, I18nConfigParams, I18nConfigParams as I18nConfigParams$1, Locale, ReadonlyConditionStoreInterface, WritableConditionStoreParams, WritableConditionStoreParams as WritableConditionStoreParams$1 } from "gt-i18n/internal/types";
+import { I18nCache, I18nConfig, ReadonlyConditionStore, WritableConditionStore } from "gt-i18n/internal";
+
+//#region src/utils/plurals/getPluralBranch.d.ts
+/**
+ * Main function to get the appropriate branch based on the provided number and branches.
+ *
+ * @param {number} n - The number to determine the branch for.
+ * @param {any} branches - The object containing possible branches.
+ * @returns {any} The determined branch.
+ */
+declare function getPluralBranch<T>(n: number, locales: string[], branches: Record<string, T>): T | null;
+//#endregion
+//#region ../format/dist/types-COaQnqVZ.d.cts
+//#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
+ */
+/**
+ * A content type representing JSX elements.
+ */
+type JsxChildren = JsxChild | JsxChild[];
+/**
+ * A content type representing ICU messages.
+ */
+//#endregion
+//#region ../core/dist/types-CdRgQtET.d.cts
+type TransformationPrefix = 'translate' | 'variable' | 'plural' | 'branch' | 'fragment' | 'derive';
+type VariableTransformationSuffix = 'variable' | 'number' | 'datetime' | 'currency' | 'relative-time';
+type InjectionType = 'automatic' | 'manual'; //#endregion
+//#region src/types.d.ts
+/**
+ * @deprecated Use {@link Content} instead.
+ */
+//#endregion
+//#region src/utils/types.d.ts
+/**
+ * TaggedElement is a React element with a GTProp property.
+ */
+type GTTag = {
+  id: number;
+  injectionType: InjectionType;
+  transformation?: TransformationPrefix;
+  branches?: Record<string, TaggedChildren>;
+  variableType?: VariableTransformationSuffix;
+};
+type TaggedElementProps = Record<string, unknown> & {
+  'data-_gt': GTTag;
+  children?: TaggedChildren;
+  branch?: string | number | boolean;
+  n?: number;
+  key?: React.Key;
+};
+type TaggedElement = React.ReactElement<TaggedElementProps>;
+type TaggedChild = Exclude<React.ReactNode, React.ReactElement> | TaggedElement;
+type TaggedChildren = TaggedChild[] | TaggedChild;
+/**
+ * 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 Entry = string;
+type MetaEntry = {
+  $context?: string;
+  $maxChars?: number;
+  $_hash?: string;
+  [key: string]: unknown;
+};
+type Metadata = MetaEntry;
+type DictionaryEntry = Entry | [Entry] | [Entry, MetaEntry];
+type Dictionary = {
+  [key: string]: Dictionary | DictionaryEntry;
+} | (Dictionary | DictionaryEntry)[];
+type FlattenedDictionary = {
+  [key: string]: DictionaryEntry;
+};
+type DictionaryContent = string;
+type DictionaryObject = {
+  [id: string]: DictionaryContent;
+};
+type LocalesDictionary = {
+  [locale: string]: DictionaryObject;
+};
+type CustomLoader = (locale: string) => Promise<unknown>;
+type RelativeTimeFormatOptions = Intl.RelativeTimeFormatOptions & {
+  unit?: Intl.RelativeTimeFormatUnit;
+  baseDate?: Date;
+};
+type VariableProps = {
+  /** Whether the variable was automatically injected by the compiler */variableType: VariableType;
+  variableValue: unknown;
+  variableOptions: Intl.NumberFormatOptions | Intl.DateTimeFormatOptions | RelativeTimeFormatOptions;
+  variableName: string;
+  injectionType: InjectionType;
+};
+type RenderVariable = ({
+  variableType,
+  variableValue,
+  variableOptions,
+  locales,
+  enableI18n,
+  injectionType
+}: Omit<VariableProps, 'variableName'> & {
+  locales: string[];
+  enableI18n: boolean;
+}) => React.ReactNode;
+type Translations = {
+  [hash: string]: TranslatedChildren | null;
+};
+type RenderMethod = 'skeleton' | 'replace' | 'default';
+type _Message = {
+  message: string;
+  $id?: string;
+  $context?: string;
+  $maxChars?: number;
+  $_hash?: string;
+};
+type _Messages = _Message[];
+type AuthFromEnvParams = {
+  projectId?: string;
+  devApiKey?: string;
+};
+type AuthFromEnvReturn = {
+  projectId: string;
+  devApiKey?: string;
+};
+//#endregion
+//#region src/utils/internal/addGTIdentifier.d.ts
+declare function addGTIdentifier(children: ReactNode, startingIndex?: number): TaggedChildren;
+//#endregion
+//#region src/utils/internal/writeChildrenAsObjects.d.ts
+/**
+ * Transforms children elements into objects, processing each child recursively if needed.
+ * TaggedChildren are transformed into JsxChildren
+ * @param {Children} children - The children to process.
+ * @returns {object} The processed children as objects.
+ */
+declare function writeChildrenAsObjects(children: TaggedChildren): JsxChildren;
+//#endregion
+//#region src/utils/dictionaries/flattenDictionary.d.ts
+/**
+ * Flattens a nested dictionary by concatenating nested keys.
+ * Throws an error if two keys result in the same flattened key.
+ * @param {Record<string, any>} dictionary - The dictionary to flatten.
+ * @param {string} [prefix=''] - The prefix for nested keys.
+ * @returns {Record<string, React.ReactNode>} The flattened dictionary object.
+ * @throws {Error} If two keys result in the same flattened key.
+ */
+declare function flattenDictionary(dictionary: Dictionary, prefix?: string): FlattenedDictionary;
+//#endregion
+//#region src/utils/variables/_getVariableProps.d.ts
+type VariableElementProps = {
+  'data-_gt': GTTag & {
+    transformation: 'variable';
+  };
+  [key: string]: unknown;
+};
+declare function getVariableProps(props: VariableElementProps): VariableProps;
+//#endregion
+//#region src/utils/variables/getVariableName.d.ts
+declare const defaultVariableNames: {
+  readonly variable: "value";
+  readonly number: "n";
+  readonly datetime: "date";
+  readonly currency: "cost";
+  readonly 'relative-time': "time";
+};
+declare function getVariableName(props: Record<string, unknown> | undefined, variableType: keyof typeof defaultVariableNames): string;
+//#endregion
+//#region src/hooks/utils/getFormatLocales.d.ts
+declare function getFormatLocales({
+  locale,
+  enableI18n,
+  localesProp
+}: {
+  locale: string;
+  enableI18n: boolean;
+  localesProp?: string[];
+}): string[];
+//#endregion
+//#region src/functions/helpers/getTranslationsSnapshot.d.ts
+/**
+ * Returns a promise of serializable cached translations that
+ * can be passed to a provider for hydration
+ *
+ * TODO: perhaps should be moved to /i18n if allowing for type generics
+ */
+declare function getTranslationsSnapshot(locale: Locale): Promise<Record<Locale, Record<Hash, Translation>>>;
+//#endregion
+//#region src/functions/translation/t.d.ts
+/**
+ * Translate a message
+ * @param {string} message - The message to translate.
+ * @param {InlineTranslationOptions} [options] - The options for the translation.
+ * @returns {string} The translated message.
+ *
+ * @example
+ * t('Hello, world!'); // Translates 'Hello, world!'
+ *
+ * @example
+ * t('Hello, {name}!', { name: 'John' }); // Translates 'Hello, John!'
+ *
+ * @example
+ * t`Hello, ${name}` // Translate via tagged template literal
+ *
+ */
+declare const t: StringOrTemplateSyncResolutionFunction;
+/**
+ * Overloaded type for the `t` function.
+ * - Tagged template: t`Hello, ${name}` (transformed by the compiler plugin at build time)
+ * - Function call: t("Hello, {name}", { name: "John" })
+ *
+ * {@link TemplateSyncResolutionFunction}
+ * {@link SyncResolutionFunction}
+ */
+interface StringOrTemplateSyncResolutionFunction {
+  (strings: TemplateStringsArray, ...values: unknown[]): string;
+  (message: string, options?: InlineTranslationOptions$1): string;
+}
+//#endregion
+//#region src/components/variables/Currency.shared.d.ts
+type CurrencyProps = {
+  children: number | string | null | undefined;
+  currency?: string;
+  options?: Intl.NumberFormatOptions;
+  locales?: string[];
+  name?: string;
+  _locale?: string;
+  _enableI18n?: boolean;
+};
+type ResolvedCurrencyProps = CurrencyProps & {
+  _locale: string;
+  _enableI18n: boolean;
+};
+//#endregion
+//#region src/components/variables/DateTime.shared.d.ts
+type DateTimeProps = {
+  children: Date | null | undefined;
+  locales?: string[];
+  options?: Intl.DateTimeFormatOptions;
+  name?: string;
+  _locale?: string;
+  _enableI18n?: boolean;
+};
+type ResolvedDateTimeProps = DateTimeProps & {
+  _locale: string;
+  _enableI18n: boolean;
+};
+//#endregion
+//#region src/components/variables/Num.shared.d.ts
+type NumProps = {
+  children: number | string | null | undefined;
+  options?: Intl.NumberFormatOptions;
+  locales?: string[];
+  name?: string;
+  _locale?: string;
+  _enableI18n?: boolean;
+};
+type ResolvedNumProps = NumProps & {
+  _locale: string;
+  _enableI18n: boolean;
+};
+//#endregion
+//#region src/components/variables/RelativeTime.shared.d.ts
+type RelativeTimeProps = {
+  date?: Date | null | undefined;
+  children?: Date | null | undefined;
+  name?: string;
+  value?: number;
+  unit?: Intl.RelativeTimeFormatUnit;
+  baseDate?: Date;
+  locales?: string[];
+  options?: Intl.RelativeTimeFormatOptions;
+  _locale?: string;
+  _enableI18n?: boolean;
+};
+type ResolvedRelativeTimeProps = RelativeTimeProps & {
+  _locale: string;
+  _enableI18n: boolean;
+};
+//#endregion
+//#region src/utils/rendering/createRenderVariable.d.ts
+type RenderableNode = ReactNode | Promise<ReactNode>;
+type VariableComponents = {
+  Currency: (props: ResolvedCurrencyProps) => RenderableNode;
+  GtInternalCurrency: (props: ResolvedCurrencyProps) => RenderableNode;
+  DateTime: (props: ResolvedDateTimeProps) => RenderableNode;
+  GtInternalDateTime: (props: ResolvedDateTimeProps) => RenderableNode;
+  Num: (props: ResolvedNumProps) => RenderableNode;
+  GtInternalNum: (props: ResolvedNumProps) => RenderableNode;
+  RelativeTime: (props: ResolvedRelativeTimeProps) => RenderableNode;
+  GtInternalRelativeTime: (props: ResolvedRelativeTimeProps) => RenderableNode;
+  Var: (props: {
+    children: ReactNode;
+    name?: string;
+    _locale: string;
+    _enableI18n: boolean;
+  }) => RenderableNode;
+  GtInternalVar: (props: {
+    children: ReactNode;
+    name?: string;
+    _locale: string;
+    _enableI18n: boolean;
+  }) => RenderableNode;
+};
+//#endregion
+//#region src/utils/rendering/renderDefaultChildren.shared.d.ts
+type RenderDefaultChildrenArgs = {
+  children: TaggedChildren;
+  defaultLocale: string;
+  enableI18n: boolean;
+};
+//#endregion
+//#region src/utils/rendering/renderTranslatedChildren.shared.d.ts
+type RenderTranslatedChildrenArgs = {
+  source: TaggedChildren;
+  target: TranslatedChildren;
+  locales: string[];
+  enableI18n: boolean;
+};
+//#endregion
+//#region src/utils/rendering/renderPreparedT.shared.d.ts
+type RenderPreparedTParams = {
+  taggedSourceChildren: TaggedChildren;
+  targetJsxChildren: JsxChildren | null | undefined;
+  locale: string;
+  defaultLocale: string;
+  enableI18n: boolean;
+  shouldTranslate: boolean;
+};
+//#endregion
+//#region src/utils/rendering/createRenderPipeline.d.ts
+type RenderPipeline = {
+  renderVariable: RenderVariable;
+  renderDefaultChildren: (args: RenderDefaultChildrenArgs) => ReactNode;
+  renderTranslatedChildren: (args: RenderTranslatedChildrenArgs) => ReactNode;
+  renderPreparedT: (args: RenderPreparedTParams) => ReactNode;
+};
+declare function createRenderPipeline(components: VariableComponents): RenderPipeline;
+//#endregion
+//#region src/utils/translation/prepareT.shared.d.ts
+type RenderPreparedT = (params: RenderPreparedTParams) => ReactNode;
+//#endregion
+//#region src/i18n-cache/ReactI18nCache.d.ts
+declare class ReactI18nCache extends I18nCache<Translation> {}
+type ReactI18nCacheParams = I18nCacheConstructorParams<Translation>;
+//#endregion
+//#region src/i18n-cache/singleton-operations.d.ts
+declare function getReactI18nCache(): ReactI18nCache;
+declare function setReactI18nCache(i18nCache: ReactI18nCache): void;
+//#endregion
+//#region src/utils/cookies.d.ts
+/**
+ * Cookie name for tracking the user's selected locale.
+ */
+declare const defaultLocaleCookieName = "generaltranslation.locale";
+/**
+ * Cookie name for tracking the user's selected region.
+ */
+declare const defaultRegionCookieName = "generaltranslation.region";
+/**
+ * Cookie name for persisting the enableI18n feature flag.
+ */
+declare const defaultEnableI18nCookieName = "generaltranslation.enable-i18n";
+//#endregion
+//#region src/utils/dictionaries/getDictionaryEntry.d.ts
+declare function isValidDictionaryEntry(value: unknown): value is DictionaryEntry;
+declare function getDictionaryEntry<T extends Dictionary>(dictionary: T, id: string): Dictionary | DictionaryEntry | undefined;
+//#endregion
+//#region src/utils/dictionaries/getEntryAndMetadata.d.ts
+declare function getEntryAndMetadata(value: DictionaryEntry): {
+  entry: string;
+  metadata?: MetaEntry;
+};
+//#endregion
+//#region src/utils/rendering/isVariableObject.d.ts
+declare function isVariableObject(obj: unknown): obj is Variable;
+//#endregion
+//#region src/utils/rendering/renderSkeleton.d.ts
+/**
+ * renderSkeleton is a function that handles the rendering behavior for the skeleton loading method.
+ * It replaces all content with empty strings
+ * @returns an empty string
+ */
+declare function renderSkeleton(): React.ReactNode;
+//#endregion
+//#region src/utils/dictionaries/mergeDictionaries.d.ts
+declare function mergeDictionaries(defaultLocaleDictionary: Dictionary, localeDictionary: Dictionary): Dictionary;
+//#endregion
+//#region src/utils/rendering/getDefaultRenderSettings.d.ts
+declare const getDefaultRenderSettings: (environment?: "development" | "production" | "test") => {
+  method: RenderMethod;
+  timeout: number;
+};
+//#endregion
+//#region src/utils/promises/reactHasUse.d.ts
+declare const reactHasUse: boolean;
+//#endregion
+//#region src/utils/dictionaries/getSubtree.d.ts
+declare function getSubtree<T extends Dictionary>({
+  dictionary,
+  id
+}: {
+  dictionary: T;
+  id: string;
+}): Dictionary | DictionaryEntry | undefined;
+/**
+ * @description A function that gets a subtree from a dictionary
+ * @param dictionary - new dictionary to get the subtree from
+ * @param id - id of the subtree to get
+ * @param sourceDictionary - source dictionary to model off of
+ * @returns
+ */
+declare function getSubtreeWithCreation<T extends Dictionary>({
+  dictionary,
+  id,
+  sourceDictionary
+}: {
+  dictionary: T;
+  id: string;
+  sourceDictionary: T;
+}): Dictionary | DictionaryEntry | undefined;
+//#endregion
+//#region src/utils/dictionaries/injectEntry.d.ts
+/**
+ * @description Injects an entry into a translations object
+ * @param translations - The translations object to inject the entry into
+ * @param entry - The entry to inject
+ * @param hash - The hash of the entry
+ * @param sourceDictionary - The source dictionary to model the new dictionary after
+ */
+declare function injectEntry(dictionaryEntry: DictionaryEntry, dictionary: Dictionary | DictionaryEntry, id: string, sourceDictionary: Dictionary | DictionaryEntry): DictionaryEntry | undefined;
+//#endregion
+//#region src/utils/dictionaries/isDictionaryEntry.d.ts
+/**
+ * Type guard function that checks if a value is a DictionaryEntry
+ * @param value - The value to check
+ * @returns true if the value is a DictionaryEntry, false otherwise
+ */
+declare function isDictionaryEntry(value: Dictionary | DictionaryEntry | undefined): value is DictionaryEntry;
+//#endregion
+//#region src/utils/dictionaries/stripMetadataFromEntries.d.ts
+/**
+ * @description Iterate over tree and remove metadata leaving just the entry
+ */
+declare function stripMetadataFromEntries(dictionary: Dictionary): Dictionary;
+//#endregion
+//#region src/utils/dictionaries/injectHashes.d.ts
+/**
+ * @description Given a dictionary, adds hashes to all dictionary entries
+ * @param dictionary - The dictionary to add hashes to
+ * @param id - The starting point of dictionary (if subtree)
+ */
+declare function injectHashes(dictionary: Dictionary, id?: string): {
+  dictionary: Dictionary;
+  updateDictionary: boolean;
+};
+//#endregion
+//#region src/utils/dictionaries/injectTranslations.d.ts
+/**
+ * @description Injects translations into a dictionary
+ * @param dictionary - The dictionary to inject translations into
+ * @param translationsDictionary - The translations to inject into the dictionary
+ * @param translations - The translations to inject into the dictionary
+ * @param id - The id of the dictionary to inject translations into
+ */
+declare function injectTranslations(dictionary: Dictionary, translationsDictionary: Dictionary, translations: Translations, missingTranslations: {
+  source: string;
+  metadata: {
+    $id: string;
+    $context?: string;
+    $maxChars?: number;
+    $_hash: string;
+  };
+}[], prefixToRemove?: string): {
+  dictionary: Dictionary;
+  updateDictionary: boolean;
+};
+//#endregion
+//#region src/utils/dictionaries/injectFallbacks.d.ts
+/**
+ * @description Injects fallbacks into a dictionary
+ * @param dictionary - The dictionary to inject translations into
+ * @param translationsDictionary - The translations to inject into the dictionary
+ * @param translations - The translations to inject into the dictionary
+ * @param id - The id of the dictionary to inject translations into
+ */
+declare function injectFallbacks(dictionary: Dictionary, translationsDictionary: Dictionary, missingTranslations: {
+  source: string;
+  metadata: {
+    $id: string;
+    $context?: string;
+    $maxChars?: number;
+    $_hash: string;
+  };
+}[], prefixToRemove?: string): Dictionary;
+//#endregion
+//#region src/utils/dictionaries/injectAndMerge.d.ts
+/**
+ * @description Given a subtree and a dictionary, injects the subtree into the dictionary at the given id
+ * @param dictionary - The dictionary to inject the subtree into
+ * @param subtree - The subtree to inject into the dictionary
+ * @param id - The id of the subtree to inject into the dictionary
+ */
+declare function injectAndMerge(dictionary: Dictionary, subtree: Dictionary, id: string): Dictionary;
+//#endregion
+//#region src/utils/dictionaries/collectUntranslatedEntries.d.ts
+/**
+ * @description Collects all untranslated entries from a dictionary
+ * @param dictionary - The dictionary to collect untranslated entries from
+ * @param translationsDictionary - The translated dictionary to compare against
+ * @param id - The id of the dictionary to collect untranslated entries from
+ * @returns An array of untranslated entries
+ */
+declare function collectUntranslatedEntries(dictionary: Dictionary, translationsDictionary: Dictionary, id?: string): {
+  source: string;
+  metadata: {
+    $id: string;
+    $context?: string;
+    $maxChars?: number;
+    $_hash: string;
+  };
+}[];
+//#endregion
+//#region src/setup/initializeGTSRA.d.ts
+/**
+ * Validation and setup for read only properties
+ */
+declare function internalInitializeGTSRA(config: I18nConfigParams$1 & GTServicesEnabledParams & ReactI18nCacheParams): void;
+//#endregion
+//#region src/setup/initializeGTSPA.d.ts
+/**
+ * Initialize GT for an SPA
+ * - i18nCache
+ * - conditionStore
+ * - i18nStore
+ *
+ * @deprecated moved to /react and /react-native
+ */
+declare function internalInitializeGTSPA(config: I18nConfigParams$1 & GTServicesEnabledParams & ReactI18nCacheParams & WritableConditionStoreParams$1): void;
+//#endregion
+//#region src/i18n-store/storeTypes.d.ts
+type Unsubscribe = () => void;
+type StoreListener = () => void;
+type TranslateEventListener = (lookup: TranslateLookup) => void;
+type TranslateLookup<T extends Translation = Translation> = {
+  locale: string;
+  message: T;
+  options: LookupOptions;
+};
+type DictionaryLookup = {
+  locale: string;
+  id: string;
+};
+type TranslateSnapshot<T extends Translation = Translation> = T | undefined;
+type DictionaryEntrySnapshot = DictionaryEntry$1 | undefined;
+type DictionaryObjectSnapshot = DictionaryObject$1 | undefined;
+//#endregion
+//#region src/i18n-store/I18nStore.d.ts
+type DictionaryStoreListener = (event: DictionaryLookup) => void;
+/**
+ * I18nStore gives us the ability to perform client-side updates to translations.
+ * Primarily useful for dev hot reload.
+ *
+ * This is the stateful primitive behind lookup subscriptions and runtime
+ * translation requests. It intentionally does not know whether lookups are
+ * being served from SPA singletons or SRA provider snapshots; that policy lives
+ * in LookupAdapter, not in this store.
+ */
+declare class I18nStore {
+  private translateListeners;
+  private dictionaryEntryListeners;
+  private dictionaryObjectListeners;
+  /**
+   * I18nCache must be already initialized
+   */
+  constructor();
+  updateTranslations: (translations: Record<Locale, Record<Hash, Translation>>) => void;
+  updateDictionaries: (dictionaries: Record<Locale, Dictionary$1>) => void;
+  translate: <T extends Translation>(lookup: TranslateLookup<T>) => Promise<void>;
+  translateDictionaryEntry: (lookup: DictionaryLookup) => void;
+  translateDictionaryObject: (lookup: DictionaryLookup) => void;
+  subscribeToTranslate: <T extends Translation>(lookup: TranslateLookup<T>, listener: StoreListener) => Unsubscribe;
+  subscribeToTranslationEvents: (listener: TranslateEventListener) => Unsubscribe;
+  subscribeToDictionaryEntryEvents: (listener: DictionaryStoreListener) => Unsubscribe;
+  subscribeToDictionaryObjectEvents: (listener: DictionaryStoreListener) => Unsubscribe;
+  getTranslateSnapshot: <T extends Translation>(lookup: TranslateLookup<T>, translationsSnapshot?: Record<Locale, Record<Hash, Translation>>) => TranslateSnapshot<T>;
+  getDictionaryEntrySnapshot: (lookup: DictionaryLookup, dictionariesSnapshot?: Record<Locale, Dictionary$1>) => DictionaryEntrySnapshot;
+  getDictionaryObjectSnapshot: (lookup: DictionaryLookup, dictionariesSnapshot?: Record<Locale, Dictionary$1>) => DictionaryObjectSnapshot;
+  private emitTranslateEvent;
+  private emitDictionaryEvent;
+}
+//#endregion
+//#region src/i18n-store/singleton-operations.d.ts
+declare function getI18nStore(): I18nStore;
+declare function setI18nStore(nextStore: I18nStore): void;
+declare function isI18nStoreInitialized(): boolean;
+//#endregion
+//#region src/setup/i18nConfig.d.ts
+/**
+ * Helps us distinguish behavior for SPA vs server-rendered apps.
+ * - server-rendered apps must use context
+ * - SPA apps can synchronously access the locale
+ */
+type RenderStrategy = 'SPA' | 'server-render';
+declare class ReactI18nConfig extends I18nConfig {
+  private renderStrategy;
+  constructor(params?: I18nConfigParams$1, renderStrategy?: RenderStrategy);
+  getRenderStrategy(): RenderStrategy;
+}
+declare function getI18nConfig(): ReactI18nConfig;
+declare function setI18nConfig(nextI18nConfig: ReactI18nConfig): void;
+declare function initializeI18nConfig(params?: I18nConfigParams$1, renderStrategy?: RenderStrategy): ReactI18nConfig;
+//#endregion
+//#region src/condition-store/singleton-operations.d.ts
+declare const getConditionStore: () => ReadonlyConditionStoreInterface, setConditionStore: (nextConditionStore: ReadonlyConditionStoreInterface) => void, isConditionStoreInitialized: () => boolean;
+/**
+ * Opinionated decision: add a safety wrapper around the condition store to be more forgiving in production
+ * TODO: perhaps this is how condition store should always be accessed
+ */
+declare function getReadonlyConditionStoreWithFallback(): ReadonlyConditionStoreInterface;
+//#endregion
+//#region src/hooks/utils/missing-translation.d.ts
+type OnMissingTranslation = <T extends Translation>(lookup: TranslateLookup<T>) => void;
+type OnMissingDictionaryEntry = (lookup: DictionaryLookup) => void;
+type OnMissingDictionaryObj = (lookup: DictionaryLookup) => void;
+//#endregion
+export { type AuthFromEnvParams, type AuthFromEnvReturn, type CustomLoader, type Dictionary, type DictionaryContent, type DictionaryEntry, type DictionaryLookup, type DictionaryObject, type DictionaryTranslationOptions, type Entry, type FlattenedDictionary, type GTFunctionType, type GTProp, type I18nConfigParams, I18nStore, type InlineTranslationOptions, type LocalesDictionary, type MFunctionType, type Metadata, type OnMissingDictionaryEntry, type OnMissingDictionaryObj, type OnMissingTranslation, ReactI18nCache, type ReactI18nCacheParams, ReactI18nConfig, ReadonlyConditionStore, type RelativeTimeFormatOptions, type RenderMethod, type RenderPipeline, type RenderPreparedT, type RenderVariable, type RuntimeTranslationOptions, type TranslateLookup, type TranslatedChildren, type Translations, type VariableProps, WritableConditionStore, type WritableConditionStoreParams, type _Message, type _Messages, addGTIdentifier, collectUntranslatedEntries, createRenderPipeline, declareVar, decodeMsg, decodeOptions, decodeVars, defaultEnableI18nCookieName, defaultLocaleCookieName, defaultRegionCookieName, derive, flattenDictionary, getDefaultLocale, getDefaultRenderSettings, getDictionaryEntry, getEntryAndMetadata, getFormatLocales, getGTClass, getI18nConfig, getI18nStore, getLocaleProperties, getLocales, getPluralBranch, getReactI18nCache, getReadonlyConditionStoreWithFallback, getSubtree, getSubtreeWithCreation, getTranslationsSnapshot, getVariableName, getVariableProps, getVersionId, gtFallback, internalInitializeGTSRA as initializeGT, internalInitializeGTSRA, initializeI18nConfig, injectAndMerge, injectEntry, injectFallbacks, injectHashes, injectTranslations, internalInitializeGTSPA, isDictionaryEntry, isI18nStoreInitialized, isValidDictionaryEntry, isVariableObject, mFallback, mergeDictionaries, msg, reactHasUse, renderSkeleton, setI18nConfig, setI18nStore, setReactI18nCache, setConditionStore as setReadonlyConditionStore, stripMetadataFromEntries, t, writeChildrenAsObjects };
+//# sourceMappingURL=pure.d.ts.map