@mionjs/run-types 0.8.8 → 0.13.0

package/dist/cjs/go-generated/runTypeKind.generated.d.ts

@@ -0,0 +1,62 @@
+export declare const RunTypeKind: {
+    readonly never: 0;
+    readonly any: 1;
+    readonly unknown: 2;
+    readonly void: 3;
+    readonly object: 4;
+    readonly string: 5;
+    readonly number: 6;
+    readonly boolean: 7;
+    readonly symbol: 8;
+    readonly bigint: 9;
+    readonly null: 10;
+    readonly undefined: 11;
+    readonly regexp: 12;
+    readonly literal: 13;
+    readonly templateLiteral: 14;
+    readonly property: 15;
+    readonly method: 16;
+    readonly function: 17;
+    readonly parameter: 18;
+    readonly promise: 19;
+    readonly class: 20;
+    readonly typeParameter: 21;
+    readonly enum: 22;
+    readonly union: 23;
+    readonly intersection: 24;
+    readonly array: 25;
+    readonly tuple: 26;
+    readonly tupleMember: 27;
+    readonly enumMember: 28;
+    readonly rest: 29;
+    readonly objectLiteral: 30;
+    readonly indexSignature: 31;
+    readonly propertySignature: 32;
+    readonly methodSignature: 33;
+    readonly infer: 34;
+    readonly callSignature: 35;
+    readonly ref: -1;
+};
+export type RunTypeKindName = keyof typeof RunTypeKind;
+export type RunTypeKindValue = (typeof RunTypeKind)[RunTypeKindName];
+export declare const RunTypeSubKind: {
+    readonly none: 0;
+    readonly mapKey: 1801;
+    readonly mapValue: 1802;
+    readonly setItem: 1803;
+    readonly date: 2001;
+    readonly map: 2002;
+    readonly set: 2003;
+    readonly nonSerializable: 2004;
+    readonly url: 2005;
+    readonly temporalInstant: 2101;
+    readonly temporalZonedDateTime: 2102;
+    readonly temporalPlainDate: 2103;
+    readonly temporalPlainTime: 2104;
+    readonly temporalPlainDateTime: 2105;
+    readonly temporalPlainYearMonth: 2106;
+    readonly temporalPlainMonthDay: 2107;
+    readonly temporalDuration: 2108;
+};
+export type RunTypeSubKindName = keyof typeof RunTypeSubKind;
+export type RunTypeSubKindValue = (typeof RunTypeSubKind)[RunTypeSubKindName];

package/dist/cjs/go-generated/runTypeKind.generated.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunTypeSubKind = exports.RunTypeKind = void 0;
+exports.RunTypeKind = {
+    never: 0,
+    any: 1,
+    unknown: 2,
+    void: 3,
+    object: 4,
+    string: 5,
+    number: 6,
+    boolean: 7,
+    symbol: 8,
+    bigint: 9,
+    null: 10,
+    undefined: 11,
+    regexp: 12,
+    literal: 13,
+    templateLiteral: 14,
+    property: 15,
+    method: 16,
+    function: 17,
+    parameter: 18,
+    promise: 19,
+    class: 20,
+    typeParameter: 21,
+    enum: 22,
+    union: 23,
+    intersection: 24,
+    array: 25,
+    tuple: 26,
+    tupleMember: 27,
+    enumMember: 28,
+    rest: 29,
+    objectLiteral: 30,
+    indexSignature: 31,
+    propertySignature: 32,
+    methodSignature: 33,
+    infer: 34,
+    callSignature: 35,
+    ref: -1,
+};
+exports.RunTypeSubKind = {
+    none: 0,
+    mapKey: 1801,
+    mapValue: 1802,
+    setItem: 1803,
+    date: 2001,
+    map: 2002,
+    set: 2003,
+    nonSerializable: 2004,
+    url: 2005,
+    temporalInstant: 2101,
+    temporalZonedDateTime: 2102,
+    temporalPlainDate: 2103,
+    temporalPlainTime: 2104,
+    temporalPlainDateTime: 2105,
+    temporalPlainYearMonth: 2106,
+    temporalPlainMonthDay: 2107,
+    temporalDuration: 2108,
+};

package/dist/cjs/go-generated/typeFormats.generated.d.ts

