@arrirpc/schema 0.70.1 → 0.71.0

package/README.md

@@ -2,6 +2,8 @@
 
 A type builder and validation library for [Arri Type Definitions](/specifications/arri_type_definition.md). A lot of inspiration was taken from both [Typebox](https://github.com/sinclairzx81/typebox) and [Zod](https://github.com/colinhacks/zod) when designing this library.
 
+This library also supports [standard-schema](https://github.com/standard-schema/standard-schema) meaning it can be used with any third-party library that accepts standard schema.
+
 ## Project Philosophy
 
 The goals of this project are as follows:
@@ -66,7 +68,7 @@ pnpm install @arrirpc/schema
 ## Basic Example
 
 ```ts
-import { a } from "@arrirpc/schema";
+import { a } from '@arrirpc/schema';
 
 const User = a.object({
     id: a.string(),
@@ -81,12 +83,12 @@ a.parse(User, `{"id": "1", "name": "John Doe"}`);
 a.parse(User, `{"id": "1", "name": null}`);
 
 // returns true
-a.validate(User, { id: "1", name: "John Doe" });
+a.validate(User, { id: '1', name: 'John Doe' });
 // returns false
-a.validate(User, { id: "1", name: null });
+a.validate(User, { id: '1', name: null });
 
 // outputs valid json
-a.serialize(User, { id: "1", name: "John Doe" });
+a.serialize(User, { id: '1', name: 'John Doe' });
 ```
 
 ## Usage With @arrirpc/server
@@ -94,8 +96,8 @@ a.serialize(User, { id: "1", name: "John Doe" });
 See [here](/languages/ts/ts-server/README.md) for full details.
 
 ```ts
-import { a } from "@arrirpc/schema";
-import { defineRpc } from "@arrirpc/server";
+import { a } from '@arrirpc/schema';
+import { defineRpc } from '@arrirpc/server';
 
 export default defineRpc({
     params: a.object({
@@ -141,11 +143,11 @@ Enum schemas allow you to specify a predefine list of accepted strings
 **Usage**
 
 ```ts
-const Status = a.enumerator(["ACTIVE", "INACTIVE", "UNKNOWN"]);
+const Status = a.enumerator(['ACTIVE', 'INACTIVE', 'UNKNOWN']);
 type Status = a.infer<typeof Status>; // "ACTIVE" | "INACTIVE" | "UNKNOWN";
 
-a.validate(Status, "BLAH"); // false
-a.validate(Status, "ACTIVE"); // true
+a.validate(Status, 'BLAH'); // false
+a.validate(Status, 'ACTIVE'); // true
 ```
 
 **Outputted JTD**
@@ -165,7 +167,7 @@ const MyList = a.array(a.string());
 type MyList = a.infer<typeof MyList>; // string[];
 
 a.validate(MyList, [1, 2]); // false
-a.validate(MyList, ["hello", "world"]); // true
+a.validate(MyList, ['hello', 'world']); // true
 ```
 
 **Outputted JTD**
@@ -191,12 +193,12 @@ const User = a.object({
 type User = a.infer<typeof User>; // { id: string; email: string; created: Date; }
 
 a.validate({
-    id: "1",
-    email: "johndoe@example.com",
+    id: '1',
+    email: 'johndoe@example.com',
     created: new Date(),
 }); // true
 a.validate({
-    id: "1",
+    id: '1',
     email: null,
     created: new Date(),
 }); // false
@@ -237,10 +239,10 @@ const UserStrict = a.object(
 );
 
 a.parse(UserStrict, {
-    id: "1",
-    name: "johndoe",
+    id: '1',
+    name: 'johndoe',
     created: new Date(),
-    bio: "my name is joe",
+    bio: 'my name is joe',
 }); // fails parsing because of the additional field "bio"
 ```
 
@@ -276,7 +278,7 @@ a.validate(R, {
     world: false,
 }); // true;
 a.validate(R, {
-    hello: "world",
+    hello: 'world',
 }); // false;
 ```
 
@@ -295,7 +297,7 @@ a.validate(R, {
 **Usage**
 
 ```ts
-const Shape = a.discriminator("type", {
+const Shape = a.discriminator('type', {
     RECTANGLE: a.object({
         width: a.float32(),
         height: a.float32(),
@@ -307,20 +309,20 @@ const Shape = a.discriminator("type", {
 type Shape = a.infer<typeof Shape>; // { type: "RECTANGLE"; width: number; height: number; } | { type: "CIRCLE"; radius: number; }
 
 // Infer specific sub types of the union
-type ShapeTypeRectangle = a.inferSubType<Shape, "type", "RECTANGLE">; // { type "RECTANGLE"; width: number; height: number; };
-type ShapeTypeCircle = a.inferSubType<Shape, "type", "CIRCLE">; // { type "CIRCLE"; radius: number; }
+type ShapeTypeRectangle = a.inferSubType<Shape, 'type', 'RECTANGLE'>; // { type "RECTANGLE"; width: number; height: number; };
+type ShapeTypeCircle = a.inferSubType<Shape, 'type', 'CIRCLE'>; // { type "CIRCLE"; radius: number; }
 
 a.validate(Shape, {
-    type: "RECTANGLE",
+    type: 'RECTANGLE',
     width: 1,
     height: 1.5,
 }); // true
 a.validate(Shape, {
-    type: "CIRCLE",
+    type: 'CIRCLE',
     radius: 5,
 }); // true
 a.validate(Shape, {
-    type: "CIRCLE",
+    type: 'CIRCLE',
     width: 1,
     height: 1.5,
 }); // false
@@ -385,7 +387,7 @@ const BinaryTree = a.recursive<BinaryTree>(
             right: a.nullable(self),
         }),
     {
-        id: "BinaryTree",
+        id: 'BinaryTree',
     },
 );
 
@@ -506,7 +508,7 @@ const A = a.object(
         a: a.string(),
         b: a.float32(),
     },
-    { id: "A" },
+    { id: 'A' },
 );
 console.log(A.metadata.id); // "A"
 
@@ -545,7 +547,7 @@ const A = a.object({
 });
 // { a: string; b: number; }
 
-const B = a.omit(A, ["a"]);
+const B = a.omit(A, ['a']);
 // { b: number; }
 ```
 
@@ -561,7 +563,7 @@ const A = a.object({
 });
 // { a: string; b: number; c: Date; }
 
-const B = a.pick(A, ["a", "c"]);
+const B = a.pick(A, ['a', 'c']);
 // { a: string; c: Date; }
 ```
 
@@ -593,7 +595,7 @@ const User = a.object({
     name: a.string(),
 });
 a.validate(User, true); // false
-a.validate(User, { id: "1", name: "john doe" }); // true
+a.validate(User, { id: '1', name: 'john doe' }); // true
 
 if (a.validate(User, someInput)) {
     console.log(someInput.id); // intellisense works here
@@ -644,9 +646,9 @@ const A = a.object({
 });
 
 a.coerce(A, {
-    a: "1",
-    b: "true",
-    c: "500.24",
+    a: '1',
+    b: 'true',
+    c: '500.24',
 });
 // { a: "1", b: true, c: 500.24 };
 ```
@@ -681,7 +683,7 @@ const User = a.object({
     name: a.string(),
 });
 
-a.serialize(User, { id: "1", name: "john doe" });
+a.serialize(User, { id: '1', name: 'john doe' });
 // {"id":"1","name":"john doe"}
 ```
 
@@ -697,7 +699,7 @@ const User = a.object({
     date: a.timestamp(),
 });
 
-a.errors(User, { id: 1, date: "hello world" });
+a.errors(User, { id: 1, date: 'hello world' });
 /**
  * [
  *   {
@@ -730,7 +732,7 @@ const $$User = a.compile(User);
 
 $$User.validate(someInput);
 $$User.parse(someJson);
-$$User.serialize({ id: "1", email: null, created: new Date() });
+$$User.serialize({ id: '1', email: null, created: new Date() });
 ```
 
 In most cases, the compiled validators will be much faster than the standard utilities. However there is some overhead with compiling the schemas so ideally each validator would be compiled once. Additionally the resulting methods make use of eval so they can only be used in an environment that you control such as a backend server. They WILL NOT work in a browser environment.
@@ -764,8 +766,8 @@ const BookSchema = a.object(
         publishDate: a.timestamp(),
     },
     {
-        id: "Book",
-        description: "This is a book",
+        id: 'Book',
+        description: 'This is a book',
     },
 );
 ```
@@ -831,14 +833,14 @@ Because IDs are really important for producing concise type names. Arri validate
 
 ```ts
 // ID will be set to "Book"
-const BookSchema = a.object("Book", {
+const BookSchema = a.object('Book', {
     title: a.string(),
     author: a.string(),
     publishDate: a.timestamp(),
 });
 
 // ID will be set to "Message"
-const MessageSchema = a.discriminator("Message", "type", {
+const MessageSchema = a.discriminator('Message', 'type', {
     TEXT: a.object({
         userId: a.string(),
         content: a.string(),
@@ -850,7 +852,7 @@ const MessageSchema = a.discriminator("Message", "type", {
 });
 
 // ID will be set to "BTree"
-const BinaryTreeSchema = a.recursive("BTree", (self) =>
+const BinaryTreeSchema = a.recursive('BTree', (self) =>
     a.object({
         left: a.nullable(self),
         right: a.nullable(self),

package/dist/index.cjs

@@ -2,7 +2,7 @@
 
 const typeDefs = require('@arrirpc/type-defs');
 const scule = require('scule');
-const timestamp = require('./shared/schema.TlNJgMz1.cjs');
+const timestamp = require('./shared/schema.BcsXcrqv.cjs');
 
 function createParsingTemplate(input, schema) {
   const fallbackTemplate = `
@@ -1367,33 +1367,31 @@ function compile(schema) {
   const parseFn = parser.fn;
   const serializer = getCompiledSerializer(schema);
   const serializeFn = serializer.fn;
-  const validate = new Function(
-    "input",
-    validateCode
-  );
-  return {
-    validate,
-    parse(input) {
-      try {
-        return parseFn(input);
-      } catch (err) {
-        const errors = timestamp.errors(schema, input);
-        let errorMessage = err instanceof Error ? err.message : "";
-        if (errors.length) {
-          errorMessage = errors[0].message ?? `Parsing error at ${errors[0].instancePath}`;
-        }
-        throw new timestamp.ValidationError({
-          message: errorMessage,
-          errors
-        });
+  const validate = new Function("input", validateCode);
+  const parse = (input) => {
+    try {
+      return parseFn(input);
+    } catch (err) {
+      const errors = timestamp.errors(schema, input);
+      let errorMessage = err instanceof Error ? err.message : "";
+      if (errors.length) {
+        errorMessage = errors[0].message ?? `Parsing error at ${errors[0].instancePath}`;
       }
-    },
+      throw new timestamp.ValidationError({
+        message: errorMessage,
+        errors
+      });
+    }
+  };
+  const result = {
+    validate,
+    parse,
     safeParse(input) {
       try {
-        const result = parseFn(input);
+        const result2 = parseFn(input);
         return {
           success: true,
-          value: result
+          value: result2
         };
       } catch (err) {
         const errors = timestamp.errors(schema, input);
@@ -1426,8 +1424,10 @@ function compile(schema) {
       validate: validateCode,
       parse: parser.code,
       serialize: serializer.code
-    }
+    },
+    "~standard": timestamp.createStandardSchemaProperty(validate, parse)
   };
+  return result;
 }
 function getCompiledParser(input, schema) {
   const code = createParsingTemplate(input, schema);
@@ -2134,7 +2134,7 @@ function isAdaptedSchema(input) {
   return input.metadata[timestamp.SCHEMA_METADATA]._isAdapted === true;
 }
 function validatorFromAdaptedSchema(schema) {
-  return {
+  const result = {
     compiledCode: {
       parse: "",
       serialize: "",
@@ -2156,13 +2156,13 @@ function validatorFromAdaptedSchema(schema) {
         errors: []
       };
       try {
-        const result = schema.metadata[timestamp.SCHEMA_METADATA].parse(
+        const result2 = schema.metadata[timestamp.SCHEMA_METADATA].parse(
           input,
           context
         );
         return {
           success: true,
-          value: result
+          value: result2
         };
       } catch (err) {
         if (err instanceof timestamp.ValidationError) {
@@ -2187,8 +2187,13 @@ function validatorFromAdaptedSchema(schema) {
         errors: []
       };
       return schema.metadata[timestamp.SCHEMA_METADATA].serialize(input, context);
-    }
+    },
+    "~standard": timestamp.createStandardSchemaProperty(
+      schema.metadata[timestamp.SCHEMA_METADATA].validate,
+      schema.metadata[timestamp.SCHEMA_METADATA].parse
+    )
   };
+  return result;
 }
 
 exports.NumberTypeValues = timestamp.NumberTypeValues;
@@ -2200,12 +2205,14 @@ exports.array = timestamp.array;
 exports.boolean = timestamp.boolean;
 exports.clone = timestamp.clone;
 exports.coerce = timestamp.coerce;
+exports.createStandardSchemaProperty = timestamp.createStandardSchemaProperty;
 exports.discriminator = timestamp.discriminator;
 exports.enumerator = timestamp.enumerator;
 exports.errors = timestamp.errors;
 exports.extend = timestamp.extend;
 exports.float32 = timestamp.float32;
 exports.float64 = timestamp.float64;
+exports.hideInvalidProperties = timestamp.hideInvalidProperties;
 exports.int16 = timestamp.int16;
 exports.int16Max = timestamp.int16Max;
 exports.int16Min = timestamp.int16Min;

package/dist/index.d.cts

@@ -1,5 +1,6 @@
-import { A as ASchema, I as InferType, S as SafeResult, a as ASchemaOptions, b as AArraySchema, c as AScalarSchema, d as AObjectSchema, e as ADiscriminatorSchema, R as ResolveObject, f as AStringEnumSchema, g as AObjectSchemaOptions, h as InferObjectOutput, V as ValidationContext, i as ARecordSchema, j as ARefSchema, k as coerce, l as errors, m as InferSubType, p as parse, s as safeCoerce, n as safeParse, o as serialize, v as validate } from './shared/schema.C-0ZU_OQ.cjs';
-export { K as InferObjectRawType, M as MaybeNullable, D as NumberType, N as NumberTypeValues, P as PartialBy, B as Resolve, w as SCHEMA_METADATA, y as SchemaMetadata, x as SchemaValidator, t as ValidationError, r as ValueError, E as isAAraySchema, G as isADiscriminatorSchema, J as isAObjectSchema, H as isARecordSchema, O as isARefSchema, C as isAScalarSchema, z as isASchema, F as isAStringEnumSchema, L as isObject, u as isValidationError, q as sanitizeJson } from './shared/schema.C-0ZU_OQ.cjs';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { A as ASchema, I as InferType, S as SafeResult, a as ASchemaOptions, b as AArraySchema, c as AScalarSchema, d as AObjectSchema, e as ADiscriminatorSchema, R as ResolveObject, f as AStringEnumSchema, g as AObjectSchemaOptions, h as InferObjectOutput, V as ValidationContext, i as ARecordSchema, j as ARefSchema, k as coerce, l as errors, m as InferSubType, p as parse, s as safeCoerce, n as safeParse, o as serialize, v as validate } from './shared/schema.DLX0nTwB.cjs';
+export { K as InferObjectRawType, M as MaybeNullable, D as NumberType, N as NumberTypeValues, P as PartialBy, B as Resolve, w as SCHEMA_METADATA, y as SchemaMetadata, x as SchemaValidator, t as ValidationError, r as ValueError, E as isAAraySchema, G as isADiscriminatorSchema, J as isAObjectSchema, H as isARecordSchema, O as isARefSchema, C as isAScalarSchema, z as isASchema, F as isAStringEnumSchema, L as isObject, u as isValidationError, q as sanitizeJson } from './shared/schema.DLX0nTwB.cjs';
 import { Schema } from '@arrirpc/type-defs';
 
 declare function createParsingTemplate(input: string, schema: Schema): string;
@@ -8,7 +9,7 @@ declare function createSerializationV2Template(inputName: string, schema: Schema
 
 declare function createValidationTemplate(inputName: string, schema: ASchema<any>): string;
 
-interface CompiledValidator<TSchema extends ASchema<any>> {
+interface CompiledValidator<TSchema extends ASchema<any>> extends StandardSchemaV1<InferType<TSchema>> {
     /**
      * Determine if a type matches a schema. This is a type guard.
      */
@@ -35,7 +36,7 @@ interface CompiledValidator<TSchema extends ASchema<any>> {
  * Create compiled versions of the `parse()`, `validate()`, and `serialize()` functions
  */
 declare function compile<TSchema extends ASchema<any>>(schema: TSchema): CompiledValidator<TSchema>;
-type CompiledParser<TSchema extends ASchema<any>> = CompiledValidator<TSchema>["parse"];
+type CompiledParser<TSchema extends ASchema<any>> = CompiledValidator<TSchema>['parse'];
 declare function getCompiledParser<TSchema extends ASchema<any>>(input: string, schema: TSchema): {
     fn: CompiledParser<TSchema>;
     code: string;
@@ -58,7 +59,7 @@ declare function array<TInnerSchema extends ASchema<any> = any>(schema: TInnerSc
  * a.validate(Schema, true) // true;
  * a.validate(Schema, false) // true;
  */
-declare function boolean(opts?: ASchemaOptions): AScalarSchema<"boolean", boolean>;
+declare function boolean(opts?: ASchemaOptions): AScalarSchema<'boolean', boolean>;
 
 /**
  * Create a discriminated union / tagged union
@@ -173,8 +174,8 @@ declare function int16(opts?: ASchemaOptions): AScalarSchema<"int16", number>;
 declare function uint16(opts?: ASchemaOptions): AScalarSchema<"uint16", number>;
 declare function int32(opts?: ASchemaOptions): AScalarSchema<"int32", number>;
 declare function uint32(opts?: ASchemaOptions): AScalarSchema<"uint32", number>;
-declare function int64(opts?: ASchemaOptions): AScalarSchema<"int64", bigint>;
-declare function uint64(opts?: ASchemaOptions): AScalarSchema<"uint64", bigint>;
+declare function int64(opts?: ASchemaOptions): AScalarSchema<'int64', bigint>;
+declare function uint64(opts?: ASchemaOptions): AScalarSchema<'uint64', bigint>;
 
 /**
  * Create an object schema
@@ -285,7 +286,7 @@ declare function recursive<T = any>(id: string, callback: RecursiveCallback<T>):
  * a.validate(StringSchema, "hello world") // true
  * a.validate(StringSchema, 10) // false
  */
-declare function string(opts?: ASchemaOptions): AScalarSchema<"string", string>;
+declare function string(opts?: ASchemaOptions): AScalarSchema<'string', string>;
 declare function serializeString(input: string): string;
 declare const STR_ESCAPE: RegExp;
 declare function serializeSmallString(input: string): string;
@@ -297,7 +298,7 @@ declare function serializeSmallString(input: string): string;
  * const Schema = a.timestamp();
  * a.validate(Schema, new Date()) // true
  */
-declare function timestamp(opts?: ASchemaOptions): AScalarSchema<"timestamp", Date>;
+declare function timestamp(opts?: ASchemaOptions): AScalarSchema<'timestamp', Date>;
 
 declare const _namespace_any: typeof any;
 declare const _namespace_array: typeof array;
@@ -361,4 +362,10 @@ declare const int64Max: bigint;
 declare const uint64Min: bigint;
 declare const uint64Max: bigint;
 
-export { AArraySchema, ADiscriminatorSchema, AObjectSchema, AObjectSchemaOptions, ARecordSchema, ARefSchema, AScalarSchema, ASchema, ASchemaOptions, AStringEnumSchema, type CompiledValidator, InferObjectOutput, InferSubType, InferType, ResolveObject, STR_ESCAPE, SafeResult, type ValidationAdapter, ValidationContext, _namespace as a, any, array, boolean, clone, coerce, compile, discriminator, enumerator, errors, extend, float32, float64, getCompiledParser, getCompiledSerializer, createParsingTemplate as getSchemaParsingCode, createSerializationV2Template as getSchemaSerializationCode, createValidationTemplate as getSchemaValidationCode, int16, int16Max, int16Min, int32, int32Max, int32Min, int64, int64Max, int64Min, int8, int8Max, int8Min, isAdaptedSchema, nullable, number, object, omit, optional, parse, parseObjectSchema, partial, pick, record, recursive, safeCoerce, safeParse, serialize, serializeObject, serializeSmallString, serializeString, string, stringEnum, timestamp, uint16, uint16Max, uint16Min, uint32, uint32Max, uint32Min, uint64, uint64Max, uint64Min, uint8, uint8Max, uint8Min, validate, validateObjectSchema, validatorFromAdaptedSchema };
+declare function createStandardSchemaProperty<T>(validate: (input: unknown) => input is T, parse: (input: unknown, ctx: ValidationContext) => T | undefined): StandardSchemaV1<T>['~standard'];
+/**
+ * Ensure that non ATD compliant properties get hidden when serialized to JSON
+ */
+declare function hideInvalidProperties(schema: ASchema): void;
+
+export { AArraySchema, ADiscriminatorSchema, AObjectSchema, AObjectSchemaOptions, ARecordSchema, ARefSchema, AScalarSchema, ASchema, ASchemaOptions, AStringEnumSchema, type CompiledValidator, InferObjectOutput, InferSubType, InferType, ResolveObject, STR_ESCAPE, SafeResult, type ValidationAdapter, ValidationContext, _namespace as a, any, array, boolean, clone, coerce, compile, createStandardSchemaProperty, discriminator, enumerator, errors, extend, float32, float64, getCompiledParser, getCompiledSerializer, createParsingTemplate as getSchemaParsingCode, createSerializationV2Template as getSchemaSerializationCode, createValidationTemplate as getSchemaValidationCode, hideInvalidProperties, int16, int16Max, int16Min, int32, int32Max, int32Min, int64, int64Max, int64Min, int8, int8Max, int8Min, isAdaptedSchema, nullable, number, object, omit, optional, parse, parseObjectSchema, partial, pick, record, recursive, safeCoerce, safeParse, serialize, serializeObject, serializeSmallString, serializeString, string, stringEnum, timestamp, uint16, uint16Max, uint16Min, uint32, uint32Max, uint32Min, uint64, uint64Max, uint64Min, uint8, uint8Max, uint8Min, validate, validateObjectSchema, validatorFromAdaptedSchema };

package/dist/index.d.mts

@@ -1,5 +1,6 @@
-import { A as ASchema, I as InferType, S as SafeResult, a as ASchemaOptions, b as AArraySchema, c as AScalarSchema, d as AObjectSchema, e as ADiscriminatorSchema, R as ResolveObject, f as AStringEnumSchema, g as AObjectSchemaOptions, h as InferObjectOutput, V as ValidationContext, i as ARecordSchema, j as ARefSchema, k as coerce, l as errors, m as InferSubType, p as parse, s as safeCoerce, n as safeParse, o as serialize, v as validate } from './shared/schema.C-0ZU_OQ.mjs';
-export { K as InferObjectRawType, M as MaybeNullable, D as NumberType, N as NumberTypeValues, P as PartialBy, B as Resolve, w as SCHEMA_METADATA, y as SchemaMetadata, x as SchemaValidator, t as ValidationError, r as ValueError, E as isAAraySchema, G as isADiscriminatorSchema, J as isAObjectSchema, H as isARecordSchema, O as isARefSchema, C as isAScalarSchema, z as isASchema, F as isAStringEnumSchema, L as isObject, u as isValidationError, q as sanitizeJson } from './shared/schema.C-0ZU_OQ.mjs';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { A as ASchema, I as InferType, S as SafeResult, a as ASchemaOptions, b as AArraySchema, c as AScalarSchema, d as AObjectSchema, e as ADiscriminatorSchema, R as ResolveObject, f as AStringEnumSchema, g as AObjectSchemaOptions, h as InferObjectOutput, V as ValidationContext, i as ARecordSchema, j as ARefSchema, k as coerce, l as errors, m as InferSubType, p as parse, s as safeCoerce, n as safeParse, o as serialize, v as validate } from './shared/schema.DLX0nTwB.mjs';
+export { K as InferObjectRawType, M as MaybeNullable, D as NumberType, N as NumberTypeValues, P as PartialBy, B as Resolve, w as SCHEMA_METADATA, y as SchemaMetadata, x as SchemaValidator, t as ValidationError, r as ValueError, E as isAAraySchema, G as isADiscriminatorSchema, J as isAObjectSchema, H as isARecordSchema, O as isARefSchema, C as isAScalarSchema, z as isASchema, F as isAStringEnumSchema, L as isObject, u as isValidationError, q as sanitizeJson } from './shared/schema.DLX0nTwB.mjs';
 import { Schema } from '@arrirpc/type-defs';
 
 declare function createParsingTemplate(input: string, schema: Schema): string;
@@ -8,7 +9,7 @@ declare function createSerializationV2Template(inputName: string, schema: Schema
 
 declare function createValidationTemplate(inputName: string, schema: ASchema<any>): string;
 
-interface CompiledValidator<TSchema extends ASchema<any>> {
+interface CompiledValidator<TSchema extends ASchema<any>> extends StandardSchemaV1<InferType<TSchema>> {
     /**
      * Determine if a type matches a schema. This is a type guard.
      */
@@ -35,7 +36,7 @@ interface CompiledValidator<TSchema extends ASchema<any>> {
  * Create compiled versions of the `parse()`, `validate()`, and `serialize()` functions
  */
 declare function compile<TSchema extends ASchema<any>>(schema: TSchema): CompiledValidator<TSchema>;
-type CompiledParser<TSchema extends ASchema<any>> = CompiledValidator<TSchema>["parse"];
+type CompiledParser<TSchema extends ASchema<any>> = CompiledValidator<TSchema>['parse'];
 declare function getCompiledParser<TSchema extends ASchema<any>>(input: string, schema: TSchema): {
     fn: CompiledParser<TSchema>;
     code: string;
@@ -58,7 +59,7 @@ declare function array<TInnerSchema extends ASchema<any> = any>(schema: TInnerSc
  * a.validate(Schema, true) // true;
  * a.validate(Schema, false) // true;
  */
-declare function boolean(opts?: ASchemaOptions): AScalarSchema<"boolean", boolean>;
+declare function boolean(opts?: ASchemaOptions): AScalarSchema<'boolean', boolean>;
 
 /**
  * Create a discriminated union / tagged union
@@ -173,8 +174,8 @@ declare function int16(opts?: ASchemaOptions): AScalarSchema<"int16", number>;
 declare function uint16(opts?: ASchemaOptions): AScalarSchema<"uint16", number>;
 declare function int32(opts?: ASchemaOptions): AScalarSchema<"int32", number>;
 declare function uint32(opts?: ASchemaOptions): AScalarSchema<"uint32", number>;
-declare function int64(opts?: ASchemaOptions): AScalarSchema<"int64", bigint>;
-declare function uint64(opts?: ASchemaOptions): AScalarSchema<"uint64", bigint>;
+declare function int64(opts?: ASchemaOptions): AScalarSchema<'int64', bigint>;
+declare function uint64(opts?: ASchemaOptions): AScalarSchema<'uint64', bigint>;
 
 /**
  * Create an object schema
@@ -285,7 +286,7 @@ declare function recursive<T = any>(id: string, callback: RecursiveCallback<T>):
  * a.validate(StringSchema, "hello world") // true
  * a.validate(StringSchema, 10) // false
  */
-declare function string(opts?: ASchemaOptions): AScalarSchema<"string", string>;
+declare function string(opts?: ASchemaOptions): AScalarSchema<'string', string>;
 declare function serializeString(input: string): string;
 declare const STR_ESCAPE: RegExp;
 declare function serializeSmallString(input: string): string;
@@ -297,7 +298,7 @@ declare function serializeSmallString(input: string): string;
  * const Schema = a.timestamp();
  * a.validate(Schema, new Date()) // true
  */
-declare function timestamp(opts?: ASchemaOptions): AScalarSchema<"timestamp", Date>;
+declare function timestamp(opts?: ASchemaOptions): AScalarSchema<'timestamp', Date>;
 
 declare const _namespace_any: typeof any;
 declare const _namespace_array: typeof array;
@@ -361,4 +362,10 @@ declare const int64Max: bigint;
 declare const uint64Min: bigint;
 declare const uint64Max: bigint;
 
-export { AArraySchema, ADiscriminatorSchema, AObjectSchema, AObjectSchemaOptions, ARecordSchema, ARefSchema, AScalarSchema, ASchema, ASchemaOptions, AStringEnumSchema, type CompiledValidator, InferObjectOutput, InferSubType, InferType, ResolveObject, STR_ESCAPE, SafeResult, type ValidationAdapter, ValidationContext, _namespace as a, any, array, boolean, clone, coerce, compile, discriminator, enumerator, errors, extend, float32, float64, getCompiledParser, getCompiledSerializer, createParsingTemplate as getSchemaParsingCode, createSerializationV2Template as getSchemaSerializationCode, createValidationTemplate as getSchemaValidationCode, int16, int16Max, int16Min, int32, int32Max, int32Min, int64, int64Max, int64Min, int8, int8Max, int8Min, isAdaptedSchema, nullable, number, object, omit, optional, parse, parseObjectSchema, partial, pick, record, recursive, safeCoerce, safeParse, serialize, serializeObject, serializeSmallString, serializeString, string, stringEnum, timestamp, uint16, uint16Max, uint16Min, uint32, uint32Max, uint32Min, uint64, uint64Max, uint64Min, uint8, uint8Max, uint8Min, validate, validateObjectSchema, validatorFromAdaptedSchema };
+declare function createStandardSchemaProperty<T>(validate: (input: unknown) => input is T, parse: (input: unknown, ctx: ValidationContext) => T | undefined): StandardSchemaV1<T>['~standard'];
+/**
+ * Ensure that non ATD compliant properties get hidden when serialized to JSON
+ */
+declare function hideInvalidProperties(schema: ASchema): void;
+
+export { AArraySchema, ADiscriminatorSchema, AObjectSchema, AObjectSchemaOptions, ARecordSchema, ARefSchema, AScalarSchema, ASchema, ASchemaOptions, AStringEnumSchema, type CompiledValidator, InferObjectOutput, InferSubType, InferType, ResolveObject, STR_ESCAPE, SafeResult, type ValidationAdapter, ValidationContext, _namespace as a, any, array, boolean, clone, coerce, compile, createStandardSchemaProperty, discriminator, enumerator, errors, extend, float32, float64, getCompiledParser, getCompiledSerializer, createParsingTemplate as getSchemaParsingCode, createSerializationV2Template as getSchemaSerializationCode, createValidationTemplate as getSchemaValidationCode, hideInvalidProperties, int16, int16Max, int16Min, int32, int32Max, int32Min, int64, int64Max, int64Min, int8, int8Max, int8Min, isAdaptedSchema, nullable, number, object, omit, optional, parse, parseObjectSchema, partial, pick, record, recursive, safeCoerce, safeParse, serialize, serializeObject, serializeSmallString, serializeString, string, stringEnum, timestamp, uint16, uint16Max, uint16Min, uint32, uint32Max, uint32Min, uint64, uint64Max, uint64Min, uint8, uint8Max, uint8Min, validate, validateObjectSchema, validatorFromAdaptedSchema };

package/dist/index.d.ts

@@ -1,5 +1,6 @@
-import { A as ASchema, I as InferType, S as SafeResult, a as ASchemaOptions, b as AArraySchema, c as AScalarSchema, d as AObjectSchema, e as ADiscriminatorSchema, R as ResolveObject, f as AStringEnumSchema, g as AObjectSchemaOptions, h as InferObjectOutput, V as ValidationContext, i as ARecordSchema, j as ARefSchema, k as coerce, l as errors, m as InferSubType, p as parse, s as safeCoerce, n as safeParse, o as serialize, v as validate } from './shared/schema.C-0ZU_OQ.js';
-export { K as InferObjectRawType, M as MaybeNullable, D as NumberType, N as NumberTypeValues, P as PartialBy, B as Resolve, w as SCHEMA_METADATA, y as SchemaMetadata, x as SchemaValidator, t as ValidationError, r as ValueError, E as isAAraySchema, G as isADiscriminatorSchema, J as isAObjectSchema, H as isARecordSchema, O as isARefSchema, C as isAScalarSchema, z as isASchema, F as isAStringEnumSchema, L as isObject, u as isValidationError, q as sanitizeJson } from './shared/schema.C-0ZU_OQ.js';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { A as ASchema, I as InferType, S as SafeResult, a as ASchemaOptions, b as AArraySchema, c as AScalarSchema, d as AObjectSchema, e as ADiscriminatorSchema, R as ResolveObject, f as AStringEnumSchema, g as AObjectSchemaOptions, h as InferObjectOutput, V as ValidationContext, i as ARecordSchema, j as ARefSchema, k as coerce, l as errors, m as InferSubType, p as parse, s as safeCoerce, n as safeParse, o as serialize, v as validate } from './shared/schema.DLX0nTwB.js';
+export { K as InferObjectRawType, M as MaybeNullable, D as NumberType, N as NumberTypeValues, P as PartialBy, B as Resolve, w as SCHEMA_METADATA, y as SchemaMetadata, x as SchemaValidator, t as ValidationError, r as ValueError, E as isAAraySchema, G as isADiscriminatorSchema, J as isAObjectSchema, H as isARecordSchema, O as isARefSchema, C as isAScalarSchema, z as isASchema, F as isAStringEnumSchema, L as isObject, u as isValidationError, q as sanitizeJson } from './shared/schema.DLX0nTwB.js';
 import { Schema } from '@arrirpc/type-defs';
 
 declare function createParsingTemplate(input: string, schema: Schema): string;
@@ -8,7 +9,7 @@ declare function createSerializationV2Template(inputName: string, schema: Schema
 
 declare function createValidationTemplate(inputName: string, schema: ASchema<any>): string;
 
-interface CompiledValidator<TSchema extends ASchema<any>> {
+interface CompiledValidator<TSchema extends ASchema<any>> extends StandardSchemaV1<InferType<TSchema>> {
     /**
      * Determine if a type matches a schema. This is a type guard.
      */
@@ -35,7 +36,7 @@ interface CompiledValidator<TSchema extends ASchema<any>> {
  * Create compiled versions of the `parse()`, `validate()`, and `serialize()` functions
  */
 declare function compile<TSchema extends ASchema<any>>(schema: TSchema): CompiledValidator<TSchema>;
-type CompiledParser<TSchema extends ASchema<any>> = CompiledValidator<TSchema>["parse"];
+type CompiledParser<TSchema extends ASchema<any>> = CompiledValidator<TSchema>['parse'];
 declare function getCompiledParser<TSchema extends ASchema<any>>(input: string, schema: TSchema): {
     fn: CompiledParser<TSchema>;
     code: string;
@@ -58,7 +59,7 @@ declare function array<TInnerSchema extends ASchema<any> = any>(schema: TInnerSc
  * a.validate(Schema, true) // true;
  * a.validate(Schema, false) // true;
  */
-declare function boolean(opts?: ASchemaOptions): AScalarSchema<"boolean", boolean>;
+declare function boolean(opts?: ASchemaOptions): AScalarSchema<'boolean', boolean>;
 
 /**
  * Create a discriminated union / tagged union
@@ -173,8 +174,8 @@ declare function int16(opts?: ASchemaOptions): AScalarSchema<"int16", number>;
 declare function uint16(opts?: ASchemaOptions): AScalarSchema<"uint16", number>;
 declare function int32(opts?: ASchemaOptions): AScalarSchema<"int32", number>;
 declare function uint32(opts?: ASchemaOptions): AScalarSchema<"uint32", number>;
-declare function int64(opts?: ASchemaOptions): AScalarSchema<"int64", bigint>;
-declare function uint64(opts?: ASchemaOptions): AScalarSchema<"uint64", bigint>;
+declare function int64(opts?: ASchemaOptions): AScalarSchema<'int64', bigint>;
+declare function uint64(opts?: ASchemaOptions): AScalarSchema<'uint64', bigint>;
 
 /**
  * Create an object schema
@@ -285,7 +286,7 @@ declare function recursive<T = any>(id: string, callback: RecursiveCallback<T>):
  * a.validate(StringSchema, "hello world") // true
  * a.validate(StringSchema, 10) // false
  */
-declare function string(opts?: ASchemaOptions): AScalarSchema<"string", string>;
+declare function string(opts?: ASchemaOptions): AScalarSchema<'string', string>;
 declare function serializeString(input: string): string;
 declare const STR_ESCAPE: RegExp;
 declare function serializeSmallString(input: string): string;
@@ -297,7 +298,7 @@ declare function serializeSmallString(input: string): string;
  * const Schema = a.timestamp();
  * a.validate(Schema, new Date()) // true
  */
-declare function timestamp(opts?: ASchemaOptions): AScalarSchema<"timestamp", Date>;
+declare function timestamp(opts?: ASchemaOptions): AScalarSchema<'timestamp', Date>;
 
 declare const _namespace_any: typeof any;
 declare const _namespace_array: typeof array;
@@ -361,4 +362,10 @@ declare const int64Max: bigint;
 declare const uint64Min: bigint;
 declare const uint64Max: bigint;
 
-export { AArraySchema, ADiscriminatorSchema, AObjectSchema, AObjectSchemaOptions, ARecordSchema, ARefSchema, AScalarSchema, ASchema, ASchemaOptions, AStringEnumSchema, type CompiledValidator, InferObjectOutput, InferSubType, InferType, ResolveObject, STR_ESCAPE, SafeResult, type ValidationAdapter, ValidationContext, _namespace as a, any, array, boolean, clone, coerce, compile, discriminator, enumerator, errors, extend, float32, float64, getCompiledParser, getCompiledSerializer, createParsingTemplate as getSchemaParsingCode, createSerializationV2Template as getSchemaSerializationCode, createValidationTemplate as getSchemaValidationCode, int16, int16Max, int16Min, int32, int32Max, int32Min, int64, int64Max, int64Min, int8, int8Max, int8Min, isAdaptedSchema, nullable, number, object, omit, optional, parse, parseObjectSchema, partial, pick, record, recursive, safeCoerce, safeParse, serialize, serializeObject, serializeSmallString, serializeString, string, stringEnum, timestamp, uint16, uint16Max, uint16Min, uint32, uint32Max, uint32Min, uint64, uint64Max, uint64Min, uint8, uint8Max, uint8Min, validate, validateObjectSchema, validatorFromAdaptedSchema };
+declare function createStandardSchemaProperty<T>(validate: (input: unknown) => input is T, parse: (input: unknown, ctx: ValidationContext) => T | undefined): StandardSchemaV1<T>['~standard'];
+/**
+ * Ensure that non ATD compliant properties get hidden when serialized to JSON
+ */
+declare function hideInvalidProperties(schema: ASchema): void;
+
+export { AArraySchema, ADiscriminatorSchema, AObjectSchema, AObjectSchemaOptions, ARecordSchema, ARefSchema, AScalarSchema, ASchema, ASchemaOptions, AStringEnumSchema, type CompiledValidator, InferObjectOutput, InferSubType, InferType, ResolveObject, STR_ESCAPE, SafeResult, type ValidationAdapter, ValidationContext, _namespace as a, any, array, boolean, clone, coerce, compile, createStandardSchemaProperty, discriminator, enumerator, errors, extend, float32, float64, getCompiledParser, getCompiledSerializer, createParsingTemplate as getSchemaParsingCode, createSerializationV2Template as getSchemaSerializationCode, createValidationTemplate as getSchemaValidationCode, hideInvalidProperties, int16, int16Max, int16Min, int32, int32Max, int32Min, int64, int64Max, int64Min, int8, int8Max, int8Min, isAdaptedSchema, nullable, number, object, omit, optional, parse, parseObjectSchema, partial, pick, record, recursive, safeCoerce, safeParse, serialize, serializeObject, serializeSmallString, serializeString, string, stringEnum, timestamp, uint16, uint16Max, uint16Min, uint32, uint32Max, uint32Min, uint64, uint64Max, uint64Min, uint8, uint8Max, uint8Min, validate, validateObjectSchema, validatorFromAdaptedSchema };