@arrirpc/schema 0.70.1 → 0.71.1

package/dist/shared/{schema.lowJcmic.mjs → schema.PNAcAdz3.mjs}

@@ -1,4 +1,5 @@
 import { TypeValues, isSchemaFormElements, isSchemaFormEnum, isSchemaFormDiscriminator, isSchemaFormValues, isSchemaFormProperties, isSchemaFormRef } from '@arrirpc/type-defs';
+import 'scule';
 
 const int8Min = -128;
 const int8Max = 127;
@@ -67,24 +68,78 @@ function isARefSchema(input) {
   return isASchema(input) && isSchemaFormRef(input);
 }
 
-function any(options = {}) {
+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: void 0,
-        parse: (input, context) => {
-          if (context.instancePath.length === 0 && typeof input === "string") {
-            try {
-              return JSON.parse(input);
-            } catch {
-              return input;
-            }
-          }
-          return input;
-        },
+        output: undefined,
+        parse,
         coerce: (input, context) => {
           if (context.instancePath.length === 0 && typeof input === "string") {
             try {
@@ -95,17 +150,26 @@ function any(options = {}) {
           }
           return input;
         },
-        validate: (input) => true,
+        validate,
         serialize(input) {
           return JSON.stringify(input);
         }
       }
-    }
+    },
+    "~standard": createStandardSchemaProperty(validate, parse)
   };
+  hideInvalidProperties(result);
+  return result;
 }
 
 function array(schema, opts = {}) {
-  return {
+  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,
@@ -113,15 +177,11 @@ function array(schema, opts = {}) {
       isDeprecated: opts.isDeprecated,
       [SCHEMA_METADATA]: {
         output: [],
-        parse(input, context) {
-          return parse$6(schema, input, context, false);
-        },
+        parse: parseType,
         coerce(input, context) {
           return parse$6(schema, input, context, true);
         },
-        validate(input) {
-          return validate$5(schema, input);
-        },
+        validate: validateType,
         serialize(input, context) {
           const strParts = [];
           for (let i = 0; i < input.length; i++) {
@@ -137,8 +197,11 @@ function array(schema, opts = {}) {
           return `[${strParts.join(",")}]`;
         }
       }
-    }
+    },
+    "~standard": createStandardSchemaProperty(validateType, parseType)
   };
+  hideInvalidProperties(result);
+  return result;
 }
 function validate$5(innerSchema, input) {
   if (!Array.isArray(input)) {
@@ -163,7 +226,7 @@ function parse$6(innerSchema, input, data, coerce = false) {
         schemaPath: `${data.schemaPath}/elements`,
         message: `Error at ${data.instancePath}. Invalid JSON.`
       });
-      return void 0;
+      return undefined;
     }
   }
   if (!Array.isArray(parsedInput)) {
@@ -172,7 +235,7 @@ function parse$6(innerSchema, input, data, coerce = false) {
       schemaPath: `${data.schemaPath}/elements`,
       message: `Error at ${data.instancePath}. Expected array. Got ${typeof input}.`
     });
-    return void 0;
+    return undefined;
   }
   const result = [];
   for (let i = 0; i < parsedInput.length; i++) {
@@ -200,13 +263,13 @@ function parse$6(innerSchema, input, data, coerce = false) {
     }
   }
   if (data.errors.length) {
-    return void 0;
+    return undefined;
   }
   return result;
 }
 
 function boolean(opts = {}) {
-  return {
+  const result = {
     type: "boolean",
     metadata: {
       id: opts.id,
@@ -238,11 +301,14 @@ function boolean(opts = {}) {
             schemaPath: context.schemaPath,
             message: `Error at ${context.instancePath}. Unable to coerce ${input} to boolean.`
           });
-          return void 0;
+          return undefined;
         }
       }
-    }
+    },
+    "~standard": createStandardSchemaProperty(validate$4, parse$5)
   };
+  hideInvalidProperties(result);
+  return result;
 }
 function validate$4(input) {
   return typeof input === "boolean";
@@ -263,14 +329,14 @@ function parse$5(input, data) {
       schemaPath: `${data.schemaPath}/type`,
       message: `Error at ${data.instancePath}. Expected boolean. Got ${typeof input}.`
     });