@@ -0,0 +1,104 @@
+import { type RunTypeKindValue } from './runTypeKind.generated.ts';
+export interface TypeFormatMeta {
+    readonly name: FormatName;
+    readonly kind: RunTypeKindValue;
+}
+export declare const typeFormats: {
+    readonly bigintFormat: {
+        readonly name: "bigintFormat";
+        readonly kind: 9;
+    };
+    readonly creditCard: {
+        readonly name: "creditCard";
+        readonly kind: 5;
+    };
+    readonly date: {
+        readonly name: "date";
+        readonly kind: 5;
+    };
+    readonly dateTime: {
+        readonly name: "dateTime";
+        readonly kind: 5;
+    };
+    readonly domain: {
+        readonly name: "domain";
+        readonly kind: 5;
+    };
+    readonly email: {
+        readonly name: "email";
+        readonly kind: 5;
+    };
+    readonly formattedArray: {
+        readonly name: "formattedArray";
+        readonly kind: 25;
+    };
+    readonly formattedMap: {
+        readonly name: "formattedMap";
+        readonly kind: 20;
+    };
+    readonly formattedObject: {
+        readonly name: "formattedObject";
+        readonly kind: 4;
+    };
+    readonly formattedSet: {
+        readonly name: "formattedSet";
+        readonly kind: 20;
+    };
+    readonly ip: {
+        readonly name: "ip";
+        readonly kind: 5;
+    };
+    readonly nativeDate: {
+        readonly name: "nativeDate";
+        readonly kind: 20;
+    };
+    readonly nativeUrl: {
+        readonly name: "nativeUrl";
+        readonly kind: 20;
+    };
+    readonly numberFormat: {
+        readonly name: "numberFormat";
+        readonly kind: 6;
+    };
+    readonly stringFormat: {
+        readonly name: "stringFormat";
+        readonly kind: 5;
+    };
+    readonly temporalInstant: {
+        readonly name: "temporalInstant";
+        readonly kind: 20;
+    };
+    readonly temporalPlainDate: {
+        readonly name: "temporalPlainDate";
+        readonly kind: 20;
+    };
+    readonly temporalPlainDateTime: {
+        readonly name: "temporalPlainDateTime";
+        readonly kind: 20;
+    };
+    readonly temporalPlainTime: {
+        readonly name: "temporalPlainTime";
+        readonly kind: 20;
+    };
+    readonly temporalPlainYearMonth: {
+        readonly name: "temporalPlainYearMonth";
+        readonly kind: 20;
+    };
+    readonly temporalZonedDateTime: {
+        readonly name: "temporalZonedDateTime";
+        readonly kind: 20;
+    };
+    readonly time: {
+        readonly name: "time";
+        readonly kind: 5;
+    };
+    readonly url: {
+        readonly name: "url";
+        readonly kind: 5;
+    };
+    readonly uuid: {
+        readonly name: "uuid";
+        readonly kind: 5;
+    };
+};
+export type FormatName = keyof typeof typeFormats;

