@intlayer/core 9.4.3 → 9.5.0

package/dist/types/dictionaryManipulator/editDictionaryByKeyPath.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"editDictionaryByKeyPath.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/editDictionaryByKeyPath.ts"],"mappings":";;;cAMa,0BAAuB,mBACf,aAAW,SACrB,WAAS,UACR,gBACT"}
+{"version":3,"file":"editDictionaryByKeyPath.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/editDictionaryByKeyPath.ts"],"mappings":";;;qBAMa,0BAAuB,mBACf,aAAW,SACrB,WAAS,UACR,gBACT"}

package/dist/types/dictionaryManipulator/getContentNodeByKeyPath.d.ts

@@ -2,7 +2,6 @@ import { ContentNode } from "@intlayer/types/dictionary";
 import { LocalesValues } from "@intlayer/types/module_augmentation";
 import { KeyPath } from "@intlayer/types/keyPath";
 //#region src/dictionaryManipulator/getContentNodeByKeyPath.d.ts
-declare const getContentNodeByKeyPath: (dictionaryContent: ContentNode, keyPath: KeyPath[], fallbackLocale?: LocalesValues) => ContentNode;
+export declare const getContentNodeByKeyPath: (dictionaryContent: ContentNode, keyPath: KeyPath[], fallbackLocale?: LocalesValues) => ContentNode;
 //#endregion
-export { getContentNodeByKeyPath };
 //# sourceMappingURL=getContentNodeByKeyPath.d.ts.map

package/dist/types/dictionaryManipulator/getContentNodeByKeyPath.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getContentNodeByKeyPath.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/getContentNodeByKeyPath.ts"],"mappings":";;;;cAKa,0BAAuB,mBACf,aAAW,SACrB,WAAS,iBACD,kBAChB"}
+{"version":3,"file":"getContentNodeByKeyPath.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/getContentNodeByKeyPath.ts"],"mappings":";;;;qBAKa,0BAAuB,mBACf,aAAW,SACrB,WAAS,iBACD,kBAChB"}

package/dist/types/dictionaryManipulator/getDefaultNode.d.ts

@@ -2,7 +2,6 @@ import { ContentNode } from "@intlayer/types/dictionary";
 import { LocalesValues } from "@intlayer/types/module_augmentation";
 import { NodeType } from "@intlayer/types/nodeType";
 //#region src/dictionaryManipulator/getDefaultNode.d.ts
-declare const getDefaultNode: (nodeType: NodeType, locales: LocalesValues[], content?: ContentNode) => ContentNode;
+export declare const getDefaultNode: (nodeType: NodeType, locales: LocalesValues[], content?: ContentNode) => ContentNode;
 //#endregion
-export { getDefaultNode };
 //# sourceMappingURL=getDefaultNode.d.ts.map

package/dist/types/dictionaryManipulator/getDefaultNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getDefaultNode.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/getDefaultNode.ts"],"mappings":";;;;cAMa,iBAAc,UACf,UAAQ,SACT,iBAAe,UACd,gBACT"}
+{"version":3,"file":"getDefaultNode.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/getDefaultNode.ts"],"mappings":";;;;qBAMa,iBAAc,UACf,UAAQ,SACT,iBAAe,UACd,gBACT"}

package/dist/types/dictionaryManipulator/getEmptyNode.d.ts

@@ -1,6 +1,5 @@
 import { ContentNode } from "@intlayer/types/dictionary";
 //#region src/dictionaryManipulator/getEmptyNode.d.ts
-declare const getEmptyNode: (section: ContentNode) => ContentNode;
+export declare const getEmptyNode: (section: ContentNode) => ContentNode;
 //#endregion
-export { getEmptyNode };
 //# sourceMappingURL=getEmptyNode.d.ts.map

package/dist/types/dictionaryManipulator/getEmptyNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getEmptyNode.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/getEmptyNode.ts"],"mappings":";;cAIa,eAAY,SAAa,gBAAc"}
+{"version":3,"file":"getEmptyNode.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/getEmptyNode.ts"],"mappings":";;qBAIa,eAAY,SAAa,gBAAc"}

package/dist/types/dictionaryManipulator/getNestedDictionaryReferences.d.ts

@@ -7,7 +7,7 @@
  * (`nest('common')` without a path), so no field of that dictionary may be
  * dropped.
  */
-type NestedFieldReferences = Set<string> | 'all';
+export type NestedFieldReferences = Set<string> | 'all';
 /**
  * Walks a dictionary tree and collects every dictionary referenced through a
  * `nest()` node, together with the top-level fields those references read.
@@ -26,14 +26,14 @@ type NestedFieldReferences = Set<string> | 'all';
  * // Map { 'common' => Set { 'period' } }
  * ```
  */
-declare const getNestedDictionaryReferences: (dictionaries: Iterable<unknown>) => Map<string, NestedFieldReferences>;
+export declare const getNestedDictionaryReferences: (dictionaries: Iterable<unknown>) => Map<string, NestedFieldReferences>;
 /**
  * Keys of every dictionary referenced through a `nest()` node.
  *
  * @param dictionaries - Dictionary objects (or any content subtree) to scan.
  * @returns Set of nest-target dictionary keys.
  */
-declare const getNestedDictionaryKeys: (dictionaries: Iterable<unknown>) => Set<string>;
+export declare const getNestedDictionaryKeys: (dictionaries: Iterable<unknown>) => Set<string>;
 /**
  * Builds the `nest()` dependency graph of a set of dictionaries: for each
  * dictionary key, the keys of every dictionary it needs in order to resolve its
@@ -56,7 +56,6 @@ declare const getNestedDictionaryKeys: (dictionaries: Iterable<unknown>) => Set<
  * // Map { 'dashboard' => Set { 'common', 'labels' }, 'common' => Set { 'labels' } }
  * ```
  */
-declare const getNestedDictionaryGraph: (dictionaries: Iterable<unknown>) => Map<string, Set<string>>;
+export declare const getNestedDictionaryGraph: (dictionaries: Iterable<unknown>) => Map<string, Set<string>>;
 //#endregion
