@arrirpc/schema 0.70.1 → 0.71.1

package/dist/shared/{schema.TlNJgMz1.cjs → schema.COiEWm_0.cjs}

@@ -1,6 +1,7 @@
 'use strict';
 
 const typeDefs = require('@arrirpc/type-defs');
+require('scule');
 
 const int8Min = -128;
 const int8Max = 127;
@@ -69,24 +70,78 @@ function isARefSchema(input) {
   return isASchema(input) && typeDefs.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 {
@@ -97,17 +152,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,
@@ -115,15 +179,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++) {
@@ -139,8 +199,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)) {
@@ -165,7 +228,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)) {
@@ -174,7 +237,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++) {
@@ -202,13 +265,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,
@@ -240,11 +303,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";
@@ -265,14 +331,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}`;
@@ -403,7 +469,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: {
@@ -412,12 +484,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);
         },
@@ -430,18 +498,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)) {
@@ -471,7 +542,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({
@@ -479,7 +550,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];
@@ -491,7 +562,7 @@ function parse$3(discriminator2, mapping, input, data, coerce = false) {
         ", "
       )}]`
     });
-    return void 0;
+    return undefined;
   }
   const targetSchema = mapping[parsedInput[discriminator2]];
   if (!targetSchema) {
@@ -548,7 +619,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,
@@ -556,19 +640,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;
@@ -580,7 +652,7 @@ function enumerator(paramA, paramB) {
               ", "
             )}]`
           });
-          return void 0;
+          return undefined;
         },
         validate: isType,
         serialize(input, context) {
@@ -590,8 +662,11 @@ function enumerator(paramA, paramB) {
           return `"${input}"`;
         }
       }
-    }
+    },
+    "~standard": createStandardSchemaProperty(isType, parse)
   };
+  hideInvalidProperties(result);
+  return result;
 }
 
 function nullable(schema, opts = {}) {
@@ -601,7 +676,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: {
@@ -612,15 +696,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;
@@ -642,39 +718,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);
         },
@@ -685,8 +764,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 = {
@@ -698,8 +780,10 @@ function clone(input, opts = {}) {
       [SCHEMA_METADATA]: {
         ...input.metadata[SCHEMA_METADATA]
       }
-    }
+    },
+    "~standard": input["~standard"]
   };
+  hideInvalidProperties(schema);
   return schema;
 }
 
@@ -715,7 +799,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);
   }
@@ -840,7 +924,7 @@ function int64(opts = {}) {
           schemaPath: `${data.schemaPath}/type`,
           instancePath: data.instancePath
         });
-        return void 0;
+        return undefined;
       }
     }
     if (isType(input)) {
@@ -851,9 +935,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,
@@ -871,8 +955,11 @@ function int64(opts = {}) {
           return `"${input.toString()}"`;
         }
       }
-    }
+    },
+    "~standard": createStandardSchemaProperty(isType, parse)
   };
+  hideInvalidProperties(result);
+  return result;
 }
 function uint64(opts = {}) {
   function isType(input) {
@@ -897,7 +984,7 @@ function uint64(opts = {}) {
           schemaPath: `${data.schemaPath}/type`,
           instancePath: data.instancePath
         });
-        return void 0;
+        return undefined;
       }
     }
     if (isType(input)) {
@@ -908,9 +995,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,
@@ -928,11 +1015,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;
@@ -949,7 +1039,7 @@ function parseNumber(input, options) {
         schemaPath: `${options.schemaPath}/type`,
         message: `Error at ${options.instancePath}. Invalid number.`
       });
-      return void 0;
+      return undefined;
     }
     return result;
   }
@@ -961,10 +1051,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,
@@ -972,62 +1093,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) {
@@ -1051,6 +1146,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: {
@@ -1059,14 +1165,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,
@@ -1075,9 +1174,7 @@ function object(propA, propB) {
             true
           );
         },
-        validate(input2) {
-          return validateObjectSchema(schema, input2);
-        },
+        validate,
         serialize(input2, context) {
           return serializeObject(
             schema,
@@ -1086,8 +1183,10 @@ function object(propA, propB) {
           );
         }
       }
-    }
+    },
+    "~standard": createStandardSchemaProperty(validate, parse)
   };
+  hideInvalidProperties(result);
   return result;
 }
 function parseObjectSchema(schema, input, data, coerce = false) {
@@ -1102,7 +1201,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)) {
@@ -1111,7 +1210,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 ?? {};
@@ -1130,7 +1229,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;
@@ -1155,7 +1254,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) {
@@ -1175,7 +1274,7 @@ function parseObjectSchema(schema, input, data, coerce = false) {
     }
   }
   if (data.errors.length) {
-    return void 0;
+    return undefined;
   }
   return result;
 }
@@ -1183,17 +1282,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;
@@ -1225,7 +1335,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,
@@ -1233,14 +1349,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,
@@ -1249,15 +1358,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 = {
@@ -1287,7 +1397,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,
@@ -1295,12 +1407,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);
         },
@@ -1313,8 +1421,11 @@ function omit(inputSchema, keys, options = {}) {
           );
         }
       }
-    }
+    },
+    "~standard": createStandardSchemaProperty(validate, parse)
   };
+  hideInvalidProperties(result);
+  return result;
 }
 function serializeObject(schema, input, data) {
   const strParts = [];
@@ -1411,23 +1522,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,
@@ -1442,11 +1550,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,
@@ -1470,8 +1583,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) {
@@ -1494,7 +1610,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);
@@ -1529,7 +1645,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,
@@ -1537,35 +1669,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}`,
@@ -1574,12 +1692,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;
@@ -1592,7 +1713,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)) {
@@ -1612,7 +1733,7 @@ function parse$1(schema, input, data, coerce = false) {
     }
   }
   if (data.errors.length) {
-    return void 0;
+    return undefined;
   }
   return result;
 }
@@ -1630,36 +1751,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;
@@ -1673,7 +1801,7 @@ function recursive(propA, propB) {
 }
 
 function timestamp(opts = {}) {
-  return {
+  const result = {
     type: "timestamp",
     metadata: {
       id: opts.id,
@@ -1686,8 +1814,11 @@ function timestamp(opts = {}) {
         coerce,
         serialize
       }
-    }
+    },
+    "~standard": createStandardSchemaProperty(validate, parse)
   };
+  hideInvalidProperties(result);
+  return result;
 }
 function validate(input) {
   return typeof input === "object" && input instanceof Date;
@@ -1704,7 +1835,7 @@ function parse(input, data) {
         instancePath: data.instancePath,
         schemaPath: `${data.schemaPath}/type`
       });
-      return void 0;
+      return undefined;
     }
     return new Date(result);
   }
@@ -1713,7 +1844,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") {
@@ -1737,12 +1868,14 @@ 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;