@intlayer/types 9.4.3 → 9.5.0

package/README.md

@@ -69,8 +69,6 @@ With **per-locale content files**, **TypeScript autocompletion**, **tree-shakabl
 | <img src="https://github.com/aymericzip/intlayer/blob/main/docs/assets/interoperability.png?raw=true" alt="Feature" width="700">                    | **Interoperability**<br><br>Allow interoperability with react-i18next, next-i18next, next-intl, react-intl, vue-i18n. <br><br> - [Intlayer and react-intl](https://intlayer.org/blog/intlayer-with-react-intl) <br> - [Intlayer and next-intl](https://intlayer.org/blog/intlayer-with-next-intl) <br> - [Intlayer and next-i18next](https://intlayer.org/blog/intlayer-with-next-i18next) <br> - [Intlayer and vue-i18n](https://intlayer.org/blog/intlayer-with-vue-i18n) <br> - [Intlayer compat adapters](https://intlayer.org/doc/compatibility) |
 | <img src="https://github.com/aymericzip/intlayer/blob/main/docs/assets/benchmark.png?raw=true" alt="Feature" width="700">                           | **Performances & Benchmark**<br><br>Uses advanced tree-shaking and dynamic loading to boost performances and keep the solution as light as possible. <br><br> - [Performances & Benchmark](https://intlayer.org/doc/benchmark)                                                                                                                                                                                                                                                                                                                        |
 
----
-
 ## 📦 Installation
 
 Start your journey with Intlayer today and experience a smoother, more powerful approach to internationalization.

package/dist/types/allLocales.d.ts

@@ -1,9 +1,8 @@
 import { locales_d_exports } from "./locales.js";
 //#region src/allLocales.d.ts
 /** Object containing all locale string values as properties, e.g. { ENGLISH: 'en', ... } */
-declare const ALL_LOCALES: typeof locales_d_exports;
+export declare const ALL_LOCALES: typeof locales_d_exports;
 /** Union of all locale string values, e.g. 'en' | 'en-US' | 'ar' | 'ar-AE' | ... */
-type Locale = (typeof locales_d_exports)[keyof typeof locales_d_exports];
+export type Locale = (typeof locales_d_exports)[keyof typeof locales_d_exports];
 //#endregion
-export { ALL_LOCALES, Locale };
 //# sourceMappingURL=allLocales.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"allLocales.d.ts","names":[],"sources":["../../src/allLocales.ts"],"mappings":";;;cAUa,oBAAoB;;KAGrB,iBAAiB,gCAAsB"}
+{"version":3,"file":"allLocales.d.ts","names":[],"sources":["../../src/allLocales.ts"],"mappings":";;;qBAUa,oBAAoB;;YAGrB,iBAAiB,gCAAsB"}

package/dist/types/config.d.ts

@@ -7,25 +7,25 @@ import { Plugin } from "./plugin.js";
  * Structural type for schema validation, compatible with Zod and other
  * schema libraries that implement safeParse. Avoids a hard dependency on Zod.
  */
-type ConfigSchema = {
+export type ConfigSchema = {
   safeParse(data: unknown): {
     success: boolean;
     data?: unknown;
     error?: unknown;
   };
 };
-type StrictMode = "strict" | "inclusive" | "loose";
+export type StrictMode = "strict" | "inclusive" | "loose";
 type Protocol = "http" | "https";
 type URLPath = `/${string}`;
 type OptionalURLPath = `/${string}` | "";
 type LocalhostURL = `${Protocol}://localhost:${number}${OptionalURLPath}`;
 type IPUrl = `${Protocol}://${number}.${string}${OptionalURLPath}` | `${Protocol}://${number}.${string}:${number}${OptionalURLPath}`;
 type DomainURL = `${Protocol}://${string}.${string}${OptionalURLPath}`;
-type URLType = LocalhostURL | IPUrl | DomainURL | (string & {});
+export type URLType = LocalhostURL | IPUrl | DomainURL | (string & {});
 /**
  * Configuration for internationalization settings
  */
-type InternationalizationConfig = {
+export type InternationalizationConfig = {
   /**
    * Locales available in the application
    *
@@ -62,7 +62,7 @@ type InternationalizationConfig = {
    */
   defaultLocale: Locale;
 };
-type CookiesAttributes = {
+export type CookiesAttributes = {
   /**
    * Type of the storage
    *
@@ -146,7 +146,7 @@ type CookiesAttributes = {
    */
   maxAge?: number;
 };
-type StorageAttributes = {
+export type StorageAttributes = {
   /**
    * Storage type where the locale is stored
    *
@@ -172,7 +172,7 @@ type StorageAttributes = {
  * - `number` → seconds from cookie creation (relative);
  * - `string` → an absolute expiry as an ISO date string.
  */
-type ProcessedCookieAttributes = {
+export type ProcessedCookieAttributes = {
   domain?: string;
   path?: string;
   secure?: boolean;
@@ -184,7 +184,7 @@ type ProcessedCookieAttributes = {
  * Pre-computed storage attributes derived from `RoutingConfig.storage`.
  * Computed at config-build time to avoid repeated processing at runtime.
  */
-type ProcessedStorageAttributes = {
+export type ProcessedStorageAttributes = {
   cookies?: {
     name: string;
     attributes: ProcessedCookieAttributes;
@@ -199,14 +199,14 @@ type ProcessedStorageAttributes = {
     name: string;
   }[];
 };
-type RewriteRule<T extends string = string> = {
+export type RewriteRule<T extends string = string> = {
   canonical: T;
   localized: StrictModeLocaleMap<string>;
 };
-type RewriteRules = {
+export type RewriteRules = {
   rules: RewriteRule[];
 };
-type RewriteObject = {
+export type RewriteObject = {
   /**
    * Used for client-side URL generation (e.g., getLocalizedUrl).
    * Patterns are usually stripped of locale prefixes as the core logic handles prefixing.
@@ -225,7 +225,7 @@ type RewriteObject = {
 /**
  * Configuration for routing behaviors
  */
-type RoutingConfig = {
+export type RoutingConfig = {
   /**
    * Rewrite the URLs to a localized path
    *
@@ -337,17 +337,17 @@ type RoutingConfig = {
  * - Config both localStorage and cookies for the storage of the locale if you want to support GDPR compliance.
  * - Disable the cookie storage by default on the useLocale hook by waiting for the user to consent to the cookie storage.
  */
-type RoutingStorageInput = false | "cookie" | "localStorage" | "sessionStorage" | "header" | CookiesAttributes | StorageAttributes | ("cookie" | "localStorage" | "sessionStorage" | "header" | CookiesAttributes | StorageAttributes)[];
+export type RoutingStorageInput = false | "cookie" | "localStorage" | "sessionStorage" | "header" | CookiesAttributes | StorageAttributes | ("cookie" | "localStorage" | "sessionStorage" | "header" | CookiesAttributes | StorageAttributes)[];
 /**
  * User-facing routing configuration (accepted in `intlayer.config.ts`).
  */
-type CustomRoutingConfig = Omit<RoutingConfig, "storage"> & {
+export type CustomRoutingConfig = Omit<RoutingConfig, "storage"> & {
   storage?: RoutingStorageInput;
 };
 /**
  * Configuration for intlayer editor
  */
-type EditorConfig = {
+export type EditorConfig = {
   /**
    * URL of the application. Used to restrict the origin of the editor for security reasons.
    *
@@ -455,7 +455,7 @@ type EditorConfig = {
  * Nothing is collected while the package is absent, or while no project key
  * (`editor.clientId`) is configured for attribution.
  */
-type AnalyticsConfig = {
+export type AnalyticsConfig = {
   /**
    * Enables analytics collection (page views, content exposures, A/B events).
    *
@@ -490,7 +490,7 @@ type AnalyticsConfig = {
    */
   sampleRate: number;
 };
-declare enum AiProviders {
+export declare enum AiProviders {
   OPENAI = "openai",
   ANTHROPIC = "anthropic",
   MISTRAL = "mistral",
@@ -509,7 +509,7 @@ declare enum AiProviders {
   LMSTUDIO = "lmstudio",
   MOONSHOTAI = "moonshotai"
 }
-type CommonAiConfig = {
+export type CommonAiConfig = {
   /**
    * API model
    *
@@ -562,14 +562,14 @@ type CommonAiConfig = {
    */
   dataSerialization?: "json" | "toon";
 };
-type AiProviderConfigMap = {};
+export type AiProviderConfigMap = {};
 type AiConfigUnion = { [P in keyof AiProviderConfigMap]: {
   provider: P | `${P}`;
 } & AiProviderConfigMap[P]; }[keyof AiProviderConfigMap];
-type AiConfig = CommonAiConfig & (AiConfigUnion | {
+export type AiConfig = CommonAiConfig & (AiConfigUnion | {
   provider?: AiProviders | `${AiProviders}`;
 });
-type BuildConfig = {
+export type BuildConfig = {
   /**
    * Indicates the mode of the build
    *
@@ -749,7 +749,7 @@ type BuildConfig = {
    */
   checkTypes: boolean;
 };
-type CompilerConfig = {
+export type CompilerConfig = {
   /**
    * Indicates if the compiler should be enabled.
    * If 'build-only', the compiler will be skipped during development mode to speed up start times.
@@ -882,7 +882,7 @@ type CompilerConfig = {
 /**
  * Custom configuration that can be provided to override default settings
  */
-type CustomIntlayerConfig = {
+export type CustomIntlayerConfig = {
   /**
    * Custom internationalization configuration
    */
@@ -948,7 +948,7 @@ type CustomIntlayerConfig = {
    */
   plugins?: (Plugin | Promise<Plugin>)[];
 };
-type DictionaryConfig = {
+export type DictionaryConfig = {
   /**
    * Indicate how the dictionary should be filled using AI.
    *
@@ -1139,7 +1139,7 @@ type DictionaryConfig = {
 /**
  * Combined configuration for internationalization, middleware, and content
  */
-type IntlayerConfig = {
+export type IntlayerConfig = {
   /**
    * Internationalization configuration
    */
@@ -1196,7 +1196,7 @@ type IntlayerConfig = {
 /**
  * Configuration for content handling
  */
-type ContentConfig = {
+export type ContentConfig = {
   /**
    * File extensions of content to look for
    *
@@ -1266,7 +1266,7 @@ type ContentConfig = {
    */
   formatCommand: string | undefined;
 };
-type SystemConfig = {
+export type SystemConfig = {
   /**
    * Absolute path of the project's base directory
    *
@@ -1364,13 +1364,13 @@ type SystemConfig = {
    */
   tempDir: string;
 };
-type LogFunctions = {
+export type LogFunctions = {
   error?: typeof console.error;
   log?: typeof console.log;
   info?: typeof console.info;
   warn?: typeof console.warn;
 };
-type LogConfig = {
+export type LogConfig = {
   /**
    * Indicates if the logger is enabled
    *
@@ -1399,5 +1399,4 @@ type LogConfig = {
   debug?: typeof console.debug;
 };
 //#endregion
-export { AiConfig, AiProviderConfigMap, AiProviders, AnalyticsConfig, BuildConfig, CommonAiConfig, CompilerConfig, ConfigSchema, ContentConfig, CookiesAttributes, CustomIntlayerConfig, CustomRoutingConfig, DictionaryConfig, EditorConfig, InternationalizationConfig, IntlayerConfig, LogConfig, LogFunctions, ProcessedCookieAttributes, ProcessedStorageAttributes, RewriteObject, RewriteRule, RewriteRules, RoutingConfig, RoutingStorageInput, StorageAttributes, StrictMode, SystemConfig, URLType };
 //# sourceMappingURL=config.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","names":[],"sources":["../../src/config.ts"],"mappings":"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"}
+{"version":3,"file":"config.d.ts","names":[],"sources":["../../src/config.ts"],"mappings":";;;;;;;;;YAcY;EACV,UAAU;IACR;IACA;IACA;;;YAIQ;KAEP;KAEA;KAEA;KAGA,kBAAkB,iCAAiC;KAGnD,WACE,iCAAiC,uBACjC,2CAA2C;KAI7C,eAAe,iCAAiC;YAEzC,UAAU,eAAe,QAAQ;;;;YAKjC;;;;;;;;EAQV,SAAS;;;;;;;;;;EAWT,iBAAiB;;;;;;;;;EAUjB,YAAY;;;;;;;;EASZ,eAAe;;YAGL;;;;;;EAMV;;;;;;;;EAQA;;;;;;;;;EASA;;;;;;;;EAQA;;;;;;;;;EASA;;;;;;;;EAQA;;;;;;;;;;EAUA;;;;;;;;;;;;;;EAeA,UAAU;;;;;;;;;;EAUV;;YAGU;;;;;;;EAOV;;;;;;;;EASA;;;;;;;;;;;YAYU;EACV;EACA;EACA;EACA;EACA;EACA;;;;;;YAOU;EACV;IACE;IACA,YAAY;;EAEd;IACE;;EAEF;IACE;;EAEF;IACE;;;YAIQ,YAAY;EACtB,WAAW;EACX,WAAW;;YAGD;EACV,OAAO;;YAGG;;;;;EAKV,KAAK;;;;;EAKL,SAAS;;;;EAIT,OAAO;;;;;YAMG;;;;;;;;;;;;;;;;EAgBV,UAAU,OAAO,SAAS,oBAAoB,YAAY;;;;;;;;;;;;;;;;;;;;EAqB1D;;;;;;;;;;;;;;;;;;;;;;;;EAyBA;;;;;;EAOA,SAAS;;;;;;;;EAST;;;;;;;;;;;;;;;;;EAkBA,UAAU,QAAQ,OAAO;;;;;;;;;;;;;;;;;;;;;YAsBf,wFAMR,oBACA,+EAMI,oBACA;;;;YAMI,sBAAsB,KAAK;EACrC,UAAU;;;;;YAMA;;;;;;EAMV,iBAAiB;;;;;EAMjB,YAAY;;;;;EAMZ,SAAS;;;;;EAMT,aAAa;;;;;;;;;;;;;;;;;;;;;;EAuBb;;;;;EAMA;;;;;;;;;;EAWA;;;;;;;;;;EAWA;;;;;;;;;;;EAYA;;;;;;;EAQA;;;;;;EAOA;;;;;;EAOA,aAAa;;;;;;;;;;YAWH;;;;;;;;;;;;;;;;;;;;EAoBV;;;;;;EAOA;;;;;;;EAQA;;oBAGU;EACV;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;YAGU;;;;;;;;;EASV;;;;;;;;;;EAWA;;;;;;;;EASA;;;;;;;;EASA;;;;;;;;EASA;;;;;;;;EASA;;YAGU;KAEP,mBACF,WAAW;EACV,UAAU,OAAO;IACf,oBAAoB,YAClB;YAEI,WAAW,kBACpB;EAAkB,WAAW,iBAAiB;;YAErC;;;;;;;;;;;EAWV;;;;;;;;;;;;;;;;;;EAmBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8BA;;;;;;;;;;;EAYA;;;;;;;;;EAUA;;;;;;;;;;;;;;;;;EAkBA;;;;;;;;;;;;;;;;;;;;;;EAuBA;;;;;;;;;;;;;;;EAgBA;;;;;;;;;;EAWA;;;;;;;;;EAUA;;;;;;;;;;;;;;;;;;EAmBA,UAAU,OAAO;;;;;;;;;EAUjB;;YAGU;;;;;EAKV;;;;;EAMA;;;;;;;;;;;;;;;;;EAkBA;;;;;;;;;;;;EAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmDA,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+BT;;;;;;;;;EAUA;;;;;YAMU;;;;EAIV,uBAAuB,QAAQ;;;;EAK/B,aAAa,QAAQ;;;;EAKrB,UAAU,QAAQ;;;;EAKlB,UAAU,QAAQ;;;;EAKlB,SAAS,QAAQ;;;;EAKjB,YAAY,QAAQ;;;;EAKpB,MAAM,QAAQ;;;;EAKd,KAAK,QAAQ;;;;EAKb,QAAQ,QAAQ;;;;EAKhB,WAAW,QAAQ;;;;EAKnB,SAAS,QAAQ;;;;;;;;;;;;;;;;EAiBjB,UAAU,eAAe;;;;EAKzB,WAAW,SAAS,QAAQ;;YAGlB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyDV,OAAO;;;;;;;;;;;;;;;;;;;EAmBP;;;;;;;;;;;;;;;;;;EAkBA,SAAS;;;;;;;;;;;;EAYT,4BAA4B;;;;;EAK5B;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BA;;;;;;;;;;;;;EAaA;;;;;;;;;;;;EAYA;;;;;;;;;EASA,WAAW;;;;;;;;;;;;;;EAeX,SAAS;;;;;YAMC;;;;EAIV,sBAAsB;;;;EAKtB,aAAa,QAAQ;;;;EAKrB,SAAS;;;;EAKT,SAAS;;;;EAKT,QAAQ;;;;EAKR,QAAQ;;;;EAKR,YAAY;;;;EAKZ,KAAK;;;;EAKL,KAAK,QAAQ;;;;EAKb,OAAO;;;;EAKP,UAAU;;;;EAKV,UAAU,eAAe;;;;EAKzB,UAAU;;;;;YAMA;;;;;;;;EAQV;;;;;;;;;;EAWA;;;;;;;;;;EAWA;;;;;;;;EASA;;;;;;EAOA;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BA;;YAGU;;;;;;;;EAQV;;;;;;;;EASA;;;;;;;;EASA;;;;;;;;EASA;;;;;;;;EASA;;;;;;;;EASA;;;;;;;;EASA;;;;;;;;EASA;;;;;;;;EASA;;;;;;;;EASA;;;;;;;;EASA;;;;;;;;EASA;;YAGU;EACV,eAAe,QAAQ;EACvB,aAAa,QAAQ;EACrB,cAAc,QAAQ;EACtB,cAAc,QAAQ;;YAGZ;;;;;;;;;;EAUV;;;;;;;;EASA;;;;EAKA,eAAe,QAAQ;EACvB,aAAa,QAAQ;EACrB,cAAc,QAAQ;EACtB,cAAc,QAAQ;EACtB,eAAe,QAAQ"}

package/dist/types/dictionary.d.ts

@@ -6,9 +6,9 @@ type BaseNode = number | string | boolean | null | undefined;
 type TypedNodeBase = {
   nodeType: NodeType;
 };
-interface TypedNode<_NodeType = undefined> extends TypedNodeBase {}
+export interface TypedNode<_NodeType = undefined> extends TypedNodeBase {}
 type FetchableContentNode<NodeType> = (args?: any) => ContentNode<NodeType> | Promise<ContentNode<NodeType>>;
-type ContentNode<T = undefined, FetchableNode = false, NodeType = T extends undefined ? BaseNode : T> = NodeType | TypedNode<NodeType> | ((args?: any) => ContentNode<NodeType>) | (FetchableNode extends true ? FetchableContentNode<NodeType> : undefined);
+export type ContentNode<T = undefined, FetchableNode = false, NodeType = T extends undefined ? BaseNode : T> = NodeType | TypedNode<NodeType> | ((args?: any) => ContentNode<NodeType>) | (FetchableNode extends true ? FetchableContentNode<NodeType> : undefined);
 type IsArray<T> = T extends any[] ? true : false;
 type ReplaceContentValueArray<T, FetchableNode> = T extends (infer U)[] ? ContentNode<T, FetchableNode> | ReplaceContentValue<U, FetchableNode>[] : never;
 type ReplaceContentValueObject<T, FetchableNode> = { [K in keyof T]: ReplaceContentValue<T[K], FetchableNode>; };
@@ -69,9 +69,9 @@ type ReplaceContentValue<NodeType, FetchableNode = true> = NodeType extends obje
  *   - `componentFormat`: The format of the component dictionary.
  *   - `componentDirPath`: The directory path of the component.
  */
-type Fill = boolean | FilePathPattern | Partial<Record<DeclaredLocales, boolean | FilePathPattern>>;
-type DictionaryId = string;
-type DictionaryKey = string;
+export type Fill = boolean | FilePathPattern | Partial<Record<DeclaredLocales, boolean | FilePathPattern>>;
+export type DictionaryId = string;
+export type DictionaryKey = string;
 /**
  * A dimension used to discriminate sibling dictionaries sharing the same key.
  *
@@ -84,7 +84,7 @@ type DictionaryKey = string;
  * have variants). They are always ordered canonically as `variant → item`,
  * with `item` as the innermost / collection axis.
  */
-type DictionaryQualifierType = "variant" | "item";
+export type DictionaryQualifierType = "variant" | "item";
 /**
  * A single variant value declared on a dictionary:
  *
@@ -95,7 +95,7 @@ type DictionaryQualifierType = "variant" | "item";
  * The `variant` field of a dictionary accepts one value or an **array** of
  * values — an array registers the same content under every listed variant id.
  */
-type DictionaryVariantValue = string | Record<string, string | number>;
+export type DictionaryVariantValue = string | Record<string, string | number>;
 /**
  * A variant coordinate as pinned by a **selector** (or by a provider default):
  * one value, or an **ordered preference chain**.
@@ -109,7 +109,7 @@ type DictionaryVariantValue = string | Record<string, string | number>;
  * a {@link Dictionary}: there an array **declares** one entry per element
  * (fan-out), here it **consumes** them in priority order.
  */
-type DictionaryVariantChain = DictionaryVariantValue | readonly DictionaryVariantValue[];
+export type DictionaryVariantChain = DictionaryVariantValue | readonly DictionaryVariantValue[];
 /**
  * Variant default carried by a framework provider (`<IntlayerProvider variant>`)
  * and applied to every dictionary read below it, the way `locale` already is.
@@ -125,8 +125,8 @@ type DictionaryVariantChain = DictionaryVariantValue | readonly DictionaryVarian
  * structured variant globally, nest it under an entry:
  * `variant={{ default: { id: 'prod_abc' } }}`.
  */
-type ProviderVariantMap<Key extends string = DictionaryKey> = Partial<Record<Key | "default", DictionaryVariantChain>>;
-type ProviderVariant<Key extends string = DictionaryKey> = string | readonly DictionaryVariantValue[] | ProviderVariantMap<Key>;
+export type ProviderVariantMap<Key extends string = DictionaryKey> = Partial<Record<Key | "default", DictionaryVariantChain>>;
+export type ProviderVariantBase<Key extends string = DictionaryKey> = string | readonly DictionaryVariantValue[] | ProviderVariantMap<Key>;
 /**
  * Output of the merge step for a key whose dictionaries declare one or more
  * qualifier dimensions (`variant`, `item`).
@@ -155,7 +155,7 @@ type ProviderVariant<Key extends string = DictionaryKey> = string | readonly Dic
  * }
  * ```
  */
-type QualifiedDictionaryGroup = {
+export type QualifiedDictionaryGroup = {
   $schema?: "https://intlayer.org/schema.json";
   key: DictionaryKey;
   qualifierTypes: DictionaryQualifierType[];
@@ -180,7 +180,7 @@ type QualifiedDictionaryGroup = {
  *   variant; the object must equal the variant declared on the dictionary
  * - `locale` composes with any of the above and overrides the context locale
  */
-type DictionarySelector = {
+export type DictionarySelector = {
   /**
    * The declared locales are offered as suggestions, but any string is
    * accepted: a locale usually reaches this API as a router param or a stored
@@ -283,7 +283,7 @@ type IsItemAxisOpen<QualifierTypes extends readonly DictionaryQualifierType[], S
  *   the group declares one (sparse-override fallback)
  * - plain dictionary → its `content` (selector ignored)
  */
-type ResolveQualifiedDictionaryContent<T, Selector = undefined> = T extends {
+export type ResolveQualifiedDictionaryContent<T, Selector = undefined> = T extends {
   qualifierTypes: infer QualifierTypes extends readonly DictionaryQualifierType[];
   content: infer ContentMap extends Record<string, any>;
 } ? MatchingEntries<ReconstructedEntries<ContentMap, QualifierTypes>, QualifierTypes, Selector, EffectiveSelectorVariant<Selector, DeclaredVariantIds<ContentMap>>> extends (infer Matched) ? IsItemAxisOpen<QualifierTypes, Selector> extends true ? QualifiedEntryContent<Matched[keyof Matched]>[] : [keyof Matched] extends [never] ? null : QualifiedEntryContent<Matched[keyof Matched]> : never : T extends {
@@ -334,7 +334,7 @@ type ParseObjectVariantId<Id extends string> = Id extends `${infer Pair}&${infer
  * Excludes object variants: their serialized form is an internal storage
  * encoding, never a value the selector should accept as a string.
  */
-type DictionaryVariantIdsOf<T> = NamedVariantIds<VariantIdsOfGroup<T>>;
+export type DictionaryVariantIdsOf<T> = NamedVariantIds<VariantIdsOfGroup<T>>;
 /**
  * The object variants a group declares, rebuilt into their declared shape.
  *
@@ -373,7 +373,7 @@ type HasDefaultVariant<T> = "default" extends VariantIdsOfGroup<T> ? true : fals
  *   that is a storage encoding, not part of the API.
  */
 type SelectableVariantsOf<T, KnownVariants> = NamedVariantIds<EntryVariant<GroupEntryUnion<T>>> | (HasDefaultVariant<T> extends true ? KnownVariants : never) | DictionaryObjectVariantsOf<T>;
-type DictionarySelectorForGroup<T, KnownVariants = DeclaredVariants> = [GroupEntryUnion<T>] extends [never] ? DictionarySelector : {
+export type DictionarySelectorForGroup<T, KnownVariants = DeclaredVariants> = [GroupEntryUnion<T>] extends [never] ? DictionarySelector : {
   locale?: LocalesValues;
 } & ([EntryVariant<GroupEntryUnion<T>>] extends [never] ? unknown : {
   /**
@@ -384,9 +384,9 @@ type DictionarySelectorForGroup<T, KnownVariants = DeclaredVariants> = [GroupEnt
 }) & ([EntryItem<GroupEntryUnion<T>>] extends [never] ? unknown : {
   item?: EntryItem<GroupEntryUnion<T>> | number | (string & {});
 });
-type DictionaryLocation = "remote" | "local" | "hybrid" | "plugin" | (string & {});
-type LocalDictionaryId = `${DictionaryKey}::${Dictionary["location"]}::${Dictionary["filePath"] | DictionaryId}`;
-type DictionaryFormat = "intlayer" | "icu" | "i18next" | "vue-i18n" | "po";
+export type DictionaryLocation = "remote" | "local" | "hybrid" | "plugin" | (string & {});
+export type LocalDictionaryId = `${DictionaryKey}::${Dictionary["location"]}::${Dictionary["filePath"] | DictionaryId}`;
+export type DictionaryFormat = "intlayer" | "icu" | "i18next" | "vue-i18n" | "po";
 /**
  * Indicates the mode of import to use for the dictionary.
  *
@@ -401,8 +401,8 @@ type DictionaryFormat = "intlayer" | "icu" | "i18next" | "vue-i18n" | "po";
  *
  * Default: "static"
  */
-type ImportMode = "static" | "dynamic" | "fetch";
-type ContentAutoTransformation = boolean | {
+export type ImportMode = "static" | "dynamic" | "fetch";
+export type ContentAutoTransformation = boolean | {
   /**
    * Indicates if the content should be automatically transformed to a markdown node.
    * Default: true
@@ -754,8 +754,7 @@ type DictionaryWithoutSchema<ContentType, FetchableNode> = {
 /**
  * The Final Dictionary Type
  */
-type Dictionary<ContentType = undefined, SchemaKey extends SchemaKeys | undefined = undefined, FetchableNode = false> = DictionaryBase & (SchemaKey extends SchemaKeys ? DictionaryWithSchema<ContentType, FetchableNode, SchemaKey> : undefined extends SchemaKey ? DictionaryWithoutSchema<ContentType, FetchableNode> | DictionaryWithSchema<ContentType, FetchableNode> : never);
-type GetSubPath<T, P> = P extends `${infer K}.${infer Rest}` ? K extends keyof T ? GetSubPath<T[K], Rest> : never : P extends keyof T ? T[P] : T;
+export type Dictionary<ContentType = undefined, SchemaKey extends SchemaKeys | undefined = undefined, FetchableNode = false> = DictionaryBase & (SchemaKey extends SchemaKeys ? DictionaryWithSchema<ContentType, FetchableNode, SchemaKey> : undefined extends SchemaKey ? DictionaryWithoutSchema<ContentType, FetchableNode> | DictionaryWithSchema<ContentType, FetchableNode> : never);
+export type GetSubPath<T, P> = P extends `${infer K}.${infer Rest}` ? K extends keyof T ? GetSubPath<T[K], Rest> : never : P extends keyof T ? T[P] : T;
 //#endregion
-export { ContentAutoTransformation, ContentNode, Dictionary, DictionaryFormat, DictionaryId, DictionaryKey, DictionaryLocation, DictionaryQualifierType, DictionarySelector, DictionarySelectorForGroup, DictionaryVariantChain, DictionaryVariantIdsOf, DictionaryVariantValue, Fill, GetSubPath, ImportMode, LocalDictionaryId, ProviderVariant, ProviderVariantMap, QualifiedDictionaryGroup, ResolveQualifiedDictionaryContent, TypedNode };
 //# sourceMappingURL=dictionary.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"dictionary.d.ts","names":[],"sources":["../../src/dictionary.ts"],"mappings":"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"}
+{"version":3,"file":"dictionary.d.ts","names":[],"sources":["../../src/dictionary.ts"],"mappings":"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"}

package/dist/types/filePathPattern.d.ts

@@ -2,7 +2,7 @@ import { DeclaredLocales } from "./module_augmentation.js";
 import { DictionaryKey } from "./dictionary.js";
 //#region src/filePathPattern.d.ts
 type ContentExtension = `.${string}.${"json" | "js" | "ts" | "jsx" | "tsx" | "cjs" | "mjs"}`;
-type FilePathPatternContext = {
+export type FilePathPatternContext = {
   locale?: DeclaredLocales;
   key: DictionaryKey;
   fileName: string;
@@ -16,13 +16,12 @@ type FilePathPatternContext = {
 /**
  * Syntax for resolving file paths.
  */
-type FilePathPatternFunction = (context: FilePathPatternContext) => string | Promise<string>;
+export type FilePathPatternFunction = (context: FilePathPatternContext) => string | Promise<string>;
 /**
  * Global syntax for defining file paths and patterns.
  * Can be a static string, a templated string (e.g. `path/{{locale}}/{{key}}{{extension}}`),
  * or a function evaluating the path dynamically.
  */
-type FilePathPattern = string | FilePathPatternFunction;
+export type FilePathPattern = string | FilePathPatternFunction;
 //#endregion
-export { FilePathPattern, FilePathPatternContext, FilePathPatternFunction };
 //# sourceMappingURL=filePathPattern.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"filePathPattern.d.ts","names":[],"sources":["../../src/filePathPattern.ts"],"mappings":";;;KAGK;KAGO;EACV,SAAS;EACT,KAAK;EACL;EACA,WAAW;EACX;EACA;EAQA;EAEA;EACA;;;;;KAMU,2BACV,SAAS,oCACG;;;;;;KAOF,2BAA2B"}
+{"version":3,"file":"filePathPattern.d.ts","names":[],"sources":["../../src/filePathPattern.ts"],"mappings":";;;KAGK;YAGO;EACV,SAAS;EACT,KAAK;EACL;EACA,WAAW;EACX;EACA;EAQA;EAEA;EACA;;;;;YAMU,2BACV,SAAS,oCACG;;;;;;YAOF,2BAA2B"}

package/dist/types/index.d.ts

@@ -1,10 +1,10 @@
 import { locales_d_exports } from "./locales.js";
 import { ALL_LOCALES, Locale } from "./allLocales.js";
-import { DeclaredLocales, DeclaredVariants, DictionaryKeys, DictionaryRegistry, DictionaryRegistryContent, DictionaryRegistryElement, DictionaryRegistryResult, DictionarySelectorForKey, DomainRegistryEntry, DomainRuleMap, ExtractSelectorLocale, GetLocaleLang, IsDomainExclusive, LocaleDomainOrigin, LocalesValues, LocalizedPath, LocalizedPathname, LocalizedUrl, PathWithoutLocale, RequiredLocales, ResolvedDefaultLocale, ResolvedDomains, ResolvedEditor, ResolvedRewriteRules, ResolvedRoutingMode, RewriteRuleMap, Schema, SchemaKeys, StrictModeLocaleMap } from "./module_augmentation.js";
+import { DeclaredLocales, DeclaredVariants, DictionaryKeys, DictionaryRegistry, DictionaryRegistryContent, DictionaryRegistryElement, DictionaryRegistryResult, DictionarySelectorForKey, DomainRegistryEntry, DomainRuleMap, ExtractSelectorLocale, GetLocaleLang, IsDomainExclusive, LocaleDomainOrigin, LocalesValues, LocalizedPath, LocalizedPathname, LocalizedUrl, PathWithoutLocale, ProviderVariant, RequiredLocales, ResolvedDefaultLocale, ResolvedDomains, ResolvedEditor, ResolvedRewriteRules, ResolvedRoutingMode, RewriteRuleMap, Schema, SchemaKeys, StrictModeLocaleMap } from "./module_augmentation.js";
 import { FilePathPattern, FilePathPatternContext, FilePathPatternFunction } from "./filePathPattern.js";
 import { ARRAY, BOOLEAN, CONDITION, ENUMERATION, FILE, GENDER, HTML, INSERTION, MARKDOWN, NESTED, NULL, NUMBER, NodeType, OBJECT, PLUGIN_NODE_TYPES, PLURAL, PREACT_NODE, REACT_NODE, SELECT, SOLID_NODE, TEXT, TRANSLATION, TypedNodeModel, UNKNOWN, formatNodeType } from "./nodeType.js";
-import { ContentAutoTransformation, ContentNode, Dictionary, DictionaryFormat, DictionaryId, DictionaryKey, DictionaryLocation, DictionaryQualifierType, DictionarySelector, DictionarySelectorForGroup, DictionaryVariantChain, DictionaryVariantIdsOf, DictionaryVariantValue, Fill, GetSubPath, ImportMode, LocalDictionaryId, ProviderVariant, ProviderVariantMap, QualifiedDictionaryGroup, ResolveQualifiedDictionaryContent, TypedNode } from "./dictionary.js";
+import { ContentAutoTransformation, ContentNode, Dictionary, DictionaryFormat, DictionaryId, DictionaryKey, DictionaryLocation, DictionaryQualifierType, DictionarySelector, DictionarySelectorForGroup, DictionaryVariantChain, DictionaryVariantIdsOf, DictionaryVariantValue, Fill, GetSubPath, ImportMode, LocalDictionaryId, ProviderVariantBase, ProviderVariantMap, QualifiedDictionaryGroup, ResolveQualifiedDictionaryContent, TypedNode } from "./dictionary.js";
 import { MergedDictionaryOutput, MergedDictionaryResult, Plugin, UnmergedDictionaryOutput, UnmergedDictionaryResult } from "./plugin.js";
 import { AiConfig, AiProviderConfigMap, AiProviders, AnalyticsConfig, BuildConfig, CommonAiConfig, CompilerConfig, ConfigSchema, ContentConfig, CookiesAttributes, CustomIntlayerConfig, CustomRoutingConfig, DictionaryConfig, EditorConfig, InternationalizationConfig, IntlayerConfig, LogConfig, LogFunctions, ProcessedCookieAttributes, ProcessedStorageAttributes, RewriteObject, RewriteRule, RewriteRules, RoutingConfig, RoutingStorageInput, StorageAttributes, StrictMode, SystemConfig, URLType } from "./config.js";
 import { ArrayNode, ConditionNode, EnumerationNode, FileNode, GenderNode, HTMLNode, InsertionNode, KeyPath, MarkdownNode, NestedNode, ObjectNode, PluralNode, ReactNode, SelectNode, TranslationNode } from "./keyPath.js";
-export { ALL_LOCALES, ARRAY, AiConfig, AiProviderConfigMap, AiProviders, AnalyticsConfig, ArrayNode, BOOLEAN, BuildConfig, CONDITION, CommonAiConfig, CompilerConfig, ConditionNode, ConfigSchema, ContentAutoTransformation, ContentConfig, ContentNode, CookiesAttributes, CustomIntlayerConfig, CustomRoutingConfig, DeclaredLocales, DeclaredVariants, Dictionary, DictionaryConfig, DictionaryFormat, DictionaryId, DictionaryKey, DictionaryKeys, DictionaryLocation, DictionaryQualifierType, DictionaryRegistry, DictionaryRegistryContent, DictionaryRegistryElement, DictionaryRegistryResult, DictionarySelector, DictionarySelectorForGroup, DictionarySelectorForKey, DictionaryVariantChain, DictionaryVariantIdsOf, DictionaryVariantValue, DomainRegistryEntry, DomainRuleMap, ENUMERATION, EditorConfig, EnumerationNode, ExtractSelectorLocale, FILE, FileNode, FilePathPattern, FilePathPatternContext, FilePathPatternFunction, Fill, GENDER, GenderNode, GetLocaleLang, GetSubPath, HTML, HTMLNode, INSERTION, ImportMode, InsertionNode, InternationalizationConfig, IntlayerConfig, IsDomainExclusive, KeyPath, LocalDictionaryId, Locale, LocaleDomainOrigin, locales_d_exports as Locales, LocalesValues, LocalizedPath, LocalizedPathname, LocalizedUrl, LogConfig, LogFunctions, MARKDOWN, MarkdownNode, MergedDictionaryOutput, MergedDictionaryResult, NESTED, NULL, NUMBER, NestedNode, NodeType, OBJECT, ObjectNode, PLUGIN_NODE_TYPES, PLURAL, PREACT_NODE, PathWithoutLocale, Plugin, PluralNode, ProcessedCookieAttributes, ProcessedStorageAttributes, ProviderVariantMap, QualifiedDictionaryGroup, REACT_NODE, ReactNode, RequiredLocales, ResolveQualifiedDictionaryContent, ResolvedDefaultLocale, ResolvedDomains, ResolvedEditor, ResolvedRewriteRules, ResolvedRoutingMode, RewriteObject, RewriteRule, RewriteRuleMap, RewriteRules, RoutingConfig, RoutingStorageInput, SELECT, SOLID_NODE, Schema, SchemaKeys, SelectNode, StorageAttributes, StrictMode, StrictModeLocaleMap, SystemConfig, TEXT, TRANSLATION, TranslationNode, TypedNode, TypedNodeModel, UNKNOWN, URLType, UnmergedDictionaryOutput, UnmergedDictionaryResult, formatNodeType };
+export { ALL_LOCALES, ARRAY, AiConfig, AiProviderConfigMap, AiProviders, AnalyticsConfig, ArrayNode, BOOLEAN, BuildConfig, CONDITION, CommonAiConfig, CompilerConfig, ConditionNode, ConfigSchema, ContentAutoTransformation, ContentConfig, ContentNode, CookiesAttributes, CustomIntlayerConfig, CustomRoutingConfig, DeclaredLocales, DeclaredVariants, Dictionary, DictionaryConfig, DictionaryFormat, DictionaryId, DictionaryKey, DictionaryKeys, DictionaryLocation, DictionaryQualifierType, DictionaryRegistry, DictionaryRegistryContent, DictionaryRegistryElement, DictionaryRegistryResult, DictionarySelector, DictionarySelectorForGroup, DictionarySelectorForKey, DictionaryVariantChain, DictionaryVariantIdsOf, DictionaryVariantValue, DomainRegistryEntry, DomainRuleMap, ENUMERATION, EditorConfig, EnumerationNode, ExtractSelectorLocale, FILE, FileNode, FilePathPattern, FilePathPatternContext, FilePathPatternFunction, Fill, GENDER, GenderNode, GetLocaleLang, GetSubPath, HTML, HTMLNode, INSERTION, ImportMode, InsertionNode, InternationalizationConfig, IntlayerConfig, IsDomainExclusive, KeyPath, LocalDictionaryId, Locale, LocaleDomainOrigin, locales_d_exports as Locales, LocalesValues, LocalizedPath, LocalizedPathname, LocalizedUrl, LogConfig, LogFunctions, MARKDOWN, MarkdownNode, MergedDictionaryOutput, MergedDictionaryResult, NESTED, NULL, NUMBER, NestedNode, NodeType, OBJECT, ObjectNode, PLUGIN_NODE_TYPES, PLURAL, PREACT_NODE, PathWithoutLocale, Plugin, PluralNode, ProcessedCookieAttributes, ProcessedStorageAttributes, ProviderVariant, ProviderVariantBase, ProviderVariantMap, QualifiedDictionaryGroup, REACT_NODE, ReactNode, RequiredLocales, ResolveQualifiedDictionaryContent, ResolvedDefaultLocale, ResolvedDomains, ResolvedEditor, ResolvedRewriteRules, ResolvedRoutingMode, RewriteObject, RewriteRule, RewriteRuleMap, RewriteRules, RoutingConfig, RoutingStorageInput, SELECT, SOLID_NODE, Schema, SchemaKeys, SelectNode, StorageAttributes, StrictMode, StrictModeLocaleMap, SystemConfig, TEXT, TRANSLATION, TranslationNode, TypedNode, TypedNodeModel, UNKNOWN, URLType, UnmergedDictionaryOutput, UnmergedDictionaryResult, formatNodeType };

package/dist/types/keyPath.d.ts

@@ -1,62 +1,61 @@
-import { ARRAY, CONDITION, ENUMERATION, FILE, GENDER, HTML, INSERTION, MARKDOWN, NESTED, OBJECT, PLURAL, REACT_NODE, SELECT, TRANSLATION } from "./nodeType.js";
+import { ARRAY, CONDITION, ENUMERATION, FILE, GENDER, HTML, INSERTION, MARKDOWN, NESTED, OBJECT, PLURAL, REACT_NODE, SELECT, TRANSLATION, nodeType_d_exports } from "./nodeType.js";
 //#region src/keyPath.d.ts
-type ObjectNode = {
+export type ObjectNode = {
   type: typeof OBJECT;
   key: string;
 };
-type ArrayNode = {
+export type ArrayNode = {
   type: typeof ARRAY;
   key: number;
 };
-type EnumerationNode = {
+export type EnumerationNode = {
   type: typeof ENUMERATION;
   key: string;
 };
-type PluralNode = {
+export type PluralNode = {
   type: typeof PLURAL;
   key: string;
 };
-type TranslationNode = {
+export type TranslationNode = {
   type: typeof TRANSLATION;
   key: string;
 };
-type ConditionNode = {
+export type ConditionNode = {
   type: typeof CONDITION;
   key: string;
 };
-type GenderNode = {
+export type GenderNode = {
   type: typeof GENDER;
   key: string;
 };
-type SelectNode = {
+export type SelectNode = {
   type: typeof SELECT;
   key: string;
 };
-type InsertionNode = {
+export type InsertionNode = {
   type: typeof INSERTION;
   key?: undefined;
 };
-type MarkdownNode = {
+export type MarkdownNode = {
   type: typeof MARKDOWN;
   key?: undefined;
 };
-type ReactNode = {
+export type ReactNode = {
   type: typeof REACT_NODE;
   key?: undefined;
 };
-type NestedNode = {
+export type NestedNode = {
   type: typeof NESTED;
   key?: undefined;
 };
-type FileNode = {
+export type FileNode = {
   type: typeof FILE;
   key?: undefined;
 };
-type HTMLNode = {
+export type HTMLNode = {
   type: typeof HTML;
   key?: undefined;
 };
-type KeyPath = ObjectNode | ArrayNode | TranslationNode | EnumerationNode | PluralNode | InsertionNode | GenderNode | SelectNode | MarkdownNode | ReactNode | ConditionNode | NestedNode | FileNode | HTMLNode;
+export type KeyPath = ObjectNode | ArrayNode | TranslationNode | EnumerationNode | PluralNode | InsertionNode | GenderNode | SelectNode | MarkdownNode | ReactNode | ConditionNode | NestedNode | FileNode | HTMLNode;
 //#endregion
-export { ArrayNode, ConditionNode, EnumerationNode, FileNode, GenderNode, HTMLNode, InsertionNode, KeyPath, MarkdownNode, NestedNode, ObjectNode, PluralNode, ReactNode, SelectNode, TranslationNode };
 //# sourceMappingURL=keyPath.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"keyPath.d.ts","names":[],"sources":["../../src/keyPath.ts"],"mappings":";;KAEY;EACV,aAAa;EACb;;KAGU;EACV,aAAa;EACb;;KAGU;EACV,aAAa;EACb;;KAGU;EACV,aAAa;EACb;;KAGU;EACV,aAAa;EACb;;KAGU;EACV,aAAa;EACb;;KAGU;EACV,aAAa;EACb;;KAGU;EACV,aAAa;EACb;;KAGU;EACV,aAAa;EACb;;KAGU;EACV,aAAa;EACb;;KAGU;EACV,aAAa;EACb;;KAGU;EACV,aAAa;EACb;;KAGU;EACV,aAAa;EACb;;KAGU;EACV,aAAa;EACb;;KAGU,UACR,aACA,YACA,kBACA,kBACA,aACA,gBACA,aACA,aACA,eACA,YACA,gBACA,aACA,WACA"}
+{"version":3,"file":"keyPath.d.ts","names":[],"sources":["../../src/keyPath.ts"],"mappings":";;YAEY;EACV,aAAa;EACb;;YAGU;EACV,aAAa;EACb;;YAGU;EACV,aAAa;EACb;;YAGU;EACV,aAAa;EACb;;YAGU;EACV,aAAa;EACb;;YAGU;EACV,aAAa;EACb;;YAGU;EACV,aAAa;EACb;;YAGU;EACV,aAAa;EACb;;YAGU;EACV,aAAa;EACb;;YAGU;EACV,aAAa;EACb;;YAGU;EACV,aAAa;EACb;;YAGU;EACV,aAAa;EACb;;YAGU;EACV,aAAa;EACb;;YAGU;EACV,aAAa;EACb;;YAGU,UACR,aACA,YACA,kBACA,kBACA,aACA,gBACA,aACA,aACA,eACA,YACA,gBACA,aACA,WACA"}