gt-react 10.19.15 → 10.19.16

package/dist/internal.d.mts

@@ -0,0 +1,1118 @@
+import t, { ReactNode } from "react";
+//#region ../react-core/dist/internal.d.ts
+//#region ../format/dist/types-UnF22q9r.d.cts
+//#endregion
+//#region src/types-dir/jsx/variables.d.ts
+type VariableType$1 = 'v' | 'n' | 'd' | 'c' | 'rt';
+/**
+ * Variables are used to store the variable name and type.
+ */
+type Variable$1 = {
+  k: string;
+  i?: number;
+  v?: VariableType$1;
+}; //#endregion
+//#region src/types-dir/jsx/content.d.ts
+/**
+ * Map of data-_gt properties to their corresponding React props
+ */
+declare const HTML_CONTENT_PROPS$1: {
+  readonly pl: "placeholder";
+  readonly ti: "title";
+  readonly alt: "alt";
+  readonly arl: "aria-label";
+  readonly arb: "aria-labelledby";
+  readonly ard: "aria-describedby";
+};
+type HtmlContentPropKeysRecord$1 = Partial<Record<keyof typeof HTML_CONTENT_PROPS$1, 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$1 = {
+  b?: Record<string, JsxChildren$1>;
+  t?: 'p' | 'b';
+} & HtmlContentPropKeysRecord$1;
+type JsxElement$1 = {
+  t?: string;
+  i?: number;
+  d?: GTProp$1;
+  c?: JsxChildren$1;
+};
+type JsxChild$1 = string | JsxElement$1 | Variable$1;
+/**
+ * The format of the string content
+ */
+type StringFormat$1 = 'ICU' | 'I18NEXT' | 'STRING';
+/**
+ * The format of the content.
+ */
+/**
+ * A content type representing JSX elements.
+ */
+type JsxChildren$1 = JsxChild$1 | JsxChild$1[];
+/**
+ * A content type representing ICU messages.
+ */
+//#endregion
+//#region ../core/dist/types-YrrGRHBP.d.cts
+type TransformationPrefix = 'translate' | 'variable' | 'plural' | 'branch' | 'fragment' | 'derive';
+type VariableTransformationSuffix = 'variable' | 'number' | 'datetime' | 'currency' | 'relative-time';
+type InjectionType$1 = 'automatic' | 'manual'; //#endregion
+//#region src/types.d.ts
+/**
+ * @deprecated Use {@link Content} instead.
+ */
+//#endregion
+//#region ../i18n/dist/options-D0Lnxv2X.d.cts
+//#region src/translation-functions/types/options.d.ts
+type BaseTranslationOptions$1 = Record<string, unknown>;
+/**
+ * Options for string resolution
+ * Used by the gt() function
+ */
+type InlineTranslationOptions$1 = BaseTranslationOptions$1 & {
+  $context?: string;
+  $id?: string; /** The data format for the message (e.g., 'ICU', 'STRING'). Defaults to 'ICU'. */
+  $format?: StringFormat$1; /** 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
+ */
+//#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$1 = (message: string, options?: InlineTranslationOptions$1) => 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$1 = SyncResolutionFunctionWithFallback$1;
+/**
+ * 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$1 = <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
+/**
+ * TaggedElement is a React element with a GTProp property.
+ */
+type GTTag = {
+  id: number;
+  injectionType: InjectionType$1;
+  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?: t.Key;
+};
+type TaggedElement = t.ReactElement<TaggedElementProps>;
+type TaggedChild = Exclude<t.ReactNode, t.ReactElement> | TaggedElement;
+type TaggedChildren = TaggedChild[] | TaggedChild;
+/**
+ * For dictionaries, we have Entry and MetaEntry
+ */
+type Entry$1 = string;
+type MetaEntry$1 = {
+  $context?: string;
+  $maxChars?: number;
+  $_hash?: string;
+  [key: string]: unknown;
+};
+type DictionaryEntry$1 = Entry$1 | [Entry$1] | [Entry$1, MetaEntry$1];
+type Dictionary$1 = {
+  [key: string]: Dictionary$1 | DictionaryEntry$1;
+} | (Dictionary$1 | DictionaryEntry$1)[];
+type FlattenedDictionary$1 = {
+  [key: string]: DictionaryEntry$1;
+};
+/**
+ * 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$1 = {
+  i?: number;
+  d?: GTProp$1;
+  c?: TranslatedChildren$1;
+};
+type TranslatedChild$1 = TranslatedElement$1 | string | Variable$1;
+type TranslatedChildren$1 = TranslatedChild$1 | TranslatedChild$1[];
+type Translations$1 = {
+  [hash: string]: TranslatedChildren$1 | null;
+};
+type RenderMethod$1 = 'skeleton' | 'replace' | 'default';
+type RelativeTimeFormatOptions$1 = Intl.RelativeTimeFormatOptions & {
+  unit?: Intl.RelativeTimeFormatUnit;
+  baseDate?: Date;
+};
+type VariableProps$1 = {
+  /** Whether the variable was automatically injected by the compiler */variableType: VariableType$1;
+  variableValue: unknown;
+  variableOptions: Intl.NumberFormatOptions | Intl.DateTimeFormatOptions | RelativeTimeFormatOptions$1;
+  variableName: string;
+  injectionType: InjectionType$1;
+};
+type RenderVariable$1 = ({
+  variableType,
+  variableValue,
+  variableOptions,
+  locales,
+  injectionType
+}: Omit<VariableProps$1, 'variableName'> & {
+  locales: string[];
+}) => t.ReactNode; //#endregion
+//#region src/internal/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$1, prefix?: string): FlattenedDictionary$1; //#endregion
+//#region src/internal/addGTIdentifier.d.ts
+declare function addGTIdentifier(children: ReactNode, startingIndex?: number): TaggedChildren; //#endregion
+//#region src/internal/removeInjectedT.d.ts
+/**
+ * Remove injected _T components at runtime. This is only for i18n-context T components to use.
+ * This is necessary because when dealing with deriving fragmented content. The compiler will always
+ * inject a `_T` component.
+ *
+ * Only remove if within a `<Derive>` or `<Static>` component as this scopes this behavior
+ * to only where it can actually appear.
+ */
+//#endregion
+//#region src/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$1; //#endregion
+//#region src/branches/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(n: number, locales: string[], branches: Record<string, unknown>): unknown; //#endregion
+//#region src/dictionaries/getDictionaryEntry.d.ts
+declare function isValidDictionaryEntry(value: unknown): value is DictionaryEntry$1;
+declare function getDictionaryEntry<T extends Dictionary$1>(dictionary: T, id: string): Dictionary$1 | DictionaryEntry$1 | undefined; //#endregion
+//#region src/dictionaries/getEntryAndMetadata.d.ts
+declare function getEntryAndMetadata(value: DictionaryEntry$1): {
+  entry: string;
+  metadata?: MetaEntry$1;
+}; //#endregion
+//#region src/variables/_getVariableProps.d.ts
+type VariableElementProps = {
+  'data-_gt': GTTag & {
+    transformation: 'variable';
+  };
+  [key: string]: unknown;
+};
+declare function getVariableProps(props: VariableElementProps): VariableProps$1; //#endregion
+//#region src/rendering/isVariableObject.d.ts
+declare function isVariableObject(obj: unknown): obj is Variable$1; //#endregion
+//#region src/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/rendering/renderDefaultChildren.d.ts
+declare function renderDefaultChildren({
+  children,
+  defaultLocale,
+  renderVariable
+}: {
+  children: TaggedChildren;
+  defaultLocale: string;
+  renderVariable: RenderVariable$1;
+}): t.ReactNode; //#endregion
+//#region src/rendering/renderTranslatedChildren.d.ts
+declare function renderTranslatedChildren({
+  source,
+  target,
+  locales,
+  renderVariable
+}: {
+  source: TaggedChildren;
+  target: TranslatedChildren$1;
+  locales: string[];
+  renderVariable: RenderVariable$1;
+}): ReactNode; //#endregion
+//#region src/rendering/getDefaultRenderSettings.d.ts
+declare const getDefaultRenderSettings: (environment?: "development" | "production" | "test") => {
+  method: RenderMethod$1;
+  timeout: number;
+}; //#endregion
+//#region src/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(): t.ReactNode; //#endregion
+//#region src/utils/cookies.d.ts
+/**
+ * Cookie name for tracking the referrer 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
+ * "true" or "false"
+ */
+//#endregion
+//#region src/dictionaries/mergeDictionaries.d.ts
+declare function mergeDictionaries(defaultLocaleDictionary: Dictionary$1, localeDictionary: Dictionary$1): Dictionary$1; //#endregion
+//#region src/promises/reactHasUse.d.ts
+declare const reactHasUse: boolean; //#endregion
+//#region src/dictionaries/getSubtree.d.ts
+declare function getSubtree<T extends Dictionary$1>({
+  dictionary,
+  id
+}: {
+  dictionary: T;
+  id: string;
+}): Dictionary$1 | DictionaryEntry$1 | 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$1>({
+  dictionary,
+  id,
+  sourceDictionary
+}: {
+  dictionary: T;
+  id: string;
+  sourceDictionary: T;
+}): Dictionary$1 | DictionaryEntry$1 | undefined; //#endregion
+//#region src/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$1, dictionary: Dictionary$1 | DictionaryEntry$1, id: string, sourceDictionary: Dictionary$1 | DictionaryEntry$1): DictionaryEntry$1 | undefined; //#endregion
+//#region src/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$1 | DictionaryEntry$1 | undefined): value is DictionaryEntry$1; //#endregion
+//#region src/dictionaries/stripMetadataFromEntries.d.ts
+/**
+ * @description Iterate over tree and remove metadata leaving just the entry
+ */
+declare function stripMetadataFromEntries(dictionary: Dictionary$1): Dictionary$1; //#endregion
+//#region src/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$1, id?: string): {
+  dictionary: Dictionary$1;
+  updateDictionary: boolean;
+}; //#endregion
+//#region src/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$1, translationsDictionary: Dictionary$1, translations: Translations$1, missingTranslations: {
+  source: string;
+  metadata: {
+    $id: string;
+    $context?: string;
+    $maxChars?: number;
+    $_hash: string;
+  };
+}[], prefixToRemove?: string): {
+  dictionary: Dictionary$1;
+  updateDictionary: boolean;
+}; //#endregion
+//#region src/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$1, translationsDictionary: Dictionary$1, missingTranslations: {
+  source: string;
+  metadata: {
+    $id: string;
+    $context?: string;
+    $maxChars?: number;
+    $_hash: string;
+  };
+}[], prefixToRemove?: string): Dictionary$1; //#endregion
+//#region src/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$1, subtree: Dictionary$1, id: string): Dictionary$1; //#endregion
+//#region src/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$1, translationsDictionary: Dictionary$1, id?: string): {
+  source: string;
+  metadata: {
+    $id: string;
+    $context?: string;
+    $maxChars?: number;
+    $_hash: string;
+  };
+}[]; //#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$1; //#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$1; //#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$1): 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$1 | null; //#endregion
+//#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 t.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 t.ReactNode>(props: {
+  children: T;
+}): T;
+declare namespace Static {
+  var _gtt: string;
+} //#endregion
+//#endregion
+//#region ../react-core/dist/types.d.ts
+//#region ../format/dist/types-UnF22q9r.d.cts
+//#region src/locales/customLocaleMapping.d.ts
+type CustomMapping$1 = Record<string, string | Partial<LocaleProperties$1>>; //#endregion
+//#region src/locales/getLocaleProperties.d.ts
+type LocaleProperties$1 = {
+  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 ../core/dist/types-YrrGRHBP.d.cts
+type InjectionType = 'automatic' | 'manual'; //#endregion
+//#region src/types.d.ts
+/**
+ * @deprecated Use {@link Content} instead.
+ */
+//#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 src/types-dir/types.d.ts
+/**
+ * TaggedElement is a React element with a GTProp property.
+ */
+/**
+ * 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)[];
+type FlattenedDictionary = {
+  [key: string]: 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;
+};
+/**
+ * @deprecated use {@link Dictionary}
+ */
+type DictionaryContent = string;
+/**
+ * @deprecated use {@link Dictionary}
+ */
+type DictionaryObject = {
+  [id: string]: DictionaryContent;
+};
+type LocalesDictionary = {
+  [locale: string]: DictionaryObject;
+};
+type CustomLoader = (locale: string) => Promise<unknown>;
+type RenderMethod = 'skeleton' | 'replace' | 'default';
+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,
+  injectionType
+}: Omit<VariableProps, 'variableName'> & {
+  locales: string[];
+}) => t.ReactNode;
+type _Message = {
+  message: string;
+  $id?: string;
+  $context?: string;
+  $maxChars?: number;
+  $_hash?: string;
+};
+type _Messages = _Message[]; //#endregion
+//#region src/types-dir/runtime.d.ts
+//#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$1;
+  reloadOnLocaleUpdate?: boolean;
+};
+type UseDetermineLocaleReturn = [string, (locale: string) => void]; //#endregion
+//#region src/provider/hooks/types.d.ts
+//#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$1;
+  modelProvider?: string;
+  enableI18n?: boolean;
+};
+//#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/react-context/types/config.d.ts
+type ClientProviderProps = {
+  children: React.ReactNode;
+  dictionary: Dictionary;
+  dictionaryTranslations: Dictionary;
+  translations: Translations;
+  locale: string;
+  locales: string[];
+  region?: string;
+  _versionId?: string;
+  dictionaryEnabled?: boolean;
+  defaultLocale: string;
+  translationRequired: boolean;
+  dialectTranslationRequired: boolean;
+  renderSettings: {
+    method: RenderMethod;
+    timeout?: number;
+  };
+  developmentApiEnabled: boolean;
+  projectId?: string;
+  devApiKey?: string;
+  runtimeUrl?: string | null;
+  gtServicesEnabled?: boolean;
+  localeCookieName?: string;
+  resetLocaleCookieName: string;
+  regionCookieName?: string;
+  customMapping?: CustomMapping;
+  environment: 'development' | 'production' | 'test';
+  reloadServer: () => void;
+};
+type GTProviderProps = {
+  children?: React.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.ReactNode;
+  customMapping?: CustomMapping;
+  modelProvider?: string;
+  enableI18n?: boolean;
+  enableI18nLoaded?: boolean;
+  /**
+   * @internal - internal use only
+   * TODO: this should have a separate export for internal use
+   */
+  useDetermineLocale?: (params: UseDetermineLocaleParams) => UseDetermineLocaleReturn;
+  reloadOnLocaleUpdate?: boolean;
+  [key: string]: unknown;
+};
+//#endregion
+export { type ClientProviderProps, type CustomLoader, Derive, type Dictionary, type DictionaryContent, type DictionaryEntry, type DictionaryObject, type DictionaryTranslationOptions, type Entry, type FlattenedDictionary, type GTFunctionType, type GTProp, type GTProviderProps, type InlineTranslationOptions, type LocalesDictionary, type MFunctionType, type MetaEntry as Metadata, type RenderMethod, type RenderVariable, type RuntimeTranslationOptions, Static, type TranslatedChildren, type Translations, type VariableProps, type _Message, type _Messages, addGTIdentifier, collectUntranslatedEntries, declareStatic, declareVar, decodeMsg, decodeOptions, decodeVars, defaultLocaleCookieName, defaultRegionCookieName, derive, flattenDictionary, getDefaultRenderSettings, getDictionaryEntry, getEntryAndMetadata, getPluralBranch, getSubtree, getSubtreeWithCreation, getVariableName, getVariableProps, gtFallback, injectAndMerge, injectEntry, injectFallbacks, injectHashes, injectTranslations, isDictionaryEntry, isValidDictionaryEntry, isVariableObject, mFallback, mergeDictionaries, msg, reactHasUse, renderDefaultChildren, renderSkeleton, renderTranslatedChildren, stripMetadataFromEntries, writeChildrenAsObjects };
+//# sourceMappingURL=internal.d.mts.map