@intlayer/react-intl 9.4.2 → 9.4.4

package/dist/types/FormattedComponents.d.ts

@@ -4,63 +4,62 @@ import { FormattedDate as FormattedDate$1, FormattedDateParts as FormattedDatePa
  * Drop-in for react-intl's `<FormattedDate>`.
  * Renders a locale-aware date string using `Intl.DateTimeFormat`.
  */
-declare const FormattedDate: typeof FormattedDate$1;
+export declare const FormattedDate: typeof FormattedDate$1;
 /**
  * Drop-in for react-intl's `<FormattedTime>`.
  * Renders a locale-aware time string using `Intl.DateTimeFormat`.
  */
-declare const FormattedTime: typeof FormattedTime$1;
+export declare const FormattedTime: typeof FormattedTime$1;
 /**
  * Drop-in for react-intl's `<FormattedNumber>`.
  * Renders a locale-aware number string using `Intl.NumberFormat`.
  */
-declare const FormattedNumber: typeof FormattedNumber$1;
+export declare const FormattedNumber: typeof FormattedNumber$1;
 /**
  * Drop-in for react-intl's `<FormattedList>`.
  * Renders a locale-aware list string using `Intl.ListFormat`.
  */
-declare const FormattedList: typeof FormattedList$1;
+export declare const FormattedList: typeof FormattedList$1;
 /**
  * Drop-in for react-intl's `<FormattedDisplayName>`.
  * Renders a locale-aware display name using `Intl.DisplayNames`.
  */
-declare const FormattedDisplayName: typeof FormattedDisplayName$1;
+export declare const FormattedDisplayName: typeof FormattedDisplayName$1;
 /**
  * Drop-in for react-intl's `<FormattedRelativeTime>`.
  * Renders a locale-aware relative time string using `Intl.RelativeTimeFormat`.
  * Auto-update (`updateIntervalInSeconds`) is not implemented.
  */
-declare const FormattedRelativeTime: typeof FormattedRelativeTime$1;
+export declare const FormattedRelativeTime: typeof FormattedRelativeTime$1;
 /**
  * Drop-in for react-intl's `<FormattedPlural>`.
  * Selects the matching plural slot using `Intl.PluralRules`.
  */
-declare const FormattedPlural: typeof FormattedPlural$1;
+export declare const FormattedPlural: typeof FormattedPlural$1;
 /**
  * Drop-in for react-intl's `<FormattedDateTimeRange>`.
  * Renders a locale-aware date range string using `Intl.DateTimeFormat#formatRange`.
  */
-declare const FormattedDateTimeRange: typeof FormattedDateTimeRange$1;
+export declare const FormattedDateTimeRange: typeof FormattedDateTimeRange$1;
 /**
  * Drop-in for react-intl's `<FormattedDateParts>`.
  * Renders format parts via a `children` render-prop.
  */
-declare const FormattedDateParts: typeof FormattedDateParts$1;
+export declare const FormattedDateParts: typeof FormattedDateParts$1;
 /**
  * Drop-in for react-intl's `<FormattedTimeParts>`.
  * Renders format parts via a `children` render-prop.
  */
-declare const FormattedTimeParts: typeof FormattedTimeParts$1;
+export declare const FormattedTimeParts: typeof FormattedTimeParts$1;
 /**
  * Drop-in for react-intl's `<FormattedNumberParts>`.
  * Renders format parts via a `children` render-prop.
  */
-declare const FormattedNumberParts: typeof FormattedNumberParts$1;
+export declare const FormattedNumberParts: typeof FormattedNumberParts$1;
 /**
  * Drop-in for react-intl's `<FormattedListParts>`.
  * Renders list format parts via a `children` render-prop.
  */
-declare const FormattedListParts: typeof FormattedListParts$1;
+export declare const FormattedListParts: typeof FormattedListParts$1;
 //#endregion
-export { FormattedDate, FormattedDateParts, FormattedDateTimeRange, FormattedDisplayName, FormattedList, FormattedListParts, FormattedNumber, FormattedNumberParts, FormattedPlural, FormattedRelativeTime, FormattedTime, FormattedTimeParts };
 //# sourceMappingURL=FormattedComponents.d.ts.map

package/dist/types/FormattedComponents.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FormattedComponents.d.ts","names":[],"sources":["../../src/FormattedComponents.tsx"],"mappings":";;;;;;cA8Ba,sBAAsB;;;;;cAkBtB,sBAAsB;;;;;cAkBtB,wBAAwB;;;;;cAkBxB,sBAAsB;;;;;cAatB,6BAA6B;;;;;;cAiB7B,8BAA8B;;;;;cAmB9B,wBAAwB;;;;;cAmCxB,+BAA+B;;;;;cAkB/B,2BAA2B;;;;;cAkB3B,2BAA2B;;;;;cAkB3B,6BAA6B;;;;;cAe7B,2BAA2B"}
+{"version":3,"file":"FormattedComponents.d.ts","names":[],"sources":["../../src/FormattedComponents.tsx"],"mappings":";;;;;;qBA8Ba,sBAAsB;;;;;qBAkBtB,sBAAsB;;;;;qBAkBtB,wBAAwB;;;;;qBAkBxB,sBAAsB;;;;;qBAatB,6BAA6B;;;;;;qBAiB7B,8BAA8B;;;;;qBAmB9B,wBAAwB;;;;;qBAmCxB,+BAA+B;;;;;qBAkB/B,2BAA2B;;;;;qBAkB3B,2BAA2B;;;;;qBAkB3B,6BAA6B;;;;;qBAe7B,2BAA2B"}

package/dist/types/FormattedMessage.d.ts

@@ -21,7 +21,6 @@ import { FormattedMessage as FormattedMessage$1 } from "react-intl";
  * />
  * ```
  */
-declare const FormattedMessage: typeof FormattedMessage$1;
+export declare const FormattedMessage: typeof FormattedMessage$1;
 //#endregion
-export { FormattedMessage };
 //# sourceMappingURL=FormattedMessage.d.ts.map

package/dist/types/FormattedMessage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FormattedMessage.d.ts","names":[],"sources":["../../src/FormattedMessage.tsx"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;cA2Ba,yBAAyB"}
+{"version":3,"file":"FormattedMessage.d.ts","names":[],"sources":["../../src/FormattedMessage.tsx"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;qBA2Ba,yBAAyB"}

package/dist/types/IntlProvider.d.ts

@@ -9,7 +9,6 @@ import { IntlProvider as IntlProvider$1 } from "react-intl";
  *
  * The `locale` prop is forwarded to `IntlayerClientProvider`.
  */
-declare const IntlProvider: typeof IntlProvider$1;
+export declare const IntlProvider: typeof IntlProvider$1;
 //#endregion
-export { IntlProvider };
 //# sourceMappingURL=IntlProvider.d.ts.map

package/dist/types/IntlProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"IntlProvider.d.ts","names":[],"sources":["../../src/IntlProvider.tsx"],"mappings":";;;;;;;;;;;cAqBa,qBAAqB"}
+{"version":3,"file":"IntlProvider.d.ts","names":[],"sources":["../../src/IntlProvider.tsx"],"mappings":";;;;;;;;;;;qBAqBa,qBAAqB"}

package/dist/types/context.d.ts

@@ -4,9 +4,8 @@ import { IntlShape } from "react-intl";
  * React context holding the active intlayer-backed `IntlShape` instance.
  * Populated by {@link IntlProvider}; consumed by {@link useIntl}.
  */
-declare const IntlContext: import("react").Context<IntlShape>;
+export declare const IntlContext: import("react").Context<IntlShape>;
 /** The raw `React.Provider<IntlShape>` — same as `IntlContext.Provider`. */
-declare const RawIntlProvider: import("react").Provider<IntlShape>;
+export declare const RawIntlProvider: import("react").Provider<IntlShape>;
 //#endregion
-export { IntlContext, RawIntlProvider };
 //# sourceMappingURL=context.d.ts.map

package/dist/types/context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"context.d.ts","names":[],"sources":["../../src/context.tsx"],"mappings":";;;;;;cAOa,6BAAW,QAAA;;cAKX,iCAAe,SAAA"}
+{"version":3,"file":"context.d.ts","names":[],"sources":["../../src/context.tsx"],"mappings":";;;;;;qBAOa,6BAAW,QAAA;;qBAKX,iCAAe,SAAA"}

package/dist/types/createIntl.d.ts

@@ -10,7 +10,7 @@ import { createIntl as createIntl$1, createIntlCache as createIntlCache$1 } from
  * @deprecated
  * Has no practical effect with intlayer — no formatter pooling is needed.
  */
-declare const createIntlCache: typeof createIntlCache$1;
+export declare const createIntlCache: typeof createIntlCache$1;
 /**
  * Drop-in for react-intl's `createIntl`.
  *
@@ -28,7 +28,6 @@ declare const createIntlCache: typeof createIntlCache$1;
  * intl.formatMessage({ id: 'home.title' });
  * ```
  */
-declare const createIntl: typeof createIntl$1;
+export declare const createIntl: typeof createIntl$1;
 //#endregion
-export { createIntl, createIntlCache };
 //# sourceMappingURL=createIntl.d.ts.map

package/dist/types/createIntl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createIntl.d.ts","names":[],"sources":["../../src/createIntl.ts"],"mappings":";;;;;;;;;;;;cAoBa,wBAAwB;;;;;;;;;;;;;;;;;;cA4BxB,mBAAmB"}
+{"version":3,"file":"createIntl.d.ts","names":[],"sources":["../../src/createIntl.ts"],"mappings":";;;;;;;;;;;;qBAoBa,wBAAwB;;;;;;;;;;;;;;;;;;qBA4BxB,mBAAmB"}

package/dist/types/createIntlObject.d.ts

@@ -12,7 +12,6 @@ import { LocalesValues } from "@intlayer/types/module_augmentation";
  * @param lookupOverride - Optional message lookup replacing the registry-based
  *   id resolution; used by the dictionary-bound `useDictionary` variant.
  */
-declare const createIntlObject: (locale: LocalesValues, lookupOverride?: (id: string) => unknown) => IntlShape;
+export declare const createIntlObject: (locale: LocalesValues, lookupOverride?: (id: string) => unknown) => IntlShape;
 //#endregion
-export { createIntlObject };
 //# sourceMappingURL=createIntlObject.d.ts.map

package/dist/types/createIntlObject.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createIntlObject.d.ts","names":[],"sources":["../../src/createIntlObject.tsx"],"mappings":";;;;;;;;;;;;;;cAqFa,mBAAgB,QACnB,eAAa,kBACH,2BACjB"}
+{"version":3,"file":"createIntlObject.d.ts","names":[],"sources":["../../src/createIntlObject.tsx"],"mappings":";;;;;;;;;;;;;;qBAqFa,mBAAgB,QACnB,eAAa,kBACH,2BACjB"}

package/dist/types/defineMessages.d.ts

@@ -6,12 +6,11 @@ import { defineMessage as defineMessage$1, defineMessages as defineMessages$1 }
  * Exists so that IDEs and the intlayer analyzer can locate message ids
  * at source-analysis time.
  */
-declare const defineMessages: typeof defineMessages$1;
+export declare const defineMessages: typeof defineMessages$1;
 /**
  * Drop-in for react-intl's `defineMessage`.
  * Identity function — returns the descriptor unchanged.
  */
-declare const defineMessage: typeof defineMessage$1;
+export declare const defineMessage: typeof defineMessage$1;
 //#endregion
-export { defineMessage, defineMessages };
 //# sourceMappingURL=defineMessages.d.ts.map

package/dist/types/defineMessages.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"defineMessages.d.ts","names":[],"sources":["../../src/defineMessages.ts"],"mappings":";;;;;;;;cAWa,uBAAuB;;;;;cAMvB,sBAAsB"}
+{"version":3,"file":"defineMessages.d.ts","names":[],"sources":["../../src/defineMessages.ts"],"mappings":";;;;;;;;qBAWa,uBAAuB;;;;;qBAMvB,sBAAsB"}

