pema 0.4.0 → 0.6.0

package/lib/private/ArrayType.d.ts

@@ -7,7 +7,7 @@ import type ParseOptions from "#ParseOptions";
 import type DefaultTrait from "#trait/Default";
 import type OptionalTrait from "#trait/Optional";
 import type Validator from "#Validator";
-import type Primitive from "@rcompat/type/Primitive";
+import type { Primitive } from "@rcompat/type";
 type Next<T> = {
     validators?: Validator<T>[];
 };
@@ -25,6 +25,7 @@ export default class ArrayType<T extends Parsed<unknown>> extends GenericType<T,
      * @returns ArrayType<T>
      */
     unique(this: Infer<T> extends Primitive ? ArrayType<T> : never): ArrayType<T>;
+    uniqueBy<K>(select: (value: Infer<T>) => K): this;
     min(limit: number): this;
     max(limit: number): this;
     length(from: number, to: number): this;

package/lib/private/ArrayType.js

@@ -1,6 +1,6 @@
 import DefaultType from "#DefaultType";
-import error from "#error";
-import schemafail from "#error/schemafail";
+import EnumType from "#EnumType";
+import E from "#errors";
 import GenericType from "#GenericType";
 import OptionalType from "#OptionalType";
 import ParsedKey from "#ParsedKey";
@@ -9,14 +9,15 @@ import join from "#path/join";
 import next from "#path/next";
 import rebase from "#path/rebase";
 import PrimitiveType from "#PrimitiveType";
+import S from "#schema-errors";
 import length from "#validator/length";
 import max from "#validator/max";
 import min from "#validator/min";
 import unique from "#validator/unique";
+import uniqueBy from "#validator/unique-by";
 function isPrimitive(x) {
-    return x instanceof PrimitiveType;
+    return x instanceof PrimitiveType || x instanceof EnumType;
 }
