@lakutata/core 1.0.59 → 3.0.0-beta.0

package/dist/cjs/lib/validation/engine/schema/ref.js

@@ -0,0 +1,318 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Manager = exports.toParent = exports.toSibling = exports.Ref = void 0;
+exports.create = create;
+exports.isRef = isRef;
+exports.in = inRef;
+exports.build = build;
+/**
+ * Derived from the upstream lib/ref.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+const index_js_1 = require("../utils/index.js");
+const assert_js_1 = require("./assert.js");
+const Common = __importStar(require("./common.js"));
+const lazy_js_1 = require("./lazy.js");
+let Template;
+const defaults = {
+    adjust: null,
+    in: false,
+    iterables: null,
+    map: null,
+    separator: '.',
+    type: 'value'
+};
+/**
+ * A reference to another value (sibling key, ancestor, global context or local value)
+ */
+class Ref {
+    constructor(options) {
+        (0, assert_js_1.assert)(typeof options === 'object', 'Invalid reference construction');
+        Common.assertOptions(options, [
+            //Copied
+            'adjust', 'ancestor', 'in', 'iterables', 'map', 'path', 'render', 'separator', 'type',
+            //Overridden
+            'depth', 'key', 'root', 'display'
+        ]);
+        (0, assert_js_1.assert)([false, undefined].includes(options.separator) || typeof options.separator === 'string' && options.separator.length === 1, 'Invalid separator');
+        (0, assert_js_1.assert)(!options.adjust || typeof options.adjust === 'function', 'options.adjust must be a function');
+        (0, assert_js_1.assert)(!options.map || (0, index_js_1.isArray)(options.map), 'options.map must be an array');
+        (0, assert_js_1.assert)(!options.map || !options.adjust, 'Cannot set both map and adjust options');
+        Object.assign(this, defaults, options);
+        (0, assert_js_1.assert)(this.type === 'value' || this.ancestor === undefined, 'Non-value references cannot reference ancestors');
+        if ((0, index_js_1.isArray)(this.map))
+            this.map = new Map(this.map);
+        this.depth = this.path.length;
+        this.key = this.path.length ? this.path.join(this.separator) : null;
+        this.root = this.path[0];
+        this.updateDisplay();
+    }
+    resolve(value, state, prefs, local, options = {}) {
+        (0, assert_js_1.assert)(!this.in || options.in, 'Invalid in() reference usage');
+        if (this.type === 'global')
+            return this._resolve(prefs.context, state, options);
+        if (this.type === 'local')
+            return this._resolve(local, state, options);
+        if (!this.ancestor)
+            return this._resolve(value, state, options);
+        if (this.ancestor === 'root')
+            return this._resolve(state.ancestors[state.ancestors.length - 1], state, options);
+        (0, assert_js_1.assert)(this.ancestor <= state.ancestors.length, 'Invalid reference exceeds the schema root:', this.display);
+        return this._resolve(state.ancestors[this.ancestor - 1], state, options);
+    }
+    _resolve(target, state, options) {
+        let resolved;
+        //Like upstream: a value reference expects the state to have a mainstay
+        if (this.type === 'value' && state.mainstay.shadow && options.shadow !== false) {
+            resolved = state.mainstay.shadow.get(this.absolute(state));
+        }
+        if (resolved === undefined)
+            resolved = (0, index_js_1.reach)(target, this.path, { iterables: !!this.iterables, functions: true });
+        if (this.adjust)
+            resolved = this.adjust(resolved);
+        if (this.map) {
+            const mapped = this.map.get(resolved);
+            if (mapped !== undefined)
+                resolved = mapped;
+        }
+        if (state.mainstay)
+            state.mainstay.tracer.resolve(state, this, resolved);
+        return resolved;
+    }
+    toString() {
+        return this.display;
+    }
+    absolute(state) {
+        return [...state.path.slice(0, -this.ancestor), ...this.path];
+    }
+    clone() {
+        return new Ref(this);
+    }
+    describe() {
+        const ref = { path: this.path };
+        if (this.type !== 'value')
+            ref.type = this.type;
+        if (this.separator !== '.')
+            ref.separator = this.separator;
+        if (this.type === 'value' && this.ancestor !== 1)
+            ref.ancestor = this.ancestor;
+        if (this.map)
+            ref.map = [...this.map];
+        if (this.adjust !== null && this.adjust !== undefined)
+            ref.adjust = this.adjust;
+        if (this.iterables !== null && this.iterables !== undefined)
+            ref.iterables = this.iterables;
+        if (this.render !== null && this.render !== undefined)
+            ref.render = this.render;
+        if (this.in !== false)
+            ref.in = true;
+        return { ref };
+    }
+    updateDisplay() {
+        const key = this.key !== null ? this.key : '';
+        if (this.type !== 'value') {
+            this.display = `ref:${this.type}:${key}`;
+            return;
+        }
+        if (!this.separator) {
+            this.display = `ref:${key}`;
+            return;
+        }
+        if (!this.ancestor) {
+            this.display = `ref:${this.separator}${key}`;
+            return;
+        }
+        if (this.ancestor === 'root') {
+            this.display = `ref:root:${key}`;
+            return;
+        }
+        if (this.ancestor === 1) {
+            this.display = `ref:${key || '..'}`;
+            return;
+        }
+        const lead = new Array(this.ancestor + 1).fill(this.separator).join('');
+        this.display = `ref:${lead}${key || ''}`;
+    }
+}
+exports.Ref = Ref;
+Object.defineProperty(Ref.prototype, Common.symbols.ref, { value: true, writable: true, enumerable: true, configurable: true });
+function context(key, separator, prefix = {}) {
+    key = key.trim();
+    if (prefix) {
+        const globalp = prefix.global === undefined ? '$' : prefix.global;
+        if (globalp !== separator && key.startsWith(globalp))
+            return { key: key.slice(globalp.length), type: 'global' };
+        const local = prefix.local === undefined ? '#' : prefix.local;
+        if (local !== separator && key.startsWith(local))
+            return { key: key.slice(local.length), type: 'local' };
+        const root = prefix.root === undefined ? '/' : prefix.root;
+        if (root !== separator && key.startsWith(root))
+            return { key: key.slice(root.length), type: 'value', root: true };
+    }
+    return { key, type: 'value' };
+}
+function ancestor(key, separator) {
+    //'a_b' -> 1 (parent)
+    if (!separator)
+        return [1, 0];
+    //'a.b' -> 1 (parent)
+    if (key[0] !== separator)
+        return [1, 0];
+    //'.a.b' -> 0 (self)
+    if (key[1] !== separator)
+        return [0, 1];
+    let i = 2;
+    while (key[i] === separator)
+        ++i;
+    //'...a.b.' -> 2 (grandparent)
+    return [i - 1, i];
+}
+/**
+ * Create a reference
+ * @param key
+ * @param options
+ */
+function create(key, options = {}) {
+    (0, assert_js_1.assert)(typeof key === 'string', 'Invalid reference key:', key);
+    Common.assertOptions(options, ['adjust', 'ancestor', 'in', 'iterables', 'map', 'prefix', 'render', 'separator']);
+    (0, assert_js_1.assert)(!options.prefix || typeof options.prefix === 'object', 'options.prefix must be of type object');
+    const ref = Object.assign({}, defaults, options);
+    delete ref.prefix;
+    const separator = ref.separator;
+    const refContext = context(key, separator, options.prefix);
+    ref.type = refContext.type;
+    let refKey = refContext.key;
+    if (ref.type === 'value') {
+        if (refContext.root) {
+            (0, assert_js_1.assert)(!separator || refKey[0] !== separator, 'Cannot specify relative path with root prefix');
+            ref.ancestor = 'root';
+            if (!refKey)
+                refKey = null;
+        }
+        if (separator && separator === refKey) {
+            refKey = null;
+            ref.ancestor = 0;
+        }
+        else {
+            if (ref.ancestor !== undefined) {
+                (0, assert_js_1.assert)(!separator || !refKey || refKey[0] !== separator, 'Cannot combine prefix with ancestor option');
+            }
+            else {
+                const [refAncestor, slice] = ancestor(refKey, separator);
+                if (slice) {
+                    refKey = refKey.slice(slice);
+                    if (refKey === '')
+                        refKey = null;
+                }
+                ref.ancestor = refAncestor;
+            }
+        }
+    }
+    ref.path = separator ? (refKey === null ? [] : refKey.split(separator)) : [refKey];
+    return new Ref(ref);
+}
+function isRef(ref) {
+    return ref ? !!ref[Common.symbols.ref] : false;
+}
+/**
+ * Create an in() reference (matching any item of the referenced array or any key of the referenced object)
+ * @param key
+ * @param options
+ */
+function inRef(key, options = {}) {
+    return create(key, { ...options, in: true });
+}
+/**
+ * Build a reference from its description
+ * @param desc
+ */
+function build(desc) {
+    const settings = Object.assign({}, defaults, desc);
+    if (settings.type === 'value' && settings.ancestor === undefined)
+        settings.ancestor = 1;
+    return new Ref(settings);
+}
+exports.toSibling = 0;
+exports.toParent = 1;
+/**
+ * Tracks the references used by a schema (0: [self refs], 1: [parent refs], 2: [grandparent refs], ...)
+ */
+class Manager {
+    constructor() {
+        this.refs = [];
+    }
+    register(source, target) {
+        if (!source)
+            return;
+        const targetLevel = target === undefined ? exports.toParent : target;
+        //Array
+        if ((0, index_js_1.isArray)(source)) {
+            for (const ref of source)
+                this.register(ref, targetLevel);
+            return;
+        }
+        //Schema
+        if (Common.isSchema(source)) {
+            for (const item of source._refs.refs) {
+                if (item.ancestor - targetLevel >= 0)
+                    this.refs.push({ ancestor: item.ancestor - targetLevel, root: item.root });
+            }
+            return;
+        }
+        //Reference
+        if (isRef(source) && source.type === 'value' && source.ancestor - targetLevel >= 0) {
+            this.refs.push({ ancestor: source.ancestor - targetLevel, root: source.root });
+        }
+        //Template
+        Template = Template || lazy_js_1.Lazy.template;
+        if (Template.isTemplate(source))
+            this.register(source.refs(), targetLevel);
+    }
+    get length() {
+        return this.refs.length;
+    }
+    clone() {
+        const copy = new Manager();
+        copy.refs = (0, index_js_1.clone)(this.refs);
+        return copy;
+    }
+    reset() {
+        this.refs = [];
+    }
+    roots() {
+        return this.refs.filter((ref) => !ref.ancestor).map((ref) => ref.root);
+    }
+}
+exports.Manager = Manager;

