@arrirpc/schema 0.45.0

package/dist/index.d.mts

@@ -0,0 +1,379 @@
+import { A as ASchemaOptions, a as ASchema, b as AArraySchema, c as AScalarSchema, d as AObjectSchema, e as ADiscriminatorSchema, I as InferType, R as ResolveObject, f as AStringEnumSchema, g as AObjectSchemaOptions, h as InferObjectOutput, V as ValidationData, i as ARecordSchema, j as ARefSchema, S as SafeResult, k as coerce, l as errors, m as InferSubType, p as parse, s as safeCoerce, n as safeParse, o as serialize, v as validate, q as SchemaValidator, r as SchemaMetadata, t as SCHEMA_METADATA } from './shared/schema.b7c77149.mjs';
+export { K as InferObjectRawType, M as MaybeNullable, D as NumberType, N as NumberTypeValues, P as PartialBy, B as Resolve, x as ValidationError, w as ValueError, E as isAAraySchema, G as isADiscriminatorSchema, J as isAObjectSchema, H as isARecordSchema, O as isARefSchema, C as isAScalarSchema, z as isASchema, F as isAStringEnumSchema, L as isObject, y as isValidationError, u as sanitizeJson } from './shared/schema.b7c77149.mjs';
+import { Schema } from 'jtd-utils';
+
+/**
+ * Create a schema that accepts anything
+ */
+declare function any(options?: ASchemaOptions): ASchema<any>;
+
+declare function array<TInnerSchema extends ASchema<any> = any>(schema: TInnerSchema, opts?: ASchemaOptions): AArraySchema<TInnerSchema>;
+
+/**
+ * @example
+ * const Schema = a.boolean();
+ * a.validate(Schema, true) // true;
+ * a.validate(Schema, false) // true;
+ */
+declare function boolean(opts?: ASchemaOptions): AScalarSchema<"boolean", boolean>;
+
+/**
+ * Create a discriminated union / tagged union
+ *
+ * This is an implementation of https://jsontypedef.com/docs/jtd-in-5-minutes/#discriminator-schemas
+ *
+ * @example
+ * const Schema = a.discriminator("eventType", {
+ *   CREATED: a.object({
+ *     id: a.string(),
+ *     createdAt: a.timestamp(),
+ *   }),
+ *   UPDATED: a.object({
+ *     id: a.string(),
+ *     createdAt: a.timestamp(),
+ *     updatedAt: a.timestamp(),
+ *   })
+ * })
+ * a.validate(Schema, {
+ *   eventType: "CREATED",
+ *   id: "1",
+ *   createdAt: new Date()
+ * }) // true
+ * a.validate(Schema, {
+ *   eventType: "UPDATED",
+ *   id: "2",
+ *   createdAt: new Date(),
+ *   updatedAt: new Date(),
+ * }) // true
+ * a.validate(Schema, {
+ *   eventType: "DELETED",
+ *   id: "1",
+ *   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>>>;
+type JoinedDiscriminator<TUnionKey extends string, TInput extends Record<string, AObjectSchema<any>>> = {
+    [TKey in keyof TInput]: InferType<TInput[TKey]> & Record<TUnionKey, TKey>;
+};
+type InferDiscriminatorType<TDiscriminatorKey extends string, TMapping extends Record<string, AObjectSchema<any>>, TJoinedMapping extends JoinedDiscriminator<TDiscriminatorKey, TMapping>> = ResolveObject<TJoinedMapping[keyof TJoinedMapping]>;
+
+declare const stringEnum: typeof enumerator;
+/**
+ * An enumeration of string values
+ *
+ * This is an implementation of:
+ * https://jsontypedef.com/docs/jtd-in-5-minutes/#enum-schemas
+ *
+ * @example
+ * const Schema = a.enumerator(["A", "B"])
+ * a.validate(Schema, "A") // true
+ * 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>;
+/**
+ * An enumeration of string values
+ *
+ * This is an implementation of:
+ * https://jsontypedef.com/docs/jtd-in-5-minutes/#enum-schemas
+ *
+ * @example
+ * const Schema = a.enumerator("Schema", ["A", "B"])
+ * a.validate(Schema, "A") // true
+ * 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>;
+
+/**
+ * Transforms a schema into a nullable type
+ *
+ * @example
+ * const NullableString = a.nullable(a.string())
+ * const NullableObject = a.nullable(
+ *   a.object({
+ *     id: a.string(),
+ *     description: a.nullable(a.string())
+ *   })
+ * )
+ */
+declare function nullable<T>(schema: ASchema<T>, opts?: ASchemaOptions): ASchema<T | null>;
+/**
+ * Make an object field optional
+ *
+ * This makes use of the "optionalProperties" property in JTD. See: https://jsontypedef.com/docs/jtd-in-5-minutes/#optional-properties
+ *
+ * @example
+ * const User = a.object({
+ *   id: a.string(),
+ *   // make the email field optional
+ *   email: a.optional(a.string())
+ * })
+ */
+declare function optional<T>(input: ASchema<T>, opts?: ASchemaOptions): ASchema<T | undefined>;
+declare function clone<T>(input: ASchema<T>, opts?: ASchemaOptions): ASchema<T>;
+
+/**
+ * Alias for float64 as that is the only number type that Javascript uses
+ *
+ * @example
+ * 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>;
+
+/**
+ * Create an object schema
+ *
+ * @example
+ * const Schema = a.object('Schema', {
+ *   foo: a.string(),
+ *   bar: a.number()
+ * });
+ * a.validate(Schema, {foo: "", bar: 0}) // true
+ * a.validate(Schema, {foo: null, bar: 0}) // false
+ */
+declare function object<TInput extends Record<any, ASchema> = any, TAdditionalProps extends boolean = false>(input: TInput, opts?: AObjectSchemaOptions<TAdditionalProps>): AObjectSchema<InferObjectOutput<TInput, TAdditionalProps>, TAdditionalProps>;
+declare function object<TInput extends Record<any, ASchema> = any, TAdditionalProps extends boolean = false>(id: string, input: TInput): AObjectSchema<InferObjectOutput<TInput, TAdditionalProps>, TAdditionalProps>;
+declare function parseObjectSchema<T>(schema: AObjectSchema<T>, input: unknown, data: ValidationData, 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
+ *
+ * @example
+ * const BaseObject = a.object({
+ *   foo: a.string(),
+ *   bar: a.string(),
+ *   baz: a.string(),
+ * }) // { foo: string; bar: string; baz: string; }
+ *
+ * const SubObject = a.pick(User, ['foo']) // { foo: string; }
+ */
+declare function pick<TSchema extends AObjectSchema<any, any> = any, TKeys extends keyof InferType<TSchema> = any, TAdditionalProps extends boolean = false>(inputSchema: TSchema, keys: TKeys[], opts?: AObjectSchemaOptions<TAdditionalProps>): AObjectSchema<Pick<InferType<TSchema>, TKeys>, TAdditionalProps>;
+/**
+ * Create an object schema by omitting keys from another object schema
+ *
+ * @example
+ * const BaseObject = a.object({
+ *   foo: a.string(),
+ *   bar: a.string(),
+ *   baz: a.string(),
+ * }); // { foo: string; bar: string; baz: string; }
+ *
+ * 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 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>;
+
+/**
+ * Create a schema for a record with strings keys
+ *
+ * @example
+ * const StringRecord = a.record(
+ *   a.string(),
+ * );
+ * a.validate(StringRecord, {foo: "bar"}) // true
+ *
+ * const ObjectRecord = a.record(
+ *   a.object({
+ *     id: a.string(),
+ *     date: a.timestamp(),
+ *   })
+ * )
+ * a.validate(ObjectRecord, {foo: {id: "1", date: new Date()}}) // true
+ */
+declare function record<TInnerSchema extends ASchema<any>>(schema: TInnerSchema, opts?: ASchemaOptions): ARecordSchema<TInnerSchema>;
+
+type RecursiveCallback<T> = (self: ARefSchema<T>) => AObjectSchema<T> | ADiscriminatorSchema<T>;
+/**
+ * @example
+ * ```ts
+ * type BinaryTree = {
+ *   left: BinaryTree | null;
+ *   right: BinaryTree | null;
+ * }
+ *
+ * const BinaryTree = a.recursive<BinaryTree>(
+ *   (self) => a.object({
+ *     left: a.nullable(self),
+ *     right: a.nullable(self),
+ *   })
+ * );
+ * ```
+ */
+declare function recursive<T = any>(callback: RecursiveCallback<T>, metadata?: ASchemaOptions): AObjectSchema<T> | ADiscriminatorSchema<T>;
+/**
+ * Recursive ID Shorthand
+ *
+ * @example
+ * ```ts
+ * type BinaryTree = {
+ *   left: BinaryTree | null;
+ *   right: BinaryTree | null;
+ * }
+ *
+ * const BinaryTree = a.recursive<BinaryTree>(
+ *   "BinaryTree",
+ *   (self) => a.object({
+ *     left: a.nullable(self),
+ *     right: a.nullable(self),
+ *   })
+ * );
+ * ```
+ */
+declare function recursive<T = any>(id: string, callback: RecursiveCallback<T>): AObjectSchema<T> | ADiscriminatorSchema<T>;
+
+/**
+ * @example
+ * const StringSchema = a.string();
+ * a.validate(StringSchema, "hello world") // true
+ * a.validate(StringSchema, 10) // false
+ */
+declare function string(opts?: ASchemaOptions): AScalarSchema<"string", string>;
+declare function serializeSmallString(input: string): string;
+
+/**
+ * Create a Date schema
+ *
+ * @example
+ * const Schema = a.timestamp();
+ * a.validate(Schema, new Date()) // true
+ */
+declare function timestamp(opts?: ASchemaOptions): AScalarSchema<"timestamp", Date>;
+
+declare function createParsingTemplate(input: string, schema: Schema): string;
+
+declare function createSerializationV2Template(inputName: string, schema: Schema): string;
+
+declare function createValidationTemplate(inputName: string, schema: ASchema<any>): string;
+
+interface CompiledValidator<TSchema extends ASchema<any>> {
+    /**
+     * Determine if a type matches a schema. This is a type guard.
+     */
+    validate: (input: unknown) => input is InferType<TSchema>;
+    /**
+     * Parse a JSON string or the result of JSON.parse(). Throws an error if parsing fails.
+     */
+    parse: (input: unknown) => InferType<TSchema>;
+    /**
+     * Parse a JSON string or the result of JSON.parse() without throwing an error
+     */
+    safeParse: (input: unknown) => SafeResult<InferType<TSchema>>;
+    /**
+     * Serialize to JSON
+     */
+    serialize: (input: InferType<TSchema>) => string;
+    compiledCode: {
+        serialize: string;
+        parse: string;
+        validate: string;
+    };
+}
+/**
+ * Create compiled versions of the `parse()`, `validate()`, and `serialize()` functions
+ */
+declare function compile<TSchema extends ASchema<any>>(schema: TSchema): CompiledValidator<TSchema>;
+type CompiledParser<TSchema extends ASchema<any>> = CompiledValidator<TSchema>["parse"];
+declare function getCompiledParser<TSchema extends ASchema<any>>(input: string, schema: TSchema): {
+    fn: CompiledParser<TSchema>;
+    code: string;
+};
+declare function getCompiledSerializer<TSchema extends ASchema>(schema: TSchema): {
+    fn: (input: InferType<TSchema>) => string;
+    code: string;
+};
+
+declare const _namespace_any: typeof any;
+declare const _namespace_array: typeof array;
+declare const _namespace_boolean: typeof boolean;
+declare const _namespace_clone: typeof clone;
+declare const _namespace_coerce: typeof coerce;
+declare const _namespace_compile: typeof compile;
+declare const _namespace_discriminator: typeof discriminator;
+declare const _namespace_enumerator: typeof enumerator;
+declare const _namespace_errors: typeof errors;
+declare const _namespace_extend: typeof extend;
+declare const _namespace_float32: typeof float32;
+declare const _namespace_float64: typeof float64;
+declare const _namespace_int16: typeof int16;
+declare const _namespace_int32: typeof int32;
+declare const _namespace_int64: typeof int64;
+declare const _namespace_int8: typeof int8;
+declare const _namespace_nullable: typeof nullable;
+declare const _namespace_number: typeof number;
+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_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_string: typeof string;
+declare const _namespace_stringEnum: typeof stringEnum;
+declare const _namespace_timestamp: typeof timestamp;
+declare const _namespace_uint16: typeof uint16;
+declare const _namespace_uint32: typeof uint32;
+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 };
+}
+
+declare const int8Min = -128;
+declare const int8Max = 127;
+declare const uint8Min = 0;
+declare const uint8Max = 255;
+declare const int16Min = -32768;
+declare const int16Max = 32767;
+declare const uint16Min = 0;
+declare const uint16Max = 65535;
+declare const int32Min = -2147483648;
+declare const int32Max = 2147483647;
+declare const uint32Min = 0;
+declare const uint32Max = 4294967295;
+declare const int64Min: bigint;
+declare const int64Max: bigint;
+declare const uint64Min: bigint;
+declare const uint64Max: bigint;
+
+interface AAdaptedSchemaValidator<T> extends SchemaValidator<T> {
+    _isAdaptedSchema: true;
+}
+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>;
+
+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 };