@arrirpc/schema 0.57.8 → 0.58.1

package/README.md

@@ -1,8 +1,6 @@
 # Arri Schema
 
-A type builder and validation library built on top of the [Json Type Definition (RFC 8927)](https://jsontypedef.com) This library is pretty similar to [Typebox](https://github.com/sinclairzx81/typebox) except that it creates Json Type Definition (JTD) objects instead of Json Schema objects.
-
-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.
+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.
 
 ## Project Philosophy
 
@@ -16,7 +14,11 @@ I am not looking to support every feature of Typescript's type system or even ev
 
 ### Adherence to RFC 8927
 
-To represent the data-models in a language agnostic way this library heavily relies on JSON Type Definition (JTD). However, this library does not strictly comply with the JTD specification. The reason for this is because JTD does not support 64-bit integers. I believe sharing large integers across languages is a huge pain point especially when going to and from Javascript. For this reason alone, I have opted to break away from the JTD spec and add support for `int64` and `uint64`. So while I have no intention to break further away from the spec I am open to it if a large enough issue arises (in my view). If you use this library be aware that I'm using a superset of JTD rather than a strict spec compliant implementation.
+Originally this library was created as a way for building schemas for [Json Type Definition](https://jsontypedef.com/). However over time parts of the internal schema were modified to better suite the goals of Arri RPC. Some of these modifications include:
+
+-   Adding support for 64-bit integers
+-   Replacing the `additionalProperties` field with `strict` to allow for additional properties by default.
+-   Restrict `ref` to only be used for object types.
 
 ## Table of Contents
 
@@ -214,14 +216,13 @@ a.validate({
         "created": {
             "type": "timestamp"
         }
-    },
-    "additionalProperties": true
+    }
 }
 ```
 
 #### Strict Mode
 
-By default @arrirpc/schema will ignore and strip out any additional properties when validating objects. If you want validation to fail when additional properties are present then modify the `additionalProperties` option.
+By default @arrirpc/schema will ignore and strip out any additional properties when validating objects. If you want validation to fail when additional properties are present then modify the `strict` option.
 
 ```ts
 const UserStrict = a.object(
@@ -231,7 +232,7 @@ const UserStrict = a.object(
         created: a.timestamp(),
     },
     {
-        additionalProperties: false,
+        strict: true,
     },
 );
 
@@ -258,7 +259,7 @@ a.parse(UserStrict, {
             "type": "timestamp"
         }
     },
-    "additionalProperties": false
+    "strict": true
 }
 ```
 
@@ -339,16 +340,14 @@ a.validate(Shape, {
                 "height": {
                     "type": "float32"
                 }
-            },
-            "additionalProperties": true
+            }
         },
         "CIRCLE": {
             "properties": {
                 "radius": {
                     "type": "float32"
                 }
-            },
-            "additionalProperties": true
+            }
         }
     }
 }
@@ -426,7 +425,6 @@ a.validate(BinaryTree, {
             "nullable": true
         }
     },
-    "additionalProperties": true,
     "metadata": {
         "id": "BinaryTree"
     }

package/dist/index.cjs

@@ -2,7 +2,7 @@
 
 const jtdUtils = require('jtd-utils');
 const scule = require('scule');
-const timestamp = require('./shared/schema.e933693f.cjs');
+const timestamp = require('./shared/schema.78a649a7.cjs');
 
 function createParsingTemplate(input, schema) {
   const fallbackTemplate = `
@@ -372,7 +372,7 @@ function objectTemplate$2(input) {
       `${innerTargetVal}.${input.discriminatorKey} = "${input.discriminatorValue}";`
     );
   }
