@mionjs/run-types 0.13.0 → 0.14.0

package/dist/cjs/mocking/mockDateTimeBounds.js

@@ -1,277 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mockBoundedDate = mockBoundedDate;
-exports.mockBoundedTime = mockBoundedTime;
-exports.mockBoundedDateTime = mockBoundedDateTime;
-exports.mockBoundedNativeDate = mockBoundedNativeDate;
-const FILL_YEAR = 2000;
-const MS_PER_DAY = 86400000;
-const MS_PER_HOUR = 3600000;
-const MS_PER_MIN = 60000;
-const MS_PER_SEC = 1000;
-function randInt(min, max, random) {
-    if (max <= min)
-        return min;
-    return min + Math.floor(random.float() * (max - min + 1));
-}
-function isRelative(bound) {
-    return bound.startsWith('now');
-}
-function parseDuration(tail) {
-    const out = { years: 0, months: 0, weeks: 0, days: 0, hours: 0, minutes: 0, seconds: 0 };
-    const body = tail.substring(1);
-    const tIdx = body.indexOf('T');
-    const datePart = tIdx === -1 ? body : body.substring(0, tIdx);
-    const timePart = tIdx === -1 ? '' : body.substring(tIdx + 1);
-    const eat = (segment, map) => {
-        const re = /(\d+)([A-Z])/g;
-        let m;
-        while ((m = re.exec(segment)) !== null) {
-            const key = map[m[2]];
-            if (key)
-                out[key] = Number(m[1]);
-        }
-    };
-    eat(datePart, { Y: 'years', M: 'months', W: 'weeks', D: 'days' });
-    eat(timePart, { H: 'hours', M: 'minutes', S: 'seconds' });
-    return out;
-}
-function resolveRelative(spec, scale, random) {
-    const now = new Date(random.now());
-    if (scale === 'timeOfDay') {
-        let ms = now.getUTCHours() * MS_PER_HOUR +
-            now.getUTCMinutes() * MS_PER_MIN +
-            now.getUTCSeconds() * MS_PER_SEC +
-            now.getUTCMilliseconds();
-        if (spec !== 'now') {
-            const sign = spec[3] === '-' ? -1 : 1;
-            const d = parseDuration(spec.substring(4));
-            ms += sign * (d.hours * MS_PER_HOUR + d.minutes * MS_PER_MIN + d.seconds * MS_PER_SEC);
-        }
-        return ms;
-    }
-    const result = new Date(now.getTime());
-    if (spec !== 'now') {
-        const sign = spec[3] === '-' ? -1 : 1;
-        const d = parseDuration(spec.substring(4));
-        result.setUTCFullYear(result.getUTCFullYear() + sign * d.years);
-        result.setUTCMonth(result.getUTCMonth() + sign * d.months);
-        result.setUTCDate(result.getUTCDate() + sign * (d.weeks * 7 + d.days));
-        result.setTime(result.getTime() + sign * (d.hours * MS_PER_HOUR + d.minutes * MS_PER_MIN + d.seconds * MS_PER_SEC));
-    }
-    if (scale === 'epochDate') {
-        return Date.UTC(result.getUTCFullYear(), result.getUTCMonth(), result.getUTCDate(), 0, 0, 0, 0);
-    }
-    return result.getTime();
-}
-function dateLiteralToMs(value, layout) {
-    const parts = value.split('-');
-    let year = FILL_YEAR;
-    let month = 1;
-    let day = 1;
-    switch (layout) {
-        case 'DD-MM-YYYY':
-            day = Number(parts[0]);
-            month = Number(parts[1]);
-            year = Number(parts[2]);
-            break;
-        case 'MM-DD-YYYY':
-            month = Number(parts[0]);
-            day = Number(parts[1]);
-            year = Number(parts[2]);
-            break;
-        case 'YYYY-MM':
-            year = Number(parts[0]);
-            month = Number(parts[1]);
-            break;
-        case 'MM-DD':
-            month = Number(parts[0]);
-            day = Number(parts[1]);
-            break;
-        case 'DD-MM':
-            day = Number(parts[0]);
-            month = Number(parts[1]);
-            break;
-        default:
-            year = Number(parts[0]);
-            month = Number(parts[1]);
-            day = Number(parts[2]);
-    }
-    return Date.UTC(year, month - 1, day, 0, 0, 0, 0);
-}
-function timeLiteralToMs(value, layout) {
-    let body = value;
-    if (layout === 'ISO' || layout === 'HH:mm:ss[.mmm]TZ') {
-        if (body.endsWith('Z') || body.endsWith('z'))
-            body = body.substring(0, body.length - 1);
-        else {
-            const plus = body.indexOf('+');
-            const minus = body.lastIndexOf('-');
-            const cut = plus !== -1 ? plus : minus;
-            if (cut > 0)
-                body = body.substring(0, cut);
-        }
-    }
-    if (layout === 'HH')
-        return Number(body) * MS_PER_HOUR;
-    if (layout === 'mm')
-        return Number(body) * MS_PER_MIN;
-    if (layout === 'ss')
-        return Number(body) * MS_PER_SEC;
-    const parts = body.split(':');
-    if (layout === 'HH:mm')
-        return Number(parts[0]) * MS_PER_HOUR + Number(parts[1]) * MS_PER_MIN;
-    if (layout === 'mm:ss')
-        return Number(parts[0]) * MS_PER_MIN + Number(parts[1]) * MS_PER_SEC;
-    const secParts = (parts[2] ?? '').split('.');
-    return (Number(parts[0]) * MS_PER_HOUR +
-        Number(parts[1]) * MS_PER_MIN +
-        (secParts[0] ? Number(secParts[0]) : 0) * MS_PER_SEC +
-        (secParts[1] ? Number(secParts[1]) : 0));
-}
-function dateTimeLiteralToMs(value, splitChar) {
-    const sep = splitChar || 'T';
-    const idx = value.indexOf(sep);
-    if (idx < 0)
-        return Date.parse(value);
-    const dateMs = dateLiteralToMs(value.substring(0, idx), 'YYYY-MM-DD');
-    const timeMs = timeLiteralToMs(value.substring(idx + sep.length), 'ISO');
-    return dateMs + timeMs;
-}
-function resolveDateKey(bound, layout, random) {
-    return isRelative(bound) ? resolveRelative(bound, 'epochDate', random) : dateLiteralToMs(bound, layout);
-}
-function resolveTimeKey(bound, layout, random) {
-    return isRelative(bound) ? resolveRelative(bound, 'timeOfDay', random) : timeLiteralToMs(bound, layout);
-}
-function resolveEpochKey(bound, splitChar, random) {
-    return isRelative(bound) ? resolveRelative(bound, 'epoch', random) : dateTimeLiteralToMs(bound, splitChar);
-}
-function formatDate(ms, layout) {
-    const d = new Date(ms);
-    const year = String(d.getUTCFullYear()).padStart(4, '0');
-    const month = String(d.getUTCMonth() + 1).padStart(2, '0');
-    const day = String(d.getUTCDate()).padStart(2, '0');
-    switch (layout) {
-        case 'DD-MM-YYYY':
-            return `${day}-${month}-${year}`;
-        case 'MM-DD-YYYY':
-            return `${month}-${day}-${year}`;
-        case 'YYYY-MM':
-            return `${year}-${month}`;
-        case 'MM-DD':
-            return `${month}-${day}`;
-        case 'DD-MM':
-            return `${day}-${month}`;
-        default:
-            return `${year}-${month}-${day}`;
-    }
-}
-function formatTime(msOfDay, layout) {
-    const h = Math.floor(msOfDay / MS_PER_HOUR);
-    const m = Math.floor((msOfDay % MS_PER_HOUR) / MS_PER_MIN);
-    const s = Math.floor((msOfDay % MS_PER_MIN) / MS_PER_SEC);
-    const ms = msOfDay % MS_PER_SEC;
-    const hh = String(h).padStart(2, '0');
-    const mm = String(m).padStart(2, '0');
-    const ss = String(s).padStart(2, '0');
-    const mmm = String(ms).padStart(3, '0');
-    switch (layout) {
-        case 'ISO':
-        case 'HH:mm:ss[.mmm]TZ':
-            return `${hh}:${mm}:${ss}.${mmm}Z`;
-        case 'HH:mm:ss[.mmm]':
-            return `${hh}:${mm}:${ss}.${mmm}`;
-        case 'HH:mm:ss':
-            return `${hh}:${mm}:${ss}`;
-        case 'HH:mm':
-            return `${hh}:${mm}`;
-        case 'mm:ss':
-            return `${mm}:${ss}`;
-        case 'HH':
-            return hh;
-        case 'mm':
-            return mm;
-        case 'ss':
-            return ss;
-        default:
-            return `${hh}:${mm}:${ss}`;
-    }
-}
-const DATE_MIN_MS = Date.UTC(1, 0, 1, 0, 0, 0, 0);
-const DATE_MAX_MS = Date.UTC(9999, 11, 31, 0, 0, 0, 0);
-function timeMaxMs(layout) {
-    switch (layout) {
-        case 'HH':
-            return 23 * MS_PER_HOUR;
-        case 'mm':
-            return 59 * MS_PER_MIN;
-        case 'ss':
-            return 59 * MS_PER_SEC;
-        case 'HH:mm':
-            return 23 * MS_PER_HOUR + 59 * MS_PER_MIN;
-        case 'mm:ss':
-            return 59 * MS_PER_MIN + 59 * MS_PER_SEC;
-        case 'HH:mm:ss':
-            return 23 * MS_PER_HOUR + 59 * MS_PER_MIN + 59 * MS_PER_SEC;
-        default:
-            return 23 * MS_PER_HOUR + 59 * MS_PER_MIN + 59 * MS_PER_SEC + 999;
-    }
-}
-function timeGridMs(layout) {
-    switch (layout) {
-        case 'HH':
-            return MS_PER_HOUR;
-        case 'mm':
-        case 'HH:mm':
-            return MS_PER_MIN;
-        case 'ss':
-        case 'mm:ss':
-        case 'HH:mm:ss':
-            return MS_PER_SEC;
-        default:
-            return 1;
-    }
-}
-function resolveRange(bounds, resolve, defaultLo, defaultHi, grid) {
-    let lo = defaultLo;
-    let hi = defaultHi;
-    if (bounds.min !== undefined)
-        lo = Math.max(lo, resolve(bounds.min));
-    if (bounds.gt !== undefined)
-        lo = Math.max(lo, resolve(bounds.gt) + grid);
-    if (bounds.max !== undefined)
-        hi = Math.min(hi, resolve(bounds.max));
-    if (bounds.lt !== undefined)
-        hi = Math.min(hi, resolve(bounds.lt) - grid);
-    if (hi < lo)
-        hi = lo;
-    return { lo, hi };
-}
-function mockBoundedDate(layout, bounds, random) {
-    const { lo, hi } = resolveRange(bounds, (b) => resolveDateKey(b, layout, random), DATE_MIN_MS, DATE_MAX_MS, MS_PER_DAY);
-    return formatDate(randInt(lo, hi, random), layout);
-}
-function mockBoundedTime(layout, bounds, random) {
-    const grid = timeGridMs(layout);
-    const { lo, hi } = resolveRange(bounds, (b) => resolveTimeKey(b, layout, random), 0, timeMaxMs(layout), grid);
-    return formatTime(randInt(lo, hi, random), layout);
-}
-function mockBoundedDateTime(params, random) {
-    const dateLayout = (params.date?.format ?? 'ISO');
-    const timeLayout = (params.time?.format ?? 'ISO');
-    const splitChar = params.splitChar ?? 'T';
-    const bounds = { min: params.min, max: params.max, gt: params.gt, lt: params.lt };
-    if (bounds.min === undefined && bounds.max === undefined && bounds.gt === undefined && bounds.lt === undefined) {
-        return `${mockBoundedDate(dateLayout, {}, random)}${splitChar}${mockBoundedTime(timeLayout, {}, random)}`;
-    }
-    const { lo, hi } = resolveRange(bounds, (b) => resolveEpochKey(b, splitChar, random), DATE_MIN_MS, DATE_MAX_MS + timeMaxMs(timeLayout), timeGridMs(timeLayout));
-    const pick = randInt(lo, hi, random);
-    const dayMs = Math.floor(pick / MS_PER_DAY) * MS_PER_DAY;
-    const timeOfDay = pick - dayMs;
-    return `${formatDate(dayMs, dateLayout)}${splitChar}${formatTime(timeOfDay, timeLayout)}`;
-}
-function mockBoundedNativeDate(bounds, random) {
-    const { lo, hi } = resolveRange(bounds, (b) => resolveEpochKey(b, 'T', random), DATE_MIN_MS, random.now(), 1);
-    return new Date(randInt(lo, hi, random));
-}

