@arrirpc/schema 0.45.0

package/dist/shared/schema.b7c77149.d.cts

@@ -0,0 +1,167 @@
+import { Type } from 'jtd-utils';
+
+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(). Throws a ValidationError if parsing fails.
+ */
+declare function parse<T = any>(schema: ASchema<T>, input: unknown): T;
+/**
+ * Parse a value without throwing an error.
+ */
+declare function safeParse<T = any>(schema: ASchema<T>, input: unknown): SafeResult<T>;
+/**
+ * Try to convert input to match the specified schema. Throws a ValidationError if conversion fails.
+ */
+declare function coerce<T = any>(schema: ASchema<T>, input: unknown): T;
+type SafeResult<T> = {
+    success: true;
+    value: T;
+} | {
+    success: false;
+    error: ValidationError;
+};
+/**
+ * Convert a value into the specified schema without throwing an error.
+ */
+declare function safeCoerce<T = any>(schema: ASchema<T>, input: unknown): SafeResult<T>;
+/**
+ * Serialize a value into a JSON string
+ */
+declare function serialize<T = any>(schema: ASchema<T>, input: T): string;
+declare function errors(schema: ASchema, input: unknown): ValueError[];
+interface ValueError {
+    instancePath: string;
+    schemaPath: string;
+    message?: string;
+    data?: any;
+}
+declare class ValidationError extends Error {
+    errors: ValueError[];
+    constructor(options: {
+        message: string;
+        errors: ValueError[];
+    });
+}
+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 {
+    instancePath: string;
+    schemaPath: string;
+    errors: ValueError[];
+    discriminatorKey?: string;
+    discriminatorValue?: string;
+}
+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;
+    validate: (input: unknown) => input is T;
+}
+interface SchemaMetadata<T> {
+    [key: string]: any;
+    id?: string;
+    description?: string;
+    isDeprecated?: boolean;
+    [SCHEMA_METADATA]: SchemaValidator<T>;
+}
+interface ASchema<T = any> {
+    metadata: SchemaMetadata<T>;
+    nullable?: boolean;
+}
+declare function isASchema(input: unknown): input is ASchema;
+interface ASchemaOptions {
+    id?: string;
+    description?: string;
+    isDeprecated?: boolean;
+}
+type Resolve<T> = T;
+type ResolveObject<T> = Resolve<{
+    [k in keyof T]: T[k];
+}>;
+type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+type InferType<TInput extends ASchema<any>> = Resolve<TInput["metadata"][typeof SCHEMA_METADATA]["output"]>;
+/**
+ * Infer a specific subtype of a discriminated union.
+ * In order for this to work you must first infer the union type using `a.infer`
+ * Then pass the type result to this
+ *
+ * @example
+ * ```ts
+ * const Shape = a.discriminator(
+ *   "type",
+ *   {
+ *     "RECTANGLE": a.object({
+ *       width: a.number(),
+ *       height: a.number(),
+ *     }),
+ *     "CIRCLE": a.object({
+ *       radius: a.number(),
+ *      }),
+ *   }
+ * );
+ *
+ * type Shape = a.infer<typeof Shape>;
+ * // { type: "RECTANGLE"; width: number; height: number } | { type: "CIRCLE"; radius: number; }
+ *
+ * type ShapeTypeRectangle = a.infer<Shape, "type", "RECTANGLE">
+ * // { type: "RECTANGLE"; width: number; height: number; }
+ *
+ * type ShapeTypeCircle = a.infer<Shape, "type", "CIRCLE">
+ * // { type: "CIRCLE"; radius: number; }
+ * ```
+ */
+type InferSubType<TUnion extends Record<string, any>, TKey extends keyof TUnion, TVal extends TUnion[TKey]> = TUnion extends Record<TKey, TVal> ? TUnion : never;
+interface AScalarSchema<T extends Type | NumberType = any, TVal = any> extends ASchema<TVal> {
+    type: T;
+}
+declare function isAScalarSchema(input: unknown): input is AScalarSchema;
+declare const NumberTypeValues: readonly ["float32", "float64", "int8", "int16", "int32", "int64", "uint8", "uint16", "uint32", "uint64"];
+type NumberType = (typeof NumberTypeValues)[number];
+interface AArraySchema<TInnerSchema extends ASchema<any> = any> extends ASchema<Array<InferType<TInnerSchema>>> {
+    elements: TInnerSchema;
+}
+declare function isAAraySchema(input: unknown): input is AArraySchema;
+interface AStringEnumSchema<TValues extends string[]> extends ASchema<TValues[number]> {
+    enum: TValues;
+}
+declare function isAStringEnumSchema(input: unknown): input is AStringEnumSchema<any>;
+interface ADiscriminatorSchema<T> extends ASchema<T> {
+    discriminator: string;
+    mapping: Record<string, AObjectSchema<any>>;
+}
+declare function isADiscriminatorSchema(input: unknown): input is ADiscriminatorSchema<any>;
+interface ARecordSchema<TInnerSchema extends ASchema<any>, TNullable extends boolean = false> extends ASchema<MaybeNullable<Record<string, InferType<TInnerSchema>>, TNullable>> {
+    values: TInnerSchema;
+}
+declare function isARecordSchema(input: unknown): input is ARecordSchema<any, any>;
+interface AObjectSchema<TVal = any, TAllowAdditionalProperties extends boolean = false> extends ASchema<TVal> {
+    properties: Record<string, ASchema>;
+    optionalProperties?: Record<string, ASchema>;
+    additionalProperties?: TAllowAdditionalProperties;
+}
+declare function isAObjectSchema(input: unknown): input is AObjectSchema;
+interface AObjectSchemaOptions<TAdditionalProps extends boolean = false> extends ASchemaOptions {
+    /**
+     * Allow this object to include additional properties not specified here
+     */
+    additionalProperties?: TAdditionalProps;
+}
+type InferObjectOutput<TInput = any, TAdditionalProps extends boolean = false> = TAdditionalProps extends true ? ResolveObject<InferObjectRawType<TInput>> & Record<any, any> : ResolveObject<InferObjectRawType<TInput>>;
+type InferObjectRawType<TInput> = TInput extends Record<any, any> ? {
+    [TKey in keyof TInput]: TInput[TKey]["metadata"][typeof SCHEMA_METADATA]["optional"] extends true ? TInput[TKey]["metadata"][typeof SCHEMA_METADATA]["output"] | undefined : TInput[TKey]["metadata"][typeof SCHEMA_METADATA]["output"];
+} : never;
+declare function isObject(input: unknown): input is Record<any, any>;
+interface ARefSchema<T> extends ASchema<T> {
+    ref: string;
+}
+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 };