-const is = (x, validator) => validator(x);
 export default class ArrayType extends GenericType {
     #item;
     #validators;
@@ -46,64 +47,51 @@ export default class ArrayType extends GenericType {
      */
     unique() {
         if (!isPrimitive(this.#item)) {
-            throw schemafail("unique: subtype {0} must be primitive", this.#item.name);
+            throw S.unique_subtype_not_primitive(this.#item.name);
         }
         return this.derive({ validators: [unique] });
     }
+    uniqueBy(select) {
+        return this.derive({ validators: [uniqueBy(select)] });
+    }
     min(limit) {
-        if (limit < 0) {
-            throw schemafail("min: {0} must be positive", limit);
-        }
+        if (limit < 0)
+            throw S.min_negative(limit);
         return this.derive({ validators: [min(limit)] });
     }
     max(limit) {
-        if (limit < 0) {
-            throw schemafail("max: {0} must be positive", limit);
-        }
+        if (limit < 0)
+            throw S.max_negative(limit);
         return this.derive({ validators: [max(limit)] });
     }
     length(from, to) {
         return this.derive({ validators: [length(from, to)] });
     }
     parse(x, options = {}) {
-        if (!is(x, _ => !!x && Array.isArray(x))) {
-            throw new ParseError(error("array", x, options));
-        }
-        const base = options[ParsedKey] ?? "";
-        let last = 0;
-        x.forEach((v, i) => {
-            // sparse array check
-            if (i > last) {
-                throw new ParseError([{
-                        ...error(this.#item.name, undefined, options)[0],
-                        path: join(base, last),
-                    }]);
-            }
-            const validator = this.#item;
-            validator.parse(v, next(i, options));
-            last++;
-        });
-        // sparse array with end slots
-        if (x.length > last) {
-            throw new ParseError([{
-                    ...error(this.#item.name, undefined, options)[0],
-                    path: join(base, last),
-                }]);
+        const path = options[ParsedKey] ?? "";
+        if (!Array.isArray(x))
+            throw E.invalid_type(x, "array", path);
+        const item = this.#item;
+        const len = x.length;
+        const out = new Array(len);
+        for (let i = 0; i < len; i++) {
+            if (!(i in x))
+                throw E.invalid_type(undefined, item.name, join(path, i));
+            out[i] = item.parse(x[i], next(i, options));
         }
-        for (const v of this.#validators) {
+        const validators = this.#validators;
+        for (let i = 0; i < validators.length; i++) {
             try {
-                v(x);
+                validators[i](out);
             }
             catch (e) {
-                if (e instanceof ParseError) {
-                    const rebased = (e.issues ?? [])
-                        .map(i => ({ ...i, path: rebase(base, i.path) }));
-                    throw new ParseError(rebased);
+                if (ParseError.is(e)) {
+                    throw new ParseError(e.issues.map(issue => ({ ...issue, path: rebase(path, issue.path) })));
                 }
                 throw e;
             }
         }
-        return x;
+        return out;
     }
     toJSON() {
         return { type: this.name, of: this.#item.toJSON() };

package/lib/private/BigIntType.d.ts

@@ -2,8 +2,8 @@ import type BigIntDataType from "#BigIntDataType";
 import coerce from "#coerce/bigint";
 import CoerceKey from "#CoerceKey";
 import NumericType from "#NumericType";
-import type Storeable from "#Storeable";
-export default class BigIntType<T extends BigIntDataType = "i64"> extends NumericType<T, bigint, "BigIntType"> implements Storeable<T> {
+import type Storable from "#Storable";
+export default class BigIntType<T extends BigIntDataType = "i64"> extends NumericType<T, bigint, "BigIntType"> implements Storable<T> {
     [CoerceKey]: typeof coerce;
     get name(): string;
 }

package/lib/private/BigUintType.d.ts

@@ -2,8 +2,8 @@ import type BigUintDataType from "#BigUintDataType";
 import coerce from "#coerce/bigint";
 import CoerceKey from "#CoerceKey";
 import NumericType from "#NumericType";
-import type Storeable from "#Storeable";
-export default class BigUintType<T extends BigUintDataType = "u64"> extends NumericType<T, bigint, "BigUintType"> implements Storeable<T> {
+import type Storable from "#Storable";
+export default class BigUintType<T extends BigUintDataType = "u64"> extends NumericType<T, bigint, "BigUintType"> implements Storable<T> {
     [CoerceKey]: typeof coerce;
     get name(): string;
 }

package/lib/private/BlobType.d.ts

@@ -1,6 +1,6 @@
 import BuiltinType from "#BuiltinType";
-import Storeable from "#Storeable";
-export default class BlobType extends BuiltinType<Blob, "BlobType"> implements Storeable<"blob"> {
+import Storable from "#Storable";
+export default class BlobType extends BuiltinType<Blob, "BlobType"> implements Storable<"blob"> {
     get Type(): {
         new (blobParts?: BlobPart[], options?: BlobPropertyBag): Blob;
         prototype: Blob;

package/lib/private/BlobType.js

@@ -1,5 +1,5 @@
 import BuiltinType from "#BuiltinType";
-import Storeable from "#Storeable";
+import Storable from "#Storable";
 export default class BlobType extends BuiltinType {
     get Type() {
         return Blob;
@@ -11,7 +11,7 @@ export default class BlobType extends BuiltinType {
         return "blob";
     }
     toJSON() {
-        return Storeable.serialize(this);
+        return Storable.serialize(this);
     }
 }
 //# sourceMappingURL=BlobType.js.map

package/lib/private/BooleanType.d.ts

@@ -1,7 +1,7 @@
 import CoerceKey from "#CoerceKey";
 import PrimitiveType from "#PrimitiveType";
-import Storeable from "#Storeable";
-export default class BooleanType extends PrimitiveType<boolean, "BooleanType"> implements Storeable<"boolean"> {
+import Storable from "#Storable";
+export default class BooleanType extends PrimitiveType<boolean, "BooleanType"> implements Storable<"boolean"> {
     get name(): "boolean";
     get datatype(): "boolean";
     [CoerceKey](x: unknown): unknown;

package/lib/private/BooleanType.js

@@ -1,7 +1,7 @@
 import CoerceKey from "#CoerceKey";
 import PrimitiveType from "#PrimitiveType";
-import Storeable from "#Storeable";
-import boolish from "@rcompat/is/boolish";
+import Storable from "#Storable";
+import is from "@rcompat/is";
 export default class BooleanType extends PrimitiveType {
     get name() {
         return "boolean";
@@ -10,10 +10,10 @@ export default class BooleanType extends PrimitiveType {
         return "boolean";
     }
     [CoerceKey](x) {
-        return boolish(x) ? x === "true" : x;
+        return is.boolish(x) ? x === "true" : x;
     }
     toJSON() {
-        return Storeable.serialize(this);
+        return Storable.serialize(this);
     }
 }
 //# sourceMappingURL=BooleanType.js.map

package/lib/private/BuiltinType.d.ts

@@ -1,12 +1,11 @@
 import type Infer from "#Infer";
 import type ParseOptions from "#ParseOptions";
 import Type from "#Type";
-import type AbstractNewable from "@rcompat/type/AbstractNewable";
+import type { AbstractNewable } from "@rcompat/type";
 export default abstract class BuiltinType<StaticType, Name extends string> extends Type<StaticType, Name> {
     #private;
     abstract get Type(): AbstractNewable;
     constructor(options?: ParseOptions);
-    get coerce(): this;
     parse(x: unknown, options?: ParseOptions): Infer<this>;
 }
 //# sourceMappingURL=BuiltinType.d.ts.map

package/lib/private/BuiltinType.js

@@ -1,6 +1,5 @@
 import CoerceKey from "#CoerceKey";
-import error from "#error";
-import ParseError from "#ParseError";
+import E from "#errors";
 import Type from "#Type";
 export default class BuiltinType extends Type {
     #options;
@@ -12,15 +11,11 @@ export default class BuiltinType extends Type {
         const Constructor = this.constructor;
         return new Constructor({ ...this.#options, ...next });
     }
-    get coerce() {
-        return this.#derive({ coerce: true });
-    }
     parse(x, options = {}) {
         const $options = { ...this.#options, ...options };
         const $x = $options.coerce === true ? this[CoerceKey](x) : x;
-        if (!($x instanceof this.Type)) {
-            throw new ParseError(error(this.name, $x, $options));
-        }
+        if (!($x instanceof this.Type))
+            throw E.invalid_type($x, this.name, $options);
         return $x;
     }
 }

package/lib/private/ConstructorType.d.ts

@@ -1,13 +1,16 @@
 import DefaultType from "#DefaultType";
 import GenericType from "#GenericType";
 import type Infer from "#Infer";
+import OptionalType from "#OptionalType";
 import type ParseOptions from "#ParseOptions";
 import type DefaultTrait from "#trait/Default";
-import type AbstractNewable from "@rcompat/type/AbstractNewable";
-export default class ConstructorType<C extends AbstractNewable> extends GenericType<C, InstanceType<C>, "InstanceType"> implements DefaultTrait<InstanceType<C>> {
+import type OptionalTrait from "#trait/Optional";
+import type { AbstractNewable } from "@rcompat/type";
+export default class ConstructorType<C extends AbstractNewable> extends GenericType<C, InstanceType<C>, "InstanceType"> implements OptionalTrait, DefaultTrait<InstanceType<C>> {
     #private;
     constructor(t: C);
     get name(): string;
+    optional(): OptionalType<this>;
     default(value: (() => InstanceType<C>) | InstanceType<C>): DefaultType<this, InstanceType<C>>;
     parse(x: unknown, options?: ParseOptions): Infer<this>;
     toJSON(): {

package/lib/private/ConstructorType.js

@@ -1,7 +1,7 @@
 import DefaultType from "#DefaultType";
-import error from "#error";
+import E from "#errors";
 import GenericType from "#GenericType";
-import ParseError from "#ParseError";
+import OptionalType from "#OptionalType";
 export default class ConstructorType extends GenericType {
     #type;
     constructor(t) {
@@ -11,13 +11,15 @@ export default class ConstructorType extends GenericType {
     get name() {
         return "constructor";
     }
+    optional() {
+        return new OptionalType(this);
+    }
     default(value) {
         return new DefaultType(this, value);
     }
     parse(x, options = {}) {
-        if (!(x instanceof this.#type)) {
-            throw new ParseError(error(this.name, x, options));
-        }
+        if (!(x instanceof this.#type))
+            throw E.invalid_type(x, this.name, options);
         return x;
     }
     toJSON() {

package/lib/private/DataType.d.ts

@@ -1,3 +1,4 @@
+import type { JSONValue } from "@rcompat/type";
 type DataType = {
     blob: Blob;
     boolean: boolean;
@@ -9,7 +10,7 @@ type DataType = {
     i32: number;
     i64: bigint;
     i8: number;
-    primary: string;
+    json: JSONValue;
     string: string;
     time: string;
     u128: bigint;
@@ -18,6 +19,9 @@ type DataType = {
     u64: bigint;
     u8: number;
     url: URL;
+    uuid: string;
+    uuid_v4: string;
+    uuid_v7: string;
 };
 export type { DataType as default };
 //# sourceMappingURL=DataType.d.ts.map

package/lib/private/DateType.d.ts

@@ -1,8 +1,8 @@
 import BuiltinType from "#BuiltinType";
 import coerce from "#coerce/date";
 import CoerceKey from "#CoerceKey";
-import Storeable from "#Storeable";
-export default class DateType extends BuiltinType<Date, "DateType"> implements Storeable<"datetime"> {
+import Storable from "#Storable";
+export default class DateType extends BuiltinType<Date, "DateType"> implements Storable<"datetime"> {
     [CoerceKey]: typeof coerce;
     get Type(): DateConstructor;
     get name(): "date";

package/lib/private/DateType.js

@@ -1,7 +1,7 @@
 import BuiltinType from "#BuiltinType";
 import coerce from "#coerce/date";
 import CoerceKey from "#CoerceKey";
-import Storeable from "#Storeable";
+import Storable from "#Storable";
 export default class DateType extends BuiltinType {
     [CoerceKey] = coerce;
     get Type() {
@@ -14,7 +14,7 @@ export default class DateType extends BuiltinType {
         return "datetime";
     }
     toJSON() {
-        return Storeable.serialize(this);
+        return Storable.serialize(this);
     }
 }
 //# sourceMappingURL=DateType.js.map

package/lib/private/DefaultType.js

@@ -1,8 +1,5 @@
 import VirtualType from "#VirtualType";
-function isDefaultFunction(x) {
-    return typeof x === "function";
-}
-;
+import is from "@rcompat/is";
 export default class DefaultType extends VirtualType {
     #schema;
     #default;
@@ -23,8 +20,8 @@ export default class DefaultType extends VirtualType {
     parse(x, options = {}) {
         let $x = x;
         // default fallback
-        if ($x === undefined) {
-            $x = isDefaultFunction(this.#default) ? this.#default() : this.#default;
+        if (is.undefined($x)) {
+            $x = is.function(this.#default) ? this.#default() : this.#default;
         }
         return this.#schema.parse($x, options);
     }

package/lib/private/EnumType.d.ts

@@ -0,0 +1,21 @@
+import DefaultType from "#DefaultType";
+import GenericType from "#GenericType";
+import type Infer from "#Infer";
+import OptionalType from "#OptionalType";
+import type ParseOptions from "#ParseOptions";
+import type OptionalTrait from "#trait/Optional";
+type Literal = string;
+export default class EnumType<T extends readonly Literal[]> extends GenericType<T, T[number], "EnumType"> implements OptionalTrait {
+    #private;
+    constructor(values: T);
+    get name(): string;
+    optional(): OptionalType<this>;
+    default<D extends T[number]>(value: (() => D) | D): DefaultType<EnumType<T>, D>;
+    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    toJSON(): {
+        type: "enum";
+        values: T[number][];
+    };
+}
+export {};
+//# sourceMappingURL=EnumType.d.ts.map

package/lib/private/EnumType.js

@@ -0,0 +1,30 @@
+import DefaultType from "#DefaultType";
+import E from "#errors";
+import GenericType from "#GenericType";
+import OptionalType from "#OptionalType";
+export default class EnumType extends GenericType {
+    #values;
+    constructor(values) {
+        super();
+        this.#values = values;
+    }
+    get name() {
+        return this.#values.map(v => `"${v}"`).join(" | ");
+    }
+    optional() {
+        return new OptionalType(this);
+    }
+    default(value) {
+        return new DefaultType(this, value);
+    }
+    parse(x, options = {}) {
+        if (typeof x !== "string" || !this.#values.includes(x)) {
+            throw E.invalid_type(x, this.name, options);
+        }
+        return x;
+    }
+    toJSON() {
+        return { type: "enum", values: [...this.#values] };
+    }
+}
+//# sourceMappingURL=EnumType.js.map

package/lib/private/FileType.d.ts

@@ -1,6 +1,6 @@
 import BuiltinType from "#BuiltinType";
-import Storeable from "#Storeable";
-export default class FileType extends BuiltinType<File, "FileType"> implements Storeable<"blob"> {
+import Storable from "#Storable";
+export default class FileType extends BuiltinType<File, "FileType"> implements Storable<"blob"> {
     get Type(): {
         new (fileBits: BlobPart[], fileName: string, options?: FilePropertyBag): File;
         prototype: File;

package/lib/private/FileType.js

@@ -1,5 +1,5 @@
 import BuiltinType from "#BuiltinType";
-import Storeable from "#Storeable";
+import Storable from "#Storable";
 export default class FileType extends BuiltinType {
     get Type() {
         return File;
@@ -11,7 +11,7 @@ export default class FileType extends BuiltinType {
         return "blob";
     }
     toJSON() {
-        return Storeable.serialize(this);
+        return Storable.serialize(this);
     }
 }
 //# sourceMappingURL=FileType.js.map

package/lib/private/FunctionType.d.ts

@@ -0,0 +1,15 @@
+import GenericType from "#GenericType";
+import type Infer from "#Infer";
+import OptionalType from "#OptionalType";
+import type ParseOptions from "#ParseOptions";
+import type OptionalTrait from "#trait/Optional";
+import type { UnknownFunction } from "@rcompat/type";
+export default class FunctionType extends GenericType<UnknownFunction, UnknownFunction, "FunctionType"> implements OptionalTrait {
+    get name(): "function";
+    optional(): OptionalType<this>;
+    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    toJSON(): {
+        type: "function";
+    };
+}
+//# sourceMappingURL=FunctionType.d.ts.map

package/lib/private/FunctionType.js

@@ -0,0 +1,20 @@
+import GenericType from "#GenericType";
+import OptionalType from "#OptionalType";
+import E from "#errors";
+export default class FunctionType extends GenericType {
+    get name() {
+        return "function";
+    }
+    optional() {
+        return new OptionalType(this);
+    }
+    parse(x, options = {}) {
+        if (typeof x !== "function")
+            throw E.invalid_type(x, this.name, options);
+        return x;
+    }
+    toJSON() {
+        return { type: this.name };
+    }
+}
+//# sourceMappingURL=FunctionType.js.map

package/lib/private/GenericType.d.ts

@@ -1,5 +1,5 @@
 import Parsed from "#Parsed";
-import type PrintableGeneric from "@rcompat/type/PrintableGeneric";
+import type { PrintableGeneric } from "@rcompat/type";
 export default abstract class GenericType<Type, Inferred, Name extends string> extends Parsed<Inferred> implements PrintableGeneric<Type> {
     get Name(): Name;
     get Type(): Type;

package/lib/private/InferInputSchema.d.ts

@@ -1,26 +1,16 @@
-import type ArrayType from "#ArrayType";
-import type DecrementDepth from "#DecrementDepth";
 import type DefaultType from "#DefaultType";
-import type Infer from "#Infer";
-import type NullType from "#NullType";
+import type NormalizeSchema from "#NormalizeSchema";
 import type ObjectType from "#ObjectType";
 import type OptionalType from "#OptionalType";
 import type Parsed from "#Parsed";
 import type Schema from "#Schema";
-import type TupleType from "#TupleType";
-import type UndefinedType from "#UndefinedType";
-import type ImpliedOptional from "@rcompat/type/ImpliedOptional";
-import type UndefinedToOptional from "@rcompat/type/UndefinedToOptional";
-type InferInputSchema<S, Depth extends number = 3> = [
-    Depth
-] extends [never] ? never : S extends DefaultType<infer T, unknown> ? Infer<T> | undefined : S extends OptionalType<infer T> ? Infer<T> | undefined : S extends ObjectType<infer P> ? ImpliedOptional<UndefinedToOptional<{
-    [K in keyof P]: InferInputSchema<P[K], DecrementDepth[Depth]>;
-}>> : S extends Parsed<unknown> ? Infer<S> : S extends null ? Infer<NullType> : S extends undefined ? Infer<UndefinedType> : S extends [infer Only] ? Only extends Parsed<unknown> ? Infer<ArrayType<Only>> : never : S extends Schema[] ? InferInputSchema<TupleType<{
-    [K in keyof S]: S[K] extends Parsed<unknown> ? InferInputSchema<S[K], DecrementDepth[Depth]> : never;
-}>> : S extends {
+import type { ImpliedOptional, UndefinedToOptional } from "@rcompat/type";
+type InferInputSchema<S> = S extends DefaultType<infer T, unknown> ? T["infer"] | undefined : S extends OptionalType<infer T> ? T["infer"] | undefined : S extends ObjectType<infer P> ? ImpliedOptional<UndefinedToOptional<{
+    [K in keyof P]: InferInputSchema<P[K]>;
+}>> : S extends Parsed<unknown> ? S["infer"] : S extends {
     [key: string]: Schema;
 } ? ImpliedOptional<UndefinedToOptional<{
-    [K in keyof S]: InferInputSchema<S[K], DecrementDepth[Depth]>;
-}>> : never;
+    [K in keyof S]: InferInputSchema<S[K]>;
+}>> : NormalizeSchema<S>["infer"];
 export type { InferInputSchema as default };
 //# sourceMappingURL=InferInputSchema.d.ts.map

package/lib/private/InferStore.d.ts

@@ -1,6 +1,6 @@
 import type Parsed from "#Parsed";
 import type StoreSchema from "#StoreSchema";
-import type UndefinedToOptional from "@rcompat/type/UndefinedToOptional";
+import type { UndefinedToOptional } from "@rcompat/type";
 type StoreValue<T> = T extends Parsed<infer U> ? U : never;
 type InferStore<T extends StoreSchema> = UndefinedToOptional<{
     [K in keyof T]: StoreValue<T[K]>;

package/lib/private/IntType.d.ts

@@ -3,8 +3,8 @@ import CoerceKey from "#CoerceKey";
 import type IntDataType from "#IntDataType";
 import NumericType from "#NumericType";
 import type ParseOptions from "#ParseOptions";
-import type Storeable from "#Storeable";
-export default class IntType<T extends IntDataType> extends NumericType<T, number, "IntType"> implements Storeable<T> {
+import type Storable from "#Storable";
+export default class IntType<T extends IntDataType> extends NumericType<T, number, "IntType"> implements Storable<T> {
     [CoerceKey]: typeof coerce;
     get name(): string;
     parse(x: unknown, options?: ParseOptions<number>): import("./Infer.js").default<this>;

package/lib/private/IsType.d.ts

@@ -0,0 +1,19 @@
+import DefaultType from "#DefaultType";
+import type Infer from "#Infer";
+import OptionalType from "#OptionalType";
+import Parsed from "#Parsed";
+import type ParseOptions from "#ParseOptions";
+import type DefaultTrait from "#trait/Default";
+import type OptionalTrait from "#trait/Optional";
+export default class IsType<T> extends Parsed<T> implements OptionalTrait, DefaultTrait<T> {
+    #private;
+    constructor(predicate: (x: unknown) => x is T);
+    get name(): "is";
+    optional(): OptionalType<this>;
+    default(value: (() => T) | T): DefaultType<this, T>;
+    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    toJSON(): {
+        type: "is";
+    };
+}
+//# sourceMappingURL=IsType.d.ts.map

package/lib/private/IsType.js

@@ -0,0 +1,29 @@
+import DefaultType from "#DefaultType";
+import E from "#errors";
+import OptionalType from "#OptionalType";
+import Parsed from "#Parsed";
+export default class IsType extends Parsed {
+    #predicate;
+    constructor(predicate) {
+        super();
+        this.#predicate = predicate;
+    }
+    get name() {
+        return "is";
+    }
+    optional() {
+        return new OptionalType(this);
+    }
+    default(value) {
+        return new DefaultType(this, value);
+    }
+    parse(x, options = {}) {
+        if (!this.#predicate(x))
+            throw E.invalid_type(x, this.name, options);
+        return x;
+    }
+    toJSON() {
+        return { type: this.name };
+    }
+}
+//# sourceMappingURL=IsType.js.map

package/lib/private/Issue.d.ts

@@ -1,5 +1,7 @@
-import type JSONPointer from "@rcompat/type/JSONPointer";
+import type IssueType from "#IssueType";
+import type { JSONPointer } from "@rcompat/type";
 export default interface Issue {
+    readonly type: IssueType;
     readonly message: string;
     readonly path: JSONPointer;
 }

package/lib/private/IssueType.d.ts

@@ -0,0 +1,3 @@
+type IssueType = "invalid_type" | "invalid_format" | "too_small" | "too_large" | "out_of_range" | "not_in_set" | "duplicate" | "network_error";
+export type { IssueType as default };
+//# sourceMappingURL=IssueType.d.ts.map

package/lib/private/IssueType.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IssueType.js.map