-    return void 0;
+    return undefined;
   }
   data.errors.push({
     instancePath: data.instancePath,
     schemaPath: `${data.schemaPath}/type`,
     message: `Error at ${data.instancePath}. Expected boolean. Got ${typeof input}.`
   });
-  return void 0;
+  return undefined;
 }
 function serialize$2(input) {
   return `${input}`;
@@ -401,7 +467,13 @@ function discriminator(propA, propB, propC) {
   if (isIdShorthand) {
     opts.id = propA;
   }
-  return {
+  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: {
@@ -410,12 +482,8 @@ function discriminator(propA, propB, propC) {
       isDeprecated: opts.isDeprecated,
       [SCHEMA_METADATA]: {
         output: {},
-        validate(input) {
-          return validate$2(discriminator2, mapping, input);
-        },
-        parse(input, context) {
-          return parse$3(discriminator2, mapping, input, context, false);
-        },
+        validate: isType,
+        parse: parseType,
         coerce: (input, context) => {
           return parse$3(discriminator2, mapping, input, context, true);
         },
@@ -428,18 +496,21 @@ function discriminator(propA, propB, propC) {
               context
             );
           }
-          const result = targetSchema.metadata[SCHEMA_METADATA].serialize(input, {
+          const result2 = targetSchema.metadata[SCHEMA_METADATA].serialize(input, {
             instancePath: context.instancePath,
             schemaPath: `${context.schemaPath}/mapping/${discriminatorVal}`,
             errors: context.errors,
             discriminatorKey: discriminator2,
             discriminatorValue: discriminatorVal
           });
-          return result;
+          return result2;
         }
       }
-    }
+    },
+    "~standard": createStandardSchemaProperty(isType, parseType)
   };
+  hideInvalidProperties(result);
+  return result;
 }
 function validate$2(discriminator2, mapping, input) {
   if (!isObject(input)) {
@@ -469,7 +540,7 @@ function parse$3(discriminator2, mapping, input, data, coerce = false) {
       schemaPath: `${data.schemaPath}/discriminator`,
       message: `Error at ${data.instancePath}. Expected object. Got ${typeof parsedInput}.`
     });
-    return void 0;
+    return undefined;
   }
   if (!(discriminator2 in parsedInput)) {
     data.errors.push({
@@ -477,7 +548,7 @@ function parse$3(discriminator2, mapping, input, data, coerce = false) {
       schemaPath: `${data.schemaPath}/discriminator`,
       message: `Error at ${data.instancePath}/${discriminator2}. Discriminator field "${discriminator2}" cannot be undefined`
     });
-    return void 0;
+    return undefined;
   }
   const acceptedDiscriminatorVals = Object.keys(mapping);
   const discriminatorVal = parsedInput[discriminator2];
@@ -489,7 +560,7 @@ function parse$3(discriminator2, mapping, input, data, coerce = false) {
         ", "
       )}]`
     });
-    return void 0;
+    return undefined;
   }
   const targetSchema = mapping[parsedInput[discriminator2]];
   if (!targetSchema) {
@@ -546,7 +617,20 @@ function enumerator(paramA, paramB) {
     }
     return false;
   };
-  return {
+  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,
@@ -554,19 +638,7 @@ function enumerator(paramA, paramB) {
       isDeprecated: meta?.isDeprecated,
       [SCHEMA_METADATA]: {
         output: paramA[0] ?? "",
-        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 void 0;
-        },
+        parse,
         coerce: (input, context) => {
           if (isType(input)) {
             return input;
@@ -578,7 +650,7 @@ function enumerator(paramA, paramB) {
               ", "
             )}]`
           });
-          return void 0;
+          return undefined;
         },
         validate: isType,
         serialize(input, context) {
@@ -588,8 +660,11 @@ function enumerator(paramA, paramB) {
           return `"${input}"`;
         }
       }
-    }
+    },
+    "~standard": createStandardSchemaProperty(isType, parse)
   };
+  hideInvalidProperties(result);
+  return result;
 }
 
 function nullable(schema, opts = {}) {
@@ -599,7 +674,16 @@ function nullable(schema, opts = {}) {
     }
     return schema.metadata[SCHEMA_METADATA].validate(val);
   };
