@arrirpc/schema 0.45.0

package/dist/shared/schema.66772201.mjs

@@ -0,0 +1,1687 @@
+import { TypeValues, isSchemaFormElements, isSchemaFormEnum, isSchemaFormDiscriminator, isSchemaFormValues, isSchemaFormProperties, isSchemaFormRef } from '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
+  (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) && isSchemaFormElements(input);
+}
+function isAStringEnumSchema(input) {
+  return isASchema(input) && isSchemaFormEnum(input);
+}
+function isADiscriminatorSchema(input) {
+  return isASchema(input) && isSchemaFormDiscriminator(input);
+}
+function isARecordSchema(input) {
+  return isASchema(input) && isSchemaFormValues(input);
+}
+function isAObjectSchema(input) {
+  return isASchema(input) && isSchemaFormProperties(input);
+}
+function isObject(input) {
+  return typeof input === "object" && input !== null;
+}
+function isARefSchema(input) {
+  return isASchema(input) && 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()}"`;
+}
+
+export { uint64 as $, enumerator as A, extend as B, float32 as C, float64 as D, int16 as E, int32 as F, int64 as G, int8 as H, nullable as I, number as J, object as K, omit as L, optional as M, parse$4 as N, partial as O, pick as P, record as Q, recursive as R, safeCoerce as S, safeParse as T, serialize$1 as U, ValidationError as V, string as W, stringEnum as X, timestamp as Y, uint16 as Z, uint32 as _, uint8Min as a, uint8 as a0, validate$3 as a1, isASchema as a2, SCHEMA_METADATA as a3, int64Min as a4, int64Max as a5, uint64Min as a6, uint64Max as a7, parseObjectSchema as a8, validateObjectSchema as a9, serializeObject as aa, serializeSmallString as ab, sanitizeJson as ac, isValidationError as ad, NumberTypeValues as ae, isObject as af, uint16Max as b, uint16Min as c, uint32Max as d, uint32Min as e, int8Min as f, int16Max as g, int16Min as h, int8Max as i, int32Max as j, int32Min as k, isAScalarSchema as l, isAObjectSchema as m, isAStringEnumSchema as n, isAAraySchema as o, isARecordSchema as p, isADiscriminatorSchema as q, isARefSchema as r, errors as s, any as t, uint8Max as u, array as v, boolean as w, clone as x, coerce$2 as y, discriminator as z };