@mionjs/run-types 0.8.10 → 0.13.2

package/dist/cjs/mocking/mockDateTimeBounds.js

@@ -0,0 +1,277 @@
+"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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,233 @@
+"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

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

package/dist/cjs/mocking/mockNumberFormat.js

@@ -0,0 +1,56 @@
+"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

@@ -0,0 +1,20 @@
+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;