fast-publicodes 0.0.0 → 1.1.0

package/LICENSE

@@ -0,0 +1,26 @@
+MIT License
+
+Copyright (c) 2026 Troopay
+
+fast-publicodes is a port of publicodes (https://github.com/publicodes/publicodes),
+distributed under the following notice:
+
+    Copyright (c) 2018-2021 beta.gouv.fr
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,83 @@
+# fast-publicodes
+
+A port of [publicodes](https://github.com/publicodes/publicodes) 1.x with its engine rewritten in Rust: the same API and the same behaviour, faster. Node loads it as a native addon, prebuilt for Linux, macOS and Windows; browsers, other runtimes and other platforms load it as WebAssembly, from the same package.
+
+> **Not affiliated with the publicodes project.** fast-publicodes is an independent port. The language, its features and every discussion about them belong to [publicodes](https://github.com/publicodes/publicodes): propose features and report language issues there, not here. If publicodes is useful to you, support its authors: star the repository, contribute, and credit them.
+
+## When to use it
+
+Use fast-publicodes where evaluating publicodes rules is a bottleneck:
+
+- **On a server**: APIs, batch jobs or simulations that evaluate many situations, where each evaluation costs CPU time and latency.
+- **In a client**: large rule sets recomputed on every input, or slower devices, where evaluation delays the interface.
+
+Stay with publicodes when its speed is enough for you, or when you need what fast-publicodes does not provide (see [Limitations](#limitations)), such as the explanations publicodes-react renders. In a browser, also weigh the size of the WebAssembly module against the time it saves.
+
+## Usage
+
+```bash
+npm install fast-publicodes
+```
+
+Then replace the import; nothing else changes.
+
+```ts
+import Engine from "fast-publicodes";
+
+const engine = new Engine(rules);
+engine.setSituation({ "salaire brut": 3000 }).evaluate("salaire net");
+```
+
+## Performance
+
+On the [modele-social](https://www.npmjs.com/package/modele-social) rules (`pnpm bench`, Node, one machine):
+
+| Operation | publicodes | fast-publicodes | Speed-up |
+| --- | --- | --- | --- |
+| Parse the rules | 366 ms | 68 ms | 5× |
+| Set a situation and evaluate one rule | 23.7 ms | 0.75 ms | 32× |
+| Set a situation and evaluate every rule | 313 ms | 18 ms | 18× |
+| `shallowCopy()` | 6.2 ms | 0.42 ms | 15× |
+
+## Limitations
+
+- **No AST.** `evaluate()` returns `nodeValue`, `unit` and `missingVariables` without `explanation`, and rules returned by `getRule()` and `getParsedRules()` carry their metadata without their node tree; their `suggestions` are opaque values that only `evaluate()` reads. `parsePublicodes`, `reduceAST`, `transformAST`, `traverseASTNode`, `utils.cyclicDependencies`, `utils.disambiguateReferenceNode` and `utils.updateReferencesMapsFromReferenceNode` are not provided, and `evaluate()` accepts no AST node other than these suggestions.
+- **Internal fields.** Of the members `publicodes` marks as internal, only `context.nodesTypes` exists, with the type inferred for each rule `getRule()` returns; `baseContext`, `publicParsedRules`, `cache`, `evaluateNode` and the rest of `context` do not.
+- **`undefined` inside rules.** A property of a rule set to `undefined` counts as absent, where `publicodes` reads some of them as an empty value.
+
+## Development
+
+### Requirements
+
+- Node 22+
+- pnpm 10.33
+- Rust via rustup (the pinned toolchain installs itself)
+- `wasm-bindgen-cli` 0.2.129, for the WebAssembly module: `cargo install wasm-bindgen-cli --version 0.2.129 --locked`
+
+### Setup
+
+```bash
+pnpm install
+pnpm build:native
+```
+
+### Commands
+
+| Command | Purpose |
+| --- | --- |
+| `pnpm build:native` | Build the debug addon, needed before `pnpm test` |
+| `pnpm build:wasm` | Build the WebAssembly module, needed before `pnpm test:wasm` |
+| `pnpm build` | Release addon, WebAssembly module and compiled package |
+| `pnpm lint` | Lint and type check Rust and TypeScript |
+| `pnpm format` | Format Rust and TypeScript |
+| `pnpm test` | TypeScript tests, including the comparison against publicodes |
+| `pnpm test:wasm` | The same tests against the WebAssembly module |
+| `FUZZ_SEED=100 pnpm test test/compat/fuzz.test.ts` | Fuzz new seeds; see [docs/testing.md](docs/testing.md) |
+| `cargo test` | Rust tests |
+| `pnpm bench` | Benchmarks against publicodes |
+
+To publish a version, see [docs/releasing.md](docs/releasing.md).
+
+## License
+
+[MIT](LICENSE), including the notice of publicodes, from which this port derives.

package/dist/api.d.ts

@@ -0,0 +1,11 @@
+import { Engine } from "./engine.js";
+import * as utils from "./ruleUtils.js";
+import type { ExprAST } from "./types.js";
+export { isPublicodesError, PublicodesError } from "./error.js";
+export { serializeEvaluation, simplifyNodeUnit } from "./evaluation.js";
+export { capitalise0, formatValue } from "./format.js";
+export type * from "./types.js";
+export { parseUnit, serializeUnit, type Unit } from "./units.js";
+export { Engine, utils };
+export default Engine;
+export declare function parseExpression(expression: string, dottedName?: string): ExprAST;

package/dist/api.js

@@ -0,0 +1,17 @@
+import { binding } from "./binding.js";
+import { Engine } from "./engine.js";
+import { fromNative } from "./error.js";
+import * as utils from "./ruleUtils.js";
+export { isPublicodesError, PublicodesError } from "./error.js";
+export { serializeEvaluation, simplifyNodeUnit } from "./evaluation.js";
+export { capitalise0, formatValue } from "./format.js";
+export { parseUnit, serializeUnit } from "./units.js";
+export { Engine, utils };
+export default Engine;
+export function parseExpression(expression, dottedName = "<expression>") {
+    const result = binding().parseExpression(expression, dottedName);
+    if ("error" in result) {
+        throw fromNative(JSON.parse(result.error));
+    }
+    return JSON.parse(result.expression);
+}

package/dist/binding.d.ts

@@ -0,0 +1,29 @@
+/** What the Node addon and the WebAssembly module both export. */
+export interface Binding {
+    Engine: new (rules: string, options: string, getToday: () => string, getUnitKey?: (unit: string) => string | {
+        message?: string;
+    }) => NativeEngine;
+    parseExpression(expression: string, dottedName: string): object;
+}
+export interface NativeEngine {
+    setSituation(situation: string, keepPrevious: boolean, strict: boolean): object;
+    evaluate(text: string, json: boolean): object;
+    evaluateSuggestion(rule: string, name: string): object;
+    evaluations(): unknown;
+    missingVariables(evaluations: unknown, index: number): object;
+    takeWarnings(): object;
+    inversionFail(): boolean;
+    resetCache(): void;
+    shallowCopy(copyCache: boolean): NativeEngine;
+    ruleNames(): string[];
+    rule(name: string): object;
+    applicablePossibilities(name: string): object;
+}
+/** Sets the binding the package uses; its entry points call it before anything else runs. */
+export declare function useBinding(binding: Binding): void;
+export declare function binding(): Binding;
+/**
+ * `value` as JSON for the binding, writing what JSON cannot as `{ "\u0000": String(it) }`:
+ * non-finite numbers, and `undefined` as `value` or as one of its properties.
+ */
+export declare function toJson(value: unknown): string;

package/dist/binding.js

@@ -0,0 +1,27 @@
+let current;
+/** Sets the binding the package uses; its entry points call it before anything else runs. */
+export function useBinding(binding) {
+    current = binding;
+}
+export function binding() {
+    if (!current)
+        throw new Error("fast-publicodes was loaded without its engine");
+    return current;
+}
+/**
+ * `value` as JSON for the binding, writing what JSON cannot as `{ "\u0000": String(it) }`:
+ * non-finite numbers, and `undefined` as `value` or as one of its properties.
+ */
+export function toJson(value) {
+    if (value === undefined)
+        return UNDEFINED;
+    return JSON.stringify(value, function (_key, item) {
+        if (typeof item === "number" && !Number.isFinite(item)) {
+            return { "\u0000": String(item) };
+        }
+        return item === undefined && this === value
+            ? { "\u0000": "undefined" }
+            : item;
+    });
+}
+const UNDEFINED = JSON.stringify({ "\u0000": "undefined" });

package/dist/engine.d.ts

@@ -0,0 +1,42 @@
+import type { EngineOptions, EvaluatedNode, InferedType, ParsedRules, Possibility, PublicodesExpression, RawPublicodes, RuleNode, Situation } from "./types.js";
+export declare class Engine<RuleNames extends string = string> {
+    private native;
+    private logger;
+    private publicSituation;
+    private parsedRules;
+    private rules;
+    /** `nodesTypes` alone, for the rule nodes `getRule()` returns. */
+    context: {
+        nodesTypes: WeakMap<RuleNode, InferedType>;
+    };
+    private warningTexts;
+    private unitKey;
+    /** Results by evaluated value, until the cache is reset. */
+    private evaluations;
+    /** The engine's handle on the evaluations of the current cache. */
+    private evaluationsHandle;
+    private units;
+    constructor(rules?: RawPublicodes<RuleNames>, options?: EngineOptions);
+    private logWarnings;
+    setSituation(situation?: Situation<RuleNames>, { keepPreviousSituation, strict, }?: {
+        keepPreviousSituation?: boolean;
+        strict?: boolean;
+    }): this;
+    private accept;
+    getSituation(): Situation<RuleNames>;
+    evaluate(value: PublicodesExpression): EvaluatedNode;
+    private evaluateNative;
+    getRule(dottedName: RuleNames): RuleNode<RuleNames>;
+    getParsedRules(): ParsedRules<RuleNames>;
+    getPossibilitiesFor(dottedName: RuleNames, { filterNotApplicable }?: {
+        filterNotApplicable?: boolean;
+    }): Possibility[] | null;
+    inversionFail(): boolean;
+    resetCache(): void;
+    private resetEvaluations;
+    private unitOf;
+    shallowCopy({ copyCache, }?: {
+        copyCache?: boolean;
+        inherit?: boolean;
+    }): Engine<RuleNames>;
+}

package/dist/engine.js

@@ -0,0 +1,246 @@
+import { binding, toJson } from "./binding.js";
+import { fromNative, PublicodesError, restoreSurrogates, } from "./error.js";
+import { resolveOptions } from "./options.js";
+function unwrap(result) {
+    if ("error" in result) {
+        throw fromNative(JSON.parse(result.error));
+    }
+    return result;
+}
+function today() {
+    const date = new Date();
+    const pad = (n) => String(n).padStart(2, "0");
+    return `${pad(date.getDate())}/${pad(date.getMonth() + 1)}/${date.getFullYear()}`;
+}
+/**
+ * `getUnitKey` as the binding calls it: it returns the message of an `Error` it throws, and
+ * keeps any other value it throws for the engine to throw once the call that ran it returns.
+ */
+class UnitKey {
+    getUnitKey;
+    thrown;
+    constructor(getUnitKey) {
+        this.getUnitKey = getUnitKey;
+    }
+    call = (unit) => {
+        try {
+            return this.getUnitKey(unit);
+        }
+        catch (error) {
+            if (error instanceof Error)
+                return { message: error.message };
+            this.thrown = { value: error };
+            return {};
+        }
+    };
+    rethrow() {
+        const thrown = this.thrown;
+        if (thrown) {
+            this.thrown = undefined;
+            throw thrown.value;
+        }
+    }
+}
+function createNative(rules, options, logger, unitKey) {
+    if (typeof rules === "string") {
+        throw new PublicodesError("EngineError", "Publicodes does not parse yaml rule sets itself anymore. Please provide a parsed js object. E.g. the `eemeli/yaml` package.", {});
+    }
+    try {
+        return new (binding().Engine)(toJson(rules), JSON.stringify(resolveOptions(options)), today, unitKey?.call);
+    }
+    catch (error) {
+        unitKey?.rethrow();
+        let details;
+        try {
+            details = JSON.parse(error.message);
+        }
+        catch {
+            throw error;
+        }
+        for (const warning of details.warnings) {
+            logger.warn(restoreSurrogates(warning));
+        }
+        throw fromNative(details);
+    }
+}
+/** The rule and name of each suggestion `getRule()` returns, which any engine evaluates. */
+const suggestionSources = new WeakMap();
+export class Engine {
+    native;
+    logger;
+    publicSituation = {};
+    parsedRules;
+    rules = new Map();
+    /** `nodesTypes` alone, for the rule nodes `getRule()` returns. */
+    context = {
+        nodesTypes: new WeakMap(),
+    };
+    warningTexts = [];
+    unitKey;
+    /** Results by evaluated value, until the cache is reset. */
+    evaluations = new Map();
+    /** The engine's handle on the evaluations of the current cache. */
+    evaluationsHandle;
+    units = [];
+    constructor(rules = {}, options = {}) {
+        this.logger = options.logger ?? console;
+        this.unitKey = options.getUnitKey && new UnitKey(options.getUnitKey);
+        this.native = createNative(rules, options, this.logger, this.unitKey);
+        this.logWarnings(this.native.takeWarnings());
+    }
+    logWarnings({ warnings, warningsReset }) {
+        if (!warnings)
+            return;
+        if (warningsReset)
+            this.warningTexts = [];
+        for (const warning of warnings) {
+            if (typeof warning === "string") {
+                const text = restoreSurrogates(warning);
+                this.warningTexts.push(text);
+                this.logger.warn(text);
+            }
+            else {
+                this.logger.warn(this.warningTexts[warning]);
+            }
+        }
+    }
+    setSituation(situation = {}, { keepPreviousSituation = false, strict = false, } = {}) {
+        this.resetEvaluations();
+        const result = this.native.setSituation(toJson(situation), Boolean(keepPreviousSituation), Boolean(strict));
+        this.logWarnings(result);
+        const { accepted, error } = result;
+        if (error !== undefined) {
+            if (result.situationReset && !keepPreviousSituation) {
+                this.publicSituation = {};
+            }
+            if (accepted.length) {
+                this.accept(situation, accepted, keepPreviousSituation);
+            }
+            this.unitKey?.rethrow();
+            throw fromNative(JSON.parse(error));
+        }
+        this.accept(situation, accepted, keepPreviousSituation);
+        return this;
+    }
+    accept(situation, accepted, keepPreviousSituation) {
+        if (!keepPreviousSituation) {
+            this.publicSituation = {};
+        }
+        for (const name of accepted) {
+            this.publicSituation[name] = situation[name];
+        }
+    }
+    getSituation() {
+        return this.publicSituation;
+    }
+    evaluate(value) {
+        const evaluated = this.evaluations.get(value);
+        if (evaluated)
+            return evaluated;
+        if (typeof value === "object" && value !== null && "nodeKind" in value) {
+            throw new PublicodesError("EngineError", "fast-publicodes n'évalue pas les nœuds d'AST", {});
+        }
+        const result = this.evaluateNative(value);
+        this.logWarnings(result);
+        this.unitKey?.rethrow();
+        const { nodeValue, index, ...nativeUnit } = unwrap(result);
+        const unit = this.unitOf(nativeUnit);
+        const native = this.native;
+        this.evaluationsHandle ??= native.evaluations();
+        const handle = this.evaluationsHandle;
+        let missingVariables;
+        const evaluation = {
+            nodeValue,
+            ...(unit && { unit }),
+            // Built on first read: most callers only need the value.
+            get missingVariables() {
+                missingVariables ??= native.missingVariables(handle, index);
+                return missingVariables;
+            },
+        };
+        this.evaluations.set(value, evaluation);
+        return evaluation;
+    }
+    evaluateNative(value) {
+        const suggestion = typeof value === "object" ? suggestionSources.get(value) : undefined;
+        if (suggestion) {
+            return this.native.evaluateSuggestion(suggestion.rule, suggestion.name);
+        }
+        const json = typeof value !== "string";
+        const text = json ? toJson(value) : value;
+        return this.native.evaluate(text, json);
+    }
+    getRule(dottedName) {
+        let rule = this.rules.get(dottedName);
+        if (!rule) {
+            const result = this.native.rule(dottedName);
+            const { node, type, suggestions } = JSON.parse(unwrap(result).rule);
+            rule = { ...node, suggestions: {} };
+            for (const name of suggestions) {
+                const suggestion = Object.freeze({});
+                suggestionSources.set(suggestion, { rule: dottedName, name });
+                rule.suggestions[name] = suggestion;
+            }
+            this.rules.set(dottedName, rule);
+            this.context.nodesTypes.set(rule, {
+                isNullable: type.isNullable ?? undefined,
+                type: type.type ?? undefined,
+            });
+        }
+        return rule;
+    }
+    getParsedRules() {
+        if (!this.parsedRules) {
+            const rules = {};
+            for (const name of this.native.ruleNames()) {
+                rules[name] = this.getRule(name);
+            }
+            this.parsedRules = rules;
+        }
+        return this.parsedRules;
+    }
+    getPossibilitiesFor(dottedName, { filterNotApplicable = false } = {}) {
+        if (!filterNotApplicable) {
+            const { possibilities } = this.getRule(dottedName);
+            return possibilities ? possibilities.explanation : null;
+        }
+        const result = this.native.applicablePossibilities(dottedName);
+        this.logWarnings(result);
+        return JSON.parse(unwrap(result).possibilities);
+    }
+    inversionFail() {
+        return this.native.inversionFail();
+    }
+    resetCache() {
+        this.resetEvaluations();
+        this.native.resetCache();
+    }
+    resetEvaluations() {
+        this.evaluations = new Map();
+        this.evaluationsHandle = undefined;
+    }
+    unitOf({ unit, newUnit, unitsReset }) {
+        if (unitsReset)
+            this.units = [];
+        if (newUnit) {
+            this.units.push(newUnit);
+            return newUnit;
+        }
+        return unit === undefined ? undefined : this.units[unit];
+    }
+    shallowCopy({ copyCache = true, } = {}) {
+        const copy = Object.create(Engine.prototype);
+        copy.native = this.native.shallowCopy(Boolean(copyCache));
+        copy.logger = this.logger;
+        copy.publicSituation = { ...this.publicSituation };
+        copy.parsedRules = this.parsedRules;
+        copy.rules = this.rules;
+        copy.context = this.context;
+        copy.warningTexts = [...this.warningTexts];
+        copy.unitKey = this.unitKey;
+        copy.evaluations = copyCache ? new Map(this.evaluations) : new Map();
+        copy.evaluationsHandle = undefined;
+        copy.units = [...this.units];
+        return copy;
+    }
+}

package/dist/error.d.ts

@@ -0,0 +1,39 @@
+export interface PublicodesErrorTypes {
+    InternalError: {
+        dottedName?: string;
+    };
+    EngineError: Record<string, never>;
+    SyntaxError: {
+        dottedName: string;
+    };
+    EvaluationError: {
+        dottedName: string;
+    };
+    SituationError: {
+        dottedName: string;
+    };
+    UnknownRule: {
+        dottedName: string;
+    };
+    PrivateRule: {
+        dottedName: string;
+    };
+    TypeError: {
+        dottedName: string;
+    };
+}
+export declare class PublicodesError<Name extends keyof PublicodesErrorTypes = keyof PublicodesErrorTypes> extends Error {
+    name: Name;
+    info: PublicodesErrorTypes[Name];
+    constructor(name: Name, message: string, info: PublicodesErrorTypes[Name], originalError?: Error);
+}
+export declare function isPublicodesError<Name extends keyof PublicodesErrorTypes>(error: unknown, name?: Name): error is PublicodesError<Name>;
+export interface NativeError {
+    name: keyof PublicodesErrorTypes | "Error" | "TypeError";
+    message: string;
+    dottedName: string;
+}
+/** Restores the lone high surrogates the engine writes as private use characters. */
+export declare function restoreSurrogates(text: string): string;
+/** The error the engine reports, with the message it already wrote. */
+export declare function fromNative({ name, message: written, dottedName, }: NativeError): Error;

package/dist/error.js

@@ -0,0 +1,45 @@
+const titles = {
+    SyntaxError: "Erreur syntaxique",
+    EvaluationError: "Erreur d'évaluation",
+    SituationError: "Erreur lors de la mise à jour de la situation",
+    UnknownRule: "Règle inconnue",
+    PrivateRule: "Règle privée",
+};
+function buildMessage(name, message, info, originalError) {
+    const isError = /error/i.test(name);
+    return (`\n[ ${titles[name] ?? name} ]` +
+        (info?.dottedName ? `\n➡️  Dans la règle "${info.dottedName}"` : "") +
+        `\n${isError ? "✖️" : "⚠️"}  ${message}` +
+        (originalError
+            ? `\n${isError ? "    " : "ℹ️  "}${originalError.message}`
+            : ""));
+}
+export class PublicodesError extends Error {
+    name;
+    info;
+    constructor(name, message, info, originalError) {
+        super(buildMessage(name, message, info, originalError));
+        this.name = name;
+        this.info = info;
+    }
+}
+export function isPublicodesError(error, name) {
+    return (error instanceof PublicodesError &&
+        (name === undefined || error.name === name));
+}
+/** Restores the lone high surrogates the engine writes as private use characters. */
+export function restoreSurrogates(text) {
+    return text.replace(/[\u{F0000}-\u{F03FF}]/gu, (c) => String.fromCharCode(0xd800 + c.codePointAt(0) - 0xf0000));
+}
+/** The error the engine reports, with the message it already wrote. */
+export function fromNative({ name, message: written, dottedName, }) {
+    const message = restoreSurrogates(written);
+    if (name === "Error")
+        return new Error(message);
+    if (name === "TypeError")
+        return new TypeError(message);
+    const info = (dottedName ? { dottedName } : {});
+    const error = new PublicodesError(name, "", info);
+    error.message = message;
+    return error;
+}

package/dist/evaluation.d.ts

@@ -0,0 +1,5 @@
+import type { EvaluatedNode } from "./types.js";
+/** The node with its unit simplified, if it has one, and its value converted to it. */
+export declare function simplifyNodeUnit<Node extends EvaluatedNode = EvaluatedNode>(node: Node): Node;
+/** The node's value as a publicodes expression. */
+export declare function serializeEvaluation(node: EvaluatedNode): string | undefined;

package/dist/evaluation.js

@@ -0,0 +1,28 @@
+import { convertUnit, serializeUnit, simplifyUnit } from "./units.js";
+/** The node with its unit simplified, if it has one, and its value converted to it. */
+export function simplifyNodeUnit(node) {
+    if (!node.unit) {
+        return node;
+    }
+    const unit = simplifyUnit(node.unit);
+    return {
+        ...node,
+        nodeValue: typeof node.nodeValue === "number"
+            ? convertUnit(node.unit, unit, node.nodeValue)
+            : node.nodeValue,
+        unit,
+    };
+}
+/** The node's value as a publicodes expression. */
+export function serializeEvaluation(node) {
+    if (typeof node.nodeValue === "number") {
+        const unit = serializeUnit(node.unit);
+        return `${node.nodeValue}${unit ? unit.replace(/\s/g, "") : ""}`;
+    }
+    if (typeof node.nodeValue === "boolean") {
+        return node.nodeValue ? "oui" : "non";
+    }
+    if (typeof node.nodeValue === "string") {
+        return `'${node.nodeValue}'`;
+    }
+}

package/dist/format.d.ts

@@ -0,0 +1,14 @@
+import { type FormatUnit, type Unit } from "./units.js";
+export declare function capitalise0(name: undefined): undefined;
+export declare function capitalise0(name: string): string;
+type Formattable = number | {
+    nodeValue: number | string | boolean | null | undefined;
+    unit?: Unit;
+} | undefined;
+export declare function formatValue(value: Formattable, { language, displayedUnit, formatUnit, precision, }?: {
+    language?: string;
+    displayedUnit?: string;
+    precision?: number;
+    formatUnit?: FormatUnit;
+}): string | undefined;
+export {};