@keymanapp/kmc-model 18.0.53-alpha → 18.0.54-alpha

package/build/src/model-defaults.d.ts

@@ -1,56 +1,56 @@
-/// <reference types="@keymanapp/models-types" />
-/**
- * Converts wordforms into an indexable form. It does this by
- * normalizing the letter case of characters INDIVIDUALLY (to disregard
- * context-sensitive case transformations), normalizing to NFKD form,
- * and removing common diacritical marks.
- *
- * This is a very speculative implementation, that might work with
- * your language. We don't guarantee that this will be perfect for your
- * language, but it's a start.
- *
- * This uses String.prototype.normalize() to convert normalize into NFKD.
- * NFKD neutralizes some funky distinctions, e.g., ꬲ, ｅ, e should all be the
- * same character; plus, it's an easy way to separate a Latin character from
- * its diacritics; Even then, orthographies regularly use code points
- * that, under NFKD normalization, do NOT decompose appropriately for your
- * language (e.g., SENĆOŦEN, Plains Cree in syllabics).
- *
- * Use this in early iterations of the model. For a production lexical model,
- * you will probably write/generate your own key function, tailored to your
- * language. There is a chance the default will work properly out of the box.
- */
-export declare function defaultSearchTermToKey(wordform: string): string;
-/**
- * Converts wordforms into an indexable form. It does this by
- * normalizing the letter case of characters INDIVIDUALLY (to disregard
- * context-sensitive case transformations), normalizing to NFKD form,
- * and removing common diacritical marks.
- *
- * This is a very speculative implementation, that might work with
- * your language. We don't guarantee that this will be perfect for your
- * language, but it's a start.
- *
- * This uses String.prototype.normalize() to convert normalize into NFKD.
- * NFKD neutralizes some funky distinctions, e.g., ꬲ, ｅ, e should all be the
- * same character; plus, it's an easy way to separate a Latin character from
- * its diacritics; Even then, orthographies regularly use code points
- * that, under NFKD normalization, do NOT decompose appropriately for your
- * language (e.g., SENĆOŦEN, Plains Cree in syllabics).
- *
- * Use this in early iterations of the model. For a production lexical model,
- * you will probably write/generate your own key function, tailored to your
- * language. There is a chance the default will work properly out of the box.
- */
-export declare function defaultCasedSearchTermToKey(wordform: string, applyCasing: CasingFunction): string;
-/**
- * Specifies default casing behavior for lexical models when `languageUsesCasing` is
- * set to true.
- * @param casing One of 'lower' (lowercased), 'upper' (uppercased), or 'initial'.
- *
- * 'initial' is designed to cover cases like sentence-initial & proper noun capitalization in English.
- * This may be overwritten as appropriate in model-specific implementations.
- * @param text The text to be modified.
- */
-export declare function defaultApplyCasing(casing: CasingForm, text: string): string;
+/// <reference types="@keymanapp/models-types" />
+/**
+ * Converts wordforms into an indexable form. It does this by
+ * normalizing the letter case of characters INDIVIDUALLY (to disregard
+ * context-sensitive case transformations), normalizing to NFKD form,
+ * and removing common diacritical marks.
+ *
+ * This is a very speculative implementation, that might work with
+ * your language. We don't guarantee that this will be perfect for your
+ * language, but it's a start.
+ *
+ * This uses String.prototype.normalize() to convert normalize into NFKD.
+ * NFKD neutralizes some funky distinctions, e.g., ꬲ, ｅ, e should all be the
+ * same character; plus, it's an easy way to separate a Latin character from
+ * its diacritics; Even then, orthographies regularly use code points
+ * that, under NFKD normalization, do NOT decompose appropriately for your
+ * language (e.g., SENĆOŦEN, Plains Cree in syllabics).
+ *
+ * Use this in early iterations of the model. For a production lexical model,
+ * you will probably write/generate your own key function, tailored to your
+ * language. There is a chance the default will work properly out of the box.
+ */
+export declare function defaultSearchTermToKey(wordform: string): string;
+/**
+ * Converts wordforms into an indexable form. It does this by
+ * normalizing the letter case of characters INDIVIDUALLY (to disregard
+ * context-sensitive case transformations), normalizing to NFKD form,
+ * and removing common diacritical marks.
+ *
+ * This is a very speculative implementation, that might work with
+ * your language. We don't guarantee that this will be perfect for your
+ * language, but it's a start.
+ *
+ * This uses String.prototype.normalize() to convert normalize into NFKD.
+ * NFKD neutralizes some funky distinctions, e.g., ꬲ, ｅ, e should all be the
+ * same character; plus, it's an easy way to separate a Latin character from
+ * its diacritics; Even then, orthographies regularly use code points
+ * that, under NFKD normalization, do NOT decompose appropriately for your
+ * language (e.g., SENĆOŦEN, Plains Cree in syllabics).
+ *
+ * Use this in early iterations of the model. For a production lexical model,
+ * you will probably write/generate your own key function, tailored to your
+ * language. There is a chance the default will work properly out of the box.
+ */
+export declare function defaultCasedSearchTermToKey(wordform: string, applyCasing: CasingFunction): string;
+/**
+ * Specifies default casing behavior for lexical models when `languageUsesCasing` is
+ * set to true.
+ * @param casing One of 'lower' (lowercased), 'upper' (uppercased), or 'initial'.
+ *
+ * 'initial' is designed to cover cases like sentence-initial & proper noun capitalization in English.
+ * This may be overwritten as appropriate in model-specific implementations.
+ * @param text The text to be modified.
+ */
+export declare function defaultApplyCasing(casing: CasingForm, text: string): string;
 //# sourceMappingURL=model-defaults.d.ts.map

