@mionjs/run-types 0.8.10 → 0.13.2

package/dist/cjs/formats/string/stringFormats.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.urlFile = exports.urlHttp = exports.stringUrlFile = exports.stringUrlHttp = exports.stringUrl = exports.emailParts = exports.emailPunycode = exports.idnEmail = exports.emailAddress = exports.email = exports.domainParts = exports.domainPunycode = exports.domainUnicode = exports.domain = exports.relativeJsonPointer = exports.jsonPointer = exports.regexString = exports.stringDuration = exports.idnHostname = exports.hostname = exports.uriTemplate = exports.iriReference = exports.iri = exports.uriReference = exports.uri = exports.ipv6WithPort = exports.ipv4WithPort = exports.ipWithPort = exports.ipv6 = exports.ipv4 = exports.ip = exports.uuidv7 = exports.uuidv4 = exports.uuid = exports.capitalize = exports.uppercase = exports.lowercase = exports.jsonContentBase64 = exports.jsonContent = exports.base16 = exports.base32 = exports.base64 = exports.numeric = exports.alphaNumeric = exports.alpha = void 0;
+exports.presetFormatBuilder = presetFormatBuilder;
+exports.transform = transform;
+exports.url = url;
+exports.stringDate = stringDate;
+exports.stringTime = stringTime;
+exports.stringDateTime = stringDateTime;
+const builderCore_ts_1 = require("../../runtypes/builderCore.js");
+function presetFormatBuilder(tag) {
+    return ((formatParamsOrId, id) => {
+        const isParams = typeof formatParamsOrId === 'object' && formatParamsOrId !== null && !Array.isArray(formatParamsOrId);
+        const injectedId = isParams ? id : (formatParamsOrId ?? id);
+        return (0, builderCore_ts_1.builderResult)(injectedId, { type: tag, formatParams: isParams ? formatParamsOrId : {} });
+    });
+}
+exports.alpha = presetFormatBuilder('stringFormat');
+exports.alphaNumeric = presetFormatBuilder('stringFormat');
+exports.numeric = presetFormatBuilder('stringFormat');
+exports.base64 = presetFormatBuilder('stringFormat');
+exports.base32 = presetFormatBuilder('stringFormat');
+exports.base16 = presetFormatBuilder('stringFormat');
+exports.jsonContent = presetFormatBuilder('stringFormat');
+exports.jsonContentBase64 = presetFormatBuilder('stringFormat');
+exports.lowercase = presetFormatBuilder('stringFormat');
+exports.uppercase = presetFormatBuilder('stringFormat');
+exports.capitalize = presetFormatBuilder('stringFormat');
+function transform(runType, transformParams, id) {
+    return (0, builderCore_ts_1.builderResult)(id, { type: 'transform', formatParams: { transform: transformParams }, inner: runType });
+}
+exports.uuid = (0, builderCore_ts_1.presetBuilder)('uuid');
+exports.uuidv4 = (0, builderCore_ts_1.presetBuilder)('uuid');
+exports.uuidv7 = (0, builderCore_ts_1.presetBuilder)('uuid');
+exports.ip = presetFormatBuilder('ip');
+exports.ipv4 = presetFormatBuilder('ip');
+exports.ipv6 = presetFormatBuilder('ip');
+exports.ipWithPort = presetFormatBuilder('ip');
+exports.ipv4WithPort = presetFormatBuilder('ip');
+exports.ipv6WithPort = presetFormatBuilder('ip');
+exports.uri = presetFormatBuilder('url');
+exports.uriReference = presetFormatBuilder('url');
+exports.iri = presetFormatBuilder('url');
+exports.iriReference = presetFormatBuilder('url');
+exports.uriTemplate = presetFormatBuilder('url');
+exports.hostname = presetFormatBuilder('domain');
+exports.idnHostname = presetFormatBuilder('domain');
+exports.stringDuration = presetFormatBuilder('stringFormat');
+exports.regexString = presetFormatBuilder('stringFormat');
+exports.jsonPointer = presetFormatBuilder('stringFormat');
+exports.relativeJsonPointer = presetFormatBuilder('stringFormat');
+exports.domain = presetFormatBuilder('domain');
+exports.domainUnicode = presetFormatBuilder('domain');
+exports.domainPunycode = presetFormatBuilder('domain');
+exports.domainParts = presetFormatBuilder('domain');
+exports.email = presetFormatBuilder('email');
+exports.emailAddress = presetFormatBuilder('email');
+exports.idnEmail = presetFormatBuilder('email');
+exports.emailPunycode = presetFormatBuilder('email');
+exports.emailParts = presetFormatBuilder('email');
+exports.stringUrl = presetFormatBuilder('url');
+exports.stringUrlHttp = presetFormatBuilder('url');
+exports.stringUrlFile = presetFormatBuilder('url');
+function url(formatParamsOrId, brandOrId, id) {
+    const formatParams = typeof formatParamsOrId === 'object' && !Array.isArray(formatParamsOrId) ? formatParamsOrId : {};
+    return (0, builderCore_ts_1.builderResult)((0, builderCore_ts_1.lastInjectedId)(formatParamsOrId, brandOrId, id), { type: 'nativeUrl', formatParams });
+}
+exports.urlHttp = presetFormatBuilder('nativeUrl');
+exports.urlFile = presetFormatBuilder('nativeUrl');
+function stringDate(formatParamsOrId, id) {
+    const formatParams = typeof formatParamsOrId === 'object' ? formatParamsOrId : {};
+    const injectedId = typeof formatParamsOrId === 'string' ? formatParamsOrId : id;
+    return (0, builderCore_ts_1.builderResult)(injectedId, { type: 'date', formatParams });
+}
+function stringTime(formatParamsOrId, id) {
+    const formatParams = typeof formatParamsOrId === 'object' ? formatParamsOrId : {};
+    const injectedId = typeof formatParamsOrId === 'string' ? formatParamsOrId : id;
+    return (0, builderCore_ts_1.builderResult)(injectedId, { type: 'time', formatParams });
+}
+function stringDateTime(formatParamsOrId, id) {
+    const formatParams = typeof formatParamsOrId === 'object' ? formatParamsOrId : {};
+    const injectedId = typeof formatParamsOrId === 'string' ? formatParamsOrId : id;
+    return (0, builderCore_ts_1.builderResult)(injectedId, { type: 'dateTime', formatParams });
+}