-  return {
+  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: {
@@ -610,15 +694,7 @@ function nullable(schema, opts = {}) {
         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);
-        },
+        parse,
         coerce(val, data) {
           if (val === null) {
             return null;
@@ -640,39 +716,42 @@ function nullable(schema, opts = {}) {
       }
     }
   };
+  hideInvalidProperties(result);
+  return result;
 }
 function optional(input, opts = {}) {
   const isType = (val) => {
-    if (val === void 0) {
+    if (val === undefined) {
       return true;
     }
     return input.metadata[SCHEMA_METADATA].validate(val);
   };
-  return {
+  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: void 0,
+        output: undefined,
         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);
-        },
+        parse,
         coerce: (val, data) => {
           if (typeof val === "undefined") {
-            return void 0;
+            return undefined;
           }
           if (val === "undefined") {
-            return void 0;
+            return undefined;
           }
           return input.metadata[SCHEMA_METADATA].coerce(val, data);
         },
@@ -683,8 +762,11 @@ function optional(input, opts = {}) {
           return input.metadata[SCHEMA_METADATA].serialize(val, data);
         }
       }
-    }
+    },
+    "~standard": createStandardSchemaProperty(isType, parse)
   };
+  hideInvalidProperties(result);
+  return result;
 }
 function clone(input, opts = {}) {
   const schema = {
@@ -696,8 +778,10 @@ function clone(input, opts = {}) {
       [SCHEMA_METADATA]: {
         ...input.metadata[SCHEMA_METADATA]
       }
-    }
+    },
+    "~standard": input["~standard"]
   };
+  hideInvalidProperties(schema);
   return schema;
 }
 
@@ -713,7 +797,7 @@ function coerceNumber(input, options) {
         schemaPath: `${options.schemaPath}/type`,
         message: `Error at ${options.instancePath}. Unable to coerce ${typeof input} into a number`
       });
-      return void 0;
+      return undefined;
     }
     return parseNumber(parsedInput, options);
   }
@@ -838,7 +922,7 @@ function int64(opts = {}) {
           schemaPath: `${data.schemaPath}/type`,
           instancePath: data.instancePath
         });
-        return void 0;
+        return undefined;
       }
     }
     if (isType(input)) {
@@ -849,9 +933,9 @@ function int64(opts = {}) {
       schemaPath: `${data.schemaPath}/type`,
       instancePath: data.instancePath
     });
-    return void 0;
+    return undefined;
   }
-  return {
+  const result = {
     type: "int64",
     metadata: {
       id: opts.id,
@@ -869,8 +953,11 @@ function int64(opts = {}) {
           return `"${input.toString()}"`;
         }
       }
-    }
+    },
+    "~standard": createStandardSchemaProperty(isType, parse)
   };
+  hideInvalidProperties(result);
+  return result;
 }
 function uint64(opts = {}) {
   function isType(input) {
@@ -895,7 +982,7 @@ function uint64(opts = {}) {
           schemaPath: `${data.schemaPath}/type`,
           instancePath: data.instancePath
         });
-        return void 0;
+        return undefined;
       }
     }
     if (isType(input)) {
@@ -906,9 +993,9 @@ function uint64(opts = {}) {
       schemaPath: `${data.schemaPath}/type`,
       instancePath: data.instancePath
     });
-    return void 0;
+    return undefined;
   }
-  return {
+  const result = {
     type: "uint64",
     metadata: {
       id: opts.id,
@@ -926,11 +1013,14 @@ function uint64(opts = {}) {
           return `"${input.toString()}"`;
         }
       }
-    }
+    },
+    "~standard": createStandardSchemaProperty(isType, parse)
   };
+  hideInvalidProperties(result);
+  return result;
 }
 function validateNumber(input) {
-  return typeof input === "number" || !Number.isNaN(input);
+  return typeof input === "number";
 }
 function validateInt(input, minVal, maxValue) {
   return Number.isInteger(input) && input >= minVal && input <= maxValue;
@@ -947,7 +1037,7 @@ function parseNumber(input, options) {
         schemaPath: `${options.schemaPath}/type`,
         message: `Error at ${options.instancePath}. Invalid number.`
       });
-      return void 0;
+      return undefined;
     }
     return result;
   }
@@ -959,10 +1049,41 @@ function parseNumber(input, options) {
     schemaPath: `${options.schemaPath}/type`,
     message: `Error at ${options.instancePath}. Invalid number.`
   });