package/build/src/model-defaults.js

@@ -1,102 +1,102 @@
-/**
- * Converts wordforms into an indexable form. It does this by
- * normalizing the letter case of characters INDIVIDUALLY (to disregard
- * context-sensitive case transformations), normalizing to NFKD form,
- * and removing common diacritical marks.
- *
- * This is a very speculative implementation, that might work with
- * your language. We don't guarantee that this will be perfect for your
- * language, but it's a start.
- *
- * This uses String.prototype.normalize() to convert normalize into NFKD.
- * NFKD neutralizes some funky distinctions, e.g., ꬲ, ｅ, e should all be the
- * same character; plus, it's an easy way to separate a Latin character from
- * its diacritics; Even then, orthographies regularly use code points
- * that, under NFKD normalization, do NOT decompose appropriately for your
- * language (e.g., SENĆOŦEN, Plains Cree in syllabics).
- *
- * Use this in early iterations of the model. For a production lexical model,
- * you will probably write/generate your own key function, tailored to your
- * language. There is a chance the default will work properly out of the box.
- */
-export function defaultSearchTermToKey(wordform) {
-    return wordform
-        .normalize('NFKD')
-        // Remove any combining diacritics (if input is in NFKD)
-        .replace(/[\u0300-\u036F]/g, '')
-        // Replace directional quotation marks with plain apostrophes
-        .replace(/[‘’]/g, "'")
-        // Also double-quote marks.
-        .replace(/[“”]/g, '"');
-}
-/**
- * Converts wordforms into an indexable form. It does this by
- * normalizing the letter case of characters INDIVIDUALLY (to disregard
- * context-sensitive case transformations), normalizing to NFKD form,
- * and removing common diacritical marks.
- *
- * This is a very speculative implementation, that might work with
- * your language. We don't guarantee that this will be perfect for your
- * language, but it's a start.
- *
- * This uses String.prototype.normalize() to convert normalize into NFKD.
- * NFKD neutralizes some funky distinctions, e.g., ꬲ, ｅ, e should all be the
- * same character; plus, it's an easy way to separate a Latin character from
- * its diacritics; Even then, orthographies regularly use code points
- * that, under NFKD normalization, do NOT decompose appropriately for your
- * language (e.g., SENĆOŦEN, Plains Cree in syllabics).
- *
- * Use this in early iterations of the model. For a production lexical model,
- * you will probably write/generate your own key function, tailored to your
- * language. There is a chance the default will work properly out of the box.
- */
-export function defaultCasedSearchTermToKey(wordform, applyCasing) {
-    // While this is a bit WET, as the basic `defaultSearchTermToKey` exists and performs some of
-    // the same functions, repetition is the easiest way to allow the function to be safely compiled
-    // with ease by use of `.toString()`.
-    return Array.from(wordform
-        .normalize('NFKD')
-        // Remove any combining diacritics (if input is in NFKD)
-        .replace(/[\u0300-\u036F]/g, '')) // end of `Array.from`
-        .map(function (c) { return applyCasing('lower', c); })
-        .join('')
-        // Replace directional quotation marks with plain apostrophes
-        .replace(/[‘’]/g, "'")
-        // Also double-quote marks.
-        .replace(/[“”]/g, '"');
-}
-/**
- * Specifies default casing behavior for lexical models when `languageUsesCasing` is
- * set to true.
- * @param casing One of 'lower' (lowercased), 'upper' (uppercased), or 'initial'.
- *
- * 'initial' is designed to cover cases like sentence-initial & proper noun capitalization in English.
- * This may be overwritten as appropriate in model-specific implementations.
- * @param text The text to be modified.
- */
-export function defaultApplyCasing(casing, text) {
-    switch (casing) {
-        case 'lower':
-            return text.toLowerCase();
-        case 'upper':
-            return text.toUpperCase();
-        case 'initial':
-            var headCode = text.charCodeAt(0);
-            // The length of the first code unit, as measured in code points.
-            var headUnitLength = 1;
-            // Is the first character a high surrogate, indicating possible use of UTF-16
-            // surrogate pairs?  Also, is the string long enough for there to BE a pair?
-            if (text.length > 1 && headCode >= 0xD800 && headCode <= 0xDBFF) {
-                // It's possible, so now we check for low surrogates.
-                var lowSurrogateCode = text.charCodeAt(1);
-                if (lowSurrogateCode >= 0xDC00 && lowSurrogateCode <= 0xDFFF) {
-                    // We have a surrogate pair; this pair is the 'first' character.
-                    headUnitLength++;
-                }
-            }
-            // Capitalizes the first code unit of the string, leaving the rest intact.
-            return text.substring(0, headUnitLength).toUpperCase() // head - uppercased
-                .concat(text.substring(headUnitLength)); // tail - lowercased
-    }
-}
+/**
+ * Converts wordforms into an indexable form. It does this by
+ * normalizing the letter case of characters INDIVIDUALLY (to disregard
+ * context-sensitive case transformations), normalizing to NFKD form,
+ * and removing common diacritical marks.
+ *
+ * This is a very speculative implementation, that might work with
+ * your language. We don't guarantee that this will be perfect for your
+ * language, but it's a start.
+ *
+ * This uses String.prototype.normalize() to convert normalize into NFKD.
+ * NFKD neutralizes some funky distinctions, e.g., ꬲ, ｅ, e should all be the
+ * same character; plus, it's an easy way to separate a Latin character from
+ * its diacritics; Even then, orthographies regularly use code points
+ * that, under NFKD normalization, do NOT decompose appropriately for your
+ * language (e.g., SENĆOŦEN, Plains Cree in syllabics).
+ *
+ * Use this in early iterations of the model. For a production lexical model,
+ * you will probably write/generate your own key function, tailored to your
+ * language. There is a chance the default will work properly out of the box.
+ */
+export function defaultSearchTermToKey(wordform) {
+    return wordform
+        .normalize('NFKD')
+        // Remove any combining diacritics (if input is in NFKD)
+        .replace(/[\u0300-\u036F]/g, '')
+        // Replace directional quotation marks with plain apostrophes
+        .replace(/[‘’]/g, "'")
+        // Also double-quote marks.
+        .replace(/[“”]/g, '"');
+}
+/**
+ * Converts wordforms into an indexable form. It does this by
+ * normalizing the letter case of characters INDIVIDUALLY (to disregard
+ * context-sensitive case transformations), normalizing to NFKD form,
+ * and removing common diacritical marks.
+ *
+ * This is a very speculative implementation, that might work with
+ * your language. We don't guarantee that this will be perfect for your
+ * language, but it's a start.
+ *
+ * This uses String.prototype.normalize() to convert normalize into NFKD.
+ * NFKD neutralizes some funky distinctions, e.g., ꬲ, ｅ, e should all be the
+ * same character; plus, it's an easy way to separate a Latin character from
+ * its diacritics; Even then, orthographies regularly use code points
+ * that, under NFKD normalization, do NOT decompose appropriately for your
+ * language (e.g., SENĆOŦEN, Plains Cree in syllabics).
+ *
+ * Use this in early iterations of the model. For a production lexical model,
+ * you will probably write/generate your own key function, tailored to your
+ * language. There is a chance the default will work properly out of the box.
+ */
+export function defaultCasedSearchTermToKey(wordform, applyCasing) {
+    // While this is a bit WET, as the basic `defaultSearchTermToKey` exists and performs some of
+    // the same functions, repetition is the easiest way to allow the function to be safely compiled
+    // with ease by use of `.toString()`.
+    return Array.from(wordform
+        .normalize('NFKD')
+        // Remove any combining diacritics (if input is in NFKD)
+        .replace(/[\u0300-\u036F]/g, '')) // end of `Array.from`
+        .map(function (c) { return applyCasing('lower', c); })
+        .join('')
+        // Replace directional quotation marks with plain apostrophes
+        .replace(/[‘’]/g, "'")
+        // Also double-quote marks.
+        .replace(/[“”]/g, '"');
+}
+/**
+ * Specifies default casing behavior for lexical models when `languageUsesCasing` is
+ * set to true.
+ * @param casing One of 'lower' (lowercased), 'upper' (uppercased), or 'initial'.
+ *
+ * 'initial' is designed to cover cases like sentence-initial & proper noun capitalization in English.
+ * This may be overwritten as appropriate in model-specific implementations.
+ * @param text The text to be modified.
+ */
+export function defaultApplyCasing(casing, text) {
+    switch (casing) {
+        case 'lower':
+            return text.toLowerCase();
+        case 'upper':
+            return text.toUpperCase();
+        case 'initial':
+            var headCode = text.charCodeAt(0);
+            // The length of the first code unit, as measured in code points.
+            var headUnitLength = 1;
+            // Is the first character a high surrogate, indicating possible use of UTF-16
+            // surrogate pairs?  Also, is the string long enough for there to BE a pair?
+            if (text.length > 1 && headCode >= 0xD800 && headCode <= 0xDBFF) {
+                // It's possible, so now we check for low surrogates.
+                var lowSurrogateCode = text.charCodeAt(1);
+                if (lowSurrogateCode >= 0xDC00 && lowSurrogateCode <= 0xDFFF) {
+                    // We have a surrogate pair; this pair is the 'first' character.
+                    headUnitLength++;
+                }
+            }
+            // Capitalizes the first code unit of the string, leaving the rest intact.
+            return text.substring(0, headUnitLength).toUpperCase() // head - uppercased
+                .concat(text.substring(headUnitLength)); // tail - lowercased
+    }
+}
 //# sourceMappingURL=model-defaults.js.map