package/dist/cjs/formats/structural.d.ts

@@ -0,0 +1,105 @@
+import type { RunType } from '../runtypes/types.ts';
+import type { __rtFormatName, __rtFormatParams, __rtContains, __rtPatternProps, __rtPropNames } from '../runtypes/sentinelKeys.ts';
+type Flatten<T> = {
+    [K in keyof T]: T[K];
+};
+export declare const FORMATTED_ARRAY_NAME = "formattedArray";
+export declare const FORMATTED_OBJECT_NAME = "formattedObject";
+export type StructuralBrand<Name extends string, P extends object> = {
+    readonly [__rtFormatName]?: Name;
+    readonly [__rtFormatParams]?: P;
+};
+export interface FormattedCollectionParams<Contains = unknown> {
+    readonly minItems?: number;
+    readonly maxItems?: number;
+    readonly uniqueItems?: true;
+    readonly contains?: Contains;
+    readonly minContains?: number;
+    readonly maxContains?: number;
+}
+type CollectionLiteralKeys = 'minItems' | 'maxItems' | 'uniqueItems';
+type CollectionLiteralPart<P> = {
+    readonly [K in Extract<keyof P, CollectionLiteralKeys>]: P[K];
+};
+type ContainsSlot<P> = P extends {
+    contains: infer C;
+} ? {
+    readonly [__rtContains]?: Flatten<{
+        readonly rt$child: C;
+    } & (P extends {
+        minContains: infer N extends number;
+    } ? {
+        readonly rt$min: N;
+    } : {
+        readonly rt$min: 1;
+    }) & (P extends {
+        maxContains: infer N extends number;
+    } ? {
+        readonly rt$max: N;
+    } : unknown)>;
+} : unknown;
+export type FormattedArray<Base extends readonly unknown[], P extends FormattedCollectionParams> = Base & ([keyof CollectionLiteralPart<P>] extends [never] ? unknown : StructuralBrand<typeof FORMATTED_ARRAY_NAME, CollectionLiteralPart<P>>) & ContainsSlot<P>;
+export declare const FORMATTED_SET_NAME = "formattedSet";
+export declare const FORMATTED_MAP_NAME = "formattedMap";
+export type FormattedSet<Base extends ReadonlySet<unknown>, P extends FormattedCollectionParams> = Base & ([keyof CollectionLiteralPart<P>] extends [never] ? unknown : StructuralBrand<typeof FORMATTED_SET_NAME, CollectionLiteralPart<P>>) & ContainsSlot<P>;
+type MapEntry = readonly [unknown, unknown];
+export type FormattedMapParams = FormattedCollectionParams<MapEntry>;
+export type FormattedMap<Base extends ReadonlyMap<unknown, unknown>, P extends FormattedMapParams> = Base & ([keyof CollectionLiteralPart<P>] extends [never] ? unknown : StructuralBrand<typeof FORMATTED_MAP_NAME, CollectionLiteralPart<P>>) & ContainsSlot<P>;
+export interface FormattedObjectParams<Value = unknown, Key = string> {
+    readonly minProperties?: number;
+    readonly maxProperties?: number;
+    readonly patternProperties?: Record<string, Value>;
+    readonly propertyNames?: Key;
+    readonly closed?: readonly string[];
+    readonly closedPatterns?: readonly string[];
+    readonly additionalOwn?: readonly string[];
+}
+type ObjectLiteralKeys = 'minProperties' | 'maxProperties' | 'closed' | 'closedPatterns' | 'additionalOwn';
+type ObjectLiteralPart<P> = {
+    readonly [K in Extract<keyof P, ObjectLiteralKeys>]: P[K];
+};
+type PatternPropsSlot<P> = P extends {
+    patternProperties: infer M;
+} ? {
+    readonly [__rtPatternProps]?: {
+        readonly [K in keyof M]: {
+            readonly rt$key: string & StructuralBrand<'stringFormat', {
+                readonly pattern: {
+                    readonly source: K;
+                    readonly flags: '';
+                };
+            }>;
+            readonly rt$value: M[K];
+        };
+    };
+} : unknown;
+type PropNamesSlot<P> = P extends {
+    propertyNames: infer N;
+} ? {
+    readonly [__rtPropNames]?: N;
+} : unknown;
+export type FormattedObject<Base extends object, P extends FormattedObjectParams> = Base & ([keyof ObjectLiteralPart<P>] extends [never] ? unknown : StructuralBrand<typeof FORMATTED_OBJECT_NAME, ObjectLiteralPart<P>>) & PatternPropsSlot<P> & PropNamesSlot<P>;
+export type FormattedCollectionParamsValueFirst = FormattedCollectionParams<RunType<unknown>>;
+export type FormattedMapParamsValueFirst = FormattedCollectionParams<RunType<readonly [unknown, unknown]>>;
+type CollectionParamsType<P> = Flatten<Pick<P, Extract<keyof P, 'minItems' | 'maxItems' | 'uniqueItems' | 'minContains' | 'maxContains'>> & (P extends {
+    contains: RunType<infer C>;
+} ? {
+    readonly contains: C;
+} : unknown)>;
+export type FormattedArrayFrom<T extends readonly unknown[], P> = FormattedArray<T, Extract<CollectionParamsType<P>, FormattedCollectionParams>>;
+export type FormattedSetFrom<T extends ReadonlySet<unknown>, P> = FormattedSet<T, Extract<CollectionParamsType<P>, FormattedCollectionParams>>;
+export type FormattedMapFrom<T extends ReadonlyMap<unknown, unknown>, P> = FormattedMap<T, Extract<CollectionParamsType<P>, FormattedMapParams>>;
+export type FormattedObjectParamsValueFirst = FormattedObjectParams<RunType<unknown>, RunType<string>>;
+type ObjectParamsType<P> = Flatten<Pick<P, Extract<keyof P, 'minProperties' | 'maxProperties' | 'closed' | 'closedPatterns'>> & (P extends {
+    patternProperties: infer M;
+} ? {
+    readonly patternProperties: {
+        [K in keyof M]: M[K] extends RunType<infer V> ? V : never;
+    };
+} : unknown) & (P extends {
+    propertyNames: RunType<infer K extends string>;
+} ? {
+    readonly propertyNames: K;
+} : unknown)>;
+export type FormattedObjectFrom<T extends object, P> = FormattedObject<T, Extract<ObjectParamsType<P>, FormattedObjectParams>>;
+export {};