package/dist/cjs/go-generated/typeFormats.generated.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typeFormats = void 0;
+const runTypeKind_generated_ts_1 = require("./runTypeKind.generated.js");
+exports.typeFormats = {
+    bigintFormat: { name: 'bigintFormat', kind: runTypeKind_generated_ts_1.RunTypeKind.bigint },
+    creditCard: { name: 'creditCard', kind: runTypeKind_generated_ts_1.RunTypeKind.string },
+    date: { name: 'date', kind: runTypeKind_generated_ts_1.RunTypeKind.string },
+    dateTime: { name: 'dateTime', kind: runTypeKind_generated_ts_1.RunTypeKind.string },
+    domain: { name: 'domain', kind: runTypeKind_generated_ts_1.RunTypeKind.string },
+    email: { name: 'email', kind: runTypeKind_generated_ts_1.RunTypeKind.string },
+    formattedArray: { name: 'formattedArray', kind: runTypeKind_generated_ts_1.RunTypeKind.array },
+    formattedMap: { name: 'formattedMap', kind: runTypeKind_generated_ts_1.RunTypeKind.class },
+    formattedObject: { name: 'formattedObject', kind: runTypeKind_generated_ts_1.RunTypeKind.object },
+    formattedSet: { name: 'formattedSet', kind: runTypeKind_generated_ts_1.RunTypeKind.class },
+    ip: { name: 'ip', kind: runTypeKind_generated_ts_1.RunTypeKind.string },
+    nativeDate: { name: 'nativeDate', kind: runTypeKind_generated_ts_1.RunTypeKind.class },
+    nativeUrl: { name: 'nativeUrl', kind: runTypeKind_generated_ts_1.RunTypeKind.class },
+    numberFormat: { name: 'numberFormat', kind: runTypeKind_generated_ts_1.RunTypeKind.number },
+    stringFormat: { name: 'stringFormat', kind: runTypeKind_generated_ts_1.RunTypeKind.string },
+    temporalInstant: { name: 'temporalInstant', kind: runTypeKind_generated_ts_1.RunTypeKind.class },
+    temporalPlainDate: { name: 'temporalPlainDate', kind: runTypeKind_generated_ts_1.RunTypeKind.class },
+    temporalPlainDateTime: { name: 'temporalPlainDateTime', kind: runTypeKind_generated_ts_1.RunTypeKind.class },
+    temporalPlainTime: { name: 'temporalPlainTime', kind: runTypeKind_generated_ts_1.RunTypeKind.class },
+    temporalPlainYearMonth: { name: 'temporalPlainYearMonth', kind: runTypeKind_generated_ts_1.RunTypeKind.class },
+    temporalZonedDateTime: { name: 'temporalZonedDateTime', kind: runTypeKind_generated_ts_1.RunTypeKind.class },
+    time: { name: 'time', kind: runTypeKind_generated_ts_1.RunTypeKind.string },
+    url: { name: 'url', kind: runTypeKind_generated_ts_1.RunTypeKind.string },
+    uuid: { name: 'uuid', kind: runTypeKind_generated_ts_1.RunTypeKind.string },
+};

package/dist/cjs/index.d.ts