-  return void 0;
+  return undefined;
 }
 function numberScalarType(type, opts, numTypeMatcher) {
-  return {
+  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,
@@ -970,62 +1091,36 @@ function numberScalarType(type, opts, numTypeMatcher) {
       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;
-        },
+        validate,
+        parse,
         serialize: serializeNumber,
         coerce(input, options) {
-          const result = coerceNumber(input, options);
-          if (typeof result !== "number") {
+          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 void 0;
+            return undefined;
           }
-          const matchResult = numTypeMatcher(result);
+          const matchResult = numTypeMatcher(result2);
           if (matchResult.success) {
-            return result;
+            return result2;
           }
           options.errors.push({
             instancePath: options.instancePath,
             schemaPath: `${options.schemaPath}/type`,
             message: `Error at ${options.instancePath}. ${matchResult.message}`
           });
-          return void 0;
+          return undefined;
         }
       }
-    }
+    },
+    "~standard": createStandardSchemaProperty(validate, parse)
   };
+  hideInvalidProperties(result);
+  return result;
 }
 
 function object(propA, propB) {
@@ -1049,6 +1144,17 @@ function object(propA, propB) {
     }
     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: {
@@ -1057,14 +1163,7 @@ function object(propA, propB) {
       isDeprecated: options.isDeprecated,
       [SCHEMA_METADATA]: {
         output: {},
-        parse(input2, context) {
-          return parseObjectSchema(
-            schema,
-            input2,
-            context,
-            false
-          );
-        },
+        parse,
         coerce(input2, context) {
           return parseObjectSchema(
             schema,
@@ -1073,9 +1172,7 @@ function object(propA, propB) {
             true
           );
         },
-        validate(input2) {
-          return validateObjectSchema(schema, input2);
-        },
+        validate,
         serialize(input2, context) {
           return serializeObject(
             schema,
@@ -1084,8 +1181,10 @@ function object(propA, propB) {
           );
         }
       }
-    }
+    },
+    "~standard": createStandardSchemaProperty(validate, parse)
   };
+  hideInvalidProperties(result);
   return result;
 }
 function parseObjectSchema(schema, input, data, coerce = false) {
@@ -1100,7 +1199,7 @@ function parseObjectSchema(schema, input, data, coerce = false) {
         schemaPath: `${data.schemaPath}/properties`,
         message: `Error at ${data.instancePath}. Invalid JSON.`
       });
-      return void 0;
+      return undefined;
     }
   }
   if (!isObject(parsedInput)) {
@@ -1109,7 +1208,7 @@ function parseObjectSchema(schema, input, data, coerce = false) {
       schemaPath: `${data.schemaPath}/properties`,
       message: `Error at ${data.instancePath}. Expected object`
     });
-    return void 0;
+    return undefined;
   }
   const result = {};
   const optionalProps = schema.optionalProperties ?? {};
@@ -1128,7 +1227,7 @@ function parseObjectSchema(schema, input, data, coerce = false) {
     }
   }
   if (data.errors.length) {
-    return void 0;
+    return undefined;
   }
   if (data.discriminatorKey) {
     result[data.discriminatorKey] = data.discriminatorValue;
@@ -1153,7 +1252,7 @@ function parseObjectSchema(schema, input, data, coerce = false) {
   for (const key of optionalKeys) {
     const val = parsedInput[key];
     const prop = optionalProps[key];
-    if (val === void 0) {
+    if (val === undefined) {
       continue;
     }
     if (coerce) {
@@ -1173,7 +1272,7 @@ function parseObjectSchema(schema, input, data, coerce = false) {
     }
   }
   if (data.errors.length) {
-    return void 0;
+    return undefined;
   }
   return result;
 }
@@ -1181,17 +1280,28 @@ 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.strict) {
-      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 (prop) {
-      const isValid = prop.metadata[SCHEMA_METADATA].validate(input[key]);
-      if (!isValid) {
-        return false;
-      }
+  }
+  if (allowedKeys) {
+    for (const key of Object.keys(input)) {
+      if (!allowedKeys.includes(key)) return false;
     }
   }
   return true;
@@ -1223,7 +1333,13 @@ function pick(inputSchema, keys, options = {}) {
       }
     });
   }