package/dist/cjs/formats/structural.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FORMATTED_MAP_NAME = exports.FORMATTED_SET_NAME = exports.FORMATTED_OBJECT_NAME = exports.FORMATTED_ARRAY_NAME = void 0;
+exports.FORMATTED_ARRAY_NAME = 'formattedArray';
+exports.FORMATTED_OBJECT_NAME = 'formattedObject';
+exports.FORMATTED_SET_NAME = 'formattedSet';
+exports.FORMATTED_MAP_NAME = 'formattedMap';

package/dist/cjs/getRunType.d.ts

@@ -0,0 +1,4 @@
+import type { InjectRunTypeId } from './markers.ts';
+import type { RunType } from './runtypes/types.ts';
+export declare function getRunType<T>(runType: RunType<T>, id?: InjectRunTypeId<T>): RunType<T>;
+export declare function getRunType<T>(_value?: T, id?: InjectRunTypeId<T>): RunType<T>;

package/dist/cjs/getRunType.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRunType = getRunType;
+const rtUtils_ts_1 = require("./runtypes/rtUtils.js");
+const entryTuple_ts_1 = require("./runtypes/entryTuple.js");
+function getRunType(_valueOrSchema, id) {
+    let injectedId = id;
+    if ((0, entryTuple_ts_1.isEntryTuple)(id)) {
+        (0, entryTuple_ts_1.initFromTuple)(id);
+        injectedId = (0, entryTuple_ts_1.entryTupleKey)(id);
+    }
+    if (injectedId === undefined) {
+        throw new Error('getRunType(): no id injected. @mionjs/devtools must be active.');
+    }
+    const runType = (0, rtUtils_ts_1.getRTUtils)().getRunType(injectedId);
+    if (!runType) {
+        throw new Error(`getRunType(): no RunType entry for "${injectedId}" in rtUtils. The build pipeline didn't emit a cache entry for that runtype.`);
+    }
+    return runType;
+}

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