@@ -0,0 +1,28 @@
+export { type InjectRunTypeId, type InjectTypeFnArgs, type InjectPureFnId, type InjectBatchId, type InjectApiMetadata, type InjectBuildVersion, type CompTimeArgs, type CompTimeFnArgs, type CompTimeHints, type PureFunction, type PureFunctionFactory, getRunTypeId, } from './markers.ts';
+export { getRunType } from './getRunType.ts';
+export { type CompiledFnData, type CompiledTypeFn, type InitializedTypeFn, type CompiledFnArgs, type CompiledPureFunction, type PureFunctionData, type AnyFn, } from './runtypes/types.ts';
+export { type RunType } from './runtypes/types.ts';
+export { type DataOnly } from './runtypes/dataOnly.ts';
+export { type StripRunTypeMeta, type JsonValue } from './runtypes/stripRunTypeMeta.ts';
+export { type JSONShape } from './runtypes/jsonShape.ts';
+export { type InferType, type AnyOf } from './builders/static.ts';
+export { type FriendlyText, type FriendlyNode, type FriendlyMeta, type ErrorTemplates, type FriendlyTemplate, type PluralCategory, type PluralTemplate, type TemplateLeaf, } from './enrich/friendlyText.ts';
+export { type MockData, type MockNode } from './enrich/mockData.ts';
+export { createFriendlyText, createFriendlyTextI18n, resolveLocale, type FriendlyMessage, type FriendlyRenderer, type FriendlyI18nOptions, } from './enrich/createFriendlyText.ts';
+import './runtypes/pure-fns-utils.ts';
+export { type TypeFormat, type TypeFormatBase, type TypeFormatParams, type FormatNameOf, type FormatParamsOf, type FormatBrandNameOf, type FormatBrand, type NominalBrand, } from './runtypes/typeFormat.ts';
+export type { __rtFormatName, __rtFormatParams } from './runtypes/sentinelKeys.ts';
+export type { FormatErrorsOf } from './runtypes/formatErrors.ts';
+export type { InsertModel, SelectModel, UpdateModel } from './modelTypes.ts';
+export { type FormatAnnotation } from './runtypes/formatAnnotation.ts';
+export { registerFormatPattern, type FormatPattern, type StringPatternArgs } from './runtypes/formatPattern.ts';
+export { RunTypeKind, type RunTypeKindName, type RunTypeKindValue, RunTypeSubKind, type RunTypeSubKindName, type RunTypeSubKindValue, } from './go-generated/runTypeKind.generated.ts';
+export { createValidateFn, type ValidateFn, type ValidateOptions, createGetValidationErrorsFn, type GetValidationErrorsFn, type RTValidationError, type TypeFormatError, type RTValidationErrorPathSegment, type RTPathSegment, createRemoveUnknownKeysFn, type RemoveUnknownKeysFn, type RemoveUnknownKeysOptions, createFormatTransformFn, type FormatTransformFn, createJsonEncoderFn, type JsonEncoderFn, type JsonEncoderOptions, type JsonEncoderStrategy, createJsonDecoderFn, type JsonDecoderFn, type JsonDecoderOptions, type JsonDecoderStrategy, createPrepareForJsonFn, type PrepareForJsonFn, type PrepareForJsonOptions, createRestoreFromJsonFn, type RestoreFromJsonFn, type RestoreFromJsonOptions, type JsonValueStrategy, } from './createRTFunctions.ts';
+export { overrideValidate, overrideGetValidationErrors, overrideRemoveUnknownKeys, overrideFormatTransform, overrideJsonEncoder, overrideJsonDecoder, } from './overrideRTFunctions.ts';
+export { createStandardSchema, type RTStandardSchemaV1, type RTValidationResult, type RTValidationFailureResult, } from './standard/createStandardSchema.ts';
+export { runTypeErrorsToIssues, type IssueMappingOptions, type RTValidationIssue } from './standard/issueMapping.ts';
+export { type StandardSchemaV1, type StandardSchemaProps, type StandardSchemaResult, type StandardSchemaSuccessResult, type StandardSchemaFailureResult, type StandardSchemaIssue, type StandardSchemaPathSegment, type StandardSchemaTypes, type StandardSchemaInferInput, type StandardSchemaInferOutput, type StandardJSONSchemaV1, type StandardJSONSchemaProps, type StandardJSONSchemaConverter, type StandardJSONSchemaOptions, } from './standard/spec.ts';
+export { createJsonSchemaFn, type JsonSchemaFn } from './standard/createJsonSchemaFn.ts';
+export { stripDialect, buildJsonSchemaConverter, JSON_SCHEMA_TARGET, JSON_SCHEMA_DIALECT_KEYWORDS, type JsonSchemaDocFn, } from './standard/jsonSchemaDoc.ts';
+export { CircularReferenceError, type CircularPath } from './runtypes/circular.ts';
+export declare const UNSAFE_PROPERTY_NAME_MESSAGE = "[mion] Unsafe property name: ";

