@heroiclands/package-build 23.6.1 → 23.7.0

package/engine/word-terms.mjs

@@ -88,6 +88,15 @@ export const WORD_FIELDS = Object.freeze([
         shape: "the word as cited, bare",
         describe: "The word as cited, with no backticks.",
     }),
+    Object.freeze({
+        name: "variants",
+        kind: "list",
+        shape: "a list of forms",
+        entries: Object.freeze({ kind: "string", shape: "a form, bare" }),
+        describe:
+            "The word's other forms, such as a long form beside a short one; a marked use of " +
+            "one cites the word.",
+    }),
     Object.freeze({
         name: "name_sort",
         kind: "string",
@@ -112,10 +121,12 @@ export const WORD_FIELDS = Object.freeze([
     }),
     Object.freeze({
         name: "gloss",
-        kind: "string",
+        kind: "string-or-list",
         required: true,
-        shape: "a string",
-        describe: "The meaning, in brief.",
+        shape: "a string, or a list of senses",
+        entries: Object.freeze({ kind: "string", shape: "a sense" }),
+        describe:
+            "The meaning, in brief; a list states one sense per entry, which a dictionary numbers.",
     }),
     Object.freeze({
         name: "source",
@@ -134,11 +145,11 @@ export const WORD_FIELDS = Object.freeze([
             "write them; absent for a root word.",
     }),
     Object.freeze({
-        name: "attested",
-        kind: "list",
-        shape: "a list of Addresses",
-        entries: Object.freeze({ kind: "address", shape: "an Address" }),
-        describe: "The notes the word is cited from.",
+        name: "note",
+        kind: "string",
+        shape: "a string",
+        describe:
+            "What a source says of the word beyond its pieces, such as a cognate it is read with.",
     }),
     Object.freeze({
         name: "pronunciation",
@@ -163,14 +174,41 @@ export const WORD_FIELDS = Object.freeze([
     Object.freeze({
         name: "frame",
         kind: "string",
-        shape: "a string",
-        describe: "The frame a root is set in.",
+        shape: "a frame of the language's `sounds.frames`",
+        describe: "The frame a root is set in, named in the language's `sounds.frames`.",
     }),
 ]);
 
 /** The keys of {@link WORD_FIELDS}, in declared order. */
 export const WORD_KEYS = Object.freeze(WORD_FIELDS.map((field) => field.name));
 
+/**
+ * A word's senses: one for a string gloss, one per entry for a list, each
+ * trimmed, blanks dropped.
+ *
+ * @param {unknown} gloss - The word's `gloss`.
+ * @returns {string[]} The senses, in order.
+ */
+export function glossSenses(gloss) {
+    const list = Array.isArray(gloss) ? gloss : [gloss];
+    return list
+        .filter((sense) => typeof sense === "string")
+        .map((sense) => sense.trim())
+        .filter(Boolean);
+}
+
+/**
+ * A word's gloss as one line of text: its senses joined by `; `, or `null`
+ * where it states none.
+ *
+ * @param {unknown} gloss - The word's `gloss`.
+ * @returns {string|null}
+ */
+export function glossText(gloss) {
+    const senses = glossSenses(gloss);
+    return senses.length ? senses.join("; ") : null;
+}
+
 /**
  * The keys one entry of a language note's `data.fields` carries.
  *
@@ -217,7 +255,29 @@ export const AFFIX_FIELDS = Object.freeze([
         name: "attaches",
         kind: "string",
         shape: "a string",
-        describe: "How it attaches, such as `replaces a closing vowel`.",
+        describe: "How it attaches, in words, such as `replaces a closing vowel`.",
+    }),
+    Object.freeze({
+        name: "replaces",
+        kind: "string",
+        shape: "`vowel`, or the letters, such as `a`",
+        describe:
+            "What it takes the place of at the close of the stem: `vowel` for any closing " +
+            "vowel, or the letters it replaces; added to the whole stem where absent.",
+    }),
+    Object.freeze({
+        name: "lengthens",
+        kind: "boolean",
+        shape: "`true` or `false`",
+        describe:
+            "Whether the stem's last vowel lengthens before the affix; `false` where unstated. An " +
+            "affix that `replaces` the stem's close does not also lengthen it.",
+    }),
+    Object.freeze({
+        name: "front",
+        kind: "string",
+        shape: "the affix as written, such as `-ür`",
+        describe: "Its form after front vowels, where the language keeps vowel harmony.",
     }),
     Object.freeze({
         name: "examples",

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@heroiclands/package-build",
-    "version": "23.6.1",
+    "version": "23.7.0",
     "description": "Shared toolchain for building and shipping a HeroicLands Foundry VTT package — content compilation, manifest, localization, staging, bundle, release and deployment.",
     "license": "GPL-3.0-or-later",
     "type": "module",

package/types/engine/dictionary-layout.d.mts

@@ -6,7 +6,8 @@
  * @property {object} [addressContext] - Address resolution context.
  * @property {(address: string) => string|undefined} [labelOf] - A note's
  *   `name.full`, by its Address.
- * @property {boolean} [showKey=true] - Whether the key is printed.
+ * @property {boolean|"only"} [showKey=true] - Whether the key is printed;
+ *   `"only"` prints the key and nothing else.
  * @property {string} [pageLanguage] - The language of the page the fence is
  *   on, which no entry is tagged with.
  */
@@ -63,9 +64,10 @@ export type LayoutOptions = {
      */
     labelOf?: ((address: string) => string | undefined) | undefined;
     /**
-     * - Whether the key is printed.
+     * - Whether the key is printed;
+     * `"only"` prints the key and nothing else.
      */
-    showKey?: boolean | undefined;
+    showKey?: boolean | "only" | undefined;
     /**
      * - The language of the page the fence is
      * on, which no entry is tagged with.

package/types/engine/language-data.d.mts

@@ -0,0 +1,22 @@
+/**
+ * Whether a tag a row names is one `data.tongues` declares.
+ *
+ * @param {string} tag - The tag as the row writes it.
+ * @param {Set<string>} declared - The declared tags.
+ * @returns {boolean}
+ */
+export function tongueDeclared(tag: string, declared: Set<string>): boolean;
+/**
+ * Check a `skill` note's language data against what it means.
+ *
+ * @param {object} note - A `skill` note: `file`, `raw` and parsed `fm`.
+ * @param {object} [context]
+ * @param {object} [context.index] - The index, for whether an Address
+ *   resolves. Without one, only what the note says of itself is checked.
+ * @param {readonly string[]} [context.types] - The note types a scope may name.
+ * @returns {object[]} The findings.
+ */
+export function checkLanguageData(note: object, { index, types }?: {
+    index?: object | undefined;
+    types?: readonly string[] | undefined;
+}): object[];

package/types/engine/language-rows.d.mts

@@ -0,0 +1,227 @@
+/**
+ * Whether a note falls in a language's `data.scope`: one of its kinds catches
+ * the note, `types` (where stated) admits its type, and `skip` does not name
+ * it. A language that states no scope covers every note.
+ *
+ * @param {Record<string, any>} record - A note's index record.
+ * @param {string} address - The note's Address.
+ * @param {object|undefined} scope - The language's `data.scope`.
+ * @returns {boolean}
+ */
+export function inScope(record: Record<string, any>, address: string, scope: object | undefined): boolean;
+/**
+ * The `register` rows of a set of index records.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records, every
+ *   Address a string, already narrowed to the audience being published to.
+ * @param {Iterable<Record<string, any>>} [all] - Every record of the package;
+ *   a note carrying a name is cited only where the audience sees it.
+ * @returns {object[]} One row per register entry, in record then entry order.
+ */
+export function registerRows(records: Iterable<Record<string, any>>, all?: Iterable<Record<string, any>>): object[];
+/**
+ * The `retired` rows: one per `data.retired` entry, `instead` a list.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function retiredRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `tongues` rows: one per `data.tongues` entry.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function tongueRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `scope` rows: one per value of each kind of `data.scope`, in the order
+ * the kinds are declared.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function scopeRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `letters` rows: one per `data.sounds.letters` entry, `letters` and
+ * `tongue` lists.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function letterRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `edges` rows: one per `data.sounds.edges` entry, `sounds` a list.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function edgeRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `clusters` rows: one per language stating `data.sounds.clusters`.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function clusterRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `read_past` rows: one per `data.sounds.readPast` entry.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function readPastRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `sound_changes` rows: one per step of each `data.soundChanges` set, with
+ * the set's `position`, `name`, `from_language` and `to_language`, and the
+ * step's `step_position` within it.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function soundChangeRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `elements` rows: one per `data.elements` entry, `examples` a list.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function elementRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `roots` rows: one per `data.roots` entry.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function rootRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `cognates` rows: one per form of each `data.cognates` set, in the order
+ * the set writes them, with the set's `position`, `gloss` and `proto`.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function cognateRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `stress` rows: one per language stating `data.sounds.stress`.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function stressRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `finals` rows: one per `data.sounds.finals` entry.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function finalRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `syllables` rows: one per language stating `data.sounds.syllables`, a
+ * list rule always a list (`any` a list of one), the harmony's sets each a
+ * column of its own.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function syllableRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `joining` rows: one per `data.sounds.joining` entry.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function joiningRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `joins` rows: one per `data.sounds.joins` entry.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function joinRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `marks` rows: one per `data.sounds.marks` entry.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function markRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `skeleton` rows: one per `data.sounds.skeleton` entry, `second` a list.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function skeletonRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `frames` rows: one per `data.sounds.frames` entry, `examples` a list of
+ * `{ root, form }` in the order the frame states them.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function frameRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `calling_names` rows: one per `data.callingNames.closings` entry, each
+ * with the language's `min_syllables`.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function callingNameRows(records: Iterable<Record<string, any>>): object[];
+/** Every column of the `register` relation, in order. */
+export const REGISTER_COLUMNS: readonly string[];
+/** Every column of the `retired` relation, in order. */
+export const RETIRED_COLUMNS: readonly string[];
+/** Every column of the `tongues` relation, in order. */
+export const TONGUE_COLUMNS: readonly any[];
+/** Every column of the `scope` relation, in order. */
+export const SCOPE_COLUMNS: readonly string[];
+/** Every column of the `letters` relation, in order. */
+export const LETTER_COLUMNS: readonly string[];
+/** Every column of the `edges` relation, in order. */
+export const EDGE_COLUMNS: readonly string[];
+/** Every column of the `clusters` relation, in order. */
+export const CLUSTER_COLUMNS: readonly string[];
+/** Every column of the `stress` relation, in order. */
+export const STRESS_COLUMNS: readonly string[];
+/** Every column of the `finals` relation, in order. */
+export const FINAL_COLUMNS: readonly string[];
+/** Every column of the `syllables` relation, in order: one row per language. */
+export const SYLLABLE_COLUMNS: readonly string[];
+/** Every column of the `joining` relation, in order. */
+export const JOINING_COLUMNS: readonly string[];
+/** Every column of the `joins` relation, in order. */
+export const JOIN_COLUMNS: readonly string[];
+/** Every column of the `marks` relation, in order. */
+export const MARK_COLUMNS: readonly string[];
+/** Every column of the `skeleton` relation, in order. */
+export const SKELETON_COLUMNS: readonly string[];
+/** Every column of the `frames` relation, in order. */
+export const FRAME_COLUMNS: readonly string[];
+/** Every column of the `read_past` relation, in order. */
+export const READ_PAST_COLUMNS: readonly string[];
+/** Every column of the `sound_changes` relation, in order: one row per step. */
+export const SOUND_CHANGE_COLUMNS: readonly string[];
+/** Every column of the `elements` relation, in order. */
+export const ELEMENT_COLUMNS: readonly any[];
+/** Every column of the `roots` relation, in order. */
+export const ROOT_COLUMNS: readonly string[];
+/** Every column of the `cognates` relation, in order. */
+export const COGNATE_COLUMNS: readonly string[];
+/** Every column of the `calling_names` relation, in order. */
+export const CALLING_NAME_COLUMNS: readonly string[];
+/**
+ * The type of each column that holds no text, by relation, so a relation
+ * with no row still has the type a fence's list or number function binds to.
+ *
+ * @type {Readonly<Record<string, Readonly<Record<string, string>>>>}
+ */
+export const LANGUAGE_COLUMN_TYPES: Readonly<Record<string, Readonly<Record<string, string>>>>;
+/**
+ * Every relation of a language's register, sounds, history and names: its
+ * name, its rows from the records the audience sees and every record of the
+ * package, and its columns. {@link LANGUAGE_COLUMN_TYPES} types its columns.
+ *
+ * @type {ReadonlyArray<[string, (visible: object[], all: object[]) => object[], readonly string[]]>}
+ */
+export const LANGUAGE_RELATIONS: ReadonlyArray<[string, (visible: object[], all: object[]) => object[], readonly string[]]>;

package/types/engine/language-terms.d.mts

@@ -0,0 +1,265 @@
+/**
+ * The keys a language note states beside its words: the register of the names
+ * the setting gives in the language's reach, the tags the register uses, the
+ * forms it does not write, the notes the register covers, the letters and sound
+ * rules, the sound changes, the name elements, the roots and the cognates.
+ *
+ * A leaf module, importing nothing: the note vocabulary reads these
+ * declarations as it loads, and `language-data.mjs` checks what the values
+ * mean. Every closed list here — the edges, element positions, register
+ * kinds, stress rules, joins, marks, onsets, harmony sets and calling-name
+ * uses — holds the labels the setting's own tables use, one word for each.
+ *
+ * @module
+ */
+/** The `data` keys a language note states its sounds, names and history in. */
+export const LANGUAGE_DATA_KEYS: readonly string[];
+/**
+ * The tongue tag every language accepts without declaring it: a name given in
+ * the language of the pages.
+ */
+export const RESERVED_TONGUE: "translation";
+/**
+ * The placeholder a tongue tag closes on to declare a family of tags, one per
+ * tongue named after the colon: `exonym:<tongue>` declares `exonym:vylari`.
+ */
+export const TONGUE_PLACEHOLDER: "<tongue>";
+/**
+ * The edges of a word a sound rule names: what may open it, close it, stand
+ * inside it, and what counts as a syllable.
+ */
+export const EDGE_KINDS: readonly string[];
+/** What each edge kind holds, for the reference and for a finding. */
+export const EDGE_MEANINGS: Readonly<{
+    openConsonant: "the single consonants that may open a word, where not every one may";
+    openCluster: "the clusters that may open a word";
+    closeConsonant: "the consonants that may close a word";
+    closeCluster: "the clusters that may close a word";
+    innerCluster: "the pairs that may stand together inside a word";
+    vowelPair: "the vowels that may stand together";
+    glide: "the glides that may follow a consonant";
+    syllabic: "the consonants that may carry a syllable";
+}>;
+/** The word a sound rule's `sounds` takes in place of a list: every sound. */
+export const ANY_SOUND: "any";
+/**
+ * Where in a name an element stands: `opening` opens a name or stands inside
+ * it, `closing` closes it, `either` does both, and `link` joins two parts and
+ * never begins or ends a name.
+ */
+export const ELEMENT_POSITIONS: readonly string[];
+/** What a register name is, where a language sorts its names by kind. */
+export const REGISTER_KINDS: readonly string[];
+/** Where a language's stress falls. */
+export const STRESS_RULES: readonly string[];
+/** Which sounds meet where two parts of a word join. */
+export const JOIN_MEETINGS: readonly string[];
+/**
+ * What happens where they meet: `merge` writes one, `insert` sets the join's
+ * letters between, `drop` loses the first, `double` doubles the consonant.
+ */
+export const JOIN_RULES: readonly string[];
+/** What a written mark says of its letter. */
+export const MARK_KINDS: readonly string[];
+/** How many of a mark a word may carry: `one` at most, or `any` number. */
+export const MARK_LIMITS: readonly string[];
+/** What a syllable may open on, where the rule is stated. */
+export const ONSET_RULES: readonly string[];
+/** Which harmony a neutral vowel counts as. */
+export const HARMONY_SETS: readonly string[];
+/** Whose name a calling-name closing usually makes. */
+export const CALLING_USES: readonly string[];
+/**
+ * The keys of one `data.tongues` entry.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const TONGUE_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.register` entry.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const REGISTER_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.retired` entry.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const RETIRED_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of a language's `data.scope`: the notes its register covers. A note
+ * is in scope when any one of them catches it and `skip` does not name it.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const SCOPE_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.sounds.letters` entry.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const LETTER_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.sounds.edges` entry.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const EDGE_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of a language's `data.sounds.clusters`.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const CLUSTER_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.sounds.readPast` entry.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const READ_PAST_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.sounds.finals` entry: a syllable final, for a
+ * language whose syllables are parsed by them.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const FINAL_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.sounds.joining` entry: how two parts are written
+ * where the first closes and the second opens on the given sounds.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const JOINING_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.sounds.joins` entry: what happens where two parts of a
+ * word meet.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const JOIN_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.sounds.marks` entry: a mark the language writes on a
+ * letter.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const MARK_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of a language's `data.sounds.syllables.harmony`.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const HARMONY_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of a language's `data.sounds.syllables`: what a syllable may open
+ * and close on, and what a word may.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const SYLLABLE_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.sounds.skeleton` entry: the vowel set between a
+ * root's second and third consonants.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const SKELETON_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.sounds.frames` entry: a pattern a root is set in.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const FRAME_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of a language's `data.sounds`.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const SOUND_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.soundChanges` entry.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const SOUND_CHANGE_STEP_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.soundChanges` set: an ordered run of steps, named, and
+ * where they lead from and to.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const SOUND_CHANGE_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.elements` entry.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const ELEMENT_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.roots` entry.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const ROOT_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.cognates` entry.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const COGNATE_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.callingNames.closings` entry: an ending, or the first
+ * syllable doubled, that a calling name closes on.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const CALLING_CLOSING_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of a language's `data.callingNames`: the short name a long given
+ * name is called by.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const CALLING_NAME_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The `data` fields this module declares, in the order the vocabulary lists
+ * them. {@link module:engine/language-data.checkLanguageData} checks what the
+ * values mean.
+ *
+ * @type {readonly object[]}
+ */
+export const LANGUAGE_DATA_FIELDS: readonly object[];
+/** The keys of {@link TONGUE_FIELDS}, in declared order. */
+export const TONGUE_KEYS: readonly string[];
+/** The keys of {@link REGISTER_FIELDS}, in declared order. */
+export const REGISTER_KEYS: readonly string[];
+/** The keys of {@link RETIRED_FIELDS}, in declared order. */
+export const RETIRED_KEYS: readonly string[];
+/** The keys of {@link LETTER_FIELDS}, in declared order. */
+export const LETTER_KEYS: readonly string[];
+/** The keys of {@link EDGE_FIELDS}, in declared order. */
+export const EDGE_KEYS: readonly string[];
+/** The keys of {@link READ_PAST_FIELDS}, in declared order. */
+export const READ_PAST_KEYS: readonly string[];
+/** The keys of {@link SOUND_CHANGE_STEP_FIELDS}, in declared order. */
+export const SOUND_CHANGE_STEP_KEYS: readonly string[];
+/** The keys of {@link FINAL_FIELDS}, in declared order. */
+export const FINAL_KEYS: readonly string[];
+/** The keys of {@link JOINING_FIELDS}, in declared order. */
+export const JOINING_KEYS: readonly string[];
+/** The keys of {@link JOIN_FIELDS}, in declared order. */
+export const JOIN_KEYS: readonly string[];
+/** The keys of {@link MARK_FIELDS}, in declared order. */
+export const MARK_KEYS: readonly string[];
+/** The keys of {@link SKELETON_FIELDS}, in declared order. */
+export const SKELETON_KEYS: readonly string[];
+/** The keys of {@link CALLING_CLOSING_FIELDS}, in declared order. */
+export const CALLING_CLOSING_KEYS: readonly string[];
+/** The keys of {@link ELEMENT_FIELDS}, in declared order. */
+export const ELEMENT_KEYS: readonly string[];
+/** The keys of {@link ROOT_FIELDS}, in declared order. */
+export const ROOT_KEYS: readonly string[];
+/** The keys of {@link SCOPE_FIELDS}, in declared order. */
+export const SCOPE_KINDS: readonly string[];