package/dist/cjs/lib/validation/engine/schema/schemas.d.ts

@@ -0,0 +1,6 @@
+import { type LazySchemas } from './lazy.js';
+/**
+ * The schemas are built on first use: building them needs the fully loaded root (index.js), which imports this
+ * module (CommonJS upstream required it lazily for the same reason)
+ */
+export default function getSchemas(): LazySchemas;

package/dist/cjs/lib/validation/engine/schema/schemas.js

@@ -0,0 +1,268 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = getSchemas;
+const index_js_1 = __importDefault(require("./index.js"));
+const lazy_js_1 = require("./lazy.js");
+const schemas = {};
+let built = false;
+/**
+ * The schemas are built on first use: building them needs the fully loaded root (index.js), which imports this
+ * module (CommonJS upstream required it lazily for the same reason)
+ */
+function getSchemas() {
+    if (!built) {
+        built = true;
+        build();
+    }
+    return schemas;
+}
+function build() {
+    //Preferences
+    const wrap = index_js_1.default.string()
+        .min(1)
+        .max(2)
+        .allow(false);
+    schemas.preferences = index_js_1.default.object({
+        allowUnknown: index_js_1.default.boolean(),
+        abortEarly: index_js_1.default.boolean(),
+        artifacts: index_js_1.default.boolean(),
+        cache: index_js_1.default.boolean(),
+        context: index_js_1.default.object(),
+        convert: index_js_1.default.boolean(),
+        dateFormat: index_js_1.default.valid('date', 'iso', 'string', 'time', 'utc'),
+        debug: index_js_1.default.boolean(),
+        errors: {
+            escapeHtml: index_js_1.default.boolean(),
+            label: index_js_1.default.valid('path', 'key', false),
+            language: [
+                index_js_1.default.string(),
+                index_js_1.default.object().ref()
+            ],
+            render: index_js_1.default.boolean(),
+            stack: index_js_1.default.boolean(),
+            wrap: {
+                label: wrap,
+                array: wrap,
+                string: wrap
+            }
+        },
+        externals: index_js_1.default.boolean(),
+        messages: index_js_1.default.object(),
+        noDefaults: index_js_1.default.boolean(),
+        nonEnumerables: index_js_1.default.boolean(),
+        presence: index_js_1.default.valid('required', 'optional', 'forbidden'),
+        skipFunctions: index_js_1.default.boolean(),
+        stripUnknown: index_js_1.default.object({
+            arrays: index_js_1.default.boolean(),
+            objects: index_js_1.default.boolean()
+        })
+            .or('arrays', 'objects')
+            .allow(true, false),
+        warnings: index_js_1.default.boolean()
+    })
+        .strict();
+    //Extensions
+    const nameRx = /^[a-zA-Z0-9]\w*$/;
+    const rule = index_js_1.default.object({
+        alias: index_js_1.default.array().items(index_js_1.default.string().pattern(nameRx)).single(),
+        args: index_js_1.default.array().items(index_js_1.default.string(), index_js_1.default.object({
+            name: index_js_1.default.string().pattern(nameRx).required(),
+            ref: index_js_1.default.boolean(),
+            assert: index_js_1.default.alternatives([
+                index_js_1.default.function(),
+                index_js_1.default.object().schema()
+            ])
+                .conditional('ref', { is: true, then: index_js_1.default.required() }),
+            normalize: index_js_1.default.function(),
+            message: index_js_1.default.string().when('assert', { is: index_js_1.default.function(), then: index_js_1.default.required() })
+        })),
+        convert: index_js_1.default.boolean(),
+        manifest: index_js_1.default.boolean(),
+        method: index_js_1.default.function().allow(false),
+        multi: index_js_1.default.boolean(),
+        validate: index_js_1.default.function()
+    });
+    schemas.extension = index_js_1.default.object({
+        type: index_js_1.default.alternatives([
+            index_js_1.default.string(),
+            index_js_1.default.object().regex()
+        ])
+            .required(),
+        args: index_js_1.default.function(),
+        cast: index_js_1.default.object().pattern(nameRx, index_js_1.default.object({
+            from: index_js_1.default.function().maxArity(1).required(),
+            to: index_js_1.default.function().minArity(1).maxArity(2).required()
+        })),
+        base: index_js_1.default.object().schema()
+            .when('type', { is: index_js_1.default.object().regex(), then: index_js_1.default.forbidden() }),
+        coerce: [
+            index_js_1.default.function().maxArity(3),
+            index_js_1.default.object({ method: index_js_1.default.function().maxArity(3).required(), from: index_js_1.default.array().items(index_js_1.default.string()).single() })
+        ],
+        flags: index_js_1.default.object().pattern(nameRx, index_js_1.default.object({
+            setter: index_js_1.default.string(),
+            default: index_js_1.default.any()
+        })),
+        manifest: {
+            build: index_js_1.default.function().arity(2)
+        },
+        messages: [index_js_1.default.object(), index_js_1.default.string()],
+        modifiers: index_js_1.default.object().pattern(nameRx, index_js_1.default.function().minArity(1).maxArity(2)),
+        overrides: index_js_1.default.object().pattern(nameRx, index_js_1.default.function()),
+        prepare: index_js_1.default.function().maxArity(3),
+        rebuild: index_js_1.default.function().arity(1),
+        rules: index_js_1.default.object().pattern(nameRx, rule),
+        terms: index_js_1.default.object().pattern(nameRx, index_js_1.default.object({
+            init: index_js_1.default.array().allow(null).required(),
+            manifest: index_js_1.default.object().pattern(/.+/, [
+                index_js_1.default.valid('schema', 'single'),
+                index_js_1.default.object({
+                    mapped: index_js_1.default.object({
+                        from: index_js_1.default.string().required(),
+                        to: index_js_1.default.string().required()
+                    })
+                        .required()
+                })
+            ])
+        })),
+        validate: index_js_1.default.function().maxArity(3)
+    })
+        .strict();
+    schemas.extensions = index_js_1.default.array().items(index_js_1.default.object(), index_js_1.default.function().arity(1)).strict();
+    //Manifest
+    const desc = {
+        buffer: index_js_1.default.object({
+            buffer: index_js_1.default.string()
+        }),
+        func: index_js_1.default.object({
+            function: index_js_1.default.function().required(),
+            options: {
+                literal: true
+            }
+        }),
+        override: index_js_1.default.object({
+            override: true
+        }),
+        ref: index_js_1.default.object({
+            ref: index_js_1.default.object({
+                type: index_js_1.default.valid('value', 'global', 'local'),
+                path: index_js_1.default.array().required(),
+                separator: index_js_1.default.string().length(1).allow(false),
+                ancestor: index_js_1.default.number().min(0).integer().allow('root'),
+                map: index_js_1.default.array().items(index_js_1.default.array().length(2)).min(1),
+                adjust: index_js_1.default.function(),
+                iterables: index_js_1.default.boolean(),
+                in: index_js_1.default.boolean(),
+                render: index_js_1.default.boolean()
+            })
+                .required()
+        }),
+        regex: index_js_1.default.object({
+            regex: index_js_1.default.string().min(3)
+        }),
+        special: index_js_1.default.object({
+            special: index_js_1.default.valid('deep').required()
+        }),
+        template: index_js_1.default.object({
+            template: index_js_1.default.string().required(),
+            options: index_js_1.default.object()
+        }),
+        value: index_js_1.default.object({
+            value: index_js_1.default.alternatives([index_js_1.default.object(), index_js_1.default.array()]).required()
+        })
+    };
+    desc.entity = index_js_1.default.alternatives([
+        index_js_1.default.array().items(index_js_1.default.link('...')),
+        index_js_1.default.boolean(),
+        index_js_1.default.function(),
+        index_js_1.default.number(),
+        index_js_1.default.string(),
+        desc.buffer,
+        desc.func,
+        desc.ref,
+        desc.regex,
+        desc.special,
+        desc.template,
+        desc.value,
+        index_js_1.default.link('/')
+    ]);
+    desc.values = index_js_1.default.array()
+        .items(null, index_js_1.default.boolean(), index_js_1.default.function(), index_js_1.default.number().allow(Infinity, -Infinity), index_js_1.default.string().allow(''), index_js_1.default.symbol(), desc.buffer, desc.func, desc.override, desc.ref, desc.regex, desc.template, desc.value);
+    desc.messages = index_js_1.default.object()
+        .pattern(/.+/, [
+        index_js_1.default.string(),
+        desc.template,
+        index_js_1.default.object().pattern(/.+/, [index_js_1.default.string(), desc.template])
+    ]);
+    schemas.description = index_js_1.default.object({
+        type: index_js_1.default.string().required(),
+        flags: index_js_1.default.object({
+            cast: index_js_1.default.string(),
+            default: index_js_1.default.any(),
+            description: index_js_1.default.string(),
+            empty: index_js_1.default.link('/'),
+            failover: desc.entity,
+            id: index_js_1.default.string(),
+            label: index_js_1.default.string(),
+            only: true,
+            presence: ['optional', 'required', 'forbidden'],
+            result: ['raw', 'strip'],
+            strip: index_js_1.default.boolean(),
+            unit: index_js_1.default.string()
+        })
+            .unknown(),
+        preferences: {
+            allowUnknown: index_js_1.default.boolean(),
+            abortEarly: index_js_1.default.boolean(),
+            artifacts: index_js_1.default.boolean(),
+            cache: index_js_1.default.boolean(),
+            convert: index_js_1.default.boolean(),
+            dateFormat: ['date', 'iso', 'string', 'time', 'utc'],
+            errors: {
+                escapeHtml: index_js_1.default.boolean(),
+                label: ['path', 'key'],
+                language: [
+                    index_js_1.default.string(),
+                    desc.ref
+                ],
+                wrap: {
+                    label: wrap,
+                    array: wrap
+                }
+            },
+            externals: index_js_1.default.boolean(),
+            messages: desc.messages,
+            noDefaults: index_js_1.default.boolean(),
+            nonEnumerables: index_js_1.default.boolean(),
+            presence: ['required', 'optional', 'forbidden'],
+            skipFunctions: index_js_1.default.boolean(),
+            stripUnknown: index_js_1.default.object({
+                arrays: index_js_1.default.boolean(),
+                objects: index_js_1.default.boolean()
+            })
+                .or('arrays', 'objects')
+                .allow(true, false),
+            warnings: index_js_1.default.boolean()
+        },
+        allow: desc.values,
+        invalid: desc.values,
+        rules: index_js_1.default.array().min(1).items({
+            name: index_js_1.default.string().required(),
+            args: index_js_1.default.object().min(1),
+            keep: index_js_1.default.boolean(),
+            message: [
+                index_js_1.default.string(),
+                desc.messages
+            ],
+            warn: index_js_1.default.boolean()
+        }),
+        //Terms
+        keys: index_js_1.default.object().pattern(/.*/, index_js_1.default.link('/')),
+        link: desc.ref
+    })
+        .pattern(/^[a-z]\w*$/, index_js_1.default.any());
+}
+lazy_js_1.Lazy.schemas = getSchemas;