-export { NestedFieldReferences, getNestedDictionaryGraph, getNestedDictionaryKeys, getNestedDictionaryReferences };
 //# sourceMappingURL=getNestedDictionaryReferences.d.ts.map

package/dist/types/dictionaryManipulator/getNestedDictionaryReferences.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getNestedDictionaryReferences.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/getNestedDictionaryReferences.ts"],"mappings":";;;;;;;;;KAUY,wBAAwB;;;;;;;;;;;;;;;;;;;cAkEvB,gCAA6B,cAC1B,sBACb,YAAY;;;;;;;cAkDF,0BAAuB,cACpB,sBACb;;;;;;;;;;;;;;;;;;;;;;;cAyDU,2BAAwB,cACrB,sBACb,YAAY"}
+{"version":3,"file":"getNestedDictionaryReferences.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/getNestedDictionaryReferences.ts"],"mappings":";;;;;;;;;YAUY,wBAAwB;;;;;;;;;;;;;;;;;;;qBAkEvB,gCAA6B,cAC1B,sBACb,YAAY;;;;;;;qBAkDF,0BAAuB,cACpB,sBACb;;;;;;;;;;;;;;;;;;;;;;;qBAyDU,2BAAwB,cACrB,sBACb,YAAY"}

package/dist/types/dictionaryManipulator/getNodeChildren.d.ts

@@ -1,6 +1,5 @@
 import { ContentNode } from "@intlayer/types/dictionary";
 //#region src/dictionaryManipulator/getNodeChildren.d.ts
-declare const getNodeChildren: (section: ContentNode) => ContentNode;
+export declare const getNodeChildren: (section: ContentNode) => ContentNode;
 //#endregion
-export { getNodeChildren };
 //# sourceMappingURL=getNodeChildren.d.ts.map

package/dist/types/dictionaryManipulator/getNodeChildren.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getNodeChildren.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/getNodeChildren.ts"],"mappings":";;cAIa,kBAAe,SAAa,gBAAc"}
+{"version":3,"file":"getNodeChildren.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/getNodeChildren.ts"],"mappings":";;qBAIa,kBAAe,SAAa,gBAAc"}

package/dist/types/dictionaryManipulator/getNodeType.d.ts

@@ -1,7 +1,6 @@
 import { ContentNode } from "@intlayer/types/dictionary";
 import { NodeType } from "@intlayer/types/nodeType";
 //#region src/dictionaryManipulator/getNodeType.d.ts
-declare const getNodeType: (content: ContentNode) => NodeType;
+export declare const getNodeType: (content: ContentNode) => NodeType;
 //#endregion
-export { getNodeType };
 //# sourceMappingURL=getNodeType.d.ts.map

package/dist/types/dictionaryManipulator/getNodeType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getNodeType.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/getNodeType.ts"],"mappings":";;;cAsDa,cAAW,SAAa,gBAAc"}
+{"version":3,"file":"getNodeType.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/getNodeType.ts"],"mappings":";;;qBAsDa,cAAW,SAAa,gBAAc"}

package/dist/types/dictionaryManipulator/mergeDictionaries.d.ts

@@ -1,6 +1,5 @@
 import { Dictionary } from "@intlayer/types/dictionary";
 //#region src/dictionaryManipulator/mergeDictionaries.d.ts
-declare const mergeDictionaries: (dictionaries: Dictionary[]) => Dictionary;
+export declare const mergeDictionaries: (dictionaries: Dictionary[]) => Dictionary;
 //#endregion
-export { mergeDictionaries };
 //# sourceMappingURL=mergeDictionaries.d.ts.map

package/dist/types/dictionaryManipulator/mergeDictionaries.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mergeDictionaries.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/mergeDictionaries.ts"],"mappings":";;cAqKa,oBAAiB,cAAkB,iBAAe"}
+{"version":3,"file":"mergeDictionaries.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/mergeDictionaries.ts"],"mappings":";;qBAqKa,oBAAiB,cAAkB,iBAAe"}

package/dist/types/dictionaryManipulator/mergeQualifiedDictionaries.d.ts

@@ -18,7 +18,6 @@ import { Dictionary, QualifiedDictionaryGroup } from "@intlayer/types/dictionary
  * Every qualified entry must declare ALL dimensions of the group; an entry that
  * declares only a subset is ambiguous and is rejected with an error log.
  */
-declare const mergeQualifiedDictionaries: (dictionaries: Dictionary[]) => Dictionary | QualifiedDictionaryGroup;
+export declare const mergeQualifiedDictionaries: (dictionaries: Dictionary[]) => Dictionary | QualifiedDictionaryGroup;
 //#endregion
-export { mergeQualifiedDictionaries };
 //# sourceMappingURL=mergeQualifiedDictionaries.d.ts.map

package/dist/types/dictionaryManipulator/mergeQualifiedDictionaries.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mergeQualifiedDictionaries.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/mergeQualifiedDictionaries.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;cAoCa,6BAA0B,cACvB,iBACb,aAAa"}
+{"version":3,"file":"mergeQualifiedDictionaries.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/mergeQualifiedDictionaries.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;qBAoCa,6BAA0B,cACvB,iBACb,aAAa"}

package/dist/types/dictionaryManipulator/normalizeDictionary.d.ts

@@ -1,8 +1,7 @@
 import { Dictionary } from "@intlayer/types/dictionary";
 import { IntlayerConfig } from "@intlayer/types/config";
 //#region src/dictionaryManipulator/normalizeDictionary.d.ts
-declare const normalizeDictionary: (dictionary: Dictionary, configuration: IntlayerConfig) => Dictionary;
-declare const normalizeDictionaries: (dictionaries: Dictionary[], configuration: IntlayerConfig) => Dictionary[];
+export declare const normalizeDictionary: (dictionary: Dictionary, configuration: IntlayerConfig) => Dictionary;
+export declare const normalizeDictionaries: (dictionaries: Dictionary[], configuration: IntlayerConfig) => Dictionary[];
 //#endregion
-export { normalizeDictionaries, normalizeDictionary };
 //# sourceMappingURL=normalizeDictionary.d.ts.map