package/dist/cjs/mocking/mockInvalid.d.ts

@@ -1,15 +0,0 @@
-import type { RunType } from '../runtypes/types.ts';
-import type { RunTypeMockOptions } from './mockTypes.ts';
-import type { MockRandom } from './mockRandom.ts';
-export interface Target {
-    parent: Record<string | number, unknown> | undefined;
-    key: string | number | undefined;
-    node: RunType | undefined;
-    value: unknown;
-    depth: number;
-    isLeaf: boolean;
-}
-export declare function negativeFor(node: RunType | undefined, value: unknown, random?: MockRandom): unknown;
-export declare function collectInvalidTargets(root: unknown, rootNode: RunType | undefined): Target[];
-export declare function chooseInvalidTarget(targets: Target[], invalidLeafProbability: number, random?: MockRandom): Target | undefined;
-export declare function mockRunTypeInvalid(runType: RunType, options: RunTypeMockOptions, stack?: RunType[]): unknown;

package/dist/cjs/mocking/mockInvalid.js

@@ -1,233 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.negativeFor = negativeFor;
-exports.collectInvalidTargets = collectInvalidTargets;
-exports.chooseInvalidTarget = chooseInvalidTarget;
-exports.mockRunTypeInvalid = mockRunTypeInvalid;
-const runTypeKind_generated_ts_1 = require("../go-generated/runTypeKind.generated.js");
-const mockRandom_ts_1 = require("./mockRandom.js");
-const mockType_ts_1 = require("./mockType.js");
-const mockStringFormat_ts_1 = require("./mockStringFormat.js");
-const K = runTypeKind_generated_ts_1.RunTypeKind;
-const kindOf = (node) => node.kind;
-function isContainer(value) {
-    if (typeof value !== 'object' || value === null)
-        return false;
-    if (Array.isArray(value))
-        return true;
-    return !(value instanceof Date ||
-        value instanceof Uint8Array ||
-        value instanceof Map ||
-        value instanceof Set ||
-        value instanceof RegExp);
-}
-function kindMatchesValue(node, candidate) {
-    switch (kindOf(node)) {
-        case K.string:
-        case K.templateLiteral:
-            return typeof candidate === 'string';
-        case K.regexp:
-            return candidate instanceof RegExp;
-        case K.number:
-            return typeof candidate === 'number';
-        case K.bigint:
-            return typeof candidate === 'bigint';
-        case K.boolean:
-            return typeof candidate === 'boolean';
-        case K.literal:
-            return candidate === node.literal;
-        case K.null:
-            return candidate === null;
-        case K.undefined:
-        case K.void:
-            return candidate === undefined;
-        case K.array:
-        case K.tuple:
-            return Array.isArray(candidate);
-        case K.object:
-        case K.objectLiteral:
-        case K.intersection:
-        case K.class:
-            return typeof candidate === 'object' && candidate !== null && !Array.isArray(candidate);
-        case K.enum:
-            return true;
-        default:
-            return false;
-    }
-}
-function memberForValue(node, value) {
-    if (!node || kindOf(node) !== K.union)
-        return node;
-    const members = (node.children ?? []).filter((member) => !member.notSupported);
-    return members.find((member) => kindMatchesValue(member, value)) ?? members[0] ?? node;
-}
-function propChildNode(node, key) {
-    const children = node?.children ?? [];
-    for (const member of children) {
-        if ((kindOf(member) === K.property || kindOf(member) === K.propertySignature) && member.name === String(key)) {
-            return member.child;
-        }
-    }
-    for (const member of children) {
-        if (kindOf(member) === K.indexSignature)
-            return member.child;
-    }
-    return undefined;
-}
-function elemNodeAt(node, i) {
-    if (!node)
-        return undefined;
-    if (kindOf(node) === K.tuple) {
-        const member = (node.children ?? [])[i];
-        return member?.child ?? member;
-    }
-    return node.child;
-}
-function typeofInverse(value) {
-    if (typeof value === 'string')
-        return 123;
-    if (typeof value === 'number' || typeof value === 'bigint')
-        return 'not-a-number';
-    if (typeof value === 'boolean')
-        return 'not-a-boolean';
-    if (value === null || value === undefined)
-        return 'unexpected';
-    if (Array.isArray(value))
-        return 'not-an-array';
-    return 'not-an-object';
-}
-const UNION_CANDIDATES = ['rt-invalid', 1234.5, true, { rtInvalid: true }, [], null];
-function negativeForUnion(members, value) {
-    const live = members.filter((member) => !member.notSupported);
-    for (const candidate of UNION_CANDIDATES) {
-        if (!live.some((member) => kindMatchesValue(member, candidate)))
-            return candidate;
-    }
-    return typeofInverse(value);
-}
-function literalInverse(lit) {
-    if (typeof lit === 'string')
-        return 1;
-    return 'not-the-literal';
-}
-function negativeFor(node, value, random = mockRandom_ts_1.nativeMockRandom) {
-    if (!node)
-        return typeofInverse(value);
-    const kind = kindOf(node);
-    if (kind === K.union)
-        return negativeForUnion(node.children ?? [], value);
-    switch (kind) {
-        case K.string: {
-            if (random.float() < 0.5) {
-                const formatNegative = (0, mockStringFormat_ts_1.negativeForStringFormat)(node.formatAnnotation, value);
-                if (formatNegative !== undefined)
-                    return formatNegative;
-            }
-            return 123;
-        }
-        case K.regexp:
-        case K.templateLiteral:
-        case K.symbol:
-            return 123;
-        case K.number:
-        case K.bigint:
-            return 'not-a-number';
-        case K.boolean:
-            return 'not-a-boolean';
-        case K.literal:
-            return literalInverse(node.literal);
-        case K.enum:
-            return {};
-        case K.null:
-            return 'not-null';
-        case K.undefined:
-        case K.void:
-            return 'should-be-undefined';
-        case K.object:
-        case K.objectLiteral:
-        case K.intersection:
-        case K.class:
-            return 'not-an-object';
-        case K.array:
-        case K.tuple:
-            return 'not-an-array';
-        case K.any:
-        case K.unknown:
-            return value;
-        default:
-            return typeofInverse(value);
-    }
-}
-function collect(value, node, parent, key, depth, out) {
-    const leaf = !isContainer(value);
-    out.push({ parent, key, node, value, depth, isLeaf: leaf });
-    if (leaf)
-        return;
-    const resolved = memberForValue(node, value);
-    if (Array.isArray(value)) {
-        const arr = value;
-        value.forEach((child, index) => collect(child, elemNodeAt(resolved, index), arr, index, depth + 1, out));
-        return;
-    }
-    const container = value;
-    for (const childKey of Object.keys(container)) {
-        collect(container[childKey], propChildNode(resolved, childKey), container, childKey, depth + 1, out);
-    }
-}
-function collectInvalidTargets(root, rootNode) {
-    const out = [];
-    collect(root, rootNode, undefined, undefined, 0, out);
-    return out;
-}
-function canCorrupt(target) {
-    if (!target.node)
-        return true;
-    const kind = kindOf(target.node);
-    return kind !== K.any && kind !== K.unknown;
-}
-function levelWeight(nd, p) {
-    return (1 - p) * (1 - nd) + p * nd;
-}
-function chooseInvalidTarget(targets, invalidLeafProbability, random = mockRandom_ts_1.nativeMockRandom) {
-    const corruptible = targets.filter(canCorrupt);
-    if (corruptible.length === 0)
-        return undefined;
-    const root = corruptible.find((target) => target.parent === undefined);
-    if (invalidLeafProbability >= 1) {
-        const leaves = corruptible.filter((target) => target.isLeaf);
-        if (leaves.length > 0)
-            return leaves[random.int(0, leaves.length - 1)];
-        return root ?? corruptible[0];
-    }
-    if (invalidLeafProbability <= 0)
-        return root ?? corruptible[0];
-    const maxDepth = corruptible.reduce((max, target) => Math.max(max, target.depth), 0);
-    if (maxDepth === 0)
-        return root ?? corruptible[0];
-    const countAtDepth = new Map();
-    for (const target of corruptible)
-        countAtDepth.set(target.depth, (countAtDepth.get(target.depth) ?? 0) + 1);
-    const weights = corruptible.map((target) => levelWeight(target.depth / maxDepth, invalidLeafProbability) / countAtDepth.get(target.depth));
-    const total = weights.reduce((sum, weight) => sum + weight, 0);
-    let roll = random.float() * total;
-    for (let i = 0; i < corruptible.length; i++) {
-        roll -= weights[i];
-        if (roll < 0)
-            return corruptible[i];
-    }
-    return corruptible[corruptible.length - 1];
-}
-function injectInvalid(root, rootNode, invalidLeafProbability, random) {
-    const targets = collectInvalidTargets(root, rootNode);
-    const chosen = chooseInvalidTarget(targets, invalidLeafProbability, random);
-    if (!chosen || chosen.parent === undefined)
-        return negativeFor(rootNode, root, random);
-    chosen.parent[chosen.key] = negativeFor(chosen.node, chosen.value, random);
-    return root;
-}
-function mockRunTypeInvalid(runType, options, stack = []) {
-    const base = (0, mockType_ts_1.mockRunType)(runType, options, stack);
-    const mockOptions = options.mock;
-    const random = mockOptions.random ?? mockRandom_ts_1.nativeMockRandom;
-    return injectInvalid(base, runType, mockOptions.invalidLeafProbability ?? 0.85, random);
-}

