@lakutata/core 1.0.59 → 3.0.0-beta.0

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

@@ -0,0 +1,242 @@
+"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.schema = schema;
+exports.ref = ref;
+exports.compile = compile;
+exports.when = when;
+/**
+ * Derived from the upstream lib/compile.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+const assert_js_1 = require("./assert.js");
+const Common = __importStar(require("./common.js"));
+const Ref = __importStar(require("./ref.js"));
+/**
+ * Compile a schema description (literals, arrays, objects, regular expressions...) into a schema
+ * @param root
+ * @param config
+ * @param options
+ */
+function schema(root, config, options = {}) {
+    Common.assertOptions(options, ['appendPath', 'override']);
+    try {
+        return compileSchema(root, config, options);
+    }
+    catch (err) {
+        if (options.appendPath && err.path !== undefined)
+            (0, assert_js_1.setMessage)(err, `${err.message} (${err.path})`);
+        throw err;
+    }
+}
+function compileSchema(root, config, options) {
+    (0, assert_js_1.assert)(config !== undefined, 'Invalid undefined schema');
+    if (Array.isArray(config)) {
+        (0, assert_js_1.assert)(config.length, 'Invalid empty array schema');
+        if (config.length === 1)
+            config = config[0];
+    }
+    const valid = (base, ...values) => {
+        if (options.override !== false)
+            return base.valid(root.override, ...values);
+        return base.valid(...values);
+    };
+    if (simple(config))
+        return valid(root, config);
+    if (typeof config === 'function')
+        return root.custom(config);
+    (0, assert_js_1.assert)(typeof config === 'object', 'Invalid schema content:', typeof config);
+    if (Common.isResolvable(config))
+        return valid(root, config);
+    if (Common.isSchema(config))
+        return config;
+    if (Array.isArray(config)) {
+        for (const item of config) {
+            if (!simple(item))
+                return root.alternatives().try(...config);
+        }
+        return valid(root, ...config);
+    }
+    if (config instanceof RegExp)
+        return root.string().regex(config);
+    if (config instanceof Date)
+        return valid(root.date(), config);
+    (0, assert_js_1.assert)(Object.getPrototypeOf(config) === Object.getPrototypeOf({}), 'Schema can only contain plain objects');
+    return root.object().keys(config);
+}
+/**
+ * A reference, created from its key unless it is one already
+ * @param id
+ * @param options
+ */
+function ref(id, options) {
+    return Ref.isRef(id) ? id : Ref.create(id, options);
+}
+/**
+ * Compile a schema, unless it is compiled already (by this version, or by a legacy one when allowed)
+ * @param root
+ * @param schema
+ * @param options
+ */
+function compile(root, schema, options = {}) {
+    Common.assertOptions(options, ['legacy']);
+    //Compiled by any supported version
+    const any = schema ? schema[Common.symbols.any] : undefined;
+    if (any) {
+        (0, assert_js_1.assert)(options.legacy || any.version === Common.version, 'Cannot mix different versions of validation schemas:', any.version, Common.version);
+        return schema;
+    }
+    //Uncompiled root
+    //Will error if schema contains other versions
+    if (typeof schema !== 'object' || !options.legacy)
+        return compileRoot(root, schema);
+    //Scan schema for compiled parts
+    const compiler = walk(schema);
+    if (!compiler)
+        return compileRoot(root, schema);
+    return compiler.compile(compiler.root, schema);
+}
+function compileRoot(root, config) {
+    return schema(root, config, { appendPath: true });
+}
+function walk(schema) {
+    if (typeof schema !== 'object')
+        return null;
+    if (Array.isArray(schema)) {
+        for (const item of schema) {
+            const compiler = walk(item);
+            if (compiler)
+                return compiler;
+        }
+        return null;
+    }
+    //Like upstream: null (typeof 'object') throws on the symbol lookup
+    const record = schema;
+    const any = record[Common.symbols.any];
+    if (any)
+        return { root: record[any.root], compile: any.compile };
+    (0, assert_js_1.assert)(Object.getPrototypeOf(schema) === Object.getPrototypeOf({}), 'Schema can only contain plain objects');
+    for (const key in record) {
+        const compiler = walk(record[key]);
+        if (compiler)
+            return compiler;
+    }
+    return null;
+}
+function simple(value) {
+    return value === null || ['boolean', 'string', 'number'].includes(typeof value);
+}
+/**
+ * Compile when() arguments into a condition or a switch statement
+ * @param schema
+ * @param condition
+ * @param options
+ */
+function when(schema, condition, options) {
+    if (options === undefined) {
+        (0, assert_js_1.assert)(condition && typeof condition === 'object', 'Missing options');
+        options = condition;
+        condition = Ref.create('.');
+    }
+    if (Array.isArray(options))
+        options = { switch: options };
+    Common.assertOptions(options, ['is', 'not', 'then', 'otherwise', 'switch', 'break']);
+    //Schema condition
+    if (Common.isSchema(condition)) {
+        (0, assert_js_1.assert)(options.is === undefined, '"is" can not be used with a schema condition');
+        (0, assert_js_1.assert)(options.not === undefined, '"not" can not be used with a schema condition');
+        (0, assert_js_1.assert)(options.switch === undefined, '"switch" can not be used with a schema condition');
+        return conditionOf(schema, { is: condition, then: options.then, otherwise: options.otherwise, break: options.break });
+    }
+    //Single condition
+    (0, assert_js_1.assert)(Ref.isRef(condition) || typeof condition === 'string', 'Invalid condition:', condition);
+    (0, assert_js_1.assert)(options.not === undefined || options.is === undefined, 'Cannot combine "is" with "not"');
+    if (options.switch === undefined) {
+        let rule = options;
+        if (options.not !== undefined)
+            rule = { is: options.not, then: options.otherwise, otherwise: options.then, break: options.break };
+        let is = rule.is !== undefined ? schema.$_compile(rule.is) : schema.$_root.invalid(null, false, 0, '').required();
+        (0, assert_js_1.assert)(rule.then !== undefined || rule.otherwise !== undefined, 'options must have at least one of "then", "otherwise", or "switch"');
+        (0, assert_js_1.assert)(rule.break === undefined || rule.then === undefined || rule.otherwise === undefined, 'Cannot specify then, otherwise, and break all together');
+        //Only apply required if this wasn't already a schema or a ref
+        if (options.is !== undefined && !Ref.isRef(options.is) && !Common.isSchema(options.is))
+            is = is.required();
+        return conditionOf(schema, { ref: ref(condition), is, then: rule.then, otherwise: rule.otherwise, break: rule.break });
+    }
+    //Switch statement
+    (0, assert_js_1.assert)(Array.isArray(options.switch), '"switch" must be an array');
+    (0, assert_js_1.assert)(options.is === undefined, 'Cannot combine "switch" with "is"');
+    (0, assert_js_1.assert)(options.not === undefined, 'Cannot combine "switch" with "not"');
+    (0, assert_js_1.assert)(options.then === undefined, 'Cannot combine "switch" with "then"');
+    const rule = {
+        ref: ref(condition),
+        switch: [],
+        break: options.break
+    };
+    for (let i = 0; i < options.switch.length; ++i) {
+        const test = options.switch[i];
+        const last = i === options.switch.length - 1;
+        Common.assertOptions(test, last ? ['is', 'then', 'otherwise'] : ['is', 'then']);
+        (0, assert_js_1.assert)(test.is !== undefined, 'Switch statement missing "is"');
+        (0, assert_js_1.assert)(test.then !== undefined, 'Switch statement missing "then"');
+        const item = {
+            is: schema.$_compile(test.is),
+            then: schema.$_compile(test.then)
+        };
+        //Only apply required if this wasn't already a schema or a ref
+        if (!Ref.isRef(test.is) && !Common.isSchema(test.is))
+            item.is = item.is.required();
+        if (last) {
+            (0, assert_js_1.assert)(options.otherwise === undefined || test.otherwise === undefined, 'Cannot specify "otherwise" inside and outside a "switch"');
+            const otherwise = options.otherwise !== undefined ? options.otherwise : test.otherwise;
+            if (otherwise !== undefined) {
+                (0, assert_js_1.assert)(rule.break === undefined, 'Cannot specify both otherwise and break');
+                item.otherwise = schema.$_compile(otherwise);
+            }
+        }
+        rule.switch.push(item);
+    }
+    return rule;
+}
+function conditionOf(schema, condition) {
+    for (const key of ['then', 'otherwise']) {
+        if (condition[key] === undefined) {
+            delete condition[key];
+        }
+        else {
+            condition[key] = schema.$_compile(condition[key]);
+        }
+    }
+    return condition;
+}

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