package/dist/types/dictionaryManipulator/normalizeDictionary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"normalizeDictionary.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/normalizeDictionary.ts"],"mappings":";;;cAOa,sBAAmB,YAClB,YAAU,eACP,mBACd;cAmCU,wBAAqB,cAClB,cAAY,eACX,mBACd"}
+{"version":3,"file":"normalizeDictionary.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/normalizeDictionary.ts"],"mappings":";;;qBAOa,sBAAmB,YAClB,YAAU,eACP,mBACd;qBAmCU,wBAAqB,cAClB,cAAY,eACX,mBACd"}

package/dist/types/dictionaryManipulator/orderDictionaries.d.ts

@@ -7,11 +7,10 @@ import { Dictionary } from "@intlayer/types/dictionary";
  * @param priorityStrategy - The priority strategy ('local_first' or 'distant_first')
  * @returns Ordered array of dictionaries
  */
-declare const orderDictionaries: (dictionaries: Dictionary[], config?: {
+export declare const orderDictionaries: (dictionaries: Dictionary[], config?: {
   editor: {
     dictionaryPriorityStrategy: 'local_first' | 'distant_first';
   };
 }) => Dictionary[];
 //#endregion
-export { orderDictionaries };
 //# sourceMappingURL=orderDictionaries.d.ts.map

package/dist/types/dictionaryManipulator/orderDictionaries.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"orderDictionaries.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/orderDictionaries.ts"],"mappings":";;;;;;;;;cAUa,oBAAiB,cACd,cAAY;EAExB;IACE;;MAGH"}
+{"version":3,"file":"orderDictionaries.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/orderDictionaries.ts"],"mappings":";;;;;;;;;qBAUa,oBAAiB,cACd,cAAY;EAExB;IACE;;MAGH"}

package/dist/types/dictionaryManipulator/plainDynamicLoader.d.ts

@@ -5,11 +5,11 @@ import { LocalesValues } from "@intlayer/types/module_augmentation";
  * Default export shape of a generated dynamic entry point for a plain (non
  * qualified) key: one lazy chunk loader per emitted locale.
  */
