@arrirpc/schema 0.55.0 → 0.57.2

package/dist/index.cjs

@@ -2,7 +2,7 @@
 
 const jtdUtils = require('jtd-utils');
 const scule = require('scule');
-const timestamp = require('./shared/schema.4c9064ee.cjs');
+const timestamp = require('./shared/schema.e933693f.cjs');
 
 function createParsingTemplate(input, schema) {
   const fallbackTemplate = `
@@ -2102,8 +2102,65 @@ const _namespace = {
     validate: timestamp.validate
 };
 
-function isAAdaptedSchema(input) {
-  return timestamp.isASchema(input) && "_isAdaptedSchema" in input.metadata[timestamp.SCHEMA_METADATA] && input.metadata[timestamp.SCHEMA_METADATA]._isAdaptedSchema === true;
+function isAdaptedSchema(input) {
+  return input.metadata[timestamp.SCHEMA_METADATA]._isAdapted === true;
+}
+function validatorFromAdaptedSchema(schema) {
+  return {
+    compiledCode: {
+      parse: "",
+      serialize: "",
+      validate: ""
+    },
+    validate: schema.metadata[timestamp.SCHEMA_METADATA].validate,
+    parse(input) {
+      const context = {
+        instancePath: "",
+        schemaPath: "",
+        errors: []
+      };
+      return schema.metadata[timestamp.SCHEMA_METADATA].parse(input, context);
+    },
+    safeParse(input) {
+      const context = {
+        instancePath: "",
+        schemaPath: "",
+        errors: []
+      };
+      try {
+        const result = schema.metadata[timestamp.SCHEMA_METADATA].parse(
+          input,
+          context
+        );
+        return {
+          success: true,
+          value: result
+        };
+      } catch (err) {
+        if (err instanceof timestamp.ValidationError) {
+          return {
+            success: false,
+            error: err
+          };
+        }
+        return {
+          success: false,
+          error: new timestamp.ValidationError({
+            message: context.errors[0]?.message ?? `Error parsing input. ${err}`,
+            errors: context.errors
+          })
+        };
+      }
+    },
+    serialize(input) {
+      const context = {
+        instancePath: "",
+        schemaPath: "",
+        errors: []
+      };
+      return schema.metadata[timestamp.SCHEMA_METADATA].serialize(input, context);
+    }
+  };
 }
 
 exports.NumberTypeValues = timestamp.NumberTypeValues;
@@ -2183,4 +2240,5 @@ exports.getCompiledSerializer = getCompiledSerializer;
 exports.getSchemaParsingCode = createParsingTemplate;
 exports.getSchemaSerializationCode = createSerializationV2Template;
 exports.getSchemaValidationCode = createValidationTemplate;
-exports.isAAdaptedSchema = isAAdaptedSchema;
+exports.isAdaptedSchema = isAdaptedSchema;
+exports.validatorFromAdaptedSchema = validatorFromAdaptedSchema;

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 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 { 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 { Schema } from 'jtd-utils';
 
 declare function createParsingTemplate(input: string, schema: Schema): string;
@@ -189,7 +189,7 @@ declare function uint64(opts?: ASchemaOptions): AScalarSchema<"uint64", bigint>;
  */
 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 parseObjectSchema<T>(schema: AObjectSchema<T>, input: unknown, data: ValidationData, coerce?: boolean): T | undefined;
+declare function parseObjectSchema<T>(schema: AObjectSchema<T>, input: unknown, data: ValidationContext, coerce?: boolean): T | undefined;
 declare function validateObjectSchema(schema: AObjectSchema, input: unknown): boolean;
 /**
  * Create an object schema using a subset of keys from another object schema
@@ -217,7 +217,7 @@ 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 serializeObject(schema: AObjectSchema, input: any, data: ValidationData): string;
+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 partial<TSchema extends AObjectSchema<any, any> = any, TAdditionalProps extends boolean = false>(schema: TSchema, options?: AObjectSchemaOptions<TAdditionalProps>): AObjectSchema<Partial<InferType<TSchema>>, TAdditionalProps>;
 
@@ -338,26 +338,9 @@ 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 };
 }
 
-interface AAdaptedSchemaValidator<T> extends SchemaValidator<T> {
-    _isAdaptedSchema: true;
-}
-interface AAdaptedSchemaMetadata<T> extends SchemaMetadata<T> {
-    [SCHEMA_METADATA]: AAdaptedSchemaValidator<T>;
-}
-interface AAdaptedSchema<T> extends ASchema<T> {
-    metadata: AAdaptedSchemaMetadata<T>;
-}
-interface AAdaptedObjectSchema<T> extends AObjectSchema<T> {
-    metadata: AAdaptedSchemaMetadata<T>;
-}
-interface AAdaptedRecordSchema<T> extends ARecordSchema<ASchema<T>> {
-    metadata: AAdaptedSchemaMetadata<Record<string, T>>;
-}
-interface AAdaptedDiscriminatorSchema<T> extends ADiscriminatorSchema<T> {
-    metadata: AAdaptedSchemaMetadata<T>;
-}
-declare function isAAdaptedSchema<T = any>(input: unknown): input is AAdaptedSchema<T>;
-type ValidationAdapter = <T>(input: any) => AAdaptedSchema<T>;
+type ValidationAdapter = <T>(input: any) => ASchema<T>;
+declare function isAdaptedSchema(input: ASchema): boolean;
+declare function validatorFromAdaptedSchema(schema: ASchema): ReturnType<typeof compile>;
 
 declare const int8Min = -128;
 declare const int8Max = 127;
@@ -376,4 +359,4 @@ 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 };
+export { AArraySchema, ADiscriminatorSchema, AObjectSchema, AObjectSchemaOptions, ARecordSchema, ARefSchema, AScalarSchema, ASchema, ASchemaOptions, AStringEnumSchema, type CompiledValidator, InferObjectOutput, InferSubType, InferType, ResolveObject, SafeResult, type ValidationAdapter, ValidationContext, _namespace as a, any, array, boolean, clone, coerce, compile, discriminator, enumerator, errors, extend, float32, float64, getCompiledParser, getCompiledSerializer, createParsingTemplate as getSchemaParsingCode, createSerializationV2Template as getSchemaSerializationCode, createValidationTemplate as getSchemaValidationCode, int16, int16Max, int16Min, int32, int32Max, int32Min, int64, int64Max, int64Min, int8, int8Max, int8Min, isAdaptedSchema, nullable, number, object, omit, optional, parse, parseObjectSchema, partial, pick, record, recursive, safeCoerce, safeParse, serialize, serializeObject, serializeSmallString, string, stringEnum, timestamp, uint16, uint16Max, uint16Min, uint32, uint32Max, uint32Min, uint64, uint64Max, uint64Min, uint8, uint8Max, uint8Min, validate, validateObjectSchema, validatorFromAdaptedSchema };

package/dist/index.d.mts

@@ -1,5 +1,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 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 { 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 { Schema } from 'jtd-utils';
 
 declare function createParsingTemplate(input: string, schema: Schema): string;
@@ -189,7 +189,7 @@ declare function uint64(opts?: ASchemaOptions): AScalarSchema<"uint64", bigint>;
  */
 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 parseObjectSchema<T>(schema: AObjectSchema<T>, input: unknown, data: ValidationData, coerce?: boolean): T | undefined;
+declare function parseObjectSchema<T>(schema: AObjectSchema<T>, input: unknown, data: ValidationContext, coerce?: boolean): T | undefined;
 declare function validateObjectSchema(schema: AObjectSchema, input: unknown): boolean;
 /**
  * Create an object schema using a subset of keys from another object schema
@@ -217,7 +217,7 @@ 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 serializeObject(schema: AObjectSchema, input: any, data: ValidationData): string;
+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 partial<TSchema extends AObjectSchema<any, any> = any, TAdditionalProps extends boolean = false>(schema: TSchema, options?: AObjectSchemaOptions<TAdditionalProps>): AObjectSchema<Partial<InferType<TSchema>>, TAdditionalProps>;
 
@@ -338,26 +338,9 @@ 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 };
 }
 
-interface AAdaptedSchemaValidator<T> extends SchemaValidator<T> {
-    _isAdaptedSchema: true;
-}
-interface AAdaptedSchemaMetadata<T> extends SchemaMetadata<T> {
-    [SCHEMA_METADATA]: AAdaptedSchemaValidator<T>;
-}
-interface AAdaptedSchema<T> extends ASchema<T> {
-    metadata: AAdaptedSchemaMetadata<T>;
-}
-interface AAdaptedObjectSchema<T> extends AObjectSchema<T> {
-    metadata: AAdaptedSchemaMetadata<T>;
-}
-interface AAdaptedRecordSchema<T> extends ARecordSchema<ASchema<T>> {
-    metadata: AAdaptedSchemaMetadata<Record<string, T>>;
-}
-interface AAdaptedDiscriminatorSchema<T> extends ADiscriminatorSchema<T> {
-    metadata: AAdaptedSchemaMetadata<T>;
-}
-declare function isAAdaptedSchema<T = any>(input: unknown): input is AAdaptedSchema<T>;
-type ValidationAdapter = <T>(input: any) => AAdaptedSchema<T>;
+type ValidationAdapter = <T>(input: any) => ASchema<T>;
+declare function isAdaptedSchema(input: ASchema): boolean;
+declare function validatorFromAdaptedSchema(schema: ASchema): ReturnType<typeof compile>;
 
 declare const int8Min = -128;
 declare const int8Max = 127;
@@ -376,4 +359,4 @@ 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 };
+export { AArraySchema, ADiscriminatorSchema, AObjectSchema, AObjectSchemaOptions, ARecordSchema, ARefSchema, AScalarSchema, ASchema, ASchemaOptions, AStringEnumSchema, type CompiledValidator, InferObjectOutput, InferSubType, InferType, ResolveObject, SafeResult, type ValidationAdapter, ValidationContext, _namespace as a, any, array, boolean, clone, coerce, compile, discriminator, enumerator, errors, extend, float32, float64, getCompiledParser, getCompiledSerializer, createParsingTemplate as getSchemaParsingCode, createSerializationV2Template as getSchemaSerializationCode, createValidationTemplate as getSchemaValidationCode, int16, int16Max, int16Min, int32, int32Max, int32Min, int64, int64Max, int64Min, int8, int8Max, int8Min, isAdaptedSchema, nullable, number, object, omit, optional, parse, parseObjectSchema, partial, pick, record, recursive, safeCoerce, safeParse, serialize, serializeObject, serializeSmallString, string, stringEnum, timestamp, uint16, uint16Max, uint16Min, uint32, uint32Max, uint32Min, uint64, uint64Max, uint64Min, uint8, uint8Max, uint8Min, validate, validateObjectSchema, validatorFromAdaptedSchema };

package/dist/index.d.ts

@@ -1,5 +1,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 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 { 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 { Schema } from 'jtd-utils';
 
 declare function createParsingTemplate(input: string, schema: Schema): string;
@@ -189,7 +189,7 @@ declare function uint64(opts?: ASchemaOptions): AScalarSchema<"uint64", bigint>;
  */
 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 parseObjectSchema<T>(schema: AObjectSchema<T>, input: unknown, data: ValidationData, coerce?: boolean): T | undefined;
+declare function parseObjectSchema<T>(schema: AObjectSchema<T>, input: unknown, data: ValidationContext, coerce?: boolean): T | undefined;
 declare function validateObjectSchema(schema: AObjectSchema, input: unknown): boolean;
 /**
  * Create an object schema using a subset of keys from another object schema
@@ -217,7 +217,7 @@ 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 serializeObject(schema: AObjectSchema, input: any, data: ValidationData): string;
+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 partial<TSchema extends AObjectSchema<any, any> = any, TAdditionalProps extends boolean = false>(schema: TSchema, options?: AObjectSchemaOptions<TAdditionalProps>): AObjectSchema<Partial<InferType<TSchema>>, TAdditionalProps>;
 
@@ -338,26 +338,9 @@ 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 };
 }
 
-interface AAdaptedSchemaValidator<T> extends SchemaValidator<T> {
-    _isAdaptedSchema: true;
-}
-interface AAdaptedSchemaMetadata<T> extends SchemaMetadata<T> {
-    [SCHEMA_METADATA]: AAdaptedSchemaValidator<T>;
-}
-interface AAdaptedSchema<T> extends ASchema<T> {
-    metadata: AAdaptedSchemaMetadata<T>;
-}
-interface AAdaptedObjectSchema<T> extends AObjectSchema<T> {
-    metadata: AAdaptedSchemaMetadata<T>;
-}
-interface AAdaptedRecordSchema<T> extends ARecordSchema<ASchema<T>> {
-    metadata: AAdaptedSchemaMetadata<Record<string, T>>;
-}
-interface AAdaptedDiscriminatorSchema<T> extends ADiscriminatorSchema<T> {
-    metadata: AAdaptedSchemaMetadata<T>;
-}
-declare function isAAdaptedSchema<T = any>(input: unknown): input is AAdaptedSchema<T>;
-type ValidationAdapter = <T>(input: any) => AAdaptedSchema<T>;
+type ValidationAdapter = <T>(input: any) => ASchema<T>;
+declare function isAdaptedSchema(input: ASchema): boolean;
+declare function validatorFromAdaptedSchema(schema: ASchema): ReturnType<typeof compile>;
 
 declare const int8Min = -128;
 declare const int8Max = 127;
@@ -376,4 +359,4 @@ 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 };
+export { AArraySchema, ADiscriminatorSchema, AObjectSchema, AObjectSchemaOptions, ARecordSchema, ARefSchema, AScalarSchema, ASchema, ASchemaOptions, AStringEnumSchema, type CompiledValidator, InferObjectOutput, InferSubType, InferType, ResolveObject, SafeResult, type ValidationAdapter, ValidationContext, _namespace as a, any, array, boolean, clone, coerce, compile, discriminator, enumerator, errors, extend, float32, float64, getCompiledParser, getCompiledSerializer, createParsingTemplate as getSchemaParsingCode, createSerializationV2Template as getSchemaSerializationCode, createValidationTemplate as getSchemaValidationCode, int16, int16Max, int16Min, int32, int32Max, int32Min, int64, int64Max, int64Min, int8, int8Max, int8Min, isAdaptedSchema, nullable, number, object, omit, optional, parse, parseObjectSchema, partial, pick, record, recursive, safeCoerce, safeParse, serialize, serializeObject, serializeSmallString, string, stringEnum, timestamp, uint16, uint16Max, uint16Min, uint32, uint32Max, uint32Min, uint64, uint64Max, uint64Min, uint8, uint8Max, uint8Min, validate, validateObjectSchema, validatorFromAdaptedSchema };

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 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';
+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';
 
 function createParsingTemplate(input, schema) {
   const fallbackTemplate = `
@@ -2101,8 +2101,65 @@ const _namespace = {
     validate: validate
 };
 
-function isAAdaptedSchema(input) {
-  return isASchema(input) && "_isAdaptedSchema" in input.metadata[SCHEMA_METADATA] && input.metadata[SCHEMA_METADATA]._isAdaptedSchema === true;
+function isAdaptedSchema(input) {
+  return input.metadata[SCHEMA_METADATA]._isAdapted === true;
+}
+function validatorFromAdaptedSchema(schema) {
+  return {
+    compiledCode: {
+      parse: "",
+      serialize: "",
+      validate: ""
+    },
+    validate: schema.metadata[SCHEMA_METADATA].validate,
+    parse(input) {
+      const context = {
+        instancePath: "",
+        schemaPath: "",
+        errors: []
+      };
+      return schema.metadata[SCHEMA_METADATA].parse(input, context);
+    },
+    safeParse(input) {
+      const context = {
+        instancePath: "",
+        schemaPath: "",
+        errors: []
+      };
+      try {
+        const result = schema.metadata[SCHEMA_METADATA].parse(
+          input,
+          context
+        );
+        return {
+          success: true,
+          value: result
+        };
+      } catch (err) {
+        if (err instanceof ValidationError) {
+          return {
+            success: false,
+            error: err
+          };
+        }
+        return {
+          success: false,
+          error: new ValidationError({
+            message: context.errors[0]?.message ?? `Error parsing input. ${err}`,
+            errors: context.errors
+          })
+        };
+      }
+    },
+    serialize(input) {
+      const context = {
+        instancePath: "",
+        schemaPath: "",
+        errors: []
+      };
+      return schema.metadata[SCHEMA_METADATA].serialize(input, context);
+    }
+  };
 }
 
-export { SCHEMA_METADATA, ValidationError, _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, int8, int8Max, int8Min, isAAdaptedSchema, isAAraySchema, isADiscriminatorSchema, isAObjectSchema, isARecordSchema, isARefSchema, isAScalarSchema, isASchema, isAStringEnumSchema, nullable, number, object, omit, optional, parse, partial, pick, record, recursive, safeCoerce, safeParse, serialize, string, stringEnum, timestamp, uint16, uint16Max, uint16Min, uint32, uint32Max, uint32Min, uint64, uint8, uint8Max, uint8Min, validate };
+export { SCHEMA_METADATA, ValidationError, _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, int8, int8Max, int8Min, isAAraySchema, isADiscriminatorSchema, isAObjectSchema, isARecordSchema, isARefSchema, isAScalarSchema, isAStringEnumSchema, isAdaptedSchema, nullable, number, object, omit, optional, parse, partial, pick, record, recursive, safeCoerce, safeParse, serialize, string, stringEnum, timestamp, uint16, uint16Max, uint16Min, uint32, uint32Max, uint32Min, uint64, uint8, uint8Max, uint8Min, validate, validatorFromAdaptedSchema };

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

@@ -50,7 +50,7 @@ declare function isValidationError(input: unknown): input is ValidationError;
 
 declare const SCHEMA_METADATA: unique symbol;
 type MaybeNullable<T = any, TIsNullable extends boolean = false> = TIsNullable extends true ? T | null : T;
-interface ValidationData {
+interface ValidationContext {
     instancePath: string;
     schemaPath: string;
     errors: ValueError[];
@@ -60,10 +60,11 @@ interface ValidationData {
 interface SchemaValidator<T> {
     output: T;
     optional?: boolean;
-    parse: (input: unknown, data: ValidationData) => T | undefined;
-    coerce: (input: unknown, data: ValidationData) => T | undefined;
-    serialize: (input: T, data: ValidationData) => string;
+    parse: (input: unknown, context: ValidationContext) => T | undefined;
+    coerce: (input: unknown, context: ValidationContext) => T | undefined;
+    serialize: (input: T, context: ValidationContext) => string;
     validate: (input: unknown) => input is T;
+    _isAdapted?: boolean;
 }
 interface SchemaMetadata<T> {
     [key: string]: any;
@@ -164,4 +165,4 @@ interface ARefSchema<T> extends ASchema<T> {
 }
 declare function isARefSchema(input: unknown): input is ARefSchema<any>;
 
-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 };
+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 ValidationContext 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, sanitizeJson as q, type ValueError as r, safeCoerce as s, ValidationError as t, isValidationError as u, validate as v, SCHEMA_METADATA as w, type SchemaValidator as x, type SchemaMetadata as y, isASchema as z };

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

@@ -50,7 +50,7 @@ declare function isValidationError(input: unknown): input is ValidationError;
 
 declare const SCHEMA_METADATA: unique symbol;
 type MaybeNullable<T = any, TIsNullable extends boolean = false> = TIsNullable extends true ? T | null : T;
-interface ValidationData {
+interface ValidationContext {
     instancePath: string;
     schemaPath: string;
     errors: ValueError[];
@@ -60,10 +60,11 @@ interface ValidationData {
 interface SchemaValidator<T> {
     output: T;
     optional?: boolean;
-    parse: (input: unknown, data: ValidationData) => T | undefined;
-    coerce: (input: unknown, data: ValidationData) => T | undefined;
-    serialize: (input: T, data: ValidationData) => string;
+    parse: (input: unknown, context: ValidationContext) => T | undefined;
+    coerce: (input: unknown, context: ValidationContext) => T | undefined;
+    serialize: (input: T, context: ValidationContext) => string;
     validate: (input: unknown) => input is T;
+    _isAdapted?: boolean;
 }
 interface SchemaMetadata<T> {
     [key: string]: any;
@@ -164,4 +165,4 @@ interface ARefSchema<T> extends ASchema<T> {
 }
 declare function isARefSchema(input: unknown): input is ARefSchema<any>;
 
-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 };
+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 ValidationContext 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, sanitizeJson as q, type ValueError as r, safeCoerce as s, ValidationError as t, isValidationError as u, validate as v, SCHEMA_METADATA as w, type SchemaValidator as x, type SchemaMetadata as y, isASchema as z };

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

@@ -50,7 +50,7 @@ declare function isValidationError(input: unknown): input is ValidationError;
 
 declare const SCHEMA_METADATA: unique symbol;
 type MaybeNullable<T = any, TIsNullable extends boolean = false> = TIsNullable extends true ? T | null : T;
-interface ValidationData {
+interface ValidationContext {
     instancePath: string;
     schemaPath: string;
     errors: ValueError[];
@@ -60,10 +60,11 @@ interface ValidationData {
 interface SchemaValidator<T> {
     output: T;
     optional?: boolean;
-    parse: (input: unknown, data: ValidationData) => T | undefined;
-    coerce: (input: unknown, data: ValidationData) => T | undefined;
-    serialize: (input: T, data: ValidationData) => string;
+    parse: (input: unknown, context: ValidationContext) => T | undefined;
+    coerce: (input: unknown, context: ValidationContext) => T | undefined;
+    serialize: (input: T, context: ValidationContext) => string;
     validate: (input: unknown) => input is T;
+    _isAdapted?: boolean;
 }
 interface SchemaMetadata<T> {
     [key: string]: any;
@@ -164,4 +165,4 @@ interface ARefSchema<T> extends ASchema<T> {
 }
 declare function isARefSchema(input: unknown): input is ARefSchema<any>;
 
-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 };
+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 ValidationContext 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, sanitizeJson as q, type ValueError as r, safeCoerce as s, ValidationError as t, isValidationError as u, validate as v, SCHEMA_METADATA as w, type SchemaValidator as x, type SchemaMetadata as y, isASchema as z };