@intlayer/types 9.0.2 → 9.1.1

package/dist/cjs/index.cjs

@@ -34,6 +34,7 @@ exports.PLUGIN_NODE_TYPES = require_nodeType.PLUGIN_NODE_TYPES;
 exports.PLURAL = require_nodeType.PLURAL;
 exports.PREACT_NODE = require_nodeType.PREACT_NODE;
 exports.REACT_NODE = require_nodeType.REACT_NODE;
+exports.SELECT = require_nodeType.SELECT;
 exports.SOLID_NODE = require_nodeType.SOLID_NODE;
 exports.TEXT = require_nodeType.TEXT;
 exports.TRANSLATION = require_nodeType.TRANSLATION;

package/dist/cjs/nodeType.cjs

@@ -19,6 +19,7 @@ const TEXT = "text";
 const NUMBER = "number";
 const BOOLEAN = "boolean";
 const GENDER = "gender";
+const SELECT = "select";
 const NULL = "null";
 const UNKNOWN = "unknown";
 /**
@@ -32,6 +33,7 @@ const PLUGIN_NODE_TYPES = [
 	CONDITION,
 	INSERTION,
 	GENDER,
+	SELECT,
 	NESTED,
 	FILE,
 	MARKDOWN,
@@ -64,6 +66,7 @@ exports.PLUGIN_NODE_TYPES = PLUGIN_NODE_TYPES;
 exports.PLURAL = PLURAL;
 exports.PREACT_NODE = PREACT_NODE;
 exports.REACT_NODE = REACT_NODE;
+exports.SELECT = SELECT;
 exports.SOLID_NODE = SOLID_NODE;
 exports.TEXT = TEXT;
 exports.TRANSLATION = TRANSLATION;

package/dist/cjs/nodeType.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"nodeType.cjs","names":[],"sources":["../../src/nodeType.ts"],"sourcesContent":["export const TRANSLATION = 'translation' as const;\nexport const ENUMERATION = 'enumeration' as const;\nexport const PLURAL = 'plural' as const;\nexport const CONDITION = 'condition' as const;\nexport const INSERTION = 'insertion' as const;\nexport const FILE = 'file' as const;\nexport const OBJECT = 'object' as const;\nexport const ARRAY = 'array' as const;\nexport const NESTED = 'nested' as const;\nexport const REACT_NODE = 'reactNode' as const;\nexport const PREACT_NODE = 'preactNode' as const;\nexport const SOLID_NODE = 'solidNode' as const;\nexport const MARKDOWN = 'markdown' as const;\nexport const HTML = 'html' as const;\nexport const TEXT = 'text' as const;\nexport const NUMBER = 'number' as const;\nexport const BOOLEAN = 'boolean' as const;\nexport const GENDER = 'gender' as const;\nexport const NULL = 'null' as const;\nexport const UNKNOWN = 'unknown' as const;\n\n/**\n * NodeType strings that correspond to plugins that can be conditionally\n * removed from the bundle when unused.\n */\nexport const PLUGIN_NODE_TYPES: readonly [\n  typeof TRANSLATION,\n  typeof ENUMERATION,\n  typeof PLURAL,\n  typeof CONDITION,\n  typeof INSERTION,\n  typeof GENDER,\n  typeof NESTED,\n  typeof FILE,\n  typeof MARKDOWN,\n  typeof HTML,\n  typeof REACT_NODE,\n  typeof PREACT_NODE,\n  typeof SOLID_NODE,\n] = [\n  TRANSLATION,\n  ENUMERATION,\n  PLURAL,\n  CONDITION,\n  INSERTION,\n  GENDER,\n  NESTED,\n  FILE,\n  MARKDOWN,\n  HTML,\n  REACT_NODE,\n  PREACT_NODE,\n  SOLID_NODE,\n] as const;\n\nexport type NodeType =\n  | typeof TRANSLATION\n  | typeof ENUMERATION\n  | typeof PLURAL\n  | typeof CONDITION\n  | typeof INSERTION\n  | typeof FILE\n  | typeof OBJECT\n  | typeof ARRAY\n  | typeof NESTED\n  | typeof REACT_NODE\n  | typeof PREACT_NODE\n  | typeof SOLID_NODE\n  | typeof MARKDOWN\n  | typeof HTML\n  | typeof TEXT\n  | typeof NUMBER\n  | typeof BOOLEAN\n  | typeof GENDER\n  | typeof NULL\n  | typeof UNKNOWN;\n\ntype AdditionalAttributesType = {\n  [key: string]: unknown;\n};\n\nexport type TypedNodeModel<\n  T extends NodeType,\n  Content,\n  AdditionalAttributes extends AdditionalAttributesType = {},\n> = {\n  nodeType: T;\n} & {\n  [K in T]: Content;\n} & AdditionalAttributes;\n\nexport const formatNodeType = <\n  T extends NodeType,\n  Content = unknown,\n  AdditionalAttributes extends AdditionalAttributesType = {},\n>(\n  nodeType: T,\n  content: Content,\n  additionalAttributes?: { [key: string]: unknown }\n) =>\n  ({\n    ...additionalAttributes,\n    nodeType,\n    [nodeType]: content,\n  }) as TypedNodeModel<T, Content, AdditionalAttributes>;\n"],"mappings":";;;AAAA,MAAa,cAAc;AAC3B,MAAa,cAAc;AAC3B,MAAa,SAAS;AACtB,MAAa,YAAY;AACzB,MAAa,YAAY;AACzB,MAAa,OAAO;AACpB,MAAa,SAAS;AACtB,MAAa,QAAQ;AACrB,MAAa,SAAS;AACtB,MAAa,aAAa;AAC1B,MAAa,cAAc;AAC3B,MAAa,aAAa;AAC1B,MAAa,WAAW;AACxB,MAAa,OAAO;AACpB,MAAa,OAAO;AACpB,MAAa,SAAS;AACtB,MAAa,UAAU;AACvB,MAAa,SAAS;AACtB,MAAa,OAAO;AACpB,MAAa,UAAU;;;;;AAMvB,MAAa,oBAcT;CACF;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;AAsCA,MAAa,kBAKX,UACA,SACA,0BAEC;CACC,GAAG;CACH;EACC,WAAW;AACd"}
+{"version":3,"file":"nodeType.cjs","names":[],"sources":["../../src/nodeType.ts"],"sourcesContent":["export const TRANSLATION = 'translation' as const;\nexport const ENUMERATION = 'enumeration' as const;\nexport const PLURAL = 'plural' as const;\nexport const CONDITION = 'condition' as const;\nexport const INSERTION = 'insertion' as const;\nexport const FILE = 'file' as const;\nexport const OBJECT = 'object' as const;\nexport const ARRAY = 'array' as const;\nexport const NESTED = 'nested' as const;\nexport const REACT_NODE = 'reactNode' as const;\nexport const PREACT_NODE = 'preactNode' as const;\nexport const SOLID_NODE = 'solidNode' as const;\nexport const MARKDOWN = 'markdown' as const;\nexport const HTML = 'html' as const;\nexport const TEXT = 'text' as const;\nexport const NUMBER = 'number' as const;\nexport const BOOLEAN = 'boolean' as const;\nexport const GENDER = 'gender' as const;\nexport const SELECT = 'select' as const;\nexport const NULL = 'null' as const;\nexport const UNKNOWN = 'unknown' as const;\n\n/**\n * NodeType strings that correspond to plugins that can be conditionally\n * removed from the bundle when unused.\n */\nexport const PLUGIN_NODE_TYPES: readonly [\n  typeof TRANSLATION,\n  typeof ENUMERATION,\n  typeof PLURAL,\n  typeof CONDITION,\n  typeof INSERTION,\n  typeof GENDER,\n  typeof SELECT,\n  typeof NESTED,\n  typeof FILE,\n  typeof MARKDOWN,\n  typeof HTML,\n  typeof REACT_NODE,\n  typeof PREACT_NODE,\n  typeof SOLID_NODE,\n] = [\n  TRANSLATION,\n  ENUMERATION,\n  PLURAL,\n  CONDITION,\n  INSERTION,\n  GENDER,\n  SELECT,\n  NESTED,\n  FILE,\n  MARKDOWN,\n  HTML,\n  REACT_NODE,\n  PREACT_NODE,\n  SOLID_NODE,\n] as const;\n\nexport type NodeType =\n  | typeof TRANSLATION\n  | typeof ENUMERATION\n  | typeof PLURAL\n  | typeof CONDITION\n  | typeof INSERTION\n  | typeof FILE\n  | typeof OBJECT\n  | typeof ARRAY\n  | typeof NESTED\n  | typeof REACT_NODE\n  | typeof PREACT_NODE\n  | typeof SOLID_NODE\n  | typeof MARKDOWN\n  | typeof HTML\n  | typeof TEXT\n  | typeof NUMBER\n  | typeof BOOLEAN\n  | typeof GENDER\n  | typeof SELECT\n  | typeof NULL\n  | typeof UNKNOWN;\n\ntype AdditionalAttributesType = {\n  [key: string]: unknown;\n};\n\nexport type TypedNodeModel<\n  T extends NodeType,\n  Content,\n  AdditionalAttributes extends AdditionalAttributesType = {},\n> = {\n  nodeType: T;\n} & {\n  [K in T]: Content;\n} & AdditionalAttributes;\n\nexport const formatNodeType = <\n  T extends NodeType,\n  Content = unknown,\n  AdditionalAttributes extends AdditionalAttributesType = {},\n>(\n  nodeType: T,\n  content: Content,\n  additionalAttributes?: { [key: string]: unknown }\n) =>\n  ({\n    ...additionalAttributes,\n    nodeType,\n    [nodeType]: content,\n  }) as TypedNodeModel<T, Content, AdditionalAttributes>;\n"],"mappings":";;;AAAA,MAAa,cAAc;AAC3B,MAAa,cAAc;AAC3B,MAAa,SAAS;AACtB,MAAa,YAAY;AACzB,MAAa,YAAY;AACzB,MAAa,OAAO;AACpB,MAAa,SAAS;AACtB,MAAa,QAAQ;AACrB,MAAa,SAAS;AACtB,MAAa,aAAa;AAC1B,MAAa,cAAc;AAC3B,MAAa,aAAa;AAC1B,MAAa,WAAW;AACxB,MAAa,OAAO;AACpB,MAAa,OAAO;AACpB,MAAa,SAAS;AACtB,MAAa,UAAU;AACvB,MAAa,SAAS;AACtB,MAAa,SAAS;AACtB,MAAa,OAAO;AACpB,MAAa,UAAU;;;;;AAMvB,MAAa,oBAeT;CACF;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;AAuCA,MAAa,kBAKX,UACA,SACA,0BAEC;CACC,GAAG;CACH;EACC,WAAW;AACd"}