@@ -0,0 +1,94 @@
+import type { Message, Messages } from './messages.js';
+import type { ErrorDetail, PathKey, Preferences, StateLike } from './model.js';
+/**
+ * The schema flags an error report reads
+ */
+export interface ReportFlags {
+    label?: string;
+    [name: string]: unknown;
+}
+/**
+ * Local context of an error report, available to its message template
+ */
+export interface ReportLocal {
+    label?: unknown;
+    value?: unknown;
+    key?: PathKey;
+    [name: string]: unknown;
+}
+/**
+ * A validation error report, rendered lazily into a message
+ */
+export declare class Report {
+    code: string;
+    flags: ReportFlags;
+    messages: Messages | null | undefined;
+    path: PathKey[];
+    prefs: Preferences;
+    state: StateLike;
+    value: unknown;
+    message: string | null;
+    template: Messages | null | undefined;
+    local: ReportLocal;
+    constructor(code: string, value: unknown, local: ReportLocal | null | undefined, flags: ReportFlags, messages: Messages | null | undefined, state: StateLike, prefs: Preferences);
+    _setTemplate(template: Messages | null | undefined): void;
+    toString(): string;
+    _template(messages: Messages | null | undefined, code?: string): Message | null | undefined;
+}
+/**
+ * Render a path for a label ('a.b[0]')
+ * @param path
+ */
+export declare function path(path: PathKey[]): string;
+/**
+ * Find the message of an error code, in the preferred language first
+ * @param value
+ * @param messages
+ * @param code
+ * @param state
+ * @param prefs
+ */
+export declare function template(value: unknown, messages: Messages | null | undefined, code: string, state: StateLike, prefs: Preferences): Message | null | undefined;
+/**
+ * The label of a value in error messages
+ * @param flags
+ * @param state
+ * @param prefs
+ * @param messages
+ */
+export declare function label(flags: ReportFlags, state: StateLike, prefs: Preferences, messages: Messages | null | undefined): unknown;
+/**
+ * An override error (thrown by a custom rule), or an error report
+ */
+export type ErrorItem = Error | Report;
+/**
+ * The validation error, or the override error, of the errors of a validation
+ * @param errors
+ * @param original
+ * @param prefs
+ */
+export declare function process(errors: ErrorItem[] | null | undefined, original: unknown, prefs: Preferences): Error | null;
+/**
+ * The detail of an override error, when override errors are not returned as they are
+ */
+export interface OverrideDetail {
+    message: string;
+    type: 'override';
+    context: {
+        error: Error;
+    };
+}
+export interface ErrorsDetails {
+    override?: Error;
+    message?: string;
+    details?: (ErrorDetail | OverrideDetail)[];
+}
+/**
+ * The message and the details of errors (or the first override error)
+ * @param errors
+ * @param options
+ */
+declare function detailsOf(errors: ErrorItem[], options?: {
+    override?: boolean;
+}): ErrorsDetails;
+export { detailsOf as details };

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