-  return {
+  const parse = (input, context) => {
+    return parseObjectSchema(schema, input, context, false);
+  };
+  const validate = (input) => {
+    return validateObjectSchema(schema, input);
+  };
+  const result = {
     ...schema,
     metadata: {
       id: options.id,
@@ -1231,14 +1347,7 @@ function pick(inputSchema, keys, options = {}) {
       isDeprecated: options.isDeprecated,
       [SCHEMA_METADATA]: {
         output: {},
-        parse: (input, context) => {
-          return parseObjectSchema(
-            schema,
-            input,
-            context,
-            true
-          );
-        },
+        parse,
         coerce(input, context) {
           return parseObjectSchema(
             schema,
@@ -1247,15 +1356,16 @@ function pick(inputSchema, keys, options = {}) {
             false
           );
         },
-        validate(input) {
-          return validateObjectSchema(schema, input);
-        },
+        validate,
         serialize(input, context) {
           return serializeObject(schema, input, context);
         }
       }
-    }
+    },
+    "~standard": createStandardSchemaProperty(validate, parse)
   };
+  hideInvalidProperties(result);
+  return result;
 }
 function omit(inputSchema, keys, options = {}) {
   const schema = {
@@ -1285,7 +1395,9 @@ function omit(inputSchema, keys, options = {}) {
       }
     });
   }
-  return {
+  const validate = (input) => validateObjectSchema(schema, input);
+  const parse = (input, context) => parseObjectSchema(schema, input, context, false);
+  const result = {
     ...schema,
     metadata: {
       id: options.id,
@@ -1293,12 +1405,8 @@ function omit(inputSchema, keys, options = {}) {
       isDeprecated: options.isDeprecated,
       [SCHEMA_METADATA]: {
         output: {},
-        validate(input) {
-          return validateObjectSchema(schema, input);
-        },
-        parse(input, data) {
-          return parseObjectSchema(schema, input, data, false);
-        },
+        validate,
+        parse,
         serialize(input, context) {
           return serializeObject(schema, input, context);
         },
@@ -1311,8 +1419,11 @@ function omit(inputSchema, keys, options = {}) {
           );
         }
       }
-    }
+    },
+    "~standard": createStandardSchemaProperty(validate, parse)
   };
+  hideInvalidProperties(result);
+  return result;
 }
 function serializeObject(schema, input, data) {
   const strParts = [];
@@ -1409,23 +1520,20 @@ function partial(schema, options = {}) {
       }
     }
   }
+  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(input) {
-        return validateObjectSchema(newSchema, input);
-      },
-      parse(input, context) {
-        return parseObjectSchema(
-          newSchema,
-          input,
-          context,
-          false
-        );
-      },
+      validate,
+      parse,
       coerce(input, context) {
         return parseObjectSchema(
           newSchema,
@@ -1440,11 +1548,16 @@ function partial(schema, options = {}) {
     }
   };
   newSchema.metadata = meta;
+  newSchema["~standard"] = createStandardSchemaProperty(
+    validate,
+    parse
+  );
+  hideInvalidProperties(newSchema);
   return newSchema;
 }
 
 function string(opts = {}) {
-  return {
+  const result = {
     type: "string",
     metadata: {
       id: opts.id,
@@ -1468,8 +1581,11 @@ function string(opts = {}) {
           return JSON.stringify(input);
         }
       }
-    }
+    },
+    "~standard": createStandardSchemaProperty(validate$1, parse$2)
   };