package/dist/cjs/lib/validation/engine/schema/state.d.ts

@@ -0,0 +1,48 @@
+import type { PathKey, StateLike } from './model.js';
+import type { Mainstay } from './validator.js';
+declare const valueSymbol: unique symbol;
+/**
+ * A shadow node: child nodes by path segment, and the shadowed value of its own path
+ */
+type ShadowNode = Map<PathKey, ShadowNode> & {
+    [valueSymbol]?: unknown;
+};
+/**
+ * An entry of the schemas chain ([current, ..., root])
+ */
+export interface StateSchemaEntry {
+    schema: unknown;
+    key?: PathKey;
+}
+/**
+ * Values changed during the validation (converted or stripped), by path
+ */
+export declare class Shadow {
+    protected _values: ShadowNode | null;
+    set(path: PathKey[], value: unknown, reason?: string): void;
+    get(path: PathKey[]): unknown;
+    node(path: PathKey[]): ShadowNode | undefined;
+    override(path: PathKey[], node: ShadowNode | undefined): void;
+}
+/**
+ * State of the value being validated
+ */
+export declare class State implements StateLike {
+    path: PathKey[];
+    ancestors: unknown[];
+    mainstay: Mainstay;
+    schemas: StateSchemaEntry[] | null;
+    debug: unknown;
+    protected _snapshot: ShadowNode | undefined;
+    constructor(path: PathKey[], ancestors: unknown[], state: {
+        mainstay: Mainstay;
+        schemas?: StateSchemaEntry[] | null;
+    });
+    localize(path: PathKey[], ancestors?: unknown[] | null, schema?: unknown): State;
+    nest(schema: unknown, debug?: unknown): State;
+    shadow(value: unknown, reason?: string): void;
+    snapshot(): void;
+    restore(): void;
+    commit(): void;
+}
+export {};