package/dist/types/dictionaryIntlShape.d.ts

@@ -19,19 +19,19 @@ type TranslatedValue<N extends DictionaryKeys, P> = ContentAtPath<N, P> extends
  * Ids accepted by a dictionary-bound intl object: the dictionary's dot-paths,
  * either relative (`'title'`) or absolute (`'home.title'`).
  */
-type DictionaryMessageIds<N extends DictionaryKeys> = ValidDotPathsFor<N> | `${N & string}.${ValidDotPathsFor<N> & string}`;
+export type DictionaryMessageIds<N extends DictionaryKeys> = ValidDotPathsFor<N> | `${N & string}.${ValidDotPathsFor<N> & string}`;
 /**
  * Resolves the translated value type for an id: the absolute form strips the
  * leading `<dictionaryKey>.` first, matching the runtime lookup.
  */
-type MessageValueForId<N extends DictionaryKeys, Id extends string> = Id extends `${N & string}.${infer RelativePath}` ? TranslatedValue<N, RelativePath> : TranslatedValue<N, Id>;
+export type MessageValueForId<N extends DictionaryKeys, Id extends string> = Id extends `${N & string}.${infer RelativePath}` ? TranslatedValue<N, RelativePath> : TranslatedValue<N, Id>;
 /**
  * `formatMessage` bound to dictionary `N`: ids are validated against the
  * dictionary's dot-paths and the return type is resolved from the content at
  * that path. With rich-text render functions in `values`, React nodes are
  * returned.
  */