package/dist/cjs/index.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UNSAFE_PROPERTY_NAME_MESSAGE = exports.CircularReferenceError = exports.JSON_SCHEMA_DIALECT_KEYWORDS = exports.JSON_SCHEMA_TARGET = exports.buildJsonSchemaConverter = exports.stripDialect = exports.createJsonSchemaFn = exports.runTypeErrorsToIssues = exports.createStandardSchema = exports.overrideJsonDecoder = exports.overrideJsonEncoder = exports.overrideFormatTransform = exports.overrideRemoveUnknownKeys = exports.overrideGetValidationErrors = exports.overrideValidate = exports.createRestoreFromJsonFn = exports.createPrepareForJsonFn = exports.createJsonDecoderFn = exports.createJsonEncoderFn = exports.createFormatTransformFn = exports.createRemoveUnknownKeysFn = exports.createGetValidationErrorsFn = exports.createValidateFn = exports.RunTypeSubKind = exports.RunTypeKind = exports.registerFormatPattern = exports.resolveLocale = exports.createFriendlyTextI18n = exports.createFriendlyText = exports.getRunType = exports.getRunTypeId = void 0;
+var markers_ts_1 = require("./markers.js");
+Object.defineProperty(exports, "getRunTypeId", { enumerable: true, get: function () { return markers_ts_1.getRunTypeId; } });
+var getRunType_ts_1 = require("./getRunType.js");
+Object.defineProperty(exports, "getRunType", { enumerable: true, get: function () { return getRunType_ts_1.getRunType; } });
+var createFriendlyText_ts_1 = require("./enrich/createFriendlyText.js");
+Object.defineProperty(exports, "createFriendlyText", { enumerable: true, get: function () { return createFriendlyText_ts_1.createFriendlyText; } });
+Object.defineProperty(exports, "createFriendlyTextI18n", { enumerable: true, get: function () { return createFriendlyText_ts_1.createFriendlyTextI18n; } });
+Object.defineProperty(exports, "resolveLocale", { enumerable: true, get: function () { return createFriendlyText_ts_1.resolveLocale; } });
+require("./runtypes/pure-fns-utils.js");
+var formatPattern_ts_1 = require("./runtypes/formatPattern.js");
+Object.defineProperty(exports, "registerFormatPattern", { enumerable: true, get: function () { return formatPattern_ts_1.registerFormatPattern; } });
+var runTypeKind_generated_ts_1 = require("./go-generated/runTypeKind.generated.js");
+Object.defineProperty(exports, "RunTypeKind", { enumerable: true, get: function () { return runTypeKind_generated_ts_1.RunTypeKind; } });
+Object.defineProperty(exports, "RunTypeSubKind", { enumerable: true, get: function () { return runTypeKind_generated_ts_1.RunTypeSubKind; } });
+var createRTFunctions_ts_1 = require("./createRTFunctions.js");
+Object.defineProperty(exports, "createValidateFn", { enumerable: true, get: function () { return createRTFunctions_ts_1.createValidateFn; } });
+Object.defineProperty(exports, "createGetValidationErrorsFn", { enumerable: true, get: function () { return createRTFunctions_ts_1.createGetValidationErrorsFn; } });
+Object.defineProperty(exports, "createRemoveUnknownKeysFn", { enumerable: true, get: function () { return createRTFunctions_ts_1.createRemoveUnknownKeysFn; } });
+Object.defineProperty(exports, "createFormatTransformFn", { enumerable: true, get: function () { return createRTFunctions_ts_1.createFormatTransformFn; } });
+Object.defineProperty(exports, "createJsonEncoderFn", { enumerable: true, get: function () { return createRTFunctions_ts_1.createJsonEncoderFn; } });
+Object.defineProperty(exports, "createJsonDecoderFn", { enumerable: true, get: function () { return createRTFunctions_ts_1.createJsonDecoderFn; } });
+Object.defineProperty(exports, "createPrepareForJsonFn", { enumerable: true, get: function () { return createRTFunctions_ts_1.createPrepareForJsonFn; } });
+Object.defineProperty(exports, "createRestoreFromJsonFn", { enumerable: true, get: function () { return createRTFunctions_ts_1.createRestoreFromJsonFn; } });
+var overrideRTFunctions_ts_1 = require("./overrideRTFunctions.js");
+Object.defineProperty(exports, "overrideValidate", { enumerable: true, get: function () { return overrideRTFunctions_ts_1.overrideValidate; } });
+Object.defineProperty(exports, "overrideGetValidationErrors", { enumerable: true, get: function () { return overrideRTFunctions_ts_1.overrideGetValidationErrors; } });
+Object.defineProperty(exports, "overrideRemoveUnknownKeys", { enumerable: true, get: function () { return overrideRTFunctions_ts_1.overrideRemoveUnknownKeys; } });
+Object.defineProperty(exports, "overrideFormatTransform", { enumerable: true, get: function () { return overrideRTFunctions_ts_1.overrideFormatTransform; } });
+Object.defineProperty(exports, "overrideJsonEncoder", { enumerable: true, get: function () { return overrideRTFunctions_ts_1.overrideJsonEncoder; } });
+Object.defineProperty(exports, "overrideJsonDecoder", { enumerable: true, get: function () { return overrideRTFunctions_ts_1.overrideJsonDecoder; } });
+var createStandardSchema_ts_1 = require("./standard/createStandardSchema.js");
+Object.defineProperty(exports, "createStandardSchema", { enumerable: true, get: function () { return createStandardSchema_ts_1.createStandardSchema; } });
+var issueMapping_ts_1 = require("./standard/issueMapping.js");
+Object.defineProperty(exports, "runTypeErrorsToIssues", { enumerable: true, get: function () { return issueMapping_ts_1.runTypeErrorsToIssues; } });
+var createJsonSchemaFn_ts_1 = require("./standard/createJsonSchemaFn.js");
+Object.defineProperty(exports, "createJsonSchemaFn", { enumerable: true, get: function () { return createJsonSchemaFn_ts_1.createJsonSchemaFn; } });
+var jsonSchemaDoc_ts_1 = require("./standard/jsonSchemaDoc.js");
+Object.defineProperty(exports, "stripDialect", { enumerable: true, get: function () { return jsonSchemaDoc_ts_1.stripDialect; } });
+Object.defineProperty(exports, "buildJsonSchemaConverter", { enumerable: true, get: function () { return jsonSchemaDoc_ts_1.buildJsonSchemaConverter; } });
+Object.defineProperty(exports, "JSON_SCHEMA_TARGET", { enumerable: true, get: function () { return jsonSchemaDoc_ts_1.JSON_SCHEMA_TARGET; } });
+Object.defineProperty(exports, "JSON_SCHEMA_DIALECT_KEYWORDS", { enumerable: true, get: function () { return jsonSchemaDoc_ts_1.JSON_SCHEMA_DIALECT_KEYWORDS; } });
+var circular_ts_1 = require("./runtypes/circular.js");
+Object.defineProperty(exports, "CircularReferenceError", { enumerable: true, get: function () { return circular_ts_1.CircularReferenceError; } });
+exports.UNSAFE_PROPERTY_NAME_MESSAGE = '[mion] Unsafe property name: ';