@@ -0,0 +1,230 @@
+"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.Report = void 0;
+exports.path = path;
+exports.template = template;
+exports.label = label;
+exports.process = process;
+exports.details = detailsOf;
+/**
+ * Derived from the upstream lib/errors.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+const SchemaValidationException_js_1 = require("../../exceptions/SchemaValidationException.js");
+const Common = __importStar(require("./common.js"));
+const template_js_1 = require("./template.js");
+/**
+ * A validation error report, rendered lazily into a message
+ */
+class Report {
+    constructor(code, value, local, flags, messages, state, prefs) {
+        this.code = code;
+        this.flags = flags;
+        this.messages = messages;
+        this.path = state.path;
+        this.prefs = prefs;
+        this.state = state;
+        this.value = value;
+        this.message = null;
+        this.template = null;
+        this.local = local || {};
+        this.local.label = label(this.flags, this.state, this.prefs, this.messages);
+        if (this.value !== undefined && !Object.prototype.hasOwnProperty.call(this.local, 'value'))
+            this.local.value = this.value;
+        if (this.path.length) {
+            const key = this.path[this.path.length - 1];
+            if (typeof key !== 'object')
+                this.local.key = key;
+        }
+    }
+    _setTemplate(template) {
+        this.template = template;
+        if (!this.flags.label && this.path.length === 0) {
+            const localized = this._template(this.template, 'root');
+            if (localized)
+                this.local.label = localized;
+        }
+    }
+    toString() {
+        if (this.message)
+            return this.message;
+        const code = this.code;
+        if (!this.prefs.errors.render)
+            return this.code;
+        const template = this._template(this.template) ||
+            this._template(this.prefs.messages) ||
+            this._template(this.messages);
+        if (template === undefined)
+            return `Error code "${code}" is not defined, your custom type is missing the correct messages definition`;
+        //Render and cache result
+        this.message = template.render(this.value, this.state, this.prefs, this.local, { errors: this.prefs.errors, messages: [this.prefs.messages, this.messages] });
+        if (!this.prefs.errors.label)
+            this.message = this.message.replace(/^"" /, '').trim();
+        return this.message;
+    }
+    _template(messages, code) {
+        return template(this.value, messages, code || this.code, this.state, this.prefs);
+    }
+}
+exports.Report = Report;
+/**
+ * Render a path for a label ('a.b[0]')
+ * @param path
+ */
+function path(path) {
+    let label = '';
+    for (const segment of path) {
+        //Exclude array single path segment
+        if (typeof segment === 'object')
+            continue;
+        if (typeof segment === 'string') {
+            if (label)
+                label += '.';
+            label += segment;
+        }
+        else {
+            label += `[${segment}]`;
+        }
+    }
+    return label;
+}
+/**
+ * Find the message of an error code, in the preferred language first
+ * @param value
+ * @param messages
+ * @param code
+ * @param state
+ * @param prefs
+ */
+function template(value, messages, code, state, prefs) {
+    if (!messages)
+        return;
+    if (template_js_1.Template.isTemplate(messages))
+        return code !== 'root' ? messages : null;
+    let lang = prefs.errors.language;
+    if (Common.isResolvable(lang))
+        lang = lang.resolve(value, state, prefs, undefined);
+    const byCode = messages;
+    if (lang && byCode[lang]) {
+        const languageMessages = byCode[lang];
+        if (languageMessages[code] !== undefined)
+            return languageMessages[code];
+        if (languageMessages['*'] !== undefined)
+            return languageMessages['*'];
+    }
+    if (!byCode[code])
+        return byCode['*'];
+    return byCode[code];
+}
+/**
+ * The label of a value in error messages
+ * @param flags
+ * @param state
+ * @param prefs
+ * @param messages
+ */
+function label(flags, state, prefs, messages) {
+    const errorPrefs = prefs.errors;
+    if (!errorPrefs.label)
+        return '';
+    if (flags.label)
+        return flags.label;
+    let labelPath = state.path;
+    if (errorPrefs.label === 'key' && state.path.length > 1)
+        labelPath = state.path.slice(-1);
+    const normalized = path(labelPath);
+    if (normalized)
+        return normalized;
+    return template(null, prefs.messages, 'root', state, prefs) ||
+        messages && template(null, messages, 'root', state, prefs) ||
+        'value';
+}
+/**
+ * The validation error, or the override error, of the errors of a validation
+ * @param errors
+ * @param original
+ * @param prefs
+ */
+function process(errors, original, prefs) {
+    if (!errors)
+        return null;
+    const { override, message, details } = detailsOf(errors);
+    if (override)
+        return override;
+    //Without override details, as override errors are returned as they are
+    if (prefs.errors.stack)
+        return new SchemaValidationException_js_1.SchemaValidationException(message, details, original);
+    const limit = Error.stackTraceLimit;
+    Error.stackTraceLimit = 0;
+    const validationError = new SchemaValidationException_js_1.SchemaValidationException(message, details, original);
+    Error.stackTraceLimit = limit;
+    return validationError;
+}
+/**
+ * The message and the details of errors (or the first override error)
+ * @param errors
+ * @param options
+ */
+function detailsOf(errors, options = {}) {
+    let messages = [];
+    const details = [];
+    for (const item of errors) {
+        //Override
+        if (item instanceof Error) {
+            if (options.override !== false)
+                return { override: item };
+            const message = item.toString();
+            messages.push(message);
+            details.push({
+                message,
+                type: 'override',
+                context: { error: item }
+            });
+            continue;
+        }
+        //Report
+        const message = item.toString();
+        messages.push(message);
+        details.push({
+            message,
+            path: item.path.filter((v) => typeof v !== 'object'),
+            type: item.code,
+            context: item.local
+        });
+    }
+    if (messages.length > 1)
+        messages = [...new Set(messages)];
+    return { message: messages.join('. '), details };
+}

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