-type PlainDynamicLoaderMap<T extends Dictionary = Dictionary> = {
+export type PlainDynamicLoaderMap<T extends Dictionary = Dictionary> = {
   [locale: string]: (() => Promise<T>) | undefined;
 };
 /** A chunk loader together with the locale it was emitted for. */
-type ResolvedDynamicLoader<T extends Dictionary = Dictionary> = {
+export type ResolvedDynamicLoader<T extends Dictionary = Dictionary> = {
   /**
    * Locale the returned loader actually serves, which differs from the
    * requested one whenever the fallback chain was walked.
@@ -31,7 +31,7 @@ type ResolvedDynamicLoader<T extends Dictionary = Dictionary> = {
  * @returns The loader to invoke and the locale its chunk holds, or `undefined`
  *          when the map holds no chunk for the locale nor for any fallback.
  */
-declare const findPlainDynamicLoader: <T extends Dictionary>(loaderMap: PlainDynamicLoaderMap<T>, locale: LocalesValues) => ResolvedDynamicLoader<T> | undefined;
+export declare const findPlainDynamicLoader: <T extends Dictionary>(loaderMap: PlainDynamicLoaderMap<T>, locale: LocalesValues) => ResolvedDynamicLoader<T> | undefined;
 /**
  * {@link findPlainDynamicLoader}, for callers that cannot render without a
  * chunk and would otherwise fail on an `undefined` loader with an error naming
@@ -44,7 +44,6 @@ declare const findPlainDynamicLoader: <T extends Dictionary>(loaderMap: PlainDyn
  * @throws When neither the locale nor any of its fallbacks has a chunk, which
  *         only happens on a malformed or empty entry point.
  */
-declare const resolvePlainDynamicLoader: <T extends Dictionary>(loaderMap: PlainDynamicLoaderMap<T>, key: string, locale: LocalesValues) => ResolvedDynamicLoader<T>;
+export declare const resolvePlainDynamicLoader: <T extends Dictionary>(loaderMap: PlainDynamicLoaderMap<T>, key: string, locale: LocalesValues) => ResolvedDynamicLoader<T>;
 //#endregion
-export { PlainDynamicLoaderMap, ResolvedDynamicLoader, findPlainDynamicLoader, resolvePlainDynamicLoader };
 //# sourceMappingURL=plainDynamicLoader.d.ts.map

package/dist/types/dictionaryManipulator/plainDynamicLoader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plainDynamicLoader.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/plainDynamicLoader.ts"],"mappings":";;;;;;;KAUY,sBAAsB,UAAU,aAAa;GACtD,wBAAwB,QAAQ;;;KAIvB,sBAAsB,UAAU,aAAa;;;;;EAKvD,QAAQ;EACR,cAAc,QAAQ;;;;;;;;;;;;;;;;cA4CX,yBAA0B,UAAU,YAAU,WAC9C,sBAAsB,IAAE,QAC3B,kBACP,sBAAsB;;;;;;;;;;;;;cAgCZ,4BAA6B,UAAU,YAAU,WACjD,sBAAsB,IAAE,aACxB,QACH,kBACP,sBAAsB"}
+{"version":3,"file":"plainDynamicLoader.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/plainDynamicLoader.ts"],"mappings":";;;;;;;YAUY,sBAAsB,UAAU,aAAa;GACtD,wBAAwB,QAAQ;;;YAIvB,sBAAsB,UAAU,aAAa;;;;;EAKvD,QAAQ;EACR,cAAc,QAAQ;;;;;;;;;;;;;;;;qBA4CX,yBAA0B,UAAU,YAAU,WAC9C,sBAAsB,IAAE,QAC3B,kBACP,sBAAsB;;;;;;;;;;;;;qBAgCZ,4BAA6B,UAAU,YAAU,WACjD,sBAAsB,IAAE,aACxB,QACH,kBACP,sBAAsB"}

package/dist/types/dictionaryManipulator/preloadedDynamicLoader.d.ts

@@ -10,12 +10,12 @@ import { PRELOADED_DYNAMIC_KEY } from "@intlayer/config/defaultValues";
  * (a client-side locale switch, or a resolution the provider overrode) falls
  * back to loading rather than serving content in the wrong language.
  */
-type PreloadedDynamicEntry = {
+export type PreloadedDynamicEntry = {
   locale: LocalesValues;
   dictionary: Dictionary;
 };
 /** A plain dynamic loader map that may carry a preloaded entry. */
-type PreloadableDynamicLoaderMap = {
+export type PreloadableDynamicLoaderMap = {
   [PRELOADED_DYNAMIC_KEY]?: PreloadedDynamicEntry;
 };
 /**
@@ -32,7 +32,7 @@ type PreloadableDynamicLoaderMap = {
  * @param locale - Locale the caller is about to render.
  * @returns The dictionary when it was preloaded for `locale`, else `undefined`.
  */
-declare const getPreloadedDictionary: (loaderMap: unknown, locale: LocalesValues) => Dictionary | undefined;
+export declare const getPreloadedDictionary: (loaderMap: unknown, locale: LocalesValues) => Dictionary | undefined;
 //#endregion
-export { PRELOADED_DYNAMIC_KEY, PreloadableDynamicLoaderMap, PreloadedDynamicEntry, getPreloadedDictionary };
+export { PRELOADED_DYNAMIC_KEY };
 //# sourceMappingURL=preloadedDynamicLoader.d.ts.map

package/dist/types/dictionaryManipulator/preloadedDynamicLoader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"preloadedDynamicLoader.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/preloadedDynamicLoader.ts"],"mappings":";;;;;;;;;;;;KAoBY;EACV,QAAQ;EACR,YAAY;;;KAIF;GACT,yBAAyB;;;;;;;;;;;;;;;;cAiBf,yBAAsB,oBACf,QACV,kBACP"}
+{"version":3,"file":"preloadedDynamicLoader.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/preloadedDynamicLoader.ts"],"mappings":";;;;;;;;;;;;YAoBY;EACV,QAAQ;EACR,YAAY;;;YAIF;GACT,yBAAyB;;;;;;;;;;;;;;;;qBAiBf,yBAAsB,oBACf,QACV,kBACP"}

package/dist/types/dictionaryManipulator/qualifiedDictionary.d.ts

@@ -1,17 +1,17 @@
-import { Dictionary, DictionarySelector, DictionaryVariantChain, DictionaryVariantValue, ProviderVariant, QualifiedDictionaryGroup } from "@intlayer/types/dictionary";
+import { Dictionary, DictionarySelector, DictionaryVariantChain, DictionaryVariantValue, ProviderVariantBase, QualifiedDictionaryGroup } from "@intlayer/types/dictionary";
 import { LocalesValues } from "@intlayer/types/module_augmentation";
 //#region src/dictionaryManipulator/qualifiedDictionary.d.ts
 /**
  * Separator joining per-dimension ids into a composite entry id. Also used as
  * the chunk path separator in dynamic mode.
  */
-declare const COMPOSITE_ID_SEPARATOR = "/";
+export declare const COMPOSITE_ID_SEPARATOR = "/";
 /**
  * Identity of the implicit fallback variant. A selector that pins no variant
  * resolves to it, and a variant that declares no entry of its own falls back to
  * it — so a key only has to ship the entries that actually differ.
  */
-declare const DEFAULT_VARIANT_ID = "default";
+export declare const DEFAULT_VARIANT_ID = "default";
 /**
  * Canonical serialization of a single variant value into its identity string —
  * the variant segment of a composite id, the chunk directory name in dynamic
@@ -30,7 +30,7 @@ declare const DEFAULT_VARIANT_ID = "default";
  * Two variants resolve to the same entry iff their serializations are equal, so
  * an object variant in a selector must equal the one declared on the dictionary.
  */
-declare const serializeVariant: (variant: DictionaryVariantValue | undefined) => string;
+export declare const serializeVariant: (variant: DictionaryVariantValue | undefined) => string;
 /**
  * Serializes the variant coordinate of a selector into the ordered list of
  * candidate ids to try, so a single value and a preference chain share one code
@@ -43,7 +43,7 @@ declare const serializeVariant: (variant: DictionaryVariantValue | undefined) =>
  * An empty chain is treated as "no variant pinned" (`['default']`) rather than
  * as an unsatisfiable request.
  */
-declare const serializeVariantChain: (variant: DictionaryVariantChain | undefined) => string[];
+export declare const serializeVariantChain: (variant: DictionaryVariantChain | undefined) => string[];
 /**
  * Resolves the variant id a selector actually targets among the ids a key
  * declares — the sparse-override fallback.
@@ -59,13 +59,13 @@ declare const serializeVariantChain: (variant: DictionaryVariantChain | undefine
  *                              list).
  * @param isVariantIdDeclared - Whether the key declares an entry for an id.
  */
-declare const resolveEffectiveVariantId: (requestedVariantIds: string[], isVariantIdDeclared: (variantId: string) => boolean) => string;
+export declare const resolveEffectiveVariantId: (requestedVariantIds: string[], isVariantIdDeclared: (variantId: string) => boolean) => string;
 /**
  * Type guard discriminating a `QualifiedDictionaryGroup` (merge output of a
  * qualified key) from a plain `Dictionary`. Both carry a `content` field; only
  * the group declares `qualifierTypes`, which is therefore the discriminator.
  */
-declare const isQualifiedDictionaryGroup: (value: unknown) => value is QualifiedDictionaryGroup;
+export declare const isQualifiedDictionaryGroup: (value: unknown) => value is QualifiedDictionaryGroup;
 /**
  * Reconstructs a resolvable {@link Dictionary} from a single entry of a
  * qualified group: the content node stored under its composite id, plus the
@@ -77,7 +77,7 @@ declare const isQualifiedDictionaryGroup: (value: unknown) => value is Qualified
  * its serialized (encoded) form, e.g. `'id=abc&userId=123'` — matching happens
  * on the composite id segments, never on this reconstructed field.
  */
-declare const reconstructQualifiedEntry: (group: QualifiedDictionaryGroup, compositeId: string) => Dictionary;
+export declare const reconstructQualifiedEntry: (group: QualifiedDictionaryGroup, compositeId: string) => Dictionary;
 /**
  * Resolves a dictionary (or qualified dictionary group) against a selector,
  * across every declared dimension.
@@ -93,12 +93,12 @@ declare const reconstructQualifiedEntry: (group: QualifiedDictionaryGroup, compo
  * Dimensions compose: e.g. a variant × item key with `{ variant: 'promo' }`
  * returns every promo item as an array; adding `{ item: 2 }` narrows to one.
  */
-declare const resolveQualifiedDictionary: (dictionaryOrGroup: Dictionary | QualifiedDictionaryGroup, selector?: DictionarySelector) => Dictionary | Dictionary[] | null;
+export declare const resolveQualifiedDictionary: (dictionaryOrGroup: Dictionary | QualifiedDictionaryGroup, selector?: DictionarySelector) => Dictionary | Dictionary[] | null;
 /**
  * Splits the second argument of `getIntlayer` / `getDictionary` into the
  * effective locale and the selector object (if any).
  */
-declare const parseDictionarySelector: <L extends LocalesValues>(localeOrSelector?: L | DictionarySelector) => {
+export declare const parseDictionarySelector: <L extends LocalesValues>(localeOrSelector?: L | DictionarySelector) => {
   locale?: L;
   selector?: DictionarySelector;
 };
@@ -117,7 +117,7 @@ declare const parseDictionarySelector: <L extends LocalesValues>(localeOrSelecto
  * @param providerVariant - The `variant` prop of the surrounding provider.
  * @param dictionaryKey - The key being read.
  */
-declare const resolveProviderVariant: (providerVariant: ProviderVariant | undefined, dictionaryKey: string) => DictionaryVariantChain | undefined;
+export declare const resolveProviderVariant: (providerVariant: ProviderVariantBase | undefined, dictionaryKey: string) => DictionaryVariantChain | undefined;
 /**
  * Builds the effective second argument of a dictionary read by layering the
  * provider defaults under the call-site one — the single place the `locale` and
@@ -132,17 +132,16 @@ declare const resolveProviderVariant: (providerVariant: ProviderVariant | undefi
  * so the existing fast path — and the cache keys built from it — are unchanged
  * for projects that never use variants.
  */
-declare const resolveDictionaryArgument: (params: {
+export declare const resolveDictionaryArgument: (params: {
   localeOrSelector?: LocalesValues | DictionarySelector;
   contextLocale?: LocalesValues;
-  contextVariant?: ProviderVariant;
+  contextVariant?: ProviderVariantBase;
   dictionaryKey: string;
 }) => LocalesValues | DictionarySelector | undefined;
 /**
  * Builds a stable string identity of a selector (excluding `locale`), suitable
  * for cache keys and memoization dependencies.
  */
-declare const getDictionarySelectorCacheKey: (selector?: DictionarySelector) => string;
+export declare const getDictionarySelectorCacheKey: (selector?: DictionarySelector) => string;
 //#endregion
-export { COMPOSITE_ID_SEPARATOR, DEFAULT_VARIANT_ID, getDictionarySelectorCacheKey, isQualifiedDictionaryGroup, parseDictionarySelector, reconstructQualifiedEntry, resolveDictionaryArgument, resolveEffectiveVariantId, resolveProviderVariant, resolveQualifiedDictionary, serializeVariant, serializeVariantChain };
 //# sourceMappingURL=qualifiedDictionary.d.ts.map

package/dist/types/dictionaryManipulator/qualifiedDictionary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"qualifiedDictionary.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/qualifiedDictionary.ts"],"mappings":";;;;;;;cAgBa;;;;;;cAOA;;;;;;;;;;;;;;;;;;;cAqDA,mBAAgB,SAClB;;;;;;;;;;;;;cA4BE,wBAAqB,SACvB;;;;;;;;;;;;;;;;cA0BE,4BAAyB,+BACP,sBACP;;;;;;cA4CX,6BAA0B,mBAEpC,SAAS;;;;;;;;;;;;cAkBC,4BAAyB,OAC7B,0BAAwB,wBAE9B;;;;;;;;;;;;;;;;cAkCU,6BAA0B,mBAClB,aAAa,0BAAwB,WAC7C,uBACV,aAAa;;;;;cAoDH,0BAA2B,UAAU,eAAa,mBAC1C,IAAI;EACpB,SAAS;EAAG,WAAW;;;;;;;;;;;;;;;;;cA0Bf,yBAAsB,iBAChB,6BAA2B,0BAE3C;;;;;;;;;;;;;;;cA0BU,4BAAyB;EACpC,mBAAmB,gBAAgB;EACnC,gBAAgB;EAChB,iBAAiB;EACjB;MACE,gBAAgB;;;;;cAqCP,gCAA6B,WAC7B"}
+{"version":3,"file":"qualifiedDictionary.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/qualifiedDictionary.ts"],"mappings":";;;;;;;qBAgBa;;;;;;qBAOA;;;;;;;;;;;;;;;;;;;qBAqDA,mBAAgB,SAClB;;;;;;;;;;;;;qBA4BE,wBAAqB,SACvB;;;;;;;;;;;;;;;;qBA0BE,4BAAyB,+BACP,sBACP;;;;;;qBA4CX,6BAA0B,mBAEpC,SAAS;;;;;;;;;;;;qBAkBC,4BAAyB,OAC7B,0BAAwB,wBAE9B;;;;;;;;;;;;;;;;qBAkCU,6BAA0B,mBAClB,aAAa,0BAAwB,WAC7C,uBACV,aAAa;;;;;qBAoDH,0BAA2B,UAAU,eAAa,mBAC1C,IAAI;EACpB,SAAS;EAAG,WAAW;;;;;;;;;;;;;;;;;qBA0Bf,yBAAsB,iBAChB,iCAA+B,0BAE/C;;;;;;;;;;;;;;;qBA0BU,4BAAyB;EACpC,mBAAmB,gBAAgB;EACnC,gBAAgB;EAChB,iBAAiB;EACjB;MACE,gBAAgB;;;;;qBAqCP,gCAA6B,WAC7B"}

package/dist/types/dictionaryManipulator/qualifiedDictionaryDeclaration.d.ts

@@ -5,7 +5,7 @@ import { Dictionary, DictionaryQualifierType } from "@intlayer/types/dictionary"
  * always nests them in this order, with `item` innermost so it can act as the
  * collection (array) axis.
  */
-declare const QUALIFIER_ORDER: readonly ["variant", "item"];
+export declare const QUALIFIER_ORDER: readonly ["variant", "item"];
 /**
  * Normalizes the `variant` field of a dictionary into the list of variant ids
  * the declaration registers under. A single value yields one id; an **array**
@@ -13,13 +13,13 @@ declare const QUALIFIER_ORDER: readonly ["variant", "item"];
  * when the dictionary does not declare the variant dimension (no `variant`
  * field, or an empty array).
  */
-declare const getVariantIds: (variant: Dictionary['variant']) => string[] | undefined;
+export declare const getVariantIds: (variant: Dictionary['variant']) => string[] | undefined;
 /**
  * Returns the qualifier dimensions declared on a dictionary, in canonical
  * order (`variant → item`). Empty when the dictionary is unqualified
  * (plain dictionary or shared base content of a qualified group).
  */
-declare const getDictionaryQualifierTypes: (dictionary: Dictionary) => DictionaryQualifierType[];
+export declare const getDictionaryQualifierTypes: (dictionary: Dictionary) => DictionaryQualifierType[];
 /**
  * Returns the qualifier identifiers of a dictionary for the given qualifier
  * dimension — the candidate segments of the composite entry ids.
@@ -28,14 +28,13 @@ declare const getDictionaryQualifierTypes: (dictionary: Dictionary) => Dictionar
  *   per element (declaration-side fan-out)
  * - 'item' → the item index as a single-element list
  */
-declare const getDictionaryQualifierIds: (dictionary: Dictionary, qualifierType: DictionaryQualifierType) => string[] | undefined;
+export declare const getDictionaryQualifierIds: (dictionary: Dictionary, qualifierType: DictionaryQualifierType) => string[] | undefined;
 /**
  * Builds every composite entry id of a dictionary — the cartesian product of
  * its per-dimension id lists, joined in canonical order. A dictionary with a
  * plain (non-array) variant yields exactly one id; an array variant fans out
  * into one id per element. `undefined` when a dimension of the set is missing.
  */
-declare const getDictionaryCompositeIds: (dictionary: Dictionary, qualifierTypes: DictionaryQualifierType[]) => string[] | undefined;
+export declare const getDictionaryCompositeIds: (dictionary: Dictionary, qualifierTypes: DictionaryQualifierType[]) => string[] | undefined;
 //#endregion
-export { QUALIFIER_ORDER, getDictionaryCompositeIds, getDictionaryQualifierIds, getDictionaryQualifierTypes, getVariantIds };
 //# sourceMappingURL=qualifiedDictionaryDeclaration.d.ts.map

package/dist/types/dictionaryManipulator/qualifiedDictionaryDeclaration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"qualifiedDictionaryDeclaration.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/qualifiedDictionaryDeclaration.ts"],"mappings":";;;;;;;cAca;;;;;;;;cAYA,gBAAa,SACf;;;;;;cAeE,8BAA2B,YAC1B,eACX;;;;;;;;;cAmBU,4BAAyB,YACxB,YAAU,eACP;;;;;;;cAcJ,4BAAyB,YACxB,YAAU,gBACN"}
+{"version":3,"file":"qualifiedDictionaryDeclaration.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/qualifiedDictionaryDeclaration.ts"],"mappings":";;;;;;;qBAca;;;;;;;;qBAYA,gBAAa,SACf;;;;;;qBAeE,8BAA2B,YAC1B,eACX;;;;;;;;;qBAmBU,4BAAyB,YACxB,YAAU,eACP;;;;;;;qBAcJ,4BAAyB,YACxB,YAAU,gBACN"}

