@arrirpc/schema 0.73.0 → 0.74.0

package/dist/index.d.ts

@@ -1,43 +1,61 @@
-import { StandardSchemaV1 } from '@standard-schema/spec';
-import { A as ASchema, I as InferType, S as SafeResult, a as ASchemaOptions, b as AArraySchema, c as AScalarSchema, d as AObjectSchema, e as ADiscriminatorSchema, R as ResolveObject, f as AStringEnumSchema, g as AObjectSchemaOptions, h as InferObjectOutput, V as ValidationContext, i as ARecordSchema, j as ARefSchema, k as coerce, l as errors, m as InferSubType, p as parse, s as safeCoerce, n as safeParse, o as serialize, v as validate } from './shared/schema.DLX0nTwB.js';
-export { K as InferObjectRawType, M as MaybeNullable, D as NumberType, N as NumberTypeValues, P as PartialBy, B as Resolve, w as SCHEMA_METADATA, y as SchemaMetadata, x as SchemaValidator, t as ValidationError, r as ValueError, E as isAAraySchema, G as isADiscriminatorSchema, J as isAObjectSchema, H as isARecordSchema, O as isARefSchema, C as isAScalarSchema, z as isASchema, F as isAStringEnumSchema, L as isObject, u as isValidationError, q as sanitizeJson } from './shared/schema.DLX0nTwB.js';
 import { Schema } from '@arrirpc/type-defs';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { A as ASchema, a as ASchemaStrict, I as InferType, R as Result, S as SchemaValidator, b as ASchemaOptions, c as ASchemaWithAdapters, d as AArraySchema, W as WithAdapters, e as AScalarSchemaWithAdapters, f as AObjectSchema, g as ADiscriminatorSchemaWithAdapters, h as ResolveObject, i as AStringEnumSchemaWithAdapters, j as AObjectSchemaOptions, k as AObjectSchemaWithAdapters, l as InferObjectOutput, V as ValidationContext, m as ARecordSchemaWithAdapters, n as ARefSchema, o as ValueError, p as InferSubType } from './shared/schema.BYXPajpl.js';
+export { G as AArraySchemaWithAdapters, K as ADiscriminatorSchema, O as ARecordSchema, Z as ARefSchemaWithAdapters, C as AScalarSchema, H as AStringEnumSchema, U as InferObjectRawType, M as MaybeNullable, E as NumberType, N as NumberTypeValues, P as PartialBy, B as Resolve, v as ResultFailure, u as ResultSuccess, y as SchemaMetadata, x as VALIDATOR_KEY, s as ValidationException, r as errorMessageFromErrors, F as isAAraySchema, L as isADiscriminatorSchema, T as isAObjectSchema, Q as isARecordSchema, Y as isARefSchema, D as isAScalarSchema, z as isASchema, J as isAStringEnumSchema, X as isObject, t as isValidationException, q as isValueError, w as newValidationContext } from './shared/schema.BYXPajpl.js';
 
-declare function createParsingTemplate(input: string, schema: Schema): string;
+declare function createParsingTemplate(input: string, schema: Schema, shouldCoerce?: boolean): string;
 
 declare function createSerializationV2Template(inputName: string, schema: Schema): string;
 
 declare function createValidationTemplate(inputName: string, schema: ASchema<any>): string;
 
