@arrirpc/schema 0.73.0 → 0.74.1

package/dist/index.cjs

@@ -1,13 +1,34 @@
 'use strict';
 
 const typeDefs = require('@arrirpc/type-defs');
+const adapters = require('./shared/schema.Cwqn0t9l.cjs');
 const scule = require('scule');
-const timestamp = require('./shared/schema.COiEWm_0.cjs');
 
-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 = {};
@@ -17,7 +38,8 @@ function createParsingTemplate(input, schema) {
     schema,
     instancePath: "",
     schemaPath: "",
-    subFunctions
+    subFunctions,
+    shouldCoerce
   });
   const jsonTemplate = schemaTemplate$1({
     val: "json",
@@ -25,7 +47,8 @@ function createParsingTemplate(input, schema) {
     schema,
     instancePath: "",
     schemaPath: "",
-    subFunctions
+    subFunctions,
+    shouldCoerce
   });
   if (typeDefs.isSchemaFormProperties(schema) || typeDefs.isSchemaFormValues(schema) || typeDefs.isSchemaFormElements(schema) || typeDefs.isSchemaFormDiscriminator(schema)) {
     jsonParseCheck = `if (typeof ${input} === 'string') {
@@ -67,17 +90,17 @@ function schemaTemplate$1(input) {
       case "float32":
         return floatTemplate$1(input);
       case "int32":
-        return intTemplate$1(input, timestamp.int32Min, timestamp.int32Max);
+        return intTemplate$1(input, int32Min, int32Max);
       case "int16":
-        return intTemplate$1(input, timestamp.int16Min, timestamp.int16Max);
+        return intTemplate$1(input, int16Min, int16Max);
       case "int8":
-        return intTemplate$1(input, timestamp.int8Min, timestamp.int8Max);
+        return intTemplate$1(input, int8Min, int8Max);
       case "uint32":
-        return intTemplate$1(input, timestamp.uint32Min, timestamp.uint32Max);
+        return intTemplate$1(input, uint32Min, uint32Max);
       case "uint16":
-        return intTemplate$1(input, timestamp.uint16Min, timestamp.uint16Max);
+        return intTemplate$1(input, uint16Min, uint16Max);
       case "uint8":
-        return intTemplate$1(input, timestamp.uint8Min, timestamp.uint8Max);
+        return intTemplate$1(input, uint8Min, uint8Max);
       case "int64":
         return bigIntTemplate$2(input, false);
       case "uint64":
@@ -115,8 +138,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') {
@@ -152,7 +194,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 {
@@ -175,19 +217,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("}");
   }
@@ -198,31 +242,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("}");
   }
@@ -231,14 +280,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");
 }
@@ -247,7 +297,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 {`);
@@ -264,9 +314,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("}");
@@ -289,12 +339,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});
@@ -316,7 +395,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) {
@@ -333,7 +412,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}) {
@@ -396,7 +475,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);
   }
@@ -409,7 +489,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
@@ -452,10 +533,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} = [];
@@ -490,7 +572,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}
@@ -543,7 +626,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} = {};
@@ -593,8 +677,7 @@ function createSerializationV2Template(inputName, schema) {
     instancePath: "",
     outputPrefix: "",
     needsSanitization: [],
-    subFunctions
-  };
+    subFunctions};
   const result = template(context);
   if (typeDefs.isSchemaFormType(schema) || typeDefs.isSchemaFormEnum(schema)) {
     return result;
@@ -832,8 +915,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) {
@@ -856,8 +938,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}`,
@@ -866,8 +947,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}
@@ -893,8 +973,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}
             }`;
@@ -943,8 +1022,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) {
@@ -977,8 +1055,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];
@@ -1046,8 +1123,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;
@@ -1115,12 +1191,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]
   );