@@ -0,0 +1,196 @@
+export type FnHashAxis = 'none' | 'validateOptions' | 'jsonStrategy';
+export interface FnHashEntry {
+    readonly axis: FnHashAxis;
+    readonly defaultVariant?: string;
+    readonly circularGuarded?: true;
+    readonly variants: Readonly<Record<string, string>>;
+}
+export declare const FN_HASHES: {
+    readonly classSerializerReg: {
+        readonly axis: "none";
+        readonly variants: {
+            readonly '': "fGyS";
+        };
+    };
+    readonly compactForJson: {
+        readonly axis: "none";
+        readonly variants: {
+            readonly '': "rpEK";
+        };
+    };
+    readonly compactFromJson: {
+        readonly axis: "none";
+        readonly variants: {
+            readonly '': "FFsn";
+        };
+    };
+    readonly formatTransform: {
+        readonly axis: "none";
+        readonly variants: {
+            readonly '': "mzca";
+        };
+    };
+    readonly jsonDecoder: {
+        readonly axis: "jsonStrategy";
+        readonly defaultVariant: "clone";
+        readonly variants: {
+            readonly clone: "xXCs";
+            readonly compact: "hoBv";
+            readonly mutate: "TqQA";
+        };
+    };
+    readonly jsonEncoder: {
+        readonly axis: "jsonStrategy";
+        readonly defaultVariant: "clone";
+        readonly circularGuarded: true;
+        readonly variants: {
+            readonly clone: "tx9T";
+            readonly cloneC: "ZLjB";
+            readonly compact: "FL2w";
+            readonly compactC: "D9wa";
+            readonly mutate: "l3Wy";
+            readonly mutateC: "E23P";
+        };
+    };
+    readonly jsonSchema: {
+        readonly axis: "none";
+        readonly variants: {
+            readonly '': "VwiH";
+        };
+    };
+    readonly prepareForJsonClone: {
+        readonly axis: "none";
+        readonly variants: {
+            readonly '': "A0Qb";
+        };
+    };
+    readonly prepareForJsonMutate: {
+        readonly axis: "none";
+        readonly variants: {
+            readonly '': "AwYs";
+        };
+    };
+    readonly removeUnknownKeys: {
+        readonly axis: "none";
+        readonly variants: {
+            readonly '': "C85b";
+        };
+    };
+    readonly removeUnknownKeysRefuse: {
+        readonly axis: "none";
+        readonly variants: {
+            readonly '': "lJ3b";
+        };
+    };
+    readonly removeUnknownKeysShared: {
+        readonly axis: "none";
+        readonly variants: {
+            readonly '': "LMn9";
+        };
+    };
+    readonly restoreFromJsonClone: {
+        readonly axis: "none";
+        readonly variants: {
+            readonly '': "Ky89";
+        };
+    };
+    readonly restoreFromJsonMutate: {
+        readonly axis: "none";
+        readonly variants: {
+            readonly '': "w8ie";
+        };
+    };
+    readonly validate: {
+        readonly axis: "validateOptions";
+        readonly circularGuarded: true;
+        readonly variants: {
+            readonly '': "Eq2V";
+            readonly C: "VpZY";
+            readonly NM: "PHIy";
+            readonly NMC: "STwe";
+            readonly NT: "WOvb";
+            readonly NTC: "Tq25";
+        };
+    };
+    readonly validateStrict: {
+        readonly axis: "validateOptions";
+        readonly circularGuarded: true;
+        readonly variants: {
+            readonly '': "fZHy";
+            readonly C: "ljLE";
+            readonly NM: "EwD7";
+            readonly NMC: "dobr";
+            readonly NT: "gAsC";
+            readonly NTC: "Oz5j";
+        };
+    };
+    readonly validateUnionKeys: {
+        readonly axis: "validateOptions";
+        readonly circularGuarded: true;
+        readonly variants: {
+            readonly '': "Xhuv";
+            readonly C: "H97o";
+            readonly NM: "NX1L";
+            readonly NMC: "qzkT";
+            readonly NT: "BhE9";
+            readonly NTC: "q7RI";
+        };
+    };
+    readonly validationErrors: {
+        readonly axis: "validateOptions";
+        readonly circularGuarded: true;
+        readonly variants: {
+            readonly '': "swxg";
+            readonly C: "UYW2";
+            readonly NM: "zncs";
+            readonly NMC: "VTY9";
+            readonly NT: "aZak";
+            readonly NTC: "hjJf";
+        };
+    };
+    readonly validationErrorsStrict: {
+        readonly axis: "validateOptions";
+        readonly circularGuarded: true;
+        readonly variants: {
+            readonly '': "OB5g";
+            readonly C: "c6EY";
+            readonly NM: "TGyU";
+            readonly NMC: "k7iN";
+            readonly NT: "ikAJ";
+            readonly NTC: "ypxr";
+        };
+    };
+    readonly validationErrorsUnionKeys: {
+        readonly axis: "validateOptions";
+        readonly circularGuarded: true;
+        readonly variants: {
+            readonly '': "OBOg";
+            readonly C: "O8IR";
+            readonly NM: "zAg4";
+            readonly NMC: "Yu6R";
+            readonly NT: "X6fx";
+            readonly NTC: "bEtz";
+        };
+    };
+};
+export declare const FAMILY_TAG_TO_FN_KEY: {
+    readonly cj: "compactForJson";
+    readonly cjr: "compactFromJson";
+    readonly csr: "classSerializerReg";
+    readonly fmt: "formatTransform";
+    readonly jsc: "jsonSchema";
+    readonly pj: "prepareForJsonMutate";
+    readonly pjs: "prepareForJsonClone";
+    readonly rj: "restoreFromJsonMutate";
+    readonly rjs: "restoreFromJsonClone";
+    readonly ruk: "removeUnknownKeys";
+    readonly rukr: "removeUnknownKeysRefuse";
+    readonly ruks: "removeUnknownKeysShared";
+    readonly val: "validate";
+    readonly verr: "validationErrors";
+    readonly vest: "validationErrorsStrict";
+    readonly veuk: "validationErrorsUnionKeys";
+    readonly vst: "validateStrict";
+    readonly vuk: "validateUnionKeys";
+};
+export declare const VALIDATE_OPTION_LETTERS: readonly [readonly ["numberTypeof", "T"], readonly ["numberNotNaN", "M"]];

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

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VALIDATE_OPTION_LETTERS = exports.FAMILY_TAG_TO_FN_KEY = exports.FN_HASHES = void 0;
+exports.FN_HASHES = {
+    classSerializerReg: { axis: 'none', variants: { '': 'fGyS' } },
+    compactForJson: { axis: 'none', variants: { '': 'rpEK' } },
+    compactFromJson: { axis: 'none', variants: { '': 'FFsn' } },
+    formatTransform: { axis: 'none', variants: { '': 'mzca' } },
+    jsonDecoder: { axis: 'jsonStrategy', defaultVariant: 'clone', variants: { clone: 'xXCs', compact: 'hoBv', mutate: 'TqQA' } },
+    jsonEncoder: {
+        axis: 'jsonStrategy',
+        defaultVariant: 'clone',
+        circularGuarded: true,
+        variants: { clone: 'tx9T', cloneC: 'ZLjB', compact: 'FL2w', compactC: 'D9wa', mutate: 'l3Wy', mutateC: 'E23P' },
+    },
+    jsonSchema: { axis: 'none', variants: { '': 'VwiH' } },
+    prepareForJsonClone: { axis: 'none', variants: { '': 'A0Qb' } },
+    prepareForJsonMutate: { axis: 'none', variants: { '': 'AwYs' } },
+    removeUnknownKeys: { axis: 'none', variants: { '': 'C85b' } },
+    removeUnknownKeysRefuse: { axis: 'none', variants: { '': 'lJ3b' } },
+    removeUnknownKeysShared: { axis: 'none', variants: { '': 'LMn9' } },
+    restoreFromJsonClone: { axis: 'none', variants: { '': 'Ky89' } },
+    restoreFromJsonMutate: { axis: 'none', variants: { '': 'w8ie' } },
+    validate: {
+        axis: 'validateOptions',
+        circularGuarded: true,
+        variants: { '': 'Eq2V', C: 'VpZY', NM: 'PHIy', NMC: 'STwe', NT: 'WOvb', NTC: 'Tq25' },
+    },
+    validateStrict: {
+        axis: 'validateOptions',
+        circularGuarded: true,
+        variants: { '': 'fZHy', C: 'ljLE', NM: 'EwD7', NMC: 'dobr', NT: 'gAsC', NTC: 'Oz5j' },
+    },
+    validateUnionKeys: {
+        axis: 'validateOptions',
+        circularGuarded: true,
+        variants: { '': 'Xhuv', C: 'H97o', NM: 'NX1L', NMC: 'qzkT', NT: 'BhE9', NTC: 'q7RI' },
+    },
+    validationErrors: {
+        axis: 'validateOptions',
+        circularGuarded: true,
+        variants: { '': 'swxg', C: 'UYW2', NM: 'zncs', NMC: 'VTY9', NT: 'aZak', NTC: 'hjJf' },
+    },
+    validationErrorsStrict: {
+        axis: 'validateOptions',
+        circularGuarded: true,
+        variants: { '': 'OB5g', C: 'c6EY', NM: 'TGyU', NMC: 'k7iN', NT: 'ikAJ', NTC: 'ypxr' },
+    },
+    validationErrorsUnionKeys: {
+        axis: 'validateOptions',
+        circularGuarded: true,
+        variants: { '': 'OBOg', C: 'O8IR', NM: 'zAg4', NMC: 'Yu6R', NT: 'X6fx', NTC: 'bEtz' },
+    },
+};
+exports.FAMILY_TAG_TO_FN_KEY = {
+    cj: 'compactForJson',
+    cjr: 'compactFromJson',
+    csr: 'classSerializerReg',
+    fmt: 'formatTransform',
+    jsc: 'jsonSchema',
+    pj: 'prepareForJsonMutate',
+    pjs: 'prepareForJsonClone',
+    rj: 'restoreFromJsonMutate',
+    rjs: 'restoreFromJsonClone',
+    ruk: 'removeUnknownKeys',
+    rukr: 'removeUnknownKeysRefuse',
+    ruks: 'removeUnknownKeysShared',
+    val: 'validate',
+    verr: 'validationErrors',
+    vest: 'validationErrorsStrict',
+    veuk: 'validationErrorsUnionKeys',
+    vst: 'validateStrict',
+    vuk: 'validateUnionKeys',
+};
+exports.VALIDATE_OPTION_LETTERS = [
+    ['numberTypeof', 'T'],
+    ['numberNotNaN', 'M'],
+];

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

