@arrirpc/schema 0.45.0

package/dist/shared/schema.34cb5fb7.cjs

@@ -0,0 +1,1758 @@
+'use strict';
+
+const jtdUtils = require('jtd-utils');
+
+const SCHEMA_METADATA = Symbol.for("arri.schema_metadata");
+function isASchema(input) {
+  if (typeof input !== "object") {
+    return false;
+  }
+  if (!input || !("metadata" in input)) {
+    return false;
+  }
+  if (!input.metadata || typeof input.metadata !== "object" || !(SCHEMA_METADATA in input.metadata) || !input.metadata[SCHEMA_METADATA] || typeof input.metadata[SCHEMA_METADATA] !== "object") {
+    return false;
+  }
+  return "parse" in input.metadata[SCHEMA_METADATA] && typeof input.metadata[SCHEMA_METADATA] === "object";
+}
+function isAScalarSchema(input) {
+  return isASchema(input) && "type" in input && typeof input.type === "string" && // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+  (jtdUtils.TypeValues.includes(input.type) || // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+  NumberTypeValues.includes(input.type));
+}
+const NumberTypeValues = [
+  "float32",
+  "float64",
+  "int8",
+  "int16",
+  "int32",
+  "int64",
+  "uint8",
+  "uint16",
+  "uint32",
+  "uint64"
+];
+function isAAraySchema(input) {
+  return isASchema(input) && jtdUtils.isSchemaFormElements(input);
+}
+function isAStringEnumSchema(input) {
+  return isASchema(input) && jtdUtils.isSchemaFormEnum(input);
+}
+function isADiscriminatorSchema(input) {
+  return isASchema(input) && jtdUtils.isSchemaFormDiscriminator(input);
+}
+function isARecordSchema(input) {
+  return isASchema(input) && jtdUtils.isSchemaFormValues(input);
+}
+function isAObjectSchema(input) {
+  return isASchema(input) && jtdUtils.isSchemaFormProperties(input);
+}
+function isObject(input) {
+  return typeof input === "object" && input !== null;
+}
+function isARefSchema(input) {
+  return isASchema(input) && jtdUtils.isSchemaFormRef(input);
+}
+
+function any(options = {}) {
+  return {
+    metadata: {
+      id: options.id,
+      description: options.description,
+      isDeprecated: options.isDeprecated,
+      [SCHEMA_METADATA]: {
+        output: void 0,
+        parse: (input, data) => {
+          if (data.instancePath.length === 0 && typeof input === "string") {
+            try {
+              return JSON.parse(input);
+            } catch {
+              return input;
+            }
+          }
+          return input;
+        },
+        coerce: (input, data) => {
+          if (data.instancePath.length === 0 && typeof input === "string") {
+            try {
+              return JSON.parse(input);
+            } catch {
+              return input;
+            }
+          }
+          return input;
+        },
+        validate: (input) => true,
+        serialize(input) {
+          return JSON.stringify(input);
+        }
+      }
+    }
+  };
+}
+
+function array(schema, opts = {}) {
+  return {
+    elements: schema,
+    metadata: {
+      id: opts.id,
+      description: opts.description,
+      isDeprecated: opts.isDeprecated,
+      [SCHEMA_METADATA]: {
+        output: [],
+        parse(input, data) {
+          return parse$6(schema, input, data, false);
+        },
+        coerce(input, data) {
+          return parse$6(schema, input, data, true);
+        },
+        validate(input) {
+          return validate$5(schema, input);
+        },
+        serialize(input, data) {
+          const strParts = [];
+          for (let i = 0; i < input.length; i++) {
+            const item = input[i];
+            strParts.push(
+              schema.metadata[SCHEMA_METADATA].serialize(item, {
+                instancePath: `${data.instancePath}/${i}`,
+                schemaPath: `${data.schemaPath}/elements`,
+                errors: data.errors
+              })
+            );
+          }
+          return `[${strParts.join(",")}]`;
+        }
+      }
+    }
+  };
+}
+function validate$5(innerSchema, input) {
+  if (!Array.isArray(input)) {
+    return false;
+  }
+  for (const item of input) {
+    const isValid = innerSchema.metadata[SCHEMA_METADATA].validate(item);
+    if (!isValid) {
+      return false;
+    }
+  }
+  return true;
+}
+function parse$6(innerSchema, input, data, coerce = false) {
+  let parsedInput = input;
+  if (data.instancePath.length === 0 && typeof input === "string") {
+    try {
+      parsedInput = JSON.parse(input);
+    } catch (err) {
+      data.errors.push({
+        instancePath: data.instancePath,
+        schemaPath: `${data.schemaPath}/elements`,
+        message: `Error at ${data.instancePath}. Invalid JSON.`
+      });
+      return void 0;
+    }
+  }
+  if (!Array.isArray(parsedInput)) {
+    data.errors.push({
+      instancePath: data.instancePath,
+      schemaPath: `${data.schemaPath}/elements`,
+      message: `Error at ${data.instancePath}. Expected array. Got ${typeof input}.`
+    });
+    return void 0;
+  }
+  const result = [];
+  for (let i = 0; i < parsedInput.length; i++) {
+    const item = parsedInput[i];
+    if (coerce) {
+      const parsedItem = innerSchema.metadata[SCHEMA_METADATA].coerce(
+        item,
+        {
+          instancePath: `${data.instancePath}/${i}`,
+          schemaPath: `${data.schemaPath}/elements`,
+          errors: data.errors
+        }
+      );
+      result.push(parsedItem);
+    } else {
+      const parsedItem = innerSchema.metadata[SCHEMA_METADATA].parse(
+        item,
+        {
+          instancePath: `${data.instancePath}/${i}`,
+          schemaPath: `${data.schemaPath}/elements`,
+          errors: data.errors
+        }
+      );
+      result.push(parsedItem);
+    }
+  }
+  if (data.errors.length) {
+    return void 0;
+  }
+  return result;
+}
+
+function boolean(opts = {}) {
+  return {
+    type: "boolean",
+    metadata: {
+      id: opts.id,
+      description: opts.description,
+      isDeprecated: opts.isDeprecated,
+      [SCHEMA_METADATA]: {
+        output: false,
+        parse: parse$5,
+        validate: validate$4,
+        serialize: serialize$2,
+        coerce(input, data) {
+          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;
+          }
+          data.errors.push({
+            instancePath: data.instancePath,
+            schemaPath: data.schemaPath,
+            message: `Error at ${data.instancePath}. Unable to coerce ${input} to boolean.`
+          });
+          return void 0;
+        }
+      }
+    }
+  };
+}
+function validate$4(input) {
+  return typeof input === "boolean";
+}
+function parse$5(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 void 0;
+  }
+  data.errors.push({
+    instancePath: data.instancePath,
+    schemaPath: `${data.schemaPath}/type`,
+    message: `Error at ${data.instancePath}. Expected boolean. Got ${typeof input}.`
+  });
+  return void 0;
+}
+function serialize$2(input) {
+  return `${input}`;
+}
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+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$3(schema, input) {
+  return schema.metadata[SCHEMA_METADATA].validate(input);
+}
+function parse$4(schema, input) {
+  const errors2 = [];
+  const result = schema.metadata[SCHEMA_METADATA].parse(input, {
+    schemaPath: "",
+    instancePath: "",
+    errors: errors2
+  });
+  if (errors2.length) {
+    throw new ValidationError({
+      message: `Unable to parse input. ${errors2[0].message}`,
+      errors: errors2
+    });
+  }
+  return result;
+}
+function safeParse(schema, input) {
+  try {
+    const result = parse$4(schema, input);
+    return {
+      success: true,
+      value: result
+    };
+  } catch (err) {
+    if (isValidationError(err)) {
+      return {
+        success: false,
+        error: err
+      };
+    }
+    return {
+      success: false,
+      error: new ValidationError({
+        message: "Unable to parse input",
+        errors: []
+      })
+    };
+  }
+}
+function coerce$2(schema, input) {
+  const errors2 = [];
+  const result = schema.metadata[SCHEMA_METADATA].coerce(input, {
+    schemaPath: "",
+    instancePath: "",
+    errors: errors2
+  });
+  if (errors2.length) {
+    throw new ValidationError({
+      message: `Unable to coerce input. ${errors2[0]?.message}`,
+      errors: errors2
+    });
+  }
+  return result;
+}
+function safeCoerce(schema, input) {
+  try {
+    const result = coerce$2(schema, input);
+    return {
+      success: true,
+      value: result
+    };
+  } catch (err) {
+    if (isValidationError(err)) {
+      return {
+        success: false,
+        error: err
+      };
+    }
+    return {
+      success: false,
+      error: new ValidationError({
+        message: "Unable to coerce input",
+        errors: []
+      })
+    };
+  }
+}
+function serialize$1(schema, input) {
+  const data = {
+    instancePath: "",
+    schemaPath: "",
+    errors: []
+  };
+  return schema.metadata[SCHEMA_METADATA].serialize(input, data);
+}
+function errors(schema, input) {
+  const errorList = [];
+  try {
+    schema.metadata[SCHEMA_METADATA].parse(input, {
+      errors: errorList,
+      instancePath: "",
+      schemaPath: ""
+    });
+  } catch (err) {
+    errorList.push({ instancePath: "", schemaPath: "", message: `${err}` });
+  }
+  return errorList;
+}
+class ValidationError extends Error {
+  constructor(options) {
+    super(options.message);
+    __publicField(this, "errors");
+    this.errors = options.errors;
+  }
+}
+function isValidationError(input) {
+  if (typeof input !== "object" || !input) {
+    return false;
+  }
+  return "message" in input && typeof input.message === "string" && "errors" in input && Array.isArray(input.errors);
+}
+
+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;
+  }
+  return {
+    discriminator: discriminator2,
+    mapping,
+    metadata: {
+      id: opts.id,
+      description: opts.description,
+      isDeprecated: opts.isDeprecated,
+      [SCHEMA_METADATA]: {
+        output: {},
+        validate(input) {
+          return validate$2(discriminator2, mapping, input);
+        },
+        parse(input, data) {
+          return parse$3(discriminator2, mapping, input, data, false);
+        },
+        coerce: (input, data) => {
+          return parse$3(discriminator2, mapping, input, data, true);
+        },
+        serialize(input, data) {
+          const discriminatorVal = input[discriminator2] ?? "";
+          const targetSchema = mapping[discriminatorVal];
+          if (!targetSchema) {
+            throw discriminatorMappingError(discriminatorVal, data);
+          }
+          const result = targetSchema.metadata[SCHEMA_METADATA].serialize(input, {
+            instancePath: data.instancePath,
+            schemaPath: `${data.schemaPath}/mapping/${discriminatorVal}`,
+            errors: data.errors,
+            discriminatorKey: discriminator2,
+            discriminatorValue: discriminatorVal
+          });
+          return result;
+        }
+      }
+    }
+  };
+}
+function validate$2(discriminator2, mapping, input) {
+  if (!isObject(input)) {
+    return false;
+  }
+  if (!(discriminator2 in input)) {
+    return false;
+  }
+  const discriminatorOptions = Object.keys(mapping);
+  if (!discriminatorOptions.includes(input[discriminator2])) {
+    return false;
+  }
+  const targetSchema = mapping[input[discriminator2]];
+  if (!targetSchema) {
+    return false;
+  }
+  return targetSchema.metadata[SCHEMA_METADATA].validate(input);
+}
+function parse$3(discriminator2, mapping, input, data, coerce = false) {
+  let parsedInput = input;
+  if (typeof input === "string" && input.length && data.instancePath.length === 0) {
+    parsedInput = JSON.parse(input);
+  }
+  if (!isObject(parsedInput)) {
+    data.errors.push({
+      instancePath: data.instancePath,
+      schemaPath: `${data.schemaPath}/discriminator`,
+      message: `Error at ${data.instancePath}. Expected object. Got ${typeof parsedInput}.`
+    });
+    return void 0;
+  }
+  if (!(discriminator2 in parsedInput)) {
+    data.errors.push({
+      instancePath: `${data.instancePath}/${discriminator2}`,
+      schemaPath: `${data.schemaPath}/discriminator`,
+      message: `Error at ${data.instancePath}/${discriminator2}. Discriminator field "${discriminator2}" cannot be undefined`
+    });
+    return void 0;
+  }
+  const acceptedDiscriminatorVals = Object.keys(mapping);
+  const discriminatorVal = parsedInput[discriminator2];
+  if (!acceptedDiscriminatorVals.includes(discriminatorVal)) {
+    data.errors.push({
+      instancePath: `${data.instancePath}/${discriminator2}`,
+      schemaPath: `${data.schemaPath}/discriminator`,
+      message: `Error at ${data.instancePath}/${discriminator2}. "${parsedInput[discriminator2]}" is not one of the accepted discriminator values: [${acceptedDiscriminatorVals.join(
+        ", "
+      )}]`
+    });
+    return void 0;
+  }
+  const targetSchema = mapping[parsedInput[discriminator2]];
+  if (!targetSchema) {
+    throw discriminatorMappingError(discriminatorVal, data);
+  }
+  if (coerce) {
+    const result2 = targetSchema.metadata[SCHEMA_METADATA].coerce(
+      parsedInput,
+      {
+        instancePath: data.instancePath,
+        schemaPath: `${data.schemaPath}/mapping/${discriminatorVal}`,
+        errors: data.errors,
+        discriminatorKey: discriminator2,
+        discriminatorValue: discriminatorVal
+      }
+    );
+    return result2;
+  }
+  const result = targetSchema.metadata[SCHEMA_METADATA].parse(parsedInput, {
+    instancePath: data.instancePath,
+    schemaPath: `${data.schemaPath}/mapping/${discriminatorVal}`,
+    errors: data.errors,
+    discriminatorKey: discriminator2,
+    discriminatorValue: discriminatorVal
+  });
+  return result;
+}
+function discriminatorMappingError(discriminatorVal, data) {
+  return new ValidationError({
+    message: `Error fetching discriminator schema for "${discriminatorVal}"`,
+    errors: [
+      {
+        message: "Error fetching discriminator schema",
+        instancePath: data.instancePath,
+        schemaPath: data.schemaPath
+      }
+    ]
+  });
+}
+
+const stringEnum = enumerator;
+function enumerator(paramA, paramB) {
+  const isType = (input) => {
+    if (typeof input !== "string") {
+      return false;
+    }
+    for (const val of paramA) {
+      if (val === input) {
+        return true;
+      }
+    }
+    return false;
+  };
+  const isIdShorthand = typeof paramA === "string";
+  const enumVal = isIdShorthand ? paramB : paramA;
+  const meta = isIdShorthand ? { id: paramA } : paramB;
+  return {
+    enum: enumVal,
+    metadata: {
+      id: meta?.id,
+      description: meta?.description,
+      isDeprecated: meta?.isDeprecated,
+      [SCHEMA_METADATA]: {
+        output: paramA[0] ?? "",
+        parse(input, data) {
+          if (isType(input)) {
+            return input;
+          }
+          data.errors.push({
+            instancePath: data.instancePath,
+            schemaPath: `${data.schemaPath}/enum`,
+            message: `Error at ${data.instancePath}. Invalid enum value. Expected one of the following values: [${enumVal.join(
+              ", "
+            )}]`
+          });
+          return void 0;
+        },
+        coerce: (input, data) => {
+          if (isType(input)) {
+            return input;
+          }
+          data.errors.push({
+            instancePath: data.instancePath,
+            schemaPath: `${data.schemaPath}/enum`,
+            message: `Error at ${data.instancePath}. Invalid enum value. Expected one of the following values: [${enumVal.join(
+              ", "
+            )}]`
+          });
+          return void 0;
+        },
+        validate: isType,
+        serialize(input, data) {
+          if (data.instancePath.length === 0) {
+            return input;
+          }
+          return `"${input}"`;
+        }
+      }
+    }
+  };
+}
+
+function nullable(schema, opts = {}) {
+  const isType = (val) => {
+    if (val === null) {
+      return true;
+    }
+    return schema.metadata[SCHEMA_METADATA].validate(val);
+  };
+  return {
+    ...schema,
+    nullable: true,
+    metadata: {
+      id: opts.id ?? schema.metadata.id,
+      description: opts.description ?? schema.metadata.description,
+      isDeprecated: opts.isDeprecated ?? schema.metadata.isDeprecated,
+      [SCHEMA_METADATA]: {
+        output: null,
+        optional: schema.metadata[SCHEMA_METADATA].optional,
+        validate: isType,
+        parse(val, data) {
+          if (data.instancePath.length === 0 && typeof val === "string" && val === "null") {
+            return null;
+          }
+          if (val === null) {
+            return null;
+          }
+          return schema.metadata[SCHEMA_METADATA].parse(val, data);
+        },
+        coerce(val, data) {
+          if (val === null) {
+            return null;
+          }
+          if (val === "null") {
+            return null;
+          }
+          return schema.metadata[SCHEMA_METADATA].coerce(val, data);
+        },
+        serialize(val, data) {
+          if (val === null) {
+            return "null";
+          }
+          return schema.metadata[SCHEMA_METADATA].serialize(
+            val,
+            data
+          );
+        }
+      }
+    }
+  };
+}
+function optional(input, opts = {}) {
+  const isType = (val) => {
+    if (val === void 0) {
+      return true;
+    }
+    return input.metadata[SCHEMA_METADATA].validate(val);
+  };
+  return {
+    ...input,
+    metadata: {
+      id: opts.id ?? input.metadata.id,
+      description: opts.description ?? input.metadata.description,
+      isDeprecated: opts.isDeprecated ?? input.metadata.isDeprecated,
+      [SCHEMA_METADATA]: {
+        output: void 0,
+        optional: true,
+        validate: isType,
+        parse: (val, data) => {
+          if (typeof val === "undefined") {
+            return void 0;
+          }
+          if (data.instancePath.length === 0 && val === "undefined") {
+            return void 0;
+          }
+          return input.metadata[SCHEMA_METADATA].parse(val, data);
+        },
+        coerce: (val, data) => {
+          if (typeof val === "undefined") {
+            return void 0;
+          }
+          if (val === "undefined") {
+            return void 0;
+          }
+          return input.metadata[SCHEMA_METADATA].coerce(val, data);
+        },
+        serialize: (val, data) => {
+          if (typeof val === "undefined") {
+            return "undefined";
+          }
+          return input.metadata[SCHEMA_METADATA].serialize(val, data);
+        }
+      }
+    }
+  };
+}
+function clone(input, opts = {}) {
+  const schema = {
+    ...input,
+    metadata: {
+      id: opts.id,
+      description: opts.description,
+      isDeprecated: opts.isDeprecated,
+      [SCHEMA_METADATA]: {
+        ...input.metadata[SCHEMA_METADATA]
+      }
+    }
+  };
+  return 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 number(opts = {}) {
+  return float64(opts);
+}
+function coerceNumber(input, options) {
+  if (typeof input === "string") {
+    const parsedInput = Number(input);
+    if (Number.isNaN(parsedInput)) {
+      options.errors.push({
+        instancePath: `${options.instancePath}`,
+        schemaPath: `${options.schemaPath}/type`,
+        message: `Error at ${options.instancePath}. Unable to coerce ${typeof input} into a number`
+      });
+      return void 0;
+    }
+    return parseNumber(parsedInput, options);
+  }
+  return parseNumber(input, options);
+}
+function float32(opts = {}) {
+  return numberScalarType("float32", opts, (input) => {
+    return {
+      success: true
+    };
+  });
+}
+function float64(opts = {}) {
+  return numberScalarType("float64", opts, (input) => {
+    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, data) {
+    if (typeof input === "string" || typeof input === "number") {
+      try {
+        const val = BigInt(input);
+        if (isType(val)) {
+          return val;
+        }
+        data.errors.push({
+          message: `Error at ${data.instancePath}. Invalid int64.`,
+          schemaPath: `${data.schemaPath}/type`,
+          instancePath: data.instancePath
+        });
+        return void 0;
+      } catch (err) {
+        data.errors.push({
+          message: `Error at ${data.instancePath}. Unable to transform ${input} to BigInt`,
+          schemaPath: `${data.schemaPath}/type`,
+          instancePath: data.instancePath
+        });
+        return void 0;
+      }
+    }
+    if (isType(input)) {
+      return input;
+    }
+    data.errors.push({
+      message: `Error at ${data.instancePath}. Expected BigInt or integer string`,
+      schemaPath: `${data.schemaPath}/type`,
+      instancePath: data.instancePath
+    });
+    return void 0;
+  }
+  return {
+    type: "int64",
+    metadata: {
+      id: opts.id,
+      description: opts.description,
+      isDeprecated: opts.isDeprecated,
+      [SCHEMA_METADATA]: {
+        output: BigInt("0"),
+        validate: isType,
+        parse,
+        coerce: parse,
+        serialize(input, data) {
+          if (data.instancePath.length === 0) {
+            return input.toString();
+          }
+          return `"${input.toString()}"`;
+        }
+      }
+    }
+  };
+}
+function uint64(opts = {}) {
+  function isType(input) {
+    return typeof input === "bigint" && input >= uint64Min && input <= uint64Max;
+  }
+  function parse(input, data) {
+    if (typeof input === "string" || typeof input === "number") {
+      try {
+        const val = BigInt(input);
+        if (isType(val)) {
+          return val;
+        }
+        data.errors.push({
+          message: `Error at ${data.instancePath}. Invalid uint64.`,
+          schemaPath: `${data.schemaPath}/type`,
+          instancePath: data.instancePath
+        });
+        return void 0;
+      } catch (err) {
+        data.errors.push({
+          message: `Error at ${data.instancePath}. Unable to transform ${input} to BigInt.`,
+          schemaPath: `${data.schemaPath}/type`,
+          instancePath: data.instancePath
+        });
+        return void 0;
+      }
+    }
+    if (isType(input)) {
+      return input;
+    }
+    data.errors.push({
+      message: `Error at ${data.instancePath}. Expected BigInt or integer string.`,
+      schemaPath: `${data.schemaPath}/type`,
+      instancePath: data.instancePath
+    });
+    return void 0;
+  }
+  return {
+    type: "uint64",
+    metadata: {
+      id: opts.id,
+      description: opts.description,
+      isDeprecated: opts.isDeprecated,
+      [SCHEMA_METADATA]: {
+        output: BigInt("0"),
+        validate: isType,
+        parse,
+        coerce: parse,
+        serialize(input, data) {
+          if (data.instancePath.length === 0) {
+            return input.toString();
+          }
+          return `"${input.toString()}"`;
+        }
+      }
+    }
+  };
+}
+function validateNumber(input) {
+  return typeof input === "number" || !Number.isNaN(input);
+}
+function validateInt(input, minVal, maxValue) {
+  return Number.isInteger(input) && input >= minVal && input <= maxValue;
+}
+function serializeNumber(input, data) {
+  return input.toString();
+}
+function parseNumber(input, options) {
+  if (options.instancePath.length === 0 && typeof input === "string") {
+    const result = Number(input);
+    if (Number.isNaN(result)) {
+      options?.errors.push({
+        instancePath: options.instancePath,
+        schemaPath: `${options.schemaPath}/type`,
+        message: `Error at ${options.instancePath}. Invalid number.`
+      });
+      return void 0;
+    }
+    return result;
+  }
+  if (typeof input === "number" && !Number.isNaN(input)) {
+    return input;
+  }
+  options?.errors.push({
+    instancePath: options.instancePath,
+    schemaPath: `${options.schemaPath}/type`,
+    message: `Error at ${options.instancePath}. Invalid number.`
+  });
+  return void 0;
+}
+function numberScalarType(type, opts, numTypeMatcher) {
+  return {
+    type,
+    metadata: {
+      id: opts.id,
+      description: opts.description,
+      isDeprecated: opts.isDeprecated,
+      [SCHEMA_METADATA]: {
+        output: 0,
+        validate(input) {
+          const isNum = validateNumber(input);
+          if (!isNum) {
+            return false;
+          }
+          return numTypeMatcher(input).success;
+        },
+        parse(input, options) {
+          const result = parseNumber(input, options);
+          if (options.errors.length) {
+            return void 0;
+          }
+          if (typeof result !== "number") {
+            options?.errors.push({
+              instancePath: options.instancePath,
+              schemaPath: `${options.schemaPath}/type`,
+              message: `Error at ${options.instancePath}. Invalid number.`
+            });
+            return void 0;
+          }
+          const matchResult = numTypeMatcher(result);
+          if (matchResult.success) {
+            return result;
+          }
+          options?.errors.push({
+            instancePath: options.instancePath,
+            schemaPath: `${options.schemaPath}/type`,
+            message: `Error at ${options.instancePath}. ${matchResult.message}`
+          });
+          return void 0;
+        },
+        serialize: serializeNumber,
+        coerce(input, options) {
+          const result = coerceNumber(input, options);
+          if (typeof result !== "number") {
+            options.errors.push({
+              instancePath: options.instancePath,
+              schemaPath: `${options.schemaPath}/type`,
+              message: `Error at ${options.instancePath}. Unable to coerce ${typeof input} to ${type}.`
+            });
+            return void 0;
+          }
+          const matchResult = numTypeMatcher(result);
+          if (matchResult.success) {
+            return result;
+          }
+          options.errors.push({
+            instancePath: options.instancePath,
+            schemaPath: `${options.schemaPath}/type`,
+            message: `Error at ${options.instancePath}. ${matchResult.message}`
+          });
+          return void 0;
+        }
+      }
+    }
+  };
+}
+
+function object(propA, propB) {
+  const isIdShorthand = typeof propA === "string";
+  const input = isIdShorthand ? propB : propA;
+  const opts = isIdShorthand ? { id: propA } : propB ?? {};
+  const schema = {
+    properties: {},
+    additionalProperties: typeof opts.additionalProperties === "boolean" ? opts.additionalProperties : true
+  };
+  for (const key of Object.keys(input)) {
+    const prop = input[key];
+    if (prop.metadata[SCHEMA_METADATA].optional) {
+      if (!schema.optionalProperties) {
+        schema.optionalProperties = {};
+      }
+      schema.optionalProperties[key] = prop;
+      continue;
+    }
+    schema.properties[key] = prop;
+  }
+  const result = {
+    ...schema,
+    metadata: {
+      id: opts.id,
+      description: opts.description,
+      isDeprecated: opts.isDeprecated,
+      [SCHEMA_METADATA]: {
+        output: {},
+        parse(input2, data) {
+          return parseObjectSchema(
+            schema,
+            input2,
+            data,
+            false
+          );
+        },
+        coerce(input2, data) {
+          return parseObjectSchema(
+            schema,
+            input2,
+            data,
+            true
+          );
+        },
+        validate(input2) {
+          return validateObjectSchema(schema, input2);
+        },
+        serialize(input2, data) {
+          return serializeObject(
+            schema,
+            input2,
+            data
+          );
+        }
+      }
+    }
+  };
+  return result;
+}
+function parseObjectSchema(schema, input, data, coerce = false) {
+  let parsedInput = input;
+  if (data.instancePath.length === 0 && typeof input === "string") {
+    try {
+      const result2 = JSON.parse(input);
+      parsedInput = result2;
+    } catch (err) {
+      data.errors.push({
+        instancePath: data.instancePath,
+        schemaPath: `${data.schemaPath}/properties`,
+        message: `Error at ${data.instancePath}. Invalid JSON.`
+      });
+      return void 0;
+    }
+  }
+  if (!isObject(parsedInput)) {
+    data.errors.push({
+      instancePath: data.instancePath,
+      schemaPath: `${data.schemaPath}/properties`,
+      message: `Error at ${data.instancePath}. Expected object`
+    });
+    return void 0;
+  }
+  const result = {};
+  const optionalProps = schema.optionalProperties ?? {};
+  const inputKeys = Object.keys(parsedInput);
+  const requiredKeys = Object.keys(schema.properties);
+  const optionalKeys = Object.keys(optionalProps);
+  if (!schema.additionalProperties) {
+    for (const key of inputKeys) {
+      if (!requiredKeys.includes(key) && !optionalKeys.includes(key) && key !== data.discriminatorKey) {
+        data.errors.push({
+          instancePath: `${data.instancePath}/${key}`,
+          schemaPath: `${data.schemaPath}/additionalProperties`,
+          message: `Error at ${data.instancePath}/${key}. Key '${key}' is not included in the schema. To allow additional input properties set additionalProperties to 'true'.`
+        });
+      }
+    }
+  }
+  if (data.errors.length) {
+    return void 0;
+  }
+  if (data.discriminatorKey) {
+    result[data.discriminatorKey] = data.discriminatorValue;
+  }
+  for (const key of requiredKeys) {
+    const val = parsedInput[key];
+    const prop = schema.properties[key];
+    if (coerce) {
+      result[key] = prop.metadata[SCHEMA_METADATA].coerce(val, {
+        instancePath: `${data.instancePath}/${key}`,
+        schemaPath: `${data.schemaPath}/properties/${key}`,
+        errors: data.errors
+      });
+      continue;
+    }
+    result[key] = prop.metadata[SCHEMA_METADATA].parse(val, {
+      instancePath: `${data.instancePath}/${key}`,
+      schemaPath: `${data.schemaPath}/properties/${key}`,
+      errors: data.errors
+    });
+  }
+  for (const key of optionalKeys) {
+    const val = parsedInput[key];
+    const prop = optionalProps[key];
+    if (val === void 0) {
+      continue;
+    }
+    if (coerce) {
+      result[key] = prop.metadata[SCHEMA_METADATA].coerce(val, {
+        instancePath: `${data.instancePath}/${key}`,
+        schemaPath: `${data.schemaPath}/optionalProperties/${key}`,
+        errors: data.errors
+      });
+      continue;
+    }
+    if (typeof val !== "undefined") {
+      result[key] = prop.metadata[SCHEMA_METADATA].parse(val, {
+        instancePath: `${data.instancePath}/${key}`,
+        schemaPath: `${data.schemaPath}/optionalProperties/${key}`,
+        errors: data.errors
+      });
+    }
+  }
+  if (data.errors.length) {
+    return void 0;
+  }
+  return result;
+}
+function validateObjectSchema(schema, input) {
+  if (!isObject(input)) {
+    return false;
+  }
+  const optionalProps = schema.optionalProperties ?? {};
+  for (const key of Object.keys(input)) {
+    const prop = schema.properties[key] ?? optionalProps[key];
+    if (!prop && !schema.additionalProperties) {
+      return false;
+    }
+    if (prop) {
+      const isValid = prop.metadata[SCHEMA_METADATA].validate(input[key]);
+      if (!isValid) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function pick(inputSchema, keys, opts = {}) {
+  const schema = {
+    properties: {},
+    nullable: inputSchema.nullable,
+    additionalProperties: typeof opts.additionalProperties === "boolean" ? opts.additionalProperties : true
+  };
+  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];
+      }
+    });
+  }
+  return {
+    ...schema,
+    metadata: {
+      id: opts.id,
+      description: opts.description,
+      isDeprecated: opts.isDeprecated,
+      [SCHEMA_METADATA]: {
+        output: {},
+        parse: (input, data) => {
+          return parseObjectSchema(schema, input, data, true);
+        },
+        coerce(input, data) {
+          return parseObjectSchema(schema, input, data, false);
+        },
+        validate(input) {
+          return validateObjectSchema(schema, input);
+        },
+        serialize(input, data) {
+          return serializeObject(schema, input, data);
+        }
+      }
+    }
+  };
+}
+function omit(inputSchema, keys, opts = {}) {
+  const schema = {
+    properties: {
+      ...inputSchema.properties
+    },
+    nullable: inputSchema.nullable,
+    additionalProperties: typeof opts.additionalProperties === "boolean" ? opts.additionalProperties : true
+  };
+  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];
+      }
+    });
+  }
+  return {
+    ...schema,
+    metadata: {
+      id: opts.id,
+      description: opts.description,
+      isDeprecated: opts.isDeprecated,
+      [SCHEMA_METADATA]: {
+        output: {},
+        validate(input) {
+          return validateObjectSchema(schema, input);
+        },
+        parse(input, data) {
+          return parseObjectSchema(schema, input, data, false);
+        },
+        serialize(input, data) {
+          return serializeObject(schema, input, data);
+        },
+        coerce(input, data) {
+          return parseObjectSchema(schema, input, data, true);
+        }
+      }
+    }
+  };
+}
+function serializeObject(schema, input, data) {
+  const strParts = [];
+  if (data.discriminatorKey && data.discriminatorValue) {
+    strParts.push(
+      `"${data.discriminatorKey}":"${data.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.metadata[SCHEMA_METADATA].serialize(val, {
+          instancePath: `${data.instancePath}/${key}`,
+          schemaPath: `${data.schemaPath}/properties/${key}`,
+          errors: data.errors
+        })}`
+      );
+    }
+  }
+  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.metadata[SCHEMA_METADATA].serialize(val, {
+            instancePath: `${data.instancePath}/${key}`,
+            schemaPath: `${data.schemaPath}/optionalProperties/${key}`,
+            errors: data.errors
+          })}`
+        );
+      }
+    }
+  }
+  return `{${strParts.join(",")}}`;
+}
+function extend(baseSchema, inputSchema, opts = {}) {
+  const schema = {
+    properties: {
+      ...baseSchema.properties,
+      ...inputSchema.properties
+    },
+    optionalProperties: {
+      ...baseSchema.optionalProperties,
+      ...inputSchema.optionalProperties
+    },
+    additionalProperties: typeof opts.additionalProperties === "boolean" ? opts.additionalProperties : true
+  };
+  const isType = (input) => validateObjectSchema(schema, input);
+  const meta = {
+    id: opts.id,
+    description: opts.description,
+    [SCHEMA_METADATA]: {
+      output: {},
+      parse(input, data) {
+        return parseObjectSchema(schema, input, data, false);
+      },
+      coerce(input, data) {
+        return parseObjectSchema(schema, input, data, true);
+      },
+      validate: isType,
+      serialize(input, data) {
+        return serializeObject(schema, input, data);
+      }
+    }
+  };
+  schema.metadata = meta;
+  return schema;
+}
+function partial(schema, options = {}) {
+  const newSchema = {
+    properties: {},
+    optionalProperties: {},
+    additionalProperties: typeof options.additionalProperties === "boolean" ? options.additionalProperties : true,
+    nullable: schema.nullable
+  };
+  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.metadata[SCHEMA_METADATA].optional) {
+        newSchema.optionalProperties[key] = prop;
+      } else {
+        newSchema.optionalProperties[key] = optional(prop);
+      }
+    }
+  }
+  const meta = {
+    id: options.id,
+    description: options.description,
+    [SCHEMA_METADATA]: {
+      output: {},
+      optional: schema.metadata[SCHEMA_METADATA].optional,
+      validate(input) {
+        return validateObjectSchema(newSchema, input);
+      },
+      parse(input, data) {
+        return parseObjectSchema(newSchema, input, data, false);
+      },
+      coerce(input, data) {
+        return parseObjectSchema(newSchema, input, data, true);
+      },
+      serialize(input, data) {
+        return serializeObject(schema, input, data);
+      }
+    }
+  };
+  newSchema.metadata = meta;
+  return newSchema;
+}
+
+function record(schema, opts = {}) {
+  return {
+    values: schema,
+    metadata: {
+      id: opts.id,
+      description: opts.description,
+      isDeprecated: opts.isDeprecated,
+      [SCHEMA_METADATA]: {
+        output: {},
+        validate(input) {
+          if (!isObject(input)) {
+            return false;
+          }
+          for (const key of Object.keys(input)) {
+            const val = input[key];
+            const isValid = schema.metadata[SCHEMA_METADATA].validate(val);
+            if (!isValid) {
+              return false;
+            }
+          }
+          return true;
+        },
+        parse(input, data) {
+          return parse$2(schema, input, data, false);
+        },
+        coerce(input, data) {
+          return parse$2(schema, input, data, true);
+        },
+        serialize(input, data) {
+          const strParts = [];
+          for (const key of Object.keys(input)) {
+            const val = input[key];
+            strParts.push(
+              `"${key}":${schema.metadata[SCHEMA_METADATA].serialize(val, {
+                instancePath: `${data.instancePath}/${key}`,
+                schemaPath: `${data.schemaPath}/values`,
+                errors: data.errors
+              })}`
+            );
+          }
+          const result = `{${strParts.join(",")}}`;
+          if (data.instancePath.length === 0) {
+            return sanitizeJson(result);
+          }
+          return result;
+        }
+      }
+    }
+  };
+}
+function parse$2(schema, input, data, coerce = false) {
+  let parsedInput = input;
+  if (data.instancePath.length === 0 && typeof input === "string") {
+    parsedInput = JSON.parse(input);
+  }
+  if (!isObject(parsedInput)) {
+    data.errors.push({
+      instancePath: data.instancePath,
+      schemaPath: `${data.schemaPath}/values`,
+      message: `Error at ${data.instancePath} Expected object`
+    });
+    return void 0;
+  }
+  const result = {};
+  for (const key of Object.keys(parsedInput)) {
+    const val = parsedInput[key];
+    if (coerce) {
+      result[key] = schema.metadata[SCHEMA_METADATA].coerce(val, {
+        instancePath: `${data.instancePath}/${key}`,
+        schemaPath: `${data.schemaPath}/values`,
+        errors: data.errors
+      });
+    } else {
+      result[key] = schema.metadata[SCHEMA_METADATA].parse(val, {
+        instancePath: `${data.instancePath}/${key}`,
+        schemaPath: `${data.schemaPath}/values`,
+        errors: data.errors
+      });
+    }
+  }
+  if (data.errors.length) {
+    return void 0;
+  }
+  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 ?? {};
+  const recursiveFns = {};
+  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 mainSchema = callback({
+    ref: id,
+    metadata: {
+      [SCHEMA_METADATA]: {
+        output: "",
+        parse(input, data) {
+          if (recursiveFns[id]) {
+            return recursiveFns[id].parse(input, data);
+          }
+        },
+        serialize(input, data) {
+          if (recursiveFns[id]) {
+            return recursiveFns[id].serialize(input, data);
+          }
+          return "";
+        },
+        validate(input) {
+          if (recursiveFns[id]) {
+            return recursiveFns[id].validate(input);
+          }
+          return false;
+        },
+        coerce(input, data) {
+          if (recursiveFns[id]) {
+            return recursiveFns[id].coerce(input, data);
+          }
+        }
+      }
+    }
+  });
+  mainSchema.metadata.id = id;
+  mainSchema.metadata.description = options?.description ?? mainSchema.metadata.description;
+  mainSchema.metadata.isDeprecated = options?.isDeprecated ?? mainSchema.metadata.isDeprecated;
+  recursiveFns[id] = {
+    validate: mainSchema.metadata[SCHEMA_METADATA].validate,
+    parse: mainSchema.metadata[SCHEMA_METADATA].parse,
+    serialize: mainSchema.metadata[SCHEMA_METADATA].serialize,
+    coerce: mainSchema.metadata[SCHEMA_METADATA].coerce
+  };
+  return mainSchema;
+}
+
+function string(opts = {}) {
+  return {
+    type: "string",
+    metadata: {
+      id: opts.id,
+      description: opts.description,
+      isDeprecated: opts.isDeprecated,
+      [SCHEMA_METADATA]: {
+        output: "",
+        parse: parse$1,
+        coerce: coerce$1,
+        validate: validate$1,
+        serialize(input, data) {
+          if (data.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);
+        }
+      }
+    }
+  };
+}
+function validate$1(input) {
+  return typeof input === "string";
+}
+function parse$1(input, context) {
+  if (validate$1(input)) {
+    return input;
+  }
+  context.errors.push({
+    instancePath: context.instancePath,
+    schemaPath: `${context.schemaPath}/type`,
+    message: `Error at ${context.instancePath}. Expected 'string' got ${typeof input}.`
+  });
+  return void 0;
+}
+function coerce$1(input, context) {
+  return parse$1(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 timestamp(opts = {}) {
+  return {
+    type: "timestamp",
+    metadata: {
+      id: opts.id,
+      description: opts.description,
+      isDeprecated: opts.isDeprecated,
+      [SCHEMA_METADATA]: {
+        output: /* @__PURE__ */ new Date(),
+        validate,
+        parse,
+        coerce,
+        serialize
+      }
+    }
+  };
+}
+function validate(input) {
+  return typeof input === "object" && input instanceof Date;
+}
+function parse(input, data) {
+  if (validate(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;
+}
+function coerce(input, options) {
+  if (typeof input === "number") {
+    return new Date(input);
+  }
+  return parse(input, options);
+}
+function serialize(input, data) {
+  if (data.instancePath.length === 0) {
+    return input.toISOString();
+  }
+  return `"${input.toISOString()}"`;
+}
+
+exports.NumberTypeValues = NumberTypeValues;
+exports.SCHEMA_METADATA = SCHEMA_METADATA;
+exports.ValidationError = ValidationError;
+exports.any = any;
+exports.array = array;
+exports.boolean = boolean;
+exports.clone = clone;
+exports.coerce = coerce$2;
+exports.discriminator = discriminator;
+exports.enumerator = enumerator;
+exports.errors = errors;
+exports.extend = extend;
+exports.float32 = float32;
+exports.float64 = float64;
+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.isAAraySchema = isAAraySchema;
+exports.isADiscriminatorSchema = isADiscriminatorSchema;
+exports.isAObjectSchema = isAObjectSchema;
+exports.isARecordSchema = isARecordSchema;
+exports.isARefSchema = isARefSchema;
+exports.isAScalarSchema = isAScalarSchema;
+exports.isASchema = isASchema;
+exports.isAStringEnumSchema = isAStringEnumSchema;
+exports.isObject = isObject;
+exports.isValidationError = isValidationError;
+exports.nullable = nullable;
+exports.number = number;
+exports.object = object;
+exports.omit = omit;
+exports.optional = optional;
+exports.parse = parse$4;
+exports.parseObjectSchema = parseObjectSchema;
+exports.partial = partial;
+exports.pick = pick;
+exports.record = record;
+exports.recursive = recursive;
+exports.safeCoerce = safeCoerce;
+exports.safeParse = safeParse;
+exports.sanitizeJson = sanitizeJson;
+exports.serialize = serialize$1;
+exports.serializeObject = serializeObject;
+exports.serializeSmallString = serializeSmallString;
+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$3;
+exports.validateObjectSchema = validateObjectSchema;