package/dist/shared/schema.b7c77149.d.mts

@@ -0,0 +1,167 @@
+import { Type } from 'jtd-utils';
+
+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(). Throws a ValidationError if parsing fails.
+ */
+declare function parse<T = any>(schema: ASchema<T>, input: unknown): T;
+/**
+ * Parse a value without throwing an error.
+ */
+declare function safeParse<T = any>(schema: ASchema<T>, input: unknown): SafeResult<T>;
+/**
+ * Try to convert input to match the specified schema. Throws a ValidationError if conversion fails.
+ */
+declare function coerce<T = any>(schema: ASchema<T>, input: unknown): T;
+type SafeResult<T> = {
+    success: true;
+    value: T;
+} | {
+    success: false;
+    error: ValidationError;
+};
+/**
+ * Convert a value into the specified schema without throwing an error.
+ */
+declare function safeCoerce<T = any>(schema: ASchema<T>, input: unknown): SafeResult<T>;
+/**
+ * Serialize a value into a JSON string
+ */
+declare function serialize<T = any>(schema: ASchema<T>, input: T): string;
+declare function errors(schema: ASchema, input: unknown): ValueError[];
+interface ValueError {
+    instancePath: string;
+    schemaPath: string;
+    message?: string;
+    data?: any;
+}
+declare class ValidationError extends Error {
+    errors: ValueError[];
+    constructor(options: {
+        message: string;
+        errors: ValueError[];
+    });
+}
+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 {
+    instancePath: string;
+    schemaPath: string;
+    errors: ValueError[];
+    discriminatorKey?: string;
+    discriminatorValue?: string;
+}
+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;
+    validate: (input: unknown) => input is T;
+}
+interface SchemaMetadata<T> {
+    [key: string]: any;
+    id?: string;
+    description?: string;
+    isDeprecated?: boolean;
+    [SCHEMA_METADATA]: SchemaValidator<T>;
+}
+interface ASchema<T = any> {
+    metadata: SchemaMetadata<T>;
+    nullable?: boolean;
+}
+declare function isASchema(input: unknown): input is ASchema;
+interface ASchemaOptions {
+    id?: string;
+    description?: string;
+    isDeprecated?: boolean;
+}
+type Resolve<T> = T;
+type ResolveObject<T> = Resolve<{
+    [k in keyof T]: T[k];
+}>;
+type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+type InferType<TInput extends ASchema<any>> = Resolve<TInput["metadata"][typeof SCHEMA_METADATA]["output"]>;
+/**
+ * Infer a specific subtype of a discriminated union.
+ * In order for this to work you must first infer the union type using `a.infer`
+ * Then pass the type result to this
+ *
+ * @example
+ * ```ts
+ * const Shape = a.discriminator(
+ *   "type",
+ *   {
+ *     "RECTANGLE": a.object({
+ *       width: a.number(),
+ *       height: a.number(),
+ *     }),
+ *     "CIRCLE": a.object({
+ *       radius: a.number(),
+ *      }),
+ *   }
+ * );
+ *
+ * type Shape = a.infer<typeof Shape>;
+ * // { type: "RECTANGLE"; width: number; height: number } | { type: "CIRCLE"; radius: number; }
+ *
+ * type ShapeTypeRectangle = a.infer<Shape, "type", "RECTANGLE">
+ * // { type: "RECTANGLE"; width: number; height: number; }
+ *
+ * type ShapeTypeCircle = a.infer<Shape, "type", "CIRCLE">
+ * // { type: "CIRCLE"; radius: number; }
+ * ```
+ */
+type InferSubType<TUnion extends Record<string, any>, TKey extends keyof TUnion, TVal extends TUnion[TKey]> = TUnion extends Record<TKey, TVal> ? TUnion : never;
+interface AScalarSchema<T extends Type | NumberType = any, TVal = any> extends ASchema<TVal> {
+    type: T;
+}
+declare function isAScalarSchema(input: unknown): input is AScalarSchema;
+declare const NumberTypeValues: readonly ["float32", "float64", "int8", "int16", "int32", "int64", "uint8", "uint16", "uint32", "uint64"];
+type NumberType = (typeof NumberTypeValues)[number];
+interface AArraySchema<TInnerSchema extends ASchema<any> = any> extends ASchema<Array<InferType<TInnerSchema>>> {
+    elements: TInnerSchema;
+}
+declare function isAAraySchema(input: unknown): input is AArraySchema;
+interface AStringEnumSchema<TValues extends string[]> extends ASchema<TValues[number]> {
+    enum: TValues;
+}
+declare function isAStringEnumSchema(input: unknown): input is AStringEnumSchema<any>;
+interface ADiscriminatorSchema<T> extends ASchema<T> {
+    discriminator: string;
+    mapping: Record<string, AObjectSchema<any>>;
+}
+declare function isADiscriminatorSchema(input: unknown): input is ADiscriminatorSchema<any>;
+interface ARecordSchema<TInnerSchema extends ASchema<any>, TNullable extends boolean = false> extends ASchema<MaybeNullable<Record<string, InferType<TInnerSchema>>, TNullable>> {
+    values: TInnerSchema;
+}
+declare function isARecordSchema(input: unknown): input is ARecordSchema<any, any>;
+interface AObjectSchema<TVal = any, TAllowAdditionalProperties extends boolean = false> extends ASchema<TVal> {
+    properties: Record<string, ASchema>;
+    optionalProperties?: Record<string, ASchema>;
+    additionalProperties?: TAllowAdditionalProperties;
+}
+declare function isAObjectSchema(input: unknown): input is AObjectSchema;
+interface AObjectSchemaOptions<TAdditionalProps extends boolean = false> extends ASchemaOptions {
+    /**
+     * Allow this object to include additional properties not specified here
+     */
+    additionalProperties?: TAdditionalProps;
+}
+type InferObjectOutput<TInput = any, TAdditionalProps extends boolean = false> = TAdditionalProps extends true ? ResolveObject<InferObjectRawType<TInput>> & Record<any, any> : ResolveObject<InferObjectRawType<TInput>>;
+type InferObjectRawType<TInput> = TInput extends Record<any, any> ? {
+    [TKey in keyof TInput]: TInput[TKey]["metadata"][typeof SCHEMA_METADATA]["optional"] extends true ? TInput[TKey]["metadata"][typeof SCHEMA_METADATA]["output"] | undefined : TInput[TKey]["metadata"][typeof SCHEMA_METADATA]["output"];
+} : never;
+declare function isObject(input: unknown): input is Record<any, any>;
+interface ARefSchema<T> extends ASchema<T> {
+    ref: string;
+}
+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 };