@@ -0,0 +1,78 @@
+export type FormatErrorKeys = {
+    bigintFormat: 'gt' | 'lt' | 'max' | 'min' | 'multipleOf';
+    creditCard: 'creditCard' | 'networks';
+    date: 'format' | 'gt' | 'lt' | 'max' | 'min';
+    dateTime: 'date' | 'gt' | 'lt' | 'max' | 'min' | 'splitChar' | 'time';
+    domain: 'allowedValues' | 'hyphen' | 'idna' | 'maxLength' | 'maxParts' | 'minLength' | 'minParts' | 'pattern';
+    email: '@' | 'emailRfc' | 'hyphen' | 'maxLength' | 'maxParts' | 'minLength' | 'minParts' | 'pattern';
+    formattedArray: 'maxItems' | 'minItems' | 'uniqueItems';
+    formattedMap: 'maxItems' | 'minItems' | 'uniqueItems';
+    formattedObject: 'closed' | 'maxProperties' | 'minProperties';
+    formattedSet: 'maxItems' | 'minItems' | 'uniqueItems';
+    ip: 'version';
+    nativeDate: 'gt' | 'lt' | 'max' | 'min';
+    nativeUrl: 'maxLength' | 'minLength' | 'pattern';
+    numberFormat: 'gt' | 'integer' | 'lt' | 'max' | 'min' | 'multipleOf';
+    stringFormat: 'allowedChars' | 'allowedValues' | 'contentMediaType' | 'disallowedChars' | 'disallowedValues' | 'isRegex' | 'length' | 'maxLength' | 'minLength' | 'pattern';
+    temporalInstant: 'gt' | 'lt' | 'max' | 'min';
+    temporalPlainDate: 'gt' | 'lt' | 'max' | 'min';
+    temporalPlainDateTime: 'gt' | 'lt' | 'max' | 'min';
+    temporalPlainTime: 'gt' | 'lt' | 'max' | 'min';
+    temporalPlainYearMonth: 'gt' | 'lt' | 'max' | 'min';
+    temporalZonedDateTime: 'gt' | 'lt' | 'max' | 'min';
+    time: 'format' | 'gt' | 'lt' | 'max' | 'min';
+    url: 'maxLength' | 'minLength' | 'pattern';
+    uuid: 'version';
+};
+export declare const FORMAT_ERROR_KEYS: {
+    readonly bigintFormat: readonly ["gt", "lt", "max", "min", "multipleOf"];
+    readonly creditCard: readonly ["creditCard", "networks"];
+    readonly date: readonly ["format", "gt", "lt", "max", "min"];
+    readonly dateTime: readonly ["date", "gt", "lt", "max", "min", "splitChar", "time"];
+    readonly domain: readonly ["allowedValues", "hyphen", "idna", "maxLength", "maxParts", "minLength", "minParts", "pattern"];
+    readonly email: readonly ["@", "emailRfc", "hyphen", "maxLength", "maxParts", "minLength", "minParts", "pattern"];
+    readonly formattedArray: readonly ["maxItems", "minItems", "uniqueItems"];
+    readonly formattedMap: readonly ["maxItems", "minItems", "uniqueItems"];
+    readonly formattedObject: readonly ["closed", "maxProperties", "minProperties"];
+    readonly formattedSet: readonly ["maxItems", "minItems", "uniqueItems"];
+    readonly ip: readonly ["version"];
+    readonly nativeDate: readonly ["gt", "lt", "max", "min"];
+    readonly nativeUrl: readonly ["maxLength", "minLength", "pattern"];
+    readonly numberFormat: readonly ["gt", "integer", "lt", "max", "min", "multipleOf"];
+    readonly stringFormat: readonly ["allowedChars", "allowedValues", "contentMediaType", "disallowedChars", "disallowedValues", "isRegex", "length", "maxLength", "minLength", "pattern"];
+    readonly temporalInstant: readonly ["gt", "lt", "max", "min"];
+    readonly temporalPlainDate: readonly ["gt", "lt", "max", "min"];
+    readonly temporalPlainDateTime: readonly ["gt", "lt", "max", "min"];
+    readonly temporalPlainTime: readonly ["gt", "lt", "max", "min"];
+    readonly temporalPlainYearMonth: readonly ["gt", "lt", "max", "min"];
+    readonly temporalZonedDateTime: readonly ["gt", "lt", "max", "min"];
+    readonly time: readonly ["format", "gt", "lt", "max", "min"];
+    readonly url: readonly ["maxLength", "minLength", "pattern"];
+    readonly uuid: readonly ["version"];
+};
+export type FormatSampledParams = {
+    bigintFormat: 'exclusiveMaximum' | 'exclusiveMinimum' | 'gt' | 'lt' | 'max' | 'maximum' | 'min' | 'minimum' | 'multipleOf';
+    creditCard: 'networks' | 'separators' | 'transform';
+    date: 'exclusiveMaximum' | 'exclusiveMinimum' | 'format' | 'gt' | 'lt' | 'max' | 'maximum' | 'min' | 'minimum';
+    dateTime: 'date' | 'exclusiveMaximum' | 'exclusiveMinimum' | 'gt' | 'lt' | 'max' | 'maximum' | 'min' | 'minimum' | 'splitChar' | 'time';
+    domain: 'allowedValues' | 'idna' | 'maxLength' | 'maxParts' | 'minLength' | 'minParts' | 'mockSamples' | 'names' | 'pattern' | 'tld' | 'transform';
+    email: 'domain' | 'emailRfc' | 'localPart' | 'maxLength' | 'minLength' | 'mockSamples' | 'pattern' | 'transform';
+    formattedArray: 'contains' | 'maxContains' | 'maxItems' | 'minContains' | 'minItems' | 'uniqueItems';
+    formattedMap: 'contains' | 'maxContains' | 'maxItems' | 'minContains' | 'minItems' | 'uniqueItems';
+    formattedObject: 'additionalOwn' | 'closed' | 'closedPatterns' | 'maxProperties' | 'minProperties' | 'patternProperties' | 'propertyNames';
+    formattedSet: 'contains' | 'maxContains' | 'maxItems' | 'minContains' | 'minItems' | 'uniqueItems';
+    ip: 'allowLocalHost' | 'allowPort' | 'transform' | 'version';
+    nativeDate: 'exclusiveMaximum' | 'exclusiveMinimum' | 'gt' | 'lt' | 'max' | 'maximum' | 'min' | 'minimum';
+    nativeUrl: 'maxLength' | 'minLength' | 'mockSamples' | 'pattern';
+    numberFormat: 'exclusiveMaximum' | 'exclusiveMinimum' | 'float' | 'gt' | 'integer' | 'isCurrency' | 'lt' | 'max' | 'maximum' | 'min' | 'minimum' | 'multipleOf' | 'multipleOfTolerance';
+    stringFormat: 'allowedChars' | 'allowedValues' | 'contentEncoding' | 'contentMediaType' | 'disallowedChars' | 'disallowedValues' | 'isRegex' | 'length' | 'maxLength' | 'minLength' | 'mockSamples' | 'pattern' | 'transform';
+    temporalInstant: 'exclusiveMaximum' | 'exclusiveMinimum' | 'gt' | 'lt' | 'max' | 'maximum' | 'min' | 'minimum';
+    temporalPlainDate: 'exclusiveMaximum' | 'exclusiveMinimum' | 'gt' | 'lt' | 'max' | 'maximum' | 'min' | 'minimum';
+    temporalPlainDateTime: 'exclusiveMaximum' | 'exclusiveMinimum' | 'gt' | 'lt' | 'max' | 'maximum' | 'min' | 'minimum';
+    temporalPlainTime: 'exclusiveMaximum' | 'exclusiveMinimum' | 'gt' | 'lt' | 'max' | 'maximum' | 'min' | 'minimum';
+    temporalPlainYearMonth: 'exclusiveMaximum' | 'exclusiveMinimum' | 'gt' | 'lt' | 'max' | 'maximum' | 'min' | 'minimum';
+    temporalZonedDateTime: 'exclusiveMaximum' | 'exclusiveMinimum' | 'gt' | 'lt' | 'max' | 'maximum' | 'min' | 'minimum';
+    time: 'exclusiveMaximum' | 'exclusiveMinimum' | 'format' | 'gt' | 'lt' | 'max' | 'maximum' | 'min' | 'minimum';
+    url: 'maxLength' | 'minLength' | 'mockSamples' | 'pattern' | 'transform';
+    uuid: 'version';
+};

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FORMAT_ERROR_KEYS = void 0;
+exports.FORMAT_ERROR_KEYS = {
+    bigintFormat: ['gt', 'lt', 'max', 'min', 'multipleOf'],
+    creditCard: ['creditCard', 'networks'],
+    date: ['format', 'gt', 'lt', 'max', 'min'],
+    dateTime: ['date', 'gt', 'lt', 'max', 'min', 'splitChar', 'time'],
+    domain: ['allowedValues', 'hyphen', 'idna', 'maxLength', 'maxParts', 'minLength', 'minParts', 'pattern'],
+    email: ['@', 'emailRfc', 'hyphen', 'maxLength', 'maxParts', 'minLength', 'minParts', 'pattern'],
+    formattedArray: ['maxItems', 'minItems', 'uniqueItems'],
+    formattedMap: ['maxItems', 'minItems', 'uniqueItems'],
+    formattedObject: ['closed', 'maxProperties', 'minProperties'],
+    formattedSet: ['maxItems', 'minItems', 'uniqueItems'],
+    ip: ['version'],
+    nativeDate: ['gt', 'lt', 'max', 'min'],
+    nativeUrl: ['maxLength', 'minLength', 'pattern'],
+    numberFormat: ['gt', 'integer', 'lt', 'max', 'min', 'multipleOf'],
+    stringFormat: [
+        'allowedChars',
+        'allowedValues',
+        'contentMediaType',
+        'disallowedChars',
+        'disallowedValues',
+        'isRegex',
+        'length',
+        'maxLength',
+        'minLength',
+        'pattern',
+    ],
+    temporalInstant: ['gt', 'lt', 'max', 'min'],
+    temporalPlainDate: ['gt', 'lt', 'max', 'min'],
+    temporalPlainDateTime: ['gt', 'lt', 'max', 'min'],
+    temporalPlainTime: ['gt', 'lt', 'max', 'min'],
+    temporalPlainYearMonth: ['gt', 'lt', 'max', 'min'],
+    temporalZonedDateTime: ['gt', 'lt', 'max', 'min'],
+    time: ['format', 'gt', 'lt', 'max', 'min'],
+    url: ['maxLength', 'minLength', 'pattern'],
+    uuid: ['version'],
+};