@arrirpc/schema 0.73.0 → 0.74.1

package/dist/index.mjs

@@ -1,12 +1,33 @@
 import { isSchemaFormProperties, isSchemaFormValues, isSchemaFormElements, isSchemaFormDiscriminator, isSchemaFormEmpty, isSchemaFormType, isSchemaFormEnum, isSchemaFormRef } from '@arrirpc/type-defs';
+import { i as isAScalarSchema, a as isAObjectSchema, b as isAStringEnumSchema, c as isAAraySchema, d as isARecordSchema, e as isADiscriminatorSchema, f as isARefSchema, g as createStandardSchemaProperty, n as newValidationContext, h as hideInvalidProperties, V as VALIDATOR_KEY, j as isObject } from './shared/schema.CZrExOkx.mjs';
+export { N as NumberTypeValues, k as isASchema } from './shared/schema.CZrExOkx.mjs';
 import { camelCase } from 'scule';
-import { u as uint8Max, a as uint8Min, b as uint16Max, c as uint16Min, d as uint32Max, e as uint32Min, i as int8Max, f as int8Min, g as int16Max, h as int16Min, j as int32Max, k as int32Min, l as isAScalarSchema, m as isAObjectSchema, n as isAStringEnumSchema, o as isAAraySchema, p as isARecordSchema, q as isADiscriminatorSchema, r as isARefSchema, s as errors, V as ValidationError, t as createStandardSchemaProperty, v as any, w as array, x as boolean, y as clone, z as coerce, A as discriminator, B as enumerator, C as extend, D as float32, E as float64, F as int16, G as int32, H as int64, I as int8, J as nullable, K as number, L as object, M as omit, N as optional, O as parse, P as partial, Q as pick, R as record, S as recursive, T as safeCoerce, U as safeParse, W as serialize, X as string, Y as stringEnum, Z as timestamp, _ as uint16, $ as uint32, a0 as uint64, a1 as uint8, a2 as validate, a3 as SCHEMA_METADATA } from './shared/schema.PNAcAdz3.mjs';
-export { ah as NumberTypeValues, ac as STR_ESCAPE, aj as hideInvalidProperties, a5 as int64Max, a4 as int64Min, ag as isASchema, ai as isObject, af as isValidationError, a8 as parseObjectSchema, ae as sanitizeJson, aa as serializeObject, ad as serializeSmallString, ab as serializeString, a7 as uint64Max, a6 as uint64Min, a9 as validateObjectSchema } from './shared/schema.PNAcAdz3.mjs';
 
