@arrirpc/schema 0.45.0

package/dist/index.cjs

@@ -0,0 +1,2186 @@
+'use strict';
+
+const timestamp = require('./shared/schema.34cb5fb7.cjs');
+const jtdUtils = require('jtd-utils');
+const scule = require('scule');
+
+function createParsingTemplate(input, schema) {
+  const fallbackTemplate = `
+    function $fallback(instancePath, schemaPath) {
+        throw new Error(\`Error parsing input. InstancePath: "\${instancePath}". SchemaPath: "\${schemaPath}"\`);
+    }`;
+  let jsonParseCheck = "";
+  const subFunctions = {};
+  const template = schemaTemplate$1({
+    val: input,
+    targetVal: "result",
+    schema,
+    instancePath: "",
+    schemaPath: "",
+    subFunctions
+  });
+  const jsonTemplate = schemaTemplate$1({
+    val: "json",
+    targetVal: "result",
+    schema,
+    instancePath: "",
+    schemaPath: "",
+    subFunctions
+  });
+  if (jtdUtils.isSchemaFormProperties(schema) || jtdUtils.isSchemaFormValues(schema) || jtdUtils.isSchemaFormElements(schema) || jtdUtils.isSchemaFormDiscriminator(schema)) {
+    jsonParseCheck = `if (typeof ${input} === 'string') {
+            const json = JSON.parse(${input});
+            let result = {};
+            ${jsonTemplate}
+            return result;
+        }`;
+  }
+  if (jtdUtils.isSchemaFormEmpty(schema)) {
+    jsonParseCheck = `try {
+            const json = JSON.parse(${input});
+            return json;
+        } catch {
+            return ${input};
+        }`;
+  }
+  const functionBodyParts = Object.keys(subFunctions).map(
+    (key) => subFunctions[key]
+  );
+  const finalTemplate = `${fallbackTemplate}
+    ${functionBodyParts.join("\n")}
+    ${jsonParseCheck}
+    let result = {};
+    ${template}
+    return result;`;
+  return finalTemplate;
+}
+function schemaTemplate$1(input) {
+  if (jtdUtils.isSchemaFormType(input.schema)) {
+    switch (input.schema.type) {
+      case "boolean":
+        return booleanTemplate$2(input);
+      case "string":
+        return stringTemplate$2(input);
+      case "timestamp":
+        return timestampTemplate$2(input);
+      case "float64":
+      case "float32":
+        return floatTemplate$1(input);
+      case "int32":
+        return intTemplate$1(input, timestamp.int32Min, timestamp.int32Max);
+      case "int16":
+        return intTemplate$1(input, timestamp.int16Min, timestamp.int16Max);
+      case "int8":
+        return intTemplate$1(input, timestamp.int8Min, timestamp.int8Max);
+      case "uint32":
+        return intTemplate$1(input, timestamp.uint32Min, timestamp.uint32Max);
+      case "uint16":
+        return intTemplate$1(input, timestamp.uint16Min, timestamp.uint16Max);
+      case "uint8":
+        return intTemplate$1(input, timestamp.uint8Min, timestamp.uint8Max);
+      case "int64":
+        return bigIntTemplate$2(input, false);
+      case "uint64":
+        return bigIntTemplate$2(input, true);
+    }
+  }
+  if (jtdUtils.isSchemaFormEnum(input.schema)) {
+    return enumTemplate$2(input);
+  }
+  if (jtdUtils.isSchemaFormProperties(input.schema)) {
+    return objectTemplate$2(input);
+  }
+  if (jtdUtils.isSchemaFormElements(input.schema)) {
+    return arrayTemplate$2(input);
+  }
+  if (jtdUtils.isSchemaFormValues(input.schema)) {
+    return recordTemplate$2(input);
+  }
+  if (jtdUtils.isSchemaFormDiscriminator(input.schema)) {
+    return discriminatorTemplate$2(input);
+  }
+  if (jtdUtils.isSchemaFormRef(input.schema)) {
+    return refTemplate$2(input);
+  }
+  return anyTemplate$1(input);
+}
+function anyTemplate$1(input) {
+  if (input.instancePath.length === 0) {
+    return `try {
+            ${input.targetVal} = JSON.parse(${input.val});
+        } catch {
+            ${input.targetVal} = ${input.val};
+        }`;
+  }
+  return `${input.targetVal} = ${input.val}`;
+}
+function booleanTemplate$2(input) {
+  const errorMessage = input.instancePath.length ? `Expected boolean for ${input.instancePath}` : `Expected boolean`;
+  const templateParts = [];
+  if (input.instancePath.length === 0) {
+    templateParts.push(`if (typeof ${input.val} === 'string') {
+            if (${input.val} === 'true') {
+                ${input.targetVal} = true;
+            }
+            if (${input.val} === 'false') {
+                ${input.targetVal} = false;
+            }`);
+    if (input.schema.nullable) {
+      templateParts.push(`if (${input.val} === 'null') {
+                ${input.targetVal} = null;
+            }`);
+    }
+    templateParts.push(
+      `$fallback("${input.instancePath}", "${input.schemaPath}/type", "${errorMessage}");`
+    );
+    templateParts.push("}");
+  }
+  const mainTemplate = `if (typeof ${input.val} === 'boolean') {
+        ${input.targetVal} = ${input.val};
+    } else {
+        $fallback("${input.instancePath}", "${input.schemaPath}/type", "${errorMessage}");
+    }`;
+  if (input.schema.nullable) {
+    templateParts.push(`if (${input.val} === null) {
+            ${input.targetVal} = null;
+        } else {
+            ${mainTemplate}
+        }`);
+  } else {
+    templateParts.push(mainTemplate);
+  }
+  return templateParts.join("\n");
+}
+function stringTemplate$2(input) {
+  const errorMessage = `Expected string at ${input.instancePath}`;
+  const mainTemplate = `if (typeof ${input.val} === 'string') {
+        ${input.targetVal} = ${input.val};
+    } else {
+        $fallback("${input.instancePath}", "${input.schemaPath}/type", "${errorMessage}");
+    }`;
+  if (input.schema.nullable) {
+    return `if (${input.val} === null) {
+            ${input.targetVal} = ${input.val};
+        } else {
+            ${mainTemplate}
+        }`;
+  }
+  return mainTemplate;
+}
+function getVarName(input) {
+  return scule.camelCase(
+    input.split(".").join("_").split("[").join("_").split("]").join("_")
+  );
+}
+function floatTemplate$1(input) {
+  const valName = getVarName(`${input.val}Val`);
+  const templateParts = [];
+  if (input.instancePath.length === 0) {
+    templateParts.push(`if (typeof ${input.val} === 'string') {
+            const ${valName} = Number(${input.val});
+            if (!Number.isNaN(parsedVal)) {
+                ${input.targetVal} = ${valName};
+            }`);
+    if (input.schema.nullable) {
+      templateParts.push(`if (${input.val} === 'null') {
+                ${input.targetVal} = null;
+            }`);
+    }
+    templateParts.push(
+      `$fallback("${input.instancePath}", "${input.schemaPath}/type", \`Could not parse number from \${${input.val}}\`);`
+    );
+    templateParts.push("}");
+  }
+  const errorMessage = `Expected number at ${input.instancePath}`;
+  const mainTemplate = `if (typeof ${input.val} === 'number' && !Number.isNaN(${input.val})) {
+        ${input.targetVal} = ${input.val};
+    } else {
+        $fallback("${input.instancePath}", "${input.schemaPath}/type", "${errorMessage}");
+    }`;
+  if (input.schema.nullable) {
+    templateParts.push(`if (${input.val} === null) {
+            ${input.targetVal} = null;
+        } else {
+            ${mainTemplate}
+        }`);
+  } else {
+    templateParts.push(mainTemplate);
+  }
+  return templateParts.join("\n");
+}
+function intTemplate$1(input, min, max) {
+  const templateParts = [];
+  if (input.instancePath.length === 0) {
+    templateParts.push(`if (typeof ${input.val} === 'string') {
+            const parsedVal = Number(${input.val});
+            if (Number.isInteger(parsedVal) && parsedVal >= ${min} && parsedVal <= ${max}) {
+                ${input.targetVal} = ${input.val};
+            }`);
+    if (input.schema.nullable) {
+      templateParts.push(`if (${input.val} === 'null') {
+                ${input.targetVal} = null;
+            }`);
+    }
+    templateParts.push(
+      `$fallback("${input.instancePath}", "${input.schemaPath}", "Expected valid integer between ${min} and ${max});`
+    );
+    templateParts.push("}");
+  }
+  const mainTemplate = `if (typeof ${input.val} === 'number' && Number.isInteger(${input.val}) && ${input.val} >= ${min} && ${input.val} <= ${max}) {
+            ${input.targetVal} = ${input.val};
+        } else {
+            $fallback("${input.instancePath}", "${input.schemaPath}", "Expected valid integer between ${min} and ${max}");
+        }`;
+  if (input.schema.nullable) {
+    templateParts.push(`if (${input.val} === null) {
+            ${input.targetVal} = null;
+        } else {
+            ${mainTemplate}
+        }`);
+  } else {
+    templateParts.push(mainTemplate);
+  }
+  return templateParts.join("\n");
+}
+function bigIntTemplate$2(input, isUnsigned) {
+  const templateParts = [];
+  templateParts.push(
+    `if (typeof ${input.val} === 'string' || typeof ${input.val} === 'number') {`
+  );
+  if (input.instancePath.length === 0 && input.schema.nullable) {
+    templateParts.push(`if (${input.val} === 'null') {
+            ${input.targetVal} = null;
+        } else {`);
+  }
+  templateParts.push(`try { 
+        const val = BigInt(${input.val});`);
+  if (isUnsigned) {
+    templateParts.push(`if (val >= BigInt("0")) {
+            ${input.targetVal} = val;
+        } else {
+            $fallback("${input.instancePath}", "${input.schemaPath}", "Unsigned int must be greater than or equal to 0.");
+        }`);
+  } else {
+    templateParts.push(`${input.targetVal} = val;`);
+  }
+  templateParts.push(`} catch(err) {
+        $fallback("${input.instancePath}", "${input.schemaPath}", "Unable to parse BigInt from ${input.val}.");
+    }`);
+  if (input.instancePath.length === 0 && input.schema.nullable) {
+    templateParts.push("}");
+  }
+  templateParts.push("}");
+  if (isUnsigned) {
+    templateParts.push(`else if (typeof ${input.val} === 'bigint') {
+        if (${input.val} >= BigInt("0")) {
+            ${input.targetVal} = ${input.val};
+        } else {
+            $fallback("${input.instancePath}", "${input.schemaPath}", "Unsigned int must be greater than or equal to 0.");
+        }
+    }`);
+  } else {
+    templateParts.push(`else if (typeof ${input.val} === 'bigint') {
+            ${input.targetVal} = ${input.val};
+        }`);
+  }
+  if (input.schema.nullable) {
+    templateParts.push(`else if (${input.val} === null) {
+            ${input.targetVal} = null;
+        }`);
+  }
+  templateParts.push(`else {
+        $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.instancePath.length === 0) {
+    templateParts.push(`if (typeof ${input.val} === 'string') {
+            const parsedVal = new Date(${input.val});
+            if (!Number.isNaN(parsedVal.getMonth())) {
+                ${input.targetVal} = parsedVal;
+            }`);
+    if (input.schema.nullable) {
+      templateParts.push(`if (${input.val} === 'null') {
+                ${input.targetVal} = null;
+            }`);
+    }
+    templateParts.push(
+      `$fallback("${input.instancePath}", "${input.schemaPath}", "Expected instanceof Date or ISO Date string");`
+    );
+    templateParts.push("}");
+  }
+  const mainTemplate = `if (typeof ${input.val} === 'object' && ${input.val} instanceof Date) {
+        ${input.targetVal} = ${input.val};
+    } 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}")
+    }`;
+  if (input.schema.nullable) {
+    templateParts.push(`if (${input.val} === null) {
+            ${input.targetVal} = null
+        } else {
+            ${mainTemplate}
+        }`);
+  } else {
+    templateParts.push(mainTemplate);
+  }
+  return templateParts.join("\n");
+}
+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}) {
+            ${input.targetVal} = ${input.val};
+        }
+    `);
+  if (input.instancePath.length === 0 && input.schema.nullable) {
+    templateParts.push(`else if (${input.val} === 'null') {
+            ${input.targetVal} = null;
+        }`);
+  }
+  templateParts.push(
+    `else {
+            $fallback("${input.instancePath}", "${input.schemaPath}", "${errorMessage}"); 
+        }
+    } else {
+        $fallback("${input.instancePath}", "${input.schemaPath}", "${errorMessage}");
+    }`
+  );
+  const mainTemplate = templateParts.join("\n");
+  if (input.schema.nullable) {
+    return `if (${input.val} === null) {
+            ${input.targetVal} = null;
+        } else {
+            ${mainTemplate}
+        }`;
+  }
+  return mainTemplate;
+}
+function objectTemplate$2(input) {
+  const depthStr = getDepthStr(input.instancePath);
+  const innerTargetVal = `__${depthStr}`;
+  const parsingParts = [];
+  if (input.discriminatorKey && input.discriminatorValue) {
+    parsingParts.push(
+      `${innerTargetVal}.${input.discriminatorKey} = "${input.discriminatorValue}";`
+    );
+  }
+  if (!input.schema.additionalProperties) {
+    const keyVal = `_${depthStr}_keys`;
+    const optionalKeyVal = `_${depthStr}_optionalKeys`;
+    const keys = Object.keys(input.schema.properties).map((key) => `"${key}"`).join(",");
+    const optionalKeys = Object.keys(input.schema.optionalProperties ?? {}).map((key) => `"${key}"`).join(",");
+    parsingParts.push(
+      `const ${keyVal} = [${keys}];
+            const ${optionalKeyVal} = [${optionalKeys}];
+            for (let _key of Object.keys(${input.val})) {
+                if(!${keyVal}.includes(_key) && !${optionalKeyVal}.includes(_key) && _key !== "${input.discriminatorKey ?? ""}") {
+                    $fallback("${input.instancePath}", "${input.schemaPath}/additionalProperties", \`The following key is now allowed by the schema "\${_key}".\`);
+                }
+            }
+                `
+    );
+  }
+  for (const key of Object.keys(input.schema.properties)) {
+    const subSchema = input.schema.properties[key];
+    const innerTemplate = schemaTemplate$1({
+      val: `${input.val}.${key}`,
+      targetVal: `${innerTargetVal}.${key}`,
+      schema: subSchema,
+      instancePath: `${input.instancePath}/${key}`,
+      schemaPath: `${input.schemaPath}/properties/${key}`,
+      subFunctions: input.subFunctions
+    });
+    parsingParts.push(innerTemplate);
+  }
+  if (input.schema.optionalProperties) {
+    for (const key of Object.keys(input.schema.optionalProperties)) {
+      const subSchema = input.schema.optionalProperties[key];
+      const innerTemplate = schemaTemplate$1({
+        val: `${input.val}.${key}`,
+        targetVal: `${innerTargetVal}.${key}`,
+        schema: subSchema,
+        instancePath: `${input.instancePath}/${key}`,
+        schemaPath: `${input.schemaPath}/optionalProperties/${key}`,
+        subFunctions: input.subFunctions
+      });
+      parsingParts.push(`if (typeof ${input.val}.${key} === 'undefined') {
+                // ignore undefined
+            } else {
+                ${innerTemplate}
+            }`);
+    }
+  }
+  let mainTemplate = `if (typeof ${input.val} === 'object' && ${input.val} !== null) {
+        const ${innerTargetVal} = {};
+        ${parsingParts.join("\n")}
+        ${input.targetVal} = ${innerTargetVal};
+    } else {
+        $fallback("${input.instancePath}", "${input.schemaPath}", "Expected object");
+    }`;
+  const fnName = refFunctionName$1(input.schema.metadata?.id ?? "");
+  if (Object.keys(input.subFunctions).includes(fnName)) {
+    if (!input.subFunctions[fnName]) {
+      input.subFunctions[fnName] = `function ${fnName}(_fnVal) {
+                    let _fnTarget
+                ${mainTemplate.split(` ${input.val}`).join(" _fnVal").split(`(${input.val}`).join(`(_fnVal`).split(` ${input.targetVal}`).join(` _fnTarget`).split(`(${input.targetVal}`).join("(_fnTarget")}
+                return _fnTarget;
+            }`;
+    }
+    mainTemplate = `${input.targetVal} = ${fnName}(${input.val});`;
+  }
+  if (input.schema.nullable) {
+    return `if (${input.val} === null) {
+            ${input.targetVal} = null;
+        } else {
+            ${mainTemplate}
+        }`;
+  }
+  return mainTemplate;
+}
+function arrayTemplate$2(input) {
+  const resultVar = `__${getDepthStr(input.instancePath)}`;
+  const itemVar = `${resultVar}AItem`;
+  const itemResultVar = `${itemVar}AResult`;
+  const innerTemplate = schemaTemplate$1({
+    val: itemVar,
+    targetVal: itemResultVar,
+    instancePath: `${input.instancePath}/[0]`,
+    schemaPath: `${input.schemaPath}/elements`,
+    schema: input.schema.elements,
+    subFunctions: input.subFunctions
+  });
+  const mainTemplate = `if (Array.isArray(${input.val})) {
+        const ${resultVar} = [];
+        for(const ${itemVar} of ${input.val}) {
+            let ${itemResultVar};
+            ${innerTemplate}
+            ${resultVar}.push(${itemResultVar});
+        }
+        ${input.targetVal} = ${resultVar};
+    } else {
+        $fallback("${input.instancePath}", "${input.schemaPath}", "Expected Array");
+    }`;
+  if (input.schema.nullable) {
+    return `if (${input.val} === null) {
+            ${input.targetVal} = null;
+        } else {
+            ${mainTemplate}
+        }`;
+  }
+  return mainTemplate;
+}
+function discriminatorTemplate$2(input) {
+  const switchParts = [];
+  const types = Object.keys(input.schema.mapping);
+  for (const type of types) {
+    const innerSchema = input.schema.mapping[type];
+    const template = objectTemplate$2({
+      val: input.val,
+      targetVal: input.targetVal,
+      schema: innerSchema,
+      schemaPath: `${input.schemaPath}/mapping`,
+      instancePath: `${input.instancePath}`,
+      discriminatorKey: input.schema.discriminator,
+      discriminatorValue: type,
+      subFunctions: input.subFunctions
+    });
+    switchParts.push(`case "${type}": {
+            ${template}
+            break;
+        }`);
+  }
+  let mainTemplate = `if (typeof ${input.val} === 'object' && ${input.val} !== null) {
+        switch(${input.val}.${input.schema.discriminator}) {
+            ${switchParts.join("\n")}
+            default:
+                $fallback("${input.instancePath}", "${input.schemaPath}/mapping", "${input.val}.${input.schema.discriminator} did not match one of the specified values");
+                break;
+        }
+    } else {
+        $fallback("${input.instancePath}", "${input.schemaPath}", "Expected Object.");
+    }`;
+  const fnName = refFunctionName$1(input.schema.metadata?.id ?? "");
+  if (Object.keys(input.subFunctions).includes(fnName)) {
+    if (!input.subFunctions[fnName]) {
+      input.subFunctions[fnName] = `function ${fnName}(_fnVal) {
+                let _fnTarget;
+                ${mainTemplate.split(` ${input.val}`).join(` _fnVal`).split(`(${input.val}`).join(`(_fnVal`).split(` ${input.targetVal}`).join(` _fnTarget`).split(`(${input.targetVal}`).join(`(_fnTarget`)}
+                return _fnTarget;
+            }`;
+    }
+    mainTemplate = `${input.targetVal} = ${fnName}(${input.val});`;
+  }
+  if (input.schema.nullable) {
+    return `if (${input.val} === null) {
+            ${input.targetVal} = null;
+        } else {
+            ${mainTemplate}
+        }`;
+  }
+  return mainTemplate;
+}
+function getDepthStr(instancePath) {
+  const parts = instancePath.split("/");
+  const depth = parts.length;
+  return `D${depth}`;
+}
+function recordTemplate$2(input) {
+  const valPrefix = getDepthStr(input.instancePath);
+  const resultVal = `__${valPrefix}RResult`;
+  const loopVal = `__${valPrefix}RKey`;
+  const loopResultVal = `${loopVal}RVal`;
+  const innerTemplate = schemaTemplate$1({
+    val: `${input.val}[${loopVal}]`,
+    targetVal: loopResultVal,
+    instancePath: `${input.instancePath}/[key]`,
+    schemaPath: `${input.schemaPath}/values`,
+    schema: input.schema.values,
+    subFunctions: input.subFunctions
+  });
+  const mainTemplate = `if (typeof ${input.val} === 'object' && ${input.val} !== null) {
+        const ${resultVal} = {};
+        for(const ${loopVal} of Object.keys(${input.val})) {
+            let ${loopResultVal};
+            ${innerTemplate};
+            ${resultVal}[${loopVal}] = ${loopResultVal};
+        }
+        ${input.targetVal} = ${resultVal};
+    } else {
+        $fallback("${input.instancePath}", "${input.schemaPath}", "Expected object.");
+    }`;
+  if (input.schema.nullable) {
+    return `if (${input.val} === null) {
+            ${input.targetVal} = null;
+        } else {
+            ${mainTemplate}
+        }`;
+  }
+  return mainTemplate;
+}
+function refFunctionName$1(id) {
+  return `__parse_${id}`;
+}
+function refTemplate$2(input) {
+  const fnName = refFunctionName$1(input.schema.ref);
+  if (!Object.keys(input.subFunctions).includes(fnName)) {
+    input.subFunctions[fnName] = "";
+  }
+  if (input.schema.nullable) {
+    return `if (${input.val} === null) {
+            ${input.targetVal} = null;
+        } else {
+            ${input.targetVal} = ${fnName}(${input.val});
+        }`;
+  }
+  return `${input.targetVal} = ${fnName}(${input.val})`;
+}
+
+function createSerializationV2Template(inputName, schema) {
+  const subFunctions = {};
+  const context = {
+    val: inputName,
+    targetVal: "json",
+    schema,
+    schemaPath: "",
+    instancePath: "",
+    outputPrefix: "",
+    needsSanitization: [],
+    subFunctions
+  };
+  const result = template(context);
+  if (jtdUtils.isSchemaFormType(schema) || jtdUtils.isSchemaFormEnum(schema)) {
+    return result;
+  }
+  const subFunctionParts = Object.keys(subFunctions).map(
+    (key) => subFunctions[key]
+  );
+  return `
+    let json = '';
+    ${subFunctionParts.join("\n")}
+    ${context.needsSanitization.length > 0 ? `const STR_ESCAPE = /[\\u0000-\\u001f\\u0022\\u005c\\ud800-\\udfff]|[\\ud800-\\udbff](?![\\udc00-\\udfff])|(?:[^\\ud800-\\udbff]|^)[\\udc00-\\udfff]/;` : ""}
+    ${result}
+    return json;`;
+}
+function template(input) {
+  if (jtdUtils.isSchemaFormType(input.schema)) {
+    return scalarTemplate(input);
+  }
+  if (jtdUtils.isSchemaFormEnum(input.schema)) {
+    return enumTemplate$1(input);
+  }
+  if (jtdUtils.isSchemaFormProperties(input.schema)) {
+    return objectTemplate$1(input);
+  }
+  if (jtdUtils.isSchemaFormElements(input.schema)) {
+    return arrayTemplate$1(input);
+  }
+  if (jtdUtils.isSchemaFormValues(input.schema)) {
+    return recordTemplate$1(input);
+  }
+  if (jtdUtils.isSchemaFormDiscriminator(input.schema)) {
+    return discriminatorTemplate$1(input);
+  }
+  if (jtdUtils.isSchemaFormRef(input.schema)) {
+    return refTemplate$1(input);
+  }
+  return anyTemplate(input);
+}
+function scalarTemplate(input) {
+  switch (input.schema.type) {
+    case "string":
+      return stringTemplate$1(input);
+    case "boolean":
+      return booleanTemplate$1(input);
+    case "timestamp":
+      return timestampTemplate$1(input);
+    case "float32":
+    case "float64":
+      return numberTemplate(input);
+    case "int64":
+      return bigIntTemplate$1(input);
+    case "int32":
+    case "int16":
+    case "int8":
+      return numberTemplate(input);
+    case "uint64":
+      return bigIntTemplate$1(input);
+    case "uint32":
+    case "uint16":
+    case "uint8":
+      return numberTemplate(input);
+    default:
+      input.schema.type;
+      throw new Error("Invalid value in 'type'");
+  }
+}
+function stringTemplate$1(input) {
+  if (input.instancePath.length === 0) {
+    if (input.schema.nullable) {
+      return `if (typeof ${input.val} === 'string') {
+                return ${input.val};
+            }
+            return 'null';`;
+    }
+    return `return ${input.val};`;
+  }
+  input.needsSanitization.push(input.instancePath);
+  const mainTemplate = `${input.targetVal} += \`${input.outputPrefix ?? ""}\`;
+if (${input.val}.length < 42) {
+    let __result__ = "";
+    let __last__ = -1;
+    let __point__ = 255;
+    let __finished__ = false;
+    for (let i = 0; i < ${input.val}.length; i++) {
+        __point__ = ${input.val}.charCodeAt(i);
+        if (__point__ < 32 || (__point__ >= 0xd800 && __point__ <= 0xdfff)) {
+            ${input.targetVal} += JSON.stringify(${input.val});
+            __finished__ = true;
+            break;
+        }
+        if (__point__ === 0x22 || __point__ === 0x5c) {
+            __last__ === -1 && (__last__ = 0);
+            __result__ += ${input.val}.slice(__last__, i) + '\\\\';
+            __last__ = i;
+        }
+    }
+    if(!__finished__) {
+        if (__last__ === -1) {
+            ${input.targetVal} += \`"\${${input.val}}"\`;
+        } else {
+            ${input.targetVal} += \`"\${__result__}\${${input.val}.slice(__last__)}"\`;
+        }
+    }
+} else if (${input.val}.length < 5000 && !STR_ESCAPE.test(${input.val})) {
+    ${input.targetVal} += \`"\${${input.val}}"\`;
+} else {
+    ${input.targetVal} += JSON.stringify(${input.val});
+}`;
+  if (input.schema.nullable) {
+    return `if (typeof ${input.val} === 'string') {
+            ${mainTemplate}
+        } else {
+            ${input.targetVal} += '${input.outputPrefix ?? ""}null';
+        }`;
+  }
+  return mainTemplate;
+}
+function booleanTemplate$1(input) {
+  if (input.instancePath.length === 0) {
+    return `return \`\${${input.val}}\`;`;
+  }
+  const mainTemplate = `${input.targetVal} += \`${input.outputPrefix}\${${input.val}}\`;`;
+  if (input.schema.nullable) {
+    return `if (typeof ${input.val} === 'boolean') {
+            ${mainTemplate}
+        } else {
+            ${input.targetVal} += '${input.outputPrefix}null';
+        }`;
+  }
+  return mainTemplate;
+}
+function timestampTemplate$1(input) {
+  if (input.instancePath.length === 0) {
+    if (input.schema.nullable) {
+      return `if (typeof ${input.val} === 'object' && ${input.val} instanceof Date) {
+                return ${input.val}.toISOString();
+            }
+            return 'null';`;
+    }
+    return `return ${input.val}.toISOString();`;
+  }
+  const mainTemplate = `${input.targetVal} += \`${input.outputPrefix}"\${${input.val}.toISOString()}"\`;`;
+  if (input.schema.nullable) {
+    return `if (typeof ${input.val} === 'object' && ${input.val} instanceof Date) {
+            ${mainTemplate}
+        } else {
+            ${input.targetVal} += '${input.outputPrefix}null';
+        }`;
+  }
+  return mainTemplate;
+}
+function numberTemplate(input) {
+  if (input.instancePath.length === 0) {
+    if (input.schema.nullable) {
+      return `if (typeof ${input.val} === 'number' && !Number.isNaN(${input.val})) {
+                return \`\${${input.val}}\`;
+            }
+            return 'null';`;
+    }
+    return `return \`\${${input.val}}\`;`;
+  }
+  const mainTemplate = `
+    if(Number.isNaN(${input.val})) {
+        throw new Error("Expected number at ${input.instancePath} got NaN");
+    }
+    ${input.targetVal} += \`${input.outputPrefix}\${${input.val}}\`;`;
+  if (input.schema.nullable) {
+    return `if (typeof ${input.val} === 'number' && !Number.isNaN(${input.val})) {
+            ${mainTemplate}
+        } else {
+            ${input.targetVal} += '${input.outputPrefix}null';
+        }`;
+  }
+  return mainTemplate;
+}
+function bigIntTemplate$1(input) {
+  if (input.instancePath.length === 0) {
+    if (input.schema.nullable) {
+      return `if (typeof ${input.val} === 'bigint') {
+                return ${input.val}.toString();
+            }
+            return 'null';`;
+    }
+    return `return ${input.val}.toString();`;
+  }
+  const mainTemplate = `${input.targetVal} += \`${input.outputPrefix}"\${${input.val}.toString()}"\`;`;
+  if (input.schema.nullable) {
+    return `if (typeof ${input.val} === 'bigint') {
+            ${mainTemplate}
+        } else {
+            ${input.targetVal} += '${input.outputPrefix}null';
+        }`;
+  }
+  return mainTemplate;
+}
+function enumTemplate$1(input) {
+  if (input.instancePath.length === 0) {
+    if (input.schema.nullable) {
+      return `if (typeof ${input.val} === 'string') {
+                return ${input.val};
+            }
+            return 'null';`;
+    }
+    return `return ${input.val};`;
+  }
+  const mainTemplate = `${input.targetVal} += \`${input.outputPrefix}"\${${input.val}}"\``;
+  if (input.schema.nullable) {
+    return `if (typeof ${input.val} === 'string') {
+            ${mainTemplate}
+        } else {
+            ${input.targetVal} += '${input.outputPrefix}null';
+        }`;
+  }
+  return mainTemplate;
+}
+function objectTemplate$1(input) {
+  const templateParts = [`${input.targetVal} += '{';`];
+  if (input.discriminatorKey && input.discriminatorValue) {
+    templateParts.push(
+      `${input.targetVal} += \`"${input.discriminatorKey}":"${input.discriminatorValue}"\`;`
+    );
+  }
+  const propKeys = Object.keys(input.schema.properties);
+  const optionalPropKeys = Object.keys(input.schema.optionalProperties ?? {});
+  const isAllOptionalKeys = propKeys.length === 0 && !input.discriminatorKey?.length && !input.discriminatorValue?.length;
+  for (let i = 0; i < propKeys.length; i++) {
+    const key = propKeys[i];
+    const propSchema = input.schema.properties[key];
+    const includeComma = i !== 0 || input.discriminatorKey && input.discriminatorValue;
+    const innerTemplate = template({
+      schema: propSchema,
+      val: `___val___.${key}`,
+      targetVal: input.targetVal,
+      instancePath: `${input.instancePath}/${key}`,
+      schemaPath: `${input.schemaPath}/properties/${key}`,
+      outputPrefix: includeComma ? `,"${key}":` : `"${key}":`,
+      needsSanitization: input.needsSanitization,
+      subFunctions: input.subFunctions
+    });
+    templateParts.push(innerTemplate);
+  }
+  if (isAllOptionalKeys) {
+    const hasFieldsVar = input.instancePath.length ? scule.camelCase(`${input.instancePath}_HasFields`) : scule.camelCase(
+      `${input.val}_HasFields`.split("[").join("").split("]").join("")
+    );
+    templateParts.push(`let ${hasFieldsVar} = false;`);
+    for (let i = 0; i < optionalPropKeys.length; i++) {
+      const key = optionalPropKeys[i];
+      const optionalPropSchema = input.schema.optionalProperties?.[key];
+      if (!optionalPropSchema) {
+        continue;
+      }
+      const innerVal = `___val___.${key}`;
+      const innerTemplate = template({
+        schema: optionalPropSchema,
+        schemaPath: `${input.schemaPath}/optionalProperties/${key}`,
+        instancePath: `${input.instancePath}/${key}`,
+        val: innerVal,
+        targetVal: input.targetVal,
+        outputPrefix: `"${key}":`,
+        needsSanitization: input.needsSanitization,
+        subFunctions: input.subFunctions
+      });
+      const innerTemplateWithComma = template({
+        schema: optionalPropSchema,
+        schemaPath: `${input.schemaPath}/optionalProperties/${key}`,
+        instancePath: `${input.instancePath}/${key}`,
+        val: innerVal,
+        targetVal: input.targetVal,
+        outputPrefix: `,"${key}":`,
+        needsSanitization: input.needsSanitization,
+        subFunctions: input.subFunctions
+      });
+      templateParts.push(`if (typeof ${innerVal} !== 'undefined') {
+                if (${hasFieldsVar}) {
+                    ${innerTemplateWithComma}
+                } else {
+                    ${innerTemplate}
+                    ${hasFieldsVar} = true;
+                }
+            }`);
+    }
+  } else {
+    for (let i = 0; i < optionalPropKeys.length; i++) {
+      const key = optionalPropKeys[i];
+      const optionalPropSchema = input.schema.optionalProperties?.[key];
+      if (!optionalPropSchema) {
+        continue;
+      }
+      const innerVal = `___val___.${key}`;
+      const innerTemplate = template({
+        schema: optionalPropSchema,
+        schemaPath: `${input.schemaPath}/optionalProperties/${key}`,
+        instancePath: `${input.instancePath}/${key}`,
+        val: innerVal,
+        targetVal: "json",
+        outputPrefix: `,"${key}":`,
+        needsSanitization: input.needsSanitization,
+        subFunctions: input.subFunctions
+      });
+      const completeInnerTemplate = `if (typeof ${innerVal} !== 'undefined') {
+                ${innerTemplate}
+            }`;
+      templateParts.push(completeInnerTemplate);
+    }
+  }
+  templateParts.push(`${input.targetVal} += '}';`);
+  let mainTemplate = templateParts.join("\n");
+  const fnName = refFnName(input.schema.metadata?.id ?? "");
+  if (hasFunctionName(fnName, input.subFunctions)) {
+    if (!hasFunctionBody(fnName, input.subFunctions)) {
+      input.subFunctions[fnName] = `function ${fnName}(__inputVal__) {
+                ${mainTemplate.split("___val___").join("__inputVal__")}
+            }`;
+    }
+    mainTemplate = `${fnName}(${input.val});`;
+  }
+  if (input.schema.nullable) {
+    return `if (typeof ${input.val} === 'object' && ${input.val} !== null) {
+            ${input.targetVal} += '${input.outputPrefix}';
+            ${mainTemplate.split("___val___").join(input.val)}
+        } else {
+            ${input.targetVal} += '${input.outputPrefix}null';
+        }`;
+  }
+  return `
+    ${input.targetVal} += '${input.outputPrefix}';
+    ${mainTemplate.split("___val___").join(input.val)}`;
+}
+function hasFunctionName(name, fns) {
+  return typeof fns[name] === "string";
+}
+function hasFunctionBody(name, fns) {
+  return typeof fns[name] === "string" && fns[name].length > 0;
+}
+function arrayTemplate$1(input) {
+  const itemVarName = scule.camelCase(`${input.val || "list"}_item`);
+  const templateParts = [
+    `${input.targetVal} += '${input.outputPrefix}[';`
+  ];
+  const innerTemplate = template({
+    schema: input.schema.elements,
+    schemaPath: `${input.schemaPath}/elements`,
+    instancePath: `${input.instancePath}/i`,
+    val: itemVarName,
+    targetVal: input.targetVal,
+    outputPrefix: "",
+    needsSanitization: input.needsSanitization,
+    subFunctions: input.subFunctions
+  });
+  templateParts.push(`for (let i = 0; i < ${input.val}.length; i++) {
+        const ${itemVarName} = ${input.val}[i];
+        if (i !== 0) {
+            ${input.targetVal} += ',';
+        }
+        ${innerTemplate}
+    }`);
+  templateParts.push(`${input.targetVal} += ']';`);
+  const mainTemplate = templateParts.join("\n");
+  if (input.schema.nullable) {
+    return `if (Array.isArray(${input.val})) {
+            ${mainTemplate}
+        } else {
+            ${input.targetVal} += '${input.outputPrefix}null';
+        }`;
+  }
+  return mainTemplate;
+}
+function recordTemplate$1(input) {
+  const keysVarName = input.instancePath.length ? scule.camelCase(input.instancePath.split("/").join("_")) + "Keys" : scule.camelCase(`${input.val.split(".").join("_")}_Keys`);
+  const templateParts = [
+    `const ${keysVarName} = Object.keys(${input.val});`,
+    `${input.targetVal} += '${input.outputPrefix}{';`
+  ];
+  const innerTemplate = template({
+    schema: input.schema.values,
+    schemaPath: `${input.schemaPath}/values`,
+    instancePath: `${input.instancePath}/key`,
+    val: `innerVal`,
+    targetVal: input.targetVal,
+    outputPrefix: "",
+    needsSanitization: input.needsSanitization,
+    subFunctions: input.subFunctions
+  });
+  templateParts.push(`for (let i = 0; i < ${keysVarName}.length; i++) {
+        const key = ${keysVarName}[i];
+        const innerVal = ${input.val}[key];
+        if(i !== 0) {
+            ${input.targetVal} += \`,"\${key}":\`;
+        } else {
+            ${input.targetVal} += \`"\${key}":\`;
+        }
+        ${innerTemplate}
+    }`);
+  templateParts.push(`${input.targetVal} += '}';`);
+  const mainTemplate = templateParts.join("\n");
+  if (input.schema.nullable) {
+    return `if (typeof ${input.val} === 'object' && ${input.val} !== null) {
+            ${mainTemplate}
+        } else {
+            ${input.targetVal} += '${input.outputPrefix}null';
+        }`;
+  }
+  return mainTemplate;
+}
+function discriminatorTemplate$1(input) {
+  const discriminatorKey = input.schema.discriminator;
+  const discriminatorVals = Object.keys(input.schema.mapping);
+  const inputPlaceholder = "<<<tempval>>>";
+  const templateParts = [`switch(${inputPlaceholder}.${discriminatorKey}) {`];
+  for (const val of discriminatorVals) {
+    const valSchema = input.schema.mapping[val];
+    const innerTemplate = template({
+      schema: valSchema,
+      schemaPath: `${input.schemaPath}/mapping/${val}`,
+      instancePath: `${input.instancePath}`,
+      val: inputPlaceholder,
+      targetVal: input.targetVal,
+      discriminatorKey,
+      discriminatorValue: val,
+      outputPrefix: input.outputPrefix,
+      needsSanitization: input.needsSanitization,
+      subFunctions: input.subFunctions
+    });
+    templateParts.push(`case '${val}': {
+            ${innerTemplate}
+            break;
+        }`);
+  }
+  templateParts.push("}");
+  let mainTemplate = templateParts.join("\n");
+  const fnName = refFnName(input.schema.metadata?.id ?? "");
+  if (hasFunctionName(fnName, input.subFunctions)) {
+    if (!hasFunctionBody(fnName, input.subFunctions)) {
+      input.subFunctions[fnName] = `function ${fnName}(__fnInput__){
+                ${mainTemplate.split(inputPlaceholder).join("__fnInput__")}
+            }`;
+    }
+    mainTemplate = `${fnName}(${input.val});`;
+  }
+  if (input.schema.nullable) {
+    return `if (typeof ${input.val} === 'object' && ${input.val} !== null) {
+            ${mainTemplate.split(inputPlaceholder).join(input.val)}
+        } else {
+            ${input.targetVal} += '${input.outputPrefix}null';
+        }`;
+  }
+  return mainTemplate.split(inputPlaceholder).join(input.val);
+}
+function anyTemplate(input) {
+  if (input.outputPrefix) {
+    const mainTemplate = `if (typeof ${input.val} !== 'undefined') {
+            ${input.targetVal} += '${input.outputPrefix}' + JSON.stringify(${input.val});
+        }`;
+    if (input.schema.nullable) {
+      return `if (${input.val} === null) {
+                ${input.targetVal} += '${input.outputPrefix}null';
+            } else {
+                ${mainTemplate}
+            }`;
+    }
+    return mainTemplate;
+  }
+  return `if (typeof ${input.val} !== 'undefined') {
+        ${input.targetVal} += JSON.stringify(${input.val});
+    }`;
+}
+function refFnName(id) {
+  return `__serialize_${id}`;
+}
+function refTemplate$1(input) {
+  const fnName = refFnName(input.schema.ref);
+  if (!Object.keys(input.subFunctions).includes(fnName)) {
+    input.subFunctions[fnName] = "";
+  }
+  if (input.schema.nullable) {
+    return `if (${input.val} === null) {
+            ${input.targetVal} += '${input.outputPrefix}null';
+        } else {
+            ${input.targetVal} += '${input.outputPrefix}';
+            ${fnName}(${input.val});
+        }`;
+  }
+  return `${input.targetVal} += '${input.outputPrefix}';
+    ${fnName}(${input.val});`;
+}
+
+function createValidationTemplate(inputName, schema) {
+  const subFunctions = {};
+  const template = schemaTemplate({
+    val: inputName,
+    targetVal: "",
+    schema,
+    schemaPath: ``,
+    instancePath: "",
+    subFunctions
+  });
+  const subFunctionBodies = Object.keys(subFunctions).map(
+    (key) => subFunctions[key]
+  );
+  return `${subFunctionBodies.join("\n")}
+    return ${template}`;
+}
+function schemaTemplate(input) {
+  if (timestamp.isAScalarSchema(input.schema)) {
+    switch (input.schema.type) {
+      case "boolean":
+        return booleanTemplate(input);
+      case "float32":
+      case "float64":
+        return floatTemplate(input);
+      case "int8":
+        return intTemplate(input, timestamp.int8Min, timestamp.int8Max);
+      case "int16":
+        return intTemplate(input, timestamp.int16Min, timestamp.int16Max);
+      case "int32":
+        return intTemplate(input, timestamp.int32Min, timestamp.int32Max);
+      case "uint8":
+        return intTemplate(input, timestamp.uint8Min, timestamp.uint8Max);
+      case "uint16":
+        return intTemplate(input, timestamp.uint16Min, timestamp.uint16Max);
+      case "uint32":
+        return intTemplate(input, timestamp.uint32Min, timestamp.uint32Max);
+      case "int64":
+        return bigIntTemplate(input, false);
+      case "uint64":
+        return bigIntTemplate(input, true);
+      case "string":
+        return stringTemplate(input);
+      case "timestamp":
+        return timestampTemplate(input);
+    }
+  }
+  if (timestamp.isAObjectSchema(input.schema)) {
+    return objectTemplate(input);
+  }
+  if (timestamp.isAStringEnumSchema(input.schema)) {
+    return enumTemplate(input);
+  }
+  if (timestamp.isAAraySchema(input.schema)) {
+    return arrayTemplate(input);
+  }
+  if (timestamp.isARecordSchema(input.schema)) {
+    return recordTemplate(input);
+  }
+  if (timestamp.isADiscriminatorSchema(input.schema)) {
+    return discriminatorTemplate(input);
+  }
+  if (timestamp.isARefSchema(input.schema)) {
+    return refTemplate(input);
+  }
+  return "true";
+}
+function booleanTemplate(input) {
+  if (input.schema.nullable) {
+    return `(${input.val} === null || typeof ${input.val} === 'boolean')`;
+  }
+  return `typeof ${input.val} === 'boolean'`;
+}
+function floatTemplate(input) {
+  if (input.schema.nullable) {
+    return `((typeof ${input.val} === 'number' && !Number.isNaN(${input.val})) || ${input.val} === null)`;
+  }
+  return `(typeof ${input.val} === 'number' && !Number.isNaN(${input.val}))`;
+}
+function intTemplate(input, min, max) {
+  if (input.schema.nullable) {
+    return `((typeof ${input.val} === 'number' && Number.isInteger(${input.val}) && ${input.val} >= ${min} && ${input.val} <= ${max}) || ${input.val} === null)`;
+  }
+  return `(typeof ${input.val} === 'number' && Number.isInteger(${input.val}) && ${input.val} >= ${min} && ${input.val} <= ${max})`;
+}
+function bigIntTemplate(input, isUnsigned = false) {
+  const mainTemplate = isUnsigned ? `typeof ${input.val} === 'bigint' && ${input.val} >= BigInt("0")` : `typeof ${input.val} === 'bigint' && ${input.val} < BigInt("9223372036854775808") && ${input.val} > BigInt("-9223372036854775809")`;
+  if (input.schema.nullable) {
+    return `(${mainTemplate}) || ${input.val} === null`;
+  }
+  return mainTemplate;
+}
+function stringTemplate(input) {
+  if (input.schema.nullable) {
+    return `(typeof ${input.val} === 'string' || ${input.val} === null)`;
+  }
+  return `typeof ${input.val} === 'string'`;
+}
+function timestampTemplate(input) {
+  if (input.schema.nullable) {
+    return `((typeof ${input.val} === 'object' && ${input.val} instanceof Date) || ${input.val} === null)`;
+  }
+  return `typeof ${input.val} === 'object' && ${input.val}  instanceof Date`;
+}
+function objectTemplate(input) {
+  const parts = [];
+  if (input.discriminatorKey && input.discriminatorValue) {
+    parts.push(
+      `${input.val}.${input.discriminatorKey} === "${input.discriminatorValue}"`
+    );
+  } else {
+    parts.push(`typeof ${input.val} === 'object' && ${input.val} !== null`);
+  }
+  if (!input.schema.additionalProperties) {
+    const allowedKeys = Object.keys(input.schema.properties);
+    for (const key of Object.keys(input.schema.optionalProperties ?? {})) {
+      allowedKeys.push(key);
+    }
+    parts.push(
+      `Object.keys(${input.val}).every((key) => "${input.discriminatorKey}" === key || ${JSON.stringify(allowedKeys)}.includes(key))`
+    );
+  }
+  for (const key of Object.keys(input.schema.properties)) {
+    const prop = input.schema.properties[key];
+    parts.push(
+      schemaTemplate({
+        schema: prop,
+        schemaPath: `${input.schemaPath}/properties/${key}`,
+        instancePath: `${input.instancePath}/${key}`,
+        val: `${input.val}.${key}`,
+        targetVal: "",
+        subFunctions: input.subFunctions
+      })
+    );
+  }
+  if (input.schema.optionalProperties) {
+    for (const key of Object.keys(input.schema.optionalProperties)) {
+      const prop = input.schema.optionalProperties[key];
+      const template = schemaTemplate({
+        schema: prop,
+        schemaPath: `${input.schemaPath}/optionalProperties/${key}`,
+        instancePath: `${input.instancePath}/${key}`,
+        val: `${input.val}.${key}`,
+        targetVal: "",
+        subFunctions: input.subFunctions
+      });
+      parts.push(
+        `(typeof ${input.val}.${key} === 'undefined' || (${template}))`
+      );
+    }
+  }
+  let mainTemplate = parts.join(" && ");
+  const fnName = refFunctionName(input.schema.metadata.id ?? "");
+  if (Object.keys(input.subFunctions).includes(fnName)) {
+    if (!input.subFunctions[fnName]) {
+      input.subFunctions[fnName] = `function ${fnName}(input) {
+            return ${mainTemplate}
+        }`;
+    }
+    mainTemplate = `${fnName}(${input.val})`;
+  }
+  if (input.schema.nullable) {
+    return `((${mainTemplate}) || ${input.val} === null)`;
+  }
+  return mainTemplate;
+}
+function enumTemplate(input) {
+  const enumPart = input.schema.enum.map((val) => `${input.val} === "${val}"`).join(" || ");
+  if (input.schema.nullable) {
+    return `((typeof ${input.val} === 'string' && (${enumPart})) || ${input.val} === null)`;
+  }
+  return `(typeof ${input.val} === 'string' && (${enumPart}))`;
+}
+function arrayTemplate(input) {
+  const innerTemplate = schemaTemplate({
+    val: "item",
+    instancePath: `${input.instancePath}/item`,
+    schemaPath: `${input.schemaPath}/elements`,
+    schema: input.schema.elements,
+    targetVal: "",
+    subFunctions: input.subFunctions
+  });
+  if (input.schema.nullable) {
+    return `((Array.isArray(${input.val}) && ${input.val}.every((item) => ${innerTemplate})) || ${input.val} === null)`;
+  }
+  return `(Array.isArray(${input.val}) && ${input.val}.every((item) => ${innerTemplate}))`;
+}
+function recordTemplate(input) {
+  const subTemplate = schemaTemplate({
+    schema: input.schema.values,
+    instancePath: `${input.instancePath}`,
+    schemaPath: `${input.schemaPath}/values`,
+    val: `${input.val}[key]`,
+    targetVal: "",
+    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)`;
+  }
+  return mainTemplate;
+}
+function discriminatorTemplate(input) {
+  const parts = [];
+  for (const discriminatorVal of Object.keys(input.schema.mapping)) {
+    const subSchema = input.schema.mapping[discriminatorVal];
+    if (!subSchema) {
+      continue;
+    }
+    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
+      })
+    );
+  }
+  let mainTemplate = `typeof ${input.val} === 'object' && ${input.val} !== null && (${parts.join(" || ")})`;
+  const fnName = refFunctionName(input.schema.metadata.id ?? "");
+  if (Object.keys(input.subFunctions).includes(fnName)) {
+    if (!input.subFunctions[fnName]) {
+      input.subFunctions[fnName] = `function ${fnName}(input) {
+            return ${mainTemplate}
+        }`;
+    }
+    mainTemplate = `${fnName}(${input.val})`;
+  }
+  if (input.schema.nullable) {
+    return `((${mainTemplate}) || ${input.val} === null)`;
+  }
+  return mainTemplate;
+}
+function refFunctionName(id) {
+  return `__validate_${id}`;
+}
+function refTemplate(input) {
+  const fnName = refFunctionName(input.schema.ref);
+  if (!Object.keys(input.subFunctions).includes(fnName)) {
+    input.subFunctions[fnName] = "";
+  }
+  if (input.schema.nullable) {
+    return `(${input.val} === null || ${fnName}(${input.val}))`;
+  }
+  return `${fnName}(${input.val})`;
+}
+
+function compile(schema) {
+  const validateCode = createValidationTemplate("input", schema);
+  const parser = getCompiledParser("input", schema);
+  const parseFn = parser.fn;
+  const serializer = getCompiledSerializer(schema);
+  const serializeFn = serializer.fn;
+  const validate = new Function(
+    "input",
+    validateCode
+  );
+  return {
+    validate,
+    parse(input) {
+      try {
+        return parseFn(input);
+      } 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}`;
+        }
+        throw new timestamp.ValidationError({
+          message: errorMessage,
+          errors
+        });
+      }
+    },
+    safeParse(input) {
+      try {
+        const result = parseFn(input);
+        return {
+          success: true,
+          value: result
+        };
+      } 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: false,
+          error: new timestamp.ValidationError({
+            message: errorMessage,
+            errors
+          })
+        };
+      }
+    },
+    // eslint-disable-next-line no-eval
+    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 });
+      }
+    },
+    compiledCode: {
+      validate: validateCode,
+      parse: parser.code,
+      serialize: serializer.code
+    }
+  };
+}
+function getCompiledParser(input, schema) {
+  const code = createParsingTemplate(input, schema);
+  if (jtdUtils.isSchemaFormType(schema)) {
+    switch (schema.type) {
+      case "float32":
+      case "float64":
+        if (schema.nullable) {
+          return {
+            fn: nullableFloatParser,
+            code
+          };
+        }
+        return {
+          fn: compiledFloatParser,
+          code
+        };
+      case "int64":
+        return {
+          fn(input2) {
+            return bigIntParser(
+              input2,
+              false,
+              schema.nullable ?? false
+            );
+          },
+          code
+        };
+      case "uint64":
+        return {
+          fn(input2) {
+            return bigIntParser(
+              input2,
+              true,
+              schema.nullable ?? false
+            );
+          },
+          code
+        };
+      case "int32":
+        if (schema.nullable) {
+          return {
+            fn(input2) {
+              return nullableIntParser(input2, timestamp.int32Min, timestamp.int32Max);
+            },
+            code
+          };
+        }
+        return {
+          fn(input2) {
+            return intParser(input2, timestamp.int32Min, timestamp.int32Max);
+          },
+          code
+        };
+      case "int16":
+        if (schema.nullable) {
+          return {
+            fn(input2) {
+              return nullableIntParser(input2, timestamp.int16Min, timestamp.int16Max);
+            },
+            code
+          };
+        }
+        return {
+          fn(input2) {
+            return intParser(input2, timestamp.int16Min, timestamp.int16Max);
+          },
+          code
+        };
+      case "int8":
+        if (schema.nullable) {
+          return {
+            fn(input2) {
+              return nullableIntParser(input2, timestamp.int8Min, timestamp.int8Max);
+            },
+            code
+          };
+        }
+        return {
+          fn(input2) {
+            return intParser(input2, timestamp.int8Min, timestamp.int8Max);
+          },
+          code
+        };
+      case "uint32":
+        if (schema.nullable) {
+          return {
+            fn(input2) {
+              return nullableIntParser(
+                input2,
+                timestamp.uint32Min,
+                timestamp.uint32Max
+              );
+            },
+            code
+          };
+        }
+        return {
+          fn(input2) {
+            return intParser(input2, timestamp.uint32Min, timestamp.uint32Max);
+          },
+          code
+        };
+      case "uint16":
+        if (schema.nullable) {
+          return {
+            fn(input2) {
+              return nullableIntParser(
+                input2,
+                timestamp.uint16Min,
+                timestamp.uint16Max
+              );
+            },
+            code
+          };
+        }
+        return {
+          fn(input2) {
+            return intParser(input2, timestamp.uint16Min, timestamp.uint16Max);
+          },
+          code
+        };
+      case "uint8":
+        if (schema.nullable) {
+          return {
+            fn(input2) {
+              return nullableIntParser(input2, timestamp.uint8Min, timestamp.uint8Max);
+            },
+            code
+          };
+        }
+        return {
+          fn(input2) {
+            return intParser(input2, timestamp.uint8Min, timestamp.uint8Max);
+          },
+          code
+        };
+      case "boolean":
+        if (schema.nullable) {
+          return {
+            code,
+            fn(input2) {
+              if (typeof input2 === "string") {
+                if (input2 === "true") {
+                  return true;
+                }
+                if (input2 === "false") {
+                  return false;
+                }
+                if (input2 === "null") {
+                  return null;
+                }
+              }
+              if (typeof input2 === "boolean") {
+                return input2;
+              }
+              if (input2 === null) {
+                return null;
+              }
+              throw new timestamp.ValidationError({
+                message: `Expected boolean. Got ${typeof input2}`,
+                errors: [
+                  {
+                    instancePath: "",
+                    schemaPath: "/type"
+                  }
+                ]
+              });
+            }
+          };
+        }
+        return {
+          fn(input2) {
+            if (typeof input2 === "string") {
+              if (input2 === "true") {
+                return true;
+              }
+              if (input2 === "false") {
+                return false;
+              }
+            }
+            if (typeof input2 === "boolean") {
+              return input2;
+            }
+            throw new timestamp.ValidationError({
+              message: `Expected boolean. Got ${typeof input2}`,
+              errors: [
+                {
+                  instancePath: "",
+                  schemaPath: "/type"
+                }
+              ]
+            });
+          },
+          code
+        };
+      case "string":
+        if (schema.nullable) {
+          return {
+            fn(input2) {
+              if (typeof input2 === "string") {
+                if (input2 === "null") {
+                  return null;
+                }
+                return input2;
+              }
+              if (input2 === null) {
+                return null;
+              }
+              throw new timestamp.ValidationError({
+                message: `Expected string or null. Got ${typeof input2}.`,
+                errors: [
+                  {
+                    instancePath: "",
+                    schemaPath: "/type"
+                  }
+                ]
+              });
+            },
+            code
+          };
+        }
+        return {
+          fn(input2) {
+            if (typeof input2 === "string") {
+              return input2;
+            }
+            throw new timestamp.ValidationError({
+              message: `Expected string. Got ${typeof input2}.`,
+              errors: [
+                {
+                  instancePath: "",
+                  schemaPath: "/type"
+                }
+              ]
+            });
+          },
+          code
+        };
+      case "timestamp":
+        if (schema.nullable) {
+          return {
+            fn(input2) {
+              if (typeof input2 === "string") {
+                const parsedInput = new Date(input2);
+                if (!Number.isNaN(parsedInput.getMonth())) {
+                  return parsedInput;
+                }
+                if (input2 === "null") {
+                  return null;
+                }
+              }
+              if (typeof input2 === "object" && input2 instanceof Date) {
+                return input2;
+              }
+              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"
+                  }
+                ]
+              });
+            },
+            code
+          };
+        }
+        return {
+          fn(input2) {
+            if (typeof input2 === "string") {
+              const parsedInput = new Date(input2);
+              if (!Number.isNaN(parsedInput.getMonth())) {
+                return parsedInput;
+              }
+            }
+            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"
+                }
+              ]
+            });
+          },
+          code
+        };
+    }
+  }
+  if (jtdUtils.isSchemaFormEnum(schema)) {
+    if (schema.nullable) {
+      return {
+        fn(input2) {
+          if (typeof input2 === "string") {
+            for (const val of schema.enum) {
+              if (input2 === val) {
+                return val;
+              }
+            }
+            if (input2 === "null") {
+              return null;
+            }
+          }
+          if (input2 === null) {
+            return null;
+          }
+          throw new timestamp.ValidationError({
+            message: `Expected one of the following values: [${schema.enum.join(
+              ", "
+            )}] or null. Got ${typeof input2}.`,
+            errors: [
+              {
+                instancePath: "",
+                schemaPath: "/enum"
+              }
+            ]
+          });
+        },
+        code
+      };
+    }
+    return {
+      fn(input2) {
+        if (typeof input2 === "string") {
+          for (const val of schema.enum) {
+            if (input2 === val) {
+              return val;
+            }
+          }
+        }
+        throw new timestamp.ValidationError({
+          message: `Expected one of the following values: [${schema.enum.join(
+            ", "
+          )}]. Got ${typeof input2}.`,
+          errors: [
+            {
+              instancePath: "",
+              schemaPath: "/enum"
+            }
+          ]
+        });
+      },
+      code
+    };
+  }
+  return { fn: new Function(input, code), code };
+}
+function compiledFloatParser(input) {
+  if (typeof input === "string") {
+    const parsedVal = Number(input);
+    if (!Number.isNaN(parsedVal)) {
+      return parsedVal;
+    }
+    throw new timestamp.ValidationError({
+      message: `Unable to parse number from ${input}`,
+      errors: [
+        {
+          instancePath: "",
+          schemaPath: "/type"
+        }
+      ]
+    });
+  }
+  if (typeof input === "number" && !Number.isNaN(input)) {
+    return input;
+  }
+  throw new timestamp.ValidationError({
+    message: `Expected number. Got ${typeof input}`,
+    errors: [
+      {
+        instancePath: "",
+        schemaPath: "/type"
+      }
+    ]
+  });
+}
+function nullableFloatParser(input) {
+  if (typeof input === "string") {
+    const parsedVal = Number(input);
+    if (!Number.isNaN(parsedVal)) {
+      return parsedVal;
+    }
+    if (input === "null") {
+      return null;
+    }
+    throw new timestamp.ValidationError({
+      message: `Unable to parse number from ${input}`,
+      errors: [
+        {
+          instancePath: "",
+          schemaPath: "/type"
+        }
+      ]
+    });
+  }
+  if (typeof input === "number" && !Number.isNaN(input)) {
+    return input;
+  }
+  if (input === null) {
+    return null;
+  }
+  throw new timestamp.ValidationError({
+    message: `Expected number or null. Got ${typeof input}`,
+    errors: [
+      {
+        instancePath: "",
+        schemaPath: "/type"
+      }
+    ]
+  });
+}
+function bigIntParser(input, isUnsigned, isNullable) {
+  if (typeof input === "string" || typeof input === "number") {
+    if (isNullable && input === "null") {
+      return null;
+    }
+    try {
+      const val = BigInt(input);
+      if (isUnsigned) {
+        if (val >= BigInt("0")) {
+          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: ""
+            }
+          ]
+        });
+      }
+      return val;
+    } catch (err) {
+      throw new timestamp.ValidationError({
+        message: `Error transforming ${input} to BigInt`,
+        errors: [
+          {
+            schemaPath: "/type",
+            instancePath: "",
+            data: err
+          }
+        ]
+      });
+    }
+  }
+  if (typeof input === "bigint") {
+    if (isUnsigned) {
+      if (input >= BigInt("0")) {
+        return input;
+      }
+      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: ""
+          }
+        ]
+      });
+    }
+    return input;
+  }
+  if (isNullable && input === null) {
+    return null;
+  }
+  throw new timestamp.ValidationError({
+    message: "Expected BigInt or Integer string",
+    errors: [
+      {
+        schemaPath: "/type",
+        instancePath: ""
+      }
+    ]
+  });
+}
+function nullableIntParser(input, minNum, maxNum) {
+  if (typeof input === "string") {
+    const parsedInput = Number(input);
+    if (Number.isInteger(parsedInput) && parsedInput >= minNum && parsedInput <= maxNum) {
+      return parsedInput;
+    }
+    if (input === "null") {
+      return null;
+    }
+  }
+  if (typeof input === "number" && Number.isInteger(input) && input >= minNum && input <= maxNum) {
+    return input;
+  }
+  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"
+      }
+    ]
+  });
+}
+function intParser(input, minNum, maxNum) {
+  if (typeof input === "string") {
+    const parsedInput = Number(input);
+    if (Number.isInteger(parsedInput) && parsedInput >= minNum && parsedInput <= maxNum) {
+      return parsedInput;
+    }
+  }
+  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"
+      }
+    ]
+  });
+}
+function getCompiledSerializer(schema) {
+  const code = createSerializationV2Template("input", schema);
+  if (jtdUtils.isSchemaFormType(schema)) {
+    switch (schema.type) {
+      case "string":
+        if (schema.nullable) {
+          return {
+            fn(input) {
+              if (typeof input === "string") {
+                return input;
+              }
+              return "null";
+            },
+            code
+          };
+        }
+        return {
+          fn(input) {
+            return input;
+          },
+          code
+        };
+      case "timestamp":
+        if (schema.nullable) {
+          return {
+            fn(input) {
+              if (typeof input === "object" && input !== null) {
+                return input.toISOString();
+              }
+              return "null";
+            },
+            code
+          };
+        }
+        return {
+          fn(input) {
+            return input.toISOString();
+          },
+          code
+        };
+      case "boolean":
+        if (schema.nullable) {
+          return {
+            fn(input) {
+              if (typeof input === "boolean") {
+                return `${input}`;
+              }
+              return "null";
+            },
+            code
+          };
+        }
+        return {
+          fn(input) {
+            return `${input}`;
+          },
+          code
+        };
+      case "float32":
+      case "float64":
+      case "int8":
+      case "int16":
+      case "int32":
+      case "uint8":
+      case "uint16":
+      case "uint32":
+        if (schema.nullable) {
+          return {
+            fn(input) {
+              if (typeof input === "number") {
+                return `${input}`;
+              }
+              return `null`;
+            },
+            code
+          };
+        }
+        return {
+          fn(input) {
+            return `${input}`;
+          },
+          code
+        };
+      case "int64":
+      case "uint64":
+        if (schema.nullable) {
+          return {
+            fn(input) {
+              if (typeof input === "bigint") {
+                return input.toString();
+              }
+              return "null";
+            },
+            code
+          };
+        }
+        return {
+          fn(input) {
+            return input.toString();
+          },
+          code
+        };
+    }
+  }
+  if (jtdUtils.isSchemaFormEnum(schema)) {
+    if (schema.nullable) {
+      return {
+        fn(input) {
+          if (typeof input === "string" && schema.enum.includes(input)) {
+            return input;
+          }
+          return "null";
+        },
+        code
+      };
+    }
+    return {
+      fn(input) {
+        return input;
+      },
+      code
+    };
+  }
+  const fn = new Function("input", code);
+  return {
+    fn,
+    code
+  };
+}
+
+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 isAAdaptedSchema(input) {
+  return timestamp.isASchema(input) && "_isAdaptedSchema" in input.metadata[timestamp.SCHEMA_METADATA] && input.metadata[timestamp.SCHEMA_METADATA]._isAdaptedSchema === true;
+}
+
+exports.NumberTypeValues = timestamp.NumberTypeValues;
+exports.SCHEMA_METADATA = timestamp.SCHEMA_METADATA;
+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.discriminator = timestamp.discriminator;
+exports.enumerator = timestamp.enumerator;
+exports.errors = timestamp.errors;
+exports.extend = timestamp.extend;
+exports.float32 = timestamp.float32;
+exports.float64 = timestamp.float64;
+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.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.a = _namespace;
+exports.compile = compile;
+exports.getCompiledParser = getCompiledParser;
+exports.getCompiledSerializer = getCompiledSerializer;
+exports.getSchemaParsingCode = createParsingTemplate;
+exports.getSchemaSerializationCode = createSerializationV2Template;
+exports.getSchemaValidationCode = createValidationTemplate;
+exports.isAAdaptedSchema = isAAdaptedSchema;