package/dist/esm/index.mjs

@@ -1,4 +1,4 @@
-import { ARRAY, BOOLEAN, CONDITION, ENUMERATION, FILE, GENDER, HTML, INSERTION, MARKDOWN, NESTED, NULL, NUMBER, OBJECT, PLUGIN_NODE_TYPES, PLURAL, PREACT_NODE, REACT_NODE, SOLID_NODE, TEXT, TRANSLATION, UNKNOWN, formatNodeType } from "./nodeType.mjs";
+import { ARRAY, BOOLEAN, CONDITION, ENUMERATION, FILE, GENDER, HTML, INSERTION, MARKDOWN, NESTED, NULL, NUMBER, OBJECT, PLUGIN_NODE_TYPES, PLURAL, PREACT_NODE, REACT_NODE, SELECT, SOLID_NODE, TEXT, TRANSLATION, UNKNOWN, formatNodeType } from "./nodeType.mjs";
 import "./dictionary.mjs";
 import * as locales_exports from "./locales.mjs";
 import "./plugin.mjs";
@@ -8,4 +8,4 @@ import "./module_augmentation.mjs";
 import { ALL_LOCALES } from "./allLocales.mjs";
 import { AiProviders } from "./config.mjs";
 
-export { ALL_LOCALES, ARRAY, AiProviders, BOOLEAN, CONDITION, ENUMERATION, FILE, GENDER, HTML, INSERTION, locales_exports as Locales, MARKDOWN, NESTED, NULL, NUMBER, OBJECT, PLUGIN_NODE_TYPES, PLURAL, PREACT_NODE, REACT_NODE, SOLID_NODE, TEXT, TRANSLATION, UNKNOWN, formatNodeType };
+export { ALL_LOCALES, ARRAY, AiProviders, BOOLEAN, CONDITION, ENUMERATION, FILE, GENDER, HTML, INSERTION, locales_exports as Locales, MARKDOWN, NESTED, NULL, NUMBER, OBJECT, PLUGIN_NODE_TYPES, PLURAL, PREACT_NODE, REACT_NODE, SELECT, SOLID_NODE, TEXT, TRANSLATION, UNKNOWN, formatNodeType };

