pema 0.6.1 → 0.7.0

package/lib/private/ArrayType.d.ts

@@ -29,7 +29,7 @@ export default class ArrayType<T extends Parsed<unknown>> extends GenericType<T,
     min(limit: number): this;
     max(limit: number): this;
     length(from: number, to: number): this;
-    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    parse(u: unknown, options?: ParseOptions): Infer<this>;
     toJSON(): {
         type: "array";
         of: import("./Serialized.js").default;

package/lib/private/ArrayType.js

@@ -2,6 +2,7 @@ import DefaultType from "#DefaultType";
 import EnumType from "#EnumType";
 import E from "#errors";
 import GenericType from "#GenericType";
+import Loose from "#Loose";
 import OptionalType from "#OptionalType";
 import ParsedKey from "#ParsedKey";
 import ParseError from "#ParseError";
@@ -9,12 +10,14 @@ import join from "#path/join";
 import next from "#path/next";
 import rebase from "#path/rebase";
 import PrimitiveType from "#PrimitiveType";
+import resolve from "#resolve";
 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";
+import is from "@rcompat/is";
 function isPrimitive(x) {
     return x instanceof PrimitiveType || x instanceof EnumType;
 }
@@ -67,9 +70,13 @@ export default class ArrayType extends GenericType {
     length(from, to) {
         return this.derive({ validators: [length(from, to)] });
     }
-    parse(x, options = {}) {
-        const path = options[ParsedKey] ?? "";
-        if (!Array.isArray(x))
+    parse(u, options = {}) {
+        const x = resolve(u);
+        const $options = this[Loose] !== undefined
+            ? { ...options, [Loose]: this[Loose] }
+            : options;
+        const path = $options[ParsedKey] ?? "";
+        if (!is.array(x))
             throw E.invalid_type(x, "array", path);
         const item = this.#item;
         const len = x.length;
@@ -77,7 +84,7 @@ export default class ArrayType extends GenericType {
         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));
+            out[i] = item.parse(x[i], next(i, $options));
         }
         const validators = this.#validators;
         for (let i = 0; i < validators.length; i++) {

package/lib/private/BuiltinType.d.ts

@@ -6,6 +6,6 @@ export default abstract class BuiltinType<StaticType, Name extends string> exten
     #private;
     abstract get Type(): AbstractNewable;
     constructor(options?: ParseOptions);
-    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    parse(u: unknown, options?: ParseOptions): Infer<this>;
 }
 //# sourceMappingURL=BuiltinType.d.ts.map

package/lib/private/BuiltinType.js

@@ -1,5 +1,7 @@
 import CoerceKey from "#CoerceKey";
 import E from "#errors";
+import Loose from "#Loose";
+import resolve from "#resolve";
 import Type from "#Type";
 export default class BuiltinType extends Type {
     #options;
@@ -11,9 +13,11 @@ export default class BuiltinType extends Type {
         const Constructor = this.constructor;
         return new Constructor({ ...this.#options, ...next });
     }
-    parse(x, options = {}) {
+    parse(u, options = {}) {
+        const x = resolve(u);
         const $options = { ...this.#options, ...options };
-        const $x = $options.coerce === true ? this[CoerceKey](x) : x;
+        const loose = this[Loose] ?? $options[Loose] ?? false;
+        const $x = loose ? this[CoerceKey](x) : x;
         if (!($x instanceof this.Type))
             throw E.invalid_type($x, this.name, $options);
         return $x;

package/lib/private/ConstructorType.d.ts

@@ -12,7 +12,7 @@ export default class ConstructorType<C extends AbstractNewable> extends GenericT
     get name(): string;
     optional(): OptionalType<this>;
     default(value: (() => InstanceType<C>) | InstanceType<C>): DefaultType<this, InstanceType<C>>;
-    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    parse(u: unknown, options?: ParseOptions): Infer<this>;
     toJSON(): {
         type: "newable";
         of: string;

package/lib/private/ConstructorType.js

@@ -2,6 +2,7 @@ import DefaultType from "#DefaultType";
 import E from "#errors";
 import GenericType from "#GenericType";
 import OptionalType from "#OptionalType";
+import resolve from "#resolve";
 export default class ConstructorType extends GenericType {
     #type;
     constructor(t) {
@@ -17,7 +18,8 @@ export default class ConstructorType extends GenericType {
     default(value) {
         return new DefaultType(this, value);
     }
-    parse(x, options = {}) {
+    parse(u, options = {}) {
+        const x = resolve(u);
         if (!(x instanceof this.#type))
             throw E.invalid_type(x, this.name, options);
         return x;

package/lib/private/DefaultType.d.ts

@@ -8,7 +8,7 @@ export default class DefaultType<S extends Parsed<unknown>, D extends Infer<S>>
     get name(): "default";
     get schema(): S;
     get input(): Infer<S> | undefined;
-    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    parse(u: unknown, options?: ParseOptions): Infer<this>;
     toJSON(): {
         type: "default";
         of: import("./Serialized.js").default;

package/lib/private/DefaultType.js

@@ -1,3 +1,4 @@
+import resolve from "#resolve";
 import VirtualType from "#VirtualType";
 import is from "@rcompat/is";
 export default class DefaultType extends VirtualType {
@@ -17,13 +18,13 @@ export default class DefaultType extends VirtualType {
     get input() {
         return undefined;
     }
-    parse(x, options = {}) {
-        let $x = x;
+    parse(u, options = {}) {
+        let x = resolve(u);
         // default fallback
-        if (is.undefined($x)) {
-            $x = is.function(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);
+        return this.#schema.parse(x, options);
     }
     toJSON() {
         return { type: this.name, of: this.#schema.toJSON() };

package/lib/private/EnumType.d.ts

@@ -11,7 +11,7 @@ export default class EnumType<T extends readonly Literal[]> extends GenericType<
     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>;
+    parse(u: unknown, options?: ParseOptions): Infer<this>;
     toJSON(): {
         type: "enum";
         values: T[number][];

package/lib/private/EnumType.js

@@ -2,6 +2,8 @@ import DefaultType from "#DefaultType";
 import E from "#errors";
 import GenericType from "#GenericType";
 import OptionalType from "#OptionalType";
+import resolve from "#resolve";
+import is from "@rcompat/is";
 export default class EnumType extends GenericType {
     #values;
     constructor(values) {
@@ -17,8 +19,9 @@ export default class EnumType extends GenericType {
     default(value) {
         return new DefaultType(this, value);
     }
-    parse(x, options = {}) {
-        if (typeof x !== "string" || !this.#values.includes(x)) {
+    parse(u, options = {}) {
+        const x = resolve(u);
+        if (!is.string(x) || !this.#values.includes(x)) {
             throw E.invalid_type(x, this.name, options);
         }
         return x;

package/lib/private/FunctionType.d.ts

@@ -7,7 +7,7 @@ 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>;
+    parse(u: unknown, options?: ParseOptions): Infer<this>;
     toJSON(): {
         type: "function";
     };

package/lib/private/FunctionType.js

@@ -1,6 +1,8 @@
+import E from "#errors";
 import GenericType from "#GenericType";
 import OptionalType from "#OptionalType";
-import E from "#errors";
+import resolve from "#resolve";
+import is from "@rcompat/is";
 export default class FunctionType extends GenericType {
     get name() {
         return "function";
@@ -8,8 +10,9 @@ export default class FunctionType extends GenericType {
     optional() {
         return new OptionalType(this);
     }
-    parse(x, options = {}) {
-        if (typeof x !== "function")
+    parse(u, options = {}) {
+        const x = resolve(u);
+        if (!is.function(x))
             throw E.invalid_type(x, this.name, options);
         return x;
     }

package/lib/private/IntType.d.ts

@@ -7,6 +7,6 @@ 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>;
+    parse(u: unknown, options?: ParseOptions<number>): import("./Infer.js").default<this>;
 }
 //# sourceMappingURL=IntType.d.ts.map

package/lib/private/IntType.js

@@ -7,8 +7,8 @@ export default class IntType extends NumericType {
     get name() {
         return "number";
     }
-    parse(x, options = {}) {
-        return super.parse(x, {
+    parse(u, options = {}) {
+        return super.parse(u, {
             ...options,
             validators: [integer],
         });

package/lib/private/IsType.d.ts

@@ -11,7 +11,7 @@ export default class IsType<T> extends Parsed<T> implements OptionalTrait, Defau
     get name(): "is";
     optional(): OptionalType<this>;
     default(value: (() => T) | T): DefaultType<this, T>;
-    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    parse(u: unknown, options?: ParseOptions): Infer<this>;
     toJSON(): {
         type: "is";
     };

package/lib/private/IsType.js

@@ -2,6 +2,7 @@ import DefaultType from "#DefaultType";
 import E from "#errors";
 import OptionalType from "#OptionalType";
 import Parsed from "#Parsed";
+import resolve from "#resolve";
 export default class IsType extends Parsed {
     #predicate;
     constructor(predicate) {
@@ -17,7 +18,8 @@ export default class IsType extends Parsed {
     default(value) {
         return new DefaultType(this, value);
     }
-    parse(x, options = {}) {
+    parse(u, options = {}) {
+        const x = resolve(u);
         if (!this.#predicate(x))
             throw E.invalid_type(x, this.name, options);
         return x;

package/lib/private/JSONType.d.ts

@@ -16,7 +16,7 @@ export default class JSONType<S extends JSONInput = undefined> extends Storable<
     get datatype(): "json";
     optional(): OptionalType<this>;
     default(value: (() => Infer<this>) | Infer<this>): DefaultType<this, Infer<this>>;
-    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    parse(u: unknown, options?: ParseOptions): Infer<this>;
     toJSON(): {
         type: "json";
         datatype: "json";

package/lib/private/JSONType.js

@@ -1,6 +1,7 @@
 import DefaultType from "#DefaultType";
 import E from "#errors";
 import OptionalType from "#OptionalType";
+import resolve from "#resolve";
 import Storable from "#Storable";
 import is from "@rcompat/is";
 export default class JSONType extends Storable {
@@ -21,7 +22,8 @@ export default class JSONType extends Storable {
     default(value) {
         return new DefaultType(this, value);
     }
-    parse(x, options = {}) {
+    parse(u, options = {}) {
+        const x = resolve(u);
         if (this.#inner !== undefined) {
             // delegate to inner schema for typed validation
             return this.#inner.parse(x, options);

package/lib/private/LiteralType.d.ts

@@ -7,12 +7,11 @@ type Literal = string | boolean | number;
 export default class LiteralType<T extends Literal> extends GenericType<T, T, "LiteralType"> {
     #private;
     constructor(literal: T);
-    static new<T extends Literal>(literal: T): LiteralType<T>;
     static get Literal(): Literal;
     get name(): string;
     optional(): OptionalType<this>;
     default(value: (() => T) | T): DefaultType<this, T>;
-    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    parse(u: unknown, options?: ParseOptions): Infer<this>;
     toJSON(): {
         type: "literal";
         value: T;

package/lib/private/LiteralType.js

@@ -2,15 +2,13 @@ import DefaultType from "#DefaultType";
 import GenericType from "#GenericType";
 import OptionalType from "#OptionalType";
 import E from "#errors";
+import resolve from "#resolve";
 export default class LiteralType extends GenericType {
     #literal;
     constructor(literal) {
         super();
         this.#literal = literal;
     }
-    static new(literal) {
-        return new LiteralType(literal);
-    }
     static get Literal() {
         return undefined;
     }
@@ -23,7 +21,8 @@ export default class LiteralType extends GenericType {
     default(value) {
         return new DefaultType(this, value);
     }
-    parse(x, options = {}) {
+    parse(u, options = {}) {
+        const x = resolve(u);
         if (x !== this.#literal)
             throw E.invalid_type(x, this.name, options);
         return x;

package/lib/private/Loose.d.ts

@@ -0,0 +1,4 @@
+declare const Loose: unique symbol;
+type Loose = typeof Loose;
+export { Loose as default };
+//# sourceMappingURL=Loose.d.ts.map

package/lib/private/Loose.js

@@ -0,0 +1,3 @@
+const Loose = Symbol("Loose");
+export { Loose as default };
+//# sourceMappingURL=Loose.js.map

package/lib/private/NormalizeSchema.d.ts

@@ -7,13 +7,13 @@ import type Parsed from "#Parsed";
 import type Schema from "#Schema";
 import type TupleType from "#TupleType";
 import type UndefinedType from "#UndefinedType";
-import type { AbstractNewable } from "@rcompat/type";
+import type { AbstractNewable, Dict } from "@rcompat/type";
 type NormalizeSchemaArray<T extends Schema[]> = {
     [K in keyof T]: NormalizeSchema<T[K]>;
 };
-export type NormalizeSchemaObject<T extends Record<string, unknown>> = {
+export type NormalizeSchemaObject<T extends Dict> = {
     -readonly [K in keyof T]: NormalizeSchema<T[K]>;
 };
-type NormalizeSchema<S> = S extends Parsed<unknown> ? S : S extends null ? NullType : S extends undefined ? UndefinedType : S extends string | number | boolean ? LiteralType<S> : S extends AbstractNewable ? ConstructorType<S> : S extends [Schema] ? ArrayType<NormalizeSchema<S[0]>> : S extends Schema[] ? TupleType<NormalizeSchemaArray<S>> : S extends Record<string, unknown> ? ObjectType<NormalizeSchemaObject<S>> : never;
+type NormalizeSchema<S> = S extends Parsed<unknown> ? S : S extends null ? NullType : S extends undefined ? UndefinedType : S extends string | number | boolean ? LiteralType<S> : S extends AbstractNewable ? ConstructorType<S> : S extends [Schema] ? ArrayType<NormalizeSchema<S[0]>> : S extends Schema[] ? TupleType<NormalizeSchemaArray<S>> : S extends Dict ? ObjectType<NormalizeSchemaObject<S>> : never;
 export type { NormalizeSchema as default };
 //# sourceMappingURL=NormalizeSchema.d.ts.map

package/lib/private/NullType.d.ts

@@ -3,7 +3,7 @@ import type ParseOptions from "#ParseOptions";
 import PrimitiveType from "#PrimitiveType";
 export default class NullType extends PrimitiveType<null, "NullType"> {
     get name(): "null";
-    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    parse(u: unknown, options?: ParseOptions): Infer<this>;
     toJSON(): {
         type: "null";
     };

package/lib/private/NullType.js

@@ -1,11 +1,14 @@
 import PrimitiveType from "#PrimitiveType";
 import E from "#errors";
+import resolve from "#resolve";
+import is from "@rcompat/is";
 export default class NullType extends PrimitiveType {
     get name() {
         return "null";
     }
-    parse(x, options = {}) {
-        if (x !== null)
+    parse(u, options = {}) {
+        const x = resolve(u);
+        if (!is.null(x))
             throw E.invalid_type(x, this.name, options);
         return x;
     }

package/lib/private/NumericType.d.ts

@@ -3,6 +3,7 @@ import type ParseOptions from "#ParseOptions";
 import PrimitiveType from "#PrimitiveType";
 import type Storable from "#Storable";
 import type Validator from "#Validator";
+import type { Dict } from "@rcompat/type";
 type Next<T> = {
     options?: ParseOptions;
     validators?: Validator<T>[];
@@ -11,7 +12,7 @@ export default abstract class NumericType<Key extends DataKey, T extends bigint
     #private;
     constructor(datatype: Key, validators?: Validator<T>[], options?: ParseOptions);
     derive(next: Next<T>): this;
-    values(anyof: Record<string, T>): this;
+    values(anyof: Dict<T>): this;
     range(from: T, to: T): this;
     min(from: T): this;
     max(to: T): this;

package/lib/private/ObjectType.d.ts

@@ -22,7 +22,7 @@ export default class ObjectType<P extends Dict<Parsed<unknown>>, I = ObjectInfer
     extend<E extends {
         [K in keyof E]: K extends keyof P ? never : Parsed<unknown>;
     }>(extra: E | ObjectType<E>): ObjectType<Unpack<P & E>>;
-    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    parse(u: unknown, options?: ParseOptions): Infer<this>;
     toJSON(): {
         type: "object";
         properties: Dict<Serialized>;

package/lib/private/ObjectType.js

@@ -1,7 +1,9 @@
 import E from "#errors";
 import GenericType from "#GenericType";
+import Loose from "#Loose";
 import OptionalType from "#OptionalType";
 import next from "#path/next";
+import resolve from "#resolve";
 import SE from "#schema-errors";
 import is from "@rcompat/is";
 export default class ObjectType extends GenericType {
@@ -26,13 +28,19 @@ export default class ObjectType extends GenericType {
     }
     #derive(options) {
         const Constructor = this.constructor;
-        return new Constructor(this.#properties, { ...this.#options, ...options });
+        const instance = new Constructor(this.#properties, {
+            ...this.#options, ...options,
+        });
+        instance[Loose] = this[Loose];
+        return instance;
     }
     optional() {
         return new OptionalType(this);
     }
     shape() {
-        return new ObjectType(this.#properties, this.#options);
+        const i = new ObjectType(this.#properties, this.#options);
+        i[Loose] = this[Loose];
+        return i;
     }
     extend(extra) {
         const properties = extra instanceof ObjectType ? extra.properties : extra;
@@ -40,10 +48,15 @@ export default class ObjectType extends GenericType {
             if (key in this.#properties)
                 throw SE.extend_key_collision(key);
         }
-        return new ObjectType({ ...this.#properties, ...properties }, this.#options);
+        const instance = new ObjectType({ ...this.#properties, ...properties }, this.#options);
+        instance[Loose] = this[Loose];
+        return instance;
     }
-    parse(x, options = {}) {
-        const $options = { ...this.#options, ...options };
+    parse(u, options = {}) {
+        const x = resolve(u);
+        const $options = this[Loose] !== undefined
+            ? { ...this.#options, ...options, [Loose]: this[Loose] }
+            : { ...this.#options, ...options };
         if (is.defined(x) && !is.dict(x))
             throw E.invalid_type(x, "object", $options);
         const input = x ?? {};

package/lib/private/OmitType.d.ts

@@ -11,7 +11,7 @@ export default class OmitType<P extends Dict<Parsed<unknown>>, K extends keyof P
     #private;
     constructor(type: ObjectType<P>, keys: K[]);
     get name(): "omit";
-    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    parse(u: unknown, options?: ParseOptions): Infer<this>;
     toJSON(): {
         type: "omit";
         properties: Dict<Serialized>;

package/lib/private/OmitType.js

@@ -2,6 +2,7 @@ import E from "#errors";
 import GenericType from "#GenericType";
 import ParsedKey from "#ParsedKey";
 import join from "#path/join";
+import resolve from "#resolve";
 import is from "@rcompat/is";
 export default class OmitType extends GenericType {
     #properties;
@@ -16,7 +17,8 @@ export default class OmitType extends GenericType {
     get name() {
         return "omit";
     }
-    parse(x, options = {}) {
+    parse(u, options = {}) {
+        const x = resolve(u);
         if (!is.dict(x))
             throw E.invalid_type(x, "object", options);
         const out = {};

package/lib/private/OptionalType.d.ts

@@ -8,7 +8,7 @@ export default class OptionalType<S extends Parsed<unknown>> extends VirtualType
     get name(): "optional";
     get schema(): S;
     get nullable(): boolean;
-    parse(x: unknown, options?: ParseOptions): Infer<this>;
+    parse(u: unknown, options?: ParseOptions): Infer<this>;
     toJSON(): {
         type: "optional";
         of: import("./Serialized.js").default;

package/lib/private/OptionalType.js

@@ -1,4 +1,6 @@
+import resolve from "#resolve";
 import VirtualType from "#VirtualType";
+import is from "@rcompat/is";
 export default class OptionalType extends VirtualType {
     #schema;
     constructor(s) {
@@ -14,13 +16,12 @@ export default class OptionalType extends VirtualType {
     get nullable() {
         return true;
     }
-    parse(x, options = {}) {
-        const s = this.#schema;
+    parse(u, options = {}) {
+        const x = resolve(u);
         // optional
-        if (x === undefined) {
+        if (is.undefined(x))
             return undefined;
-        }
-        return s.parse(x, options);
+        return this.#schema.parse(x, options);
     }
     toJSON() {
         return {

package/lib/private/ParseError.d.ts

@@ -5,7 +5,7 @@ declare const brand: unique symbol;
 export default class ParseError extends Error implements Serializable {
     #private;
     [brand]: boolean;
-    static is(error: unknown): error is ParseError;
+    static is(x: unknown): x is ParseError;
     constructor(issues: ParseIssue[]);
     get issues(): ParseIssue[];
     toJSON(): JSONPayload;

package/lib/private/ParseError.js

@@ -1,4 +1,5 @@
 import assert from "@rcompat/assert";
+import is from "@rcompat/is";
 function humanize(path) {
     return path === ""
         ? ""
@@ -16,12 +17,12 @@ function stringify(issue) {
         ? issue.message
         : `${humanize(issue.path)}: ${issue.message}`;
 }
-const brand = Symbol.for("pema/error/parse/v0");
+const brand = Symbol.for("pema/ParseError/v0");
 export default class ParseError extends Error {
     [brand] = true;
     #issues = [];
-    static is(error) {
-        return typeof error === "object" && error !== null && brand in error;
+    static is(x) {
+        return is.branded(x, brand);
     }
     constructor(issues) {
         super(stringify(issues[0]));
@@ -43,19 +44,19 @@ export default class ParseError extends Error {
                 messages,
             };
         }
-        const dict = {};
+        const payload = {};
         for (const i of issues) {
             const key = i.path;
-            if (!(key in dict))
-                dict[key] = {
+            if (!(key in payload))
+                payload[key] = {
                     type: i.type,
                     message: i.message,
                     messages: [],
                 };
-            const entry = dict[key];
+            const entry = payload[key];
             entry.messages.push(i.message);
         }
-        return dict;
+        return payload;
     }
 }
 //# sourceMappingURL=ParseError.js.map

package/lib/private/ParseOptions.d.ts

@@ -1,9 +1,10 @@
+import type Loose from "#Loose";
 import type ParsedKey from "#ParsedKey";
 import type Validator from "#Validator";
 import type { JSONPointer } from "@rcompat/type";
 export default interface ParseOptions<T = unknown> {
-    coerce?: boolean;
     [ParsedKey]?: JSONPointer;
+    [Loose]?: boolean;
     partial?: boolean;
     validators?: Validator<T>[];
 }

package/lib/private/Parsed.d.ts

@@ -1,4 +1,5 @@
 import CoerceKey from "#CoerceKey";
+import Loose from "#Loose";
 import ParsedKey from "#ParsedKey";
 import type ParseOptions from "#ParseOptions";
 import type Serialized from "#Serialized";
@@ -7,19 +8,19 @@ export default abstract class Parsed<StaticType> implements Serializable {
     get [ParsedKey](): "ParsedKey";
     get infer(): StaticType;
     get nullable(): boolean;
+    [Loose]: boolean | undefined;
     [CoerceKey](x: unknown): unknown;
     abstract get name(): string;
     /**
     * Parse the given value.
     *
-    * @param x Value to parse.
+    * @param u Value to parse.
     *
     * @throws `ParseError` if the value could not be parsed.
     *
     * @returns The parsed value, if successfully parsed.
     */
-    abstract parse(x: unknown, options?: ParseOptions): StaticType;
-    coerce(x: unknown, options?: ParseOptions): StaticType;
+    abstract parse(u: unknown, options?: ParseOptions): StaticType;
     abstract toJSON(): Serialized;
 }
 //# sourceMappingURL=Parsed.d.ts.map