package/dist/cjs/markers.d.ts

@@ -0,0 +1,33 @@
+import type { RunType } from './runtypes/types.ts';
+export type InjectRunTypeId<T> = string & {
+    readonly __rtInjectRunTypeIdBrand?: T;
+};
+export type InjectTypeFnArgs<T, F1 extends string, F2 extends string = never, F3 extends string = never, F4 extends string = never, F5 extends string = never, F6 extends string = never, F7 extends string = never, F8 extends string = never, F9 extends string = never, F10 extends string = never, F11 extends string = never, F12 extends string = never> = string & {
+    readonly __rtInjectTypeFnArgsBrand?: T;
+    readonly __rtInjectTypeFnArgsFns?: [F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12];
+};
+export declare function getRunTypeId<T>(runType: RunType<T>, id?: InjectRunTypeId<T>): InjectRunTypeId<T>;
+export declare function getRunTypeId<T>(_value?: T, id?: InjectRunTypeId<T>): InjectRunTypeId<T>;
+export type CompTimeArgs<T> = T;
+export type CompTimeFnArgs<T> = T & {
+    readonly __rtCompTimeFnArgsBrand?: never;
+};
+export type CompTimeHints<T> = T;
+export type PureFunction<F> = F & {
+    readonly __rtPureFunctionBrand?: never;
+};
+export type PureFunctionFactory<F> = F & {
+    readonly __rtPureFunctionFactoryBrand?: never;
+};
+export type InjectPureFnId<F> = string & {
+    readonly __rtInjectPureFnIdBrand?: F;
+};
+export type InjectBatchId<Routes> = string & {
+    readonly __rtInjectBatchIdBrand?: Routes;
+};
+export type InjectApiMetadata<Api, Id extends string> = {
+    readonly __rtInjectApiMetadataBrand?: [Api, Id];
+};
+export type InjectBuildVersion<Api> = string & {
+    readonly __rtInjectBuildVersionBrand?: Api;
+};

package/dist/cjs/markers.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRunTypeId = getRunTypeId;
+const entryTuple_ts_1 = require("./runtypes/entryTuple.js");
+function getRunTypeId(_valueOrSchema, id) {
+    if ((0, entryTuple_ts_1.isEntryTuple)(id)) {
+        (0, entryTuple_ts_1.initFromTuple)(id);
+        return (0, entryTuple_ts_1.entryTupleKey)(id);
+    }
+    if (id === undefined) {
+        throw new Error('getRunTypeId(): no id injected. @mionjs/devtools must be active.');
+    }
+    return id;
+}

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

@@ -0,0 +1,3 @@
+import type { RunType } from '../runtypes/types.ts';
+export declare function childSchemaMatches(value: unknown, child: RunType): boolean;
+export declare function isMockSamplingError(error: unknown): boolean;