-type TypedFormatMessage<N extends DictionaryKeys> = {
+export type TypedFormatMessage<N extends DictionaryKeys> = {
   <Id extends DictionaryMessageIds<N> & string>(descriptor: Omit<MessageDescriptor, 'id'> & {
     id: Id;
   }, values?: Record<string, PrimitiveType>): MessageValueForId<N, Id>;
@@ -44,10 +44,9 @@ type TypedFormatMessage<N extends DictionaryKeys> = {
  * `N`. Returned by the dictionary-bound `useDictionary` /
  * `useDictionaryDynamic` variants.
  */
-type DictionaryIntlShape<N extends DictionaryKeys> = Omit<IntlShape, 'formatMessage' | '$t'> & {
+export type DictionaryIntlShape<N extends DictionaryKeys> = Omit<IntlShape, 'formatMessage' | '$t'> & {
   formatMessage: TypedFormatMessage<N>;
   $t: TypedFormatMessage<N>;
 };
 //#endregion
-export { DictionaryIntlShape, DictionaryMessageIds, MessageValueForId, TypedFormatMessage };
 //# sourceMappingURL=dictionaryIntlShape.d.ts.map

package/dist/types/dictionaryIntlShape.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dictionaryIntlShape.d.ts","names":[],"sources":["../../src/dictionaryIntlShape.ts"],"mappings":";;;;;;;;;;KAUK,cAAc,UAAU,gBAAgB,KAAK,iBAAiB,GAAG;;;;;;KAOjE,gBAAgB,UAAU,gBAAgB,KAC7C,cAAc,GAAG,oBAAoB,cAAc,GAAG;;;;;KAM5C,qBAAqB,UAAU,kBACvC,iBAAiB,QACd,cAAc,iBAAiB;;;;;KAM1B,kBACV,UAAU,gBACV,qBACE,cAAc,oBAAoB,iBAClC,gBAAgB,GAAG,gBACnB,gBAAgB,GAAG;;;;;;;KAQX,mBAAmB,UAAU;GACtC,WAAW,qBAAqB,aAC/B,YAAY,KAAK;IAA6B,IAAI;KAClD,SAAS,eAAe,iBACvB,kBAAkB,GAAG;GACvB,WAAW,qBAAqB,aAC/B,YAAY,KAAK;IAA6B,IAAI;KAClD,SAAS,eAEP,YAAY,kBAAkB,QAAQ,cAAc,uBAE5C;;;;;;;KAQF,oBAAoB,UAAU,kBAAkB,KAC1D;EAGA,eAAe,mBAAmB;EAClC,IAAI,mBAAmB"}
+{"version":3,"file":"dictionaryIntlShape.d.ts","names":[],"sources":["../../src/dictionaryIntlShape.ts"],"mappings":";;;;;;;;;;KAUK,cAAc,UAAU,gBAAgB,KAAK,iBAAiB,GAAG;;;;;;KAOjE,gBAAgB,UAAU,gBAAgB,KAC7C,cAAc,GAAG,oBAAoB,cAAc,GAAG;;;;;YAM5C,qBAAqB,UAAU,kBACvC,iBAAiB,QACd,cAAc,iBAAiB;;;;;YAM1B,kBACV,UAAU,gBACV,qBACE,cAAc,oBAAoB,iBAClC,gBAAgB,GAAG,gBACnB,gBAAgB,GAAG;;;;;;;YAQX,mBAAmB,UAAU;GACtC,WAAW,qBAAqB,aAC/B,YAAY,KAAK;IAA6B,IAAI;KAClD,SAAS,eAAe,iBACvB,kBAAkB,GAAG;GACvB,WAAW,qBAAqB,aAC/B,YAAY,KAAK;IAA6B,IAAI;KAClD,SAAS,eAEP,YAAY,kBAAkB,QAAQ,cAAc,uBAE5C;;;;;;;YAQF,oBAAoB,UAAU,kBAAkB,KAC1D;EAGA,eAAe,mBAAmB;EAClC,IAAI,mBAAmB"}

package/dist/types/errors.d.ts

@@ -5,7 +5,7 @@
  * @deprecated These error codes are not raised by the intlayer compat adapter.
  * Exported for API compatibility only.
  */
-declare enum ReactIntlErrorCode {
+export declare enum ReactIntlErrorCode {
   FORMAT_ERROR = "FORMAT_ERROR",
   UNSUPPORTED_FORMATTER = "UNSUPPORTED_FORMATTER",
   INVALID_CONFIG = "INVALID_CONFIG",
@@ -17,40 +17,39 @@ declare enum ReactIntlErrorCode {
  *
  * @deprecated Not raised by the intlayer compat adapter. Exported for API compatibility only.
  */
-declare class ReactIntlError extends Error {
+export declare class ReactIntlError extends Error {
   readonly code: ReactIntlErrorCode;
   constructor(code: ReactIntlErrorCode, message: string);
 }
 /**
  * @deprecated Not raised by the intlayer compat adapter. Exported for API compatibility only.
  */
-declare class InvalidConfigError extends ReactIntlError {
+export declare class InvalidConfigError extends ReactIntlError {
   constructor(message: string);
 }
 /**
  * @deprecated Not raised by the intlayer compat adapter. Exported for API compatibility only.
  */
-declare class MessageFormatError extends ReactIntlError {
+export declare class MessageFormatError extends ReactIntlError {
   constructor(message: string);
 }
 /**
  * @deprecated Not raised by the intlayer compat adapter. Exported for API compatibility only.
  */
-declare class MissingDataError extends ReactIntlError {
+export declare class MissingDataError extends ReactIntlError {
   constructor(message: string);
 }
 /**
  * @deprecated Not raised by the intlayer compat adapter. Exported for API compatibility only.
  */
-declare class MissingTranslationError extends ReactIntlError {
+export declare class MissingTranslationError extends ReactIntlError {
   constructor(message: string);
 }
 /**
  * @deprecated Not raised by the intlayer compat adapter. Exported for API compatibility only.
  */
-declare class UnsupportedFormatterError extends ReactIntlError {
+export declare class UnsupportedFormatterError extends ReactIntlError {
   constructor(message: string);
 }
 //#endregion
-export { InvalidConfigError, MessageFormatError, MissingDataError, MissingTranslationError, ReactIntlError, ReactIntlErrorCode, UnsupportedFormatterError };
 //# sourceMappingURL=errors.d.ts.map

package/dist/types/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","names":[],"sources":["../../src/errors.ts"],"mappings":";;;;;;;aAMY;EACV;EACA;EACA;EACA;EACA;;;;;;;cAQW,uBAAuB;WAClB,MAAM;EAEtB,YAAY,MAAM,oBAAoB;;;;;cAU3B,2BAA2B;EACtC,YAAY;;;;;cASD,2BAA2B;EACtC,YAAY;;;;;cASD,yBAAyB;EACpC,YAAY;;;;;cASD,gCAAgC;EAC3C,YAAY;;;;;cASD,kCAAkC;EAC7C,YAAY"}
+{"version":3,"file":"errors.d.ts","names":[],"sources":["../../src/errors.ts"],"mappings":";;;;;;;oBAMY;EACV;EACA;EACA;EACA;EACA;;;;;;;qBAQW,uBAAuB;WAClB,MAAM;EAEtB,YAAY,MAAM,oBAAoB;;;;;qBAU3B,2BAA2B;EACtC,YAAY;;;;;qBASD,2BAA2B;EACtC,YAAY;;;;;qBASD,yBAAyB;EACpC,YAAY;;;;;qBASD,gCAAgC;EAC3C,YAAY;;;;;qBASD,kCAAkC;EAC7C,YAAY"}

package/dist/types/plugin/index.d.ts

@@ -16,7 +16,7 @@ import { intlayer } from "vite-intlayer";
  * });
  * ```
  */
-declare const reactIntlVitePlugin: (options?: Parameters<typeof intlayer>[0]) => PluginOption[];
+export declare const reactIntlVitePlugin: (options?: Parameters<typeof intlayer>[0]) => PluginOption[];
 //#endregion
-export { reactIntlVitePlugin as default, reactIntlVitePlugin };
+export { reactIntlVitePlugin as default };
 //# sourceMappingURL=index.d.ts.map

package/dist/types/plugin/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/plugin/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;cAwBa,sBAAmB,UACpB,kBAAkB,iBAC3B"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/plugin/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;qBAwBa,sBAAmB,UACpB,kBAAkB,iBAC3B"}

package/dist/types/typedMessageIds.d.ts

@@ -6,7 +6,7 @@ import { ValidDotPathsFor } from "@intlayer/core/transpiler";
  * first segment designates the intlayer dictionary. Falls back to `string`
  * when no dictionary registry is declared (e.g. before the first build).
  */
-type RootMessageIds = string extends DictionaryKeys ? string : { [K in DictionaryKeys]: `${K & string}.${ValidDotPathsFor<K> & string}`; }[DictionaryKeys];
+export type RootMessageIds = string extends DictionaryKeys ? string : { [K in DictionaryKeys]: `${K & string}.${ValidDotPathsFor<K> & string}`; }[DictionaryKeys];
 declare global {
   namespace FormatjsIntl {
     interface Message {
@@ -21,5 +21,4 @@ declare global {
   }
 }
 //#endregion
-export { RootMessageIds };
 //# sourceMappingURL=typedMessageIds.d.ts.map

package/dist/types/typedMessageIds.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"typedMessageIds.d.ts","names":[],"sources":["../../src/typedMessageIds.ts"],"mappings":";;;;;;;;KAQY,gCAAgC,6BAGrC,KAAK,oBAAoB,cAAc,iBAAiB,iBACzD;QAEE;YACI;cACE;;;;;;;MAOR,KAAK"}
+{"version":3,"file":"typedMessageIds.d.ts","names":[],"sources":["../../src/typedMessageIds.ts"],"mappings":";;;;;;;;YAQY,gCAAgC,6BAGrC,KAAK,oBAAoB,cAAc,iBAAiB,iBACzD;QAEE;YACI;cACE;;;;;;;MAOR,KAAK"}

package/dist/types/useDictionary.d.ts

@@ -10,7 +10,7 @@ import { Dictionary } from "@intlayer/types/dictionary";
  * supplied directly, the leading `<dictionaryKey>.` is stripped so both the
  * absolute (`'home.title'`) and relative (`'title'`) forms resolve.
  */
-declare const createDictionaryLookup: (dictionaryKey: string, content: unknown) => (id: string) => unknown;
+export declare const createDictionaryLookup: (dictionaryKey: string, content: unknown) => (id: string) => unknown;
 /**
  * Dictionary-accepting variant of `useIntl`.
  *
@@ -24,7 +24,6 @@ declare const createDictionaryLookup: (dictionaryKey: string, content: unknown)
  * const intl = useDictionary(_abc);
  * intl.formatMessage({ id: 'home.title' }); // or { id: 'title' } — both typed
  */
-declare const useDictionary: <T extends Dictionary>(dictionary: T) => DictionaryIntlShape<T['key'] & DictionaryKeys>;
+export declare const useDictionary: <T extends Dictionary>(dictionary: T) => DictionaryIntlShape<T['key'] & DictionaryKeys>;
 //#endregion
-export { createDictionaryLookup, useDictionary };
 //# sourceMappingURL=useDictionary.d.ts.map

package/dist/types/useDictionary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDictionary.d.ts","names":[],"sources":["../../src/useDictionary.ts"],"mappings":";;;;;;;;;;;;cAqBa,yBAAsB,uBACX,sBAAkB;;;;;;;;;;;;;;cAuB7B,gBAAiB,UAAU,YAAU,YACpC,MACX,oBAAoB,WAAW"}
+{"version":3,"file":"useDictionary.d.ts","names":[],"sources":["../../src/useDictionary.ts"],"mappings":";;;;;;;;;;;;qBAqBa,yBAAsB,uBACX,sBAAkB;;;;;;;;;;;;;;qBAuB7B,gBAAiB,UAAU,YAAU,YACpC,MACX,oBAAoB,WAAW"}

package/dist/types/useDictionaryDynamic.d.ts

@@ -8,7 +8,6 @@ import { Dictionary } from "@intlayer/types/dictionary";
  * Counterpart to {@link useDictionary} for dictionaries imported lazily per
  * locale. Used internally by the build-time optimization.
  */
-declare const useDictionaryDynamic: <const T extends Dictionary, const K extends DictionaryKeys>(dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>, key: K) => DictionaryIntlShape<K>;
+export declare const useDictionaryDynamic: <const T extends Dictionary, const K extends DictionaryKeys>(dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>, key: K) => DictionaryIntlShape<K>;
 //#endregion
-export { useDictionaryDynamic };
 //# sourceMappingURL=useDictionaryDynamic.d.ts.map

package/dist/types/useDictionaryDynamic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDictionaryDynamic.d.ts","names":[],"sources":["../../src/useDictionaryDynamic.ts"],"mappings":";;;;;;;;;;cAuBa,6BACL,UAAU,kBACV,UAAU,gBAAc,mBAEX,0BAA0B,QAAQ,KAAG,KACnD,MACJ,oBAAoB"}
+{"version":3,"file":"useDictionaryDynamic.d.ts","names":[],"sources":["../../src/useDictionaryDynamic.ts"],"mappings":";;;;;;;;;;qBAuBa,6BACL,UAAU,kBACV,UAAU,gBAAc,mBAEX,0BAA0B,QAAQ,KAAG,KACnD,MACJ,oBAAoB"}

package/dist/types/useIntl.d.ts

@@ -14,7 +14,6 @@ import { useIntl as useIntl$1 } from "react-intl";
  * intl.formatNumber(42, { style: 'currency', currency: 'USD' });
  * ```
  */
-declare const useIntl: typeof useIntl$1;
+export declare const useIntl: typeof useIntl$1;
 //#endregion
-export { useIntl };
 //# sourceMappingURL=useIntl.d.ts.map

package/dist/types/useIntl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useIntl.d.ts","names":[],"sources":["../../src/useIntl.ts"],"mappings":";;;;;;;;;;;;;;;;cAuBa,gBAAgB"}
+{"version":3,"file":"useIntl.d.ts","names":[],"sources":["../../src/useIntl.ts"],"mappings":";;;;;;;;;;;;;;;;qBAuBa,gBAAgB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intlayer/react-intl",
-  "version": "9.4.2",
+  "version": "9.4.4",
   "private": false,
   "description": "react-intl API adapter for intlayer — drop-in compatibility layer",
   "keywords": [
@@ -74,13 +74,13 @@
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "dependencies": {
-    "@intlayer/config": "9.4.2",
-    "@intlayer/core": "9.4.2",
-    "@intlayer/dictionaries-entry": "9.4.2",
-    "@intlayer/engine": "9.4.2",
-    "@intlayer/types": "9.4.2",
-    "react-intlayer": "9.4.2",
-    "vite-intlayer": "9.4.2"
+    "@intlayer/config": "9.4.4",
+    "@intlayer/core": "9.4.4",
+    "@intlayer/dictionaries-entry": "9.4.4",
+    "@intlayer/engine": "9.4.4",
+    "@intlayer/types": "9.4.4",
+    "react-intlayer": "9.4.4",
+    "vite-intlayer": "9.4.4"
   },
   "devDependencies": {
     "@types/node": "26.4.1",
@@ -90,10 +90,10 @@
     "@utils/tsdown-config": "1.0.4",
     "react-intl": "^10.1.18",
     "rimraf": "6.1.3",
-    "tsdown": "0.22.14",
+    "tsdown": "0.23.0",
     "typescript": "7.0.2",
     "vite": "8.2.2",
-    "vitest": "4.1.11"
+    "vitest": "5.0.0"
   },
   "peerDependencies": {
     "react": ">=16.0.0",