@arrirpc/schema 0.73.0 → 0.74.0

package/dist/shared/schema.COiEWm_0.cjs

@@ -1,1935 +0,0 @@
-'use strict';
-
-const typeDefs = require('@arrirpc/type-defs');
-require('scule');
-
-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");
-
-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" && (typeDefs.TypeValues.includes(input.type) || NumberTypeValues.includes(input.type));
-}
-const NumberTypeValues = [
-  "float32",
-  "float64",
-  "int8",
-  "int16",
-  "int32",
-  "int64",
-  "uint8",
-  "uint16",
-  "uint32",
-  "uint64"
-];
-function isAAraySchema(input) {
-  return isASchema(input) && typeDefs.isSchemaFormElements(input);
-}
-function isAStringEnumSchema(input) {
-  return isASchema(input) && typeDefs.isSchemaFormEnum(input);
-}
-function isADiscriminatorSchema(input) {
-  return isASchema(input) && typeDefs.isSchemaFormDiscriminator(input);
-}
-function isARecordSchema(input) {
-  return isASchema(input) && typeDefs.isSchemaFormValues(input);
-}
-function isAObjectSchema(input) {
-  return isASchema(input) && typeDefs.isSchemaFormProperties(input);
-}
-function isObject(input) {
-  return typeof input === "object" && input !== null;
-}
-function isARefSchema(input) {
-  return isASchema(input) && typeDefs.isSchemaFormRef(input);
-}
-
-function createStandardSchemaProperty(validate, parse) {
-  return {
-    version: 1,
-    vendor: "arri",
-    validate(input) {
-      if (validate(input)) {
-        return {
-          value: input
-        };
-      }
-      const ctx = {
-        instancePath: "",
-        schemaPath: "",
-        errors: []
-      };
-      try {
-        const result = parse(input, ctx);
-        if (ctx.errors.length) {
-          return {
-            issues: ctx.errors.map((err) => ({
-              message: err.message ?? "Unknown error",
-              path: err.instancePath.split("/").filter((val) => val.length > 0)
-            }))
-          };
-        }
-        return {
-          value: result
-        };
-      } catch (err) {
-        if (err instanceof ValidationError) {
-          return {
-            issues: err.errors.map((err2) => ({
-              message: err2.message ?? "Unknown error",
-              path: err2.instancePath.split("/").filter((item) => item.length > 0)
-            }))
-          };
-        }
-        return {
-          issues: [
-            {
-              message: err instanceof Error ? err.message : `${err}`
-            }
-          ]
-        };
-      }
-    }
-  };
-}
-function hideInvalidProperties(schema) {
-  Object.defineProperty(schema, "~standard", { enumerable: false });
-}
-
-function any(options = {}) {
-  const validate = (input) => true;
-  const parse = (input, context) => {
-    if (context.instancePath.length === 0 && typeof input === "string") {
-      try {
-        return JSON.parse(input);
-      } catch {
-        return input;
-      }
-    }
-    return input;
-  };
-  const result = {
-    metadata: {
-      id: options.id,
-      description: options.description,
-      isDeprecated: options.isDeprecated,
-      [SCHEMA_METADATA]: {
-        output: undefined,
-        parse,
-        coerce: (input, context) => {
-          if (context.instancePath.length === 0 && typeof input === "string") {
-            try {
-              return JSON.parse(input);
-            } catch {
-              return input;
-            }
-          }
-          return input;
-        },
-        validate,
-        serialize(input) {
-          return JSON.stringify(input);
-        }
-      }
-    },
-    "~standard": createStandardSchemaProperty(validate, parse)
-  };
-  hideInvalidProperties(result);
-  return result;
-}
-
-function array(schema, opts = {}) {
-  const validateType = (input) => {
-    return validate$5(schema, input);
-  };
-  const parseType = (input, context) => {
-    return parse$6(schema, input, context, false);
-  };
-  const result = {
-    elements: schema,
-    metadata: {
-      id: opts.id,
-      description: opts.description,
-      isDeprecated: opts.isDeprecated,
-      [SCHEMA_METADATA]: {
-        output: [],
-        parse: parseType,
-        coerce(input, context) {
-          return parse$6(schema, input, context, true);
-        },
-        validate: validateType,
-        serialize(input, context) {
-          const strParts = [];
-          for (let i = 0; i < input.length; i++) {
-            const item = input[i];
-            strParts.push(
-              schema.metadata[SCHEMA_METADATA].serialize(item, {
-                instancePath: `${context.instancePath}/${i}`,
-                schemaPath: `${context.schemaPath}/elements`,
-                errors: context.errors
-              })
-            );
-          }
-          return `[${strParts.join(",")}]`;
-        }
-      }
-    },
-    "~standard": createStandardSchemaProperty(validateType, parseType)
-  };
-  hideInvalidProperties(result);
-  return result;
-}
-function validate$5(innerSchema, input) {
-  if (!Array.isArray(input)) {
-    return false;
-  }
-  for (const item of input) {
-    const isValid = innerSchema.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 (_) {
-      data.errors.push({
-        instancePath: data.instancePath,
-        schemaPath: `${data.schemaPath}/elements`,
-        message: `Error at ${data.instancePath}. Invalid JSON.`
-      });
-      return undefined;
-    }
-  }
-  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 undefined;
-  }
-  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 undefined;
-  }
-  return result;
-}
-
-function boolean(opts = {}) {
-  const result = {
-    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, context) {
-          if (validate$4(input)) {
-            return input;
-          }
-          switch (input) {
-            case "true":
-            case "TRUE":
-            case "1":
-            case 1:
-              return true;
-            case "false":
-            case "FALSE":
-            case "0":
-            case 0:
-              return false;
-          }
-          context.errors.push({
-            instancePath: context.instancePath,
-            schemaPath: context.schemaPath,
-            message: `Error at ${context.instancePath}. Unable to coerce ${input} to boolean.`
-          });
-          return undefined;
-        }
-      }
-    },
-    "~standard": createStandardSchemaProperty(validate$4, parse$5)
-  };
-  hideInvalidProperties(result);
-  return result;
-}
-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 undefined;
-  }
-  data.errors.push({
-    instancePath: data.instancePath,
-    schemaPath: `${data.schemaPath}/type`,
-    message: `Error at ${data.instancePath}. Expected boolean. Got ${typeof input}.`
-  });
-  return undefined;
-}
-function serialize$2(input) {
-  return `${input}`;
-}
-
-function 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 context = {
-    instancePath: "",
-    schemaPath: "",
-    errors: []
-  };
-  return schema.metadata[SCHEMA_METADATA].serialize(input, context);
-}
-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 {
-  errors;
-  constructor(options) {
-    super(options.message);
-    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;
-  }
-  const isType = (input) => {
-    return validate$2(discriminator2, mapping, input);
-  };
-  const parseType = (input, context) => {
-    return parse$3(discriminator2, mapping, input, context, false);
-  };
-  const result = {
-    discriminator: discriminator2,
-    mapping,
-    metadata: {
-      id: opts.id,
-      description: opts.description,
-      isDeprecated: opts.isDeprecated,
-      [SCHEMA_METADATA]: {
-        output: {},
-        validate: isType,
-        parse: parseType,
-        coerce: (input, context) => {
-          return parse$3(discriminator2, mapping, input, context, true);
-        },
-        serialize(input, context) {
-          const discriminatorVal = input[discriminator2] ?? "";
-          const targetSchema = mapping[discriminatorVal];
-          if (!targetSchema) {
-            throw discriminatorMappingError(
-              discriminatorVal,
-              context
-            );
-          }
-          const result2 = targetSchema.metadata[SCHEMA_METADATA].serialize(input, {
-            instancePath: context.instancePath,
-            schemaPath: `${context.schemaPath}/mapping/${discriminatorVal}`,
-            errors: context.errors,
-            discriminatorKey: discriminator2,
-            discriminatorValue: discriminatorVal
-          });
-          return result2;
-        }
-      }
-    },
-    "~standard": createStandardSchemaProperty(isType, parseType)
-  };
-  hideInvalidProperties(result);
-  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 undefined;
-  }
-  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 undefined;
-  }
-  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 undefined;
-  }
-  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 isIdShorthand = typeof paramA === "string";
-  const enumVal = isIdShorthand ? paramB : paramA;
-  const meta = isIdShorthand ? { id: paramA } : paramB;
-  const isType = (input) => {
-    if (typeof input !== "string") {
-      return false;
-    }
-    for (const val of enumVal) {
-      if (val === input) {
-        return true;
-      }
-    }
-    return false;
-  };
-  const parse = (input, context) => {
-    if (isType(input)) {
-      return input;
-    }
-    context.errors.push({
-      instancePath: context.instancePath,
-      schemaPath: `${context.schemaPath}/enum`,
-      message: `Error at ${context.instancePath}. Invalid enum value. Expected one of the following values: [${enumVal.join(
-        ", "
-      )}]`
-    });
-    return undefined;
-  };
-  const result = {
-    enum: enumVal,
-    metadata: {
-      id: meta?.id,
-      description: meta?.description,
-      isDeprecated: meta?.isDeprecated,
-      [SCHEMA_METADATA]: {
-        output: paramA[0] ?? "",
-        parse,
-        coerce: (input, context) => {
-          if (isType(input)) {
-            return input;
-          }
-          context.errors.push({
-            instancePath: context.instancePath,
-            schemaPath: `${context.schemaPath}/enum`,
-            message: `Error at ${context.instancePath}. Invalid enum value. Expected one of the following values: [${enumVal.join(
-              ", "
-            )}]`
-          });
-          return undefined;
-        },
-        validate: isType,
-        serialize(input, context) {
-          if (context.instancePath.length === 0) {
-            return input;
-          }
-          return `"${input}"`;
-        }
-      }
-    },
-    "~standard": createStandardSchemaProperty(isType, parse)
-  };
-  hideInvalidProperties(result);
-  return result;
-}
-
-function nullable(schema, opts = {}) {
-  const isType = (val) => {
-    if (val === null) {
-      return true;
-    }
-    return schema.metadata[SCHEMA_METADATA].validate(val);
-  };
-  const parse = (val, data) => {
-    if (data.instancePath.length === 0 && typeof val === "string" && val === "null") {
-      return null;
-    }
-    if (val === null) {
-      return null;
-    }
-    return schema.metadata[SCHEMA_METADATA].parse(val, data);
-  };
-  const result = {
-    ...schema,
-    nullable: true,
-    metadata: {
-      id: opts.id ?? schema.metadata.id,
-      description: opts.description ?? schema.metadata.description,
-      isDeprecated: opts.isDeprecated ?? schema.metadata.isDeprecated,
-      [SCHEMA_METADATA]: {
-        output: null,
-        optional: schema.metadata[SCHEMA_METADATA].optional,
-        validate: isType,
-        parse,
-        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
-          );
-        }
-      }
-    }
-  };
-  hideInvalidProperties(result);
-  return result;
-}
-function optional(input, opts = {}) {
-  const isType = (val) => {
-    if (val === undefined) {
-      return true;
-    }
-    return input.metadata[SCHEMA_METADATA].validate(val);
-  };
-  const parse = (val, context) => {
-    if (typeof val === "undefined") {
-      return undefined;
-    }
-    if (context.instancePath.length === 0 && val === "undefined") {
-      return undefined;
-    }
-    return input.metadata[SCHEMA_METADATA].parse(val, context);
-  };
-  const result = {
-    ...input,
-    metadata: {
-      id: opts.id ?? input.metadata.id,
-      description: opts.description ?? input.metadata.description,
-      isDeprecated: opts.isDeprecated ?? input.metadata.isDeprecated,
-      [SCHEMA_METADATA]: {
-        output: undefined,
-        optional: true,
-        validate: isType,
-        parse,
-        coerce: (val, data) => {
-          if (typeof val === "undefined") {
-            return undefined;
-          }
-          if (val === "undefined") {
-            return undefined;
-          }
-          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);
-        }
-      }
-    },
-    "~standard": createStandardSchemaProperty(isType, parse)
-  };
-  hideInvalidProperties(result);
-  return result;
-}
-function clone(input, opts = {}) {
-  const schema = {
-    ...input,
-    metadata: {
-      id: opts.id,
-      description: opts.description,
-      isDeprecated: opts.isDeprecated,
-      [SCHEMA_METADATA]: {
-        ...input.metadata[SCHEMA_METADATA]
-      }
-    },
-    "~standard": input["~standard"]
-  };
-  hideInvalidProperties(schema);
-  return schema;
-}
-
-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 undefined;
-    }
-    return parseNumber(parsedInput, options);
-  }
-  return parseNumber(input, options);
-}
-function float32(opts = {}) {
-  return numberScalarType("float32", opts, () => {
-    return {
-      success: true
-    };
-  });
-}
-function float64(opts = {}) {
-  return numberScalarType("float64", opts, () => {
-    return {
-      success: true
-    };
-  });
-}
-function int8(opts = {}) {
-  return numberScalarType("int8", opts, (input) => {
-    const isValid = validateInt(input, int8Min, int8Max);
-    if (isValid) {
-      return {
-        success: true
-      };
-    }
-    return {
-      success: false,
-      message: `Must be an valid integer between ${int8Min} and ${int8Max}`
-    };
-  });
-}
-function uint8(opts = {}) {
-  return numberScalarType("uint8", opts, (input) => {
-    const isValid = validateInt(input, uint8Min, uint8Max);
-    if (isValid) {
-      return {
-        success: true
-      };
-    }
-    return {
-      success: false,
-      message: `Must be a valid integer between ${uint8Min} and ${uint8Max}`
-    };
-  });
-}
-function int16(opts = {}) {
-  return numberScalarType("int16", opts, (input) => {
-    const isValid = validateInt(input, int16Min, int16Max);
-    if (isValid) {
-      return {
-        success: true
-      };
-    }
-    return {
-      success: false,
-      message: `Must be a valid integer between ${int16Min} and ${int16Max}`
-    };
-  });
-}
-function uint16(opts = {}) {
-  return numberScalarType("uint16", opts, (input) => {
-    const isValid = validateInt(input, uint16Min, uint16Max);
-    if (isValid) {
-      return {
-        success: true
-      };
-    }
-    return {
-      success: false,
-      message: `Must be a valid integer between ${uint16Min} and ${uint16Max}`
-    };
-  });
-}
-function int32(opts = {}) {
-  return numberScalarType("int32", opts, (input) => {
-    const isValid = validateInt(input, int32Min, int32Max);
-    if (isValid) {
-      return {
-        success: true
-      };
-    }
-    return {
-      success: false,
-      message: `Must be a valid integer between ${int32Min} and ${int32Max}`
-    };
-  });
-}
-function uint32(opts = {}) {
-  return numberScalarType("uint32", opts, (input) => {
-    const isValid = validateInt(input, uint32Min, uint32Max);
-    if (isValid) {
-      return { success: true };
-    }
-    return {
-      success: false,
-      message: `Must be a valid integer between ${uint32Min} and ${uint32Max}`
-    };
-  });
-}
-function int64(opts = {}) {
-  function isType(input) {
-    return typeof input === "bigint" && input >= int64Min && input <= int64Max;
-  }
-  function parse(input, 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 (_) {
-        data.errors.push({
-          message: `Error at ${data.instancePath}. Unable to transform ${input} to BigInt`,
-          schemaPath: `${data.schemaPath}/type`,
-          instancePath: data.instancePath
-        });
-        return undefined;
-      }
-    }
-    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 undefined;
-  }
-  const result = {
-    type: "int64",
-    metadata: {
-      id: opts.id,
-      description: opts.description,
-      isDeprecated: opts.isDeprecated,
-      [SCHEMA_METADATA]: {
-        output: BigInt("0"),
-        validate: isType,
-        parse,
-        coerce: parse,
-        serialize(input, context) {
-          if (context.instancePath.length === 0) {
-            return input.toString();
-          }
-          return `"${input.toString()}"`;
-        }
-      }
-    },
-    "~standard": createStandardSchemaProperty(isType, parse)
-  };
-  hideInvalidProperties(result);
-  return result;
-}
-function uint64(opts = {}) {
-  function isType(input) {
-    return typeof input === "bigint" && input >= uint64Min && input <= uint64Max;
-  }
-  function parse(input, 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 (_) {
-        data.errors.push({
-          message: `Error at ${data.instancePath}. Unable to transform ${input} to BigInt.`,
-          schemaPath: `${data.schemaPath}/type`,
-          instancePath: data.instancePath
-        });
-        return undefined;
-      }
-    }
-    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 undefined;
-  }
-  const result = {
-    type: "uint64",
-    metadata: {
-      id: opts.id,
-      description: opts.description,
-      isDeprecated: opts.isDeprecated,
-      [SCHEMA_METADATA]: {
-        output: BigInt("0"),
-        validate: isType,
-        parse,
-        coerce: parse,
-        serialize(input, context) {
-          if (context.instancePath.length === 0) {
-            return input.toString();
-          }
-          return `"${input.toString()}"`;
-        }
-      }
-    },
-    "~standard": createStandardSchemaProperty(isType, parse)
-  };
-  hideInvalidProperties(result);
-  return result;
-}
-function validateNumber(input) {
-  return typeof input === "number";
-}
-function validateInt(input, minVal, maxValue) {
-  return Number.isInteger(input) && input >= minVal && input <= maxValue;
-}
-function serializeNumber(input, _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 undefined;
-    }
-    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 undefined;
-}
-function numberScalarType(type, opts, numTypeMatcher) {
-  const validate = (input) => {
-    const isNum = validateNumber(input);
-    if (!isNum) {
-      return false;
-    }
-    return numTypeMatcher(input).success;
-  };
-  const parse = (input, context) => {
-    const result2 = parseNumber(input, context);
-    if (context.errors.length) {
-      return undefined;
-    }
-    if (typeof result2 !== "number") {
-      context?.errors.push({
-        instancePath: context.instancePath,
-        schemaPath: `${context.schemaPath}/type`,
-        message: `Error at ${context.instancePath}. Invalid number.`
-      });
-      return undefined;
-    }
-    const matchResult = numTypeMatcher(result2);
-    if (matchResult.success) {
-      return result2;
-    }
-    context?.errors.push({
-      instancePath: context.instancePath,
-      schemaPath: `${context.schemaPath}/type`,
-      message: `Error at ${context.instancePath}. ${matchResult.message}`
-    });
-    return undefined;
-  };
-  const result = {
-    type,
-    metadata: {
-      id: opts.id,
-      description: opts.description,
-      isDeprecated: opts.isDeprecated,
-      [SCHEMA_METADATA]: {
-        output: 0,
-        validate,
-        parse,
-        serialize: serializeNumber,
-        coerce(input, options) {
-          const result2 = coerceNumber(input, options);
-          if (typeof result2 !== "number") {
-            options.errors.push({
-              instancePath: options.instancePath,
-              schemaPath: `${options.schemaPath}/type`,
-              message: `Error at ${options.instancePath}. Unable to coerce ${typeof input} to ${type}.`
-            });
-            return undefined;
-          }
-          const matchResult = numTypeMatcher(result2);
-          if (matchResult.success) {
-            return result2;
-          }
-          options.errors.push({
-            instancePath: options.instancePath,
-            schemaPath: `${options.schemaPath}/type`,
-            message: `Error at ${options.instancePath}. ${matchResult.message}`
-          });
-          return undefined;
-        }
-      }
-    },
-    "~standard": createStandardSchemaProperty(validate, parse)
-  };
-  hideInvalidProperties(result);
-  return result;
-}
-
-function object(propA, propB) {
-  const isIdShorthand = typeof propA === "string";
-  const input = isIdShorthand ? propB : propA;
-  const options = isIdShorthand ? { id: propA } : propB ?? {};
-  const schema = {
-    properties: {}
-  };
-  if (typeof options.strict === "boolean") {
-    schema.strict = options.strict;
-  }
-  for (const key of Object.keys(input)) {
-    const prop = input[key];
-    if (prop.metadata[SCHEMA_METADATA].optional) {
-      if (!schema.optionalProperties) {
-        schema.optionalProperties = {};
-      }
-      schema.optionalProperties[key] = prop;
-      continue;
-    }
-    schema.properties[key] = prop;
-  }
-  const validate = (input2) => {
-    return validateObjectSchema(schema, input2);
-  };
-  const parse = (input2, context) => {
-    return parseObjectSchema(
-      schema,
-      input2,
-      context,
-      false
-    );
-  };
-  const result = {
-    ...schema,
-    metadata: {
-      id: options.id,
-      description: options.description,
-      isDeprecated: options.isDeprecated,
-      [SCHEMA_METADATA]: {
-        output: {},
-        parse,
-        coerce(input2, context) {
-          return parseObjectSchema(
-            schema,
-            input2,
-            context,
-            true
-          );
-        },
-        validate,
-        serialize(input2, context) {
-          return serializeObject(
-            schema,
-            input2,
-            context
-          );
-        }
-      }
-    },
-    "~standard": createStandardSchemaProperty(validate, parse)
-  };
-  hideInvalidProperties(result);
-  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 undefined;
-    }
-  }
-  if (!isObject(parsedInput)) {
-    data.errors.push({
-      instancePath: data.instancePath,
-      schemaPath: `${data.schemaPath}/properties`,
-      message: `Error at ${data.instancePath}. Expected object`
-    });
-    return undefined;
-  }
-  const result = {};
-  const optionalProps = schema.optionalProperties ?? {};
-  const inputKeys = Object.keys(parsedInput);
-  const requiredKeys = Object.keys(schema.properties);
-  const optionalKeys = Object.keys(optionalProps);
-  if (schema.strict) {
-    for (const key of inputKeys) {
-      if (!requiredKeys.includes(key) && !optionalKeys.includes(key) && key !== data.discriminatorKey) {
-        data.errors.push({
-          instancePath: `${data.instancePath}/${key}`,
-          schemaPath: `${data.schemaPath}/strict`,
-          message: `Error at ${data.instancePath}/${key}. Key '${key}' is not included in the schema. To allow additional input properties set strict to 'false'.`
-        });
-      }
-    }
-  }
-  if (data.errors.length) {
-    return undefined;
-  }
-  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 === undefined) {
-      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 undefined;
-  }
-  return result;
-}
-function validateObjectSchema(schema, input) {
-  if (!isObject(input)) {
-    return false;
-  }
-  const allowedKeys = schema.strict ? [] : undefined;
-  for (const key of Object.keys(schema.properties)) {
-    const propSchema = schema.properties[key];
-    const isValid = propSchema.metadata[SCHEMA_METADATA].validate(
-      input[key]
-    );
-    if (!isValid) return false;
-    allowedKeys?.push(key);
-  }
-  if (schema.optionalProperties) {
-    for (const key of Object.keys(schema.optionalProperties)) {
-      const propsSchema = schema.optionalProperties[key];
-      const isValid = propsSchema.metadata[SCHEMA_METADATA].validate(
-        input[key]
-      );
-      if (!isValid) return false;
-      allowedKeys?.push(key);
-    }
-  }
-  if (allowedKeys) {
-    for (const key of Object.keys(input)) {
-      if (!allowedKeys.includes(key)) return false;
-    }
-  }
-  return true;
-}
-function pick(inputSchema, keys, options = {}) {
-  const schema = {
-    properties: {},
-    nullable: inputSchema.nullable
-  };
-  if (typeof options.strict === "boolean") {
-    schema.strict = options.strict;
-  }
-  Object.keys(inputSchema.properties).forEach((key) => {
-    if (!schema.properties) {
-      return;
-    }
-    if (keys.includes(key)) {
-      schema.properties[key] = inputSchema.properties[key];
-    }
-  });
-  if (inputSchema.optionalProperties) {
-    schema.optionalProperties = {};
-    Object.keys(inputSchema.optionalProperties).forEach((key) => {
-      if (!schema.optionalProperties || !inputSchema.optionalProperties) {
-        return;
-      }
-      if (keys.includes(key)) {
-        schema.optionalProperties[key] = inputSchema.optionalProperties[key];
-      }
-    });
-  }
-  const parse = (input, context) => {
-    return parseObjectSchema(schema, input, context, false);
-  };
-  const validate = (input) => {
-    return validateObjectSchema(schema, input);
-  };
-  const result = {
-    ...schema,
-    metadata: {
-      id: options.id,
-      description: options.description,
-      isDeprecated: options.isDeprecated,
-      [SCHEMA_METADATA]: {
-        output: {},
-        parse,
-        coerce(input, context) {
-          return parseObjectSchema(
-            schema,
-            input,
-            context,
-            false
-          );
-        },
-        validate,
-        serialize(input, context) {
-          return serializeObject(schema, input, context);
-        }
-      }
-    },
-    "~standard": createStandardSchemaProperty(validate, parse)
-  };
-  hideInvalidProperties(result);
-  return result;
-}
-function omit(inputSchema, keys, options = {}) {
-  const schema = {
-    properties: {
-      ...inputSchema.properties
-    },
-    nullable: inputSchema.nullable
-  };
-  if (typeof options.strict === "boolean") {
-    schema.strict = options.strict;
-  }
-  Object.keys(inputSchema.properties).forEach((key) => {
-    if (keys.includes(key)) {
-      delete schema.properties[key];
-    }
-  });
-  if (inputSchema.optionalProperties) {
-    schema.optionalProperties = {
-      ...inputSchema.optionalProperties
-    };
-    Object.keys(inputSchema.optionalProperties).forEach((key) => {
-      if (!schema.optionalProperties) {
-        return;
-      }
-      if (keys.includes(key)) {
-        delete schema.optionalProperties[key];
-      }
-    });
-  }
-  const validate = (input) => validateObjectSchema(schema, input);
-  const parse = (input, context) => parseObjectSchema(schema, input, context, false);
-  const result = {
-    ...schema,
-    metadata: {
-      id: options.id,
-      description: options.description,
-      isDeprecated: options.isDeprecated,
-      [SCHEMA_METADATA]: {
-        output: {},
-        validate,
-        parse,
-        serialize(input, context) {
-          return serializeObject(schema, input, context);
-        },
-        coerce(input, context) {
-          return parseObjectSchema(
-            schema,
-            input,
-            context,
-            true
-          );
-        }
-      }
-    },
-    "~standard": createStandardSchemaProperty(validate, parse)
-  };
-  hideInvalidProperties(result);
-  return result;
-}
-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, options = {}) {
-  const schema = {
-    properties: {
-      ...baseSchema.properties,
-      ...inputSchema.properties
-    },
-    optionalProperties: {
-      ...baseSchema.optionalProperties,
-      ...inputSchema.optionalProperties
-    }
-  };
-  if (typeof options.strict === "boolean") {
-    schema.strict = options.strict;
-  }
-  const isType = (input) => validateObjectSchema(schema, input);
-  const meta = {
-    id: options.id,
-    description: options.description,
-    [SCHEMA_METADATA]: {
-      output: {},
-      parse(input, context) {
-        return parseObjectSchema(schema, input, context, false);
-      },
-      coerce(input, context) {
-        return parseObjectSchema(schema, input, context, true);
-      },
-      validate: isType,
-      serialize(input, context) {
-        return serializeObject(schema, input, context);
-      }
-    }
-  };
-  schema.metadata = meta;
-  return schema;
-}
-function partial(schema, options = {}) {
-  const newSchema = {
-    properties: {},
-    optionalProperties: {},
-    nullable: schema.nullable
-  };
-  if (typeof options.strict === "boolean") {
-    schema.strict = options.strict;
-  }
-  for (const key of Object.keys(schema.properties)) {
-    const prop = schema.properties[key];
-    newSchema.optionalProperties[key] = optional(prop);
-  }
-  if (schema.optionalProperties && newSchema.optionalProperties) {
-    for (const key of Object.keys(schema.optionalProperties)) {
-      const prop = schema.optionalProperties[key];
-      if (prop.metadata[SCHEMA_METADATA].optional) {
-        newSchema.optionalProperties[key] = prop;
-      } else {
-        newSchema.optionalProperties[key] = optional(prop);
-      }
-    }
-  }
-  const validate = (input) => {
-    return validateObjectSchema(newSchema, input);
-  };
-  const parse = (input, context) => {
-    return parseObjectSchema(newSchema, input, context, false);
-  };
-  const meta = {
-    id: options.id,
-    description: options.description,
-    [SCHEMA_METADATA]: {
-      output: {},
-      optional: schema.metadata[SCHEMA_METADATA].optional,
-      validate,
-      parse,
-      coerce(input, context) {
-        return parseObjectSchema(
-          newSchema,
-          input,
-          context,
-          true
-        );
-      },
-      serialize(input, context) {
-        return serializeObject(schema, input, context);
-      }
-    }
-  };
-  newSchema.metadata = meta;
-  newSchema["~standard"] = createStandardSchemaProperty(
-    validate,
-    parse
-  );
-  hideInvalidProperties(newSchema);
-  return newSchema;
-}
-
-function string(opts = {}) {
-  const result = {
-    type: "string",
-    metadata: {
-      id: opts.id,
-      description: opts.description,
-      isDeprecated: opts.isDeprecated,
-      [SCHEMA_METADATA]: {
-        output: "",
-        parse: parse$2,
-        coerce: coerce$1,
-        validate: validate$1,
-        serialize(input, context) {
-          if (context.instancePath.length === 0) {
-            return input;
-          }
-          if (input.length < 42) {
-            return serializeSmallString(input);
-          }
-          if (input.length < 5e3 && !STR_ESCAPE.test(input)) {
-            return `"${input}"`;
-          }
-          return JSON.stringify(input);
-        }
-      }
-    },
-    "~standard": createStandardSchemaProperty(validate$1, parse$2)
-  };
-  hideInvalidProperties(result);
-  return result;
-}
-function serializeString(input) {
-  if (input.length < 42) {
-    return serializeSmallString(input);
-  }
-  if (input.length < 5e3 && !STR_ESCAPE.test(input)) {
-    return `"${input}"`;
-  }
-  return JSON.stringify(input);
-}
-function validate$1(input) {
-  return typeof input === "string";
-}
-function parse$2(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 undefined;
-}
-function coerce$1(input, context) {
-  return parse$2(input, context);
-}
-const STR_ESCAPE = (
-  // eslint-disable-next-line no-control-regex
-  /[\u0000-\u001f\u0022\u005c\ud800-\udfff]|[\ud800-\udbff](?![\udc00-\udfff])|(?:[^\ud800-\udbff]|^)[\udc00-\udfff]/
-);
-function serializeSmallString(input) {
-  const len = input.length;
-  let result = "";
-  let last = -1;
-  let point = 255;
-  for (let i = 0; i < len; i++) {
-    point = input.charCodeAt(i);
-    if (point < 32 || point >= 55296 && point <= 57343) {
-      return JSON.stringify(input);
-    }
-    if (point === 34 || // '"'
-    point === 92) {
-      if (last === -1) {
-        last = 0;
-      }
-      result += input.slice(last, i) + "\\";
-      last = i;
-    }
-  }
-  if (last === -1) {
-    return `"${input}"`;
-  }
-  return `"${result}${input.slice(last)}"`;
-}
-
-function record(schema, opts = {}) {
-  const validateFn = (input) => {
-    if (!isObject(input)) {
-      return false;
-    }
-    for (const key of Object.keys(input)) {
-      const val = input[key];
-      const isValid = schema.metadata[SCHEMA_METADATA].validate(val);
-      if (!isValid) {
-        return false;
-      }
-    }
-    return true;
-  };
-  const parseFn = (input, ctx) => {
-    return parse$1(schema, input, ctx, false);
-  };
-  const result = {
-    values: schema,
-    metadata: {
-      id: opts.id,
-      description: opts.description,
-      isDeprecated: opts.isDeprecated,
-      [SCHEMA_METADATA]: {
-        output: {},
-        validate: validateFn,
-        parse: parseFn,
-        coerce(input, data) {
-          return parse$1(schema, input, data, true);
-        },
-        serialize(input, context) {
-          let result2 = "{";
-          const keys = Object.keys(input);
-          for (let i = 0; i < keys.length; i++) {
-            const key = keys[i];
-            const val = input[key];
-            if (i > 0) result2 += ",";
-            result2 += serializeString(key);
-            result2 += ":";
-            result2 += schema.metadata[SCHEMA_METADATA].serialize(
-              val,
-              {
-                instancePath: `${context.instancePath}/${key}`,
-                schemaPath: `${context.schemaPath}/values`,
-                errors: context.errors
-              }
-            );
-          }
-          result2 += "}";
-          return result2;
-        }
-      }
-    },
-    "~standard": createStandardSchemaProperty(validateFn, parseFn)
-  };
-  hideInvalidProperties(result);
-  return result;
-}
-function parse$1(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 undefined;
-  }
-  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 undefined;
-  }
-  return result;
-}
-
-let recursiveTypeCount = 0;
-function recursive(propA, propB) {
-  const isIdShorthand = typeof propA === "string";
-  const callback = isIdShorthand ? propB : propA;
-  const options = isIdShorthand ? { id: propA } : propB ?? {};
-  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 metadata = {
-    [SCHEMA_METADATA]: {
-      output: "",
-      parse(input, context) {
-        if (recursiveFns[id]) {
-          return recursiveFns[id].parse(input, context);
-        }
-      },
-      serialize(input, context) {
-        if (recursiveFns[id]) {
-          return recursiveFns[id].serialize(input, context);
-        }
-        return "";
-      },
-      validate(input) {
-        if (recursiveFns[id]) {
-          return recursiveFns[id].validate(input);
-        }
-        return false;
-      },
-      coerce(input, context) {
-        if (recursiveFns[id]) {
-          return recursiveFns[id].coerce(input, context);
-        }
-      }
-    }
-  };
-  const schema = {
-    ref: id,
-    metadata,
-    "~standard": createStandardSchemaProperty(
-      metadata[SCHEMA_METADATA].validate,
-      metadata[SCHEMA_METADATA].parse
-    )
-  };
-  hideInvalidProperties(schema);
-  const mainSchema = callback(schema);
-  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 timestamp(opts = {}) {
-  const result = {
-    type: "timestamp",
-    metadata: {
-      id: opts.id,
-      description: opts.description,
-      isDeprecated: opts.isDeprecated,
-      [SCHEMA_METADATA]: {
-        output: /* @__PURE__ */ new Date(),
-        validate,
-        parse,
-        coerce,
-        serialize
-      }
-    },
-    "~standard": createStandardSchemaProperty(validate, parse)
-  };
-  hideInvalidProperties(result);
-  return result;
-}
-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 undefined;
-    }
-    return new Date(result);
-  }
-  data.errors.push({
-    message: `Error at ${data.instancePath}. Invalid date.`,
-    instancePath: data.instancePath,
-    schemaPath: `${data.schemaPath}/type`
-  });
-  return undefined;
-}
-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.STR_ESCAPE = STR_ESCAPE;
-exports.ValidationError = ValidationError;
-exports.any = any;
-exports.array = array;
-exports.boolean = boolean;
-exports.clone = clone;
-exports.coerce = coerce$2;
-exports.createStandardSchemaProperty = createStandardSchemaProperty;
-exports.discriminator = discriminator;
-exports.enumerator = enumerator;
-exports.errors = errors;
-exports.extend = extend;
-exports.float32 = float32;
-exports.float64 = float64;
-exports.hideInvalidProperties = hideInvalidProperties;
-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.serializeString = serializeString;
-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;