package/dist/esm/nodeType.mjs

@@ -17,6 +17,7 @@ const TEXT = "text";
 const NUMBER = "number";
 const BOOLEAN = "boolean";
 const GENDER = "gender";
+const SELECT = "select";
 const NULL = "null";
 const UNKNOWN = "unknown";
 /**
@@ -30,6 +31,7 @@ const PLUGIN_NODE_TYPES = [
 	CONDITION,
 	INSERTION,
 	GENDER,
+	SELECT,
 	NESTED,
 	FILE,
 	MARKDOWN,
@@ -45,5 +47,5 @@ const formatNodeType = (nodeType, content, additionalAttributes) => ({
 });
 
 //#endregion
-export { ARRAY, BOOLEAN, CONDITION, ENUMERATION, FILE, GENDER, HTML, INSERTION, MARKDOWN, NESTED, NULL, NUMBER, OBJECT, PLUGIN_NODE_TYPES, PLURAL, PREACT_NODE, REACT_NODE, SOLID_NODE, TEXT, TRANSLATION, UNKNOWN, formatNodeType };
+export { ARRAY, BOOLEAN, CONDITION, ENUMERATION, FILE, GENDER, HTML, INSERTION, MARKDOWN, NESTED, NULL, NUMBER, OBJECT, PLUGIN_NODE_TYPES, PLURAL, PREACT_NODE, REACT_NODE, SELECT, SOLID_NODE, TEXT, TRANSLATION, UNKNOWN, formatNodeType };
 //# sourceMappingURL=nodeType.mjs.map

package/dist/esm/nodeType.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"nodeType.mjs","names":[],"sources":["../../src/nodeType.ts"],"sourcesContent":["export const TRANSLATION = 'translation' as const;\nexport const ENUMERATION = 'enumeration' as const;\nexport const PLURAL = 'plural' as const;\nexport const CONDITION = 'condition' as const;\nexport const INSERTION = 'insertion' as const;\nexport const FILE = 'file' as const;\nexport const OBJECT = 'object' as const;\nexport const ARRAY = 'array' as const;\nexport const NESTED = 'nested' as const;\nexport const REACT_NODE = 'reactNode' as const;\nexport const PREACT_NODE = 'preactNode' as const;\nexport const SOLID_NODE = 'solidNode' as const;\nexport const MARKDOWN = 'markdown' as const;\nexport const HTML = 'html' as const;\nexport const TEXT = 'text' as const;\nexport const NUMBER = 'number' as const;\nexport const BOOLEAN = 'boolean' as const;\nexport const GENDER = 'gender' as const;\nexport const NULL = 'null' as const;\nexport const UNKNOWN = 'unknown' as const;\n\n/**\n * NodeType strings that correspond to plugins that can be conditionally\n * removed from the bundle when unused.\n */\nexport const PLUGIN_NODE_TYPES: readonly [\n  typeof TRANSLATION,\n  typeof ENUMERATION,\n  typeof PLURAL,\n  typeof CONDITION,\n  typeof INSERTION,\n  typeof GENDER,\n  typeof NESTED,\n  typeof FILE,\n  typeof MARKDOWN,\n  typeof HTML,\n  typeof REACT_NODE,\n  typeof PREACT_NODE,\n  typeof SOLID_NODE,\n] = [\n  TRANSLATION,\n  ENUMERATION,\n  PLURAL,\n  CONDITION,\n  INSERTION,\n  GENDER,\n  NESTED,\n  FILE,\n  MARKDOWN,\n  HTML,\n  REACT_NODE,\n  PREACT_NODE,\n  SOLID_NODE,\n] as const;\n\nexport type NodeType =\n  | typeof TRANSLATION\n  | typeof ENUMERATION\n  | typeof PLURAL\n  | typeof CONDITION\n  | typeof INSERTION\n  | typeof FILE\n  | typeof OBJECT\n  | typeof ARRAY\n  | typeof NESTED\n  | typeof REACT_NODE\n  | typeof PREACT_NODE\n  | typeof SOLID_NODE\n  | typeof MARKDOWN\n  | typeof HTML\n  | typeof TEXT\n  | typeof NUMBER\n  | typeof BOOLEAN\n  | typeof GENDER\n  | typeof NULL\n  | typeof UNKNOWN;\n\ntype AdditionalAttributesType = {\n  [key: string]: unknown;\n};\n\nexport type TypedNodeModel<\n  T extends NodeType,\n  Content,\n  AdditionalAttributes extends AdditionalAttributesType = {},\n> = {\n  nodeType: T;\n} & {\n  [K in T]: Content;\n} & AdditionalAttributes;\n\nexport const formatNodeType = <\n  T extends NodeType,\n  Content = unknown,\n  AdditionalAttributes extends AdditionalAttributesType = {},\n>(\n  nodeType: T,\n  content: Content,\n  additionalAttributes?: { [key: string]: unknown }\n) =>\n  ({\n    ...additionalAttributes,\n    nodeType,\n    [nodeType]: content,\n  }) as TypedNodeModel<T, Content, AdditionalAttributes>;\n"],"mappings":";AAAA,MAAa,cAAc;AAC3B,MAAa,cAAc;AAC3B,MAAa,SAAS;AACtB,MAAa,YAAY;AACzB,MAAa,YAAY;AACzB,MAAa,OAAO;AACpB,MAAa,SAAS;AACtB,MAAa,QAAQ;AACrB,MAAa,SAAS;AACtB,MAAa,aAAa;AAC1B,MAAa,cAAc;AAC3B,MAAa,aAAa;AAC1B,MAAa,WAAW;AACxB,MAAa,OAAO;AACpB,MAAa,OAAO;AACpB,MAAa,SAAS;AACtB,MAAa,UAAU;AACvB,MAAa,SAAS;AACtB,MAAa,OAAO;AACpB,MAAa,UAAU;;;;;AAMvB,MAAa,oBAcT;CACF;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;AAsCA,MAAa,kBAKX,UACA,SACA,0BAEC;CACC,GAAG;CACH;EACC,WAAW;AACd"}
+{"version":3,"file":"nodeType.mjs","names":[],"sources":["../../src/nodeType.ts"],"sourcesContent":["export const TRANSLATION = 'translation' as const;\nexport const ENUMERATION = 'enumeration' as const;\nexport const PLURAL = 'plural' as const;\nexport const CONDITION = 'condition' as const;\nexport const INSERTION = 'insertion' as const;\nexport const FILE = 'file' as const;\nexport const OBJECT = 'object' as const;\nexport const ARRAY = 'array' as const;\nexport const NESTED = 'nested' as const;\nexport const REACT_NODE = 'reactNode' as const;\nexport const PREACT_NODE = 'preactNode' as const;\nexport const SOLID_NODE = 'solidNode' as const;\nexport const MARKDOWN = 'markdown' as const;\nexport const HTML = 'html' as const;\nexport const TEXT = 'text' as const;\nexport const NUMBER = 'number' as const;\nexport const BOOLEAN = 'boolean' as const;\nexport const GENDER = 'gender' as const;\nexport const SELECT = 'select' as const;\nexport const NULL = 'null' as const;\nexport const UNKNOWN = 'unknown' as const;\n\n/**\n * NodeType strings that correspond to plugins that can be conditionally\n * removed from the bundle when unused.\n */\nexport const PLUGIN_NODE_TYPES: readonly [\n  typeof TRANSLATION,\n  typeof ENUMERATION,\n  typeof PLURAL,\n  typeof CONDITION,\n  typeof INSERTION,\n  typeof GENDER,\n  typeof SELECT,\n  typeof NESTED,\n  typeof FILE,\n  typeof MARKDOWN,\n  typeof HTML,\n  typeof REACT_NODE,\n  typeof PREACT_NODE,\n  typeof SOLID_NODE,\n] = [\n  TRANSLATION,\n  ENUMERATION,\n  PLURAL,\n  CONDITION,\n  INSERTION,\n  GENDER,\n  SELECT,\n  NESTED,\n  FILE,\n  MARKDOWN,\n  HTML,\n  REACT_NODE,\n  PREACT_NODE,\n  SOLID_NODE,\n] as const;\n\nexport type NodeType =\n  | typeof TRANSLATION\n  | typeof ENUMERATION\n  | typeof PLURAL\n  | typeof CONDITION\n  | typeof INSERTION\n  | typeof FILE\n  | typeof OBJECT\n  | typeof ARRAY\n  | typeof NESTED\n  | typeof REACT_NODE\n  | typeof PREACT_NODE\n  | typeof SOLID_NODE\n  | typeof MARKDOWN\n  | typeof HTML\n  | typeof TEXT\n  | typeof NUMBER\n  | typeof BOOLEAN\n  | typeof GENDER\n  | typeof SELECT\n  | typeof NULL\n  | typeof UNKNOWN;\n\ntype AdditionalAttributesType = {\n  [key: string]: unknown;\n};\n\nexport type TypedNodeModel<\n  T extends NodeType,\n  Content,\n  AdditionalAttributes extends AdditionalAttributesType = {},\n> = {\n  nodeType: T;\n} & {\n  [K in T]: Content;\n} & AdditionalAttributes;\n\nexport const formatNodeType = <\n  T extends NodeType,\n  Content = unknown,\n  AdditionalAttributes extends AdditionalAttributesType = {},\n>(\n  nodeType: T,\n  content: Content,\n  additionalAttributes?: { [key: string]: unknown }\n) =>\n  ({\n    ...additionalAttributes,\n    nodeType,\n    [nodeType]: content,\n  }) as TypedNodeModel<T, Content, AdditionalAttributes>;\n"],"mappings":";AAAA,MAAa,cAAc;AAC3B,MAAa,cAAc;AAC3B,MAAa,SAAS;AACtB,MAAa,YAAY;AACzB,MAAa,YAAY;AACzB,MAAa,OAAO;AACpB,MAAa,SAAS;AACtB,MAAa,QAAQ;AACrB,MAAa,SAAS;AACtB,MAAa,aAAa;AAC1B,MAAa,cAAc;AAC3B,MAAa,aAAa;AAC1B,MAAa,WAAW;AACxB,MAAa,OAAO;AACpB,MAAa,OAAO;AACpB,MAAa,SAAS;AACtB,MAAa,UAAU;AACvB,MAAa,SAAS;AACtB,MAAa,SAAS;AACtB,MAAa,OAAO;AACpB,MAAa,UAAU;;;;;AAMvB,MAAa,oBAeT;CACF;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;AAuCA,MAAa,kBAKX,UACA,SACA,0BAEC;CACC,GAAG;CACH;EACC,WAAW;AACd"}

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
@@ -148,7 +148,11 @@ type QualifiedDictionaryGroup = {
  * - `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;
 };
@@ -161,8 +165,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
@@ -189,24 +199,36 @@ type CoordinateEquals<Left, Right> = [StringifyCoordinate<Left>] extends [String
  * variant entry, since the object identity is not reconstructable at the type
  * level). An absent selector defaults to the `'default'` variant.
  */
-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 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 +241,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 +262,82 @@ 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 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>;
+  variant?: NamedVariantIds<EntryVariant<GroupEntryUnion<T>>> | (HasDefaultVariant<T> extends true ? KnownVariants : never) | DictionaryObjectVariantsOf<T>;
 }) & ([EntryItem<GroupEntryUnion<T>>] extends [never] ? unknown : {
   item?: EntryItem<GroupEntryUnion<T>> | number | (string & {});
 });
@@ -613,5 +702,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, DictionaryVariantIdsOf, DictionaryVariantValue, Fill, GetSubPath, ImportMode, LocalDictionaryId, 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":";;;;KASK;KAEA;EACH,UAAU;;UAGK,UAAU,+BAA+B;KAErD,qBAAqB,aACxB,eACG,YAAY,YAAY,QAAQ,YAAY;KAErC,YACV,eACA,uBACA,WAAW,sBAAsB,WAAW,KAE1C,WACA,UAAU,cACR,eAAe,YAAY,cAC5B,6BAA6B,qBAAqB;KAGlD,QAAQ,KAAK;KAEb,yBAAyB,GAAG,iBAAiB,iBAAiB,OAG/D,YAAY,GAAG,iBAAiB,oBAAoB,GAAG;KAGtD,0BAA0B,GAAG,oBAC/B,WAAW,IAAI,oBAAoB,EAAE,IAAI;KAIvC,oBACH,UACA,wBACE,0BACA,QAAQ,yBACN,yBAAyB,UAAU,iBAE/B,YAAY,UAAU,iBACtB,0BAA0B,UAAU,iBAC1C,YAAY,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA0Dd,iBAER,kBACA,QAAQ,OAAO,2BAA2B;KAElC;KACA;;;;;;;;;;;;;KAcA;;;;;;;;;;;KAYA,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA8BlC;EACV;EACA,KAAK;EACL,gBAAgB;;;;;EAKhB,SAAS;;EAET,aAAa;EACb,WAAW;;;;;;;;;;;;KAaD;EACV,SAAS;EACT;EACA,UAAU;;KAGP,sBAAsB,SAAS;EAAgB,eAAe;IAC/D;;KAIC,iBAAiB,qBACpB,oBAAoB,cAAc,UAC7B,SAAS,iBAAiB,UAC1B;;;;;;KAOF,wBACH,gCAAgC,2BAChC,yCAEC,eAAe,kBAAkB,eAAe,eAAe,0BAC5D,eAAe,iBACP,oBAAoB,WAAW,SAAS;;;;;;KAQjD,qBACH,YACA,gCAAgC,gCAE/B,aAAa,sBAAsB,wBAClC,gBACA,iBAAiB,qBACH;EACV,SAAS,WAAW;KAAU;EAAsB,eAAe;;EAC/D,SAAS;gBAEZ;EAAsB,YAAY;;EAAW,MAAM;;;KAKvD,oBAAoB,SAAS,mCAC3B;;KAIF,iBAAiB,MAAM,UAAU,oBAAoB,gBACxD,oBAAoB;;;;;;;KAWjB,gBAAgB,YAAY;EAAmB,eAAe;IAC/D,yBACE;KAGD,aAAa,YAAY;EAAmB,YAAY;IACzD;;;;;;KAQC,qBACH,OACA,gCAAgC,2BAChC,+BAEkB,yBACd;EAAgB,eAAe;IAC7B,iBAAiB,SAAS,gBAAgB,yDAI/B,0BACZ,aAAa,wCAEZ;EAAgB,YAAY;IAC1B,iBAAiB,MAAM,aAAa;;KAMzC,gBACH,SACA,gCAAgC,2BAChC,eAEC,aAAa,WAAW,qBACvB,QAAQ,MACR,gBACA,yBAEE,cACQ,QAAQ;;KAIjB,eACH,gCAAgC,2BAChC,2BACiB,0BACd,aAAa;;;;;;;;;;;;;KAiBN,kCACV,GACA,wBACE;EACF,sBAAsB,gCACX;EACX,eAAe,mBAAmB;IAEhC,qBAAqB,YAAY,+BAA8B,WAC7D,eAAe,gBAAgB,yBAC7B,sBACE,gBACE,SACA,gBACA,gBACM,gBAAgB,SAAS,gBAAgB,uBAE5C,gBAAgB,SAAS,gBAAgB,oCAI9C,sBACE,gBACE,SACA,gBACA,gBACM,gBAAgB,SAAS,gBAAgB,sBAGzD;EAAY,eAAe;IACzB;;KAID,gBAAgB,KAAK;EACxB,sBAAsB,gCACX;EACX,eAAe;IAEb,qBAAqB,YAAY,sBAAsB,qBACrD,YACA;KAID,aAAa,SAAS;EAAgB,eAAe;IACtD;KAEC,UAAU,SAAS;EAAgB,YAAY;IAAS;;;;;;;;KASjD,2BAA2B,MAAM,gBAAgB,sBACzD;EACE,SAAS;MAAoB,aAAa,gBAAgB;EAKtD,UACI,aAAa,gBAAgB,sBAE7B;OAEN,UAAU,gBAAgB;EAEtB,OAAO,UAAU,gBAAgB;;KACjC;KAOA,uBACP,kBAAkB,2BAA2B,yBAAyB;KAE/D;;;;;;;;;;;;;;;KAqBA;KAEA;;;;;EAON;;;;;EAKA;;;;;EAKA;;;;;KAKD;;;;;;EAMH;;;;;;EAOA,KAAK;;;;;;;EAQL;;;;;;EAOA,UAAU;;;;;;EAOV,WAAW;;;;;;;;EASX,SAAS;;;;;;;;;;;;;;EAeT,KAAK;;;;;;;;;;;;;EAcL;;;;;;;;;;;;;;;;;;;EAoBA;;;;;;EAOA;;;;;;EAOA;;;;;;EAOA;;;;;;;;;;;;EAaA;;;;;;;;;;;;;;;;;;;EAoBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4CA,UAAU,yBAAyB;;;;;;;;;;;;;;;;;;EAmBnC,SAAS;;;;;;;;;;;;EAaT,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0D5B,OAAO;;;;;;;EAQP;;;;;EAMA;;;;;;;;;;;;;;;EAgBA,aAAa;;;;;;;;;EAUb,WAAW;;;;;;KAOR,qBACH,aACA,eACA,UAAU,aAAa,cACrB;EAEE,QAAQ;EACR,SAAS,gCACL,oBAAoB,OAAO,IAAI,iBAAiB,OAAO,KAEnD,oBAAoB,cAAc,OAAO,IAAI,kBAC5C,cAAc,OAAO;;;;;KAO/B,wBAAwB,aAAa;EACxC;EACA,SAAS,sCAEL,oBAAoB,aAAa,iBAAiB;;;;;KAM5C,WACV,yBACA,kBAAkB,oCAClB,yBACE,kBACD,kBAAkB,aACf,qBAAqB,aAAa,eAAe,+BAC/B,YAEZ,wBAAwB,aAAa,iBACrC,qBAAqB,aAAa;KAGlC,WAAW,GAAG,KAAK,mBAAmB,WAAW,SACzD,gBAAgB,IACd,WAAW,EAAE,IAAI,gBAEnB,gBAAgB,IACd,EAAE,KACF"}
+{"version":3,"file":"dictionary.d.ts","names":[],"sources":["../../src/dictionary.ts"],"mappings":";;;;KAUK;KAEA;EACH,UAAU;;UAGK,UAAU,+BAA+B;KAErD,qBAAqB,aACxB,eACG,YAAY,YAAY,QAAQ,YAAY;KAErC,YACV,eACA,uBACA,WAAW,sBAAsB,WAAW,KAE1C,WACA,UAAU,cACR,eAAe,YAAY,cAC5B,6BAA6B,qBAAqB;KAGlD,QAAQ,KAAK;KAEb,yBAAyB,GAAG,iBAAiB,iBAAiB,OAG/D,YAAY,GAAG,iBAAiB,oBAAoB,GAAG;KAGtD,0BAA0B,GAAG,oBAC/B,WAAW,IAAI,oBAAoB,EAAE,IAAI;KAIvC,oBACH,UACA,wBACE,0BACA,QAAQ,yBACN,yBAAyB,UAAU,iBAE/B,YAAY,UAAU,iBACtB,0BAA0B,UAAU,iBAC1C,YAAY,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA0Dd,iBAER,kBACA,QAAQ,OAAO,2BAA2B;KAElC;KACA;;;;;;;;;;;;;KAcA;;;;;;;;;;;KAYA,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA8BlC;EACV;EACA,KAAK;EACL,gBAAgB;;;;;EAKhB,SAAS;;EAET,aAAa;EACb,WAAW;;;;;;;;;;;;KAaD;;;;;EAKV,SAAS;EACT;EACA,UAAU;;KAGP,sBAAsB,SAAS;EAAgB,eAAe;IAC/D;;KAIC,iBAAiB,qBACpB,oBAAoB,cAAc,UAC7B,SAAS,iBAAiB,UAC1B;;;;;;;;;;;;KAaF,wBACH,gCAAgC,2BAChC,sCACE,uCACI,kBAAkB,kCACf,gCAAgC,6BAEvC,iCACQ,iCACG,6CAEN,OAAO,YAAY,aAAY,wBAChC,gBACA;;;;;;KAUH,qBACH,YACA,gCAAgC,gCAE/B,aAAa,sBAAsB,wBAClC,gBACA,iBAAiB,qBACH;EACV,SAAS,WAAW;KAAU;EAAsB,eAAe;;EAC/D,SAAS;gBAEZ;EAAsB,YAAY;;EAAW,MAAM;;;KAKvD,oBAAoB,SAAS,mCAC3B;;KAIF,iBAAiB,MAAM,UAAU,oBAAoB,gBACxD,oBAAoB;;;;;;;KAWjB,gBAAgB,oCAAoC,WACrD,2BAA2B,yBAAwB,WACjD,yBACE;;KAMH,aAAa,iCAAiC,WAC/C,wBAAwB;;;;;KAOvB,mBAAmB,cAAc,uBAC9B;;;;;;;;;KAWH,yBAAyB,UAAU,8BACtC,gBAAgB,yBAAwB,2CACrB,YACb,YACA,kBAAkB,cAChB,8BACkB,0BAEhB;;;;;;;KASP,qBACH,OACA,gCAAgC,2BAChC,UACA,uCAEkB,yBACd;EAAgB,eAAe;IAC7B,iBAAiB,SAAS,gEAIf,0BACZ,aAAa,wCAEZ;EAAgB,YAAY;IAC1B,iBAAiB,MAAM,aAAa;;KAMzC,gBACH,SACA,gCAAgC,2BAChC,UACA,uBAEC,aAAa,WAAW,qBACvB,QAAQ,MACR,gBACA,UACA,iCAEE,cACQ,QAAQ;;KAIjB,eACH,gCAAgC,2BAChC,2BACiB,0BACd,aAAa;;;;;;;;;;;;;;;KAmBN,kCACV,GACA,wBACE;EACF,sBAAsB,gCACX;EACX,eAAe,mBAAmB;IAEhC,gBACE,qBAAqB,YAAY,iBACjC,gBACA,UACA,yBAAyB,UAAU,mBAAmB,6BACxC,WACd,eAAe,gBAAgB,yBAC7B,sBAAsB,cAAc,qBAC7B,kCAEL,sBAAsB,cAAc,oBAE1C;EAAY,eAAe;IACzB;;KAID,gBAAgB,KAAK;EACxB,sBAAsB,gCACX;EACX,eAAe;IAEb,qBAAqB,YAAY,sBAAsB,qBACrD,YACA;KAID,aAAa,SAAS;EAAgB,eAAe;IACtD;KAEC,UAAU,SAAS;EAAgB,YAAY;IAAS;;;;;;KAOxD,kBAAkB,KAAK;EAC1B,sBAAsB,gCACX;EACX,eAAe;sBAEK,yBAChB,mBAAmB;;;;;;KASpB,gBAAgB,OAAO,4CAA4C;KACnE,iBAAiB,OAAO,oCAAoC;;KAG5D,iBAAiB,uBACpB,sBAAsB,eAAe,aAC9B,OAAO,QAAQ;;;;;;;;;;;KAanB,qBAAqB,qBACxB,oBAAoB,cAAc,SAC9B,iBAAiB,QAAQ,qBAAqB,QAC9C,iBAAiB;;;;;;KAOX,uBAAuB,KAAK,gBAAgB,kBAAkB;;;;;;;;KASrE,2BAA2B,KAAK,qBACnC,iBAAiB,kBAAkB;;;;;;;KAShC,kBAAkB,uBACH,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;KAwB1B,2BAA2B,GAAG,gBAAgB,qBACxD,gBAAgB,sBAEd;EACE,SAAS;MAAsB,aAAa,gBAAgB;EAKxD,UACI,gBAAgB,aAAa,gBAAgB,QAC5C,kBAAkB,kBAAkB,yBACrC,2BAA2B;OAEjC,UAAU,gBAAgB;EAEtB,OAAO,UAAU,gBAAgB;;KACjC;KAOA,uBACP,kBAAkB,2BAA2B,yBAAyB;KAE/D;;;;;;;;;;;;;;;KAqBA;KAEA;;;;;EAON;;;;;EAKA;;;;;EAKA;;;;;KAKD;;;;;;EAMH;;;;;;EAOA,KAAK;;;;;;;EAQL;;;;;;EAOA,UAAU;;;;;;EAOV,WAAW;;;;;;;;EASX,SAAS;;;;;;;;;;;;;;EAeT,KAAK;;;;;;;;;;;;;EAcL;;;;;;;;;;;;;;;;;;;EAoBA;;;;;;EAOA;;;;;;EAOA;;;;;;EAOA;;;;;;;;;;;;EAaA;;;;;;;;;;;;;;;;;;;EAoBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4CA,UAAU,yBAAyB;;;;;;;;;;;;;;;;;;EAmBnC,SAAS;;;;;;;;;;;;EAaT,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0D5B,OAAO;;;;;;;EAQP;;;;;EAMA;;;;;;;;;;;;;;;EAgBA,aAAa;;;;;;;;;EAUb,WAAW;;;;;;KAOR,qBACH,aACA,eACA,UAAU,aAAa,cACrB;EAEE,QAAQ;EACR,SAAS,gCACL,oBAAoB,OAAO,IAAI,iBAAiB,OAAO,KAEnD,oBAAoB,cAAc,OAAO,IAAI,kBAC5C,cAAc,OAAO;;;;;KAO/B,wBAAwB,aAAa;EACxC;EACA,SAAS,sCAEL,oBAAoB,aAAa,iBAAiB;;;;;KAM5C,WACV,yBACA,kBAAkB,oCAClB,yBACE,kBACD,kBAAkB,aACf,qBAAqB,aAAa,eAAe,+BAC/B,YAEZ,wBAAwB,aAAa,iBACrC,qBAAqB,aAAa;KAGlC,WAAW,GAAG,KAAK,mBAAmB,WAAW,SACzD,gBAAgB,IACd,WAAW,EAAE,IAAI,gBAEnB,gBAAgB,IACd,EAAE,KACF"}

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, 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 { 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, DictionaryVariantIdsOf, DictionaryVariantValue, Fill, GetSubPath, ImportMode, LocalDictionaryId, 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, 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, SOLID_NODE, Schema, SchemaKeys, StorageAttributes, StrictMode, StrictModeLocaleMap, SystemConfig, TEXT, TRANSLATION, TranslationNode, TypedNode, TypedNodeModel, UNKNOWN, URLType, UnmergedDictionaryOutput, UnmergedDictionaryResult, formatNodeType };
+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, 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, 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/keyPath.d.ts

@@ -1,4 +1,4 @@
-import { ARRAY, CONDITION, ENUMERATION, FILE, GENDER, HTML, INSERTION, MARKDOWN, NESTED, OBJECT, PLURAL, REACT_NODE, TRANSLATION } from "./nodeType.js";
+import { ARRAY, CONDITION, ENUMERATION, FILE, GENDER, HTML, INSERTION, MARKDOWN, NESTED, OBJECT, PLURAL, REACT_NODE, SELECT, TRANSLATION } from "./nodeType.js";
 //#region src/keyPath.d.ts
 type ObjectNode = {
   type: typeof OBJECT;
@@ -28,6 +28,10 @@ type GenderNode = {
   type: typeof GENDER;
   key: string;
 };
+type SelectNode = {
+  type: typeof SELECT;
+  key: string;
+};
 type InsertionNode = {
   type: typeof INSERTION;
   key?: undefined;
@@ -52,7 +56,7 @@ type HTMLNode = {
   type: typeof HTML;
   key?: undefined;
 };
-type KeyPath = ObjectNode | ArrayNode | TranslationNode | EnumerationNode | PluralNode | InsertionNode | GenderNode | MarkdownNode | ReactNode | ConditionNode | NestedNode | FileNode | HTMLNode;
+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, TranslationNode };
+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,UACR,aACA,YACA,kBACA,kBACA,aACA,gBACA,aACA,eACA,YACA,gBACA,aACA,WACA"}
+{"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"}

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, 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,6 +28,23 @@ 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
@@ -98,5 +115,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, 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":";;;;;KAmBY,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;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"}

package/dist/types/nodeType.d.ts

@@ -17,14 +17,15 @@ declare const TEXT: "text";
 declare const NUMBER: "number";
 declare const BOOLEAN: "boolean";
 declare const GENDER: "gender";
+declare const SELECT: "select";
 declare const NULL: "null";
 declare const UNKNOWN: "unknown";
 /**
  * NodeType strings that correspond to plugins that can be conditionally
  * removed from the bundle when unused.
  */
-declare const PLUGIN_NODE_TYPES: readonly [typeof TRANSLATION, typeof ENUMERATION, typeof PLURAL, typeof CONDITION, typeof INSERTION, typeof GENDER, typeof NESTED, typeof FILE, typeof MARKDOWN, typeof HTML, typeof REACT_NODE, typeof PREACT_NODE, typeof SOLID_NODE];
-type NodeType = typeof TRANSLATION | typeof ENUMERATION | typeof PLURAL | typeof CONDITION | typeof INSERTION | typeof FILE | typeof OBJECT | typeof ARRAY | typeof NESTED | typeof REACT_NODE | typeof PREACT_NODE | typeof SOLID_NODE | typeof MARKDOWN | typeof HTML | typeof TEXT | typeof NUMBER | typeof BOOLEAN | typeof GENDER | typeof NULL | typeof UNKNOWN;
+declare const PLUGIN_NODE_TYPES: readonly [typeof TRANSLATION, typeof ENUMERATION, typeof PLURAL, typeof CONDITION, typeof INSERTION, typeof GENDER, typeof SELECT, typeof NESTED, typeof FILE, typeof MARKDOWN, typeof HTML, typeof REACT_NODE, typeof PREACT_NODE, typeof SOLID_NODE];
+type NodeType = typeof TRANSLATION | typeof ENUMERATION | typeof PLURAL | typeof CONDITION | typeof INSERTION | typeof FILE | typeof OBJECT | typeof ARRAY | typeof NESTED | typeof REACT_NODE | typeof PREACT_NODE | typeof SOLID_NODE | typeof MARKDOWN | typeof HTML | typeof TEXT | typeof NUMBER | typeof BOOLEAN | typeof GENDER | typeof SELECT | typeof NULL | typeof UNKNOWN;
 type AdditionalAttributesType = {
   [key: string]: unknown;
 };
@@ -35,5 +36,5 @@ declare const formatNodeType: <T extends NodeType, Content = unknown, Additional
   [key: string]: unknown;
 }) => TypedNodeModel<T, Content, AdditionalAttributes>;
 //#endregion
-export { ARRAY, BOOLEAN, CONDITION, ENUMERATION, FILE, GENDER, HTML, INSERTION, MARKDOWN, NESTED, NULL, NUMBER, NodeType, OBJECT, PLUGIN_NODE_TYPES, PLURAL, PREACT_NODE, REACT_NODE, SOLID_NODE, TEXT, TRANSLATION, TypedNodeModel, UNKNOWN, formatNodeType };
+export { 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 };
 //# sourceMappingURL=nodeType.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"nodeType.d.ts","names":[],"sources":["../../src/nodeType.ts"],"mappings":";cAAa;cACA;cACA;cACA;cACA;cACA;cACA;cACA;cACA;cACA;cACA;cACA;cACA;cACA;cACA;cACA;cACA;cACA;cACA;cACA;;;;;cAMA,oCACJ,oBACA,oBACA,eACA,kBACA,kBACA,eACA,eACA,aACA,iBACA,aACA,mBACA,oBACA;KAiBG,kBACD,qBACA,qBACA,gBACA,mBACA,mBACA,cACA,gBACA,eACA,gBACA,oBACA,qBACA,oBACA,kBACA,cACA,cACA,gBACA,iBACA,gBACA,cACA;KAEN;GAAA;;KAIO,eACV,UAAU,UACV,SACA,6BAA6B;EAE7B,UAAU;OAET,KAAK,IAAI,aACR;cAES,iBACX,UAAU,UACV,mBACA,6BAA6B,+BAE7B,UAAU,GACV,SAAS,SACT;;MAMM,eAAe,GAAG,SAAS"}
+{"version":3,"file":"nodeType.d.ts","names":[],"sources":["../../src/nodeType.ts"],"mappings":";cAAa;cACA;cACA;cACA;cACA;cACA;cACA;cACA;cACA;cACA;cACA;cACA;cACA;cACA;cACA;cACA;cACA;cACA;cACA;cACA;cACA;;;;;cAMA,oCACJ,oBACA,oBACA,eACA,kBACA,kBACA,eACA,eACA,eACA,aACA,iBACA,aACA,mBACA,oBACA;KAkBG,kBACD,qBACA,qBACA,gBACA,mBACA,mBACA,cACA,gBACA,eACA,gBACA,oBACA,qBACA,oBACA,kBACA,cACA,cACA,gBACA,iBACA,gBACA,gBACA,cACA;KAEN;GAAA;;KAIO,eACV,UAAU,UACV,SACA,6BAA6B;EAE7B,UAAU;OAET,KAAK,IAAI,aACR;cAES,iBACX,UAAU,UACV,mBACA,6BAA6B,+BAE7B,UAAU,GACV,SAAS,SACT;;MAMM,eAAe,GAAG,SAAS"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intlayer/types",
-  "version": "9.0.2",
+  "version": "9.1.1",
   "private": false,
   "description": "Retrieve Intlayer configurations and manage environment variables for both server-side and client-side environments.",
   "keywords": [
@@ -141,7 +141,7 @@
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "devDependencies": {
-    "@types/node": "26.1.1",
+    "@types/node": "26.1.2",
     "@utils/ts-config": "1.0.4",
     "@utils/ts-config-types": "1.0.4",
     "@utils/tsdown-config": "1.0.4",