@intlayer/types 9.1.0 → 9.1.2

package/dist/types/dictionary.d.ts

@@ -1,4 +1,4 @@
-import { DeclaredLocales, LocalesValues, Schema, SchemaKeys } from "./module_augmentation.js";
+import { DeclaredLocales, DeclaredVariants, LocalesValues, Schema, SchemaKeys } from "./module_augmentation.js";
 import { FilePathPattern } from "./filePathPattern.js";
 import { NodeType } from "./nodeType.js";
 //#region src/dictionary.d.ts
@@ -96,6 +96,37 @@ type DictionaryQualifierType = "variant" | "item";
  * values — an array registers the same content under every listed variant id.
  */
 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**.
+ *
+ * A chain is tried left to right against the entries the key declares, and the
+ * first declared one wins; when none is declared the implicit `default` entry
+ * is used, exactly as for a single value. So `['black-friday', 'promo']` reads
+ * as "black-friday if this key has one, else promo, else default".
+ *
+ * Note this is the mirror image of the array accepted by the `variant` field of
+ * 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[];
+/**
+ * Variant default carried by a framework provider (`<IntlayerProvider variant>`)
+ * and applied to every dictionary read below it, the way `locale` already is.
+ *
+ * Three forms:
+ * - `'school1'` — one named variant for every key
+ * - `['school1', 'default']` — an ordered {@link DictionaryVariantChain}
+ * - `{ key1: 'school1', default: 'base' }` — per dictionary key, with the
+ *   reserved `default` entry covering every key not listed
+ *
+ * On a provider a plain object is **always** read as the per-key map, never as
+ * a structured variant value — the two are structurally identical. To pin a
+ * 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>;
 /**
  * Output of the merge step for a key whose dictionaries declare one or more
  * qualifier dimensions (`variant`, `item`).
@@ -143,14 +174,20 @@ type QualifiedDictionaryGroup = {
  *
  * - `{ item: 2 }` selects a collection item (1-based index)
  * - `{ variant: 'black-friday' }` selects a named variant
+ * - `{ variant: ['black-friday', 'promo'] }` selects the first of an ordered
+ *   preference chain that the key actually declares
  * - `{ variant: { id: 'prod_abc', userId: '123' } }` selects a structured
  *   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 = {
-  locale?: LocalesValues;
+  /**
+   * Restricted to the declared locales (no `string` escape hatch), so a typo is
+   * a compile error and the declared locales are offered as suggestions.
+   */
+  locale?: DeclaredLocales;
   item?: number;