package/build/src/model-defaults.js.map

@@ -1 +1 @@
-{"version":3,"file":"model-defaults.js","sourceRoot":"","sources":["../../src/model-defaults.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,sBAAsB,CAAC,QAAgB;IACrD,OAAO,QAAQ;SACV,SAAS,CAAC,MAAM,CAAC;QAClB,wDAAwD;SACvD,OAAO,CAAC,kBAAkB,EAAE,EAAE,CAAC;QAChC,6DAA6D;SAC5D,OAAO,CAAC,OAAO,EAAE,GAAG,CAAC;QACtB,2BAA2B;SAC1B,OAAO,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;AAC7B,CAAC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,2BAA2B,CAAC,QAAgB,EAAE,WAA2B;IACvF,6FAA6F;IAC7F,gGAAgG;IAChG,qCAAqC;IACrC,OAAO,KAAK,CAAC,IAAI,CAAC,QAAQ;SACnB,SAAS,CAAC,MAAM,CAAC;QAClB,wDAAwD;SACvD,OAAO,CAAC,kBAAkB,EAAE,EAAE,CAAC,CACjC,CAAC,sBAAsB;SACvB,GAAG,CAAC,UAAS,CAAC,IAAI,OAAO,WAAW,CAAC,OAAO,EAAE,CAAC,CAAC,CAAA,CAAA,CAAC,CAAC;SAClD,IAAI,CAAC,EAAE,CAAC;QACT,6DAA6D;SAC5D,OAAO,CAAC,OAAO,EAAE,GAAG,CAAC;QACtB,2BAA2B;SAC1B,OAAO,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;AAC7B,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,kBAAkB,CAAC,MAAkB,EAAE,IAAY;IACjE,QAAO,MAAM,EAAE;QACb,KAAK,OAAO;YACV,OAAO,IAAI,CAAC,WAAW,EAAE,CAAC;QAC5B,KAAK,OAAO;YACV,OAAO,IAAI,CAAC,WAAW,EAAE,CAAC;QAC5B,KAAK,SAAS;YACZ,IAAI,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;YAClC,iEAAiE;YACjE,IAAI,cAAc,GAAG,CAAC,CAAC;YAEvB,6EAA6E;YAC7E,4EAA4E;YAC5E,IAAG,IAAI,CAAC,MAAM,GAAG,CAAC,IAAI,QAAQ,IAAI,MAAM,IAAI,QAAQ,IAAI,MAAM,EAAE;gBAC9D,qDAAqD;gBACrD,IAAI,gBAAgB,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;gBAE1C,IAAG,gBAAgB,IAAI,MAAM,IAAI,gBAAgB,IAAI,MAAM,EAAE;oBAC3D,gEAAgE;oBAChE,cAAc,EAAE,CAAC;iBAClB;aACF;YAED,0EAA0E;YAC1E,OAAO,IAAI,CAAC,SAAS,CAAC,CAAC,EAAE,cAAc,CAAC,CAAC,WAAW,EAAE,CAAC,oBAAoB;iBACnE,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC,CAAC,CAAQ,oBAAoB;KAC9E;AACH,CAAC"}
+{"version":3,"file":"model-defaults.js","sourceRoot":"","sources":["../../src/model-defaults.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,sBAAsB,CAAC,QAAgB;IACrD,OAAO,QAAQ;SACV,SAAS,CAAC,MAAM,CAAC;QAClB,wDAAwD;SACvD,OAAO,CAAC,kBAAkB,EAAE,EAAE,CAAC;QAChC,6DAA6D;SAC5D,OAAO,CAAC,OAAO,EAAE,GAAG,CAAC;QACtB,2BAA2B;SAC1B,OAAO,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;AAC7B,CAAC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,2BAA2B,CAAC,QAAgB,EAAE,WAA2B;IACvF,6FAA6F;IAC7F,gGAAgG;IAChG,qCAAqC;IACrC,OAAO,KAAK,CAAC,IAAI,CAAC,QAAQ;SACnB,SAAS,CAAC,MAAM,CAAC;QAClB,wDAAwD;SACvD,OAAO,CAAC,kBAAkB,EAAE,EAAE,CAAC,CACjC,CAAC,sBAAsB;SACvB,GAAG,CAAC,UAAS,CAAC,IAAI,OAAO,WAAW,CAAC,OAAO,EAAE,CAAC,CAAC,CAAA,CAAA,CAAC,CAAC;SAClD,IAAI,CAAC,EAAE,CAAC;QACT,6DAA6D;SAC5D,OAAO,CAAC,OAAO,EAAE,GAAG,CAAC;QACtB,2BAA2B;SAC1B,OAAO,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;AAC7B,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,kBAAkB,CAAC,MAAkB,EAAE,IAAY;IACjE,QAAO,MAAM,EAAE,CAAC;QACd,KAAK,OAAO;YACV,OAAO,IAAI,CAAC,WAAW,EAAE,CAAC;QAC5B,KAAK,OAAO;YACV,OAAO,IAAI,CAAC,WAAW,EAAE,CAAC;QAC5B,KAAK,SAAS;YACZ,IAAI,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;YAClC,iEAAiE;YACjE,IAAI,cAAc,GAAG,CAAC,CAAC;YAEvB,6EAA6E;YAC7E,4EAA4E;YAC5E,IAAG,IAAI,CAAC,MAAM,GAAG,CAAC,IAAI,QAAQ,IAAI,MAAM,IAAI,QAAQ,IAAI,MAAM,EAAE,CAAC;gBAC/D,qDAAqD;gBACrD,IAAI,gBAAgB,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;gBAE1C,IAAG,gBAAgB,IAAI,MAAM,IAAI,gBAAgB,IAAI,MAAM,EAAE,CAAC;oBAC5D,gEAAgE;oBAChE,cAAc,EAAE,CAAC;gBACnB,CAAC;YACH,CAAC;YAED,0EAA0E;YAC1E,OAAO,IAAI,CAAC,SAAS,CAAC,CAAC,EAAE,cAAc,CAAC,CAAC,WAAW,EAAE,CAAC,oBAAoB;iBACnE,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC,CAAC,CAAQ,oBAAoB;IAC/E,CAAC;AACH,CAAC"}

package/build/src/model-definitions.d.ts

@@ -1,71 +1,71 @@
-/// <reference types="@keymanapp/models-types" />
-import { LexicalModelSource, WordformToKeySpec } from "./lexical-model.js";
-/**
- * Processes certain defined model behaviors in such a way that the needed closures
- * may be safely compiled to a JS file and loaded within the LMLayer.
- *
- * This is accomplished by writing out a 'pseudoclosure' within the model's IIFE,
- * then used to build _actual_ closures at LMLayer load time.  This 'pseudoclosure'
- * will very closely match the organizational patterns of this class in order to
- * facilitate the maintenance of this approach.
- */
-export declare class ModelDefinitions {
-    static readonly COMPILED_NAME = "definitions";
-    /**
-     * A closure fully implementing the model's defined `applyCasing` behavior with
-     * the function parameter preset to the version-appropriate default.
-     * `defaults.applyCasing` is captured as part of the closure.
-     *
-     * During compilation of some models (such as Trie-based wordlist templated models),
-     * this closure will be directly used as part of searchTermToKey.
-     *
-     * In compiled code, this will instead be defined in-line as an autogenerated closure
-     * using the other properties of the pseudoclosure.
-     */
-    applyCasing?: CasingFunction;
-    /**
-     * A closure fully implementing the model's defined `searchTermToKey` behavior
-     * based upon the model's specified casing rules.  The `applyCasing` closure is
-     * itself captured within this closure.
-     *
-     * During compilation of some models (such as Trie-based wordlist templated models),
-     * this closure will be directly utilized when compiling the lexicon.
-     *
-     * In compiled code, this will instead be defined in-line as an autogenerated closure
-     * using the other properties of the pseudoclosure.
-     */
-    searchTermToKey?: WordformToKeySpec;
-    /**
-     * Contains embedded 'default' implementations that may be needed for
-     * closures in the compiled version, annotated with the current version
-     * of Developer.
-     */
-    private defaults;
-    /**
-     * Contains the model-specific definitions specified in the model's source.
-     *
-     * These definitions may expect `defaults.applyCasing` as a parameter in
-     * their final closures.
-     */
-    private model;
-    constructor(modelSource: LexicalModelSource);
-    /**
-     * Writes out a compiled JS version of the pseudoclosure, preserving all function
-     * implementations.
-     *
-     * This should be written to the file within the same IIFE as the model but BEFORE
-     * the model itself, as the model will need to refer to the definitions herein.
-     */
-    compileDefinitions(): string;
-    /**
-     * Compiles the model-options entry for `searchTermToKey` in reference to the
-     * compiled pseudoclosure.
-     */
-    compileSearchTermToKey(): string;
-    /**
-     * Compiles the model-options entry for `applyCasing` in reference to the
-     * compiled pseudoclosure.
-     */
-    compileApplyCasing(): string;
-}
+/// <reference types="@keymanapp/models-types" />
+import { LexicalModelSource, WordformToKeySpec } from "./lexical-model.js";
+/**
+ * Processes certain defined model behaviors in such a way that the needed closures
+ * may be safely compiled to a JS file and loaded within the LMLayer.
+ *
+ * This is accomplished by writing out a 'pseudoclosure' within the model's IIFE,
+ * then used to build _actual_ closures at LMLayer load time.  This 'pseudoclosure'
+ * will very closely match the organizational patterns of this class in order to
+ * facilitate the maintenance of this approach.
+ */
+export declare class ModelDefinitions {
+    static readonly COMPILED_NAME = "definitions";
+    /**
+     * A closure fully implementing the model's defined `applyCasing` behavior with
+     * the function parameter preset to the version-appropriate default.
+     * `defaults.applyCasing` is captured as part of the closure.
+     *
+     * During compilation of some models (such as Trie-based wordlist templated models),
+     * this closure will be directly used as part of searchTermToKey.
+     *
+     * In compiled code, this will instead be defined in-line as an autogenerated closure
+     * using the other properties of the pseudoclosure.
+     */
+    applyCasing?: CasingFunction;
+    /**
+     * A closure fully implementing the model's defined `searchTermToKey` behavior
+     * based upon the model's specified casing rules.  The `applyCasing` closure is
+     * itself captured within this closure.
+     *
+     * During compilation of some models (such as Trie-based wordlist templated models),
+     * this closure will be directly utilized when compiling the lexicon.
+     *
+     * In compiled code, this will instead be defined in-line as an autogenerated closure
+     * using the other properties of the pseudoclosure.
+     */
+    searchTermToKey?: WordformToKeySpec;
+    /**
+     * Contains embedded 'default' implementations that may be needed for
+     * closures in the compiled version, annotated with the current version
+     * of Developer.
+     */
+    private defaults;
+    /**
+     * Contains the model-specific definitions specified in the model's source.
+     *
+     * These definitions may expect `defaults.applyCasing` as a parameter in
+     * their final closures.
+     */
+    private model;
+    constructor(modelSource: LexicalModelSource);
+    /**
+     * Writes out a compiled JS version of the pseudoclosure, preserving all function
+     * implementations.
+     *
+     * This should be written to the file within the same IIFE as the model but BEFORE
+     * the model itself, as the model will need to refer to the definitions herein.
+     */
+    compileDefinitions(): string;
+    /**
+     * Compiles the model-options entry for `searchTermToKey` in reference to the
+     * compiled pseudoclosure.
+     */
+    compileSearchTermToKey(): string;
+    /**
+     * Compiles the model-options entry for `applyCasing` in reference to the
+     * compiled pseudoclosure.
+     */
+    compileApplyCasing(): string;
+}
 //# sourceMappingURL=model-definitions.d.ts.map