-function createParsingTemplate(input, schema) {
+const int8Min = -128;
+const int8Max = 127;
+const uint8Min = 0;
+const uint8Max = 255;
+const int16Min = -32768;
+const int16Max = 32767;
+const uint16Min = 0;
+const uint16Max = 65535;
+const int32Min = -2147483648;
+const int32Max = 2147483647;
+const uint32Min = 0;
+const uint32Max = 4294967295;
+const int64Min = BigInt("-9223372036854775808");
+const int64Max = BigInt("9223372036854775807");
+const uint64Min = BigInt("0");
+const uint64Max = BigInt("18446744073709551615");
+
+function createParsingTemplate(input, schema, shouldCoerce = false) {
   const fallbackTemplate = `
-    function $fallback(instancePath, schemaPath) {
-        throw new Error(\`Error parsing input. InstancePath: "\${instancePath}". SchemaPath: "\${schemaPath}"\`);
+    function $fallback(instancePath, schemaPath, message) {
+        context.errors.push({
+            message: message,
+            instancePath: instancePath,
+            schemaPath: schemaPath,
+        })
     }`;
   let jsonParseCheck = "";
   const subFunctions = {};
@@ -16,7 +37,8 @@ function createParsingTemplate(input, schema) {
     schema,
     instancePath: "",
     schemaPath: "",
-    subFunctions
+    subFunctions,
+    shouldCoerce
   });
   const jsonTemplate = schemaTemplate$1({
     val: "json",
@@ -24,7 +46,8 @@ function createParsingTemplate(input, schema) {
     schema,
     instancePath: "",
     schemaPath: "",
-    subFunctions
+    subFunctions,
+    shouldCoerce
   });
   if (isSchemaFormProperties(schema) || isSchemaFormValues(schema) || isSchemaFormElements(schema) || isSchemaFormDiscriminator(schema)) {
     jsonParseCheck = `if (typeof ${input} === 'string') {
@@ -114,8 +137,27 @@ function anyTemplate$1(input) {
   return `${input.targetVal} = ${input.val}`;
 }
 function booleanTemplate$2(input) {
-  const errorMessage = input.instancePath.length ? `Expected boolean for ${input.instancePath}` : `Expected boolean`;
+  const errorMessage = "expected boolean";
   const templateParts = [];
+  if (input.shouldCoerce) {
+    templateParts.push(`if (${input.val} === true || ${input.val} === 'true' || ${input.val} === 'TRUE' || ${input.val} === 1 || ${input.val} === '1') {
+                ${input.targetVal} = true;
+            }
+            else if (${input.val} === false || ${input.val} === 'false' || ${input.val} === 'FALSE' || ${input.val} === 0 || ${input.val} === '0') {
+                ${input.targetVal} = false;
+            }`);
+    if (input.schema.nullable) {
+      templateParts.push(`else if (${input.val} === null || ${input.val} === 'null') {
+                    ${input.targetVal} = null;
+                }`);
+    }
+    templateParts.push(
+      `else {
+                $fallback("${input.instancePath}", "${input.schemaPath}/type", "${errorMessage}");
+            }`
+    );
+    return templateParts.join("\n");
+  }
   if (input.instancePath.length === 0) {
     templateParts.push(`if (typeof ${input.val} === 'string') {
             if (${input.val} === 'true') {
@@ -151,7 +193,7 @@ function booleanTemplate$2(input) {
   return templateParts.join("\n");
 }
 function stringTemplate$2(input) {
-  const errorMessage = `Expected string at ${input.instancePath}`;
+  const errorMessage = `expected string`;
   const mainTemplate = `if (typeof ${input.val} === 'string') {
         ${input.targetVal} = ${input.val};
     } else {
@@ -174,19 +216,21 @@ function getVarName(input) {
 function floatTemplate$1(input) {
   const valName = getVarName(`${input.val}Val`);
   const templateParts = [];
-  if (input.instancePath.length === 0) {
+  if (input.instancePath.length === 0 || input.shouldCoerce) {
     templateParts.push(`if (typeof ${input.val} === 'string') {
             const ${valName} = Number(${input.val});
-            if (!Number.isNaN(parsedVal)) {
+            if (!Number.isNaN(${valName})) {
                 ${input.targetVal} = ${valName};
             }`);
     if (input.schema.nullable) {
-      templateParts.push(`if (${input.val} === 'null') {
+      templateParts.push(`else if (${input.val} === 'null') {
                 ${input.targetVal} = null;
             }`);
     }
     templateParts.push(
-      `$fallback("${input.instancePath}", "${input.schemaPath}/type", \`Could not parse number from \${${input.val}}\`);`
+      `else { 
+                $fallback("${input.instancePath}", "${input.schemaPath}/type", \`Could not parse number from \${${input.val}}\`);
+            }`
     );
     templateParts.push("}");
   }
@@ -197,31 +241,36 @@ function floatTemplate$1(input) {
         $fallback("${input.instancePath}", "${input.schemaPath}/type", "${errorMessage}");
     }`;
   if (input.schema.nullable) {
-    templateParts.push(`if (${input.val} === null) {
+    templateParts.push(`${input.instancePath.length === 0 || input.shouldCoerce ? "else " : ""}if (${input.val} === null) {
             ${input.targetVal} = null;
         } else {
             ${mainTemplate}
         }`);
   } else {
-    templateParts.push(mainTemplate);
+    templateParts.push(
+      `${input.instancePath.length === 0 || input.shouldCoerce ? "else " : ""}${mainTemplate}`
+    );
   }
   return templateParts.join("\n");
 }
 function intTemplate$1(input, min, max) {
   const templateParts = [];
-  if (input.instancePath.length === 0) {
+  const shouldCoerce = input.shouldCoerce || input.instancePath.length === 0;
+  if (shouldCoerce) {
     templateParts.push(`if (typeof ${input.val} === 'string') {
             const parsedVal = Number(${input.val});
             if (Number.isInteger(parsedVal) && parsedVal >= ${min} && parsedVal <= ${max}) {
-                ${input.targetVal} = ${input.val};
+                ${input.targetVal} = parsedVal;
             }`);
     if (input.schema.nullable) {
-      templateParts.push(`if (${input.val} === 'null') {
+      templateParts.push(`else if (${input.val} === 'null') {
                 ${input.targetVal} = null;
             }`);
     }
     templateParts.push(
-      `$fallback("${input.instancePath}", "${input.schemaPath}", "Expected valid integer between ${min} and ${max});`
+      `else {
+                $fallback("${input.instancePath}", "${input.schemaPath}", "Expected valid integer between ${min} and ${max}");
+            }`
     );
     templateParts.push("}");
   }
@@ -230,14 +279,15 @@ function intTemplate$1(input, min, max) {
         } else {
             $fallback("${input.instancePath}", "${input.schemaPath}", "Expected valid integer between ${min} and ${max}");
         }`;
+  const prefix = shouldCoerce ? `else ` : "";
   if (input.schema.nullable) {
-    templateParts.push(`if (${input.val} === null) {
+    templateParts.push(`${prefix}if (${input.val} === null) {
             ${input.targetVal} = null;
         } else {
             ${mainTemplate}
         }`);
   } else {
-    templateParts.push(mainTemplate);
+    templateParts.push(prefix + mainTemplate);
   }
   return templateParts.join("\n");
 }
@@ -246,7 +296,7 @@ function bigIntTemplate$2(input, isUnsigned) {
   templateParts.push(
     `if (typeof ${input.val} === 'string' || typeof ${input.val} === 'number') {`
   );
-  if (input.instancePath.length === 0 && input.schema.nullable) {
+  if ((input.instancePath.length === 0 || input.shouldCoerce) && input.schema.nullable) {
     templateParts.push(`if (${input.val} === 'null') {
             ${input.targetVal} = null;
         } else {`);
@@ -263,9 +313,9 @@ function bigIntTemplate$2(input, isUnsigned) {
     templateParts.push(`${input.targetVal} = val;`);
   }
   templateParts.push(`} catch(err) {
-        $fallback("${input.instancePath}", "${input.schemaPath}", "Unable to parse BigInt from ${input.val}.");
+        $fallback("${input.instancePath}", "${input.schemaPath}", \`Unable to parse BigInt from \${${input.val}}\`);
     }`);
-  if (input.instancePath.length === 0 && input.schema.nullable) {
+  if ((input.instancePath.length === 0 || input.shouldCoerce) && input.schema.nullable) {
     templateParts.push("}");
   }
   templateParts.push("}");
@@ -288,12 +338,41 @@ function bigIntTemplate$2(input, isUnsigned) {
         }`);
   }
   templateParts.push(`else {
-        $fallback("${input.instancePath}", "${input.schemaPath}", "Expected BigInt or Integer string. Got \${${input.val}}");
+        $fallback("${input.instancePath}", "${input.schemaPath}", \`Expected BigInt or Integer string. Got \${${input.val}}\`);
     }`);
   return templateParts.join("\n");
 }
 function timestampTemplate$2(input) {
   const templateParts = [];
+  if (input.shouldCoerce) {
+    return `if (typeof ${input.val} === 'string') {
+            try {
+                const parsedVal = new Date(${input.val});
+                if (!Number.isNaN(parsedVal.getMonth())) {
+                    ${input.targetVal} = parsedVal;
+                } ${input.schema.nullable ? `else if (${input.val} === 'null') {
+                                ${input.targetVal} = null;
+                            }` : ""} else {
+                    $fallback("${input.instancePath}", "${input.schemaPath}", "Unable to coerce date"); 
+                }
+            } catch (err) {
+                $fallback("${input.instancePath}", "${input.schemaPath}", "Unable to parse date"); 
+            }    
+        } else if (typeof ${input.val} === 'number') {
+            const parsedVal = new Date(${input.val});
+            if (!Number.isNaN(parsedVal.getMonth())) {
+                ${input.targetVal} = parsedVal;
+            } else {
+                $fallback("${input.instancePath}", "${input.schemaPath}", "Unable to parse date");  
+            }
+        } else if (typeof ${input.val} === 'object' && ${input.val} instanceof Date) {
+            ${input.targetVal} = ${input.val};
+        }${input.schema.nullable ? ` else if (${input.val} === null) {
+                    ${input.targetVal} = null;    
+                }` : ""} else {
+                $fallback("${input.instancePath}", "${input.schemaPath}", "Unable to parse date");  
+            }`;
+  }
   if (input.instancePath.length === 0) {
     templateParts.push(`if (typeof ${input.val} === 'string') {
             const parsedVal = new Date(${input.val});
@@ -315,7 +394,7 @@ function timestampTemplate$2(input) {
     } else if (typeof ${input.val} === 'string') {
         ${input.targetVal} = new Date(${input.val});
     } else {
-        $fallback("${input.instancePath}", "${input.schemaPath}", "Expected instanceof Date or ISO Date string at ${input.instancePath}")
+        $fallback("${input.instancePath}", "${input.schemaPath}", "Expected instanceof Date or ISO Date string")
     }`;
   if (input.schema.nullable) {
     templateParts.push(`if (${input.val} === null) {
@@ -332,7 +411,7 @@ function enumTemplate$2(input) {
   const enumTemplate2 = input.schema.enum.map((val) => `${input.val} === "${val}"`).join(" || ");
   const errorMessage = `Expected one of the following values: [${input.schema.enum.join(
     ", "
-  )}]${input.instancePath.length ? ` at ${input.instancePath}` : ""}.`;
+  )}]`;
   const templateParts = [];
   templateParts.push(`if (typeof ${input.val} === 'string') {
         if (${enumTemplate2}) {
@@ -395,7 +474,8 @@ function objectTemplate$2(input) {
       schema: subSchema,
       instancePath: `${input.instancePath}/${key}`,
       schemaPath: `${input.schemaPath}/properties/${key}`,
-      subFunctions: input.subFunctions
+      subFunctions: input.subFunctions,
+      shouldCoerce: input.shouldCoerce
     });
     parsingParts.push(innerTemplate);
   }
@@ -408,7 +488,8 @@ function objectTemplate$2(input) {
         schema: subSchema,
         instancePath: `${input.instancePath}/${key}`,
         schemaPath: `${input.schemaPath}/optionalProperties/${key}`,
-        subFunctions: input.subFunctions
+        subFunctions: input.subFunctions,
+        shouldCoerce: input.shouldCoerce
       });
       parsingParts.push(`if (typeof ${input.val}.${key} === 'undefined') {
                 // ignore undefined
@@ -451,10 +532,11 @@ function arrayTemplate$2(input) {
   const innerTemplate = schemaTemplate$1({
     val: itemVar,
     targetVal: itemResultVar,
-    instancePath: `${input.instancePath}/[0]`,
+    instancePath: `${input.instancePath}/[i]`,
     schemaPath: `${input.schemaPath}/elements`,
     schema: input.schema.elements,
-    subFunctions: input.subFunctions
+    subFunctions: input.subFunctions,
+    shouldCoerce: input.shouldCoerce
   });
   const mainTemplate = `if (Array.isArray(${input.val})) {
         const ${resultVar} = [];
@@ -489,7 +571,8 @@ function discriminatorTemplate$2(input) {
       instancePath: `${input.instancePath}`,
       discriminatorKey: input.schema.discriminator,
       discriminatorValue: type,
-      subFunctions: input.subFunctions
+      subFunctions: input.subFunctions,
+      shouldCoerce: input.shouldCoerce
     });
     switchParts.push(`case "${type}": {
             ${template}
@@ -542,7 +625,8 @@ function recordTemplate$2(input) {
     instancePath: `${input.instancePath}/[key]`,
     schemaPath: `${input.schemaPath}/values`,
     schema: input.schema.values,
-    subFunctions: input.subFunctions
+    subFunctions: input.subFunctions,
+    shouldCoerce: input.shouldCoerce
   });
   const mainTemplate = `if (typeof ${input.val} === 'object' && ${input.val} !== null) {
         const ${resultVal} = {};
@@ -592,8 +676,7 @@ function createSerializationV2Template(inputName, schema) {
     instancePath: "",
     outputPrefix: "",
     needsSanitization: [],
-    subFunctions
-  };
+    subFunctions};
   const result = template(context);
   if (isSchemaFormType(schema) || isSchemaFormEnum(schema)) {
     return result;
@@ -831,8 +914,7 @@ function objectTemplate$1(input) {
       schemaPath: `${input.schemaPath}/properties/${key}`,
       outputPrefix: includeComma ? `,"${key}":` : `"${key}":`,
       needsSanitization: input.needsSanitization,
-      subFunctions: input.subFunctions
-    });
+      subFunctions: input.subFunctions});
     templateParts.push(innerTemplate);
   }
   if (isAllOptionalKeys) {
@@ -855,8 +937,7 @@ function objectTemplate$1(input) {
         targetVal: input.targetVal,
         outputPrefix: `"${key}":`,
         needsSanitization: input.needsSanitization,
-        subFunctions: input.subFunctions
-      });
+        subFunctions: input.subFunctions});
       const innerTemplateWithComma = template({
         schema: optionalPropSchema,
         schemaPath: `${input.schemaPath}/optionalProperties/${key}`,
@@ -865,8 +946,7 @@ function objectTemplate$1(input) {
         targetVal: input.targetVal,
         outputPrefix: `,"${key}":`,
         needsSanitization: input.needsSanitization,
-        subFunctions: input.subFunctions
-      });
+        subFunctions: input.subFunctions});
       templateParts.push(`if (typeof ${innerVal} !== 'undefined') {
                 if (${hasFieldsVar}) {
                     ${innerTemplateWithComma}
@@ -892,8 +972,7 @@ function objectTemplate$1(input) {
         targetVal: "json",
         outputPrefix: `,"${key}":`,
         needsSanitization: input.needsSanitization,
-        subFunctions: input.subFunctions
-      });
+        subFunctions: input.subFunctions});
       const completeInnerTemplate = `if (typeof ${innerVal} !== 'undefined') {
                 ${innerTemplate}
             }`;
@@ -942,8 +1021,7 @@ function arrayTemplate$1(input) {
     targetVal: input.targetVal,
     outputPrefix: "",
     needsSanitization: input.needsSanitization,
-    subFunctions: input.subFunctions
-  });
+    subFunctions: input.subFunctions});
   templateParts.push(`for (let i = 0; i < ${input.val}.length; i++) {
         const ${itemVarName} = ${input.val}[i];
         if (i !== 0) {
@@ -976,8 +1054,7 @@ function recordTemplate$1(input) {
     targetVal: input.targetVal,
     outputPrefix: "",
     needsSanitization: input.needsSanitization,
-    subFunctions: input.subFunctions
-  });
+    subFunctions: input.subFunctions});
   templateParts.push(`for (let i = 0; i < ${keysVarName}.length; i++) {
         const key = ${keysVarName}[i];
         const innerVal = ${input.val}[key];
@@ -1045,8 +1122,7 @@ function discriminatorTemplate$1(input) {
       discriminatorValue: val,
       outputPrefix: input.outputPrefix,
       needsSanitization: input.needsSanitization,
-      subFunctions: input.subFunctions
-    });
+      subFunctions: input.subFunctions});
     templateParts.push(`case '${val}': {
             ${innerTemplate}
             break;
@@ -1114,12 +1190,10 @@ function createValidationTemplate(inputName, schema) {
   const subFunctions = {};
   const template = schemaTemplate({
     val: inputName,
-    targetVal: "",
     schema,
     schemaPath: ``,
     instancePath: "",
-    subFunctions
-  });
+    subFunctions});
   const subFunctionBodies = Object.keys(subFunctions).map(
     (key) => subFunctions[key]
   );
@@ -1239,9 +1313,7 @@ function objectTemplate(input) {
         schemaPath: `${input.schemaPath}/properties/${key}`,
         instancePath: `${input.instancePath}/${key}`,
         val: `${input.val}.${key}`,
-        targetVal: "",
-        subFunctions: input.subFunctions
-      })
+        subFunctions: input.subFunctions})
     );
   }
   if (input.schema.optionalProperties) {
@@ -1252,16 +1324,14 @@ function objectTemplate(input) {
         schemaPath: `${input.schemaPath}/optionalProperties/${key}`,
         instancePath: `${input.instancePath}/${key}`,
         val: `${input.val}.${key}`,
-        targetVal: "",
-        subFunctions: input.subFunctions
-      });
+        subFunctions: input.subFunctions});
       parts.push(
         `(typeof ${input.val}.${key} === 'undefined' || (${template}))`
       );
     }
   }
   let mainTemplate = parts.join(" && ");
-  const fnName = refFunctionName(input.schema.metadata.id ?? "");
+  const fnName = refFunctionName(input.schema.metadata?.id ?? "");
   if (Object.keys(input.subFunctions).includes(fnName)) {
     if (!input.subFunctions[fnName]) {
       input.subFunctions[fnName] = `function ${fnName}(input) {
@@ -1288,9 +1358,7 @@ function arrayTemplate(input) {
     instancePath: `${input.instancePath}/item`,
     schemaPath: `${input.schemaPath}/elements`,
     schema: input.schema.elements,
-    targetVal: "",
-    subFunctions: input.subFunctions
-  });
+    subFunctions: input.subFunctions});
   if (input.schema.nullable) {
     return `((Array.isArray(${input.val}) && ${input.val}.every((item) => ${innerTemplate})) || ${input.val} === null)`;
   }
@@ -1302,9 +1370,7 @@ function recordTemplate(input) {
     instancePath: `${input.instancePath}`,
     schemaPath: `${input.schemaPath}/values`,
     val: `${input.val}[key]`,
-    targetVal: "",
-    subFunctions: input.subFunctions
-  });
+    subFunctions: input.subFunctions});
   const mainTemplate = `typeof ${input.val} === 'object' && ${input.val} !== null && Object.keys(${input.val}).every((key) => ${subTemplate})`;
   if (input.schema.nullable) {
     return `((${mainTemplate}) || ${input.val} === null)`;
@@ -1321,18 +1387,16 @@ function discriminatorTemplate(input) {
     parts.push(
       objectTemplate({
         val: input.val,
-        targetVal: "",
         schema: subSchema,
         schemaPath: `${input.schemaPath}/mapping/${discriminatorVal}`,
         instancePath: input.instancePath,
         discriminatorKey: input.schema.discriminator,
         discriminatorValue: discriminatorVal,
-        subFunctions: input.subFunctions
-      })
+        subFunctions: input.subFunctions})
     );
   }
   let mainTemplate = `typeof ${input.val} === 'object' && ${input.val} !== null && (${parts.join(" || ")})`;
-  const fnName = refFunctionName(input.schema.metadata.id ?? "");
+  const fnName = refFunctionName(input.schema.metadata?.id ?? "");
   if (Object.keys(input.subFunctions).includes(fnName)) {
     if (!input.subFunctions[fnName]) {
       input.subFunctions[fnName] = `function ${fnName}(input) {
@@ -1360,108 +1424,211 @@ function refTemplate(input) {
   return `${fnName}(${input.val})`;
 }
 
+function isValueError(input) {
+  if (typeof input !== "object" || !input) {
+    return false;
+  }
+  return "message" in input && typeof input.message === "string" && (typeof input.instancePath === "undefined" || typeof input.instancePath === "string") && (typeof input.schemaPath === "undefined" || typeof input.schemaPath === "string");
+}
+function errorMessageFromErrors(errors) {
+  if (errors.length === 0) {
+    return `Input failed validation`;
+  }
+  if (errors.length === 1) {
+    return errors[0].message;
+  }
+  let propStr = "[";
+  for (let i = 0; i < errors.length; i++) {
+    const err = errors[i];
+    if (i > 0) {
+      propStr += ", ";
+    }
+    propStr += err.instancePath;
+  }
+  propStr += "]";
+  return `Invalid input. Affected properties ${propStr}.`;
+}
+class ValidationException extends Error {
+  errors;
+  constructor(options) {
+    super(options.message ?? errorMessageFromErrors(options.errors));
+    this.errors = options.errors;
+  }
+}
+function isValidationException(input) {
+  return input instanceof ValidationException;
+}
+
 function compile(schema) {
   const validateCode = createValidationTemplate("input", schema);
-  const parser = getCompiledParser("input", schema);
-  const parseFn = parser.fn;
+  const parser = getCompiledParser("input", schema, false);
+  const parserFn = parser.fn;
+  const coercer = getCompiledParser("input", schema, true);
+  const coercerFn = coercer.fn;
   const serializer = getCompiledSerializer(schema);
   const serializeFn = serializer.fn;
+  const serialize = (input) => {
+    try {
+      const result2 = serializeFn(input);
+      return {
+        success: true,
+        value: result2
+      };
+    } catch (err) {
+      return {
+        success: false,
+        errors: [
+          {
+            instancePath: "/",
+            message: err instanceof Error ? err.message : `${err}`
+          }
+        ]
+      };
+    }
+  };
   const validate = new Function("input", validateCode);
   const parse = (input) => {
+    const context = newValidationContext();
     try {
-      return parseFn(input);
+      const result2 = parserFn(input, context);
+      if (context.errors.length) {
+        return {
+          success: false,
+          errors: context.errors
+        };
+      }
+      return {
+        success: true,
+        value: result2
+      };
     } catch (err) {
-      const errors$1 = errors(schema, input);
-      let errorMessage = err instanceof Error ? err.message : "";
-      if (errors$1.length) {
-        errorMessage = errors$1[0].message ?? `Parsing error at ${errors$1[0].instancePath}`;
+      if (context.errors.length) {
+        return {
+          success: false,
+          errors: context.errors
+        };
       }
-      throw new ValidationError({
-        message: errorMessage,
-        errors: errors$1
-      });
+      return {
+        success: false,
+        errors: [
+          {
+            message: err instanceof Error ? err.message : `${err}`,
+            instancePath: "/"
+          }
+        ]
+      };
     }
   };
-  const result = {
-    validate,
-    parse,
-    safeParse(input) {
-      try {
-        const result2 = parseFn(input);
+  const coerce = (input) => {
+    const context = newValidationContext();
+    try {
+      const result2 = coercerFn(input, context);
+      if (context.errors.length) {
         return {
-          success: true,
-          value: result2
+          success: false,
+          errors: context.errors
         };
-      } catch (err) {
-        const errors$1 = errors(schema, input);
-        let errorMessage = err instanceof Error ? err.message : "";
-        if (errors$1.length) {
-          errorMessage = errors$1[0].message ?? `Parsing error at ${errors$1[0].instancePath}`;
-        }
+      }
+      return {
+        success: true,
+        value: result2
+      };
+    } catch (err) {
+      if (context.errors.length) {
         return {
           success: false,
-          error: new ValidationError({
-            message: errorMessage,
-            errors: errors$1
-          })
+          errors: context.errors
         };
       }
+      return {
+        success: false,
+        errors: [
+          {
+            message: err instanceof Error ? err.message : `${err}`,
+            instancePath: "/"
+          }
+        ]
+      };
+    }
+  };
+  const result = {
+    schema: JSON.parse(JSON.stringify(schema)),
+    validate,
+    parse,
+    parseUnsafe(input) {
+      const context = newValidationContext();
+      const result2 = parserFn(input, context);
+      if (context.errors.length) {
+        throw new ValidationException({ errors: context.errors });
+      }
+      return result2;
     },
-    serialize(input) {
-      try {
-        return serializeFn(input);
-      } catch (err) {
-        const errors$1 = errors(schema, input);
-        let errorMessage = err instanceof Error ? err.message : "";
-        if (errors$1.length) {
-          errorMessage = errors$1[0].message ?? `Serialization error at ${errors$1[0].instancePath}`;
-        }
-        throw new ValidationError({ message: errorMessage, errors: errors$1 });
+    coerce,
+    coerceUnsafe(input) {
+      const context = newValidationContext();
+      const result2 = coercerFn(input, context);
+      if (context.errors.length) {
+        throw new ValidationException({ errors: context.errors });
       }
+      return result2;
+    },
+    serialize,
+    serializeUnsafe(input) {
+      return serializeFn(input);
     },
     compiledCode: {
       validate: validateCode,
       parse: parser.code,
+      coerce: coercer.code,
       serialize: serializer.code
     },
-    "~standard": createStandardSchemaProperty(validate, parse)
+    "~standard": createStandardSchemaProperty(validate, (input, ctx) => {
+      const result2 = parse(input);
+      if (!result2.success) {
+        ctx.errors = result2.errors;
+        return undefined;
+      }
+      return result2.value;
+    })
   };
   return result;
 }
-function getCompiledParser(input, schema) {
-  const code = createParsingTemplate(input, schema);
+function getCompiledParser(input, schema, shouldCoerce) {
+  const code = createParsingTemplate(input, schema, shouldCoerce);
   if (isSchemaFormType(schema)) {
     switch (schema.type) {
       case "float32":
       case "float64":
         if (schema.nullable) {
           return {
-            fn: nullableFloatParser,
+            fn: nullableFloatDecoder,
             code
           };
         }
         return {
-          fn: compiledFloatParser,
+          fn: compiledFloatDecoder,
           code
         };
       case "int64":
         return {
-          fn(input2) {
-            return bigIntParser(
+          fn(input2, context) {
+            return bigIntDecoder(
               input2,
               false,
-              schema.nullable ?? false
+              schema.nullable ?? false,
+              context
             );
           },
           code
         };
       case "uint64":
         return {
-          fn(input2) {
-            return bigIntParser(
+          fn(input2, context) {
+            return bigIntDecoder(
               input2,
               true,
-              schema.nullable ?? false
+              schema.nullable ?? false,
+              context
             );
           },
           code
@@ -1469,106 +1636,191 @@ function getCompiledParser(input, schema) {
       case "int32":
         if (schema.nullable) {
           return {
-            fn(input2) {
-              return nullableIntParser(input2, int32Min, int32Max);
+            fn(input2, context) {
+              return nullableIntDecoder(
+                input2,
+                int32Min,
+                int32Max,
+                context
+              );
             },
             code
           };
         }
         return {
-          fn(input2) {
-            return intParser(input2, int32Min, int32Max);
+          fn(input2, context) {
+            return intDecoder(input2, int32Min, int32Max, context);
           },
           code
         };
       case "int16":
         if (schema.nullable) {
           return {
-            fn(input2) {
-              return nullableIntParser(input2, int16Min, int16Max);
+            fn(input2, context) {
+              return nullableIntDecoder(
+                input2,
+                int16Min,
+                int16Max,
+                context
+              );
             },
             code
           };
         }
         return {
-          fn(input2) {
-            return intParser(input2, int16Min, int16Max);
+          fn(input2, context) {
+            return intDecoder(input2, int16Min, int16Max, context);
           },
           code
         };
       case "int8":
         if (schema.nullable) {
           return {
-            fn(input2) {
-              return nullableIntParser(input2, int8Min, int8Max);
+            fn(input2, context) {
+              return nullableIntDecoder(
+                input2,
+                int8Min,
+                int8Max,
+                context
+              );
             },
             code
           };
         }
         return {
-          fn(input2) {
-            return intParser(input2, int8Min, int8Max);
+          fn(input2, context) {
+            return intDecoder(input2, int8Min, int8Max, context);
           },
           code
         };
       case "uint32":
         if (schema.nullable) {
           return {
-            fn(input2) {
-              return nullableIntParser(
+            fn(input2, context) {
+              return nullableIntDecoder(
                 input2,
                 uint32Min,
-                uint32Max
+                uint32Max,
+                context
               );
             },
             code
           };
         }
         return {
-          fn(input2) {
-            return intParser(input2, uint32Min, uint32Max);
+          fn(input2, context) {
+            return intDecoder(input2, uint32Min, uint32Max, context);
           },
           code
         };
       case "uint16":
         if (schema.nullable) {
           return {
-            fn(input2) {
-              return nullableIntParser(
+            fn(input2, context) {
+              return nullableIntDecoder(
                 input2,
                 uint16Min,
-                uint16Max
+                uint16Max,
+                context
               );
             },
             code
           };
         }
         return {
-          fn(input2) {
-            return intParser(input2, uint16Min, uint16Max);
+          fn(input2, context) {
+            return intDecoder(input2, uint16Min, uint16Max, context);
           },
           code
         };
       case "uint8":
         if (schema.nullable) {
           return {
-            fn(input2) {
-              return nullableIntParser(input2, uint8Min, uint8Max);
+            fn(input2, context) {
+              return nullableIntDecoder(
+                input2,
+                uint8Min,
+                uint8Max,
+                context
+              );
             },
             code
           };
         }
         return {
-          fn(input2) {
-            return intParser(input2, uint8Min, uint8Max);
+          fn(input2, context) {
+            return intDecoder(input2, uint8Min, uint8Max, context);
           },
           code
         };
       case "boolean":
+        if (shouldCoerce) {
+          if (schema.nullable) {
+            return {
+              code,
+              fn(input2, context) {
+                switch (input2) {
+                  case true:
+                    return true;
+                  case false:
+                    return false;
+                  case "true":
+                  case "TRUE":
+                  case "1":
+                  case 1:
+                    return true;
+                  case "false":
+                  case "FALSE":
+                  case "0":
+                  case 0:
+                    return false;
+                  case null:
+                  case "null":
+                    return null;
+                  default:
+                    context.errors.push({
+                      instancePath: "/",
+                      schemaPath: "/type",
+                      message: `Unable to coerce ${input2} into boolean`
+                    });
+                    return undefined;
+                }
+              }
+            };
+          }
+          return {
+            code,
+            fn(input2, context) {
+              switch (input2) {
+                case true:
+                  return true;
+                case false:
+                  return false;
+                case "true":
+                case "TRUE":
+                case "1":
+                case 1:
+                  return true;
+                case "false":
+                case "FALSE":
+                case "0":
+                case 0:
+                  return false;
+                default:
+                  context.errors.push({
+                    instancePath: "/",
+                    schemaPath: "/type",
+                    message: `Unable to coerce ${input2} into boolean`
+                  });
+                  return undefined;
+              }
+            }
+          };
+        }
         if (schema.nullable) {
           return {
             code,
-            fn(input2) {
+            fn(input2, context) {
               if (typeof input2 === "string") {
                 if (input2 === "true") {
                   return true;
@@ -1586,20 +1838,17 @@ function getCompiledParser(input, schema) {
               if (input2 === null) {
                 return null;
               }
-              throw new ValidationError({
-                message: `Expected boolean. Got ${typeof input2}`,
-                errors: [
-                  {
-                    instancePath: "",
-                    schemaPath: "/type"
-                  }
-                ]
+              context.errors.push({
+                instancePath: "",
+                schemaPath: "/type",
+                message: `Expected boolean. Got ${typeof input2}`
               });
+              return undefined;
             }
           };
         }
         return {
-          fn(input2) {
+          fn(input2, context) {
             if (typeof input2 === "string") {
               if (input2 === "true") {
                 return true;
@@ -1611,22 +1860,19 @@ function getCompiledParser(input, schema) {
             if (typeof input2 === "boolean") {
               return input2;
             }
-            throw new ValidationError({
-              message: `Expected boolean. Got ${typeof input2}`,
-              errors: [
-                {
-                  instancePath: "",
-                  schemaPath: "/type"
-                }
-              ]
+            context.errors.push({
+              instancePath: "",
+              schemaPath: "/type",
+              message: `Expected boolean. Got ${typeof input2}`
             });
+            return undefined;
           },
           code
         };
       case "string":
         if (schema.nullable) {
           return {
-            fn(input2) {
+            fn(input2, context) {
               if (typeof input2 === "string") {
                 if (input2 === "null") {
                   return null;
@@ -1636,44 +1882,100 @@ function getCompiledParser(input, schema) {
               if (input2 === null) {
                 return null;
               }
-              throw new ValidationError({
-                message: `Expected string or null. Got ${typeof input2}.`,
-                errors: [
-                  {
-                    instancePath: "",
-                    schemaPath: "/type"
-                  }
-                ]
+              context.errors.push({
+                instancePath: "",
+                schemaPath: "/type",
+                message: `Expected string or null. Got ${typeof input2}.`
               });
+              return undefined;
             },
             code
           };
         }
         return {
-          fn(input2) {
+          fn(input2, context) {
             if (typeof input2 === "string") {
               return input2;
             }
-            throw new ValidationError({
+            context.errors.push({
               message: `Expected string. Got ${typeof input2}.`,
-              errors: [
-                {
-                  instancePath: "",
-                  schemaPath: "/type"
-                }
-              ]
+              instancePath: "/",
+              schemaPath: "/type"
             });
+            return undefined;
           },
           code
         };
       case "timestamp":
+        if (shouldCoerce) {
+          if (schema.nullable) {
+            return {
+              fn(input2, context) {
+                if (typeof input2 === "string") {
+                  const decodedInput = new Date(input2);
+                  if (!Number.isNaN(decodedInput.getMonth())) {
+                    return decodedInput;
+                  }
+                  if (input2 === "null") {
+                    return null;
+                  }
+                }
+                if (typeof input2 === "number") {
+                  const decodedInput = new Date(input2);
+                  if (!Number.isNaN(decodedInput.getMonth())) {
+                    return decodedInput;
+                  }
+                }
+                if (typeof input2 === "object" && input2 instanceof Date) {
+                  return input2;
+                }
+                if (input2 === null) {
+                  return null;
+                }
+                context.errors.push({
+                  instancePath: "",
+                  schemaPath: "/type",
+                  message: `Expected instanceof Date, ISO Date string, or null. Got ${typeof input2}.`
+                });
+                return undefined;
+              },
+              code
+            };
+          }
+          return {
+            fn(input2, context) {
+              if (typeof input2 === "string") {
+                const decodedInput = new Date(input2);
+                if (!Number.isNaN(decodedInput.getMonth())) {
+                  return decodedInput;
+                }
+              }
+              if (typeof input2 === "number") {
+                const decodedInput = new Date(input2);
+                if (!Number.isNaN(decodedInput.getMonth())) {
+                  return decodedInput;
+                }
+              }
+              if (typeof input2 === "object" && input2 instanceof Date) {
+                return input2;
+              }
+              context.errors.push({
+                instancePath: "",
+                schemaPath: "/type",
+                message: `Expected instanceof Date or ISO Date string. Got ${typeof input2}.`
+              });
+              return undefined;
+            },
+            code
+          };
+        }
         if (schema.nullable) {
           return {
-            fn(input2) {
+            fn(input2, context) {
               if (typeof input2 === "string") {
-                const parsedInput = new Date(input2);
-                if (!Number.isNaN(parsedInput.getMonth())) {
-                  return parsedInput;
+                const decodedInput = new Date(input2);
+                if (!Number.isNaN(decodedInput.getMonth())) {
+                  return decodedInput;
                 }
                 if (input2 === "null") {
                   return null;
@@ -1685,39 +1987,33 @@ function getCompiledParser(input, schema) {
               if (input2 === null) {
                 return null;
               }
-              throw new ValidationError({
-                message: `Expected instanceof Date, ISO Date string, or null. Got ${typeof input2}.`,
-                errors: [
-                  {
-                    instancePath: "",
-                    schemaPath: "/type"
-                  }
-                ]
+              context.errors.push({
+                instancePath: "",
+                schemaPath: "/type",
+                message: `Expected instanceof Date, ISO Date string, or null. Got ${typeof input2}.`
               });
+              return undefined;
             },
             code
           };
         }
         return {
-          fn(input2) {
+          fn(input2, context) {
             if (typeof input2 === "string") {
-              const parsedInput = new Date(input2);
-              if (!Number.isNaN(parsedInput.getMonth())) {
-                return parsedInput;
+              const decodedInput = new Date(input2);
+              if (!Number.isNaN(decodedInput.getMonth())) {
+                return decodedInput;
               }
             }
             if (typeof input2 === "object" && input2 instanceof Date) {
               return input2;
             }
-            throw new ValidationError({
-              message: `Expected instance of Date or ISO date string. Got ${typeof input2}.`,
-              errors: [
-                {
-                  instancePath: "",
-                  schemaPath: "/type"
-                }
-              ]
+            context.errors.push({
+              instancePath: "",
+              schemaPath: "/type",
+              message: `Expected instance of Date or ISO date string. Got ${typeof input2}.`
             });
+            return undefined;
           },
           code
         };
@@ -1726,7 +2022,7 @@ function getCompiledParser(input, schema) {
   if (isSchemaFormEnum(schema)) {
     if (schema.nullable) {
       return {
-        fn(input2) {
+        fn(input2, context) {
           if (typeof input2 === "string") {
             for (const val of schema.enum) {
               if (input2 === val) {
@@ -1740,23 +2036,20 @@ function getCompiledParser(input, schema) {
           if (input2 === null) {
             return null;
           }
-          throw new ValidationError({
+          context.errors.push({
+            instancePath: "",
+            schemaPath: "/enum",
             message: `Expected one of the following values: [${schema.enum.join(
               ", "
-            )}] or null. Got ${typeof input2}.`,
-            errors: [
-              {
-                instancePath: "",
-                schemaPath: "/enum"
-              }
-            ]
+            )}] or null. Got ${typeof input2}.`
           });
+          return undefined;
         },
         code
       };
     }
     return {
-      fn(input2) {
+      fn(input2, context) {
         if (typeof input2 === "string") {
           for (const val of schema.enum) {
             if (input2 === val) {
@@ -1764,70 +2057,58 @@ function getCompiledParser(input, schema) {
             }
           }
         }
-        throw new ValidationError({
+        context.errors.push({
+          instancePath: "",
+          schemaPath: "/enum",
           message: `Expected one of the following values: [${schema.enum.join(
             ", "
-          )}]. Got ${typeof input2}.`,
-          errors: [
-            {
-              instancePath: "",
-              schemaPath: "/enum"
-            }
-          ]
+          )}]. Got ${typeof input2}.`
         });
+        return undefined;
       },
       code
     };
   }
-  return { fn: new Function(input, code), code };
+  return { fn: new Function(input, "context", code), code };
 }
-function compiledFloatParser(input) {
+function compiledFloatDecoder(input, context) {
   if (typeof input === "string") {
-    const parsedVal = Number(input);
-    if (!Number.isNaN(parsedVal)) {
-      return parsedVal;
+    const decodedVal = Number(input);
+    if (!Number.isNaN(decodedVal)) {
+      return decodedVal;
     }
-    throw new ValidationError({
-      message: `Unable to parse number from ${input}`,
-      errors: [
-        {
-          instancePath: "",
-          schemaPath: "/type"
-        }
-      ]
+    context.errors.push({
+      instancePath: "",
+      schemaPath: "/type",
+      message: `Unable to decode number from ${input}`
     });
+    return undefined;
   }
   if (typeof input === "number" && !Number.isNaN(input)) {
     return input;
   }
-  throw new ValidationError({
-    message: `Expected number. Got ${typeof input}`,
-    errors: [
-      {
-        instancePath: "",
-        schemaPath: "/type"
-      }
-    ]
+  context.errors.push({
+    instancePath: "",
+    schemaPath: "/type",
+    message: `Expected number. Got ${typeof input}`
   });
+  return undefined;
 }
-function nullableFloatParser(input) {
+function nullableFloatDecoder(input, context) {
   if (typeof input === "string") {
-    const parsedVal = Number(input);
-    if (!Number.isNaN(parsedVal)) {
-      return parsedVal;
+    const decodedVal = Number(input);
+    if (!Number.isNaN(decodedVal)) {
+      return decodedVal;
     }
     if (input === "null") {
       return null;
     }
-    throw new ValidationError({
-      message: `Unable to parse number from ${input}`,
-      errors: [
-        {
-          instancePath: "",
-          schemaPath: "/type"
-        }
-      ]
+    context.errors.push({
+      instancePath: "",
+      schemaPath: "/type",
+      message: `Unable to decode number from ${input}`
     });
+    return undefined;
   }
   if (typeof input === "number" && !Number.isNaN(input)) {
     return input;
@@ -1835,17 +2116,14 @@ function nullableFloatParser(input) {
   if (input === null) {
     return null;
   }
-  throw new ValidationError({
-    message: `Expected number or null. Got ${typeof input}`,
-    errors: [
-      {
-        instancePath: "",
-        schemaPath: "/type"
-      }
-    ]
+  context.errors.push({
+    instancePath: "",
+    schemaPath: "/type",
+    message: `Expected number or null. Got ${typeof input}`
   });
+  return undefined;
 }
-function bigIntParser(input, isUnsigned, isNullable) {
+function bigIntDecoder(input, isUnsigned, isNullable, context) {
   if (typeof input === "string" || typeof input === "number") {
     if (isNullable && input === "null") {
       return null;
@@ -1853,70 +2131,71 @@ function bigIntParser(input, isUnsigned, isNullable) {
     try {
       const val = BigInt(input);
       if (isUnsigned) {
-        if (val >= BigInt("0")) {
+        if (val >= uint64Min && val <= uint64Max) {
           return val;
         }
-        throw new ValidationError({
-          message: "uint64 must be greater than or equal to 0",
-          errors: [
-            {
-              message: "uint64 must be greater than or equal to 0",
-              schemaPath: "/type",
-              instancePath: ""
-            }
-          ]
+        context.errors.push({
+          message: "uint64 must an integer between 0 and 18,446,744,073,709,551,615",
+          schemaPath: "/type",
+          instancePath: ""
         });
+        return void 0;
+      }
+      if (val >= int64Min && val <= int64Max) {
+        return val;
       }
-      return val;
+      context.errors.push({
+        schemaPath: "/type",
+        instancePath: "/",
+        message: `int64 must be an integer between -9,223,372,036,854,775,808 and 9,223,372,036,854,775,807`
+      });
+      return void 0;
     } catch (err) {
-      throw new ValidationError({
-        message: `Error transforming ${input} to BigInt`,
-        errors: [
-          {
-            schemaPath: "/type",
-            instancePath: "",
-            data: err
-          }
-        ]
+      context.errors.push({
+        schemaPath: "/type",
+        instancePath: "",
+        data: err,
+        message: `Error transforming ${input} to BigInt`
       });
+      return undefined;
     }
   }
   if (typeof input === "bigint") {
     if (isUnsigned) {
-      if (input >= BigInt("0")) {
+      if (input >= uint64Min && input <= uint64Max) {
         return input;
       }
-      throw new ValidationError({
+      context.errors.push({
         message: "uint64 must be greater than or equal to 0",
-        errors: [
-          {
-            message: "uint64 must be greater than or equal to 0",
-            schemaPath: "/type",
-            instancePath: ""
-          }
-        ]
+        schemaPath: "/type",
+        instancePath: "/"
       });
     }
-    return input;
+    if (input >= int64Min && input <= int64Max) {
+      return input;
+    }
+    context.errors.push({
+      schemaPath: "/type",
+      instancePath: "/",
+      message: `int64 must be an integer between -9,223,372,036,854,775,808 and 9,223,372,036,854,775,807`
+    });
+    return undefined;
   }
   if (isNullable && input === null) {
     return null;
   }
-  throw new ValidationError({
-    message: "Expected BigInt or Integer string",
-    errors: [
-      {
-        schemaPath: "/type",
-        instancePath: ""
-      }
-    ]
+  context.errors.push({
+    schemaPath: "/type",
+    instancePath: "/",
+    message: "Expected BigInt or Integer string"
   });
+  return undefined;
 }
-function nullableIntParser(input, minNum, maxNum) {
+function nullableIntDecoder(input, minNum, maxNum, context) {
   if (typeof input === "string") {
-    const parsedInput = Number(input);
-    if (Number.isInteger(parsedInput) && parsedInput >= minNum && parsedInput <= maxNum) {
-      return parsedInput;
+    const decodedInput = Number(input);
+    if (Number.isInteger(decodedInput) && decodedInput >= minNum && decodedInput <= maxNum) {
+      return decodedInput;
     }
     if (input === "null") {
       return null;
@@ -1928,35 +2207,29 @@ function nullableIntParser(input, minNum, maxNum) {
   if (input === null) {
     return null;
   }
-  throw new ValidationError({
-    message: `Expected valid integer between ${minNum} & ${maxNum} or null. Got ${typeof input}.`,
-    errors: [
-      {
-        instancePath: "",
-        schemaPath: "/type"
-      }
-    ]
+  context.errors.push({
+    instancePath: "",
+    schemaPath: "/type",
+    message: `Expected valid integer between ${minNum} & ${maxNum} or null. Got ${typeof input}.`
   });
+  return undefined;
 }
-function intParser(input, minNum, maxNum) {
+function intDecoder(input, minNum, maxNum, context) {
   if (typeof input === "string") {
-    const parsedInput = Number(input);
-    if (Number.isInteger(parsedInput) && parsedInput >= minNum && parsedInput <= maxNum) {
-      return parsedInput;
+    const decodedInput = Number(input);
+    if (Number.isInteger(decodedInput) && decodedInput >= minNum && decodedInput <= maxNum) {
+      return decodedInput;
     }
   }
   if (typeof input === "number" && Number.isInteger(input) && input >= minNum && input <= maxNum) {
     return input;
   }
-  throw new ValidationError({
-    message: `Expected valid integer between ${minNum} & ${maxNum}`,
-    errors: [
-      {
-        instancePath: "",
-        schemaPath: "/type"
-      }
-    ]
+  context.errors.push({
+    instancePath: "",
+    schemaPath: "/type",
+    message: `Expected valid integer between ${minNum} & ${maxNum}`
   });
+  return undefined;
 }
 function getCompiledSerializer(schema) {
   const code = createSerializationV2Template("input", schema);
@@ -2088,111 +2361,1914 @@ function getCompiledSerializer(schema) {
   };
 }
 
-const _namespace = {
-    __proto__: null,
-    any: any,
-    array: array,
-    boolean: boolean,
-    clone: clone,
-    coerce: coerce,
-    compile: compile,
-    discriminator: discriminator,
-    enumerator: enumerator,
-    errors: errors,
-    extend: extend,
-    float32: float32,
-    float64: float64,
-    int16: int16,
-    int32: int32,
-    int64: int64,
-    int8: int8,
-    nullable: nullable,
-    number: number,
-    object: object,
-    omit: omit,
-    optional: optional,
-    parse: parse,
-    partial: partial,
-    pick: pick,
-    record: record,
-    recursive: recursive,
-    safeCoerce: safeCoerce,
-    safeParse: safeParse,
-    serialize: serialize,
-    string: string,
-    stringEnum: stringEnum,
-    timestamp: timestamp,
-    uint16: uint16,
-    uint32: uint32,
-    uint64: uint64,
-    uint8: uint8,
-    validate: validate
-};
+function any(options = {}) {
+  const validate = (input) => true;
+  const parse = (input, context) => {
+    if (context.instancePath.length === 0 && typeof input === "string") {
+      try {
+        return JSON.parse(input);
+      } catch {
+        return input;
+      }
+    }
+    return input;
+  };
+  const validator = {
+    output: undefined,
+    parse,
+    coerce: (input, context) => {
+      if (context.instancePath.length === 0 && typeof input === "string") {
+        try {
+          return JSON.parse(input);
+        } catch {
+          return input;
+        }
+      }
+      return input;
+    },
+    validate,
+    serialize(input) {
+      return JSON.stringify(input);
+    }
+  };
+  const result = {
+    metadata: {
+      id: options.id,
+      description: options.description,
+      isDeprecated: options.isDeprecated
+    },
+    [VALIDATOR_KEY]: validator,
+    "~standard": createStandardSchemaProperty(validate, parse)
+  };
+  hideInvalidProperties(result);
+  return result;
+}
 
-function isAdaptedSchema(input) {
-  return input.metadata[SCHEMA_METADATA]._isAdapted === true;
+function array(schema, opts = {}) {
+  const validateType = (input) => {
+    return validate$5(schema, input);
+  };
+  const parseType = (input, context) => {
+    return parse$5(schema, input, context, false);
+  };
+  const validator = {
+    output: [],
+    parse: parseType,
+    coerce(input, context) {
+      return parse$5(schema, input, context, true);
+    },
+    validate: validateType,
+    serialize(input, context) {
+      const strParts = [];
+      for (let i = 0; i < input.length; i++) {
+        const item = input[i];
+        const part = schema[VALIDATOR_KEY].serialize(item, {
+          instancePath: `${context.instancePath}/${i}`,
+          schemaPath: `${context.schemaPath}/elements`,
+          errors: context.errors,
+          depth: context.depth + 1,
+          maxDepth: context.maxDepth,
+          exitOnFirstError: context.exitOnFirstError
+        });
+        if (!part) {
+          return undefined;
+        }
+        strParts.push(part);
+      }
+      return `[${strParts.join(",")}]`;
+    }
+  };
+  const result = {
+    elements: schema,
+    metadata: {
+      id: opts.id,
+      description: opts.description,
+      isDeprecated: opts.isDeprecated
+    },
+    [VALIDATOR_KEY]: validator,
+    "~standard": createStandardSchemaProperty(validateType, parseType)
+  };
+  hideInvalidProperties(result);
+  return result;
+}
+function validate$5(innerSchema, input) {
+  if (!Array.isArray(input)) {
+    return false;
+  }
+  for (const item of input) {
+    const isValid = innerSchema[VALIDATOR_KEY].validate(item);
+    if (!isValid) {
+      return false;
+    }
+  }
+  return true;
+}
+function parse$5(innerSchema, input, context, coerce = false) {
+  let parsedInput = input;
+  if (context.instancePath.length === 0 && typeof input === "string") {
+    try {
+      parsedInput = JSON.parse(input);
+    } catch (_) {
+      context.errors.push({
+        instancePath: context.instancePath,
+        schemaPath: `${context.schemaPath}/elements`,
+        message: `Error at ${context.instancePath}. Invalid JSON.`
+      });
+      return undefined;
+    }
+  }
+  if (!Array.isArray(parsedInput)) {
+    context.errors.push({
+      instancePath: context.instancePath,
+      schemaPath: `${context.schemaPath}/elements`,
+      message: `Error at ${context.instancePath}. Expected array. Got ${typeof input}.`
+    });
+    return undefined;
+  }
+  const result = [];
+  for (let i = 0; i < parsedInput.length; i++) {
+    const item = parsedInput[i];
+    if (coerce) {
+      const parsedItem = innerSchema[VALIDATOR_KEY].coerce(item, {
+        instancePath: `${context.instancePath}/${i}`,
+        schemaPath: `${context.schemaPath}/elements`,
+        errors: context.errors,
+        depth: context.depth + 1,
+        maxDepth: context.maxDepth,
+        exitOnFirstError: context.exitOnFirstError
+      });
+      result.push(parsedItem);
+    } else {
+      const parsedItem = innerSchema[VALIDATOR_KEY].parse(item, {
+        instancePath: `${context.instancePath}/${i}`,
+        schemaPath: `${context.schemaPath}/elements`,
+        errors: context.errors,
+        depth: context.depth + 1,
+        maxDepth: context.maxDepth,
+        exitOnFirstError: context.exitOnFirstError
+      });
+      result.push(parsedItem);
+    }
+  }
+  if (context.errors.length) {
+    return undefined;
+  }
+  return result;
 }
-function validatorFromAdaptedSchema(schema) {
+
+function boolean(opts = {}) {
+  const validator = {
+    output: false,
+    parse: parse$4,
+    validate: validate$4,
+    serialize: serialize$2,
+    coerce(input, context) {
+      if (validate$4(input)) {
+        return input;
+      }
+      switch (input) {
+        case "true":
+        case "TRUE":
+        case "1":
+        case 1:
+          return true;
+        case "false":
+        case "FALSE":
+        case "0":
+        case 0:
+          return false;
+      }
+      context.errors.push({
+        instancePath: context.instancePath,
+        schemaPath: context.schemaPath,
+        message: `Error at ${context.instancePath}. Unable to coerce ${input} to boolean.`
+      });
+      return undefined;
+    }
+  };
   const result = {
-    compiledCode: {
-      parse: "",
-      serialize: "",
-      validate: ""
+    type: "boolean",
+    metadata: {
+      id: opts.id,
+      description: opts.description,
+      isDeprecated: opts.isDeprecated
     },
-    validate: schema.metadata[SCHEMA_METADATA].validate,
-    parse(input) {
-      const context = {
-        instancePath: "",
-        schemaPath: "",
-        errors: []
-      };
-      return schema.metadata[SCHEMA_METADATA].parse(input, context);
+    [VALIDATOR_KEY]: validator,
+    "~standard": createStandardSchemaProperty(validate$4, parse$4)
+  };
+  hideInvalidProperties(result);
+  return result;
+}
+function validate$4(input) {
+  return typeof input === "boolean";
+}
+function parse$4(input, data) {
+  if (validate$4(input)) {
+    return input;
+  }
+  if (data.instancePath.length === 0 && typeof input === "string") {
+    if (input === "true") {
+      return true;
+    }
+    if (input === "false") {
+      return false;
+    }
+    data.errors.push({
+      instancePath: data.instancePath,
+      schemaPath: `${data.schemaPath}/type`,
+      message: `Error at ${data.instancePath}. Expected boolean. Got ${typeof input}.`
+    });
+    return undefined;
+  }
+  data.errors.push({
+    instancePath: data.instancePath,
+    schemaPath: `${data.schemaPath}/type`,
+    message: `Error at ${data.instancePath}. Expected boolean. Got ${typeof input}.`
+  });
+  return undefined;
+}
+function serialize$2(input) {
+  return `${input}`;
+}
+
+function discriminator(propA, propB, propC) {
+  const isIdShorthand = typeof propB === "string";
+  const discriminator2 = isIdShorthand ? propB : propA;
+  const mapping = isIdShorthand ? propC : propB;
+  const opts = isIdShorthand ? { id: propA } : propC ?? {};
+  if (isIdShorthand) {
+    opts.id = propA;
+  }
+  const isType = (input) => {
+    return validate$3(discriminator2, mapping, input);
+  };
+  const parseType = (input, context) => {
+    return parse$3(discriminator2, mapping, input, context, false);
+  };
+  const validator = {
+    output: {},
+    validate: isType,
+    parse: parseType,
+    coerce: (input, context) => {
+      return parse$3(discriminator2, mapping, input, context, true);
     },
-    safeParse(input) {
-      const context = {
-        instancePath: "",
-        schemaPath: "",
-        errors: []
-      };
-      try {
-        const result2 = schema.metadata[SCHEMA_METADATA].parse(
-          input,
-          context
+    serialize(input, context) {
+      const discriminatorVal = input[discriminator2] ?? "";
+      const targetSchema = mapping[discriminatorVal];
+      if (!targetSchema) {
+        context.errors.push(
+          discriminatorMappingError(discriminatorVal, context)
         );
-        return {
-          success: true,
-          value: result2
-        };
-      } catch (err) {
-        if (err instanceof ValidationError) {
-          return {
-            success: false,
-            error: err
-          };
-        }
-        return {
-          success: false,
-          error: new ValidationError({
-            message: context.errors[0]?.message ?? `Error parsing input. ${err}`,
-            errors: context.errors
-          })
-        };
+        return undefined;
       }
+      const result2 = targetSchema[VALIDATOR_KEY].serialize(input, {
+        instancePath: context.instancePath,
+        schemaPath: `${context.schemaPath}/mapping/${discriminatorVal}`,
+        errors: context.errors,
+        discriminatorKey: discriminator2,
+        discriminatorValue: discriminatorVal,
+        depth: context.depth,
+        maxDepth: context.maxDepth,
+        exitOnFirstError: context.exitOnFirstError
+      });
+      return result2;
+    }
+  };
+  const result = {
+    discriminator: discriminator2,
+    mapping,
+    metadata: {
+      id: opts.id,
+      description: opts.description,
+      isDeprecated: opts.isDeprecated
     },
-    serialize(input) {
-      const context = {
-        instancePath: "",
-        schemaPath: "",
-        errors: []
-      };
-      return schema.metadata[SCHEMA_METADATA].serialize(input, context);
+    [VALIDATOR_KEY]: validator,
+    "~standard": createStandardSchemaProperty(isType, parseType)
+  };
+  hideInvalidProperties(result);
+  return result;
+}
+function validate$3(discriminator2, mapping, input) {
+  if (!isObject(input)) {
+    return false;
+  }
+  if (!(discriminator2 in input)) {
+    return false;
+  }
+  const discriminatorOptions = Object.keys(mapping);
+  if (!discriminatorOptions.includes(input[discriminator2])) {
+    return false;
+  }
+  const targetSchema = mapping[input[discriminator2]];
+  if (!targetSchema) {
+    return false;
+  }
+  return targetSchema[VALIDATOR_KEY].validate(input);
+}
+function parse$3(discriminator2, mapping, input, context, coerce = false) {
+  let parsedInput = input;
+  if (typeof input === "string" && input.length && context.instancePath.length === 0) {
+    try {
+      parsedInput = JSON.parse(input);
+    } catch (err) {
+      context.errors.push({
+        message: err instanceof Error ? err.message : `${err}`,
+        data: err,
+        instancePath: context.instancePath,
+        schemaPath: context.schemaPath
+      });
+      return undefined;
+    }
+  }
+  if (!isObject(parsedInput)) {
+    context.errors.push({
+      instancePath: context.instancePath,
+      schemaPath: `${context.schemaPath}/discriminator`,
+      message: `Error at ${context.instancePath}. Expected object. Got ${typeof parsedInput}.`
+    });
+    return undefined;
+  }
+  if (!(discriminator2 in parsedInput)) {
+    context.errors.push({
+      instancePath: `${context.instancePath}/${discriminator2}`,
+      schemaPath: `${context.schemaPath}/discriminator`,
+      message: `Error at ${context.instancePath}/${discriminator2}. Discriminator field "${discriminator2}" cannot be undefined`
+    });
+    return undefined;
+  }
+  const acceptedDiscriminatorVals = Object.keys(mapping);
+  const discriminatorVal = parsedInput[discriminator2];
+  if (!acceptedDiscriminatorVals.includes(discriminatorVal)) {
+    context.errors.push({
+      instancePath: `${context.instancePath}/${discriminator2}`,
+      schemaPath: `${context.schemaPath}/discriminator`,
+      message: `Error at ${context.instancePath}/${discriminator2}. "${parsedInput[discriminator2]}" is not one of the accepted discriminator values: [${acceptedDiscriminatorVals.join(
+        ", "
+      )}]`
+    });
+    return undefined;
+  }
+  const targetSchema = mapping[parsedInput[discriminator2]];
+  if (!targetSchema) {
+    return undefined;
+  }
+  if (coerce) {
+    const result2 = targetSchema[VALIDATOR_KEY].coerce(parsedInput, {
+      instancePath: context.instancePath,
+      schemaPath: `${context.schemaPath}/mapping/${discriminatorVal}`,
+      errors: context.errors,
+      discriminatorKey: discriminator2,
+      discriminatorValue: discriminatorVal,
+      depth: context.depth + 1,
+      maxDepth: context.maxDepth,
+      exitOnFirstError: context.exitOnFirstError
+    });
+    return result2;
+  }
+  const result = targetSchema[VALIDATOR_KEY].parse(parsedInput, {
+    instancePath: context.instancePath,
+    schemaPath: `${context.schemaPath}/mapping/${discriminatorVal}`,
+    errors: context.errors,
+    discriminatorKey: discriminator2,
+    discriminatorValue: discriminatorVal,
+    depth: context.depth + 1,
+    maxDepth: context.maxDepth,
+    exitOnFirstError: context.exitOnFirstError
+  });
+  return result;
+}
+function discriminatorMappingError(discriminatorVal, data) {
+  return {
+    message: `Error fetching discriminator schema. Mapping for "${discriminatorVal} is undefined.`,
+    instancePath: data.instancePath,
+    schemaPath: data.schemaPath
+  };
+}
+
+const stringEnum = enumerator;
+function enumerator(paramA, paramB) {
+  const isIdShorthand = typeof paramA === "string";
+  const enumVal = isIdShorthand ? paramB : paramA;
+  const meta = isIdShorthand ? { id: paramA } : paramB;
+  const isType = (input) => {
+    if (typeof input !== "string") {
+      return false;
+    }
+    for (const val of enumVal) {
+      if (val === input) {
+        return true;
+      }
+    }
+    return false;
+  };
+  const parse = (input, context) => {
+    if (isType(input)) {
+      return input;
+    }
+    context.errors.push({
+      instancePath: context.instancePath,
+      schemaPath: `${context.schemaPath}/enum`,
+      message: `Error at ${context.instancePath}. Invalid enum value. Expected one of the following values: [${enumVal.join(
+        ", "
+      )}]`
+    });
+    return undefined;
+  };
+  const validator = {
+    output: paramA[0] ?? "",
+    parse,
+    coerce: (input, context) => {
+      if (isType(input)) {
+        return input;
+      }
+      context.errors.push({
+        instancePath: context.instancePath,
+        schemaPath: `${context.schemaPath}/enum`,
+        message: `Error at ${context.instancePath}. Invalid enum value. Expected one of the following values: [${enumVal.join(
+          ", "
+        )}]`
+      });
+      return undefined;
+    },
+    validate: isType,
+    serialize(input, context) {
+      if (context.instancePath.length === 0) {
+        return input;
+      }
+      return `"${input}"`;
+    }
+  };
+  const result = {
+    enum: enumVal,
+    metadata: {
+      id: meta?.id,
+      description: meta?.description,
+      isDeprecated: meta?.isDeprecated
+    },
+    [VALIDATOR_KEY]: validator,
+    "~standard": createStandardSchemaProperty(isType, parse)
+  };
+  hideInvalidProperties(result);
+  return result;
+}
+
+function nullable(schema, opts = {}) {
+  const isType = (val) => {
+    if (val === null) {
+      return true;
+    }
+    return schema[VALIDATOR_KEY].validate(val);
+  };
+  const parse = (val, data) => {
+    if (data.instancePath.length === 0 && typeof val === "string" && val === "null") {
+      return null;
+    }
+    if (val === null) {
+      return null;
+    }
+    return schema[VALIDATOR_KEY].parse(val, data);
+  };
+  const validator = {
+    output: null,
+    optional: schema[VALIDATOR_KEY].optional,
+    validate: isType,
+    parse,
+    coerce(val, data) {
+      if (val === null) {
+        return null;
+      }
+      if (val === "null") {
+        return null;
+      }
+      return schema[VALIDATOR_KEY].coerce(val, data);
+    },
+    serialize(val, data) {
+      if (val === null) {
+        return "null";
+      }
+      return schema[VALIDATOR_KEY].serialize(val, data);
+    }
+  };
+  const result = {
+    ...schema,
+    nullable: true,
+    metadata: {
+      id: opts.id ?? schema.metadata?.id,
+      description: opts.description ?? schema.metadata?.description,
+      isDeprecated: opts.isDeprecated ?? schema.metadata?.isDeprecated
     },
+    [VALIDATOR_KEY]: validator,
     "~standard": createStandardSchemaProperty(
-      schema.metadata[SCHEMA_METADATA].validate,
-      schema.metadata[SCHEMA_METADATA].parse
+      validator.validate,
+      validator.parse
     )
   };
+  hideInvalidProperties(result);
+  return result;
+}
+function optional(input, opts = {}) {
+  const isType = (val) => {
+    if (val === undefined) {
+      return true;
+    }
+    return input[VALIDATOR_KEY].validate(val);
+  };
+  const parse = (val, context) => {
+    if (typeof val === "undefined") {
+      return undefined;
+    }
+    if (context.instancePath.length === 0 && val === "undefined") {
+      return undefined;
+    }
+    return input[VALIDATOR_KEY].parse(val, context);
+  };
+  const validator = {
+    output: undefined,
+    optional: true,
+    validate: isType,
+    parse,
+    coerce: (val, data) => {
+      if (typeof val === "undefined") {
+        return undefined;
+      }
+      if (val === "undefined") {
+        return undefined;
+      }
+      return input[VALIDATOR_KEY].coerce(val, data);
+    },
+    serialize: (val, data) => {
+      if (typeof val === "undefined") {
+        return "undefined";
+      }
+      return input[VALIDATOR_KEY].serialize(val, data);
+    }
+  };
+  const result = {
+    ...input,
+    metadata: {
+      id: opts.id ?? input.metadata?.id,
+      description: opts.description ?? input.metadata?.description,
+      isDeprecated: opts.isDeprecated ?? input.metadata?.isDeprecated
+    },
+    [VALIDATOR_KEY]: validator,
+    "~standard": createStandardSchemaProperty(isType, parse)
+  };
+  hideInvalidProperties(result);
   return result;
 }
+function clone(input, opts = {}) {
+  const validator = {
+    ...input[VALIDATOR_KEY]
+  };
+  const schema = {
+    ...input,
+    metadata: {
+      id: opts.id,
+      description: opts.description,
+      isDeprecated: opts.isDeprecated
+    },
+    [VALIDATOR_KEY]: validator,
+    "~standard": createStandardSchemaProperty(
+      validator.validate,
+      validator.parse
+    )
+  };
+  hideInvalidProperties(schema);
+  return schema;
+}
+
+function number(opts = {}) {
+  return float64(opts);
+}
+function coerceNumber(input, options) {
+  if (typeof input === "string") {
+    const decodedInput = Number(input);
+    if (Number.isNaN(decodedInput)) {
+      options.errors.push({
+        instancePath: `${options.instancePath}`,
+        schemaPath: `${options.schemaPath}/type`,
+        message: `Error at ${options.instancePath}. Unable to coerce ${typeof input} into a number`
+      });
+      return undefined;
+    }
+    return decodeNumber(decodedInput, options);
+  }
+  return decodeNumber(input, options);
+}
+function float32(opts = {}) {
+  return numberScalarType("float32", opts, () => {
+    return {
+      success: true
+    };
+  });
+}
+function float64(opts = {}) {
+  return numberScalarType("float64", opts, () => {
+    return {
+      success: true
+    };
+  });
+}
+function int8(opts = {}) {
+  return numberScalarType("int8", opts, (input) => {
+    const isValid = validateInt(input, int8Min, int8Max);
+    if (isValid) {
+      return {
+        success: true
+      };
+    }
+    return {
+      success: false,
+      message: `Must be an valid integer between ${int8Min} and ${int8Max}`
+    };
+  });
+}
+function uint8(opts = {}) {
+  return numberScalarType("uint8", opts, (input) => {
+    const isValid = validateInt(input, uint8Min, uint8Max);
+    if (isValid) {
+      return {
+        success: true
+      };
+    }
+    return {
+      success: false,
+      message: `Must be a valid integer between ${uint8Min} and ${uint8Max}`
+    };
+  });
+}
+function int16(opts = {}) {
+  return numberScalarType("int16", opts, (input) => {
+    const isValid = validateInt(input, int16Min, int16Max);
+    if (isValid) {
+      return {
+        success: true
+      };
+    }
+    return {
+      success: false,
+      message: `Must be a valid integer between ${int16Min} and ${int16Max}`
+    };
+  });
+}
+function uint16(opts = {}) {
+  return numberScalarType("uint16", opts, (input) => {
+    const isValid = validateInt(input, uint16Min, uint16Max);
+    if (isValid) {
+      return {
+        success: true
+      };
+    }
+    return {
+      success: false,
+      message: `Must be a valid integer between ${uint16Min} and ${uint16Max}`
+    };
+  });
+}
+function int32(opts = {}) {
+  return numberScalarType("int32", opts, (input) => {
+    const isValid = validateInt(input, int32Min, int32Max);
+    if (isValid) {
+      return {
+        success: true
+      };
+    }
+    return {
+      success: false,
+      message: `Must be a valid integer between ${int32Min} and ${int32Max}`
+    };
+  });
+}
+function uint32(opts = {}) {
+  return numberScalarType("uint32", opts, (input) => {
+    const isValid = validateInt(input, uint32Min, uint32Max);
+    if (isValid) {
+      return { success: true };
+    }
+    return {
+      success: false,
+      message: `Must be a valid integer between ${uint32Min} and ${uint32Max}`
+    };
+  });
+}
+function int64(opts = {}) {
+  function isType(input) {
+    return typeof input === "bigint" && input >= int64Min && input <= int64Max;
+  }
+  function parse(input, context) {
+    if (typeof input === "string" || typeof input === "number") {
+      try {
+        const val = BigInt(input);
+        if (isType(val)) {
+          return val;
+        }
+        context.errors.push({
+          message: `Error at ${context.instancePath}. Invalid int64.`,
+          schemaPath: `${context.schemaPath}/type`,
+          instancePath: context.instancePath
+        });
+        return void 0;
+      } catch (_) {
+        context.errors.push({
+          message: `Error at ${context.instancePath}. Unable to transform ${input} to BigInt`,
+          schemaPath: `${context.schemaPath}/type`,
+          instancePath: context.instancePath
+        });
+        return undefined;
+      }
+    }
+    if (isType(input)) {
+      return input;
+    }
+    context.errors.push({
+      message: `Error at ${context.instancePath}. Expected BigInt or integer string`,
+      schemaPath: `${context.schemaPath}/type`,
+      instancePath: context.instancePath
+    });
+    return undefined;
+  }
+  const validator = {
+    output: BigInt("0"),
+    validate: isType,
+    parse,
+    coerce: parse,
+    serialize(input, context) {
+      if (context.instancePath.length === 0) {
+        return input.toString();
+      }
+      return `"${input.toString()}"`;
+    }
+  };
+  const result = {
+    type: "int64",
+    metadata: {
+      id: opts.id,
+      description: opts.description,
+      isDeprecated: opts.isDeprecated
+    },
+    [VALIDATOR_KEY]: validator,
+    "~standard": createStandardSchemaProperty(isType, parse)
+  };
+  hideInvalidProperties(result);
+  return result;
+}
+function uint64(opts = {}) {
+  function isType(input) {
+    return typeof input === "bigint" && input >= uint64Min && input <= uint64Max;
+  }
+  function parse(input, context) {
+    if (typeof input === "string" || typeof input === "number") {
+      try {
+        const val = BigInt(input);
+        if (isType(val)) {
+          return val;
+        }
+        context.errors.push({
+          message: `Error at ${context.instancePath}. Invalid uint64.`,
+          schemaPath: `${context.schemaPath}/type`,
+          instancePath: context.instancePath
+        });
+        return void 0;
+      } catch (_) {
+        context.errors.push({
+          message: `Error at ${context.instancePath}. Unable to transform ${input} to BigInt.`,
+          schemaPath: `${context.schemaPath}/type`,
+          instancePath: context.instancePath
+        });
+        return undefined;
+      }
+    }
+    if (isType(input)) {
+      return input;
+    }
+    context.errors.push({
+      message: `Error at ${context.instancePath}. Expected BigInt or integer string.`,
+      schemaPath: `${context.schemaPath}/type`,
+      instancePath: context.instancePath
+    });
+    return undefined;
+  }
+  const validator = {
+    output: BigInt("0"),
+    validate: isType,
+    parse,
+    coerce: parse,
+    serialize(input, context) {
+      if (context.instancePath.length === 0) {
+        return input.toString();
+      }
+      return `"${input.toString()}"`;
+    }
+  };
+  const result = {
+    type: "uint64",
+    metadata: {
+      id: opts.id,
+      description: opts.description,
+      isDeprecated: opts.isDeprecated
+    },
+    [VALIDATOR_KEY]: validator,
+    "~standard": createStandardSchemaProperty(isType, parse)
+  };
+  hideInvalidProperties(result);
+  return result;
+}
+function validateNumber(input) {
+  return typeof input === "number";
+}
+function validateInt(input, minVal, maxValue) {
+  return Number.isInteger(input) && input >= minVal && input <= maxValue;
+}
+function serializeNumber(input, _context) {
+  return input.toString();
+}
+function decodeNumber(input, context) {
+  if (context.instancePath.length === 0 && typeof input === "string") {
+    const result = Number(input);
+    if (Number.isNaN(result)) {
+      context?.errors.push({
+        instancePath: context.instancePath,
+        schemaPath: `${context.schemaPath}/type`,
+        message: `Error at ${context.instancePath}. Invalid number.`
+      });
+      return undefined;
+    }
+    return result;
+  }
+  if (typeof input === "number" && !Number.isNaN(input)) {
+    return input;
+  }
+  context?.errors.push({
+    instancePath: context.instancePath,
+    schemaPath: `${context.schemaPath}/type`,
+    message: `Error at ${context.instancePath}. Invalid number.`
+  });
+  return undefined;
+}
+function numberScalarType(type, opts, numTypeMatcher) {
+  const validate = (input) => {
+    const isNum = validateNumber(input);
+    if (!isNum) {
+      return false;
+    }
+    return numTypeMatcher(input).success;
+  };
+  const parse = (input, context) => {
+    const result2 = decodeNumber(input, context);
+    if (context.errors.length) {
+      return undefined;
+    }
+    if (typeof result2 !== "number") {
+      context?.errors.push({
+        instancePath: context.instancePath,
+        schemaPath: `${context.schemaPath}/type`,
+        message: `Error at ${context.instancePath}. Invalid number.`
+      });
+      return undefined;
+    }
+    const matchResult = numTypeMatcher(result2);
+    if (matchResult.success) {
+      return result2;
+    }
+    context?.errors.push({
+      instancePath: context.instancePath,
+      schemaPath: `${context.schemaPath}/type`,
+      message: `Error at ${context.instancePath}. ${matchResult.message}`
+    });
+    return undefined;
+  };
+  const validator = {
+    output: 0,
+    validate,
+    parse,
+    serialize: serializeNumber,
+    coerce(input, options) {
+      const result2 = coerceNumber(input, options);
+      if (typeof result2 !== "number") {
+        options.errors.push({
+          instancePath: options.instancePath,
+          schemaPath: `${options.schemaPath}/type`,
+          message: `Error at ${options.instancePath}. Unable to coerce ${typeof input} to ${type}.`
+        });
+        return undefined;
+      }
+      const matchResult = numTypeMatcher(result2);
+      if (matchResult.success) {
+        return result2;
+      }
+      options.errors.push({
+        instancePath: options.instancePath,
+        schemaPath: `${options.schemaPath}/type`,
+        message: `Error at ${options.instancePath}. ${matchResult.message}`
+      });
+      return undefined;
+    }
+  };
+  const result = {
+    type,
+    metadata: {
+      id: opts.id,
+      description: opts.description,
+      isDeprecated: opts.isDeprecated
+    },
+    [VALIDATOR_KEY]: validator,
+    "~standard": createStandardSchemaProperty(validate, parse)
+  };
+  hideInvalidProperties(result);
+  return result;
+}
+
+function object(propA, propB) {
+  const isIdShorthand = typeof propA === "string";
+  const input = isIdShorthand ? propB : propA;
+  const options = isIdShorthand ? { id: propA } : propB ?? {};
+  const schema = {
+    properties: {}
+  };
+  if (typeof options.strict === "boolean") {
+    schema.strict = options.strict;
+  }
+  for (const key of Object.keys(input)) {
+    const prop = input[key];
+    if (prop[VALIDATOR_KEY].optional) {
+      if (!schema.optionalProperties) {
+        schema.optionalProperties = {};
+      }
+      schema.optionalProperties[key] = prop;
+      continue;
+    }
+    schema.properties[key] = prop;
+  }
+  const validate = (input2) => {
+    return validateObjectSchema(schema, input2);
+  };
+  const decode = (input2, context) => {
+    return decodeObjectSchema(
+      schema,
+      input2,
+      context,
+      false
+    );
+  };
+  const validator = {
+    output: {},
+    parse: decode,
+    coerce(input2, context) {
+      return decodeObjectSchema(
+        schema,
+        input2,
+        context,
+        true
+      );
+    },
+    validate,
+    serialize(input2, context) {
+      return serializeObject(
+        schema,
+        input2,
+        context
+      );
+    }
+  };
+  const result = {
+    ...schema,
+    metadata: {
+      id: options.id,
+      description: options.description,
+      isDeprecated: options.isDeprecated
+    },
+    [VALIDATOR_KEY]: validator,
+    "~standard": createStandardSchemaProperty(validate, decode)
+  };
+  hideInvalidProperties(result);
+  return result;
+}
+function decodeObjectSchema(schema, input, context, coerce = false) {
+  let parsedInput = input;
+  if (context.instancePath.length === 0 && typeof input === "string") {
+    try {
+      const result2 = JSON.parse(input);
+      parsedInput = result2;
+    } catch (_err) {
+      context.errors.push({
+        instancePath: context.instancePath,
+        schemaPath: `${context.schemaPath}/properties`,
+        message: `Error at ${context.instancePath}. Invalid JSON.`
+      });
+      return undefined;
+    }
+  }
+  if (!isObject(parsedInput)) {
+    context.errors.push({
+      instancePath: context.instancePath,
+      schemaPath: `${context.schemaPath}/properties`,
+      message: `Error at ${context.instancePath}. Expected object`
+    });
+    return undefined;
+  }
+  const result = {};
+  const optionalProps = schema.optionalProperties ?? {};
+  const inputKeys = Object.keys(parsedInput);
+  const requiredKeys = Object.keys(schema.properties);
+  const optionalKeys = Object.keys(optionalProps);
+  if (schema.strict) {
+    for (const key of inputKeys) {
+      if (!requiredKeys.includes(key) && !optionalKeys.includes(key) && key !== context.discriminatorKey) {
+        context.errors.push({
+          instancePath: `${context.instancePath}/${key}`,
+          schemaPath: `${context.schemaPath}/strict`,
+          message: `Error at ${context.instancePath}/${key}. Key '${key}' is not included in the schema. To allow additional input properties set strict to 'false'.`
+        });
+      }
+    }
+  }
+  if (context.errors.length) {
+    return undefined;
+  }
+  if (context.discriminatorKey) {
+    result[context.discriminatorKey] = context.discriminatorValue;
+  }
+  for (const key of requiredKeys) {
+    const val = parsedInput[key];
+    const prop = schema.properties[key];
+    if (coerce) {
+      result[key] = prop[VALIDATOR_KEY].coerce(val, {
+        instancePath: `${context.instancePath}/${key}`,
+        schemaPath: `${context.schemaPath}/properties/${key}`,
+        errors: context.errors,
+        depth: context.depth + 1,
+        maxDepth: context.maxDepth,
+        exitOnFirstError: context.exitOnFirstError
+      });
+      if (context.errors.length && context.exitOnFirstError) {
+        return undefined;
+      }
+      continue;
+    }
+    result[key] = prop[VALIDATOR_KEY].parse(val, {
+      instancePath: `${context.instancePath}/${key}`,
+      schemaPath: `${context.schemaPath}/properties/${key}`,
+      errors: context.errors,
+      depth: context.depth + 1,
+      maxDepth: context.maxDepth,
+      exitOnFirstError: context.exitOnFirstError
+    });
+    if (context.errors.length && context.exitOnFirstError) {
+      return undefined;
+    }
+  }
+  for (const key of optionalKeys) {
+    const val = parsedInput[key];
+    const prop = optionalProps[key];
+    if (val === undefined) {
+      continue;
+    }
+    if (coerce) {
+      result[key] = prop[VALIDATOR_KEY].coerce(val, {
+        instancePath: `${context.instancePath}/${key}`,
+        schemaPath: `${context.schemaPath}/optionalProperties/${key}`,
+        errors: context.errors,
+        depth: context.depth + 1,
+        maxDepth: context.maxDepth,
+        exitOnFirstError: context.exitOnFirstError
+      });
+      if (context.errors.length && context.exitOnFirstError) {
+        return undefined;
+      }
+      continue;
+    }
+    if (typeof val !== "undefined") {
+      result[key] = prop[VALIDATOR_KEY].parse(val, {
+        instancePath: `${context.instancePath}/${key}`,
+        schemaPath: `${context.schemaPath}/optionalProperties/${key}`,
+        errors: context.errors,
+        depth: context.depth + 1,
+        maxDepth: context.maxDepth,
+        exitOnFirstError: context.exitOnFirstError
+      });
+      if (context.errors.length && context.exitOnFirstError) {
+        return undefined;
+      }
+    }
+  }
+  if (context.errors.length) {
+    return undefined;
+  }
+  return result;
+}
+function validateObjectSchema(schema, input) {
+  if (!isObject(input)) {
+    return false;
+  }
+  const allowedKeys = schema.strict ? [] : undefined;
+  for (const key of Object.keys(schema.properties)) {
+    const propSchema = schema.properties[key];
+    const isValid = propSchema[VALIDATOR_KEY].validate(input[key]);
+    if (!isValid) return false;
+    allowedKeys?.push(key);
+  }
+  if (schema.optionalProperties) {
+    for (const key of Object.keys(schema.optionalProperties)) {
+      const propsSchema = schema.optionalProperties[key];
+      const isValid = propsSchema[VALIDATOR_KEY].validate(input[key]);
+      if (!isValid) return false;
+      allowedKeys?.push(key);
+    }
+  }
+  if (allowedKeys) {
+    for (const key of Object.keys(input)) {
+      if (!allowedKeys.includes(key)) return false;
+    }
+  }
+  return true;
+}
+function pick(inputSchema, keys, options = {}) {
+  const schema = {
+    properties: {},
+    nullable: inputSchema.nullable
+  };
+  if (typeof options.strict === "boolean") {
+    schema.strict = options.strict;
+  }
+  Object.keys(inputSchema.properties).forEach((key) => {
+    if (!schema.properties) {
+      return;
+    }
+    if (keys.includes(key)) {
+      schema.properties[key] = inputSchema.properties[key];
+    }
+  });
+  if (inputSchema.optionalProperties) {
+    schema.optionalProperties = {};
+    Object.keys(inputSchema.optionalProperties).forEach((key) => {
+      if (!schema.optionalProperties || !inputSchema.optionalProperties) {
+        return;
+      }
+      if (keys.includes(key)) {
+        schema.optionalProperties[key] = inputSchema.optionalProperties[key];
+      }
+    });
+  }
+  const parse = (input, context) => {
+    return decodeObjectSchema(schema, input, context, false);
+  };
+  const validate = (input) => {
+    return validateObjectSchema(schema, input);
+  };
+  const result = {
+    ...schema,
+    metadata: {
+      id: options.id,
+      description: options.description,
+      isDeprecated: options.isDeprecated
+    },
+    [VALIDATOR_KEY]: {
+      output: {},
+      parse,
+      coerce(input, context) {
+        return decodeObjectSchema(schema, input, context, false);
+      },
+      validate,
+      serialize(input, context) {
+        return serializeObject(schema, input, context);
+      }
+    },
+    "~standard": createStandardSchemaProperty(validate, parse)
+  };
+  hideInvalidProperties(result);
+  return result;
+}
+function omit(inputSchema, keys, options = {}) {
+  const schema = {
+    properties: {
+      ...inputSchema.properties
+    },
+    nullable: inputSchema.nullable
+  };
+  if (typeof options.strict === "boolean") {
+    schema.strict = options.strict;
+  }
+  Object.keys(inputSchema.properties).forEach((key) => {
+    if (keys.includes(key)) {
+      delete schema.properties[key];
+    }
+  });
+  if (inputSchema.optionalProperties) {
+    schema.optionalProperties = {
+      ...inputSchema.optionalProperties
+    };
+    Object.keys(inputSchema.optionalProperties).forEach((key) => {
+      if (!schema.optionalProperties) {
+        return;
+      }
+      if (keys.includes(key)) {
+        delete schema.optionalProperties[key];
+      }
+    });
+  }
+  const validate = (input) => validateObjectSchema(schema, input);
+  const parse = (input, context) => decodeObjectSchema(schema, input, context, false);
+  const result = {
+    ...schema,
+    metadata: {
+      id: options.id,
+      description: options.description,
+      isDeprecated: options.isDeprecated
+    },
+    [VALIDATOR_KEY]: {
+      output: {},
+      validate,
+      parse,
+      serialize(input, context) {
+        return serializeObject(schema, input, context);
+      },
+      coerce(input, context) {
+        return decodeObjectSchema(schema, input, context, true);
+      }
+    },
+    "~standard": createStandardSchemaProperty(validate, parse)
+  };
+  hideInvalidProperties(result);
+  return result;
+}
+function serializeObject(schema, input, context) {
+  const strParts = [];
+  if (context.discriminatorKey && context.discriminatorValue) {
+    strParts.push(
+      `"${context.discriminatorKey}":"${context.discriminatorValue}"`
+    );
+  }
+  for (const key of Object.keys(schema.properties)) {
+    const prop = schema.properties[key];
+    const val = input[key];
+    if (typeof val !== "undefined") {
+      strParts.push(
+        `"${key}":${prop[VALIDATOR_KEY].serialize(val, {
+          instancePath: `${context.instancePath}/${key}`,
+          schemaPath: `${context.schemaPath}/properties/${key}`,
+          errors: context.errors,
+          depth: context.depth + 1,
+          maxDepth: context.maxDepth,
+          exitOnFirstError: context.exitOnFirstError
+        })}`
+      );
+    }
+  }
+  if (schema.optionalProperties) {
+    for (const key of Object.keys(schema.optionalProperties)) {
+      const prop = schema.optionalProperties[key];
+      const val = input[key];
+      if (typeof val !== "undefined") {
+        strParts.push(
+          `"${key}":${prop[VALIDATOR_KEY].serialize(val, {
+            instancePath: `${context.instancePath}/${key}`,
+            schemaPath: `${context.schemaPath}/optionalProperties/${key}`,
+            errors: context.errors,
+            depth: context.depth + 1,
+            maxDepth: context.maxDepth,
+            exitOnFirstError: context.exitOnFirstError
+          })}`
+        );
+      }
+    }
+  }
+  return `{${strParts.join(",")}}`;
+}
+function extend(baseSchema, inputSchema, options = {}) {
+  const schema = {
+    properties: {
+      ...baseSchema.properties,
+      ...inputSchema.properties
+    },
+    optionalProperties: {
+      ...baseSchema.optionalProperties,
+      ...inputSchema.optionalProperties
+    },
+    metadata: {
+      id: options.id,
+      description: options.description
+    }
+  };
+  if (typeof options.strict === "boolean") {
+    schema.strict = options.strict;
+  }
+  const isType = (input) => validateObjectSchema(schema, input);
+  const validator = {
+    output: {},
+    parse(input, context) {
+      return decodeObjectSchema(schema, input, context, false);
+    },
+    coerce(input, context) {
+      return decodeObjectSchema(schema, input, context, true);
+    },
+    validate: isType,
+    serialize(input, context) {
+      return serializeObject(schema, input, context);
+    }
+  };
+  const result = {
+    ...schema,
+    [VALIDATOR_KEY]: validator,
+    "~standard": createStandardSchemaProperty(
+      validator.validate,
+      validator.parse
+    )
+  };
+  hideInvalidProperties(result);
+  return result;
+}
+function partial(schema, options = {}) {
+  const newSchema = {
+    properties: {},
+    optionalProperties: {},
+    nullable: schema.nullable,
+    metadata: {
+      id: options.id,
+      description: options.description
+    }
+  };
+  if (typeof options.strict === "boolean") {
+    schema.strict = options.strict;
+  }
+  for (const key of Object.keys(schema.properties)) {
+    const prop = schema.properties[key];
+    newSchema.optionalProperties[key] = optional(prop);
+  }
+  if (schema.optionalProperties && newSchema.optionalProperties) {
+    for (const key of Object.keys(schema.optionalProperties)) {
+      const prop = schema.optionalProperties[key];
+      if (prop[VALIDATOR_KEY].optional) {
+        newSchema.optionalProperties[key] = prop;
+      } else {
+        newSchema.optionalProperties[key] = optional(prop);
+      }
+    }
+  }
+  const validate = (input) => {
+    return validateObjectSchema(newSchema, input);
+  };
+  const parse = (input, context) => {
+    return decodeObjectSchema(newSchema, input, context, false);
+  };
+  const validator = {
+    output: {},
+    optional: schema[VALIDATOR_KEY].optional,
+    validate,
+    parse,
+    coerce(input, context) {
+      return decodeObjectSchema(newSchema, input, context, true);
+    },
+    serialize(input, context) {
+      return serializeObject(schema, input, context);
+    }
+  };
+  const result = {
+    ...newSchema,
+    [VALIDATOR_KEY]: validator,
+    ["~standard"]: createStandardSchemaProperty(
+      validator.validate,
+      validator.parse
+    )
+  };
+  hideInvalidProperties(result);
+  return result;
+}
+
+function string(opts = {}) {
+  const validator = {
+    output: "",
+    parse: decode,
+    coerce: coerce$2,
+    validate: validate$2,
+    serialize(input, context) {
+      if (context.instancePath.length === 0) {
+        return input;
+      }
+      if (input.length < 42) {
+        return serializeSmallString(input);
+      }
+      if (input.length < 5e3 && !STR_ESCAPE.test(input)) {
+        return `"${input}"`;
+      }
+      return JSON.stringify(input);
+    }
+  };
+  const result = {
+    type: "string",
+    metadata: {
+      id: opts.id,
+      description: opts.description,
+      isDeprecated: opts.isDeprecated
+    },
+    [VALIDATOR_KEY]: validator,
+    "~standard": createStandardSchemaProperty(validate$2, decode)
+  };
+  hideInvalidProperties(result);
+  return result;
+}
+function serializeString(input) {
+  if (input.length < 42) {
+    return serializeSmallString(input);
+  }
+  if (input.length < 5e3 && !STR_ESCAPE.test(input)) {
+    return `"${input}"`;
+  }
+  return JSON.stringify(input);
+}
+function validate$2(input) {
+  return typeof input === "string";
+}
+function decode(input, context) {
+  if (validate$2(input)) {
+    return input;
+  }
+  context.errors.push({
+    instancePath: context.instancePath,
+    schemaPath: `${context.schemaPath}/type`,
+    message: `Error at ${context.instancePath}. Expected 'string' got ${typeof input}.`
+  });
+  return undefined;
+}
+function coerce$2(input, context) {
+  return decode(input, context);
+}
+const STR_ESCAPE = (
+  // eslint-disable-next-line no-control-regex
+  /[\u0000-\u001f\u0022\u005c\ud800-\udfff]|[\ud800-\udbff](?![\udc00-\udfff])|(?:[^\ud800-\udbff]|^)[\udc00-\udfff]/
+);
+function serializeSmallString(input) {
+  const len = input.length;
+  let result = "";
+  let last = -1;
+  let point = 255;
+  for (let i = 0; i < len; i++) {
+    point = input.charCodeAt(i);
+    if (point < 32 || point >= 55296 && point <= 57343) {
+      return JSON.stringify(input);
+    }
+    if (point === 34 || // '"'
+    point === 92) {
+      if (last === -1) {
+        last = 0;
+      }
+      result += input.slice(last, i) + "\\";
+      last = i;
+    }
+  }
+  if (last === -1) {
+    return `"${input}"`;
+  }
+  return `"${result}${input.slice(last)}"`;
+}
+
+function record(schema, opts = {}) {
+  const validateFn = (input) => {
+    if (!isObject(input)) {
+      return false;
+    }
+    for (const key of Object.keys(input)) {
+      const val = input[key];
+      const isValid = schema[VALIDATOR_KEY].validate(val);
+      if (!isValid) {
+        return false;
+      }
+    }
+    return true;
+  };
+  const parseFn = (input, ctx) => {
+    return parse$2(schema, input, ctx, false);
+  };
+  const validator = {
+    output: {},
+    validate: validateFn,
+    parse: parseFn,
+    coerce(input, data) {
+      return parse$2(schema, input, data, true);
+    },
+    serialize(input, context) {
+      if (context.depth >= context.maxDepth) {
+        context.errors.push({
+          instancePath: context.instancePath,
+          schemaPath: context.schemaPath,
+          message: "Max depth reached"
+        });
+        return undefined;
+      }
+      let result2 = "{";
+      const keys = Object.keys(input);
+      for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const val = input[key];
+        if (i > 0) result2 += ",";
+        result2 += serializeString(key);
+        result2 += ":";
+        result2 += schema[VALIDATOR_KEY].serialize(val, {
+          instancePath: `${context.instancePath}/${key}`,
+          schemaPath: `${context.schemaPath}/values`,
+          errors: context.errors,
+          exitOnFirstError: context.exitOnFirstError,
+          depth: context.depth + 1,
+          maxDepth: context.maxDepth
+        });
+      }
+      result2 += "}";
+      return result2;
+    }
+  };
+  const result = {
+    values: schema,
+    metadata: {
+      id: opts.id,
+      description: opts.description,
+      isDeprecated: opts.isDeprecated
+    },
+    [VALIDATOR_KEY]: validator,
+    "~standard": createStandardSchemaProperty(validateFn, parseFn)
+  };
+  hideInvalidProperties(result);
+  return result;
+}
+function parse$2(schema, input, data, coerce = false) {
+  if (data.depth >= data.maxDepth) {
+    data.errors.push({
+      instancePath: data.instancePath,
+      schemaPath: data.schemaPath,
+      message: "Max depth reached"
+    });
+    return undefined;
+  }
+  let parsedInput = input;
+  if (data.instancePath.length === 0 && typeof input === "string" && input.length > 0) {
+    try {
+      parsedInput = JSON.parse(input);
+    } catch (err) {
+      data.errors.push({
+        message: err instanceof Error ? err.message : `${err}`,
+        instancePath: data.instancePath,
+        schemaPath: data.schemaPath,
+        data: err
+      });
+      return undefined;
+    }
+  }
+  if (!isObject(parsedInput)) {
+    data.errors.push({
+      instancePath: data.instancePath,
+      schemaPath: `${data.schemaPath}/values`,
+      message: `Error at ${data.instancePath} Expected object`
+    });
+    return undefined;
+  }
+  const result = {};
+  for (const key of Object.keys(parsedInput)) {
+    const val = parsedInput[key];
+    if (coerce) {
+      result[key] = schema[VALIDATOR_KEY].coerce(val, {
+        instancePath: `${data.instancePath}/${key}`,
+        schemaPath: `${data.schemaPath}/values`,
+        errors: data.errors,
+        maxDepth: data.maxDepth,
+        depth: data.depth + 1,
+        exitOnFirstError: data.exitOnFirstError
+      });
+    } else {
+      result[key] = schema[VALIDATOR_KEY].parse(val, {
+        instancePath: `${data.instancePath}/${key}`,
+        schemaPath: `${data.schemaPath}/values`,
+        errors: data.errors,
+        maxDepth: data.maxDepth,
+        depth: data.depth + 1,
+        exitOnFirstError: data.exitOnFirstError
+      });
+    }
+  }
+  if (data.errors.length) {
+    return undefined;
+  }
+  return result;
+}
+
+let recursiveTypeCount = 0;
+function recursive(propA, propB) {
+  const isIdShorthand = typeof propA === "string";
+  const callback = isIdShorthand ? propB : propA;
+  const options = isIdShorthand ? { id: propA } : propB ?? {};
+  if (!options.id) {
+    recursiveTypeCount++;
+    console.warn(
+      `[@arrirpc/schema] WARNING: It is highly recommended to specify an ID for recursive types.`
+    );
+  }
+  const id = options.id ?? `TypeRef${recursiveTypeCount}`;
+  const recursiveFns = {};
+  const validator = {
+    output: "",
+    parse(input, context) {
+      if (context.depth >= context.maxDepth) {
+        context.errors.push({
+          message: "Max depth exceeded",
+          instancePath: context.instancePath,
+          schemaPath: context.schemaPath
+        });
+        return undefined;
+      }
+      if (recursiveFns[id]) {
+        return recursiveFns[id].parse(input, {
+          ...context,
+          depth: context.depth + 1
+        });
+      }
+    },
+    serialize(input, context) {
+      if (context.depth >= context.maxDepth) {
+        context.errors.push({
+          message: "Max depth exceeded",
+          instancePath: context.instancePath,
+          schemaPath: context.schemaPath
+        });
+        return undefined;
+      }
+      if (recursiveFns[id]) {
+        return recursiveFns[id].serialize(input, context);
+      }
+      return "";
+    },
+    validate(input) {
+      if (recursiveFns[id]) {
+        return recursiveFns[id].validate(input);
+      }
+      return false;
+    },
+    coerce(input, context) {
+      if (context.depth >= context.maxDepth) {
+        context.errors.push({
+          message: "Max depth exceeded",
+          instancePath: context.instancePath,
+          schemaPath: context.schemaPath
+        });
+        return undefined;
+      }
+      if (recursiveFns[id]) {
+        return recursiveFns[id].coerce(input, context);
+      }
+    }
+  };
+  const refSchema = {
+    ref: id,
+    [VALIDATOR_KEY]: validator,
+    "~standard": createStandardSchemaProperty(
+      validator.validate,
+      validator.parse
+    )
+  };
+  hideInvalidProperties(refSchema);
+  const mainSchema = callback(refSchema);
+  if (!mainSchema.metadata) mainSchema.metadata = {};
+  mainSchema.metadata.id = id;
+  mainSchema.metadata.description = options?.description ?? mainSchema.metadata.description;
+  mainSchema.metadata.isDeprecated = options?.isDeprecated ?? mainSchema.metadata.isDeprecated;
+  recursiveFns[id] = {
+    validate: mainSchema[VALIDATOR_KEY].validate,
+    parse: mainSchema[VALIDATOR_KEY].parse,
+    serialize: mainSchema[VALIDATOR_KEY].serialize,
+    coerce: mainSchema[VALIDATOR_KEY].coerce
+  };
+  return mainSchema;
+}
+
+function timestamp(opts = {}) {
+  const validator = {
+    output: /* @__PURE__ */ new Date(),
+    validate: validate$1,
+    parse: parse$1,
+    coerce: coerce$1,
+    serialize: serialize$1
+  };
+  const result = {
+    type: "timestamp",
+    metadata: {
+      id: opts.id,
+      description: opts.description,
+      isDeprecated: opts.isDeprecated
+    },
+    [VALIDATOR_KEY]: validator,
+    "~standard": createStandardSchemaProperty(validate$1, parse$1)
+  };
+  hideInvalidProperties(result);
+  return result;
+}
+function validate$1(input) {
+  return typeof input === "object" && input instanceof Date;
+}
+function parse$1(input, data) {
+  try {
+    if (validate$1(input)) {
+      return input;
+    }
+    if (typeof input === "string") {
+      const result = Date.parse(input);
+      if (Number.isNaN(result)) {
+        data?.errors.push({
+          message: `Error at ${data.instancePath}. Invalid date string.`,
+          instancePath: data.instancePath,
+          schemaPath: `${data.schemaPath}/type`
+        });
+        return void 0;
+      }
+      return new Date(result);
+    }
+    data.errors.push({
+      message: `Error at ${data.instancePath}. Invalid date.`,
+      instancePath: data.instancePath,
+      schemaPath: `${data.schemaPath}/type`
+    });
+    return void 0;
+  } catch (err) {
+    data.errors.push({
+      message: err instanceof Error ? err.message : `${err}`,
+      instancePath: data.instancePath,
+      schemaPath: data.schemaPath,
+      data: err
+    });
+    return undefined;
+  }
+}
+function coerce$1(input, options) {
+  if (typeof input === "number") {
+    return new Date(input);
+  }
+  return parse$1(input, options);
+}
+function serialize$1(input, data) {
+  if (data.instancePath.length === 0) {
+    return input.toISOString();
+  }
+  return `"${input.toISOString()}"`;
+}
+
+function sanitizeJson(json) {
+  return json.replace(/[\b]/g, "\\b").replace(/[\f]/g, "\\f").replace(/[\n]/g, "\\n").replace(/[\r]/g, "\\r").replace(/[\t]/g, "\\t");
+}
+function validate(schema, input) {
+  return schema[VALIDATOR_KEY].validate(input);
+}
+function parse(schema, input) {
+  const ctx = newValidationContext();
+  const result = schema[VALIDATOR_KEY].parse(input, ctx);
+  if (ctx.errors.length) {
+    return {
+      success: false,
+      errors: ctx.errors
+    };
+  }
+  return {
+    success: true,
+    value: result
+  };
+}
+function parseUnsafe(schema, input) {
+  const ctx = newValidationContext();
+  const result = schema[VALIDATOR_KEY].parse(input, ctx);
+  if (ctx.errors.length) {
+    throw new ValidationException({
+      message: `Unable to parse input. ${ctx.errors[0].message}`,
+      errors: ctx.errors
+    });
+  }
+  return result;
+}
+function coerce(schema, input) {
+  const ctx = newValidationContext();
+  const result = schema[VALIDATOR_KEY].coerce(input, ctx);
+  if (ctx.errors.length) {
+    return {
+      success: false,
+      errors: ctx.errors
+    };
+  }
+  return {
+    success: true,
+    value: result
+  };
+}
+function coerceUnsafe(schema, input) {
+  const ctx = newValidationContext();
+  const result = schema[VALIDATOR_KEY].coerce(input, ctx);
+  if (ctx.errors.length) {
+    throw new ValidationException({
+      message: `Unable to coerce input. ${ctx.errors[0]?.message}`,
+      errors: ctx.errors
+    });
+  }
+  return result;
+}
+function serialize(schema, input) {
+  try {
+    const context = newValidationContext();
+    const result = schema[VALIDATOR_KEY].serialize(input, context);
+    if (context.errors.length || typeof result === "undefined") {
+      return {
+        success: false,
+        errors: context.errors
+      };
+    }
+    return {
+      success: true,
+      value: result
+    };
+  } catch (err) {
+    if (err instanceof ValidationException) {
+      return {
+        success: false,
+        errors: err.errors
+      };
+    }
+    const errList = errors(schema, input);
+    if (errList.length) {
+      return {
+        success: false,
+        errors: errList
+      };
+    }
+    return {
+      success: false,
+      errors: [
+        {
+          message: err instanceof Error ? err.message : `${err}`,
+          instancePath: "/",
+          data: err
+        }
+      ]
+    };
+  }
+}
+function serializeUnsafe(schema, input) {
+  const result = serialize(schema, input);
+  if (!result.success) {
+    throw new ValidationException({
+      message: result.errors.length ? result.errors[0].message : `Unknown error`,
+      errors: result.errors
+    });
+  }
+  return result.value;
+}
+function errors(schema, input, exitOnFirstError = false) {
+  const errorList = [];
+  try {
+    schema[VALIDATOR_KEY].parse(input, {
+      errors: errorList,
+      instancePath: "",
+      schemaPath: "",
+      depth: 0,
+      maxDepth: 500,
+      exitOnFirstError
+    });
+  } catch (err) {
+    errorList.push({ instancePath: "", schemaPath: "", message: `${err}` });
+  }
+  return errorList;
+}
+
+const _namespace = {
+    __proto__: null,
+    any: any,
+    array: array,
+    boolean: boolean,
+    clone: clone,
+    coerce: coerce,
+    coerceUnsafe: coerceUnsafe,
+    compile: compile,
+    discriminator: discriminator,
+    enumerator: enumerator,
+    errors: errors,
+    extend: extend,
+    float32: float32,
+    float64: float64,
+    int16: int16,
+    int32: int32,
+    int64: int64,
+    int8: int8,
+    nullable: nullable,
+    number: number,
+    object: object,
+    omit: omit,
+    optional: optional,
+    parse: parse,
+    parseUnsafe: parseUnsafe,
+    partial: partial,
+    pick: pick,
+    record: record,
+    recursive: recursive,
+    serialize: serialize,
+    serializeUnsafe: serializeUnsafe,
+    string: string,
+    stringEnum: stringEnum,
+    timestamp: timestamp,
+    uint16: uint16,
+    uint32: uint32,
+    uint64: uint64,
+    uint8: uint8,
+    validate: validate
+};
 
-export { SCHEMA_METADATA, ValidationError, _namespace as a, any, array, boolean, clone, coerce, compile, createStandardSchemaProperty, discriminator, enumerator, errors, extend, float32, float64, getCompiledParser, getCompiledSerializer, createParsingTemplate as getSchemaParsingCode, createSerializationV2Template as getSchemaSerializationCode, createValidationTemplate as getSchemaValidationCode, int16, int16Max, int16Min, int32, int32Max, int32Min, int64, int8, int8Max, int8Min, isAAraySchema, isADiscriminatorSchema, isAObjectSchema, isARecordSchema, isARefSchema, isAScalarSchema, isAStringEnumSchema, isAdaptedSchema, nullable, number, object, omit, optional, parse, partial, pick, record, recursive, safeCoerce, safeParse, serialize, string, stringEnum, timestamp, uint16, uint16Max, uint16Min, uint32, uint32Max, uint32Min, uint64, uint8, uint8Max, uint8Min, validate, validatorFromAdaptedSchema };
+export { STR_ESCAPE, VALIDATOR_KEY, ValidationException, _namespace as a, any, array, boolean, clone, coerce, coerceUnsafe, compile, decodeObjectSchema, discriminator, enumerator, errorMessageFromErrors, errors, extend, float32, float64, getCompiledParser, getCompiledSerializer, createParsingTemplate as getSchemaDecodingCode, createSerializationV2Template as getSchemaSerializationCode, createValidationTemplate as getSchemaValidationCode, int16, int16Max, int16Min, int32, int32Max, int32Min, int64, int64Max, int64Min, int8, int8Max, int8Min, isAAraySchema, isADiscriminatorSchema, isAObjectSchema, isARecordSchema, isARefSchema, isAScalarSchema, isAStringEnumSchema, isObject, isValidationException, isValueError, newValidationContext, nullable, number, object, omit, optional, parse, parseUnsafe, partial, pick, record, recursive, sanitizeJson, serialize, serializeObject, serializeSmallString, serializeString, serializeUnsafe, string, stringEnum, timestamp, uint16, uint16Max, uint16Min, uint32, uint32Max, uint32Min, uint64, uint64Max, uint64Min, uint8, uint8Max, uint8Min, validate, validateObjectSchema };