-interface CompiledValidator<TSchema extends ASchema<any>> extends StandardSchemaV1<InferType<TSchema>> {
+interface CompiledValidator<TSchema extends ASchema<any>> {
+    schema: ASchemaStrict<TSchema>;
     /**
      * 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(). Returns a Result<T>.
+     */
+    parse: (input: unknown) => Result<InferType<TSchema>>;
     /**
      * Parse a JSON string or the result of JSON.parse(). Throws an error if parsing fails.
      */
-    parse: (input: unknown) => InferType<TSchema>;
+    parseUnsafe: (input: unknown) => InferType<TSchema>;
     /**
-     * Parse a JSON string or the result of JSON.parse() without throwing an error
+     * Coerce an object into <T>. Returns Result<T>.
      */
-    safeParse: (input: unknown) => SafeResult<InferType<TSchema>>;
+    coerce: (input: unknown) => Result<InferType<TSchema>>;
+    /**
+     * Coerce an object into <T>. Throws an error if coercion fails.
+     */
+    coerceUnsafe: (input: unknown) => InferType<TSchema>;
     /**
      * Serialize to JSON
      */
-    serialize: (input: InferType<TSchema>) => string;
+    serialize: (input: InferType<TSchema>) => Result<string>;
+    /**
+     * Serialize to JSON. Throws an error if it fails.
+     */
+    serializeUnsafe: (input: InferType<TSchema>) => string;
+    /**
+     * The ATD Schema
+     */
     compiledCode: {
-        serialize: string;
         parse: string;
+        coerce: string;
+        serialize: string;
         validate: string;
     };
 }
+type CompiledValidatorWithAdapters<TSchema extends ASchema> = CompiledValidator<TSchema> & StandardSchemaV1<InferType<TSchema>>;
 /**
- * Create compiled versions of the `parse()`, `validate()`, and `serialize()` functions
+ * Create compiled versions of the `decode()`, `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): {
+declare function compile<TSchema extends ASchema<any>>(schema: TSchema): CompiledValidatorWithAdapters<TSchema>;
+type CompiledParser<TSchema extends ASchema<any>> = SchemaValidator<InferType<TSchema>>['parse'];
+declare function getCompiledParser<TSchema extends ASchema<any>>(input: string, schema: Schema, shouldCoerce: boolean): {
     fn: CompiledParser<TSchema>;
     code: string;
 };
@@ -49,9 +67,9 @@ declare function getCompiledSerializer<TSchema extends ASchema>(schema: TSchema)
 /**
  * Create a schema that accepts anything
  */
-declare function any(options?: ASchemaOptions): ASchema<any>;
+declare function any(options?: ASchemaOptions): ASchemaWithAdapters<any>;
 
-declare function array<TInnerSchema extends ASchema<any> = any>(schema: TInnerSchema, opts?: ASchemaOptions): AArraySchema<TInnerSchema>;
+declare function array<TInnerSchema extends ASchema<any> = any>(schema: TInnerSchema, opts?: ASchemaOptions): AArraySchema<TInnerSchema> & WithAdapters<InferType<TInnerSchema>[]>;
 
 /**
  * @example
@@ -59,7 +77,7 @@ declare function array<TInnerSchema extends ASchema<any> = any>(schema: TInnerSc
  * a.validate(Schema, true) // true;
  * a.validate(Schema, false) // true;
  */
-declare function boolean(opts?: ASchemaOptions): AScalarSchema<'boolean', boolean>;
+declare function boolean(opts?: ASchemaOptions): AScalarSchemaWithAdapters<'boolean', boolean>;
 
 /**
  * Create a discriminated union / tagged union
@@ -95,8 +113,8 @@ declare function boolean(opts?: ASchemaOptions): AScalarSchema<'boolean', boolea
  *   createdAt: new Date(),
  * }) // false
  */
-declare function discriminator<TDiscriminatorKey extends string, TMapping extends Record<string, AObjectSchema<any>>>(discriminator: TDiscriminatorKey, mapping: TMapping, opts?: ASchemaOptions): ADiscriminatorSchema<InferDiscriminatorType<TDiscriminatorKey, TMapping, JoinedDiscriminator<TDiscriminatorKey, TMapping>>>;
-declare function discriminator<TDiscriminatorKey extends string, TMapping extends Record<string, AObjectSchema<any>>>(id: string, discriminator: TDiscriminatorKey, mapping: TMapping): ADiscriminatorSchema<InferDiscriminatorType<TDiscriminatorKey, TMapping, JoinedDiscriminator<TDiscriminatorKey, TMapping>>>;
+declare function discriminator<TDiscriminatorKey extends string, TMapping extends Record<string, AObjectSchema<any>>>(discriminator: TDiscriminatorKey, mapping: TMapping, opts?: ASchemaOptions): ADiscriminatorSchemaWithAdapters<InferDiscriminatorType<TDiscriminatorKey, TMapping, JoinedDiscriminator<TDiscriminatorKey, TMapping>>>;
+declare function discriminator<TDiscriminatorKey extends string, TMapping extends Record<string, AObjectSchema<any>>>(id: string, discriminator: TDiscriminatorKey, mapping: TMapping): ADiscriminatorSchemaWithAdapters<InferDiscriminatorType<TDiscriminatorKey, TMapping, JoinedDiscriminator<TDiscriminatorKey, TMapping>>>;
 type JoinedDiscriminator<TUnionKey extends string, TInput extends Record<string, AObjectSchema<any>>> = {
     [TKey in keyof TInput]: InferType<TInput[TKey]> & Record<TUnionKey, TKey>;
 };
@@ -115,7 +133,7 @@ declare const stringEnum: typeof enumerator;
  * a.validate(Schema, "B") // true
  * a.validate(Schema, "C") // false
  */
-declare function enumerator<TKeys extends string, TValues extends TKeys[]>(values: TValues, opts?: ASchemaOptions): AStringEnumSchema<TValues>;
+declare function enumerator<TKeys extends string, TValues extends TKeys[]>(values: TValues, opts?: ASchemaOptions): AStringEnumSchemaWithAdapters<TValues>;
 /**
  * An enumeration of string values
  *
@@ -128,7 +146,7 @@ declare function enumerator<TKeys extends string, TValues extends TKeys[]>(value
  * a.validate(Schema, "B") // true
  * a.validate(Schema, "C") // false
  */
-declare function enumerator<TKeys extends string, TValues extends TKeys[]>(id: string, values: TValues): AStringEnumSchema<TValues>;
+declare function enumerator<TKeys extends string, TValues extends TKeys[]>(id: string, values: TValues): AStringEnumSchemaWithAdapters<TValues>;
 
 /**
  * Transforms a schema into a nullable type
@@ -142,7 +160,7 @@ declare function enumerator<TKeys extends string, TValues extends TKeys[]>(id: s
  *   })
  * )
  */
-declare function nullable<T>(schema: ASchema<T>, opts?: ASchemaOptions): ASchema<T | null>;
+declare function nullable<T>(schema: ASchema<T>, opts?: ASchemaOptions): ASchemaWithAdapters<T | null>;
 /**
  * Make an object field optional
  *
@@ -156,7 +174,7 @@ declare function nullable<T>(schema: ASchema<T>, opts?: ASchemaOptions): ASchema
  * })
  */
 declare function optional<T>(input: ASchema<T>, opts?: ASchemaOptions): ASchema<T | undefined>;
-declare function clone<T>(input: ASchema<T>, opts?: ASchemaOptions): ASchema<T>;
+declare function clone<T>(input: ASchema<T>, opts?: ASchemaOptions): ASchemaWithAdapters<T>;
 
 /**
  * Alias for float64 as that is the only number type that Javascript uses
@@ -165,17 +183,17 @@ declare function clone<T>(input: ASchema<T>, opts?: ASchemaOptions): ASchema<T>;
  * const Schema = a.number()
  * a.validate(Schema, 1.5) // true
  */
-declare function number(opts?: ASchemaOptions): AScalarSchema<"float64", number>;
-declare function float32(opts?: ASchemaOptions): AScalarSchema<"float32", number>;
-declare function float64(opts?: ASchemaOptions): AScalarSchema<"float64", number>;
-declare function int8(opts?: ASchemaOptions): AScalarSchema<"int8", number>;
-declare function uint8(opts?: ASchemaOptions): AScalarSchema<"uint8", number>;
-declare function int16(opts?: ASchemaOptions): AScalarSchema<"int16", number>;
-declare function uint16(opts?: ASchemaOptions): AScalarSchema<"uint16", number>;
-declare function int32(opts?: ASchemaOptions): AScalarSchema<"int32", number>;
-declare function uint32(opts?: ASchemaOptions): AScalarSchema<"uint32", number>;
-declare function int64(opts?: ASchemaOptions): AScalarSchema<'int64', bigint>;
-declare function uint64(opts?: ASchemaOptions): AScalarSchema<'uint64', bigint>;
+declare function number(opts?: ASchemaOptions): AScalarSchemaWithAdapters<"float64", number>;
+declare function float32(opts?: ASchemaOptions): AScalarSchemaWithAdapters<"float32", number>;
+declare function float64(opts?: ASchemaOptions): AScalarSchemaWithAdapters<"float64", number>;
+declare function int8(opts?: ASchemaOptions): AScalarSchemaWithAdapters<"int8", number>;
+declare function uint8(opts?: ASchemaOptions): AScalarSchemaWithAdapters<"uint8", number>;
+declare function int16(opts?: ASchemaOptions): AScalarSchemaWithAdapters<"int16", number>;
+declare function uint16(opts?: ASchemaOptions): AScalarSchemaWithAdapters<"uint16", number>;
+declare function int32(opts?: ASchemaOptions): AScalarSchemaWithAdapters<"int32", number>;
+declare function uint32(opts?: ASchemaOptions): AScalarSchemaWithAdapters<"uint32", number>;
+declare function int64(opts?: ASchemaOptions): AScalarSchemaWithAdapters<'int64', bigint>;
+declare function uint64(opts?: ASchemaOptions): AScalarSchemaWithAdapters<'uint64', bigint>;
 
 /**
  * Create an object schema
@@ -188,10 +206,10 @@ declare function uint64(opts?: ASchemaOptions): AScalarSchema<'uint64', bigint>;
  * a.validate(Schema, {foo: "", bar: 0}) // true
  * a.validate(Schema, {foo: null, bar: 0}) // false
  */
-declare function object<TInput extends Record<any, ASchema> = any, TAdditionalProps extends boolean = false>(input: TInput, opts?: AObjectSchemaOptions<TAdditionalProps>): AObjectSchema<InferObjectOutput<TInput>, TAdditionalProps>;
-declare function object<TInput extends Record<any, ASchema> = any, TAdditionalProps extends boolean = false>(id: string, input: TInput): AObjectSchema<InferObjectOutput<TInput>, TAdditionalProps>;
-declare function parseObjectSchema<T>(schema: AObjectSchema<T>, input: unknown, data: ValidationContext, coerce?: boolean): T | undefined;
-declare function validateObjectSchema(schema: AObjectSchema, input: unknown): boolean;
+declare function object<TInput extends Record<any, ASchema> = any, TAdditionalProps extends boolean = false>(input: TInput, opts?: AObjectSchemaOptions<TAdditionalProps>): AObjectSchemaWithAdapters<InferObjectOutput<TInput>, TAdditionalProps>;
+declare function object<TInput extends Record<any, ASchema> = any, TAdditionalProps extends boolean = false>(id: string, input: TInput): AObjectSchemaWithAdapters<InferObjectOutput<TInput>, TAdditionalProps>;
+declare function decodeObjectSchema<T>(schema: AObjectSchemaWithAdapters<T>, input: unknown, context: ValidationContext, coerce?: boolean): T | undefined;
+declare function validateObjectSchema(schema: AObjectSchemaWithAdapters, input: unknown): boolean;
 /**
  * Create an object schema using a subset of keys from another object schema
  *
@@ -204,7 +222,7 @@ declare function validateObjectSchema(schema: AObjectSchema, input: unknown): bo
  *
  * const SubObject = a.pick(User, ['foo']) // { foo: string; }
  */
-declare function pick<TSchema extends AObjectSchema<any, any> = any, TKeys extends keyof InferType<TSchema> = any, TAdditionalProps extends boolean = false>(inputSchema: TSchema, keys: TKeys[], options?: AObjectSchemaOptions<TAdditionalProps>): AObjectSchema<Pick<InferType<TSchema>, TKeys>, TAdditionalProps>;
+declare function pick<TSchema extends AObjectSchemaWithAdapters<any, any> = any, TKeys extends keyof InferType<TSchema> = any, TStrict extends boolean = false>(inputSchema: TSchema, keys: TKeys[], options?: AObjectSchemaOptions<TStrict>): AObjectSchemaWithAdapters<Pick<InferType<TSchema>, TKeys>, TStrict>;
 /**
  * Create an object schema by omitting keys from another object schema
  *
@@ -217,10 +235,10 @@ 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[], options?: AObjectSchemaOptions<TAdditionalProps>): AObjectSchema<Omit<InferType<TSchema>, TKeys>, TAdditionalProps>;
-declare function serializeObject(schema: AObjectSchema, input: any, data: ValidationContext): string;
-declare function extend<TBaseSchema extends AObjectSchema<any, any> = any, TSchema extends AObjectSchema<any, any> = any, TAdditionalProps extends boolean = false>(baseSchema: TBaseSchema, inputSchema: TSchema, options?: AObjectSchemaOptions<TAdditionalProps>): AObjectSchema<ResolveObject<InferType<TBaseSchema> & InferType<TSchema>>, TAdditionalProps>;
-declare function partial<TSchema extends AObjectSchema<any, any> = any, TAdditionalProps extends boolean = false>(schema: TSchema, options?: AObjectSchemaOptions<TAdditionalProps>): AObjectSchema<Partial<InferType<TSchema>>, TAdditionalProps>;
+declare function omit<TSchema extends AObjectSchemaWithAdapters<any, any> = any, TKeys extends keyof InferType<TSchema> = any, TAdditionalProps extends boolean = false>(inputSchema: TSchema, keys: TKeys[], options?: AObjectSchemaOptions<TAdditionalProps>): AObjectSchemaWithAdapters<Omit<InferType<TSchema>, TKeys>, TAdditionalProps>;
+declare function serializeObject(schema: AObjectSchemaWithAdapters, input: any, context: ValidationContext): string;
+declare function extend<TBaseSchema extends AObjectSchemaWithAdapters<any, any> = any, TSchema extends AObjectSchemaWithAdapters<any, any> = any, TAdditionalProps extends boolean = false>(baseSchema: TBaseSchema, inputSchema: TSchema, options?: AObjectSchemaOptions<TAdditionalProps>): AObjectSchemaWithAdapters<ResolveObject<InferType<TBaseSchema> & InferType<TSchema>>, TAdditionalProps>;
+declare function partial<TSchema extends AObjectSchemaWithAdapters<any, any> = any, TAdditionalProps extends boolean = false>(schema: TSchema, options?: AObjectSchemaOptions<TAdditionalProps>): AObjectSchemaWithAdapters<Partial<InferType<TSchema>>, TAdditionalProps>;
 
 /**
  * Create a schema for a record with strings keys
@@ -239,9 +257,9 @@ declare function partial<TSchema extends AObjectSchema<any, any> = any, TAdditio
  * )
  * a.validate(ObjectRecord, {foo: {id: "1", date: new Date()}}) // true
  */
-declare function record<TInnerSchema extends ASchema<any>>(schema: TInnerSchema, opts?: ASchemaOptions): ARecordSchema<TInnerSchema>;
+declare function record<TInnerSchema extends ASchema<any>>(schema: TInnerSchema, opts?: ASchemaOptions): ARecordSchemaWithAdapters<TInnerSchema>;
 
-type RecursiveCallback<T> = (self: ARefSchema<T>) => AObjectSchema<T> | ADiscriminatorSchema<T>;
+type RecursiveCallback<T> = (self: ARefSchema<T>) => AObjectSchemaWithAdapters<T> | ADiscriminatorSchemaWithAdapters<T>;
 /**
  * @example
  * ```ts
@@ -258,7 +276,7 @@ type RecursiveCallback<T> = (self: ARefSchema<T>) => AObjectSchema<T> | ADiscrim
  * );
  * ```
  */
-declare function recursive<T = any>(callback: RecursiveCallback<T>, metadata?: ASchemaOptions): AObjectSchema<T> | ADiscriminatorSchema<T>;
+declare function recursive<T = any>(callback: RecursiveCallback<T>, metadata?: ASchemaOptions): AObjectSchemaWithAdapters<T> | ADiscriminatorSchemaWithAdapters<T>;
 /**
  * Recursive ID Shorthand
  *
@@ -278,7 +296,7 @@ declare function recursive<T = any>(callback: RecursiveCallback<T>, metadata?: A
  * );
  * ```
  */
-declare function recursive<T = any>(id: string, callback: RecursiveCallback<T>): AObjectSchema<T> | ADiscriminatorSchema<T>;
+declare function recursive<T = any>(id: string, callback: RecursiveCallback<T>): AObjectSchemaWithAdapters<T> | ADiscriminatorSchemaWithAdapters<T>;
 
 /**
  * @example
@@ -286,7 +304,7 @@ declare function recursive<T = any>(id: string, callback: RecursiveCallback<T>):
  * a.validate(StringSchema, "hello world") // true
  * a.validate(StringSchema, 10) // false
  */
-declare function string(opts?: ASchemaOptions): AScalarSchema<'string', string>;
+declare function string(opts?: ASchemaOptions): AScalarSchemaWithAdapters<'string', string>;
 declare function serializeString(input: string): string;
 declare const STR_ESCAPE: RegExp;
 declare function serializeSmallString(input: string): string;
@@ -298,13 +316,42 @@ declare function serializeSmallString(input: string): string;
  * const Schema = a.timestamp();
  * a.validate(Schema, new Date()) // true
  */
-declare function timestamp(opts?: ASchemaOptions): AScalarSchema<'timestamp', Date>;
+declare function timestamp(opts?: ASchemaOptions): AScalarSchemaWithAdapters<'timestamp', Date>;
+
+declare function sanitizeJson(json: string): string;
+/**
+ * Check if the input matches the specified schema. This is a type guard.
+ */
+declare function validate<T = any>(schema: ASchema<T>, input: unknown): input is T;
+/**
+ * Parse a JSON string or the result of JSON.parse() without throwing an error.
+ */
+declare function parse<T = any>(schema: ASchema<T>, input: unknown): Result<T>;
+/**
+ * Parse a JSON string or the result of JSON.parse(). Throws a [ValidationException] if parsing fails.
+ */
+declare function parseUnsafe<T = any>(schema: ASchema<T>, input: unknown): T;
+/**
+ * Convert a value into the specified schema without throwing an error.
+ */
+declare function coerce<T = any>(schema: ASchema<T>, input: unknown): Result<T>;
+/**
+ * Try to convert input to match the specified schema. Throws a [ValidationException] if conversion fails.
+ */
+declare function coerceUnsafe<T = any>(schema: ASchema<T>, input: unknown): T;
+/**
+ * Serialize a value into a JSON string.
+ */
+declare function serialize<T = any>(schema: ASchema<T>, input: T): Result<string>;
+declare function serializeUnsafe<T = any>(schema: ASchema<T>, input: T): string;
+declare function errors(schema: ASchema, input: unknown, exitOnFirstError?: boolean): ValueError[];
 
 declare const _namespace_any: typeof any;
 declare const _namespace_array: typeof array;
 declare const _namespace_boolean: typeof boolean;
 declare const _namespace_clone: typeof clone;
 declare const _namespace_coerce: typeof coerce;
+declare const _namespace_coerceUnsafe: typeof coerceUnsafe;
 declare const _namespace_compile: typeof compile;
 declare const _namespace_discriminator: typeof discriminator;
 declare const _namespace_enumerator: typeof enumerator;
@@ -322,13 +369,13 @@ declare const _namespace_object: typeof object;
 declare const _namespace_omit: typeof omit;
 declare const _namespace_optional: typeof optional;
 declare const _namespace_parse: typeof parse;
+declare const _namespace_parseUnsafe: typeof parseUnsafe;
 declare const _namespace_partial: typeof partial;
 declare const _namespace_pick: typeof pick;
 declare const _namespace_record: typeof record;
 declare const _namespace_recursive: typeof recursive;
-declare const _namespace_safeCoerce: typeof safeCoerce;
-declare const _namespace_safeParse: typeof safeParse;
 declare const _namespace_serialize: typeof serialize;
+declare const _namespace_serializeUnsafe: typeof serializeUnsafe;
 declare const _namespace_string: typeof string;
 declare const _namespace_stringEnum: typeof stringEnum;
 declare const _namespace_timestamp: typeof timestamp;
@@ -338,13 +385,9 @@ declare const _namespace_uint64: typeof uint64;
 declare const _namespace_uint8: typeof uint8;
 declare const _namespace_validate: typeof validate;
 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 };