package/dist/shared/schema.b7c77149.d.ts

@@ -0,0 +1,167 @@
+import { Type } from 'jtd-utils';
+
+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(). Throws a ValidationError if parsing fails.
+ */
+declare function parse<T = any>(schema: ASchema<T>, input: unknown): T;
+/**
+ * Parse a value without throwing an error.
+ */
+declare function safeParse<T = any>(schema: ASchema<T>, input: unknown): SafeResult<T>;
+/**
+ * Try to convert input to match the specified schema. Throws a ValidationError if conversion fails.
+ */
+declare function coerce<T = any>(schema: ASchema<T>, input: unknown): T;
+type SafeResult<T> = {
+    success: true;
+    value: T;
+} | {
+    success: false;
+    error: ValidationError;
+};
+/**
+ * Convert a value into the specified schema without throwing an error.
+ */
+declare function safeCoerce<T = any>(schema: ASchema<T>, input: unknown): SafeResult<T>;
+/**
+ * Serialize a value into a JSON string
+ */
+declare function serialize<T = any>(schema: ASchema<T>, input: T): string;
+declare function errors(schema: ASchema, input: unknown): ValueError[];
+interface ValueError {
+    instancePath: string;
+    schemaPath: string;
+    message?: string;
+    data?: any;
+}
+declare class ValidationError extends Error {
+    errors: ValueError[];
+    constructor(options: {
+        message: string;
+        errors: ValueError[];
+    });
+}
+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 {
+    instancePath: string;
+    schemaPath: string;
+    errors: ValueError[];
+    discriminatorKey?: string;
+    discriminatorValue?: string;
+}
+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;
+    validate: (input: unknown) => input is T;
+}
+interface SchemaMetadata<T> {
+    [key: string]: any;
+    id?: string;
+    description?: string;
+    isDeprecated?: boolean;
+    [SCHEMA_METADATA]: SchemaValidator<T>;
+}
+interface ASchema<T = any> {
+    metadata: SchemaMetadata<T>;
+    nullable?: boolean;
+}
+declare function isASchema(input: unknown): input is ASchema;
+interface ASchemaOptions {
+    id?: string;
+    description?: string;
+    isDeprecated?: boolean;
+}
+type Resolve<T> = T;
+type ResolveObject<T> = Resolve<{
+    [k in keyof T]: T[k];
+}>;
+type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+type InferType<TInput extends ASchema<any>> = Resolve<TInput["metadata"][typeof SCHEMA_METADATA]["output"]>;
+/**
+ * Infer a specific subtype of a discriminated union.
+ * In order for this to work you must first infer the union type using `a.infer`
+ * Then pass the type result to this
+ *
+ * @example
+ * ```ts
+ * const Shape = a.discriminator(
+ *   "type",
+ *   {
+ *     "RECTANGLE": a.object({
+ *       width: a.number(),
+ *       height: a.number(),
+ *     }),
+ *     "CIRCLE": a.object({
+ *       radius: a.number(),
+ *      }),
+ *   }
+ * );
+ *
+ * type Shape = a.infer<typeof Shape>;
+ * // { type: "RECTANGLE"; width: number; height: number } | { type: "CIRCLE"; radius: number; }
+ *
+ * type ShapeTypeRectangle = a.infer<Shape, "type", "RECTANGLE">
+ * // { type: "RECTANGLE"; width: number; height: number; }
+ *
+ * type ShapeTypeCircle = a.infer<Shape, "type", "CIRCLE">
+ * // { type: "CIRCLE"; radius: number; }
+ * ```
+ */
+type InferSubType<TUnion extends Record<string, any>, TKey extends keyof TUnion, TVal extends TUnion[TKey]> = TUnion extends Record<TKey, TVal> ? TUnion : never;
+interface AScalarSchema<T extends Type | NumberType = any, TVal = any> extends ASchema<TVal> {
+    type: T;
+}
+declare function isAScalarSchema(input: unknown): input is AScalarSchema;
+declare const NumberTypeValues: readonly ["float32", "float64", "int8", "int16", "int32", "int64", "uint8", "uint16", "uint32", "uint64"];
+type NumberType = (typeof NumberTypeValues)[number];
+interface AArraySchema<TInnerSchema extends ASchema<any> = any> extends ASchema<Array<InferType<TInnerSchema>>> {
+    elements: TInnerSchema;
+}
+declare function isAAraySchema(input: unknown): input is AArraySchema;
+interface AStringEnumSchema<TValues extends string[]> extends ASchema<TValues[number]> {
+    enum: TValues;
+}
+declare function isAStringEnumSchema(input: unknown): input is AStringEnumSchema<any>;
+interface ADiscriminatorSchema<T> extends ASchema<T> {
+    discriminator: string;
+    mapping: Record<string, AObjectSchema<any>>;
+}
+declare function isADiscriminatorSchema(input: unknown): input is ADiscriminatorSchema<any>;
+interface ARecordSchema<TInnerSchema extends ASchema<any>, TNullable extends boolean = false> extends ASchema<MaybeNullable<Record<string, InferType<TInnerSchema>>, TNullable>> {
+    values: TInnerSchema;
+}
+declare function isARecordSchema(input: unknown): input is ARecordSchema<any, any>;
+interface AObjectSchema<TVal = any, TAllowAdditionalProperties extends boolean = false> extends ASchema<TVal> {
+    properties: Record<string, ASchema>;
+    optionalProperties?: Record<string, ASchema>;
+    additionalProperties?: TAllowAdditionalProperties;
+}
+declare function isAObjectSchema(input: unknown): input is AObjectSchema;
+interface AObjectSchemaOptions<TAdditionalProps extends boolean = false> extends ASchemaOptions {
+    /**
+     * Allow this object to include additional properties not specified here
+     */
+    additionalProperties?: TAdditionalProps;
+}
+type InferObjectOutput<TInput = any, TAdditionalProps extends boolean = false> = TAdditionalProps extends true ? ResolveObject<InferObjectRawType<TInput>> & Record<any, any> : ResolveObject<InferObjectRawType<TInput>>;
+type InferObjectRawType<TInput> = TInput extends Record<any, any> ? {
+    [TKey in keyof TInput]: TInput[TKey]["metadata"][typeof SCHEMA_METADATA]["optional"] extends true ? TInput[TKey]["metadata"][typeof SCHEMA_METADATA]["output"] | undefined : TInput[TKey]["metadata"][typeof SCHEMA_METADATA]["output"];
+} : never;
+declare function isObject(input: unknown): input is Record<any, any>;
+interface ARefSchema<T> extends ASchema<T> {
+    ref: string;
+}
+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 };