package/dist/types/dictionaryManipulator/qualifiedDynamicLoader.d.ts

@@ -4,12 +4,12 @@ import { QUALIFIER_DYNAMIC_TYPES_KEY } from "@intlayer/config/defaultValues";
 /**
  * A lazily-imported per-locale dictionary chunk loader.
  */
-type DynamicDictionaryLoader = () => Promise<Dictionary>;
+export type DynamicDictionaryLoader = () => Promise<Dictionary>;
 /**
  * Nested tree of chunk loaders: one nesting level per declared dimension (in
  * canonical order), leaves are loaders.
  */
-type QualifiedDynamicLoaderTree = {
+export type QualifiedDynamicLoaderTree = {
   [segment: string]: QualifiedDynamicLoaderTree | DynamicDictionaryLoader;
 };
 /**
@@ -24,7 +24,7 @@ type QualifiedDynamicLoaderTree = {
  * }
  * ```
  */
-type QualifiedDynamicLoaderMap = {
+export type QualifiedDynamicLoaderMap = {
   [QUALIFIER_DYNAMIC_TYPES_KEY]: DictionaryQualifierType[];
   [locale: string]: QualifiedDynamicLoaderTree | DictionaryQualifierType[];
 };
@@ -32,7 +32,7 @@ type QualifiedDynamicLoaderMap = {
  * Type guard discriminating a qualified dynamic loader map (collections /
  * variants, possibly combined) from a plain dynamic loader map.
  */
-declare const isQualifiedDynamicLoaderMap: (value: unknown) => value is QualifiedDynamicLoaderMap;
+export declare const isQualifiedDynamicLoaderMap: (value: unknown) => value is QualifiedDynamicLoaderMap;
 /**
  * Resolves the content of a qualified dynamic loader map against a selector,
  * loading only the chunk(s) the selector actually targets.
@@ -56,7 +56,7 @@ declare const isQualifiedDynamicLoaderMap: (value: unknown) => value is Qualifie
  * @param loadChunk - Reads a started chunk promise, suspending until it resolves.
  * @param transform - Turns a resolved chunk dictionary into final content.
  */
-declare const resolveQualifiedDynamicContent: <Content>(params: {
+export declare const resolveQualifiedDynamicContent: <Content>(params: {
   loaderMap: QualifiedDynamicLoaderMap;
   key: string;
   locale: string;
@@ -75,7 +75,7 @@ declare const resolveQualifiedDynamicContent: <Content>(params: {
  * @param selector - The selector splitting the qualifier dimensions.
  * @param transform - Turns a resolved chunk dictionary into final content.
  */
-declare const resolveQualifiedDynamicContentAsync: <Content>(params: {
+export declare const resolveQualifiedDynamicContentAsync: <Content>(params: {
   loaderMap: QualifiedDynamicLoaderMap;
   key: string;
   locale: string;
@@ -83,5 +83,5 @@ declare const resolveQualifiedDynamicContentAsync: <Content>(params: {
   transform: (dictionary: Dictionary) => Content;
 }) => Promise<Content | Content[] | null>;
 //#endregion
-export { DynamicDictionaryLoader, QUALIFIER_DYNAMIC_TYPES_KEY, QualifiedDynamicLoaderMap, QualifiedDynamicLoaderTree, isQualifiedDynamicLoaderMap, resolveQualifiedDynamicContent, resolveQualifiedDynamicContentAsync };
+export { QUALIFIER_DYNAMIC_TYPES_KEY };
 //# sourceMappingURL=qualifiedDynamicLoader.d.ts.map

package/dist/types/dictionaryManipulator/qualifiedDynamicLoader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"qualifiedDynamicLoader.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/qualifiedDynamicLoader.ts"],"mappings":";;;;;;KAuBY,gCAAgC,QAAQ;;;;;KAMxC;GACT,kBAAkB,6BAA6B;;;;;;;;;;;;;;KAetC;GACT,8BAA8B;GAC9B,iBAAiB,6BAA6B;;;;;;cAOpC,8BAA2B,mBAErC,SAAS;;;;;;;;;;;;;;;;;;;;;;;;cAiHC,iCAAkC,SAAO;EACpD,WAAW;EACX;EACA;EACA,UAAU;EACV,YAAY,kBAAkB,SAAS,QAAQ,gBAAgB;EAC/D,YAAY,YAAY,eAAe;MACrC,UAAU;;;;;;;;;;;;cAkCD,sCAA6C,SAAO;EAC/D,WAAW;EACX;EACA;EACA,UAAU;EACV,YAAY,YAAY,eAAe;MACrC,QAAQ,UAAU"}
+{"version":3,"file":"qualifiedDynamicLoader.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/qualifiedDynamicLoader.ts"],"mappings":";;;;;;YAuBY,gCAAgC,QAAQ;;;;;YAMxC;GACT,kBAAkB,6BAA6B;;;;;;;;;;;;;;YAetC;GACT,8BAA8B;GAC9B,iBAAiB,6BAA6B;;;;;;qBAOpC,8BAA2B,mBAErC,SAAS;;;;;;;;;;;;;;;;;;;;;;;;qBAiHC,iCAAkC,SAAO;EACpD,WAAW;EACX;EACA;EACA,UAAU;EACV,YAAY,kBAAkB,SAAS,QAAQ,gBAAgB;EAC/D,YAAY,YAAY,eAAe;MACrC,UAAU;;;;;;;;;;;;qBAkCD,sCAA6C,SAAO;EAC/D,WAAW;EACX;EACA;EACA,UAAU;EACV,YAAY,YAAY,eAAe;MACrC,QAAQ,UAAU"}

package/dist/types/dictionaryManipulator/removeContentNodeByKeyPath.d.ts

@@ -1,7 +1,6 @@
 import { ContentNode } from "@intlayer/types/dictionary";
 import { KeyPath } from "@intlayer/types/keyPath";
 //#region src/dictionaryManipulator/removeContentNodeByKeyPath.d.ts
-declare const removeContentNodeByKeyPath: (dictionaryContent: ContentNode, keyPath: KeyPath[]) => ContentNode;
+export declare const removeContentNodeByKeyPath: (dictionaryContent: ContentNode, keyPath: KeyPath[]) => ContentNode;
 //#endregion
-export { removeContentNodeByKeyPath };
 //# sourceMappingURL=removeContentNodeByKeyPath.d.ts.map

package/dist/types/dictionaryManipulator/removeContentNodeByKeyPath.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"removeContentNodeByKeyPath.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/removeContentNodeByKeyPath.ts"],"mappings":";;;cAKa,6BAA0B,mBAClB,aAAW,SACrB,cACR"}
+{"version":3,"file":"removeContentNodeByKeyPath.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/removeContentNodeByKeyPath.ts"],"mappings":";;;qBAKa,6BAA0B,mBAClB,aAAW,SACrB,cACR"}

package/dist/types/dictionaryManipulator/renameContentNodeByKeyPath.d.ts

@@ -1,7 +1,6 @@
 import { ContentNode } from "@intlayer/types/dictionary";
 import { KeyPath } from "@intlayer/types/keyPath";
 //#region src/dictionaryManipulator/renameContentNodeByKeyPath.d.ts
-declare const renameContentNodeByKeyPath: (dictionaryContent: ContentNode, newKey: KeyPath['key'], keyPath: KeyPath[]) => ContentNode;
+export declare const renameContentNodeByKeyPath: (dictionaryContent: ContentNode, newKey: KeyPath['key'], keyPath: KeyPath[]) => ContentNode;
 //#endregion
-export { renameContentNodeByKeyPath };
 //# sourceMappingURL=renameContentNodeByKeyPath.d.ts.map

package/dist/types/dictionaryManipulator/renameContentNodeByKeyPath.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"renameContentNodeByKeyPath.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/renameContentNodeByKeyPath.ts"],"mappings":";;;cAKa,6BAA0B,mBAClB,aAAW,QACtB,gBAAc,SACb,cACR"}
+{"version":3,"file":"renameContentNodeByKeyPath.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/renameContentNodeByKeyPath.ts"],"mappings":";;;qBAKa,6BAA0B,mBAClB,aAAW,QACtB,gBAAc,SACb,cACR"}

package/dist/types/dictionaryManipulator/updateNodeChildren.d.ts

@@ -1,6 +1,5 @@
 import { ContentNode } from "@intlayer/types/dictionary";
 //#region src/dictionaryManipulator/updateNodeChildren.d.ts
-declare const updateNodeChildren: <T extends ContentNode, U extends ContentNode>(section: T, newChildren: U) => ContentNode;
+export declare const updateNodeChildren: <T extends ContentNode, U extends ContentNode>(section: T, newChildren: U) => ContentNode;
 //#endregion
-export { updateNodeChildren };
 //# sourceMappingURL=updateNodeChildren.d.ts.map

package/dist/types/dictionaryManipulator/updateNodeChildren.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"updateNodeChildren.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/updateNodeChildren.ts"],"mappings":";;cAIa,qBACX,UAAU,aACV,UAAU,aAAW,SAEZ,GAAC,aACG,MACZ"}
+{"version":3,"file":"updateNodeChildren.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/updateNodeChildren.ts"],"mappings":";;qBAIa,qBACX,UAAU,aACV,UAAU,aAAW,SAEZ,GAAC,aACG,MACZ"}

package/dist/types/formatters/compact.d.ts

@@ -11,9 +11,8 @@ import { LocalesValues } from "@intlayer/types/module_augmentation";
  * compact("1000000", { locale: Locales.FRENCH, compactDisplay: "long" });
  * // "1 million"
  */
-declare const compact: (value: string | number, options?: Intl.NumberFormatOptions & {
+export declare const compact: (value: string | number, options?: Intl.NumberFormatOptions & {
   locale?: LocalesValues;
 }) => string;
 //#endregion
-export { compact };
 //# sourceMappingURL=compact.d.ts.map

package/dist/types/formatters/compact.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compact.d.ts","names":[],"sources":["../../../src/formatters/compact.ts"],"mappings":";;;;;;;;;;;;;cAea,UAAO,wBACI,UACZ,KAAK;EAAwB,SAAS"}
+{"version":3,"file":"compact.d.ts","names":[],"sources":["../../../src/formatters/compact.ts"],"mappings":";;;;;;;;;;;;;qBAea,UAAO,wBACI,UACZ,KAAK;EAAwB,SAAS"}

package/dist/types/formatters/currency.d.ts

@@ -11,9 +11,8 @@ import { LocalesValues } from "@intlayer/types/module_augmentation";
  * currency("5000", { locale: Locales.FRENCH, currency: "CAD", currencyDisplay: "code" });
  * // "5 000,00 CAD"
  */
-declare const currency: (value: string | number, options?: Intl.NumberFormatOptions & {
+export declare const currency: (value: string | number, options?: Intl.NumberFormatOptions & {
   locale?: LocalesValues;
 }) => string;
 //#endregion
-export { currency };
 //# sourceMappingURL=currency.d.ts.map

package/dist/types/formatters/currency.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"currency.d.ts","names":[],"sources":["../../../src/formatters/currency.ts"],"mappings":";;;;;;;;;;;;;cAea,WAAQ,wBACG,UACZ,KAAK;EAAwB,SAAS"}
+{"version":3,"file":"currency.d.ts","names":[],"sources":["../../../src/formatters/currency.ts"],"mappings":";;;;;;;;;;;;;qBAea,WAAQ,wBACG,UACZ,KAAK;EAAwB,SAAS"}

package/dist/types/formatters/date.d.ts

@@ -1,7 +1,7 @@
 import { LocalesValues } from "@intlayer/types/module_augmentation";
 //#region src/formatters/date.d.ts
-type DateTimePreset = 'short' | 'long' | 'dateOnly' | 'timeOnly' | 'full';
-declare const presets: Record<DateTimePreset, Intl.DateTimeFormatOptions>;
+export type DateTimePreset = 'short' | 'long' | 'dateOnly' | 'timeOnly' | 'full';
+export declare const presets: Record<DateTimePreset, Intl.DateTimeFormatOptions>;
 /**
  * Formats a date/time value into a localized string using Intl.DateTimeFormat.
  *
@@ -13,9 +13,8 @@ declare const presets: Record<DateTimePreset, Intl.DateTimeFormatOptions>;
  * date("2025-08-02T14:30:00Z", { locale: Locales.FRENCH, month: "long", day: "numeric" });
  * // "2 août"
  */
-declare const date: (date: Date | string | number, options?: (Intl.DateTimeFormatOptions & {
+export declare const date: (date: Date | string | number, options?: (Intl.DateTimeFormatOptions & {
   locale?: LocalesValues;
 }) | DateTimePreset) => string;
 //#endregion
-export { DateTimePreset, date, presets };
 //# sourceMappingURL=date.d.ts.map

package/dist/types/formatters/date.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"date.d.ts","names":[],"sources":["../../../src/formatters/date.ts"],"mappings":";;KAIY;cAOC,SAAS,OAAO,gBAAgB,KAAK;;;;;;;;;;;;cA8CrC,OAAI,MACT,wBAAsB,WAEvB,KAAK;EAA0B,SAAS;KACzC"}
+{"version":3,"file":"date.d.ts","names":[],"sources":["../../../src/formatters/date.ts"],"mappings":";;YAIY;qBAOC,SAAS,OAAO,gBAAgB,KAAK;;;;;;;;;;;;qBA8CrC,OAAI,MACT,wBAAsB,WAEvB,KAAK;EAA0B,SAAS;KACzC"}

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

@@ -2,9 +2,9 @@ import { compact } from "./compact.js";
 import { currency } from "./currency.js";
 import { DateTimePreset, date, presets } from "./date.js";
 import { CachedIntl, IntlConstructorName, WrappedIntl, bindIntl, getCachedIntl } from "../utils/intl.js";
-import { list } from "./list.js";
+import { ListFormatOptions, list } from "./list.js";
 import { number } from "./number.js";
 import { percentage } from "./percentage.js";
 import { relativeTime } from "./relativeTime.js";
 import { units } from "./units.js";
-export { CachedIntl, CachedIntl as Intl, DateTimePreset, IntlConstructorName, WrappedIntl, bindIntl, compact, currency, date, getCachedIntl, list, number, percentage, presets, relativeTime, units };
+export { CachedIntl, CachedIntl as Intl, DateTimePreset, IntlConstructorName, ListFormatOptions, WrappedIntl, bindIntl, compact, currency, date, getCachedIntl, list, number, percentage, presets, relativeTime, units };