@@ -0,0 +1,122 @@
+import * as Messages from './messages.js';
+import type { Preferences, SchemaInternals, SchemaLike, SchemaRule, ValidationHelpers, ValidationOutcome } from './model.js';
+import type { State } from './state.js';
+/**
+ * Any method, called with arguments checked by its own implementation
+ */
+export type DefinitionMethod<S> = (this: S, ...args: never[]) => unknown;
+/**
+ * A type method run on the validated value (prepare, coerce, validate)
+ */
+export type TypeMethod<S extends SchemaInternals = SchemaInternals> = (value: unknown, helpers: ValidationHelpers<S>) => ValidationOutcome | undefined | void;
+/**
+ * A rule validation: the validated value, errors, or a report
+ */
+export type RuleMethod<S extends SchemaInternals = SchemaInternals> = (value: unknown, helpers: ValidationHelpers<S>, args: Record<string, unknown>, rule: SchemaRule) => unknown;
+export interface FlagDefinition {
+    default?: unknown;
+    setter?: string;
+    register?: number | false;
+}
+/**
+ * How a term is described: as schemas, as a single schema, as values, or mapped into objects
+ */
+export type TermManifest = 'schema' | 'single' | 'values' | {
+    mapped: {
+        from: string;
+        to: string;
+    };
+};
+export interface TermDefinition {
+    init: unknown;
+    manifest?: TermManifest;
+    register?: number | false;
+}
+export interface RuleArgDefinition {
+    name: string;
+    ref?: boolean;
+    assert?: SchemaLike | ((value: unknown) => unknown);
+    message?: string;
+    normalize?(value: unknown): unknown;
+}
+export interface RuleDefinition<S extends SchemaInternals = SchemaInternals> {
+    method?: DefinitionMethod<S> | false;
+    alias?: string | string[];
+    args?: (string | RuleArgDefinition)[];
+    argsByName?: Map<string, RuleArgDefinition>;
+    validate?: RuleMethod<S>;
+    convert?: boolean;
+    manifest?: boolean;
+    multi?: boolean;
+    priority?: boolean;
+    register?: number | false;
+}
+/**
+ * A rule definition, once extended
+ */
+export interface ExtendedRuleDefinition<S extends SchemaInternals = SchemaInternals> extends RuleDefinition<S> {
+    args?: RuleArgDefinition[];
+}
+export type ModifierMethod = (rule: SchemaRule, value: unknown) => void;
+export interface CastDefinition<S extends SchemaInternals = SchemaInternals> {
+    from(value: unknown): unknown;
+    to(value: unknown, helpers: ValidationHelpers<S>): unknown;
+}
+export interface CoerceDefinition<S extends SchemaInternals = SchemaInternals> {
+    method: TypeMethod<S>;
+    from?: string | string[] | null;
+}
+export interface ManifestDefinition<S extends SchemaInternals = SchemaInternals> {
+    build?(obj: S, desc: Record<string, unknown>): S;
+}
+/**
+ * The definition of a type, as provided to extend()
+ */
+export interface TypeDefinition<S extends SchemaInternals = SchemaInternals> {
+    type: string;
+    base?: S;
+    args?(schema: S, ...args: never[]): S;
+    cast?: Record<string, CastDefinition<S>>;
+    coerce?: TypeMethod<S> | CoerceDefinition<S>;
+    flags?: Record<string, FlagDefinition>;
+    generate?(schema: S, value: unknown, state: State, prefs: Preferences): S | undefined;
+    manifest?: ManifestDefinition<S>;
+    messages?: Messages.MessagesInput;
+    modifiers?: Record<string, ModifierMethod>;
+    overrides?: Record<string, DefinitionMethod<S>>;
+    prepare?: TypeMethod<S>;
+    properties?: Record<string, unknown>;
+    rebuild?(schema: S): void;
+    rules?: Record<string, RuleDefinition<S>>;
+    terms?: Record<string, TermDefinition>;
+    validate?: TypeMethod<S>;
+}
+/**
+ * The definition of a type, once extended (merged with its parent's)
+ */
+export interface Definition<S extends SchemaInternals = SchemaInternals> {
+    type: string;
+    args?(schema: S, ...args: never[]): S;
+    cast: Record<string, CastDefinition<S>>;
+    coerce?: CoerceDefinition<S> & {
+        from?: string[] | null;
+    };
+    flags: Record<string, FlagDefinition>;
+    generate?(schema: S, value: unknown, state: State, prefs: Preferences): S | undefined;
+    manifest: ManifestDefinition<S>;
+    messages: Messages.Messages | null | undefined;
+    modifiers: Record<string, ModifierMethod>;
+    overrides?: Record<string, DefinitionMethod<S>>;
+    prepare?: TypeMethod<S>;
+    properties: Record<string, unknown>;
+    rebuild?(schema: S): void;
+    rules: Record<string, ExtendedRuleDefinition<S>>;
+    terms: Record<string, TermDefinition>;
+    validate?: TypeMethod<S>;
+}
+/**
+ * A new type (a schema with its own prototype), extending the type of a schema
+ * @param from
+ * @param options
+ */
+export declare function type<S extends SchemaInternals>(from: S, options: TypeDefinition<S>): S;