@@ -1128,7 +1202,7 @@ function createValidationTemplate(inputName, schema) {
     return ${template}`;
 }
 function schemaTemplate(input) {
-  if (timestamp.isAScalarSchema(input.schema)) {
+  if (adapters.isAScalarSchema(input.schema)) {
     switch (input.schema.type) {
       case "boolean":
         return booleanTemplate(input);
@@ -1136,17 +1210,17 @@ function schemaTemplate(input) {
       case "float64":
         return floatTemplate(input);
       case "int8":
-        return intTemplate(input, timestamp.int8Min, timestamp.int8Max);
+        return intTemplate(input, int8Min, int8Max);
       case "int16":
-        return intTemplate(input, timestamp.int16Min, timestamp.int16Max);
+        return intTemplate(input, int16Min, int16Max);
       case "int32":
-        return intTemplate(input, timestamp.int32Min, timestamp.int32Max);
+        return intTemplate(input, int32Min, int32Max);
       case "uint8":
-        return intTemplate(input, timestamp.uint8Min, timestamp.uint8Max);
+        return intTemplate(input, uint8Min, uint8Max);
       case "uint16":
-        return intTemplate(input, timestamp.uint16Min, timestamp.uint16Max);
+        return intTemplate(input, uint16Min, uint16Max);
       case "uint32":
-        return intTemplate(input, timestamp.uint32Min, timestamp.uint32Max);
+        return intTemplate(input, uint32Min, uint32Max);
       case "int64":
         return bigIntTemplate(input, false);
       case "uint64":
@@ -1157,22 +1231,22 @@ function schemaTemplate(input) {
         return timestampTemplate(input);
     }
   }
-  if (timestamp.isAObjectSchema(input.schema)) {
+  if (adapters.isAObjectSchema(input.schema)) {
     return objectTemplate(input);
   }
-  if (timestamp.isAStringEnumSchema(input.schema)) {
+  if (adapters.isAStringEnumSchema(input.schema)) {
     return enumTemplate(input);
   }
-  if (timestamp.isAAraySchema(input.schema)) {
+  if (adapters.isAAraySchema(input.schema)) {
     return arrayTemplate(input);
   }
-  if (timestamp.isARecordSchema(input.schema)) {
+  if (adapters.isARecordSchema(input.schema)) {
     return recordTemplate(input);
   }
-  if (timestamp.isADiscriminatorSchema(input.schema)) {
+  if (adapters.isADiscriminatorSchema(input.schema)) {
     return discriminatorTemplate(input);
   }
-  if (timestamp.isARefSchema(input.schema)) {
+  if (adapters.isARefSchema(input.schema)) {
     return refTemplate(input);
   }
   return "true";
@@ -1240,9 +1314,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) {
@@ -1253,16 +1325,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) {
@@ -1289,9 +1359,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)`;
   }