+  export { _namespace_any as any, _namespace_array as array, _namespace_boolean as boolean, _namespace_clone as clone, _namespace_coerce as coerce, _namespace_coerceUnsafe as coerceUnsafe, _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_parseUnsafe as parseUnsafe, _namespace_partial as partial, _namespace_pick as pick, _namespace_record as record, _namespace_recursive as recursive, _namespace_serialize as serialize, _namespace_serializeUnsafe as serializeUnsafe, _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 };
 }
 
-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;
 declare const uint8Min = 0;
@@ -362,10 +405,4 @@ declare const int64Max: bigint;
 declare const uint64Min: bigint;
 declare const uint64Max: bigint;
 
-declare function createStandardSchemaProperty<T>(validate: (input: unknown) => input is T, parse: (input: unknown, ctx: ValidationContext) => T | undefined): StandardSchemaV1<T>['~standard'];
-/**
- * Ensure that non ATD compliant properties get hidden when serialized to JSON
- */
-declare function hideInvalidProperties(schema: ASchema): void;
-
-export { AArraySchema, ADiscriminatorSchema, AObjectSchema, AObjectSchemaOptions, ARecordSchema, ARefSchema, AScalarSchema, ASchema, ASchemaOptions, AStringEnumSchema, type CompiledValidator, InferObjectOutput, InferSubType, InferType, ResolveObject, STR_ESCAPE, SafeResult, type ValidationAdapter, ValidationContext, _namespace as a, any, array, boolean, clone, coerce, compile, createStandardSchemaProperty, discriminator, enumerator, errors, extend, float32, float64, getCompiledParser, getCompiledSerializer, createParsingTemplate as getSchemaParsingCode, createSerializationV2Template as getSchemaSerializationCode, createValidationTemplate as getSchemaValidationCode, hideInvalidProperties, int16, int16Max, int16Min, int32, int32Max, int32Min, int64, int64Max, int64Min, int8, int8Max, int8Min, isAdaptedSchema, nullable, number, object, omit, optional, parse, parseObjectSchema, partial, pick, record, recursive, safeCoerce, safeParse, serialize, serializeObject, serializeSmallString, serializeString, string, stringEnum, timestamp, uint16, uint16Max, uint16Min, uint32, uint32Max, uint32Min, uint64, uint64Max, uint64Min, uint8, uint8Max, uint8Min, validate, validateObjectSchema, validatorFromAdaptedSchema };
+export { AArraySchema, ADiscriminatorSchemaWithAdapters, AObjectSchema, AObjectSchemaOptions, AObjectSchemaWithAdapters, ARecordSchemaWithAdapters, ARefSchema, AScalarSchemaWithAdapters, ASchema, ASchemaOptions, ASchemaStrict, ASchemaWithAdapters, AStringEnumSchemaWithAdapters, type CompiledValidator, InferObjectOutput, InferSubType, InferType, ResolveObject, Result, STR_ESCAPE, SchemaValidator, ValidationContext, ValueError, WithAdapters, _namespace as a, any, array, boolean, clone, coerce, coerceUnsafe, compile, decodeObjectSchema, discriminator, enumerator, errors, extend, float32, float64, getCompiledParser, getCompiledSerializer, createParsingTemplate as getSchemaDecodingCode, createSerializationV2Template as getSchemaSerializationCode, createValidationTemplate as getSchemaValidationCode, int16, int16Max, int16Min, int32, int32Max, int32Min, int64, int64Max, int64Min, int8, int8Max, int8Min, nullable, number, object, omit, optional, parse, parseUnsafe, partial, pick, record, recursive, sanitizeJson, serialize, serializeObject, serializeSmallString, serializeString, serializeUnsafe, string, stringEnum, timestamp, uint16, uint16Max, uint16Min, uint32, uint32Max, uint32Min, uint64, uint64Max, uint64Min, uint8, uint8Max, uint8Min, validate, validateObjectSchema };