pema 0.7.0 → 0.8.0

package/lib/private/ArrayType.d.ts

@@ -1,6 +1,8 @@
 import DefaultType from "#DefaultType";
 import GenericType from "#GenericType";
 import type Infer from "#Infer";
+import Loose from "#Loose";
+import type Mode from "#Mode";
 import OptionalType from "#OptionalType";
 import type Parsed from "#Parsed";
 import type ParseOptions from "#ParseOptions";
@@ -11,9 +13,10 @@ import type { Primitive } from "@rcompat/type";
 type Next<T> = {
     validators?: Validator<T>[];
 };
-export default class ArrayType<T extends Parsed<unknown>> extends GenericType<T, Infer<T>[], "ArrayType"> implements OptionalTrait, DefaultTrait<Infer<T>[]> {
+export default class ArrayType<T extends Parsed<unknown>, M extends Mode = undefined> extends GenericType<T, Infer<T>[], "ArrayType"> implements OptionalTrait, DefaultTrait<Infer<T>[]> {
     #private;
-    constructor(item: T, validators?: Validator<Array<Infer<T>>>[]);
+    [Loose]: M;
+    constructor(item: T, mode?: M, validators?: Validator<Array<Infer<T>>>[]);
     get name(): "array";
     optional(): OptionalType<this>;
     default(value: (() => Infer<T>[]) | Infer<T>[]): DefaultType<this, Infer<T>[]>;

package/lib/private/ArrayType.js

@@ -24,9 +24,11 @@ function isPrimitive(x) {
 export default class ArrayType extends GenericType {
     #item;
     #validators;
-    constructor(item, validators = []) {
+    [Loose];
+    constructor(item, mode, validators = []) {
         super();
         this.#item = item;
+        this[Loose] = mode;
         this.#validators = validators;
     }
     get name() {
@@ -40,7 +42,7 @@ export default class ArrayType extends GenericType {
     }
     derive(_next) {
         const Constructor = this.constructor;
-        return new Constructor(this.#item, [...this.#validators, ..._next.validators ?? []]);
+        return new Constructor(this.#item, this[Loose], [...this.#validators, ..._next.validators ?? []]);
     }
     /**
      * Member values are unique — only for primitive subtypes.

package/lib/private/BigIntType.d.ts

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

package/lib/private/BigUintType.d.ts

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

package/lib/private/BooleanType.d.ts

@@ -1,7 +1,11 @@
 import CoerceKey from "#CoerceKey";
+import Loose from "#Loose";
+import type Mode from "#Mode";
 import PrimitiveType from "#PrimitiveType";
 import Storable from "#Storable";
-export default class BooleanType extends PrimitiveType<boolean, "BooleanType"> implements Storable<"boolean"> {
+export default class BooleanType<M extends Mode = undefined> extends PrimitiveType<boolean, "BooleanType"> implements Storable<"boolean"> {
+    [Loose]: M;
+    constructor(mode?: M);
     get name(): "boolean";
     get datatype(): "boolean";
     [CoerceKey](x: unknown): unknown;

package/lib/private/BooleanType.js

@@ -1,8 +1,14 @@
 import CoerceKey from "#CoerceKey";
+import Loose from "#Loose";
 import PrimitiveType from "#PrimitiveType";
 import Storable from "#Storable";
 import is from "@rcompat/is";
 export default class BooleanType extends PrimitiveType {
+    [Loose];
+    constructor(mode) {
+        super();
+        this[Loose] = mode;
+    }
     get name() {
         return "boolean";
     }

package/lib/private/DateType.d.ts

@@ -1,9 +1,12 @@
 import BuiltinType from "#BuiltinType";
 import coerce from "#coerce/date";
 import CoerceKey from "#CoerceKey";
+import Loose from "#Loose";
 import Storable from "#Storable";
-export default class DateType extends BuiltinType<Date, "DateType"> implements Storable<"datetime"> {
+export default class DateType<M extends boolean | undefined = undefined> extends BuiltinType<Date, "DateType"> implements Storable<"datetime"> {
     [CoerceKey]: typeof coerce;
+    [Loose]: M;
+    constructor(mode?: M);
     get Type(): DateConstructor;
     get name(): "date";
     get datatype(): "datetime";

package/lib/private/DateType.js

@@ -1,9 +1,15 @@
 import BuiltinType from "#BuiltinType";
 import coerce from "#coerce/date";
 import CoerceKey from "#CoerceKey";
+import Loose from "#Loose";
 import Storable from "#Storable";
 export default class DateType extends BuiltinType {
     [CoerceKey] = coerce;
+    [Loose];
+    constructor(mode) {
+        super();
+        this[Loose] = mode;
+    }
     get Type() {
         return Date;
     }

package/lib/private/IntType.d.ts

@@ -4,7 +4,7 @@ import type IntDataType from "#IntDataType";
 import NumericType from "#NumericType";
 import type ParseOptions from "#ParseOptions";
 import type Storable from "#Storable";
-export default class IntType<T extends IntDataType> extends NumericType<T, number, "IntType"> implements Storable<T> {
+export default class IntType<T extends IntDataType, L extends boolean | undefined = undefined> extends NumericType<T, number, "IntType", L> implements Storable<T> {
     [CoerceKey]: typeof coerce;
     get name(): string;
     parse(u: unknown, options?: ParseOptions<number>): import("./Infer.js").default<this>;

package/lib/private/LiteralType.d.ts

@@ -1,13 +1,16 @@
 import DefaultType from "#DefaultType";
 import GenericType from "#GenericType";
 import type Infer from "#Infer";
+import Loose from "#Loose";
 import OptionalType from "#OptionalType";
 import type ParseOptions from "#ParseOptions";
+import type Mode from "#Mode";
 type Literal = string | boolean | number;
-export default class LiteralType<T extends Literal> extends GenericType<T, T, "LiteralType"> {
+export default class LiteralType<T extends Literal, M extends Mode = undefined> extends GenericType<T, T, "LiteralType"> {
     #private;
-    constructor(literal: T);
+    [Loose]: M;
     static get Literal(): Literal;
+    constructor(literal: T, mode?: M);
     get name(): string;
     optional(): OptionalType<this>;
     default(value: (() => T) | T): DefaultType<this, T>;

package/lib/private/LiteralType.js

@@ -1,17 +1,20 @@
 import DefaultType from "#DefaultType";
 import GenericType from "#GenericType";
+import Loose from "#Loose";
 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;
-    }
+    [Loose];
     static get Literal() {
         return undefined;
     }
+    constructor(literal, mode) {
+        super();
+        this.#literal = literal;
+        this[Loose] = mode;
+    }
     get name() {
         return JSON.stringify(this.#literal);
     }

package/lib/private/Mode.d.ts

@@ -0,0 +1,3 @@
+type Mode = boolean | undefined;
+export type { Mode as default };
+//# sourceMappingURL=Mode.d.ts.map

package/lib/private/Mode.js

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

package/lib/private/NumberType.d.ts

@@ -2,7 +2,7 @@ import CoerceKey from "#CoerceKey";
 import type FloatDataType from "#FloatDataType";
 import NumericType from "#NumericType";
 import coerce from "#coerce/float";
-export default class NumberType<T extends FloatDataType = "f64"> extends NumericType<T, number, "NumberType"> {
+export default class NumberType<T extends FloatDataType = "f64", L extends boolean | undefined = undefined> extends NumericType<T, number, "NumberType", L> {
     [CoerceKey]: typeof coerce;
     get name(): "number";
 }

package/lib/private/NumericType.d.ts

@@ -1,4 +1,6 @@
 import type DataKey from "#DataKey";
+import Loose from "#Loose";
+import type Mode from "#Mode";
 import type ParseOptions from "#ParseOptions";
 import PrimitiveType from "#PrimitiveType";
 import type Storable from "#Storable";
@@ -8,9 +10,10 @@ type Next<T> = {
     options?: ParseOptions;
     validators?: Validator<T>[];
 };
-export default abstract class NumericType<Key extends DataKey, T extends bigint | number, Name extends string> extends PrimitiveType<T, Name> implements Storable<Key> {
+export default abstract class NumericType<Key extends DataKey, T extends bigint | number, Name extends string, M extends Mode = undefined> extends PrimitiveType<T, Name> implements Storable<Key> {
     #private;
-    constructor(datatype: Key, validators?: Validator<T>[], options?: ParseOptions);
+    [Loose]: M;
+    constructor(datatype: Key, mode?: M, validators?: Validator<T>[], options?: ParseOptions);
     derive(next: Next<T>): this;
     values(anyof: Dict<T>): this;
     range(from: T, to: T): this;

package/lib/private/NumericType.js

@@ -1,3 +1,4 @@
+import Loose from "#Loose";
 import PrimitiveType from "#PrimitiveType";
 import max from "#validator/max";
 import min from "#validator/min";
@@ -5,13 +6,15 @@ import range from "#validator/range";
 import values from "#validator/values";
 export default class NumericType extends PrimitiveType {
     #datatype;
-    constructor(datatype, validators = [], options = {}) {
+    [Loose];
+    constructor(datatype, mode = undefined, validators = [], options = {}) {
         super(validators, options);
         this.#datatype = datatype;
+        this[Loose] = mode;
     }
     derive(next) {
         const Constructor = this.constructor;
-        return new Constructor(this.#datatype, [...this.validators, ...next.validators ?? []], { ...this.options, ...next.options ?? {} });
+        return new Constructor(this.#datatype, this[Loose], [...this.validators, ...next.validators ?? []], { ...this.options, ...next.options ?? {} });
     }
     values(anyof) {
         return this.derive({ validators: [values(anyof)] });

package/lib/private/ObjectType.d.ts

@@ -1,6 +1,8 @@
 import GenericType from "#GenericType";
 import type Infer from "#Infer";
 import type InferInputSchema from "#InferInputSchema";
+import Loose from "#Loose";
+import type Mode from "#Mode";
 import OptionalType from "#OptionalType";
 import type Parsed from "#Parsed";
 import type ParseOptions from "#ParseOptions";
@@ -10,18 +12,19 @@ import type { Dict, Unpack } from "@rcompat/type";
 type ObjectInfer<P extends Dict<Parsed<unknown>>> = {
     [K in keyof P]: P[K]["infer"];
 };
-export default class ObjectType<P extends Dict<Parsed<unknown>>, I = ObjectInfer<P>> extends GenericType<P, I, "ObjectType"> implements OptionalTrait {
+export default class ObjectType<P extends Dict<Parsed<unknown>> = Dict<Parsed<unknown>>, M extends Mode = undefined, I = ObjectInfer<P>> extends GenericType<P, I, "ObjectType"> implements OptionalTrait {
     #private;
+    [Loose]: M;
     readonly Complement: ObjectType<Record<Exclude<string, keyof P>, Parsed<unknown>>>;
-    constructor(properties: P, options?: ParseOptions);
+    constructor(properties: P, mode?: M, options?: ParseOptions);
     get name(): string;
     get properties(): P;
     get input(): InferInputSchema<P>;
     optional(): OptionalType<this>;
-    shape<T>(): ObjectType<P, T>;
+    shape<T>(): ObjectType<P, M, T>;
     extend<E extends {
         [K in keyof E]: K extends keyof P ? never : Parsed<unknown>;
-    }>(extra: E | ObjectType<E>): ObjectType<Unpack<P & E>>;
+    }>(extra: E | ObjectType<E, M>): ObjectType<Unpack<P & E>, M>;
     parse(u: unknown, options?: ParseOptions): Infer<this>;
     toJSON(): {
         type: "object";

package/lib/private/ObjectType.js

@@ -9,9 +9,11 @@ import is from "@rcompat/is";
 export default class ObjectType extends GenericType {
     #properties;
     #options;
-    constructor(properties, options = {}) {
+    [Loose];
+    constructor(properties, mode, options = {}) {
         super();
         this.#properties = properties;
+        this[Loose] = mode;
         this.#options = options;
     }
     get name() {
@@ -28,7 +30,7 @@ export default class ObjectType extends GenericType {
     }
     #derive(options) {
         const Constructor = this.constructor;
-        const instance = new Constructor(this.#properties, {
+        const instance = new Constructor(this.#properties, this[Loose], {
             ...this.#options, ...options,
         });
         instance[Loose] = this[Loose];
@@ -38,9 +40,7 @@ export default class ObjectType extends GenericType {
         return new OptionalType(this);
     }
     shape() {
-        const i = new ObjectType(this.#properties, this.#options);
-        i[Loose] = this[Loose];
-        return i;
+        return new ObjectType(this.#properties, this[Loose], this.#options);
     }
     extend(extra) {
         const properties = extra instanceof ObjectType ? extra.properties : extra;
@@ -48,9 +48,7 @@ export default class ObjectType extends GenericType {
             if (key in this.#properties)
                 throw SE.extend_key_collision(key);
         }
-        const instance = new ObjectType({ ...this.#properties, ...properties }, this.#options);
-        instance[Loose] = this[Loose];
-        return instance;
+        return new ObjectType({ ...this.#properties, ...properties }, this[Loose], this.#options);
     }
     parse(u, options = {}) {
         const x = resolve(u);

package/lib/private/OmitType.d.ts

@@ -1,15 +1,18 @@
 import GenericType from "#GenericType";
 import type Infer from "#Infer";
+import Loose from "#Loose";
+import type Mode from "#Mode";
 import type ObjectType from "#ObjectType";
 import type Parsed from "#Parsed";
 import type ParseOptions from "#ParseOptions";
 import type Serialized from "#Serialized";
 import type { Dict } from "@rcompat/type";
-export default class OmitType<P extends Dict<Parsed<unknown>>, K extends keyof P> extends GenericType<Omit<P, K>, Omit<{
+export default class OmitType<P extends Dict<Parsed<unknown>>, K extends keyof P, M extends Mode = undefined> extends GenericType<Omit<P, K>, Omit<{
     [Key in keyof P]: Infer<P[Key]>;
 }, K>, "OmitType"> {
     #private;
-    constructor(type: ObjectType<P>, keys: K[]);
+    [Loose]: M;
+    constructor(type: ObjectType<P>, keys: K[], mode?: M);
     get name(): "omit";
     parse(u: unknown, options?: ParseOptions): Infer<this>;
     toJSON(): {

package/lib/private/OmitType.js

@@ -1,18 +1,21 @@
 import E from "#errors";
 import GenericType from "#GenericType";
+import Loose from "#Loose";
 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;
-    constructor(type, keys) {
+    [Loose];
+    constructor(type, keys, mode) {
         super();
         const props = { ...type.properties };
         for (const key of keys) {
             delete props[key];
         }
         this.#properties = props;
+        this[Loose] = mode;
     }
     get name() {
         return "omit";

package/lib/private/PartialType.d.ts

@@ -1,5 +1,7 @@
 import DefaultType from "#DefaultType";
 import type Infer from "#Infer";
+import Loose from "#Loose";
+import type Mode from "#Mode";
 import type ParseOptions from "#ParseOptions";
 import type Partialable from "#Partialable";
 import type DefaultTrait from "#trait/Default";
@@ -7,9 +9,10 @@ import VirtualType from "#VirtualType";
 type InferPartial<D extends Partialable> = {
     -readonly [K in keyof D]?: NonNullable<Infer<D[K]>>;
 };
-export default class PartialType<D extends Partialable> extends VirtualType<D, InferPartial<D>, "PartialType"> implements DefaultTrait<InferPartial<D>> {
+export default class PartialType<D extends Partialable, M extends Mode = undefined> extends VirtualType<D, InferPartial<D>, "PartialType"> implements DefaultTrait<InferPartial<D>> {
     #private;
-    constructor(spec: D);
+    [Loose]: M;
+    constructor(spec: D, mode?: M);
     get name(): "partial";
     get schema(): D;
     default(value: (() => InferPartial<D>) | InferPartial<D>): DefaultType<this, InferPartial<D>>;

package/lib/private/PartialType.js

@@ -1,5 +1,6 @@
 import DefaultType from "#DefaultType";
 import E from "#errors";
+import Loose from "#Loose";
 import ParsedKey from "#ParsedKey";
 import ParseError from "#ParseError";
 import join from "#path/join";
@@ -9,9 +10,11 @@ import VirtualType from "#VirtualType";
 import is from "@rcompat/is";
 export default class PartialType extends VirtualType {
     #spec;
-    constructor(spec) {
+    [Loose];
+    constructor(spec, mode) {
         super();
         this.#spec = spec;
+        this[Loose] = mode;
     }
     get name() {
         return "partial";

package/lib/private/RecordType.d.ts

@@ -5,9 +5,12 @@ import type Parsed from "#Parsed";
 import type ParseOptions from "#ParseOptions";
 import type RecordTypeKey from "#RecordTypeKey";
 import type OptionalTrait from "#trait/Optional";
-export default class RecordType<Key extends RecordTypeKey, Value extends Parsed<unknown>> extends GenericType<Value, Record<Infer<Key>, Infer<Value>>, "RecordType"> implements OptionalTrait {
+import type Mode from "#Mode";
+import Loose from "#Loose";
+export default class RecordType<Key extends RecordTypeKey, Value extends Parsed<unknown>, M extends Mode = undefined> extends GenericType<Value, Record<Infer<Key>, Infer<Value>>, "RecordType"> implements OptionalTrait {
     #private;
-    constructor(k: Key, v: Value);
+    [Loose]: M;
+    constructor(k: Key, v: Value, mode?: M);
     optional(): OptionalType<this>;
     get name(): "record";
     parse(u: unknown, options?: ParseOptions): Infer<this>;
@@ -16,11 +19,11 @@ export default class RecordType<Key extends RecordTypeKey, Value extends Parsed<
         key: {
             type: "string";
             datatype: "string";
-        } | {
-            type: "symbol";
         } | {
             type: "number" | "bigint";
             datatype: "f64";
+        } | {
+            type: "symbol";
         };
         value: import("./Serialized.js").default;
     };

package/lib/private/RecordType.js

@@ -6,13 +6,16 @@ import join from "#path/join";
 import next from "#path/next";
 import resolve from "#resolve";
 import is from "@rcompat/is";
+import Loose from "#Loose";
 export default class RecordType extends GenericType {
     #key;
     #value;
-    constructor(k, v) {
+    [Loose];
+    constructor(k, v, mode) {
         super();
         this.#key = k;
         this.#value = v;
+        this[Loose] = mode;
     }
     optional() {
         return new OptionalType(this);

package/lib/private/Serialized.d.ts

@@ -2,31 +2,31 @@ import type { Dict, JSONValue } from "@rcompat/type";
 type DT<D extends string = string> = {
     datatype?: D;
 };
-type PrimitiveSerialized = {
+type PrimitiveSerialized = ({
     type: "string";
-} & DT | {
+} & DT) | ({
     type: "boolean";
-} & DT | {
+} & DT) | ({
     type: "symbol";
-} & DT | {
+} & DT) | ({
     type: "null";
-} & DT | {
+} & DT) | ({
     type: "undefined";
-} & DT | {
+} & DT) | ({
     type: "date";
-} & DT | {
+} & DT) | ({
     type: "blob";
-} & DT | {
+} & DT) | ({
     type: "file";
-} & DT | {
+} & DT) | ({
     type: "url";
-} & DT | {
+} & DT) | ({
     type: "uuid";
-} & DT | {
+} & DT) | ({
     type: "uuid_v4";
-} & DT | {
+} & DT) | ({
     type: "uuid_v7";
-} & DT | {
+} & DT) | {
     type: "function";
 };
 type NumberSerialized = {

package/lib/private/StoreType.d.ts

@@ -8,6 +8,6 @@ export default class StoreType<S extends StoreSchema> extends ObjectType<S> {
     constructor(properties: S, pk?: string | null);
     get name(): string;
     parse(u: unknown, options?: ParseOptions): Infer<this>;
-    partial(): PartialType<any>;
+    partial(): PartialType<any, undefined>;
 }
 //# sourceMappingURL=StoreType.d.ts.map

package/lib/private/TupleType.d.ts

@@ -1,5 +1,7 @@
 import GenericType from "#GenericType";
 import type Infer from "#Infer";
+import Loose from "#Loose";
+import type Mode from "#Mode";
 import type NormalizeSchema from "#NormalizeSchema";
 import OptionalType from "#OptionalType";
 import type Parsed from "#Parsed";
@@ -9,9 +11,10 @@ import type OptionalTrait from "#trait/Optional";
 type InferTuple<T extends Schema[]> = {
     [K in keyof T]: T[K] extends Schema ? NormalizeSchema<T[K]>["infer"] : "tuple-never";
 };
-export default class TupleType<T extends Parsed<unknown>[]> extends GenericType<T, InferTuple<T>, "TupleType"> implements OptionalTrait {
+export default class TupleType<T extends Parsed<unknown>[], M extends Mode = undefined> extends GenericType<T, InferTuple<T>, "TupleType"> implements OptionalTrait {
     #private;
-    constructor(items: T);
+    [Loose]: M;
+    constructor(items: T, mode?: M);
     get name(): "tuple";
     optional(): OptionalType<this>;
     parse(u: unknown, options?: ParseOptions): Infer<this>;

package/lib/private/TupleType.js

@@ -7,9 +7,11 @@ import resolve from "#resolve";
 import is from "@rcompat/is";
 export default class TupleType extends GenericType {
     #items;
-    constructor(items) {
+    [Loose];
+    constructor(items, mode) {
         super();
         this.#items = items;
+        this[Loose] = mode;
     }
     get name() {
         return "tuple";

package/lib/private/URLType.d.ts

@@ -1,6 +1,10 @@
 import BuiltinType from "#BuiltinType";
+import CoerceKey from "#CoerceKey";
+import Loose from "#Loose";
 import Storable from "#Storable";
-export default class URLType extends BuiltinType<URL, "URLType"> implements Storable<"url"> {
+export default class URLType<M extends boolean | undefined = undefined> extends BuiltinType<URL, "URLType"> implements Storable<"url"> {
+    [Loose]: M;
+    constructor(mode?: M);
     get Type(): {
         new (url: string | URL, base?: string | URL): URL;
         prototype: URL;
@@ -11,6 +15,7 @@ export default class URLType extends BuiltinType<URL, "URLType"> implements Stor
     };
     get name(): "url";
     get datatype(): "url";
+    [CoerceKey](x: unknown): unknown;
     toJSON(): {
         type: "url";
         datatype: "url";

package/lib/private/URLType.js

@@ -1,6 +1,17 @@
 import BuiltinType from "#BuiltinType";
+import CoerceKey from "#CoerceKey";
+import Loose from "#Loose";
 import Storable from "#Storable";
+import is from "@rcompat/is";
 export default class URLType extends BuiltinType {
+    [Loose];
+    constructor(mode) {
+        super();
+        this[Loose] = mode;
+    }
+    /*get [as.out](): L extends true ? "text" : never {
+      return (this[Loose] === true ? as.$("text") : as.$()) as never;
+    }*/
     get Type() {
         return URL;
     }
@@ -10,6 +21,16 @@ export default class URLType extends BuiltinType {
     get datatype() {
         return "url";
     }
+    [CoerceKey](x) {
+        if (!is.string(x))
+            return x;
+        try {
+            return new URL(x);
+        }
+        catch {
+            return x;
+        }
+    }
     toJSON() {
         return Storable.serialize(this);
     }

package/lib/private/UintType.d.ts

@@ -4,7 +4,7 @@ import NumericType from "#NumericType";
 import type ParseOptions from "#ParseOptions";
 import type Storable from "#Storable";
 import type UintDataType from "#UintDataType";
-export default class UintType<T extends UintDataType> extends NumericType<T, number, "UintType"> implements Storable<T> {
+export default class UintType<T extends UintDataType, L extends boolean | undefined = undefined> extends NumericType<T, number, "UintType", L> implements Storable<T> {
     [CoerceKey]: typeof coerce;
     get name(): string;
     /**

package/lib/private/UnionType.d.ts

@@ -1,4 +1,5 @@
 import DefaultType from "#DefaultType";
+import type Mode from "#Mode";
 import GenericType from "#GenericType";
 import type Infer from "#Infer";
 import type NormalizeSchema from "#NormalizeSchema";
@@ -9,12 +10,14 @@ import type Schema from "#Schema";
 import type DefaultTrait from "#trait/Default";
 import type OptionalTrait from "#trait/Optional";
 import type { TupleToUnion } from "@rcompat/type";
+import Loose from "#Loose";
 type InferUnion<T extends Schema[]> = TupleToUnion<{
     [K in keyof T]: T[K] extends Schema ? NormalizeSchema<T[K]>["infer"] : "union-never";
 }>;
-export default class UnionType<T extends Parsed<unknown>[]> extends GenericType<T, InferUnion<T>, "UnionType"> implements OptionalTrait, DefaultTrait<InferUnion<T>> {
+export default class UnionType<T extends Parsed<unknown>[], M extends Mode = undefined> extends GenericType<T, InferUnion<T>, "UnionType"> implements OptionalTrait, DefaultTrait<InferUnion<T>> {
     #private;
-    constructor(of: T);
+    [Loose]: M;
+    constructor(of: T, mode?: M);
     get name(): "union";
     get schema(): T;
     optional(): OptionalType<this>;