@@ -1303,9 +1371,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)`;
@@ -1322,18 +1388,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) {
@@ -1361,108 +1425,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 = adapters.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 = timestamp.errors(schema, input);
-      let errorMessage = err instanceof Error ? err.message : "";
-      if (errors.length) {
-        errorMessage = errors[0].message ?? `Parsing error at ${errors[0].instancePath}`;
+      if (context.errors.length) {
+        return {
+          success: false,
+          errors: context.errors
+        };
       }
-      throw new timestamp.ValidationError({
-        message: errorMessage,
-        errors
-      });
+      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 = adapters.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 = timestamp.errors(schema, input);
-        let errorMessage = err instanceof Error ? err.message : "";
-        if (errors.length) {
-          errorMessage = errors[0].message ?? `Parsing error at ${errors[0].instancePath}`;
-        }
+      }
+      return {
+        success: true,
+        value: result2
+      };
+    } catch (err) {
+      if (context.errors.length) {
         return {
           success: false,
-          error: new timestamp.ValidationError({
-            message: errorMessage,
-            errors
-          })
+          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 = adapters.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 = timestamp.errors(schema, input);
-        let errorMessage = err instanceof Error ? err.message : "";
-        if (errors.length) {
-          errorMessage = errors[0].message ?? `Serialization error at ${errors[0].instancePath}`;
-        }
-        throw new timestamp.ValidationError({ message: errorMessage, errors });
+    coerce,
+    coerceUnsafe(input) {
+      const context = adapters.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": timestamp.createStandardSchemaProperty(validate, parse)
+    "~standard": adapters.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 (typeDefs.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
@@ -1470,106 +1637,191 @@ function getCompiledParser(input, schema) {
       case "int32":
         if (schema.nullable) {
           return {
-            fn(input2) {
-              return nullableIntParser(input2, timestamp.int32Min, timestamp.int32Max);
+            fn(input2, context) {
+              return nullableIntDecoder(
+                input2,
+                int32Min,
+                int32Max,
+                context
+              );
             },
             code
           };
         }
         return {
-          fn(input2) {
-            return intParser(input2, timestamp.int32Min, timestamp.int32Max);
+          fn(input2, context) {
+            return intDecoder(input2, int32Min, int32Max, context);
           },
           code
         };
       case "int16":
         if (schema.nullable) {
           return {
-            fn(input2) {
-              return nullableIntParser(input2, timestamp.int16Min, timestamp.int16Max);
+            fn(input2, context) {
+              return nullableIntDecoder(
+                input2,
+                int16Min,
+                int16Max,
+                context
+              );
             },
             code
           };
         }
         return {
-          fn(input2) {
-            return intParser(input2, timestamp.int16Min, timestamp.int16Max);
+          fn(input2, context) {
+            return intDecoder(input2, int16Min, int16Max, context);
           },
           code
         };
       case "int8":
         if (schema.nullable) {
           return {
-            fn(input2) {
-              return nullableIntParser(input2, timestamp.int8Min, timestamp.int8Max);
+            fn(input2, context) {
+              return nullableIntDecoder(
+                input2,
+                int8Min,
+                int8Max,
+                context
+              );
             },
             code
           };
         }
         return {
-          fn(input2) {
-            return intParser(input2, timestamp.int8Min, timestamp.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,
-                timestamp.uint32Min,
-                timestamp.uint32Max
+                uint32Min,
+                uint32Max,
+                context
               );
             },
             code
           };
         }
         return {
-          fn(input2) {
-            return intParser(input2, timestamp.uint32Min, timestamp.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,
-                timestamp.uint16Min,
-                timestamp.uint16Max
+                uint16Min,
+                uint16Max,
+                context
               );
             },
             code
           };
         }
         return {
-          fn(input2) {
-            return intParser(input2, timestamp.uint16Min, timestamp.uint16Max);
+          fn(input2, context) {
+            return intDecoder(input2, uint16Min, uint16Max, context);
           },
           code
         };
       case "uint8":
         if (schema.nullable) {
           return {
-            fn(input2) {
-              return nullableIntParser(input2, timestamp.uint8Min, timestamp.uint8Max);
+            fn(input2, context) {
+              return nullableIntDecoder(
+                input2,
+                uint8Min,
+                uint8Max,
+                context
+              );
             },
             code
           };
         }
         return {
-          fn(input2) {
-            return intParser(input2, timestamp.uint8Min, timestamp.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;
@@ -1587,20 +1839,17 @@ function getCompiledParser(input, schema) {
               if (input2 === null) {
                 return null;
               }
-              throw new timestamp.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;
@@ -1612,22 +1861,19 @@ function getCompiledParser(input, schema) {
             if (typeof input2 === "boolean") {
               return input2;
             }
-            throw new timestamp.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;
@@ -1637,44 +1883,100 @@ function getCompiledParser(input, schema) {
               if (input2 === null) {
                 return null;
               }
-              throw new timestamp.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 timestamp.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;
@@ -1686,39 +1988,33 @@ function getCompiledParser(input, schema) {
               if (input2 === null) {
                 return null;
               }
-              throw new timestamp.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 timestamp.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
         };
@@ -1727,7 +2023,7 @@ function getCompiledParser(input, schema) {
   if (typeDefs.isSchemaFormEnum(schema)) {
     if (schema.nullable) {
       return {
-        fn(input2) {
+        fn(input2, context) {
           if (typeof input2 === "string") {
             for (const val of schema.enum) {
               if (input2 === val) {
@@ -1741,23 +2037,20 @@ function getCompiledParser(input, schema) {
           if (input2 === null) {
             return null;
           }
-          throw new timestamp.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) {
@@ -1765,70 +2058,58 @@ function getCompiledParser(input, schema) {
             }
           }
         }
-        throw new timestamp.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 timestamp.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 timestamp.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 timestamp.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;
@@ -1836,17 +2117,14 @@ function nullableFloatParser(input) {
   if (input === null) {
     return null;
   }
-  throw new timestamp.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;
@@ -1854,70 +2132,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 timestamp.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;
       }
-      return val;
+      if (val >= int64Min && val <= int64Max) {
+        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 timestamp.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 timestamp.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 timestamp.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;
@@ -1929,35 +2208,29 @@ function nullableIntParser(input, minNum, maxNum) {
   if (input === null) {
     return null;
   }
-  throw new timestamp.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 timestamp.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);
@@ -2089,193 +2362,1996 @@ function getCompiledSerializer(schema) {
   };
 }
 
-const _namespace = {
-    __proto__: null,
-    any: timestamp.any,
-    array: timestamp.array,
-    boolean: timestamp.boolean,
-    clone: timestamp.clone,
-    coerce: timestamp.coerce,
-    compile: compile,
-    discriminator: timestamp.discriminator,
-    enumerator: timestamp.enumerator,
-    errors: timestamp.errors,
-    extend: timestamp.extend,
-    float32: timestamp.float32,
-    float64: timestamp.float64,
-    int16: timestamp.int16,
-    int32: timestamp.int32,
-    int64: timestamp.int64,
-    int8: timestamp.int8,
-    nullable: timestamp.nullable,
-    number: timestamp.number,
-    object: timestamp.object,
-    omit: timestamp.omit,
-    optional: timestamp.optional,
-    parse: timestamp.parse,
-    partial: timestamp.partial,
-    pick: timestamp.pick,
-    record: timestamp.record,
-    recursive: timestamp.recursive,
-    safeCoerce: timestamp.safeCoerce,
-    safeParse: timestamp.safeParse,
-    serialize: timestamp.serialize,
-    string: timestamp.string,
-    stringEnum: timestamp.stringEnum,
-    timestamp: timestamp.timestamp,
-    uint16: timestamp.uint16,
-    uint32: timestamp.uint32,
-    uint64: timestamp.uint64,
-    uint8: timestamp.uint8,
-    validate: timestamp.validate
-};
-
-function isAdaptedSchema(input) {
-  return input.metadata[timestamp.SCHEMA_METADATA]._isAdapted === true;
-}
-function validatorFromAdaptedSchema(schema) {
-  const result = {
-    compiledCode: {
-      parse: "",
-      serialize: "",
-      validate: ""
-    },
-    validate: schema.metadata[timestamp.SCHEMA_METADATA].validate,
-    parse(input) {
-      const context = {
-        instancePath: "",
-        schemaPath: "",
-        errors: []
-      };
-      return schema.metadata[timestamp.SCHEMA_METADATA].parse(input, context);
-    },
-    safeParse(input) {
-      const context = {
-        instancePath: "",
-        schemaPath: "",
-        errors: []
-      };
+function any(options = {}) {
+  const validate = (input) => true;
+  const parse = (input, context) => {
+    if (context.instancePath.length === 0 && typeof input === "string") {
       try {
-        const result2 = schema.metadata[timestamp.SCHEMA_METADATA].parse(
-          input,
-          context
-        );
-        return {
-          success: true,
-          value: result2
-        };
-      } catch (err) {
-        if (err instanceof timestamp.ValidationError) {
-          return {
-            success: false,
-            error: err
-          };
+        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 {
-          success: false,
-          error: new timestamp.ValidationError({
-            message: context.errors[0]?.message ?? `Error parsing input. ${err}`,
-            errors: context.errors
-          })
-        };
       }
+      return input;
     },
+    validate,
     serialize(input) {
-      const context = {
-        instancePath: "",
-        schemaPath: "",
-        errors: []
-      };
-      return schema.metadata[timestamp.SCHEMA_METADATA].serialize(input, context);
+      return JSON.stringify(input);
+    }
+  };
+  const result = {
+    metadata: {
+      id: options.id,
+      description: options.description,
+      isDeprecated: options.isDeprecated
+    },
+    [adapters.VALIDATOR_KEY]: validator,
+    "~standard": adapters.createStandardSchemaProperty(validate, parse)
+  };
+  adapters.hideInvalidProperties(result);
+  return result;
+}
+
+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[adapters.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
+    },
+    [adapters.VALIDATOR_KEY]: validator,
+    "~standard": adapters.createStandardSchemaProperty(validateType, parseType)
+  };
+  adapters.hideInvalidProperties(result);
+  return result;
+}
+function validate$5(innerSchema, input) {
+  if (!Array.isArray(input)) {
+    return false;
+  }
+  for (const item of input) {
+    const isValid = innerSchema[adapters.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[adapters.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[adapters.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 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 = {
+    type: "boolean",
+    metadata: {
+      id: opts.id,
+      description: opts.description,
+      isDeprecated: opts.isDeprecated
+    },
+    [adapters.VALIDATOR_KEY]: validator,
+    "~standard": adapters.createStandardSchemaProperty(validate$4, parse$4)
+  };
+  adapters.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);
+    },
+    serialize(input, context) {
+      const discriminatorVal = input[discriminator2] ?? "";
+      const targetSchema = mapping[discriminatorVal];
+      if (!targetSchema) {
+        context.errors.push(
+          discriminatorMappingError(discriminatorVal, context)
+        );
+        return undefined;
+      }
+      const result2 = targetSchema[adapters.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
+    },
+    [adapters.VALIDATOR_KEY]: validator,
+    "~standard": adapters.createStandardSchemaProperty(isType, parseType)
+  };
+  adapters.hideInvalidProperties(result);
+  return result;
+}
+function validate$3(discriminator2, mapping, input) {
+  if (!adapters.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[adapters.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 (!adapters.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[adapters.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[adapters.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
+    },
+    [adapters.VALIDATOR_KEY]: validator,
+    "~standard": adapters.createStandardSchemaProperty(isType, parse)
+  };
+  adapters.hideInvalidProperties(result);
+  return result;
+}
+
+function nullable(schema, opts = {}) {
+  const isType = (val) => {
+    if (val === null) {
+      return true;
+    }
+    return schema[adapters.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[adapters.VALIDATOR_KEY].parse(val, data);
+  };
+  const validator = {
+    output: null,
+    optional: schema[adapters.VALIDATOR_KEY].optional,
+    validate: isType,
+    parse,
+    coerce(val, data) {
+      if (val === null) {
+        return null;
+      }
+      if (val === "null") {
+        return null;
+      }
+      return schema[adapters.VALIDATOR_KEY].coerce(val, data);
+    },
+    serialize(val, data) {
+      if (val === null) {
+        return "null";
+      }
+      return schema[adapters.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
+    },
+    [adapters.VALIDATOR_KEY]: validator,
+    "~standard": adapters.createStandardSchemaProperty(
+      validator.validate,
+      validator.parse
+    )
+  };
+  adapters.hideInvalidProperties(result);
+  return result;
+}
+function optional(input, opts = {}) {
+  const isType = (val) => {
+    if (val === undefined) {
+      return true;
+    }
+    return input[adapters.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[adapters.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[adapters.VALIDATOR_KEY].coerce(val, data);
+    },
+    serialize: (val, data) => {
+      if (typeof val === "undefined") {
+        return "undefined";
+      }
+      return input[adapters.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
+    },
+    [adapters.VALIDATOR_KEY]: validator,
+    "~standard": adapters.createStandardSchemaProperty(isType, parse)
+  };
+  adapters.hideInvalidProperties(result);
+  return result;
+}
+function clone(input, opts = {}) {
+  const validator = {
+    ...input[adapters.VALIDATOR_KEY]
+  };
+  const schema = {
+    ...input,
+    metadata: {
+      id: opts.id,
+      description: opts.description,
+      isDeprecated: opts.isDeprecated
+    },
+    [adapters.VALIDATOR_KEY]: validator,
+    "~standard": adapters.createStandardSchemaProperty(
+      validator.validate,
+      validator.parse
+    )
+  };
+  adapters.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
+    },
+    [adapters.VALIDATOR_KEY]: validator,
+    "~standard": adapters.createStandardSchemaProperty(isType, parse)
+  };
+  adapters.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
+    },
+    [adapters.VALIDATOR_KEY]: validator,
+    "~standard": adapters.createStandardSchemaProperty(isType, parse)
+  };
+  adapters.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
+    },
+    [adapters.VALIDATOR_KEY]: validator,
+    "~standard": adapters.createStandardSchemaProperty(validate, parse)
+  };
+  adapters.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[adapters.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
+    },
+    [adapters.VALIDATOR_KEY]: validator,
+    "~standard": adapters.createStandardSchemaProperty(validate, decode)
+  };
+  adapters.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 (!adapters.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[adapters.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[adapters.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[adapters.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[adapters.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 (!adapters.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[adapters.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[adapters.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
+    },
+    [adapters.VALIDATOR_KEY]: {
+      output: {},
+      parse,
+      coerce(input, context) {
+        return decodeObjectSchema(schema, input, context, false);
+      },
+      validate,
+      serialize(input, context) {
+        return serializeObject(schema, input, context);
+      }
+    },
+    "~standard": adapters.createStandardSchemaProperty(validate, parse)
+  };
+  adapters.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
+    },
+    [adapters.VALIDATOR_KEY]: {
+      output: {},
+      validate,
+      parse,
+      serialize(input, context) {
+        return serializeObject(schema, input, context);
+      },
+      coerce(input, context) {
+        return decodeObjectSchema(schema, input, context, true);
+      }
+    },
+    "~standard": adapters.createStandardSchemaProperty(validate, parse)
+  };
+  adapters.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[adapters.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[adapters.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,
+    [adapters.VALIDATOR_KEY]: validator,
+    "~standard": adapters.createStandardSchemaProperty(
+      validator.validate,
+      validator.parse
+    )
+  };
+  adapters.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[adapters.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[adapters.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,
+    [adapters.VALIDATOR_KEY]: validator,
+    ["~standard"]: adapters.createStandardSchemaProperty(
+      validator.validate,
+      validator.parse
+    )
+  };
+  adapters.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
+    },
+    [adapters.VALIDATOR_KEY]: validator,
+    "~standard": adapters.createStandardSchemaProperty(validate$2, decode)
+  };
+  adapters.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 (!adapters.isObject(input)) {
+      return false;
+    }
+    for (const key of Object.keys(input)) {
+      const val = input[key];
+      const isValid = schema[adapters.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[adapters.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
+    },
+    [adapters.VALIDATOR_KEY]: validator,
+    "~standard": adapters.createStandardSchemaProperty(validateFn, parseFn)
+  };
+  adapters.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 (!adapters.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[adapters.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[adapters.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 "";
     },
-    "~standard": timestamp.createStandardSchemaProperty(
-      schema.metadata[timestamp.SCHEMA_METADATA].validate,
-      schema.metadata[timestamp.SCHEMA_METADATA].parse
+    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,
+    [adapters.VALIDATOR_KEY]: validator,
+    "~standard": adapters.createStandardSchemaProperty(
+      validator.validate,
+      validator.parse
     )
   };
+  adapters.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[adapters.VALIDATOR_KEY].validate,
+    parse: mainSchema[adapters.VALIDATOR_KEY].parse,
+    serialize: mainSchema[adapters.VALIDATOR_KEY].serialize,
+    coerce: mainSchema[adapters.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
+    },
+    [adapters.VALIDATOR_KEY]: validator,
+    "~standard": adapters.createStandardSchemaProperty(validate$1, parse$1)
+  };
+  adapters.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[adapters.VALIDATOR_KEY].validate(input);
+}
+function parse(schema, input) {
+  const ctx = adapters.newValidationContext();
+  const result = schema[adapters.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 = adapters.newValidationContext();
+  const result = schema[adapters.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 = adapters.newValidationContext();
+  const result = schema[adapters.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 = adapters.newValidationContext();
+  const result = schema[adapters.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 = adapters.newValidationContext();
+    const result = schema[adapters.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[adapters.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
+};
 
-exports.NumberTypeValues = timestamp.NumberTypeValues;
-exports.SCHEMA_METADATA = timestamp.SCHEMA_METADATA;
-exports.STR_ESCAPE = timestamp.STR_ESCAPE;
-exports.ValidationError = timestamp.ValidationError;
-exports.any = timestamp.any;
-exports.array = timestamp.array;
-exports.boolean = timestamp.boolean;
-exports.clone = timestamp.clone;
-exports.coerce = timestamp.coerce;
-exports.createStandardSchemaProperty = timestamp.createStandardSchemaProperty;
-exports.discriminator = timestamp.discriminator;
-exports.enumerator = timestamp.enumerator;
-exports.errors = timestamp.errors;
-exports.extend = timestamp.extend;
-exports.float32 = timestamp.float32;
-exports.float64 = timestamp.float64;
-exports.hideInvalidProperties = timestamp.hideInvalidProperties;
-exports.int16 = timestamp.int16;
-exports.int16Max = timestamp.int16Max;
-exports.int16Min = timestamp.int16Min;
-exports.int32 = timestamp.int32;
-exports.int32Max = timestamp.int32Max;
-exports.int32Min = timestamp.int32Min;
-exports.int64 = timestamp.int64;
-exports.int64Max = timestamp.int64Max;
-exports.int64Min = timestamp.int64Min;
-exports.int8 = timestamp.int8;
-exports.int8Max = timestamp.int8Max;
-exports.int8Min = timestamp.int8Min;
-exports.isAAraySchema = timestamp.isAAraySchema;
-exports.isADiscriminatorSchema = timestamp.isADiscriminatorSchema;
-exports.isAObjectSchema = timestamp.isAObjectSchema;
-exports.isARecordSchema = timestamp.isARecordSchema;
-exports.isARefSchema = timestamp.isARefSchema;
-exports.isAScalarSchema = timestamp.isAScalarSchema;
-exports.isASchema = timestamp.isASchema;
-exports.isAStringEnumSchema = timestamp.isAStringEnumSchema;
-exports.isObject = timestamp.isObject;
-exports.isValidationError = timestamp.isValidationError;
-exports.nullable = timestamp.nullable;
-exports.number = timestamp.number;
-exports.object = timestamp.object;
-exports.omit = timestamp.omit;
-exports.optional = timestamp.optional;
-exports.parse = timestamp.parse;
-exports.parseObjectSchema = timestamp.parseObjectSchema;
-exports.partial = timestamp.partial;
-exports.pick = timestamp.pick;
-exports.record = timestamp.record;
-exports.recursive = timestamp.recursive;
-exports.safeCoerce = timestamp.safeCoerce;
-exports.safeParse = timestamp.safeParse;
-exports.sanitizeJson = timestamp.sanitizeJson;
-exports.serialize = timestamp.serialize;
-exports.serializeObject = timestamp.serializeObject;
-exports.serializeSmallString = timestamp.serializeSmallString;
-exports.serializeString = timestamp.serializeString;
-exports.string = timestamp.string;
-exports.stringEnum = timestamp.stringEnum;
-exports.timestamp = timestamp.timestamp;
-exports.uint16 = timestamp.uint16;
-exports.uint16Max = timestamp.uint16Max;
-exports.uint16Min = timestamp.uint16Min;
-exports.uint32 = timestamp.uint32;
-exports.uint32Max = timestamp.uint32Max;
-exports.uint32Min = timestamp.uint32Min;
-exports.uint64 = timestamp.uint64;
-exports.uint64Max = timestamp.uint64Max;
-exports.uint64Min = timestamp.uint64Min;
-exports.uint8 = timestamp.uint8;
-exports.uint8Max = timestamp.uint8Max;
-exports.uint8Min = timestamp.uint8Min;
-exports.validate = timestamp.validate;
-exports.validateObjectSchema = timestamp.validateObjectSchema;
+exports.NumberTypeValues = adapters.NumberTypeValues;
+exports.VALIDATOR_KEY = adapters.VALIDATOR_KEY;
+exports.isAAraySchema = adapters.isAAraySchema;
+exports.isADiscriminatorSchema = adapters.isADiscriminatorSchema;
+exports.isAObjectSchema = adapters.isAObjectSchema;
+exports.isARecordSchema = adapters.isARecordSchema;
+exports.isARefSchema = adapters.isARefSchema;
+exports.isAScalarSchema = adapters.isAScalarSchema;
+exports.isASchema = adapters.isASchema;
+exports.isAStringEnumSchema = adapters.isAStringEnumSchema;
+exports.isObject = adapters.isObject;
+exports.newValidationContext = adapters.newValidationContext;
+exports.STR_ESCAPE = STR_ESCAPE;
+exports.ValidationException = ValidationException;
 exports.a = _namespace;
+exports.any = any;
+exports.array = array;
+exports.boolean = boolean;
+exports.clone = clone;
+exports.coerce = coerce;
+exports.coerceUnsafe = coerceUnsafe;
 exports.compile = compile;
+exports.decodeObjectSchema = decodeObjectSchema;
+exports.discriminator = discriminator;
+exports.enumerator = enumerator;
+exports.errorMessageFromErrors = errorMessageFromErrors;
+exports.errors = errors;
+exports.extend = extend;
+exports.float32 = float32;
+exports.float64 = float64;
 exports.getCompiledParser = getCompiledParser;
 exports.getCompiledSerializer = getCompiledSerializer;
-exports.getSchemaParsingCode = createParsingTemplate;
+exports.getSchemaDecodingCode = createParsingTemplate;
 exports.getSchemaSerializationCode = createSerializationV2Template;
 exports.getSchemaValidationCode = createValidationTemplate;
-exports.isAdaptedSchema = isAdaptedSchema;
-exports.validatorFromAdaptedSchema = validatorFromAdaptedSchema;
+exports.int16 = int16;
+exports.int16Max = int16Max;
+exports.int16Min = int16Min;
+exports.int32 = int32;
+exports.int32Max = int32Max;
+exports.int32Min = int32Min;
+exports.int64 = int64;
+exports.int64Max = int64Max;
+exports.int64Min = int64Min;
+exports.int8 = int8;
+exports.int8Max = int8Max;
+exports.int8Min = int8Min;
+exports.isValidationException = isValidationException;
+exports.isValueError = isValueError;
+exports.nullable = nullable;
+exports.number = number;
+exports.object = object;
+exports.omit = omit;
+exports.optional = optional;
+exports.parse = parse;
+exports.parseUnsafe = parseUnsafe;
+exports.partial = partial;
+exports.pick = pick;
+exports.record = record;
+exports.recursive = recursive;
+exports.sanitizeJson = sanitizeJson;
+exports.serialize = serialize;
+exports.serializeObject = serializeObject;
+exports.serializeSmallString = serializeSmallString;
+exports.serializeString = serializeString;
+exports.serializeUnsafe = serializeUnsafe;
+exports.string = string;
+exports.stringEnum = stringEnum;
+exports.timestamp = timestamp;
+exports.uint16 = uint16;
+exports.uint16Max = uint16Max;
+exports.uint16Min = uint16Min;
+exports.uint32 = uint32;
+exports.uint32Max = uint32Max;
+exports.uint32Min = uint32Min;
+exports.uint64 = uint64;
+exports.uint64Max = uint64Max;
+exports.uint64Min = uint64Min;
+exports.uint8 = uint8;
+exports.uint8Max = uint8Max;
+exports.uint8Min = uint8Min;
+exports.validate = validate;
+exports.validateObjectSchema = validateObjectSchema;