typia 5.3.12-dev.20240118 → 5.3.12-dev.20240121

package/src/index.ts

@@ -1,4 +1,4 @@
-import * as typia from "./module";
-
-export default typia;
-export * from "./module";
+import * as typia from "./module";
+
+export default typia;
+export * from "./module";

package/src/json.ts

@@ -130,9 +130,9 @@ function assertParse<T>(input: string): Primitive<T>;
 function assertParse<T>(): Primitive<T> {
   halt("assertParse");
 }
-const assertParsePure = /** @__PURE__ */ Object.assign(
+const assertParsePure = /** @__PURE__ */ Object.assign<typeof assertParse, {}>(
   assertParse,
-  /** @__PURE__ */ Namespace.assert("json.assertParse")
+  /** @__PURE__ */ Namespace.assert("json.assertParse"),
 );
 export { assertParsePure as assertParse };
 
@@ -182,7 +182,10 @@ function isParse<T>(input: string): Primitive<T> | null;
 function isParse<T>(): Primitive<T> | null {
   halt("isParse");
 }
-const isParsePure = /** @__PURE__ */ Object.assign(isParse, /** @__PURE__ */ Namespace.is());
+const isParsePure = /** @__PURE__ */ Object.assign<typeof isParse, {}>(
+  isParse,
+  /** @__PURE__ */ Namespace.is(),
+);
 export { isParsePure as isParse };
 
 /**
@@ -233,7 +236,10 @@ function validateParse<T>(input: string): IValidation<Primitive<T>>;
 function validateParse<T>(): IValidation<Primitive<T>> {
   halt("validateParse");
 }
-const validateParsePure = /** @__PURE__ */ Object.assign(validateParse, /** @__PURE__ */ Namespace.validate());
+const validateParsePure = /** @__PURE__ */ Object.assign<
+  typeof validateParse,
+  {}
+>(validateParse, /** @__PURE__ */ Namespace.validate());
 export { validateParsePure as validateParse };
 
 /* -----------------------------------------------------------
@@ -269,9 +275,9 @@ function stringify<T>(input: T): string;
 function stringify(): never {
   halt("stringify");
 }
-const stringifyPure = /** @__PURE__ */ Object.assign(
+const stringifyPure = /** @__PURE__ */ Object.assign<typeof stringify, {}>(
   stringify,
-  /** @__PURE__ */ Namespace.json.stringify("stringify")
+  /** @__PURE__ */ Namespace.json.stringify("stringify"),
 );
 export { stringifyPure as stringify };
 
@@ -327,10 +333,14 @@ function assertStringify<T>(input: T): unknown;
 function assertStringify(): string {
   halt("assertStringify");
 }
-const assertStringifyPure = /** @__PURE__ */ Object.assign(
+const assertStringifyPure = /** @__PURE__ */ Object.assign<
+  typeof assertStringify,
+  {},
+  {}
+>(
   assertStringify,
   /** @__PURE__ */ Namespace.assert("json.assertStringify"),
-  /** @__PURE__ */ Namespace.json.stringify("assertStringify")
+  /** @__PURE__ */ Namespace.json.stringify("assertStringify"),
 );
 export { assertStringifyPure as assertStringify };
 
@@ -387,10 +397,14 @@ function isStringify(): string | null {
   halt("isStringify");
 }
 
-const isStringifyPure = /** @__PURE__ */ Object.assign(
+const isStringifyPure = /** @__PURE__ */ Object.assign<
+  typeof isStringify,
+  {},
+  {}
+>(
   isStringify,
   /** @__PURE__ */ Namespace.is(),
-  /** @__PURE__ */ Namespace.json.stringify("isStringify")
+  /** @__PURE__ */ Namespace.json.stringify("isStringify"),
 );
 export { isStringifyPure as isStringify };
 
@@ -448,7 +462,11 @@ function validateStringify<T>(input: unknown): IValidation<string>;
 function validateStringify(): IValidation<string> {
   halt("validateStringify");
 }
-const validateStringifyPure = /** @__PURE__ */ Object.assign(
+const validateStringifyPure = /** @__PURE__ */ Object.assign<
+  typeof validateStringify,
+  {},
+  {}
+>(
   validateStringify,
   /** @__PURE__ */ Namespace.validate(),
   /** @__PURE__ */ Namespace.json.stringify("validateStringify"),
@@ -485,7 +503,10 @@ function createIsParse<T>(): (input: string) => Primitive<T> | null;
 function createIsParse<T>(): (input: string) => Primitive<T> | null {
   halt("createIsParse");
 }
-const createIsParsePure = /** @__PURE__ */ Object.assign(createIsParse, isParse);
+const createIsParsePure = /** @__PURE__ */ Object.assign<
+  typeof createIsParse,
+  {}
+>(createIsParse, isParsePure);
 export { createIsParsePure as createIsParse };
 
 /**
@@ -515,7 +536,10 @@ function createAssertParse<T>(): (input: string) => Primitive<T>;
 function createAssertParse<T>(): (input: string) => Primitive<T> {
   halt("createAssertParse");
 }
-const createAssertParsePure = /** @__PURE__ */ Object.assign(createAssertParse, assertParse);
+const createAssertParsePure = /** @__PURE__ */ Object.assign<
+  typeof createAssertParse,
+  {}
+>(createAssertParse, assertParsePure);
 export { createAssertParsePure as createAssertParse };
 
 /**
@@ -537,9 +561,7 @@ function createValidateParse(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createValidateParse<T>(): (
-  input: string,
-) => IValidation<Primitive<T>>;
+function createValidateParse<T>(): (input: string) => IValidation<Primitive<T>>;
 
 /**
  * @internal
@@ -550,7 +572,10 @@ function createValidateParse<T>(): (
   halt("createValidateParse");
 }
 
-const createValidateParsePure = /** @__PURE__ */ Object.assign(createValidateParse, validateParse);
+const createValidateParsePure = /** @__PURE__ */ Object.assign<
+  typeof createValidateParse,
+  {}
+>(createValidateParse, validateParsePure);
 export { createValidateParsePure as createValidateParse };
 
 /**
@@ -581,7 +606,10 @@ function createStringify<T>(): (input: T) => string {
   halt("createStringify");
 }
 
-const createStringifyPure = /** @__PURE__ */ Object.assign(createStringify, stringify);
+const createStringifyPure = /** @__PURE__ */ Object.assign<
+  typeof createStringify,
+  {}
+>(createStringify, stringifyPure);
 export { createStringifyPure as createStringify };
 
 /**
@@ -612,7 +640,10 @@ function createAssertStringify(): (input: unknown) => string {
   halt("createAssertStringify");
 }
 
-const createAssertStringifyPure = /** @__PURE__ */ Object.assign(createAssertStringify, assertStringify);
+const createAssertStringifyPure = /** @__PURE__ */ Object.assign<
+  typeof createAssertStringify,
+  {}
+>(createAssertStringify, assertStringifyPure);
 export { createAssertStringifyPure as createAssertStringify };
 
 /**
@@ -643,7 +674,10 @@ function createIsStringify(): (input: unknown) => string | null {
   halt("createIsStringify");
 }
 
-const createIsStringifyPure = /** @__PURE__ */ Object.assign(createIsStringify, isStringify);
+const createIsStringifyPure = /** @__PURE__ */ Object.assign<
+  typeof createIsStringify,
+  {}
+>(createIsStringify, isStringifyPure);
 export { createIsStringifyPure as createIsStringify };
 
 /**
@@ -665,20 +699,19 @@ function createValidateStringify(): never;
 
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createValidateStringify<T>(): (
-  input: unknown,
-) => IValidation<string>;
+function createValidateStringify<T>(): (input: unknown) => IValidation<string>;
 
 /**
  * @internal
  */
-function createValidateStringify(): (
-  input: unknown,
-) => IValidation<string> {
+function createValidateStringify(): (input: unknown) => IValidation<string> {
   halt("createValidateStringify");
 }
 
-const createValidateStringifyPure = /** @__PURE__ */ Object.assign(createValidateStringify, validateStringify);
+const createValidateStringifyPure = /** @__PURE__ */ Object.assign<
+  typeof createValidateStringify,
+  {}
+>(createValidateStringify, validateStringifyPure);
 export { createValidateStringifyPure as createValidateStringify };
 
 /**

package/src/misc.ts

@@ -84,7 +84,10 @@ function clone<T>(input: T): Resolved<T>;
 function clone(): never {
   halt("clone");
 }
-const clonePure = /** @__PURE__ */ Object.assign(clone, /** @__PURE__ */ Namespace.misc.clone("clone"));
+const clonePure = /** @__PURE__ */ Object.assign<typeof clone, {}>(
+  clone,
+  /** @__PURE__ */ Namespace.misc.clone("clone"),
+);
 export { clonePure as clone };
 
 /**
@@ -131,10 +134,14 @@ function assertClone<T>(input: unknown): Resolved<T>;
 function assertClone(): never {
   halt("assertClone");
 }
-const assertClonePure = /** @__PURE__ */ Object.assign(
+const assertClonePure = /** @__PURE__ */ Object.assign<
+  typeof assertClone,
+  {},
+  {}
+>(
   assertClone,
   /** @__PURE__ */ Namespace.assert("misc.assertClone"),
-  /** @__PURE__ */ Namespace.misc.clone("assertClone")
+  /** @__PURE__ */ Namespace.misc.clone("assertClone"),
 );
 export { assertClonePure as assertClone };
 
@@ -182,10 +189,10 @@ function isClone<T>(input: unknown): Resolved<T> | null;
 function isClone(): never {
   halt("isClone");
 }
-const isClonePure = /** @__PURE__ */ Object.assign(
+const isClonePure = /** @__PURE__ */ Object.assign<typeof isClone, {}, {}>(
   isClone,
   /** @__PURE__ */ Namespace.is(),
-  /** @__PURE__ */ Namespace.misc.clone("isClone")
+  /** @__PURE__ */ Namespace.misc.clone("isClone"),
 );
 export { isClonePure as isClone };
 
@@ -231,10 +238,14 @@ function validateClone<T>(input: unknown): IValidation<Resolved<T>>;
 function validateClone(): never {
   halt("validateClone");
 }
-const validateClonePure = /** @__PURE__ */ Object.assign(
+const validateClonePure = /** @__PURE__ */ Object.assign<
+  typeof validateClone,
+  {},
+  {}
+>(
   validateClone,
   /** @__PURE__ */ Namespace.validate(),
-  /** @__PURE__ */ Namespace.misc.clone("validateClone")
+  /** @__PURE__ */ Namespace.misc.clone("validateClone"),
 );
 export { validateClonePure as validateClone };
 
@@ -270,9 +281,9 @@ function prune<T extends object>(input: T): void;
 function prune(): never {
   halt("prune");
 }
-const prunePure = /** @__PURE__ */ Object.assign(
+const prunePure = /** @__PURE__ */ Object.assign<typeof prune, {}>(
   prune,
-  /** @__PURE__ */ Namespace.misc.prune("prune")
+  /** @__PURE__ */ Namespace.misc.prune("prune"),
 );
 export { prunePure as prune };
 
@@ -318,10 +329,14 @@ function assertPrune<T>(input: unknown): T;
 function assertPrune(): unknown {
   halt("assertPrune");
 }
-const assertPrunePure = /** @__PURE__ */ Object.assign(
+const assertPrunePure = /** @__PURE__ */ Object.assign<
+  typeof assertPrune,
+  {},
+  {}
+>(
   assertPrune,
   /** @__PURE__ */ Namespace.assert("misc.assertPrune"),
-  /** @__PURE__ */ Namespace.misc.prune("assertPrune")
+  /** @__PURE__ */ Namespace.misc.prune("assertPrune"),
 );
 export { assertPrunePure as assertPrune };
 
@@ -369,10 +384,10 @@ function isPrune<T>(input: unknown): input is T;
 function isPrune(): never {
   halt("isPrune");
 }
-const isPrunePure = /** @__PURE__ */ Object.assign(
+const isPrunePure = /** @__PURE__ */ Object.assign<typeof isPrune, {}, {}>(
   isPrune,
   /** @__PURE__ */ Namespace.is(),
-  /** @__PURE__ */ Namespace.misc.prune("isPrune")
+  /** @__PURE__ */ Namespace.misc.prune("isPrune"),
 );
 export { isPrunePure as isPrune };
 
@@ -423,10 +438,14 @@ function validatePrune<T>(): IValidation<T> {
   halt("validatePrune");
 }
 
-const validatePrunePure = /** @__PURE__ */ Object.assign(
+const validatePrunePure = /** @__PURE__ */ Object.assign<
+  typeof validatePrune,
+  {},
+  {}
+>(
   validatePrune,
   /** @__PURE__ */ Namespace.misc.prune("validatePrune"),
-  /** @__PURE__ */ Namespace.validate()
+  /** @__PURE__ */ Namespace.validate(),
 );
 export { validatePrunePure as validatePrune };
 
@@ -460,7 +479,10 @@ function createClone<T>(): (input: T) => Resolved<T>;
 function createClone(): never {
   halt("createClone");
 }
-const createClonePure = /** @__PURE__ */ Object.assign(createClone, clone);
+const createClonePure = /** @__PURE__ */ Object.assign<typeof createClone, {}>(
+  createClone,
+  clonePure,
+);
 export { createClonePure as createClone };
 
 /**
@@ -490,7 +512,10 @@ function createAssertClone<T>(): (input: unknown) => Resolved<T>;
 function createAssertClone(): never {
   halt("createAssertClone");
 }
-const createAssertClonePure = /** @__PURE__ */ Object.assign(createAssertClone, assertClone);
+const createAssertClonePure = /** @__PURE__ */ Object.assign<
+  typeof createAssertClone,
+  {}
+>(createAssertClone, assertClonePure);
 export { createAssertClonePure as createAssertClone };
 
 /**
@@ -520,7 +545,10 @@ function createIsClone<T>(): (input: unknown) => Resolved<T> | null;
 function createIsClone(): never {
   halt("createIsClone");
 }
-const createIsClonePure = /** @__PURE__ */ Object.assign(createIsClone, isClone);
+const createIsClonePure = /** @__PURE__ */ Object.assign<
+  typeof createIsClone,
+  {}
+>(createIsClone, isClonePure);
 export { createIsClonePure as createIsClone };
 
 /**
@@ -542,9 +570,7 @@ function createValidateClone(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createValidateClone<T>(): (
-  input: unknown,
-) => IValidation<Resolved<T>>;
+function createValidateClone<T>(): (input: unknown) => IValidation<Resolved<T>>;
 
 /**
  * @internal
@@ -552,7 +578,10 @@ function createValidateClone<T>(): (
 function createValidateClone(): never {
   halt("createValidateClone");
 }
-const createValidateClonePure = /** @__PURE__ */ Object.assign(createValidateClone, validateClone);
+const createValidateClonePure = /** @__PURE__ */ Object.assign<
+  typeof createValidateClone,
+  {}
+>(createValidateClone, validateClonePure);
 export { createValidateClonePure as createValidateClone };
 
 /**
@@ -582,7 +611,10 @@ function createPrune<T extends object>(): (input: T) => void;
 function createPrune<T extends object>(): (input: T) => void {
   halt("createPrune");
 }
-const createPrunePure = /** @__PURE__ */ Object.assign(createPrune, prune);
+const createPrunePure = /** @__PURE__ */ Object.assign<typeof createPrune, {}>(
+  createPrune,
+  prunePure,
+);
 export { createPrunePure as createPrune };
 
 /**
@@ -612,7 +644,10 @@ function createAssertPrune<T extends object>(): (input: T) => T;
 function createAssertPrune<T extends object>(): (input: T) => T {
   halt("createAssertPrune");
 }
-const createAssertPrunePure = /** @__PURE__ */ Object.assign(createAssertPrune, assertPrune);
+const createAssertPrunePure = /** @__PURE__ */ Object.assign<
+  typeof createAssertPrune,
+  {}
+>(createAssertPrune, assertPrunePure);
 export { createAssertPrunePure as createAssertPrune };
 
 /**
@@ -642,7 +677,10 @@ function createIsPrune<T extends object>(): (input: T) => input is T;
 function createIsPrune<T extends object>(): (input: T) => input is T {
   halt("createIsPrune");
 }
-const createIsPrunePure = /** @__PURE__ */ Object.assign(createIsPrune, isPrune);
+const createIsPrunePure = /** @__PURE__ */ Object.assign<
+  typeof createIsPrune,
+  {}
+>(createIsPrune, isPrunePure);
 export { createIsPrunePure as createIsPrune };
 
 /**
@@ -664,19 +702,18 @@ function createValidatePrune(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createValidatePrune<T extends object>(): (
-  input: T,
-) => IValidation<T>;
+function createValidatePrune<T extends object>(): (input: T) => IValidation<T>;
 
 /**
  * @internal
  */
-function createValidatePrune<T extends object>(): (
-  input: T,
-) => IValidation<T> {
+function createValidatePrune<T extends object>(): (input: T) => IValidation<T> {
   halt("createValidatePrune");
 }
-const createValidatePrunePure = /** @__PURE__ */ Object.assign(createValidatePrune, validatePrune);
+const createValidatePrunePure = /** @__PURE__ */ Object.assign<
+  typeof createValidatePrune,
+  {}
+>(createValidatePrune, validatePrunePure);
 export { createValidatePrunePure as createValidatePrune };
 
 /**

package/src/module.ts

@@ -85,7 +85,10 @@ function assert<T>(input: unknown): T;
 function assert(): never {
   halt("assert");
 }
-const assertPure = /** @__PURE__ */ Object.assign(assert, /** @__PURE__ */ Namespace.assert("assert"));
+const assertPure = /** @__PURE__ */ Object.assign<typeof assert, {}>(
+  assert,
+  /** @__PURE__ */ Namespace.assert("assert"),
+);
 export { assertPure as assert };
 
 /**
@@ -146,7 +149,10 @@ function assertGuard<T>(input: unknown): asserts input is T;
 function assertGuard(): never {
   halt("assertGuard");
 }
-const assertGuardPure = /** @__PURE__ */ Object.assign(assertGuard, /** @__PURE__ */ Namespace.assert("assertGuard"));
+const assertGuardPure = /** @__PURE__ */ Object.assign<typeof assertGuard, {}>(
+  assertGuard,
+  /** @__PURE__ */ Namespace.assert("assertGuard"),
+);
 export { assertGuardPure as assertGuard };
 
 /**
@@ -203,7 +209,10 @@ function is<T>(input: unknown): input is T;
 function is(): never {
   halt("is");
 }
-const isPure = /** @__PURE__ */ Object.assign(is, /** @__PURE__ */ Namespace.assert("is"));
+const isPure = /** @__PURE__ */ Object.assign<typeof is, {}>(
+  is,
+  /** @__PURE__ */ Namespace.assert("is"),
+);
 export { isPure as is };
 
 /**
@@ -262,7 +271,10 @@ function validate<T>(input: unknown): IValidation<T>;
 function validate(): never {
   halt("validate");
 }
-const validatePure = /** @__PURE__ */ Object.assign(validate, /** @__PURE__ */ Namespace.validate());
+const validatePure = /** @__PURE__ */ Object.assign<typeof validate, {}>(
+  validate,
+  /** @__PURE__ */ Namespace.validate(),
+);
 export { validatePure as validate };
 
 /* -----------------------------------------------------------
@@ -324,7 +336,10 @@ function assertEquals<T>(input: unknown): T;
 function assertEquals(): never {
   halt("assertEquals");
 }
-const assertEqualsPure = /** @__PURE__ */ Object.assign(assertEquals, /** @__PURE__ */ Namespace.assert("assertEquals"));
+const assertEqualsPure = /** @__PURE__ */ Object.assign<
+  typeof assertEquals,
+  {}
+>(assertEquals, /** @__PURE__ */ Namespace.assert("assertEquals"));
 export { assertEqualsPure as assertEquals };
 
 /**
@@ -391,7 +406,10 @@ function assertGuardEquals<T>(input: unknown): asserts input is T;
 function assertGuardEquals(): never {
   halt("assertGuardEquals");
 }
-const assertGuardEqualsPure = /** @__PURE__ */ Object.assign(assertGuardEquals, /** @__PURE__ */ Namespace.assert("assertGuardEquals"));
+const assertGuardEqualsPure = /** @__PURE__ */ Object.assign<
+  typeof assertGuardEquals,
+  {}
+>(assertGuardEquals, /** @__PURE__ */ Namespace.assert("assertGuardEquals"));
 export { assertGuardEqualsPure as assertGuardEquals };
 
 /**
@@ -450,7 +468,10 @@ function equals<T>(input: unknown): input is T;
 function equals(): never {
   halt("equals");
 }
-const equalsPure = /** @__PURE__ */ Object.assign(equals, /** @__PURE__ */ Namespace.is());
+const equalsPure = /** @__PURE__ */ Object.assign<typeof equals, {}>(
+  equals,
+  /** @__PURE__ */ Namespace.is(),
+);
 export { equalsPure as equals };
 
 /**
@@ -511,7 +532,10 @@ function validateEquals<T>(input: unknown): IValidation<T>;
 function validateEquals(): never {
   halt("validateEquals");
 }
-const validateEqualsPure = /** @__PURE__ */ Object.assign(validateEquals, /** @__PURE__ */ Namespace.validate());
+const validateEqualsPure = /** @__PURE__ */ Object.assign<
+  typeof validateEquals,
+  {}
+>(validateEquals, /** @__PURE__ */ Namespace.validate());
 export { validateEqualsPure as validateEquals };
 
 /* -----------------------------------------------------------
@@ -561,7 +585,10 @@ function random<T>(generator?: Partial<IRandomGenerator>): Resolved<T>;
 function random(): never {
   halt("random");
 }
-const randomPure = /** @__PURE__ */ Object.assign(random, /** @__PURE__ */ Namespace.random());
+const randomPure = /** @__PURE__ */ Object.assign<typeof random, {}>(
+  random,
+  /** @__PURE__ */ Namespace.random(),
+);
 export { randomPure as random };
 
 /* -----------------------------------------------------------
@@ -594,7 +621,10 @@ function createAssert<T>(): (input: unknown) => T;
 function createAssert<T>(): (input: unknown) => T {
   halt("createAssert");
 }
-const createAssertPure = /** @__PURE__ */ Object.assign(createAssert, assert);
+const createAssertPure = /** @__PURE__ */ Object.assign<
+  typeof createAssert,
+  {}
+>(createAssert, assertPure);
 export { createAssertPure as createAssert };
 
 /**
@@ -654,7 +684,10 @@ function createAssertGuard<T>(): (input: unknown) => AssertionGuard<T>;
 function createAssertGuard<T>(): (input: unknown) => AssertionGuard<T> {
   halt("createAssertGuard");
 }
-const createAssertGuardPure = /** @__PURE__ */ Object.assign(createAssertGuard, assertGuard);
+const createAssertGuardPure = /** @__PURE__ */ Object.assign<
+  typeof createAssertGuard,
+  {}
+>(createAssertGuard, assertGuardPure);
 export { createAssertGuardPure as createAssertGuard };
 
 /**
@@ -684,7 +717,10 @@ function createIs<T>(): (input: unknown) => input is T;
 function createIs<T>(): (input: unknown) => input is T {
   halt("createIs");
 }
-const createIsPure = /** @__PURE__ */ Object.assign(createIs, is);
+const createIsPure = /** @__PURE__ */ Object.assign<typeof createIs, {}>(
+  createIs,
+  isPure,
+);
 export { createIsPure as createIs };
 
 /**
@@ -714,7 +750,10 @@ function createValidate<T>(): (input: unknown) => IValidation<T>;
 function createValidate(): (input: unknown) => IValidation {
   halt("createValidate");
 }
-const createValidatePure = /** @__PURE__ */ Object.assign(createValidate, validate);
+const createValidatePure = /** @__PURE__ */ Object.assign<
+  typeof createValidate,
+  {}
+>(createValidate, validatePure);
 export { createValidatePure as createValidate };
 
 /**
@@ -744,7 +783,10 @@ function createAssertEquals<T>(): (input: unknown) => T;
 function createAssertEquals<T>(): (input: unknown) => T {
   halt("createAssertEquals");
 }
-const createAssertEqualsPure = /** @__PURE__ */ Object.assign(createAssertEquals, assertEquals);
+const createAssertEqualsPure = /** @__PURE__ */ Object.assign<
+  typeof createAssertEquals,
+  {}
+>(createAssertEquals, assertEqualsPure);
 export { createAssertEqualsPure as createAssertEquals };
 
 /**
@@ -796,19 +838,18 @@ function createAssertGuardEquals(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createAssertGuardEquals<T>(): (
-  input: unknown,
-) => AssertionGuard<T>;
+function createAssertGuardEquals<T>(): (input: unknown) => AssertionGuard<T>;
 
 /**
  * @internal
  */
-function createAssertGuardEquals<T>(): (
-  input: unknown,
-) => AssertionGuard<T> {
+function createAssertGuardEquals<T>(): (input: unknown) => AssertionGuard<T> {
   halt("createAssertGuardEquals");
 }
-const createAssertGuardEqualsPure = /** @__PURE__ */ Object.assign(createAssertGuardEquals, assertGuardEquals);
+const createAssertGuardEqualsPure = /** @__PURE__ */ Object.assign<
+  typeof createAssertGuardEquals,
+  {}
+>(createAssertGuardEquals, assertGuardEqualsPure);
 export { createAssertGuardEqualsPure as createAssertGuardEquals };
 
 /**
@@ -838,7 +879,10 @@ function createEquals<T>(): (input: unknown) => input is T;
 function createEquals<T>(): (input: unknown) => input is T {
   halt("createEquals");
 }
-const createEqualsPure = /** @__PURE__ */ Object.assign(createEquals, equals);
+const createEqualsPure = /** @__PURE__ */ Object.assign<
+  typeof createEquals,
+  {}
+>(createEquals, equalsPure);
 export { createEqualsPure as createEquals };
 
 /**
@@ -868,7 +912,10 @@ function createValidateEquals<T>(): (input: unknown) => IValidation<T>;
 function createValidateEquals(): (input: unknown) => IValidation {
   halt("createValidateEquals");
 }
-const createValidateEqualsPure = /** @__PURE__ */ Object.assign(createValidateEquals, validateEquals);
+const createValidateEqualsPure = /** @__PURE__ */ Object.assign<
+  typeof createValidateEquals,
+  {}
+>(createValidateEquals, validateEqualsPure);
 export { createValidateEqualsPure as createValidateEquals };
 
 /**
@@ -902,7 +949,10 @@ function createRandom<T>(
 function createRandom(): never {
   halt("createRandom");
 }
-const createRandomPure = /** @__PURE__ */ Object.assign(createRandom, random);
+const createRandomPure = /** @__PURE__ */ Object.assign<
+  typeof createRandom,
+  {}
+>(createRandom, randomPure);
 export { createRandomPure as createRandom };
 
 /**