+  hideInvalidProperties(result);
+  return result;
 }
 function serializeString(input) {
   if (input.length < 42) {
@@ -1492,7 +1608,7 @@ function parse$2(input, context) {
     schemaPath: `${context.schemaPath}/type`,
     message: `Error at ${context.instancePath}. Expected 'string' got ${typeof input}.`
   });
-  return void 0;
+  return undefined;
 }
 function coerce$1(input, context) {
   return parse$2(input, context);
@@ -1527,7 +1643,23 @@ function serializeSmallString(input) {
 }
 
 function record(schema, opts = {}) {
-  return {
+  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,
@@ -1535,35 +1667,21 @@ function record(schema, opts = {}) {
       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, context) {
-          return parse$1(schema, input, context, false);
-        },
+        validate: validateFn,
+        parse: parseFn,
         coerce(input, data) {
           return parse$1(schema, input, data, true);
         },
         serialize(input, context) {
-          let result = "{";
+          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) result += ",";
-            result += serializeString(key);
-            result += ":";
-            result += schema.metadata[SCHEMA_METADATA].serialize(
+            if (i > 0) result2 += ",";
+            result2 += serializeString(key);
+            result2 += ":";
+            result2 += schema.metadata[SCHEMA_METADATA].serialize(
               val,
               {
                 instancePath: `${context.instancePath}/${key}`,
@@ -1572,12 +1690,15 @@ function record(schema, opts = {}) {
               }
             );
           }
-          result += "}";
-          return result;
+          result2 += "}";
+          return result2;
         }
       }
-    }
+    },
+    "~standard": createStandardSchemaProperty(validateFn, parseFn)
   };
+  hideInvalidProperties(result);
+  return result;
 }
 function parse$1(schema, input, data, coerce = false) {
   let parsedInput = input;
@@ -1590,7 +1711,7 @@ function parse$1(schema, input, data, coerce = false) {
       schemaPath: `${data.schemaPath}/values`,
       message: `Error at ${data.instancePath} Expected object`
     });
-    return void 0;
+    return undefined;
   }
   const result = {};
   for (const key of Object.keys(parsedInput)) {
@@ -1610,7 +1731,7 @@ function parse$1(schema, input, data, coerce = false) {
     }
   }
   if (data.errors.length) {
-    return void 0;
+    return undefined;
   }
   return result;
 }
@@ -1628,36 +1749,43 @@ function recursive(propA, propB) {
     );
   }
   const id = options.id ?? `TypeRef${recursiveTypeCount}`;
-  const mainSchema = callback({
-    ref: id,
-    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 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;
@@ -1671,7 +1799,7 @@ function recursive(propA, propB) {
 }
 
 function timestamp(opts = {}) {
-  return {
+  const result = {
     type: "timestamp",
     metadata: {
       id: opts.id,
@@ -1684,8 +1812,11 @@ function timestamp(opts = {}) {
         coerce,
         serialize
       }
-    }
+    },
+    "~standard": createStandardSchemaProperty(validate, parse)
   };
+  hideInvalidProperties(result);
+  return result;
 }
 function validate(input) {
   return typeof input === "object" && input instanceof Date;
@@ -1702,7 +1833,7 @@ function parse(input, data) {
         instancePath: data.instancePath,
         schemaPath: `${data.schemaPath}/type`
       });
-      return void 0;
+      return undefined;
     }
     return new Date(result);
   }
@@ -1711,7 +1842,7 @@ function parse(input, data) {
     instancePath: data.instancePath,
     schemaPath: `${data.schemaPath}/type`
   });
-  return void 0;
+  return undefined;
 }
 function coerce(input, options) {
   if (typeof input === "number") {
@@ -1726,4 +1857,4 @@ function serialize(input, data) {
   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, SCHEMA_METADATA as a2, int64Min as a3, int64Max as a4, uint64Min as a5, uint64Max as a6, parseObjectSchema as a7, validateObjectSchema as a8, serializeObject as a9, serializeString as aa, STR_ESCAPE as ab, serializeSmallString as ac, sanitizeJson as ad, isValidationError as ae, isASchema as af, NumberTypeValues as ag, isObject as ah, 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 };
+export { uint32 as $, discriminator as A, enumerator as B, extend as C, float32 as D, float64 as E, int16 as F, int32 as G, int64 as H, int8 as I, nullable as J, number as K, object as L, omit as M, optional as N, parse$4 as O, partial as P, pick as Q, record as R, recursive as S, safeCoerce as T, safeParse as U, ValidationError as V, serialize$1 as W, string as X, stringEnum as Y, timestamp as Z, uint16 as _, uint8Min as a, uint64 as a0, uint8 as a1, validate$3 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, serializeString as ab, STR_ESCAPE as ac, serializeSmallString as ad, sanitizeJson as ae, isValidationError as af, isASchema as ag, NumberTypeValues as ah, isObject as ai, hideInvalidProperties as aj, 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, createStandardSchemaProperty as t, uint8Max as u, any as v, array as w, boolean as x, clone as y, coerce$2 as z };