-  if (!input.schema.additionalProperties) {
+  if (input.schema.strict) {
     const keyVal = `_${depthStr}_keys`;
     const optionalKeyVal = `_${depthStr}_optionalKeys`;
     const keys = Object.keys(input.schema.properties).map((key) => `"${key}"`).join(",");
@@ -382,7 +382,7 @@ function objectTemplate$2(input) {
             const ${optionalKeyVal} = [${optionalKeys}];
             for (let _key of Object.keys(${input.val})) {
                 if(!${keyVal}.includes(_key) && !${optionalKeyVal}.includes(_key) && _key !== "${input.discriminatorKey ?? ""}") {
-                    $fallback("${input.instancePath}", "${input.schemaPath}/additionalProperties", \`The following key is now allowed by the schema "\${_key}".\`);
+                    $fallback("${input.instancePath}", "${input.schemaPath}/strict", \`The following key is now allowed by the schema "\${_key}".\`);
                 }
             }
                 `
@@ -1194,7 +1194,7 @@ function objectTemplate(input) {
   } else {
     parts.push(`typeof ${input.val} === 'object' && ${input.val} !== null`);
   }
-  if (!input.schema.additionalProperties) {
+  if (input.schema.strict) {
     const allowedKeys = Object.keys(input.schema.properties);
     for (const key of Object.keys(input.schema.optionalProperties ?? {})) {
       allowedKeys.push(key);

package/dist/index.d.cts

@@ -1,5 +1,5 @@
-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.16e4d5ba.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.16e4d5ba.cjs';
+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.cdac4a20.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.cdac4a20.cjs';
 import { Schema } from 'jtd-utils';
 
 declare function createParsingTemplate(input: string, schema: Schema): string;
@@ -187,8 +187,8 @@ declare function uint64(opts?: ASchemaOptions): AScalarSchema<"uint64", bigint>;
  * a.validate(Schema, {foo: "", bar: 0}) // true
  * a.validate(Schema, {foo: null, bar: 0}) // false
  */
-declare function object<TInput extends Record<any, ASchema> = any, TAdditionalProps extends boolean = false>(input: TInput, opts?: AObjectSchemaOptions<TAdditionalProps>): AObjectSchema<InferObjectOutput<TInput, TAdditionalProps>, TAdditionalProps>;
-declare function object<TInput extends Record<any, ASchema> = any, TAdditionalProps extends boolean = false>(id: string, input: TInput): AObjectSchema<InferObjectOutput<TInput, TAdditionalProps>, TAdditionalProps>;
+declare function object<TInput extends Record<any, ASchema> = any, TAdditionalProps extends boolean = false>(input: TInput, opts?: AObjectSchemaOptions<TAdditionalProps>): AObjectSchema<InferObjectOutput<TInput>, TAdditionalProps>;
+declare function object<TInput extends Record<any, ASchema> = any, TAdditionalProps extends boolean = false>(id: string, input: TInput): AObjectSchema<InferObjectOutput<TInput>, TAdditionalProps>;
 declare function parseObjectSchema<T>(schema: AObjectSchema<T>, input: unknown, data: ValidationContext, coerce?: boolean): T | undefined;
 declare function validateObjectSchema(schema: AObjectSchema, input: unknown): boolean;
 /**
@@ -203,7 +203,7 @@ declare function validateObjectSchema(schema: AObjectSchema, input: unknown): bo
  *
  * const SubObject = a.pick(User, ['foo']) // { foo: string; }
  */
-declare function pick<TSchema extends AObjectSchema<any, any> = any, TKeys extends keyof InferType<TSchema> = any, TAdditionalProps extends boolean = false>(inputSchema: TSchema, keys: TKeys[], opts?: AObjectSchemaOptions<TAdditionalProps>): AObjectSchema<Pick<InferType<TSchema>, TKeys>, TAdditionalProps>;
+declare function pick<TSchema extends AObjectSchema<any, any> = any, TKeys extends keyof InferType<TSchema> = any, TAdditionalProps extends boolean = false>(inputSchema: TSchema, keys: TKeys[], options?: AObjectSchemaOptions<TAdditionalProps>): AObjectSchema<Pick<InferType<TSchema>, TKeys>, TAdditionalProps>;
 /**
  * Create an object schema by omitting keys from another object schema
  *
@@ -216,9 +216,9 @@ declare function pick<TSchema extends AObjectSchema<any, any> = any, TKeys exten
  *
  * const SubObject = a.omit(BaseObject, ['foo']) // { bar: string; baz: string; }
  */
-declare function omit<TSchema extends AObjectSchema<any, any> = any, TKeys extends keyof InferType<TSchema> = any, TAdditionalProps extends boolean = false>(inputSchema: TSchema, keys: TKeys[], opts?: AObjectSchemaOptions<TAdditionalProps>): AObjectSchema<Omit<InferType<TSchema>, TKeys>, TAdditionalProps>;
+declare function omit<TSchema extends AObjectSchema<any, any> = any, TKeys extends keyof InferType<TSchema> = any, TAdditionalProps extends boolean = false>(inputSchema: TSchema, keys: TKeys[], options?: AObjectSchemaOptions<TAdditionalProps>): AObjectSchema<Omit<InferType<TSchema>, TKeys>, TAdditionalProps>;
 declare function serializeObject(schema: AObjectSchema, input: any, data: ValidationContext): string;
-declare function extend<TBaseSchema extends AObjectSchema<any, any> = any, TSchema extends AObjectSchema<any, any> = any, TAdditionalProps extends boolean = false>(baseSchema: TBaseSchema, inputSchema: TSchema, opts?: AObjectSchemaOptions<TAdditionalProps>): AObjectSchema<ResolveObject<InferType<TBaseSchema> & InferType<TSchema>>, TAdditionalProps>;
+declare function extend<TBaseSchema extends AObjectSchema<any, any> = any, TSchema extends AObjectSchema<any, any> = any, TAdditionalProps extends boolean = false>(baseSchema: TBaseSchema, inputSchema: TSchema, options?: AObjectSchemaOptions<TAdditionalProps>): AObjectSchema<ResolveObject<InferType<TBaseSchema> & InferType<TSchema>>, TAdditionalProps>;
 declare function partial<TSchema extends AObjectSchema<any, any> = any, TAdditionalProps extends boolean = false>(schema: TSchema, options?: AObjectSchemaOptions<TAdditionalProps>): AObjectSchema<Partial<InferType<TSchema>>, TAdditionalProps>;
 
 /**

package/dist/index.d.mts

@@ -1,5 +1,5 @@
-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.16e4d5ba.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.16e4d5ba.mjs';
+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.cdac4a20.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.cdac4a20.mjs';
 import { Schema } from 'jtd-utils';
 
 declare function createParsingTemplate(input: string, schema: Schema): string;
@@ -187,8 +187,8 @@ declare function uint64(opts?: ASchemaOptions): AScalarSchema<"uint64", bigint>;
  * a.validate(Schema, {foo: "", bar: 0}) // true
  * a.validate(Schema, {foo: null, bar: 0}) // false
  */
-declare function object<TInput extends Record<any, ASchema> = any, TAdditionalProps extends boolean = false>(input: TInput, opts?: AObjectSchemaOptions<TAdditionalProps>): AObjectSchema<InferObjectOutput<TInput, TAdditionalProps>, TAdditionalProps>;
-declare function object<TInput extends Record<any, ASchema> = any, TAdditionalProps extends boolean = false>(id: string, input: TInput): AObjectSchema<InferObjectOutput<TInput, TAdditionalProps>, TAdditionalProps>;
+declare function object<TInput extends Record<any, ASchema> = any, TAdditionalProps extends boolean = false>(input: TInput, opts?: AObjectSchemaOptions<TAdditionalProps>): AObjectSchema<InferObjectOutput<TInput>, TAdditionalProps>;
+declare function object<TInput extends Record<any, ASchema> = any, TAdditionalProps extends boolean = false>(id: string, input: TInput): AObjectSchema<InferObjectOutput<TInput>, TAdditionalProps>;
 declare function parseObjectSchema<T>(schema: AObjectSchema<T>, input: unknown, data: ValidationContext, coerce?: boolean): T | undefined;
 declare function validateObjectSchema(schema: AObjectSchema, input: unknown): boolean;
 /**
@@ -203,7 +203,7 @@ declare function validateObjectSchema(schema: AObjectSchema, input: unknown): bo
  *
  * const SubObject = a.pick(User, ['foo']) // { foo: string; }
  */
-declare function pick<TSchema extends AObjectSchema<any, any> = any, TKeys extends keyof InferType<TSchema> = any, TAdditionalProps extends boolean = false>(inputSchema: TSchema, keys: TKeys[], opts?: AObjectSchemaOptions<TAdditionalProps>): AObjectSchema<Pick<InferType<TSchema>, TKeys>, TAdditionalProps>;
+declare function pick<TSchema extends AObjectSchema<any, any> = any, TKeys extends keyof InferType<TSchema> = any, TAdditionalProps extends boolean = false>(inputSchema: TSchema, keys: TKeys[], options?: AObjectSchemaOptions<TAdditionalProps>): AObjectSchema<Pick<InferType<TSchema>, TKeys>, TAdditionalProps>;
 /**
  * Create an object schema by omitting keys from another object schema
  *
@@ -216,9 +216,9 @@ declare function pick<TSchema extends AObjectSchema<any, any> = any, TKeys exten
  *
  * const SubObject = a.omit(BaseObject, ['foo']) // { bar: string; baz: string; }
  */
-declare function omit<TSchema extends AObjectSchema<any, any> = any, TKeys extends keyof InferType<TSchema> = any, TAdditionalProps extends boolean = false>(inputSchema: TSchema, keys: TKeys[], opts?: AObjectSchemaOptions<TAdditionalProps>): AObjectSchema<Omit<InferType<TSchema>, TKeys>, TAdditionalProps>;
+declare function omit<TSchema extends AObjectSchema<any, any> = any, TKeys extends keyof InferType<TSchema> = any, TAdditionalProps extends boolean = false>(inputSchema: TSchema, keys: TKeys[], options?: AObjectSchemaOptions<TAdditionalProps>): AObjectSchema<Omit<InferType<TSchema>, TKeys>, TAdditionalProps>;
 declare function serializeObject(schema: AObjectSchema, input: any, data: ValidationContext): string;
-declare function extend<TBaseSchema extends AObjectSchema<any, any> = any, TSchema extends AObjectSchema<any, any> = any, TAdditionalProps extends boolean = false>(baseSchema: TBaseSchema, inputSchema: TSchema, opts?: AObjectSchemaOptions<TAdditionalProps>): AObjectSchema<ResolveObject<InferType<TBaseSchema> & InferType<TSchema>>, TAdditionalProps>;
+declare function extend<TBaseSchema extends AObjectSchema<any, any> = any, TSchema extends AObjectSchema<any, any> = any, TAdditionalProps extends boolean = false>(baseSchema: TBaseSchema, inputSchema: TSchema, options?: AObjectSchemaOptions<TAdditionalProps>): AObjectSchema<ResolveObject<InferType<TBaseSchema> & InferType<TSchema>>, TAdditionalProps>;
 declare function partial<TSchema extends AObjectSchema<any, any> = any, TAdditionalProps extends boolean = false>(schema: TSchema, options?: AObjectSchemaOptions<TAdditionalProps>): AObjectSchema<Partial<InferType<TSchema>>, TAdditionalProps>;
 
 /**

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-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.16e4d5ba.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.16e4d5ba.js';
+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.cdac4a20.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.cdac4a20.js';
 import { Schema } from 'jtd-utils';
 
 declare function createParsingTemplate(input: string, schema: Schema): string;
@@ -187,8 +187,8 @@ declare function uint64(opts?: ASchemaOptions): AScalarSchema<"uint64", bigint>;
  * a.validate(Schema, {foo: "", bar: 0}) // true
  * a.validate(Schema, {foo: null, bar: 0}) // false
  */
-declare function object<TInput extends Record<any, ASchema> = any, TAdditionalProps extends boolean = false>(input: TInput, opts?: AObjectSchemaOptions<TAdditionalProps>): AObjectSchema<InferObjectOutput<TInput, TAdditionalProps>, TAdditionalProps>;
-declare function object<TInput extends Record<any, ASchema> = any, TAdditionalProps extends boolean = false>(id: string, input: TInput): AObjectSchema<InferObjectOutput<TInput, TAdditionalProps>, TAdditionalProps>;
+declare function object<TInput extends Record<any, ASchema> = any, TAdditionalProps extends boolean = false>(input: TInput, opts?: AObjectSchemaOptions<TAdditionalProps>): AObjectSchema<InferObjectOutput<TInput>, TAdditionalProps>;
+declare function object<TInput extends Record<any, ASchema> = any, TAdditionalProps extends boolean = false>(id: string, input: TInput): AObjectSchema<InferObjectOutput<TInput>, TAdditionalProps>;
 declare function parseObjectSchema<T>(schema: AObjectSchema<T>, input: unknown, data: ValidationContext, coerce?: boolean): T | undefined;
 declare function validateObjectSchema(schema: AObjectSchema, input: unknown): boolean;
 /**
@@ -203,7 +203,7 @@ declare function validateObjectSchema(schema: AObjectSchema, input: unknown): bo
  *
  * const SubObject = a.pick(User, ['foo']) // { foo: string; }
  */
-declare function pick<TSchema extends AObjectSchema<any, any> = any, TKeys extends keyof InferType<TSchema> = any, TAdditionalProps extends boolean = false>(inputSchema: TSchema, keys: TKeys[], opts?: AObjectSchemaOptions<TAdditionalProps>): AObjectSchema<Pick<InferType<TSchema>, TKeys>, TAdditionalProps>;
+declare function pick<TSchema extends AObjectSchema<any, any> = any, TKeys extends keyof InferType<TSchema> = any, TAdditionalProps extends boolean = false>(inputSchema: TSchema, keys: TKeys[], options?: AObjectSchemaOptions<TAdditionalProps>): AObjectSchema<Pick<InferType<TSchema>, TKeys>, TAdditionalProps>;
 /**
  * Create an object schema by omitting keys from another object schema
  *
@@ -216,9 +216,9 @@ declare function pick<TSchema extends AObjectSchema<any, any> = any, TKeys exten
  *
  * const SubObject = a.omit(BaseObject, ['foo']) // { bar: string; baz: string; }
  */
-declare function omit<TSchema extends AObjectSchema<any, any> = any, TKeys extends keyof InferType<TSchema> = any, TAdditionalProps extends boolean = false>(inputSchema: TSchema, keys: TKeys[], opts?: AObjectSchemaOptions<TAdditionalProps>): AObjectSchema<Omit<InferType<TSchema>, TKeys>, TAdditionalProps>;
+declare function omit<TSchema extends AObjectSchema<any, any> = any, TKeys extends keyof InferType<TSchema> = any, TAdditionalProps extends boolean = false>(inputSchema: TSchema, keys: TKeys[], options?: AObjectSchemaOptions<TAdditionalProps>): AObjectSchema<Omit<InferType<TSchema>, TKeys>, TAdditionalProps>;
 declare function serializeObject(schema: AObjectSchema, input: any, data: ValidationContext): string;
-declare function extend<TBaseSchema extends AObjectSchema<any, any> = any, TSchema extends AObjectSchema<any, any> = any, TAdditionalProps extends boolean = false>(baseSchema: TBaseSchema, inputSchema: TSchema, opts?: AObjectSchemaOptions<TAdditionalProps>): AObjectSchema<ResolveObject<InferType<TBaseSchema> & InferType<TSchema>>, TAdditionalProps>;
+declare function extend<TBaseSchema extends AObjectSchema<any, any> = any, TSchema extends AObjectSchema<any, any> = any, TAdditionalProps extends boolean = false>(baseSchema: TBaseSchema, inputSchema: TSchema, options?: AObjectSchemaOptions<TAdditionalProps>): AObjectSchema<ResolveObject<InferType<TBaseSchema> & InferType<TSchema>>, TAdditionalProps>;
 declare function partial<TSchema extends AObjectSchema<any, any> = any, TAdditionalProps extends boolean = false>(schema: TSchema, options?: AObjectSchemaOptions<TAdditionalProps>): AObjectSchema<Partial<InferType<TSchema>>, TAdditionalProps>;
 
 /**

package/dist/index.mjs

@@ -1,7 +1,7 @@
 import { isSchemaFormProperties, isSchemaFormValues, isSchemaFormElements, isSchemaFormDiscriminator, isSchemaFormEmpty, isSchemaFormType, isSchemaFormEnum, isSchemaFormRef } from 'jtd-utils';
 import { camelCase } from 'scule';
-import { u as uint8Max, a as uint8Min, b as uint16Max, c as uint16Min, d as uint32Max, e as uint32Min, i as int8Max, f as int8Min, g as int16Max, h as int16Min, j as int32Max, k as int32Min, l as isAScalarSchema, m as isAObjectSchema, n as isAStringEnumSchema, o as isAAraySchema, p as isARecordSchema, q as isADiscriminatorSchema, r as isARefSchema, s as errors, V as ValidationError, t as any, v as array, w as boolean, x as clone, y as coerce, z as discriminator, A as enumerator, B as extend, C as float32, D as float64, E as int16, F as int32, G as int64, H as int8, I as nullable, J as number, K as object, L as omit, M as optional, N as parse, O as partial, P as pick, Q as record, R as recursive, S as safeCoerce, T as safeParse, U as serialize, W as string, X as stringEnum, Y as timestamp, Z as uint16, _ as uint32, $ as uint64, a0 as uint8, a1 as validate, a2 as SCHEMA_METADATA } from './shared/schema.8f2f6fef.mjs';
-export { ae as NumberTypeValues, a4 as int64Max, a3 as int64Min, ad as isASchema, af as isObject, ac as isValidationError, a7 as parseObjectSchema, ab as sanitizeJson, a9 as serializeObject, aa as serializeSmallString, a6 as uint64Max, a5 as uint64Min, a8 as validateObjectSchema } from './shared/schema.8f2f6fef.mjs';
+import { u as uint8Max, a as uint8Min, b as uint16Max, c as uint16Min, d as uint32Max, e as uint32Min, i as int8Max, f as int8Min, g as int16Max, h as int16Min, j as int32Max, k as int32Min, l as isAScalarSchema, m as isAObjectSchema, n as isAStringEnumSchema, o as isAAraySchema, p as isARecordSchema, q as isADiscriminatorSchema, r as isARefSchema, s as errors, V as ValidationError, t as any, v as array, w as boolean, x as clone, y as coerce, z as discriminator, A as enumerator, B as extend, C as float32, D as float64, E as int16, F as int32, G as int64, H as int8, I as nullable, J as number, K as object, L as omit, M as optional, N as parse, O as partial, P as pick, Q as record, R as recursive, S as safeCoerce, T as safeParse, U as serialize, W as string, X as stringEnum, Y as timestamp, Z as uint16, _ as uint32, $ as uint64, a0 as uint8, a1 as validate, a2 as SCHEMA_METADATA } from './shared/schema.31273dd5.mjs';
+export { ae as NumberTypeValues, a4 as int64Max, a3 as int64Min, ad as isASchema, af as isObject, ac as isValidationError, a7 as parseObjectSchema, ab as sanitizeJson, a9 as serializeObject, aa as serializeSmallString, a6 as uint64Max, a5 as uint64Min, a8 as validateObjectSchema } from './shared/schema.31273dd5.mjs';
 
 function createParsingTemplate(input, schema) {
   const fallbackTemplate = `
@@ -371,7 +371,7 @@ function objectTemplate$2(input) {
       `${innerTargetVal}.${input.discriminatorKey} = "${input.discriminatorValue}";`
     );
   }
-  if (!input.schema.additionalProperties) {
+  if (input.schema.strict) {
     const keyVal = `_${depthStr}_keys`;
     const optionalKeyVal = `_${depthStr}_optionalKeys`;
     const keys = Object.keys(input.schema.properties).map((key) => `"${key}"`).join(",");
@@ -381,7 +381,7 @@ function objectTemplate$2(input) {
             const ${optionalKeyVal} = [${optionalKeys}];
             for (let _key of Object.keys(${input.val})) {
                 if(!${keyVal}.includes(_key) && !${optionalKeyVal}.includes(_key) && _key !== "${input.discriminatorKey ?? ""}") {
-                    $fallback("${input.instancePath}", "${input.schemaPath}/additionalProperties", \`The following key is now allowed by the schema "\${_key}".\`);
+                    $fallback("${input.instancePath}", "${input.schemaPath}/strict", \`The following key is now allowed by the schema "\${_key}".\`);
                 }
             }
                 `
@@ -1193,7 +1193,7 @@ function objectTemplate(input) {
   } else {
     parts.push(`typeof ${input.val} === 'object' && ${input.val} !== null`);
   }
-  if (!input.schema.additionalProperties) {
+  if (input.schema.strict) {
     const allowedKeys = Object.keys(input.schema.properties);
     for (const key of Object.keys(input.schema.optionalProperties ?? {})) {
       allowedKeys.push(key);

package/dist/shared/{schema.8f2f6fef.mjs → schema.31273dd5.mjs}

@@ -159,7 +159,7 @@ function parse$6(innerSchema, input, data, coerce = false) {
   if (data.instancePath.length === 0 && typeof input === "string") {
     try {
       parsedInput = JSON.parse(input);
-    } catch (err) {
+    } catch (_) {
       data.errors.push({
         instancePath: data.instancePath,
         schemaPath: `${data.schemaPath}/elements`,
@@ -840,7 +840,7 @@ function int64(opts = {}) {
           instancePath: data.instancePath
         });
         return void 0;
-      } catch (err) {
+      } catch (_) {
         data.errors.push({
           message: `Error at ${data.instancePath}. Unable to transform ${input} to BigInt`,
           schemaPath: `${data.schemaPath}/type`,
@@ -897,7 +897,7 @@ function uint64(opts = {}) {
           instancePath: data.instancePath
         });
         return void 0;
-      } catch (err) {
+      } catch (_) {
         data.errors.push({
           message: `Error at ${data.instancePath}. Unable to transform ${input} to BigInt.`,
           schemaPath: `${data.schemaPath}/type`,
@@ -1039,11 +1039,13 @@ function numberScalarType(type, opts, numTypeMatcher) {
 function object(propA, propB) {
   const isIdShorthand = typeof propA === "string";
   const input = isIdShorthand ? propB : propA;
-  const opts = isIdShorthand ? { id: propA } : propB ?? {};
+  const options = isIdShorthand ? { id: propA } : propB ?? {};
   const schema = {
-    properties: {},
-    additionalProperties: typeof opts.additionalProperties === "boolean" ? opts.additionalProperties : true
+    properties: {}
   };
+  if (typeof options.strict === "boolean") {
+    schema.strict = options.strict;
+  }
   for (const key of Object.keys(input)) {
     const prop = input[key];
     if (prop.metadata[SCHEMA_METADATA].optional) {
@@ -1058,9 +1060,9 @@ function object(propA, propB) {
   const result = {
     ...schema,
     metadata: {
-      id: opts.id,
-      description: opts.description,
-      isDeprecated: opts.isDeprecated,
+      id: options.id,
+      description: options.description,
+      isDeprecated: options.isDeprecated,
       [SCHEMA_METADATA]: {
         output: {},
         parse(input2, context) {
@@ -1071,11 +1073,11 @@ function object(propA, propB) {
             false
           );
         },
-        coerce(input2, data) {
+        coerce(input2, context) {
           return parseObjectSchema(
             schema,
             input2,
-            data,
+            context,
             true
           );
         },
@@ -1100,7 +1102,7 @@ function parseObjectSchema(schema, input, data, coerce = false) {
     try {
       const result2 = JSON.parse(input);
       parsedInput = result2;
-    } catch (err) {
+    } catch (_err) {
       data.errors.push({
         instancePath: data.instancePath,
         schemaPath: `${data.schemaPath}/properties`,
@@ -1122,13 +1124,13 @@ function parseObjectSchema(schema, input, data, coerce = false) {
   const inputKeys = Object.keys(parsedInput);
   const requiredKeys = Object.keys(schema.properties);
   const optionalKeys = Object.keys(optionalProps);
-  if (!schema.additionalProperties) {
+  if (schema.strict) {
     for (const key of inputKeys) {
       if (!requiredKeys.includes(key) && !optionalKeys.includes(key) && key !== data.discriminatorKey) {
         data.errors.push({
           instancePath: `${data.instancePath}/${key}`,
-          schemaPath: `${data.schemaPath}/additionalProperties`,
-          message: `Error at ${data.instancePath}/${key}. Key '${key}' is not included in the schema. To allow additional input properties set additionalProperties to 'true'.`
+          schemaPath: `${data.schemaPath}/strict`,
+          message: `Error at ${data.instancePath}/${key}. Key '${key}' is not included in the schema. To allow additional input properties set strict to 'false'.`
         });
       }
     }
@@ -1190,7 +1192,7 @@ function validateObjectSchema(schema, input) {
   const optionalProps = schema.optionalProperties ?? {};
   for (const key of Object.keys(input)) {
     const prop = schema.properties[key] ?? optionalProps[key];
-    if (!prop && !schema.additionalProperties) {
+    if (!prop && schema.strict) {
       return false;
     }
     if (prop) {
@@ -1202,12 +1204,14 @@ function validateObjectSchema(schema, input) {
   }
   return true;
 }
-function pick(inputSchema, keys, opts = {}) {
+function pick(inputSchema, keys, options = {}) {
   const schema = {
     properties: {},
-    nullable: inputSchema.nullable,
-    additionalProperties: typeof opts.additionalProperties === "boolean" ? opts.additionalProperties : true
+    nullable: inputSchema.nullable
   };
+  if (typeof options.strict === "boolean") {
+    schema.strict = options.strict;
+  }
   Object.keys(inputSchema.properties).forEach((key) => {
     if (!schema.properties) {
       return;
@@ -1230,9 +1234,9 @@ function pick(inputSchema, keys, opts = {}) {
   return {
     ...schema,
     metadata: {
-      id: opts.id,
-      description: opts.description,
-      isDeprecated: opts.isDeprecated,
+      id: options.id,
+      description: options.description,
+      isDeprecated: options.isDeprecated,
       [SCHEMA_METADATA]: {
         output: {},
         parse: (input, context) => {
@@ -1261,14 +1265,16 @@ function pick(inputSchema, keys, opts = {}) {
     }
   };
 }
-function omit(inputSchema, keys, opts = {}) {
+function omit(inputSchema, keys, options = {}) {
   const schema = {
     properties: {
       ...inputSchema.properties
     },
-    nullable: inputSchema.nullable,
-    additionalProperties: typeof opts.additionalProperties === "boolean" ? opts.additionalProperties : true
+    nullable: inputSchema.nullable
   };
+  if (typeof options.strict === "boolean") {
+    schema.strict = options.strict;
+  }
   Object.keys(inputSchema.properties).forEach((key) => {
     if (keys.includes(key)) {
       delete schema.properties[key];
@@ -1290,9 +1296,9 @@ function omit(inputSchema, keys, opts = {}) {
   return {
     ...schema,
     metadata: {
-      id: opts.id,
-      description: opts.description,
-      isDeprecated: opts.isDeprecated,
+      id: options.id,
+      description: options.description,
+      isDeprecated: options.isDeprecated,
       [SCHEMA_METADATA]: {
         output: {},
         validate(input) {
@@ -1353,7 +1359,7 @@ function serializeObject(schema, input, data) {
   }
   return `{${strParts.join(",")}}`;
 }
-function extend(baseSchema, inputSchema, opts = {}) {
+function extend(baseSchema, inputSchema, options = {}) {
   const schema = {
     properties: {
       ...baseSchema.properties,
@@ -1362,13 +1368,15 @@ function extend(baseSchema, inputSchema, opts = {}) {
     optionalProperties: {
       ...baseSchema.optionalProperties,
       ...inputSchema.optionalProperties
-    },
-    additionalProperties: typeof opts.additionalProperties === "boolean" ? opts.additionalProperties : true
+    }
   };
+  if (typeof options.strict === "boolean") {
+    schema.strict = options.strict;
+  }
   const isType = (input) => validateObjectSchema(schema, input);
   const meta = {
-    id: opts.id,
-    description: opts.description,
+    id: options.id,
+    description: options.description,
     [SCHEMA_METADATA]: {
       output: {},
       parse(input, context) {
@@ -1390,9 +1398,11 @@ function partial(schema, options = {}) {
   const newSchema = {
     properties: {},
     optionalProperties: {},
-    additionalProperties: typeof options.additionalProperties === "boolean" ? options.additionalProperties : true,
     nullable: schema.nullable
   };
+  if (typeof options.strict === "boolean") {
+    schema.strict = options.strict;
+  }
   for (const key of Object.keys(schema.properties)) {
     const prop = schema.properties[key];
     newSchema.optionalProperties[key] = optional(prop);

package/dist/shared/{schema.e933693f.cjs → schema.78a649a7.cjs}

@@ -161,7 +161,7 @@ function parse$6(innerSchema, input, data, coerce = false) {
   if (data.instancePath.length === 0 && typeof input === "string") {
     try {
       parsedInput = JSON.parse(input);
-    } catch (err) {
+    } catch (_) {
       data.errors.push({
         instancePath: data.instancePath,
         schemaPath: `${data.schemaPath}/elements`,
@@ -842,7 +842,7 @@ function int64(opts = {}) {
           instancePath: data.instancePath
         });
         return void 0;
-      } catch (err) {
+      } catch (_) {
         data.errors.push({
           message: `Error at ${data.instancePath}. Unable to transform ${input} to BigInt`,
           schemaPath: `${data.schemaPath}/type`,
@@ -899,7 +899,7 @@ function uint64(opts = {}) {
           instancePath: data.instancePath
         });
         return void 0;
-      } catch (err) {
+      } catch (_) {
         data.errors.push({
           message: `Error at ${data.instancePath}. Unable to transform ${input} to BigInt.`,
           schemaPath: `${data.schemaPath}/type`,
@@ -1041,11 +1041,13 @@ function numberScalarType(type, opts, numTypeMatcher) {
 function object(propA, propB) {
   const isIdShorthand = typeof propA === "string";
   const input = isIdShorthand ? propB : propA;
-  const opts = isIdShorthand ? { id: propA } : propB ?? {};
+  const options = isIdShorthand ? { id: propA } : propB ?? {};
   const schema = {
-    properties: {},
-    additionalProperties: typeof opts.additionalProperties === "boolean" ? opts.additionalProperties : true
+    properties: {}
   };
+  if (typeof options.strict === "boolean") {
+    schema.strict = options.strict;
+  }
   for (const key of Object.keys(input)) {
     const prop = input[key];
     if (prop.metadata[SCHEMA_METADATA].optional) {
@@ -1060,9 +1062,9 @@ function object(propA, propB) {
   const result = {
     ...schema,
     metadata: {
-      id: opts.id,
-      description: opts.description,
-      isDeprecated: opts.isDeprecated,
+      id: options.id,
+      description: options.description,
+      isDeprecated: options.isDeprecated,
       [SCHEMA_METADATA]: {
         output: {},
         parse(input2, context) {
@@ -1073,11 +1075,11 @@ function object(propA, propB) {
             false
           );
         },
-        coerce(input2, data) {
+        coerce(input2, context) {
           return parseObjectSchema(
             schema,
             input2,
-            data,
+            context,
             true
           );
         },
@@ -1102,7 +1104,7 @@ function parseObjectSchema(schema, input, data, coerce = false) {
     try {
       const result2 = JSON.parse(input);
       parsedInput = result2;
-    } catch (err) {
+    } catch (_err) {
       data.errors.push({
         instancePath: data.instancePath,
         schemaPath: `${data.schemaPath}/properties`,
@@ -1124,13 +1126,13 @@ function parseObjectSchema(schema, input, data, coerce = false) {
   const inputKeys = Object.keys(parsedInput);
   const requiredKeys = Object.keys(schema.properties);
   const optionalKeys = Object.keys(optionalProps);
-  if (!schema.additionalProperties) {
+  if (schema.strict) {
     for (const key of inputKeys) {
       if (!requiredKeys.includes(key) && !optionalKeys.includes(key) && key !== data.discriminatorKey) {
         data.errors.push({
           instancePath: `${data.instancePath}/${key}`,
-          schemaPath: `${data.schemaPath}/additionalProperties`,
-          message: `Error at ${data.instancePath}/${key}. Key '${key}' is not included in the schema. To allow additional input properties set additionalProperties to 'true'.`
+          schemaPath: `${data.schemaPath}/strict`,
+          message: `Error at ${data.instancePath}/${key}. Key '${key}' is not included in the schema. To allow additional input properties set strict to 'false'.`
         });
       }
     }
@@ -1192,7 +1194,7 @@ function validateObjectSchema(schema, input) {
   const optionalProps = schema.optionalProperties ?? {};
   for (const key of Object.keys(input)) {
     const prop = schema.properties[key] ?? optionalProps[key];
-    if (!prop && !schema.additionalProperties) {
+    if (!prop && schema.strict) {
       return false;
     }
     if (prop) {
@@ -1204,12 +1206,14 @@ function validateObjectSchema(schema, input) {
   }
   return true;
 }
-function pick(inputSchema, keys, opts = {}) {
+function pick(inputSchema, keys, options = {}) {
   const schema = {
     properties: {},
-    nullable: inputSchema.nullable,
-    additionalProperties: typeof opts.additionalProperties === "boolean" ? opts.additionalProperties : true
+    nullable: inputSchema.nullable
   };
+  if (typeof options.strict === "boolean") {
+    schema.strict = options.strict;
+  }
   Object.keys(inputSchema.properties).forEach((key) => {
     if (!schema.properties) {
       return;
@@ -1232,9 +1236,9 @@ function pick(inputSchema, keys, opts = {}) {
   return {
     ...schema,
     metadata: {
-      id: opts.id,
-      description: opts.description,
-      isDeprecated: opts.isDeprecated,
+      id: options.id,
+      description: options.description,
+      isDeprecated: options.isDeprecated,
       [SCHEMA_METADATA]: {
         output: {},
         parse: (input, context) => {
@@ -1263,14 +1267,16 @@ function pick(inputSchema, keys, opts = {}) {
     }
   };
 }
-function omit(inputSchema, keys, opts = {}) {
+function omit(inputSchema, keys, options = {}) {
   const schema = {
     properties: {
       ...inputSchema.properties
     },
-    nullable: inputSchema.nullable,
-    additionalProperties: typeof opts.additionalProperties === "boolean" ? opts.additionalProperties : true
+    nullable: inputSchema.nullable
   };
+  if (typeof options.strict === "boolean") {
+    schema.strict = options.strict;
+  }
   Object.keys(inputSchema.properties).forEach((key) => {
     if (keys.includes(key)) {
       delete schema.properties[key];
@@ -1292,9 +1298,9 @@ function omit(inputSchema, keys, opts = {}) {
   return {
     ...schema,
     metadata: {
-      id: opts.id,
-      description: opts.description,
-      isDeprecated: opts.isDeprecated,
+      id: options.id,
+      description: options.description,
+      isDeprecated: options.isDeprecated,
       [SCHEMA_METADATA]: {
         output: {},
         validate(input) {
@@ -1355,7 +1361,7 @@ function serializeObject(schema, input, data) {
   }
   return `{${strParts.join(",")}}`;
 }
-function extend(baseSchema, inputSchema, opts = {}) {
+function extend(baseSchema, inputSchema, options = {}) {
   const schema = {
     properties: {
       ...baseSchema.properties,
@@ -1364,13 +1370,15 @@ function extend(baseSchema, inputSchema, opts = {}) {
     optionalProperties: {
       ...baseSchema.optionalProperties,
       ...inputSchema.optionalProperties
-    },
-    additionalProperties: typeof opts.additionalProperties === "boolean" ? opts.additionalProperties : true
+    }
   };
+  if (typeof options.strict === "boolean") {
+    schema.strict = options.strict;
+  }
   const isType = (input) => validateObjectSchema(schema, input);
   const meta = {
-    id: opts.id,
-    description: opts.description,
+    id: options.id,
+    description: options.description,
     [SCHEMA_METADATA]: {
       output: {},
       parse(input, context) {
@@ -1392,9 +1400,11 @@ function partial(schema, options = {}) {
   const newSchema = {
     properties: {},
     optionalProperties: {},
-    additionalProperties: typeof options.additionalProperties === "boolean" ? options.additionalProperties : true,
     nullable: schema.nullable
   };
+  if (typeof options.strict === "boolean") {
+    schema.strict = options.strict;
+  }
   for (const key of Object.keys(schema.properties)) {
     const prop = schema.properties[key];
     newSchema.optionalProperties[key] = optional(prop);

package/dist/shared/{schema.16e4d5ba.d.cts → schema.cdac4a20.d.cts}

@@ -143,19 +143,19 @@ interface ARecordSchema<TInnerSchema extends ASchema<any>, TNullable extends boo
     values: TInnerSchema;
 }
 declare function isARecordSchema(input: unknown): input is ARecordSchema<any, any>;
-interface AObjectSchema<TVal = any, TAllowAdditionalProperties extends boolean = false> extends ASchema<TVal> {
+interface AObjectSchema<TVal = any, TStrict extends boolean = false> extends ASchema<TVal> {
     properties: Record<string, ASchema>;
     optionalProperties?: Record<string, ASchema>;
-    additionalProperties?: TAllowAdditionalProperties;
+    strict?: TStrict;
 }
 declare function isAObjectSchema(input: unknown): input is AObjectSchema;
 interface AObjectSchemaOptions<TAdditionalProps extends boolean = false> extends ASchemaOptions {
     /**
      * Allow this object to include additional properties not specified here
      */
-    additionalProperties?: TAdditionalProps;
+    strict?: TAdditionalProps;
 }
-type InferObjectOutput<TInput = any, TAdditionalProps extends boolean = false> = TAdditionalProps extends true ? ResolveObject<InferObjectRawType<TInput>> & Record<any, any> : ResolveObject<InferObjectRawType<TInput>>;
+type InferObjectOutput<TInput = any> = ResolveObject<InferObjectRawType<TInput>>;
 type InferObjectRawType<TInput> = TInput extends Record<any, any> ? {
     [TKey in keyof TInput]: TInput[TKey]["metadata"][typeof SCHEMA_METADATA]["optional"] extends true ? TInput[TKey]["metadata"][typeof SCHEMA_METADATA]["output"] | undefined : TInput[TKey]["metadata"][typeof SCHEMA_METADATA]["output"];
 } : never;

package/dist/shared/{schema.16e4d5ba.d.mts → schema.cdac4a20.d.mts}

@@ -143,19 +143,19 @@ interface ARecordSchema<TInnerSchema extends ASchema<any>, TNullable extends boo
     values: TInnerSchema;
 }
 declare function isARecordSchema(input: unknown): input is ARecordSchema<any, any>;
-interface AObjectSchema<TVal = any, TAllowAdditionalProperties extends boolean = false> extends ASchema<TVal> {
+interface AObjectSchema<TVal = any, TStrict extends boolean = false> extends ASchema<TVal> {
     properties: Record<string, ASchema>;
     optionalProperties?: Record<string, ASchema>;
-    additionalProperties?: TAllowAdditionalProperties;
+    strict?: TStrict;
 }
 declare function isAObjectSchema(input: unknown): input is AObjectSchema;
 interface AObjectSchemaOptions<TAdditionalProps extends boolean = false> extends ASchemaOptions {
     /**
      * Allow this object to include additional properties not specified here
      */
-    additionalProperties?: TAdditionalProps;
+    strict?: TAdditionalProps;
 }
-type InferObjectOutput<TInput = any, TAdditionalProps extends boolean = false> = TAdditionalProps extends true ? ResolveObject<InferObjectRawType<TInput>> & Record<any, any> : ResolveObject<InferObjectRawType<TInput>>;
+type InferObjectOutput<TInput = any> = ResolveObject<InferObjectRawType<TInput>>;
 type InferObjectRawType<TInput> = TInput extends Record<any, any> ? {
     [TKey in keyof TInput]: TInput[TKey]["metadata"][typeof SCHEMA_METADATA]["optional"] extends true ? TInput[TKey]["metadata"][typeof SCHEMA_METADATA]["output"] | undefined : TInput[TKey]["metadata"][typeof SCHEMA_METADATA]["output"];
 } : never;

package/dist/shared/{schema.16e4d5ba.d.ts → schema.cdac4a20.d.ts}

@@ -143,19 +143,19 @@ interface ARecordSchema<TInnerSchema extends ASchema<any>, TNullable extends boo
     values: TInnerSchema;
 }
 declare function isARecordSchema(input: unknown): input is ARecordSchema<any, any>;
-interface AObjectSchema<TVal = any, TAllowAdditionalProperties extends boolean = false> extends ASchema<TVal> {
+interface AObjectSchema<TVal = any, TStrict extends boolean = false> extends ASchema<TVal> {
     properties: Record<string, ASchema>;
     optionalProperties?: Record<string, ASchema>;
-    additionalProperties?: TAllowAdditionalProperties;
+    strict?: TStrict;
 }
 declare function isAObjectSchema(input: unknown): input is AObjectSchema;
 interface AObjectSchemaOptions<TAdditionalProps extends boolean = false> extends ASchemaOptions {
     /**
      * Allow this object to include additional properties not specified here
      */
-    additionalProperties?: TAdditionalProps;
+    strict?: TAdditionalProps;
 }
-type InferObjectOutput<TInput = any, TAdditionalProps extends boolean = false> = TAdditionalProps extends true ? ResolveObject<InferObjectRawType<TInput>> & Record<any, any> : ResolveObject<InferObjectRawType<TInput>>;
+type InferObjectOutput<TInput = any> = ResolveObject<InferObjectRawType<TInput>>;
 type InferObjectRawType<TInput> = TInput extends Record<any, any> ? {
     [TKey in keyof TInput]: TInput[TKey]["metadata"][typeof SCHEMA_METADATA]["optional"] extends true ? TInput[TKey]["metadata"][typeof SCHEMA_METADATA]["output"] | undefined : TInput[TKey]["metadata"][typeof SCHEMA_METADATA]["output"];
 } : never;

package/dist/testSuites.cjs

@@ -2,7 +2,7 @@
 
 require('jtd-utils');
 require('scule');
-const timestamp = require('./shared/schema.e933693f.cjs');
+const timestamp = require('./shared/schema.78a649a7.cjs');
 
 const User = timestamp.object({
   id: timestamp.string(),
@@ -157,17 +157,12 @@ world`,
   int32: {
     schema: timestamp.int32(),
     goodInputs: [491451, -13411],
-    badInputs: [
-      1e18,
-      -1e19,
-      199.5,
-      "hello world"
-    ]
+    badInputs: [999999999999999, -999999999999999, 199.5, "hello world"]
   },
   uint32: {
     schema: timestamp.uint32(),
     goodInputs: [4815141, 100],
-    badInputs: [-1, 100.5, 14e21, "hello world"]
+    badInputs: [-1, 100.5, 1399999999999999, "hello world"]
   },
   int16: {
     schema: timestamp.int16(),
@@ -662,13 +657,13 @@ world`,
       { id: "1" }
     ]
   },
-  "object with additionalProperties false": {
+  "object with strict true": {
     schema: timestamp.object(
       {
         id: timestamp.string(),
         name: timestamp.string()
       },
-      { additionalProperties: false }
+      { strict: true }
     ),
     goodInputs: [
       {
@@ -692,13 +687,13 @@ world`,
       true
     ]
   },
-  "object with additionalProperties true": {
+  "object with strict false": {
     schema: timestamp.object(
       {
         id: timestamp.string(),
         name: timestamp.string()
       },
-      { additionalProperties: true }
+      { strict: false }
     ),
     goodInputs: [
       {

package/dist/testSuites.d.cts

@@ -1,4 +1,4 @@
-import { d as AObjectSchema, e as ADiscriminatorSchema, A as ASchema } from './shared/schema.16e4d5ba.cjs';
+import { d as AObjectSchema, e as ADiscriminatorSchema, A as ASchema } from './shared/schema.cdac4a20.cjs';
 import 'jtd-utils';
 
 type RecursiveUnion = {

package/dist/testSuites.d.mts

@@ -1,4 +1,4 @@
-import { d as AObjectSchema, e as ADiscriminatorSchema, A as ASchema } from './shared/schema.16e4d5ba.mjs';
+import { d as AObjectSchema, e as ADiscriminatorSchema, A as ASchema } from './shared/schema.cdac4a20.mjs';
 import 'jtd-utils';
 
 type RecursiveUnion = {

package/dist/testSuites.d.ts

@@ -1,4 +1,4 @@
-import { d as AObjectSchema, e as ADiscriminatorSchema, A as ASchema } from './shared/schema.16e4d5ba.js';
+import { d as AObjectSchema, e as ADiscriminatorSchema, A as ASchema } from './shared/schema.cdac4a20.js';
 import 'jtd-utils';
 
 type RecursiveUnion = {

package/dist/testSuites.mjs

@@ -1,6 +1,6 @@
 import 'jtd-utils';
 import 'scule';
-import { K as object, W as string, M as optional, I as nullable, F as int32, z as discriminator, w as boolean, X as stringEnum, v as array, Y as timestamp, _ as uint32, t as any, J as number, Q as record, R as recursive, D as float64, C as float32, G as int64, E as int16, Z as uint16, H as int8, a0 as uint8, O as partial, $ as uint64, P as pick, A as enumerator } from './shared/schema.8f2f6fef.mjs';
+import { K as object, W as string, M as optional, I as nullable, F as int32, z as discriminator, w as boolean, X as stringEnum, v as array, Y as timestamp, _ as uint32, t as any, J as number, Q as record, R as recursive, D as float64, C as float32, G as int64, E as int16, Z as uint16, H as int8, a0 as uint8, O as partial, $ as uint64, P as pick, A as enumerator } from './shared/schema.31273dd5.mjs';
 
 const User = object({
   id: string(),
@@ -155,17 +155,12 @@ world`,
   int32: {
     schema: int32(),
     goodInputs: [491451, -13411],
-    badInputs: [
-      1e18,
-      -1e19,
-      199.5,
-      "hello world"
-    ]
+    badInputs: [999999999999999, -999999999999999, 199.5, "hello world"]
   },
   uint32: {
     schema: uint32(),
     goodInputs: [4815141, 100],
-    badInputs: [-1, 100.5, 14e21, "hello world"]
+    badInputs: [-1, 100.5, 1399999999999999, "hello world"]
   },
   int16: {
     schema: int16(),
@@ -660,13 +655,13 @@ world`,
       { id: "1" }
     ]
   },
-  "object with additionalProperties false": {
+  "object with strict true": {
     schema: object(
       {
         id: string(),
         name: string()
       },
-      { additionalProperties: false }
+      { strict: true }
     ),
     goodInputs: [
       {
@@ -690,13 +685,13 @@ world`,
       true
     ]
   },
-  "object with additionalProperties true": {
+  "object with strict false": {
     schema: object(
       {
         id: string(),
         name: string()
       },
-      { additionalProperties: true }
+      { strict: false }
     ),
     goodInputs: [
       {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arrirpc/schema",
-  "version": "0.57.8",
+  "version": "0.58.1",
   "type": "module",
   "license": "MIT",
   "author": {
@@ -24,7 +24,7 @@
   "dependencies": {
     "scule": "^1.3.0",
     "uncrypto": "^0.1.3",
-    "jtd-utils": "0.57.8"
+    "jtd-utils": "0.58.1"
   },
   "devDependencies": {
     "@faker-js/faker": "^8.4.1",