-  variant?: DictionaryVariantValue;
+  variant?: DictionaryVariantChain;
 };
 type QualifiedEntryContent<Entry> = Entry extends {
   content: infer Content;
@@ -161,8 +198,14 @@ type SplitCompositeId<Id extends string> = Id extends `${infer Head}/${infer Tai
  * Zips the declared qualifier dimensions with the segments decoded from a
  * composite id into a coordinate record (e.g. `['variant', 'item']` +
  * `['promo', '2']` → `{ variant: 'promo'; item: '2' }`).
+ *
+ * Both tuples are consumed head-first in lockstep. A mapped type over
+ * `keyof QualifierTypes` cannot be used here: remapping the keys of a tuple
+ * collapses the index into the union of all positions, so every dimension would
+ * receive the union of all segments (`{ variant: 'promo' | '2'; item: 'promo' |
+ * '2' }`) and no entry would ever compare equal to a selector coordinate.
  */
-type ZipQualifierCoordinates<QualifierTypes extends readonly DictionaryQualifierType[], Segments extends readonly string[]> = { [Index in keyof QualifierTypes as QualifierTypes[Index] extends DictionaryQualifierType ? QualifierTypes[Index] : never]: Index extends keyof Segments ? Segments[Index] : never; };
+type ZipQualifierCoordinates<QualifierTypes extends readonly DictionaryQualifierType[], Segments extends readonly string[]> = QualifierTypes extends readonly [infer Dimension extends DictionaryQualifierType, ...infer RestDimensions extends readonly DictionaryQualifierType[]] ? Segments extends readonly [infer Segment extends string, ...infer RestSegments extends readonly string[]] ? { [Key in Dimension]: Segment; } & ZipQualifierCoordinates<RestDimensions, RestSegments> : unknown : unknown;
 /**
  * Rebuilds the per-entry shape (`{ variant; item; content }`) from the
  * `content` map keyed by composite id, so the coordinate-comparison helpers can
@@ -188,25 +231,41 @@ type CoordinateEquals<Left, Right> = [StringifyCoordinate<Left>] extends [String
  * precisely; an object variant broadens to `string` (it matches any declared
  * variant entry, since the object identity is not reconstructable at the type
  * level). An absent selector defaults to the `'default'` variant.
+ *
+ * A {@link DictionaryVariantChain} broadens to the **union** of its entries:
+ * which one wins depends on what the key declares, which is a runtime fact, so
+ * the content type is the union of every outcome the chain can produce.
  */
-type SelectorVariant<Selector> = Selector extends {
-  variant: infer Variant;
-} ? Variant extends string ? Variant : string : "default";
-type SelectorItem<Selector> = Selector extends {
-  item: infer Item;
-} ? Item : undefined;
+type SelectorVariant<Selector> = "variant" extends keyof Selector ? Selector["variant" & keyof Selector] extends (infer Variant) ? Variant extends readonly (infer ChainEntry)[] ? ChainEntry extends string ? ChainEntry : string : Variant extends string ? Variant : string : never : "default";
+/** The item a selector pins, or `undefined` when it leaves the axis open. */
+type SelectorItem<Selector> = "item" extends keyof Selector ? Selector["item" & keyof Selector] : undefined;
+/**
+ * The variant ids a group declares — the first segment of every composite id
+ * (`variant` is always the outermost dimension in canonical order).
+ */
+type DeclaredVariantIds<ContentMap> = SplitCompositeId<keyof ContentMap & string>[0];
+/**
+ * The variant id a selector actually resolves to, mirroring the runtime
+ * sparse-override fallback: the requested id when the group declares it,
+ * otherwise the `'default'` entry when the group declares one.
+ *
+ * A broad (non-literal) variant — what an object variant widens to — is left
+ * untouched, since it is meant to match any declared entry.
+ */
+type EffectiveSelectorVariant<Selector, DeclaredIds extends string> = SelectorVariant<Selector> extends (infer Requested extends string) ? string extends Requested ? Requested : Requested extends DeclaredIds ? Requested : "default" extends DeclaredIds ? "default" : Requested : never;
 /**
  * Whether a single group entry matches the selector across every declared
  * dimension. The `item` dimension matches any value when the selector leaves it
- * open (collection axis).
+ * open (collection axis); the `variant` dimension is compared against the
+ * already-resolved effective id, so the `default` fallback applies here too.
  */
-type EntryMatchesSelector<Entry, QualifierTypes extends readonly DictionaryQualifierType[], Selector> = ("variant" extends QualifierTypes[number] ? Entry extends {
+type EntryMatchesSelector<Entry, QualifierTypes extends readonly DictionaryQualifierType[], Selector, EffectiveVariant> = ("variant" extends QualifierTypes[number] ? Entry extends {
   variant: infer Variant;
-} ? CoordinateEquals<Variant, SelectorVariant<Selector>> : false : true) extends true ? "item" extends QualifierTypes[number] ? [SelectorItem<Selector>] extends [undefined] ? true : Entry extends {
+} ? CoordinateEquals<Variant, EffectiveVariant> : false : true) extends true ? "item" extends QualifierTypes[number] ? [SelectorItem<Selector>] extends [undefined] ? true : Entry extends {
   item: infer Item;
 } ? CoordinateEquals<Item, SelectorItem<Selector>> : false : true : false;
 /** Entries that match the selector. */
-type MatchingEntries<Entries, QualifierTypes extends readonly DictionaryQualifierType[], Selector> = { [Key in keyof Entries as EntryMatchesSelector<Entries[Key], QualifierTypes, Selector> extends true ? Key : never]: Entries[Key]; };
+type MatchingEntries<Entries, QualifierTypes extends readonly DictionaryQualifierType[], Selector, EffectiveVariant> = { [Key in keyof Entries as EntryMatchesSelector<Entries[Key], QualifierTypes, Selector, EffectiveVariant> extends true ? Key : never]: Entries[Key]; };
 /** Whether the collection (`item`) axis is left open (→ array result). */
 type IsItemAxisOpen<QualifierTypes extends readonly DictionaryQualifierType[], Selector> = "item" extends QualifierTypes[number] ? [SelectorItem<Selector>] extends [undefined] ? true : false : false;
 /**
@@ -219,12 +278,14 @@ type IsItemAxisOpen<QualifierTypes extends readonly DictionaryQualifierType[], S
  * entry:
  * - `item` left open → array of the matching entries' content
  * - all dimensions pinned → that single entry's content (or `null` if none match)
+ * - a variant the group does not declare → the `default` entry's content, when
+ *   the group declares one (sparse-override fallback)
  * - plain dictionary → its `content` (selector ignored)
  */
 type ResolveQualifiedDictionaryContent<T, Selector = undefined> = T extends {
   qualifierTypes: infer QualifierTypes extends readonly DictionaryQualifierType[];
   content: infer ContentMap extends Record<string, any>;
-} ? ReconstructedEntries<ContentMap, QualifierTypes> extends (infer Entries) ? IsItemAxisOpen<QualifierTypes, Selector> extends true ? QualifiedEntryContent<MatchingEntries<Entries, QualifierTypes, Selector>[keyof MatchingEntries<Entries, QualifierTypes, Selector>]>[] : [keyof MatchingEntries<Entries, QualifierTypes, Selector>] extends [never] ? null : QualifiedEntryContent<MatchingEntries<Entries, QualifierTypes, Selector>[keyof MatchingEntries<Entries, QualifierTypes, Selector>]> : never : T extends {
+} ? 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 {
   content: infer Content;
 } ? Content : never;
 /** Distributes over the union of a group's entries. */
@@ -238,17 +299,87 @@ type EntryVariant<Entry> = Entry extends {
 type EntryItem<Entry> = Entry extends {
   item: infer Item;
 } ? Item : never;
+/**
+ * Every variant id a qualified group declares — the variant segment of each
+ * composite id, in its stored (serialized) form. Distributes over a union of
+ * groups so it can be applied to the whole dictionary registry at once.
+ */
+type VariantIdsOfGroup<T> = T extends {
+  qualifierTypes: infer QualifierTypes extends readonly DictionaryQualifierType[];
+  content: infer ContentMap;
+} ? "variant" extends QualifierTypes[number] ? DeclaredVariantIds<ContentMap> : never : never;
+/**
+ * Splits the serialized ids of a group into their two declaration forms. An
+ * object variant serializes to `field=value` pairs joined by `&`, so the
+ * presence of `=` discriminates it from a named (string) variant.
+ */
+type NamedVariantIds<Ids> = Ids extends `${string}=${string}` ? never : Ids;
+type ObjectVariantIds<Ids> = Ids extends `${string}=${string}` ? Ids : never;
+/** Rebuilds one `field=value` pair into `{ field: value }`. */
+type ParseVariantPair<Pair extends string> = Pair extends `${infer Field}=${infer Value}` ? { [Key in Field]: Value; } : never;
+/**
+ * Rebuilds a serialized object-variant id into the object literal that declared
+ * it (`'category=audio&id=abc'` → `{ category: 'audio'; id: 'abc' }`), so the
+ * selector is typed by the declaration rather than by its storage encoding.
+ *
+ * Values come back as string literals: the serialization stringifies numbers,
+ * and percent-encoded characters (see `serializeVariant`) are not decoded, so a
+ * variant whose field values contain path-hostile characters is matched on its
+ * encoded form.
+ */
+type ParseObjectVariantId<Id extends string> = Id extends `${infer Pair}&${infer Rest}` ? ParseVariantPair<Pair> & ParseObjectVariantId<Rest> : ParseVariantPair<Id>;
+/**
+ * The **named** variant ids declared by a group (or by a union of groups).
+ * 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>>;
+/**
+ * The object variants a group declares, rebuilt into their declared shape.
+ *
+ * Left as the intersection `ParseObjectVariantId` accumulates: wrapping it in a
+ * flattening mapped type makes TypeScript print the wrapper's name instead of
+ * resolving it, which hides the accepted values from the error message.
+ */
+type DictionaryObjectVariantsOf<T> = ParseObjectVariantId<ObjectVariantIds<VariantIdsOfGroup<T>> & string>;
+/**
+ * Whether a group declares a `default` entry — the target every undeclared
+ * variant falls back to. A group without one (an object-variant catalogue, say)
+ * resolves an undeclared variant to `null`, so it cannot accept the project
+ * vocabulary.
+ */
+type HasDefaultVariant<T> = "default" extends VariantIdsOfGroup<T> ? true : false;
 /**
  * The selector accepted for a specific qualified dictionary group `T`: each
  * dimension is constrained to the coordinates that actually exist, so an unknown
- * `item` is a compile-time error. Named (string) variants are suggested for
- * autocomplete; object variants are accepted via the loose `Record` form. Plain
- * dictionaries (no `entries`) fall back to the loose {@link DictionarySelector}.
+ * `item` is a compile-time error. Plain dictionaries (no `entries`) fall back to
+ * the loose {@link DictionarySelector}.
+ *
+ * The two variant forms are scoped differently, because they mean different
+ * things:
+ *
+ * - **Named** variants always accept the names this key declares. A key that
+ *   also declares a `default` entry additionally accepts any name declared
+ *   **anywhere in the project** (`KnownVariants`), because an undeclared name
+ *   resolves to that `default` entry at runtime. That is what makes the
+ *   sparse-override pattern typecheck — one session-wide variant passed to every
+ *   key, most of which override nothing — while still rejecting a name no
+ *   dictionary declares (a typo). A key **without** a `default` entry resolves
+ *   an undeclared name to `null`, so it accepts only its own names.
+ * - **Object** variants address one specific record, so they are restricted to
+ *   the objects **this key** declares, rebuilt from their stored form. They are
+ *   never accepted in their serialized string form (`'id=abc&userId=123'`) —
+ *   that is a storage encoding, not part of the API.
  */
-type DictionarySelectorForGroup<T> = [GroupEntryUnion<T>] extends [never] ? DictionarySelector : {
-  locale?: LocalesValues;
+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 : {
+  locale?: DeclaredLocales;
 } & ([EntryVariant<GroupEntryUnion<T>>] extends [never] ? unknown : {
-  variant?: EntryVariant<GroupEntryUnion<T>> | (string & {}) | Record<string, string | number>;
+  /**
+   * One variant, or an ordered preference chain of them — every value
+   * accepted alone is also accepted as a chain entry.
+   */
+  variant?: SelectableVariantsOf<T, KnownVariants> | readonly SelectableVariantsOf<T, KnownVariants>[];
 }) & ([EntryItem<GroupEntryUnion<T>>] extends [never] ? unknown : {
   item?: EntryItem<GroupEntryUnion<T>> | number | (string & {});
 });
@@ -613,5 +744,5 @@ type DictionaryWithoutSchema<ContentType, FetchableNode> = {
 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;
 //#endregion
-export { ContentAutoTransformation, ContentNode, Dictionary, DictionaryFormat, DictionaryId, DictionaryKey, DictionaryLocation, DictionaryQualifierType, DictionarySelector, DictionarySelectorForGroup, DictionaryVariantValue, Fill, GetSubPath, ImportMode, LocalDictionaryId, QualifiedDictionaryGroup, ResolveQualifiedDictionaryContent, TypedNode };
+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/index.d.ts

@@ -1,10 +1,10 @@
 import { locales_d_exports } from "./locales.js";
 import { ALL_LOCALES, Locale } from "./allLocales.js";
-import { DeclaredLocales, DictionaryKeys, DictionaryRegistry, DictionaryRegistryContent, DictionaryRegistryElement, DictionaryRegistryResult, DictionarySelectorForKey, ExtractSelectorLocale, GetLocaleLang, LocalesValues, LocalizedUrl, PathWithoutLocale, RequiredLocales, ResolvedDefaultLocale, ResolvedEditor, ResolvedRoutingMode, Schema, SchemaKeys, StrictModeLocaleMap } from "./module_augmentation.js";
+import { DeclaredLocales, DeclaredVariants, DictionaryKeys, DictionaryRegistry, DictionaryRegistryContent, DictionaryRegistryElement, DictionaryRegistryResult, DictionarySelectorForKey, ExtractSelectorLocale, GetLocaleLang, LocalesValues, LocalizedUrl, PathWithoutLocale, RequiredLocales, ResolvedDefaultLocale, ResolvedEditor, ResolvedRoutingMode, 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, DictionaryVariantValue, Fill, GetSubPath, ImportMode, LocalDictionaryId, QualifiedDictionaryGroup, ResolveQualifiedDictionaryContent, TypedNode } from "./dictionary.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 { 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, Dictionary, DictionaryConfig, DictionaryFormat, DictionaryId, DictionaryKey, DictionaryKeys, DictionaryLocation, DictionaryQualifierType, DictionaryRegistry, DictionaryRegistryContent, DictionaryRegistryElement, DictionaryRegistryResult, DictionarySelector, DictionarySelectorForGroup, DictionarySelectorForKey, DictionaryVariantValue, ENUMERATION, EditorConfig, EnumerationNode, ExtractSelectorLocale, FILE, FileNode, FilePathPattern, FilePathPatternContext, FilePathPatternFunction, Fill, GENDER, GenderNode, GetLocaleLang, GetSubPath, HTML, HTMLNode, INSERTION, ImportMode, InsertionNode, InternationalizationConfig, IntlayerConfig, KeyPath, LocalDictionaryId, Locale, locales_d_exports as Locales, LocalesValues, 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, QualifiedDictionaryGroup, REACT_NODE, ReactNode, RequiredLocales, ResolveQualifiedDictionaryContent, ResolvedDefaultLocale, ResolvedEditor, ResolvedRoutingMode, RewriteObject, RewriteRule, 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, ENUMERATION, EditorConfig, EnumerationNode, ExtractSelectorLocale, FILE, FileNode, FilePathPattern, FilePathPatternContext, FilePathPatternFunction, Fill, GENDER, GenderNode, GetLocaleLang, GetSubPath, HTML, HTMLNode, INSERTION, ImportMode, InsertionNode, InternationalizationConfig, IntlayerConfig, KeyPath, LocalDictionaryId, Locale, locales_d_exports as Locales, LocalesValues, 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, ResolvedEditor, ResolvedRoutingMode, RewriteObject, RewriteRule, 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/module_augmentation.d.ts

@@ -1,5 +1,5 @@
 import { Locale } from "./allLocales.js";
-import { Dictionary, DictionarySelector, DictionarySelectorForGroup, ResolveQualifiedDictionaryContent } from "./dictionary.js";
+import { Dictionary, DictionarySelector, DictionarySelectorForGroup, DictionaryVariantIdsOf, ProviderVariant as ProviderVariant$1, ResolveQualifiedDictionaryContent } from "./dictionary.js";
 import { StrictMode } from "./config.js";
 import { __DeclaredLocalesRegistry, __DictionaryRegistry, __EditorRegistry, __RequiredLocalesRegistry, __RoutingRegistry, __SchemaRegistry, __StrictModeRegistry } from "intlayer";
 //#region src/module_augmentation.d.ts
@@ -28,12 +28,41 @@ type DictionaryRegistryResult<T extends PropertyKey, Arg = undefined> = [T] exte
 type ExtractSelectorLocale<Arg> = Arg extends {
   locale: infer L extends LocalesValues;
 } ? L : Arg extends LocalesValues ? Arg : DeclaredLocales;
+/**
+ * Every named variant declared anywhere in the project — the vocabulary of
+ * variant names collected across the whole dictionary registry. `never` when the
+ * project declares no variant at all.
+ *
+ * This is the domain a `variant` selector is checked against, rather than the
+ * names of the single key being read: a key that declares no entry for the
+ * selected variant falls back to its `default` entry at runtime, so one
+ * session-wide variant can legitimately be passed to every key. Checking against
+ * the project vocabulary keeps that legal while still catching a name that no
+ * dictionary declares.
+ *
+ * Kept as a plain alias (the `never` fallback lives at the use site) so
+ * TypeScript prints this name in error messages instead of expanding the
+ * registry inline.
+ */
+type DeclaredVariants = DictionaryVariantIdsOf<__DictionaryRegistry[keyof __DictionaryRegistry]>;
 /**
  * The selector accepted for a dictionary **key** `T`: its `variant` / `item` /
  * `id` are constrained to the coordinates that exist for that key, so an unknown
  * value is a compile-time error. Plain keys fall back to {@link DictionarySelector}.
  */
 type DictionarySelectorForKey<T extends PropertyKey> = [T] extends [keyof __DictionaryRegistry] ? DictionarySelectorForGroup<__DictionaryRegistry[T]> : DictionarySelector;
+/**
+ * The `variant` prop of a framework provider (`<IntlayerProvider variant>`),
+ * narrowed to this project's declared dictionary keys — so the per-key map form
+ * rejects a key no dictionary declares.
+ *
+ * That narrowing is also what keeps the per-key map safely distinguishable from
+ * a structured variant value: on a provider a plain object is always read as
+ * the map, and `variant={{ id: 'prod_abc' }}` is a compile error unless `id`
+ * happens to be a dictionary key. Pin a structured variant globally by nesting
+ * it under an entry instead: `variant={{ default: { id: 'prod_abc' } }}`.
+ */
+type ProviderVariant = ProviderVariant$1<DictionaryKeys & string>;
 type NarrowStringKeys<T> = string extends keyof T ? never : Extract<keyof T, string>;
 type DeclaredLocales = [NarrowStringKeys<__DeclaredLocalesRegistry>] extends [never] ? Locale : NarrowStringKeys<__DeclaredLocalesRegistry>;
 type RequiredLocales = [NarrowStringKeys<__RequiredLocalesRegistry>] extends [never] ? never : NarrowStringKeys<__RequiredLocalesRegistry>;
@@ -98,5 +127,5 @@ type GetLocaleLang<L extends string> = L extends `${infer Lang}-${string}` ? Lan
  */
 type PathWithoutLocale<Path extends string, Locales extends string> = Path extends `${infer Protocol}://${infer Domain}/${infer Seg}/${infer Rest}` ? Seg extends Locales ? `${Protocol}://${Domain}/${Rest}` : Path : Path extends `${infer Protocol}://${infer Domain}/${infer Seg}` ? Seg extends Locales ? `${Protocol}://${Domain}/` : Path : Path extends `/${infer Seg}/${infer Rest}` ? Seg extends Locales ? `/${Rest}` : Path : Path extends `/${infer Seg}` ? Seg extends Locales ? "/" : Path : Path;
 //#endregion
-export { DeclaredLocales, DictionaryKeys, DictionaryRegistry, DictionaryRegistryContent, DictionaryRegistryElement, DictionaryRegistryResult, type DictionarySelector, type DictionarySelectorForGroup, DictionarySelectorForKey, ExtractSelectorLocale, GetLocaleLang, LocalesValues, LocalizedUrl, PathWithoutLocale, RequiredLocales, ResolvedDefaultLocale, ResolvedEditor, ResolvedRoutingMode, Schema, SchemaKeys, StrictModeLocaleMap };
+export { DeclaredLocales, DeclaredVariants, DictionaryKeys, DictionaryRegistry, DictionaryRegistryContent, DictionaryRegistryElement, DictionaryRegistryResult, type DictionarySelector, type DictionarySelectorForGroup, DictionarySelectorForKey, ExtractSelectorLocale, GetLocaleLang, LocalesValues, LocalizedUrl, PathWithoutLocale, ProviderVariant, RequiredLocales, ResolvedDefaultLocale, ResolvedEditor, ResolvedRoutingMode, Schema, SchemaKeys, StrictModeLocaleMap };
 //# sourceMappingURL=module_augmentation.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"module_augmentation.d.ts","names":[],"sources":["../../src/module_augmentation.ts"],"mappings":";;;;;KAkBY,mBAAmB,gDAErB;KAEE,OAAO,UAAU,gCAAgC,WAEzD,gBAAgB,mBACd,iBAAiB;KAGX,uBAAuB,oDAEzB;KAGE,qBACV,2BAA2B,sCACvB,eAAe,cACf;KAEM,0BAA0B,UAAU,oCAErC,KACP,aACA,gBAAgB,uBACd,qBAAqB,WAAW,aAC9B,qBAAqB,KACrB,aACF;KAEM,0BAA0B,UAAU,gBAAgB,kBACxD,wBAEJ,qBAAqB;EAAa,eAAe;IAC/C,IACA,wBACF;;;;;;;;;;KAWQ,yBAAyB,UAAU,aAAa,oBAC1D,kBACe,wBACb,kCAAkC,qBAAqB,IAAI,OAC3D;;;;;KAMQ,sBAAsB,OAAO;EACvC,cAAc,UAAU;IAEtB,IACA,YAAY,gBACV,MACA;;;;;;KAOM,yBAAyB,UAAU,gBAAgB,kBACvD,wBAEJ,2BAA2B,qBAAqB,MAChD;KAMC,iBAAiB,0BAA0B,YAE5C,cAAc;KAEN,mBACV,iBAAiB,8CAEf,SACA,iBAAiB;KAET,mBACV,iBAAiB,sDAGf,iBAAiB;;KAGT,gBAAgB;KAGvB,qBAAqB;EAA+B,YAAY;IACjE;KAIQ,oBACV,mBACA,aAAa,aAAa,sBACxB,gCACA,QAAQ,OAAO,QAAQ,YACvB,wBACE,SAAS,OAAO,iBAAiB,YAC/B,QAAQ,OAAO,iBAAiB,YAClC,2BACE,SAAS,OAAO,iBAAiB,YAC/B,QAAQ,OAAO,QAAQ,YACzB,QAAQ,OAAO,QAAQ;KAGnB,eAAe,MAAM,UAAU;EACzC;IAEE,SACA;KAIC;;KAOO,sBAAsB;EAChC,YAAY,UAAU;IAEpB;;KAIQ,wBAAwB;EAClC,qBAAqB,UAAU;IAE7B,IACA;;KAKC,oBACH,kBACA,qBACA,0BACE,+BACG,OACH,mCACE,UAAU,kBAEL;;KAIN,iBACH,qBACA,yBACE,oBACA,OACA,uBAAuB,aACjB,SAAS,SACb;;;;;;;;;;;;;;;;KAiBM,aACV,qBACA,UAAU,eACV,sBAAsB,qBACtB,gBAAgB,gBAAgB,uBAChC,yBAAyB,8CACL,iBAElB,2BACE,kBAAkB,MAAM,WACxB,wCAEE,iBACE,kBAAkB,MAAM,UACxB,oBAAoB,GAAG,MAAM;;;;;;;;KAU3B,cAAc,oBACxB,mBAAmB,mBAAmB,OAAO;;;;;;;;;;;;;;KAenC,kBAAkB,qBAAqB,0BAEjD,sBAAsB,oBAAoB,gBAAgB,aAAa,SACnE,YAAY,aACP,cAAc,UAAU,SAC3B,OAEF,sBAAsB,oBAAoB,gBAAgB,QACxD,YAAY,aACP,cAAc,YACjB,OAEF,uBAAuB,aAAa,SAClC,YAAY,cACN,SACJ,OAEF,uBAAuB,QACrB,YAAY,gBAEV,OACF"}
+{"version":3,"file":"module_augmentation.d.ts","names":[],"sources":["../../src/module_augmentation.ts"],"mappings":";;;;;KAoBY,mBAAmB,gDAErB;KAEE,OAAO,UAAU,gCAAgC,WAEzD,gBAAgB,mBACd,iBAAiB;KAGX,uBAAuB,oDAEzB;KAGE,qBACV,2BAA2B,sCACvB,eAAe,cACf;KAEM,0BAA0B,UAAU,oCAErC,KACP,aACA,gBAAgB,uBACd,qBAAqB,WAAW,aAC9B,qBAAqB,KACrB,aACF;KAEM,0BAA0B,UAAU,gBAAgB,kBACxD,wBAEJ,qBAAqB;EAAa,eAAe;IAC/C,IACA,wBACF;;;;;;;;;;KAWQ,yBAAyB,UAAU,aAAa,oBAC1D,kBACe,wBACb,kCAAkC,qBAAqB,IAAI,OAC3D;;;;;KAMQ,sBAAsB,OAAO;EACvC,cAAc,UAAU;IAEtB,IACA,YAAY,gBACV,MACA;;;;;;;;;;;;;;;;;KAkBM,mBAAmB,uBAC7B,2BAA2B;;;;;;KAQjB,yBAAyB,UAAU,gBAAgB,kBACvD,wBAEJ,2BAA2B,qBAAqB,MAChD;;;;;;;;;;;;KAaQ,kBAAkB,kBAAoB;KAM7C,iBAAiB,0BAA0B,YAE5C,cAAc;KAEN,mBACV,iBAAiB,8CAEf,SACA,iBAAiB;KAET,mBACV,iBAAiB,sDAGf,iBAAiB;;KAGT,gBAAgB;KAGvB,qBAAqB;EAA+B,YAAY;IACjE;KAIQ,oBACV,mBACA,aAAa,aAAa,sBACxB,gCACA,QAAQ,OAAO,QAAQ,YACvB,wBACE,SAAS,OAAO,iBAAiB,YAC/B,QAAQ,OAAO,iBAAiB,YAClC,2BACE,SAAS,OAAO,iBAAiB,YAC/B,QAAQ,OAAO,QAAQ,YACzB,QAAQ,OAAO,QAAQ;KAGnB,eAAe,MAAM,UAAU;EACzC;IAEE,SACA;KAIC;;KAOO,sBAAsB;EAChC,YAAY,UAAU;IAEpB;;KAIQ,wBAAwB;EAClC,qBAAqB,UAAU;IAE7B,IACA;;KAKC,oBACH,kBACA,qBACA,0BACE,+BACG,OACH,mCACE,UAAU,kBAEL;;KAIN,iBACH,qBACA,yBACE,oBACA,OACA,uBAAuB,aACjB,SAAS,SACb;;;;;;;;;;;;;;;;KAiBM,aACV,qBACA,UAAU,eACV,sBAAsB,qBACtB,gBAAgB,gBAAgB,uBAChC,yBAAyB,8CACL,iBAElB,2BACE,kBAAkB,MAAM,WACxB,wCAEE,iBACE,kBAAkB,MAAM,UACxB,oBAAoB,GAAG,MAAM;;;;;;;;KAU3B,cAAc,oBACxB,mBAAmB,mBAAmB,OAAO;;;;;;;;;;;;;;KAenC,kBAAkB,qBAAqB,0BAEjD,sBAAsB,oBAAoB,gBAAgB,aAAa,SACnE,YAAY,aACP,cAAc,UAAU,SAC3B,OAEF,sBAAsB,oBAAoB,gBAAgB,QACxD,YAAY,aACP,cAAc,YACjB,OAEF,uBAAuB,aAAa,SAClC,YAAY,cACN,SACJ,OAEF,uBAAuB,QACrB,YAAY,gBAEV,OACF"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intlayer/types",
-  "version": "9.1.0",
+  "version": "9.1.2",
   "private": false,
   "description": "Retrieve Intlayer configurations and manage environment variables for both server-side and client-side environments.",
   "keywords": [