package/dist/cjs/mocking/mockNumberFormat.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/cjs/mocking/mockNumberFormat.js

@@ -1,56 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const runTypeKind_generated_ts_1 = require("../go-generated/runTypeKind.generated.js");
-const mockRegistry_ts_1 = require("./mockRegistry.js");
-const mockRandom_ts_1 = require("./mockRandom.js");
-const isMultipleOf_ts_1 = require("./isMultipleOf.js");
-const mockNumberFormat = (annotation, random = mockRandom_ts_1.nativeMockRandom) => {
-    if (annotation.name !== 'numberFormat')
-        return undefined;
-    return mockNumberParams((annotation.params ?? {}), random);
-};
-(0, mockRegistry_ts_1.registerMockingFunction)(runTypeKind_generated_ts_1.RunTypeKind.number, mockNumberFormat);
-function mockNumberParams(params, random) {
-    let min = params.min !== undefined ? numVal(params.min) : -99999;
-    let max = params.max !== undefined ? numVal(params.max) : 99999;
-    if (params.gt !== undefined) {
-        const epsilon = params.float ? 0.01 : 1;
-        min = Math.max(min, numVal(params.gt) + epsilon);
-    }
-    if (params.lt !== undefined) {
-        const epsilon = params.float ? 0.01 : 1;
-        max = Math.min(max, numVal(params.lt) - epsilon);
-    }
-    let result;
-    if (params.integer) {
-        min = Math.ceil(min);
-        max = Math.floor(max);
-        result = random.int(min, max);
-    }
-    else {
-        result = min + random.float() * (max - min);
-    }
-    if (params.multipleOf !== undefined) {
-        const tolerance = params.multipleOfTolerance !== undefined ? numVal(params.multipleOfTolerance) : undefined;
-        result = snapToMultiple(result, numVal(params.multipleOf), tolerance);
-    }
-    return result;
-}
-function snapToMultiple(value, multipleOf, tolerance) {
-    const quotient = Math.floor(value / multipleOf);
-    if (Number.isInteger(multipleOf))
-        return quotient * multipleOf;
-    for (let step = 0; step < 4; step++) {
-        const candidate = Number(((quotient - step) * multipleOf).toPrecision(15));
-        if ((0, isMultipleOf_ts_1.isMultipleOf)(candidate, multipleOf, tolerance))
-            return candidate;
-    }
-    return 0;
-}
-function numVal(value) {
-    if (typeof value === 'number')
-        return value;
-    if (value !== null && typeof value === 'object' && 'val' in value)
-        return numVal(value.val);
-    return Number(value);
-}

package/dist/cjs/mocking/mockRandom.d.ts

@@ -1,20 +0,0 @@
-export declare function mulberry32(state: number): () => number;
-export declare class MockRandom {
-    private readonly next;
-    constructor(seed?: number);
-    float(): number;
-    int(min?: number, max?: number): number;
-    pick<T>(list: T[]): T;
-    boolean(): boolean;
-    bigint(min?: number, max?: number): bigint;
-    number(min?: number, max?: number): number;
-    string(length?: number, allowedChars?: string, disallowedChars?: string): string;
-    symbol(name?: string, length?: number, charsSet?: string): symbol;
-    regExp(list?: RegExp[]): RegExp;
-    date(minDate?: Date | number, maxDate?: Date | number): Date;
-    any(anyList?: unknown[]): unknown;
-    now(): number;
-    uuidV4(): string;
-    uuidV7(): string;
-}
-export declare const nativeMockRandom: MockRandom;