@arrirpc/schema 0.45.4 → 0.45.6

package/README.md

@@ -22,6 +22,7 @@ To represent the data-models in a language agnostic way this library heavily rel
 
 -   [Installation](#installation)
 -   [Basic Example](#basic-example)
+-   [Usage With @arrirpc/server](#usage-with-@arrirpc/server)
 -   [Supported Types](#supported-types)
     -   [Primitives](#primitives)
     -   [Enums](#enums)
@@ -86,6 +87,30 @@ a.validate(User, { id: "1", name: null });
 a.serialize(User, { id: "1", name: "John Doe" });
 ```
 
+## Usage With @arrirpc/server
+
+See [here](/languages/ts/ts-server/README.md) for full details.
+
+```ts
+import { a } from "@arrirpc/schema";
+import { defineRpc } from "@arrirpc/server";
+
+export default defineRpc({
+    params: a.object({
+        name: a.string(),
+    }),
+    response: a.object({
+        message: a.string(),
+    }),
+    handler({ params }) {
+        // can now access params.name here
+        return {
+            message: `Hello ${params.name}`,
+        };
+    },
+});
+```
+
 ## Supported Types
 
 ### Primitives

package/dist/index.cjs

@@ -1,8 +1,8 @@
 'use strict';
 
-const timestamp = require('./shared/schema.34cb5fb7.cjs');
 const jtdUtils = require('jtd-utils');
 const scule = require('scule');
+const timestamp = require('./shared/schema.4c9064ee.cjs');
 
 function createParsingTemplate(input, schema) {
   const fallbackTemplate = `

package/dist/index.d.cts

@@ -1,7 +1,50 @@
-import { A as ASchemaOptions, a as ASchema, b as AArraySchema, c as AScalarSchema, d as AObjectSchema, e as ADiscriminatorSchema, I as InferType, R as ResolveObject, f as AStringEnumSchema, g as AObjectSchemaOptions, h as InferObjectOutput, V as ValidationData, i as ARecordSchema, j as ARefSchema, S as SafeResult, k as coerce, l as errors, m as InferSubType, p as parse, s as safeCoerce, n as safeParse, o as serialize, v as validate, q as SchemaValidator, r as SchemaMetadata, t as SCHEMA_METADATA } from './shared/schema.b7c77149.cjs';
-export { K as InferObjectRawType, M as MaybeNullable, D as NumberType, N as NumberTypeValues, P as PartialBy, B as Resolve, x as ValidationError, w 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, y as isValidationError, u as sanitizeJson } from './shared/schema.b7c77149.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 ValidationData, 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, q as SchemaValidator, r as SchemaMetadata, t as SCHEMA_METADATA } from './shared/schema.7414d46a.cjs';
+export { K as InferObjectRawType, M as MaybeNullable, D as NumberType, N as NumberTypeValues, P as PartialBy, B as Resolve, x as ValidationError, w 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, y as isValidationError, u as sanitizeJson } from './shared/schema.7414d46a.cjs';
 import { Schema } from 'jtd-utils';
 
+declare function createParsingTemplate(input: string, schema: Schema): string;
+
+declare function createSerializationV2Template(inputName: string, schema: Schema): string;
+
+declare function createValidationTemplate(inputName: string, schema: ASchema<any>): string;
+
+interface CompiledValidator<TSchema extends ASchema<any>> {
+    /**
+     * Determine if a type matches a schema. This is a type guard.
+     */
+    validate: (input: unknown) => input is InferType<TSchema>;
+    /**
+     * Parse a JSON string or the result of JSON.parse(). Throws an error if parsing fails.
+     */
+    parse: (input: unknown) => InferType<TSchema>;
+    /**
+     * Parse a JSON string or the result of JSON.parse() without throwing an error
+     */
+    safeParse: (input: unknown) => SafeResult<InferType<TSchema>>;
+    /**
+     * Serialize to JSON
+     */
+    serialize: (input: InferType<TSchema>) => string;
+    compiledCode: {
+        serialize: string;
+        parse: string;
+        validate: string;
+    };
+}
+/**
+ * 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"];
+declare function getCompiledParser<TSchema extends ASchema<any>>(input: string, schema: TSchema): {
+    fn: CompiledParser<TSchema>;
+    code: string;
+};
+declare function getCompiledSerializer<TSchema extends ASchema>(schema: TSchema): {
+    fn: (input: InferType<TSchema>) => string;
+    code: string;
+};
+
 /**
  * Create a schema that accepts anything
  */
@@ -254,49 +297,6 @@ declare function serializeSmallString(input: string): string;
  */
 declare function timestamp(opts?: ASchemaOptions): AScalarSchema<"timestamp", Date>;
 
-declare function createParsingTemplate(input: string, schema: Schema): string;
-
-declare function createSerializationV2Template(inputName: string, schema: Schema): string;
-
-declare function createValidationTemplate(inputName: string, schema: ASchema<any>): string;
-
-interface CompiledValidator<TSchema extends ASchema<any>> {
-    /**
-     * Determine if a type matches a schema. This is a type guard.
-     */
-    validate: (input: unknown) => input is InferType<TSchema>;
-    /**
-     * Parse a JSON string or the result of JSON.parse(). Throws an error if parsing fails.
-     */
-    parse: (input: unknown) => InferType<TSchema>;
-    /**
-     * Parse a JSON string or the result of JSON.parse() without throwing an error
-     */
-    safeParse: (input: unknown) => SafeResult<InferType<TSchema>>;
-    /**
-     * Serialize to JSON
-     */
-    serialize: (input: InferType<TSchema>) => string;
-    compiledCode: {
-        serialize: string;
-        parse: string;
-        validate: string;
-    };
-}
-/**
- * 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"];
-declare function getCompiledParser<TSchema extends ASchema<any>>(input: string, schema: TSchema): {
-    fn: CompiledParser<TSchema>;
-    code: string;
-};
-declare function getCompiledSerializer<TSchema extends ASchema>(schema: TSchema): {
-    fn: (input: InferType<TSchema>) => string;
-    code: string;
-};
-
 declare const _namespace_any: typeof any;
 declare const _namespace_array: typeof array;
 declare const _namespace_boolean: typeof boolean;
@@ -338,23 +338,6 @@ declare namespace _namespace {
   export { _namespace_any as any, _namespace_array as array, _namespace_boolean as boolean, _namespace_clone as clone, _namespace_coerce as coerce, _namespace_compile as compile, _namespace_discriminator as discriminator, _namespace_enumerator as enumerator, _namespace_errors as errors, _namespace_extend as extend, _namespace_float32 as float32, _namespace_float64 as float64, InferType as infer, InferSubType as inferSubType, _namespace_int16 as int16, _namespace_int32 as int32, _namespace_int64 as int64, _namespace_int8 as int8, _namespace_nullable as nullable, _namespace_number as number, _namespace_object as object, _namespace_omit as omit, _namespace_optional as optional, _namespace_parse as parse, _namespace_partial as partial, _namespace_pick as pick, _namespace_record as record, _namespace_recursive as recursive, _namespace_safeCoerce as safeCoerce, _namespace_safeParse as safeParse, _namespace_serialize as serialize, _namespace_string as string, _namespace_stringEnum as stringEnum, _namespace_timestamp as timestamp, _namespace_uint16 as uint16, _namespace_uint32 as uint32, _namespace_uint64 as uint64, _namespace_uint8 as uint8, _namespace_validate as validate };
 }
 
-declare const int8Min = -128;
-declare const int8Max = 127;
-declare const uint8Min = 0;
-declare const uint8Max = 255;
-declare const int16Min = -32768;
-declare const int16Max = 32767;
-declare const uint16Min = 0;
-declare const uint16Max = 65535;
-declare const int32Min = -2147483648;
-declare const int32Max = 2147483647;
-declare const uint32Min = 0;
-declare const uint32Max = 4294967295;
-declare const int64Min: bigint;
-declare const int64Max: bigint;
-declare const uint64Min: bigint;
-declare const uint64Max: bigint;
-
 interface AAdaptedSchemaValidator<T> extends SchemaValidator<T> {
     _isAdaptedSchema: true;
 }
@@ -376,4 +359,21 @@ interface AAdaptedDiscriminatorSchema<T> extends ADiscriminatorSchema<T> {
 declare function isAAdaptedSchema<T = any>(input: unknown): input is AAdaptedSchema<T>;
 type ValidationAdapter = <T>(input: any) => AAdaptedSchema<T>;
 
+declare const int8Min = -128;
+declare const int8Max = 127;
+declare const uint8Min = 0;
+declare const uint8Max = 255;
+declare const int16Min = -32768;
+declare const int16Max = 32767;
+declare const uint16Min = 0;
+declare const uint16Max = 65535;
+declare const int32Min = -2147483648;
+declare const int32Max = 2147483647;
+declare const uint32Min = 0;
+declare const uint32Max = 4294967295;
+declare const int64Min: bigint;
+declare const int64Max: bigint;
+declare const uint64Min: bigint;
+declare const uint64Max: bigint;
+
 export { type AAdaptedDiscriminatorSchema, type AAdaptedObjectSchema, type AAdaptedRecordSchema, type AAdaptedSchema, type AAdaptedSchemaMetadata, type AAdaptedSchemaValidator, AArraySchema, ADiscriminatorSchema, AObjectSchema, AObjectSchemaOptions, ARecordSchema, ARefSchema, AScalarSchema, ASchema, ASchemaOptions, AStringEnumSchema, type CompiledValidator, InferObjectOutput, InferSubType, InferType, ResolveObject, SCHEMA_METADATA, SafeResult, SchemaMetadata, SchemaValidator, type ValidationAdapter, ValidationData, _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, isAAdaptedSchema, nullable, number, object, omit, optional, parse, parseObjectSchema, partial, pick, record, recursive, safeCoerce, safeParse, serialize, serializeObject, serializeSmallString, string, stringEnum, timestamp, uint16, uint16Max, uint16Min, uint32, uint32Max, uint32Min, uint64, uint64Max, uint64Min, uint8, uint8Max, uint8Min, validate, validateObjectSchema };

package/dist/index.d.mts

@@ -1,7 +1,50 @@
-import { A as ASchemaOptions, a as ASchema, b as AArraySchema, c as AScalarSchema, d as AObjectSchema, e as ADiscriminatorSchema, I as InferType, R as ResolveObject, f as AStringEnumSchema, g as AObjectSchemaOptions, h as InferObjectOutput, V as ValidationData, i as ARecordSchema, j as ARefSchema, S as SafeResult, k as coerce, l as errors, m as InferSubType, p as parse, s as safeCoerce, n as safeParse, o as serialize, v as validate, q as SchemaValidator, r as SchemaMetadata, t as SCHEMA_METADATA } from './shared/schema.b7c77149.mjs';
-export { K as InferObjectRawType, M as MaybeNullable, D as NumberType, N as NumberTypeValues, P as PartialBy, B as Resolve, x as ValidationError, w 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, y as isValidationError, u as sanitizeJson } from './shared/schema.b7c77149.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 ValidationData, 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, q as SchemaValidator, r as SchemaMetadata, t as SCHEMA_METADATA } from './shared/schema.7414d46a.mjs';
+export { K as InferObjectRawType, M as MaybeNullable, D as NumberType, N as NumberTypeValues, P as PartialBy, B as Resolve, x as ValidationError, w 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, y as isValidationError, u as sanitizeJson } from './shared/schema.7414d46a.mjs';
 import { Schema } from 'jtd-utils';
 
+declare function createParsingTemplate(input: string, schema: Schema): string;
+
+declare function createSerializationV2Template(inputName: string, schema: Schema): string;
+
+declare function createValidationTemplate(inputName: string, schema: ASchema<any>): string;
+
+interface CompiledValidator<TSchema extends ASchema<any>> {
+    /**
+     * Determine if a type matches a schema. This is a type guard.
+     */
+    validate: (input: unknown) => input is InferType<TSchema>;
+    /**
+     * Parse a JSON string or the result of JSON.parse(). Throws an error if parsing fails.
+     */
+    parse: (input: unknown) => InferType<TSchema>;
+    /**
+     * Parse a JSON string or the result of JSON.parse() without throwing an error
+     */
+    safeParse: (input: unknown) => SafeResult<InferType<TSchema>>;
+    /**
+     * Serialize to JSON
+     */
+    serialize: (input: InferType<TSchema>) => string;
+    compiledCode: {
+        serialize: string;
+        parse: string;
+        validate: string;
+    };
+}
+/**
+ * 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"];
+declare function getCompiledParser<TSchema extends ASchema<any>>(input: string, schema: TSchema): {
+    fn: CompiledParser<TSchema>;
+    code: string;
+};
+declare function getCompiledSerializer<TSchema extends ASchema>(schema: TSchema): {
+    fn: (input: InferType<TSchema>) => string;
+    code: string;
+};
+
 /**
  * Create a schema that accepts anything
  */
@@ -254,49 +297,6 @@ declare function serializeSmallString(input: string): string;
  */
 declare function timestamp(opts?: ASchemaOptions): AScalarSchema<"timestamp", Date>;
 
-declare function createParsingTemplate(input: string, schema: Schema): string;
-
-declare function createSerializationV2Template(inputName: string, schema: Schema): string;
-
-declare function createValidationTemplate(inputName: string, schema: ASchema<any>): string;
-
-interface CompiledValidator<TSchema extends ASchema<any>> {
-    /**
-     * Determine if a type matches a schema. This is a type guard.
-     */
-    validate: (input: unknown) => input is InferType<TSchema>;
-    /**
-     * Parse a JSON string or the result of JSON.parse(). Throws an error if parsing fails.
-     */
-    parse: (input: unknown) => InferType<TSchema>;
-    /**
-     * Parse a JSON string or the result of JSON.parse() without throwing an error
-     */
-    safeParse: (input: unknown) => SafeResult<InferType<TSchema>>;
-    /**
-     * Serialize to JSON
-     */
-    serialize: (input: InferType<TSchema>) => string;
-    compiledCode: {
-        serialize: string;
-        parse: string;
-        validate: string;
-    };
-}
-/**
- * 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"];
-declare function getCompiledParser<TSchema extends ASchema<any>>(input: string, schema: TSchema): {
-    fn: CompiledParser<TSchema>;
-    code: string;
-};
-declare function getCompiledSerializer<TSchema extends ASchema>(schema: TSchema): {
-    fn: (input: InferType<TSchema>) => string;
-    code: string;
-};
-
 declare const _namespace_any: typeof any;
 declare const _namespace_array: typeof array;
 declare const _namespace_boolean: typeof boolean;
@@ -338,23 +338,6 @@ declare namespace _namespace {
   export { _namespace_any as any, _namespace_array as array, _namespace_boolean as boolean, _namespace_clone as clone, _namespace_coerce as coerce, _namespace_compile as compile, _namespace_discriminator as discriminator, _namespace_enumerator as enumerator, _namespace_errors as errors, _namespace_extend as extend, _namespace_float32 as float32, _namespace_float64 as float64, InferType as infer, InferSubType as inferSubType, _namespace_int16 as int16, _namespace_int32 as int32, _namespace_int64 as int64, _namespace_int8 as int8, _namespace_nullable as nullable, _namespace_number as number, _namespace_object as object, _namespace_omit as omit, _namespace_optional as optional, _namespace_parse as parse, _namespace_partial as partial, _namespace_pick as pick, _namespace_record as record, _namespace_recursive as recursive, _namespace_safeCoerce as safeCoerce, _namespace_safeParse as safeParse, _namespace_serialize as serialize, _namespace_string as string, _namespace_stringEnum as stringEnum, _namespace_timestamp as timestamp, _namespace_uint16 as uint16, _namespace_uint32 as uint32, _namespace_uint64 as uint64, _namespace_uint8 as uint8, _namespace_validate as validate };
 }
 
-declare const int8Min = -128;
-declare const int8Max = 127;
-declare const uint8Min = 0;
-declare const uint8Max = 255;
-declare const int16Min = -32768;
-declare const int16Max = 32767;
-declare const uint16Min = 0;
-declare const uint16Max = 65535;
-declare const int32Min = -2147483648;
-declare const int32Max = 2147483647;
-declare const uint32Min = 0;
-declare const uint32Max = 4294967295;
-declare const int64Min: bigint;
-declare const int64Max: bigint;
-declare const uint64Min: bigint;
-declare const uint64Max: bigint;
-
 interface AAdaptedSchemaValidator<T> extends SchemaValidator<T> {
     _isAdaptedSchema: true;
 }
@@ -376,4 +359,21 @@ interface AAdaptedDiscriminatorSchema<T> extends ADiscriminatorSchema<T> {
 declare function isAAdaptedSchema<T = any>(input: unknown): input is AAdaptedSchema<T>;
 type ValidationAdapter = <T>(input: any) => AAdaptedSchema<T>;
 
+declare const int8Min = -128;
+declare const int8Max = 127;
+declare const uint8Min = 0;
+declare const uint8Max = 255;
+declare const int16Min = -32768;
+declare const int16Max = 32767;
+declare const uint16Min = 0;
+declare const uint16Max = 65535;
+declare const int32Min = -2147483648;
+declare const int32Max = 2147483647;
+declare const uint32Min = 0;
+declare const uint32Max = 4294967295;
+declare const int64Min: bigint;
+declare const int64Max: bigint;
+declare const uint64Min: bigint;
+declare const uint64Max: bigint;
+
 export { type AAdaptedDiscriminatorSchema, type AAdaptedObjectSchema, type AAdaptedRecordSchema, type AAdaptedSchema, type AAdaptedSchemaMetadata, type AAdaptedSchemaValidator, AArraySchema, ADiscriminatorSchema, AObjectSchema, AObjectSchemaOptions, ARecordSchema, ARefSchema, AScalarSchema, ASchema, ASchemaOptions, AStringEnumSchema, type CompiledValidator, InferObjectOutput, InferSubType, InferType, ResolveObject, SCHEMA_METADATA, SafeResult, SchemaMetadata, SchemaValidator, type ValidationAdapter, ValidationData, _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, isAAdaptedSchema, nullable, number, object, omit, optional, parse, parseObjectSchema, partial, pick, record, recursive, safeCoerce, safeParse, serialize, serializeObject, serializeSmallString, string, stringEnum, timestamp, uint16, uint16Max, uint16Min, uint32, uint32Max, uint32Min, uint64, uint64Max, uint64Min, uint8, uint8Max, uint8Min, validate, validateObjectSchema };

package/dist/index.d.ts

@@ -1,7 +1,50 @@
-import { A as ASchemaOptions, a as ASchema, b as AArraySchema, c as AScalarSchema, d as AObjectSchema, e as ADiscriminatorSchema, I as InferType, R as ResolveObject, f as AStringEnumSchema, g as AObjectSchemaOptions, h as InferObjectOutput, V as ValidationData, i as ARecordSchema, j as ARefSchema, S as SafeResult, k as coerce, l as errors, m as InferSubType, p as parse, s as safeCoerce, n as safeParse, o as serialize, v as validate, q as SchemaValidator, r as SchemaMetadata, t as SCHEMA_METADATA } from './shared/schema.b7c77149.js';
-export { K as InferObjectRawType, M as MaybeNullable, D as NumberType, N as NumberTypeValues, P as PartialBy, B as Resolve, x as ValidationError, w 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, y as isValidationError, u as sanitizeJson } from './shared/schema.b7c77149.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 ValidationData, 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, q as SchemaValidator, r as SchemaMetadata, t as SCHEMA_METADATA } from './shared/schema.7414d46a.js';
+export { K as InferObjectRawType, M as MaybeNullable, D as NumberType, N as NumberTypeValues, P as PartialBy, B as Resolve, x as ValidationError, w 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, y as isValidationError, u as sanitizeJson } from './shared/schema.7414d46a.js';
 import { Schema } from 'jtd-utils';
 
+declare function createParsingTemplate(input: string, schema: Schema): string;
+
+declare function createSerializationV2Template(inputName: string, schema: Schema): string;
+
+declare function createValidationTemplate(inputName: string, schema: ASchema<any>): string;
+
+interface CompiledValidator<TSchema extends ASchema<any>> {
+    /**
+     * Determine if a type matches a schema. This is a type guard.
+     */
+    validate: (input: unknown) => input is InferType<TSchema>;
+    /**
+     * Parse a JSON string or the result of JSON.parse(). Throws an error if parsing fails.
+     */
+    parse: (input: unknown) => InferType<TSchema>;
+    /**
+     * Parse a JSON string or the result of JSON.parse() without throwing an error
+     */
+    safeParse: (input: unknown) => SafeResult<InferType<TSchema>>;
+    /**
+     * Serialize to JSON
+     */
+    serialize: (input: InferType<TSchema>) => string;
+    compiledCode: {
+        serialize: string;
+        parse: string;
+        validate: string;
+    };
+}
+/**
+ * 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"];
+declare function getCompiledParser<TSchema extends ASchema<any>>(input: string, schema: TSchema): {
+    fn: CompiledParser<TSchema>;
+    code: string;
+};
+declare function getCompiledSerializer<TSchema extends ASchema>(schema: TSchema): {
+    fn: (input: InferType<TSchema>) => string;
+    code: string;
+};
+
 /**
  * Create a schema that accepts anything
  */
@@ -254,49 +297,6 @@ declare function serializeSmallString(input: string): string;
  */
 declare function timestamp(opts?: ASchemaOptions): AScalarSchema<"timestamp", Date>;
 
-declare function createParsingTemplate(input: string, schema: Schema): string;
-
-declare function createSerializationV2Template(inputName: string, schema: Schema): string;
-
-declare function createValidationTemplate(inputName: string, schema: ASchema<any>): string;
-
-interface CompiledValidator<TSchema extends ASchema<any>> {
-    /**
-     * Determine if a type matches a schema. This is a type guard.
-     */
-    validate: (input: unknown) => input is InferType<TSchema>;
-    /**
-     * Parse a JSON string or the result of JSON.parse(). Throws an error if parsing fails.
-     */
-    parse: (input: unknown) => InferType<TSchema>;
-    /**
-     * Parse a JSON string or the result of JSON.parse() without throwing an error
-     */
-    safeParse: (input: unknown) => SafeResult<InferType<TSchema>>;
-    /**
-     * Serialize to JSON
-     */
-    serialize: (input: InferType<TSchema>) => string;
-    compiledCode: {
-        serialize: string;
-        parse: string;
-        validate: string;
-    };
-}
-/**
- * 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"];
-declare function getCompiledParser<TSchema extends ASchema<any>>(input: string, schema: TSchema): {
-    fn: CompiledParser<TSchema>;
-    code: string;
-};
-declare function getCompiledSerializer<TSchema extends ASchema>(schema: TSchema): {
-    fn: (input: InferType<TSchema>) => string;
-    code: string;
-};
-
 declare const _namespace_any: typeof any;
 declare const _namespace_array: typeof array;
 declare const _namespace_boolean: typeof boolean;
@@ -338,23 +338,6 @@ declare namespace _namespace {
   export { _namespace_any as any, _namespace_array as array, _namespace_boolean as boolean, _namespace_clone as clone, _namespace_coerce as coerce, _namespace_compile as compile, _namespace_discriminator as discriminator, _namespace_enumerator as enumerator, _namespace_errors as errors, _namespace_extend as extend, _namespace_float32 as float32, _namespace_float64 as float64, InferType as infer, InferSubType as inferSubType, _namespace_int16 as int16, _namespace_int32 as int32, _namespace_int64 as int64, _namespace_int8 as int8, _namespace_nullable as nullable, _namespace_number as number, _namespace_object as object, _namespace_omit as omit, _namespace_optional as optional, _namespace_parse as parse, _namespace_partial as partial, _namespace_pick as pick, _namespace_record as record, _namespace_recursive as recursive, _namespace_safeCoerce as safeCoerce, _namespace_safeParse as safeParse, _namespace_serialize as serialize, _namespace_string as string, _namespace_stringEnum as stringEnum, _namespace_timestamp as timestamp, _namespace_uint16 as uint16, _namespace_uint32 as uint32, _namespace_uint64 as uint64, _namespace_uint8 as uint8, _namespace_validate as validate };
 }
 
-declare const int8Min = -128;
-declare const int8Max = 127;
-declare const uint8Min = 0;
-declare const uint8Max = 255;
-declare const int16Min = -32768;
-declare const int16Max = 32767;
-declare const uint16Min = 0;
-declare const uint16Max = 65535;
-declare const int32Min = -2147483648;
-declare const int32Max = 2147483647;
-declare const uint32Min = 0;
-declare const uint32Max = 4294967295;
-declare const int64Min: bigint;
-declare const int64Max: bigint;
-declare const uint64Min: bigint;
-declare const uint64Max: bigint;
-
 interface AAdaptedSchemaValidator<T> extends SchemaValidator<T> {
     _isAdaptedSchema: true;
 }
@@ -376,4 +359,21 @@ interface AAdaptedDiscriminatorSchema<T> extends ADiscriminatorSchema<T> {
 declare function isAAdaptedSchema<T = any>(input: unknown): input is AAdaptedSchema<T>;
 type ValidationAdapter = <T>(input: any) => AAdaptedSchema<T>;
 
+declare const int8Min = -128;
+declare const int8Max = 127;
+declare const uint8Min = 0;
+declare const uint8Max = 255;
+declare const int16Min = -32768;
+declare const int16Max = 32767;
+declare const uint16Min = 0;
+declare const uint16Max = 65535;
+declare const int32Min = -2147483648;
+declare const int32Max = 2147483647;
+declare const uint32Min = 0;
+declare const uint32Max = 4294967295;
+declare const int64Min: bigint;
+declare const int64Max: bigint;
+declare const uint64Min: bigint;
+declare const uint64Max: bigint;
+
 export { type AAdaptedDiscriminatorSchema, type AAdaptedObjectSchema, type AAdaptedRecordSchema, type AAdaptedSchema, type AAdaptedSchemaMetadata, type AAdaptedSchemaValidator, AArraySchema, ADiscriminatorSchema, AObjectSchema, AObjectSchemaOptions, ARecordSchema, ARefSchema, AScalarSchema, ASchema, ASchemaOptions, AStringEnumSchema, type CompiledValidator, InferObjectOutput, InferSubType, InferType, ResolveObject, SCHEMA_METADATA, SafeResult, SchemaMetadata, SchemaValidator, type ValidationAdapter, ValidationData, _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, isAAdaptedSchema, nullable, number, object, omit, optional, parse, parseObjectSchema, partial, pick, record, recursive, safeCoerce, safeParse, serialize, serializeObject, serializeSmallString, string, stringEnum, timestamp, uint16, uint16Max, uint16Min, uint32, uint32Max, uint32Min, uint64, uint64Max, uint64Min, uint8, uint8Max, uint8Min, validate, validateObjectSchema };

package/dist/index.mjs

@@ -1,7 +1,7 @@
-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 isASchema, a3 as SCHEMA_METADATA } from './shared/schema.66772201.mjs';
-export { ae as NumberTypeValues, a5 as int64Max, a4 as int64Min, af as isObject, ad as isValidationError, a8 as parseObjectSchema, ac as sanitizeJson, aa as serializeObject, ab as serializeSmallString, a7 as uint64Max, a6 as uint64Min, a9 as validateObjectSchema } from './shared/schema.66772201.mjs';
 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 isASchema, a3 as SCHEMA_METADATA } from './shared/schema.79ea38f8.mjs';
+export { ae as NumberTypeValues, a5 as int64Max, a4 as int64Min, af as isObject, ad as isValidationError, a8 as parseObjectSchema, ac as sanitizeJson, aa as serializeObject, ab as serializeSmallString, a7 as uint64Max, a6 as uint64Min, a9 as validateObjectSchema } from './shared/schema.79ea38f8.mjs';
 
 function createParsingTemplate(input, schema) {
   const fallbackTemplate = `

package/dist/shared/{schema.34cb5fb7.cjs → schema.4c9064ee.cjs}

@@ -2,6 +2,23 @@
 
 const jtdUtils = require('jtd-utils');
 
+const int8Min = -128;
+const int8Max = 127;
+const uint8Min = 0;
+const uint8Max = 255;
+const int16Min = -32768;
+const int16Max = 32767;
+const uint16Min = 0;
+const uint16Max = 65535;
+const int32Min = -2147483648;
+const int32Max = 2147483647;
+const uint32Min = 0;
+const uint32Max = 4294967295;
+const int64Min = BigInt("-9223372036854775808");
+const int64Max = BigInt("9223372036854775807");
+const uint64Min = BigInt("0");
+const uint64Max = BigInt("18446744073709551615");
+
 const SCHEMA_METADATA = Symbol.for("arri.schema_metadata");
 function isASchema(input) {
   if (typeof input !== "object") {
@@ -522,20 +539,20 @@ function discriminatorMappingError(discriminatorVal, data) {
 
 const stringEnum = enumerator;
 function enumerator(paramA, paramB) {
+  const isIdShorthand = typeof paramA === "string";
+  const enumVal = isIdShorthand ? paramB : paramA;
+  const meta = isIdShorthand ? { id: paramA } : paramB;
   const isType = (input) => {
     if (typeof input !== "string") {
       return false;
     }
-    for (const val of paramA) {
+    for (const val of enumVal) {
       if (val === input) {
         return true;
       }
     }
     return false;
   };
-  const isIdShorthand = typeof paramA === "string";
-  const enumVal = isIdShorthand ? paramB : paramA;
-  const meta = isIdShorthand ? { id: paramA } : paramB;
   return {
     enum: enumVal,
     metadata: {
@@ -691,23 +708,6 @@ function clone(input, opts = {}) {
   return schema;
 }
 
-const int8Min = -128;
-const int8Max = 127;
-const uint8Min = 0;
-const uint8Max = 255;
-const int16Min = -32768;
-const int16Max = 32767;
-const uint16Min = 0;
-const uint16Max = 65535;
-const int32Min = -2147483648;
-const int32Max = 2147483647;
-const uint32Min = 0;
-const uint32Max = 4294967295;
-const int64Min = BigInt("-9223372036854775808");
-const int64Max = BigInt("9223372036854775807");
-const uint64Min = BigInt("0");
-const uint64Max = BigInt("18446744073709551615");
-
 function number(opts = {}) {
   return float64(opts);
 }
@@ -727,14 +727,14 @@ function coerceNumber(input, options) {
   return parseNumber(input, options);
 }
 function float32(opts = {}) {
-  return numberScalarType("float32", opts, (input) => {
+  return numberScalarType("float32", opts, () => {
     return {
       success: true
     };
   });
 }
 function float64(opts = {}) {
-  return numberScalarType("float64", opts, (input) => {
+  return numberScalarType("float64", opts, () => {
     return {
       success: true
     };
@@ -942,7 +942,7 @@ function validateNumber(input) {
 function validateInt(input, minVal, maxValue) {
   return Number.isInteger(input) && input >= minVal && input <= maxValue;
 }
-function serializeNumber(input, data) {
+function serializeNumber(input, _data) {
   return input.toString();
 }
 function parseNumber(input, options) {

package/dist/shared/{schema.b7c77149.d.ts → schema.7414d46a.d.cts}

@@ -164,4 +164,4 @@ interface ARefSchema<T> extends ASchema<T> {
 }
 declare function isARefSchema(input: unknown): input is ARefSchema<any>;
 
-export { type ASchemaOptions as A, type Resolve as B, isAScalarSchema as C, type NumberType as D, isAAraySchema as E, isAStringEnumSchema as F, isADiscriminatorSchema as G, isARecordSchema as H, type InferType as I, isAObjectSchema as J, type InferObjectRawType as K, isObject as L, type MaybeNullable as M, NumberTypeValues as N, isARefSchema as O, type PartialBy as P, type ResolveObject as R, type SafeResult as S, type ValidationData as V, type ASchema as a, type AArraySchema as b, type AScalarSchema as c, type AObjectSchema as d, type ADiscriminatorSchema as e, type AStringEnumSchema as f, type AObjectSchemaOptions as g, type InferObjectOutput as h, type ARecordSchema as i, type ARefSchema as j, coerce as k, errors as l, type InferSubType as m, safeParse as n, serialize as o, parse as p, type SchemaValidator as q, type SchemaMetadata as r, safeCoerce as s, SCHEMA_METADATA as t, sanitizeJson as u, validate as v, type ValueError as w, ValidationError as x, isValidationError as y, isASchema as z };
+export { type ASchema as A, type Resolve as B, isAScalarSchema as C, type NumberType as D, isAAraySchema as E, isAStringEnumSchema as F, isADiscriminatorSchema as G, isARecordSchema as H, type InferType as I, isAObjectSchema as J, type InferObjectRawType as K, isObject as L, type MaybeNullable as M, NumberTypeValues as N, isARefSchema as O, type PartialBy as P, type ResolveObject as R, type SafeResult as S, type ValidationData as V, type ASchemaOptions as a, type AArraySchema as b, type AScalarSchema as c, type AObjectSchema as d, type ADiscriminatorSchema as e, type AStringEnumSchema as f, type AObjectSchemaOptions as g, type InferObjectOutput as h, type ARecordSchema as i, type ARefSchema as j, coerce as k, errors as l, type InferSubType as m, safeParse as n, serialize as o, parse as p, type SchemaValidator as q, type SchemaMetadata as r, safeCoerce as s, SCHEMA_METADATA as t, sanitizeJson as u, validate as v, type ValueError as w, ValidationError as x, isValidationError as y, isASchema as z };

package/dist/shared/{schema.b7c77149.d.cts → schema.7414d46a.d.mts}

@@ -164,4 +164,4 @@ interface ARefSchema<T> extends ASchema<T> {
 }
 declare function isARefSchema(input: unknown): input is ARefSchema<any>;
 
-export { type ASchemaOptions as A, type Resolve as B, isAScalarSchema as C, type NumberType as D, isAAraySchema as E, isAStringEnumSchema as F, isADiscriminatorSchema as G, isARecordSchema as H, type InferType as I, isAObjectSchema as J, type InferObjectRawType as K, isObject as L, type MaybeNullable as M, NumberTypeValues as N, isARefSchema as O, type PartialBy as P, type ResolveObject as R, type SafeResult as S, type ValidationData as V, type ASchema as a, type AArraySchema as b, type AScalarSchema as c, type AObjectSchema as d, type ADiscriminatorSchema as e, type AStringEnumSchema as f, type AObjectSchemaOptions as g, type InferObjectOutput as h, type ARecordSchema as i, type ARefSchema as j, coerce as k, errors as l, type InferSubType as m, safeParse as n, serialize as o, parse as p, type SchemaValidator as q, type SchemaMetadata as r, safeCoerce as s, SCHEMA_METADATA as t, sanitizeJson as u, validate as v, type ValueError as w, ValidationError as x, isValidationError as y, isASchema as z };
+export { type ASchema as A, type Resolve as B, isAScalarSchema as C, type NumberType as D, isAAraySchema as E, isAStringEnumSchema as F, isADiscriminatorSchema as G, isARecordSchema as H, type InferType as I, isAObjectSchema as J, type InferObjectRawType as K, isObject as L, type MaybeNullable as M, NumberTypeValues as N, isARefSchema as O, type PartialBy as P, type ResolveObject as R, type SafeResult as S, type ValidationData as V, type ASchemaOptions as a, type AArraySchema as b, type AScalarSchema as c, type AObjectSchema as d, type ADiscriminatorSchema as e, type AStringEnumSchema as f, type AObjectSchemaOptions as g, type InferObjectOutput as h, type ARecordSchema as i, type ARefSchema as j, coerce as k, errors as l, type InferSubType as m, safeParse as n, serialize as o, parse as p, type SchemaValidator as q, type SchemaMetadata as r, safeCoerce as s, SCHEMA_METADATA as t, sanitizeJson as u, validate as v, type ValueError as w, ValidationError as x, isValidationError as y, isASchema as z };

package/dist/shared/{schema.b7c77149.d.mts → schema.7414d46a.d.ts}

@@ -164,4 +164,4 @@ interface ARefSchema<T> extends ASchema<T> {
 }
 declare function isARefSchema(input: unknown): input is ARefSchema<any>;
 
-export { type ASchemaOptions as A, type Resolve as B, isAScalarSchema as C, type NumberType as D, isAAraySchema as E, isAStringEnumSchema as F, isADiscriminatorSchema as G, isARecordSchema as H, type InferType as I, isAObjectSchema as J, type InferObjectRawType as K, isObject as L, type MaybeNullable as M, NumberTypeValues as N, isARefSchema as O, type PartialBy as P, type ResolveObject as R, type SafeResult as S, type ValidationData as V, type ASchema as a, type AArraySchema as b, type AScalarSchema as c, type AObjectSchema as d, type ADiscriminatorSchema as e, type AStringEnumSchema as f, type AObjectSchemaOptions as g, type InferObjectOutput as h, type ARecordSchema as i, type ARefSchema as j, coerce as k, errors as l, type InferSubType as m, safeParse as n, serialize as o, parse as p, type SchemaValidator as q, type SchemaMetadata as r, safeCoerce as s, SCHEMA_METADATA as t, sanitizeJson as u, validate as v, type ValueError as w, ValidationError as x, isValidationError as y, isASchema as z };
+export { type ASchema as A, type Resolve as B, isAScalarSchema as C, type NumberType as D, isAAraySchema as E, isAStringEnumSchema as F, isADiscriminatorSchema as G, isARecordSchema as H, type InferType as I, isAObjectSchema as J, type InferObjectRawType as K, isObject as L, type MaybeNullable as M, NumberTypeValues as N, isARefSchema as O, type PartialBy as P, type ResolveObject as R, type SafeResult as S, type ValidationData as V, type ASchemaOptions as a, type AArraySchema as b, type AScalarSchema as c, type AObjectSchema as d, type ADiscriminatorSchema as e, type AStringEnumSchema as f, type AObjectSchemaOptions as g, type InferObjectOutput as h, type ARecordSchema as i, type ARefSchema as j, coerce as k, errors as l, type InferSubType as m, safeParse as n, serialize as o, parse as p, type SchemaValidator as q, type SchemaMetadata as r, safeCoerce as s, SCHEMA_METADATA as t, sanitizeJson as u, validate as v, type ValueError as w, ValidationError as x, isValidationError as y, isASchema as z };

package/dist/shared/{schema.66772201.mjs → schema.79ea38f8.mjs}

@@ -1,5 +1,22 @@
 import { TypeValues, isSchemaFormElements, isSchemaFormEnum, isSchemaFormDiscriminator, isSchemaFormValues, isSchemaFormProperties, isSchemaFormRef } from 'jtd-utils';
 
+const int8Min = -128;
+const int8Max = 127;
+const uint8Min = 0;
+const uint8Max = 255;
+const int16Min = -32768;
+const int16Max = 32767;
+const uint16Min = 0;
+const uint16Max = 65535;
+const int32Min = -2147483648;
+const int32Max = 2147483647;
+const uint32Min = 0;
+const uint32Max = 4294967295;
+const int64Min = BigInt("-9223372036854775808");
+const int64Max = BigInt("9223372036854775807");
+const uint64Min = BigInt("0");
+const uint64Max = BigInt("18446744073709551615");
+
 const SCHEMA_METADATA = Symbol.for("arri.schema_metadata");
 function isASchema(input) {
   if (typeof input !== "object") {
@@ -520,20 +537,20 @@ function discriminatorMappingError(discriminatorVal, data) {
 
 const stringEnum = enumerator;
 function enumerator(paramA, paramB) {
+  const isIdShorthand = typeof paramA === "string";
+  const enumVal = isIdShorthand ? paramB : paramA;
+  const meta = isIdShorthand ? { id: paramA } : paramB;
   const isType = (input) => {
     if (typeof input !== "string") {
       return false;
     }
-    for (const val of paramA) {
+    for (const val of enumVal) {
       if (val === input) {
         return true;
       }
     }
     return false;
   };
-  const isIdShorthand = typeof paramA === "string";
-  const enumVal = isIdShorthand ? paramB : paramA;
-  const meta = isIdShorthand ? { id: paramA } : paramB;
   return {
     enum: enumVal,
     metadata: {
@@ -689,23 +706,6 @@ function clone(input, opts = {}) {
   return schema;
 }
 
-const int8Min = -128;
-const int8Max = 127;
-const uint8Min = 0;
-const uint8Max = 255;
-const int16Min = -32768;
-const int16Max = 32767;
-const uint16Min = 0;
-const uint16Max = 65535;
-const int32Min = -2147483648;
-const int32Max = 2147483647;
-const uint32Min = 0;
-const uint32Max = 4294967295;
-const int64Min = BigInt("-9223372036854775808");
-const int64Max = BigInt("9223372036854775807");
-const uint64Min = BigInt("0");
-const uint64Max = BigInt("18446744073709551615");
-
 function number(opts = {}) {
   return float64(opts);
 }
@@ -725,14 +725,14 @@ function coerceNumber(input, options) {
   return parseNumber(input, options);
 }
 function float32(opts = {}) {
-  return numberScalarType("float32", opts, (input) => {
+  return numberScalarType("float32", opts, () => {
     return {
       success: true
     };
   });
 }
 function float64(opts = {}) {
-  return numberScalarType("float64", opts, (input) => {
+  return numberScalarType("float64", opts, () => {
     return {
       success: true
     };
@@ -940,7 +940,7 @@ function validateNumber(input) {
 function validateInt(input, minVal, maxValue) {
   return Number.isInteger(input) && input >= minVal && input <= maxValue;
 }
-function serializeNumber(input, data) {
+function serializeNumber(input, _data) {
   return input.toString();
 }
 function parseNumber(input, options) {

package/dist/testSuites.cjs

@@ -1,8 +1,8 @@
 'use strict';
 
-const timestamp = require('./shared/schema.34cb5fb7.cjs');
 require('jtd-utils');
 require('scule');
+const timestamp = require('./shared/schema.4c9064ee.cjs');
 
 const User = timestamp.object({
   id: timestamp.string(),

package/dist/testSuites.d.cts

@@ -1,4 +1,4 @@
-import { d as AObjectSchema, e as ADiscriminatorSchema, a as ASchema } from './shared/schema.b7c77149.cjs';
+import { d as AObjectSchema, e as ADiscriminatorSchema, A as ASchema } from './shared/schema.7414d46a.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.b7c77149.mjs';
+import { d as AObjectSchema, e as ADiscriminatorSchema, A as ASchema } from './shared/schema.7414d46a.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.b7c77149.js';
+import { d as AObjectSchema, e as ADiscriminatorSchema, A as ASchema } from './shared/schema.7414d46a.js';
 import 'jtd-utils';
 
 type RecursiveUnion = {

package/dist/testSuites.mjs

@@ -1,6 +1,6 @@
-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.66772201.mjs';
 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.79ea38f8.mjs';
 
 const User = object({
   id: string(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arrirpc/schema",
-  "version": "0.45.4",
+  "version": "0.45.6",
   "type": "module",
   "license": "MIT",
   "author": {
@@ -24,11 +24,11 @@
   "dependencies": {
     "scule": "^1.3.0",
     "uncrypto": "^0.1.3",
-    "jtd-utils": "0.45.4"
+    "jtd-utils": "0.45.6"
   },
   "devDependencies": {
     "@faker-js/faker": "^8.4.1",
-    "ajv": "^8.13.0",
+    "ajv": "^8.14.0",
     "benny": "^3.7.1"
   }
 }