typia 5.4.14 → 5.5.0-dev.20240302

package/src/json.ts

@@ -4,6 +4,7 @@ import { IJsonApplication } from "./schemas/json/IJsonApplication";
 
 import { IValidation } from "./IValidation";
 import { Primitive } from "./Primitive";
+import { TypeGuardError } from "./TypeGuardError";
 
 /* ===========================================================
     JSON
@@ -103,7 +104,10 @@ export function application(): never {
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function assertParse(input: string): never;
+function assertParse(
+  input: string,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): never;
 
 /**
  * Safe `JSON.parse()` function with type assertion.
@@ -122,7 +126,10 @@ function assertParse(input: string): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function assertParse<T>(input: string): Primitive<T>;
+function assertParse<T>(
+  input: string,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): Primitive<T>;
 
 /**
  * @internal
@@ -302,7 +309,10 @@ export { stringifyPure as stringify };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function assertStringify<T>(input: T): string;
+function assertStringify<T>(
+  input: T,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): string;
 
 /**
  * 5x faster `JSON.stringify()` function with type assertion.
@@ -325,7 +335,10 @@ function assertStringify<T>(input: T): string;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function assertStringify<T>(input: T): unknown;
+function assertStringify<T>(
+  input: T,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): unknown;
 
 /**
  * @internal
@@ -518,7 +531,9 @@ export { createIsParsePure as createIsParse };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createAssertParse(): never;
+function createAssertParse(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): never;
 
 /**
  * Creates a reusable {@link assertParse} function.
@@ -528,7 +543,9 @@ function createAssertParse(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createAssertParse<T>(): (input: string) => Primitive<T>;
+function createAssertParse<T>(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): (input: string) => Primitive<T>;
 
 /**
  * @internal
@@ -621,7 +638,9 @@ export { createStringifyPure as createStringify };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createAssertStringify(): never;
+function createAssertStringify(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): never;
 
 /**
  * Creates a reusable {@link assertStringify} function.
@@ -631,7 +650,9 @@ function createAssertStringify(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createAssertStringify<T>(): (input: unknown) => string;
+function createAssertStringify<T>(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): (input: unknown) => string;
 
 /**
  * @internal

package/src/misc.ts

@@ -13,6 +13,7 @@ import { Atomic } from "./typings/Atomic";
 
 import { IValidation } from "./IValidation";
 import { Resolved } from "./Resolved";
+import { TypeGuardError } from "./TypeGuardError";
 
 /**
  * > You must configure the generic argument `T`.
@@ -107,7 +108,10 @@ export { clonePure as clone };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function assertClone<T>(input: T): Resolved<T>;
+function assertClone<T>(
+  input: T,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): Resolved<T>;
 
 /**
  * Clone a data with type assertion.
@@ -126,7 +130,10 @@ function assertClone<T>(input: T): Resolved<T>;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function assertClone<T>(input: unknown): Resolved<T>;
+function assertClone<T>(
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): Resolved<T>;
 
 /**
  * @internal
@@ -303,7 +310,10 @@ export { prunePure as prune };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function assertPrune<T>(input: T): T;
+function assertPrune<T>(
+  input: T,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): T;
 
 /**
  * Prune, erase superfluous properties, with type assertion.
@@ -321,7 +331,10 @@ function assertPrune<T>(input: T): T;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function assertPrune<T>(input: unknown): T;
+function assertPrune<T>(
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): T;
 
 /**
  * @internal
@@ -494,7 +507,9 @@ export { createClonePure as createClone };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createAssertClone(): never;
+function createAssertClone(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): never;
 
 /**
  * Creates a resuable {@link assertClone} function.
@@ -504,7 +519,9 @@ function createAssertClone(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createAssertClone<T>(): (input: unknown) => Resolved<T>;
+function createAssertClone<T>(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): (input: unknown) => Resolved<T>;
 
 /**
  * @internal
@@ -626,7 +643,9 @@ export { createPrunePure as createPrune };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createAssertPrune(): never;
+function createAssertPrune(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): never;
 
 /**
  * Creates a resuable {@link assertPrune} function.
@@ -636,7 +655,9 @@ function createAssertPrune(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createAssertPrune<T extends object>(): (input: T) => T;
+function createAssertPrune<T extends object>(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): (input: T) => T;
 
 /**
  * @internal

package/src/module.ts

@@ -4,6 +4,7 @@ import { AssertionGuard } from "./AssertionGuard";
 import { IRandomGenerator } from "./IRandomGenerator";
 import { IValidation } from "./IValidation";
 import { Resolved } from "./Resolved";
+import { TypeGuardError } from "./TypeGuardError";
 
 export * as http from "./http";
 export * as json from "./json";
@@ -54,7 +55,10 @@ export * from "./SnakeCase";
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function assert<T>(input: T): T;
+function assert<T>(
+  input: T,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): T;
 
 /**
  * Asserts a value type.
@@ -77,7 +81,10 @@ function assert<T>(input: T): T;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function assert<T>(input: unknown): T;
+function assert<T>(
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): T;
 
 /**
  * @internal
@@ -115,7 +122,10 @@ export { assertPure as assert };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function assertGuard<T>(input: T): asserts input is T;
+function assertGuard<T>(
+  input: T,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): asserts input is T;
 
 /**
  * Assertion guard of a value type.
@@ -141,7 +151,10 @@ function assertGuard<T>(input: T): asserts input is T;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function assertGuard<T>(input: unknown): asserts input is T;
+function assertGuard<T>(
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): asserts input is T;
 
 /**
  * @internal
@@ -303,7 +316,10 @@ export { validatePure as validate };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function assertEquals<T>(input: T): T;
+function assertEquals<T>(
+  input: T,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): T;
 
 /**
  * Asserts equality between a value and its type.
@@ -328,7 +344,10 @@ function assertEquals<T>(input: T): T;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function assertEquals<T>(input: unknown): T;
+function assertEquals<T>(
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): T;
 
 /**
  * @internal
@@ -369,7 +388,10 @@ export { assertEqualsPure as assertEquals };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function assertGuardEquals<T>(input: T): asserts input is T;
+function assertGuardEquals<T>(
+  input: T,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): asserts input is T;
 
 /**
  * Assertion guard of a type with equality.
@@ -398,7 +420,10 @@ function assertGuardEquals<T>(input: T): asserts input is T;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function assertGuardEquals<T>(input: unknown): asserts input is T;
+function assertGuardEquals<T>(
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): asserts input is T;
 
 /**
  * @internal
@@ -603,7 +628,9 @@ export { randomPure as random };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createAssert(): never;
+function createAssert(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): never;
 
 /**
  * Creates a reusable {@link assert} function.
@@ -613,7 +640,9 @@ function createAssert(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createAssert<T>(): (input: unknown) => T;
+function createAssert<T>(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): (input: unknown) => T;
 
 /**
  * @internal
@@ -651,7 +680,9 @@ export { createAssertPure as createAssert };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createAssertGuard(): never;
+function createAssertGuard(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): never;
 
 /**
  * Creates a reusable {@link assertGuard} function.
@@ -676,7 +707,9 @@ function createAssertGuard(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createAssertGuard<T>(): (input: unknown) => AssertionGuard<T>;
+function createAssertGuard<T>(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): (input: unknown) => AssertionGuard<T>;
 
 /**
  * @internal
@@ -765,7 +798,9 @@ export { createValidatePure as createValidate };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createAssertEquals(): never;
+function createAssertEquals(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): never;
 
 /**
  * Creates a reusable {@link assertEquals} function.
@@ -775,7 +810,9 @@ function createAssertEquals(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createAssertEquals<T>(): (input: unknown) => T;
+function createAssertEquals<T>(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): (input: unknown) => T;
 
 /**
  * @internal
@@ -813,7 +850,9 @@ export { createAssertEqualsPure as createAssertEquals };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createAssertGuardEquals(): never;
+function createAssertGuardEquals(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): never;
 
 /**
  * Creates a reusable {@link assertGuardEquals} function.
@@ -838,7 +877,9 @@ function createAssertGuardEquals(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createAssertGuardEquals<T>(): (input: unknown) => AssertionGuard<T>;
+function createAssertGuardEquals<T>(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): (input: unknown) => AssertionGuard<T>;
 
 /**
  * @internal

package/src/notations.ts

@@ -4,6 +4,7 @@ import { CamelCase } from "./CamelCase";
 import { IValidation } from "./IValidation";
 import { PascalCase } from "./PascalCase";
 import { SnakeCase } from "./SnakeCase";
+import { TypeGuardError } from "./TypeGuardError";
 
 /* ===========================================================
     NOTATIONS (NAMING CONVENTIONS)
@@ -59,7 +60,10 @@ export { camelPure as camel };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function assertCamel<T>(input: T): CamelCase<T>;
+function assertCamel<T>(
+  input: T,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): CamelCase<T>;
 
 /**
  * Converts to camel case with type assertion.
@@ -73,7 +77,10 @@ function assertCamel<T>(input: T): CamelCase<T>;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function assertCamel<T>(input: unknown): CamelCase<T>;
+function assertCamel<T>(
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): CamelCase<T>;
 
 /**
  * @internal
@@ -230,7 +237,10 @@ export { pascalPure as pascal };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function assertPascal<T>(input: T): PascalCase<T>;
+function assertPascal<T>(
+  input: T,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): PascalCase<T>;
 
 /**
  * Converts to pascal case with type assertion.
@@ -244,7 +254,10 @@ function assertPascal<T>(input: T): PascalCase<T>;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function assertPascal<T>(input: unknown): PascalCase<T>;
+function assertPascal<T>(
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): PascalCase<T>;
 
 /**
  * @internal
@@ -401,7 +414,10 @@ export { snakePure as snake };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function assertSnake<T>(input: T): SnakeCase<T>;
+function assertSnake<T>(
+  input: T,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): SnakeCase<T>;
 
 /**
  * Converts to snake case with type assertion.
@@ -415,7 +431,10 @@ function assertSnake<T>(input: T): SnakeCase<T>;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function assertSnake<T>(input: unknown): SnakeCase<T>;
+function assertSnake<T>(
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): SnakeCase<T>;
 
 /**
  * @internal
@@ -568,7 +587,9 @@ export { createCamelPure as createCamel };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createAssertCamel(): never;
+function createAssertCamel(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): never;
 
 /**
  * Creates a reusable {@link assertCamel} function.
@@ -578,7 +599,9 @@ function createAssertCamel(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createAssertCamel<T>(): (input: T) => CamelCase<T>;
+function createAssertCamel<T>(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): (input: T) => CamelCase<T>;
 
 /**
  * @internal
@@ -715,7 +738,9 @@ export { createPascalPure as createPascal };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createAssertPascal(): never;
+function createAssertPascal(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): never;
 
 /**
  * Creates a reusable {@link assertPascal} function.
@@ -725,7 +750,9 @@ function createAssertPascal(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createAssertPascal<T>(): (input: T) => PascalCase<T>;
+function createAssertPascal<T>(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): (input: T) => PascalCase<T>;
 
 /**
  * @internal
@@ -862,7 +889,9 @@ export { createSnakePure as createSnake };
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createAssertSnake(): never;
+function createAssertSnake(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): never;
 
 /**
  * Creates a reusable {@link assertSnake} function.
@@ -872,7 +901,9 @@ function createAssertSnake(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-function createAssertSnake<T>(): (input: T) => SnakeCase<T>;
+function createAssertSnake<T>(
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+): (input: T) => SnakeCase<T>;
 
 /**
  * @internal

package/src/programmers/AssertProgrammer.ts

@@ -17,15 +17,14 @@ export namespace AssertProgrammer {
     (project: IProject) =>
     (modulo: ts.LeftHandSideExpression) =>
     (props: boolean | { equals: boolean; guard: boolean }) =>
-    (type: ts.Type, name?: string) => {
+    (type: ts.Type, name?: string, init?: ts.Expression) => {
       // TO SUPPORT LEGACY FEATURE
       if (typeof props === "boolean") props = { equals: props, guard: false };
 
       const importer: FunctionImporter = new FunctionImporter(modulo.getText());
-      const is = IsProgrammer.write(project)(modulo, true)(props.equals)(
-        type,
-        name ?? TypeFactory.getFullName(project.checker)(type),
-      );
+      const is: ts.ArrowFunction = IsProgrammer.write(project)(modulo, true)(
+        props.equals,
+      )(type, name ?? TypeFactory.getFullName(project.checker)(type));
       const assert: ts.ArrowFunction = CheckerProgrammer.write(project)({
         prefix: "$a",
         path: true,
@@ -90,7 +89,10 @@ export namespace AssertProgrammer {
       return ts.factory.createArrowFunction(
         undefined,
         undefined,
-        [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))],
+        [
+          IdentifierFactory.parameter("input", TypeFactory.keyword("any")),
+          Guardian.parameter(init),
+        ],
         props.guard
           ? ts.factory.createTypePredicateNode(
               ts.factory.createToken(ts.SyntaxKind.AssertsKeyword),
@@ -289,5 +291,43 @@ export namespace AssertProgrammer {
           ],
           true,
         ),
+        Guardian.identifier(),
       ]);
+
+  export namespace Guardian {
+    export const identifier = () => ts.factory.createIdentifier("errorFactory");
+    export const parameter = (init: ts.Expression | undefined) =>
+      IdentifierFactory.parameter(
+        "errorFactory",
+        ts.factory.createFunctionTypeNode(
+          undefined,
+          [
+            ts.factory.createParameterDeclaration(
+              undefined,
+              undefined,
+              ts.factory.createIdentifier("p"),
+              undefined,
+              ts.factory.createImportTypeNode(
+                ts.factory.createLiteralTypeNode(
+                  ts.factory.createStringLiteral("typia"),
+                ),
+                undefined,
+                ts.factory.createQualifiedName(
+                  ts.factory.createIdentifier("TypeGuardError"),
+                  ts.factory.createIdentifier("IProps"),
+                ),
+                undefined,
+                false,
+              ),
+              undefined,
+            ),
+          ],
+          ts.factory.createTypeReferenceNode(
+            ts.factory.createIdentifier("Error"),
+            undefined,
+          ),
+        ),
+        init ?? ts.factory.createToken(ts.SyntaxKind.QuestionToken),
+      );
+  }
 }

package/src/programmers/http/HttpAssertFormDataProgrammer.ts

@@ -13,7 +13,7 @@ export namespace HttpAssertFormDataProgrammer {
   export const write =
     (project: IProject) =>
     (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string): ts.ArrowFunction =>
+    (type: ts.Type, name?: string, init?: ts.Expression): ts.ArrowFunction =>
       ts.factory.createArrowFunction(
         undefined,
         undefined,
@@ -22,6 +22,7 @@ export namespace HttpAssertFormDataProgrammer {
             "input",
             ts.factory.createTypeReferenceNode("FormData"),
           ),
+          AssertProgrammer.Guardian.parameter(init),
         ],
         ts.factory.createTypeReferenceNode(
           `typia.Resolved<${
@@ -65,7 +66,10 @@ export namespace HttpAssertFormDataProgrammer {
               ts.factory.createCallExpression(
                 ts.factory.createIdentifier("assert"),
                 undefined,
-                [ts.factory.createIdentifier("output")],
+                [
+                  ts.factory.createIdentifier("output"),
+                  AssertProgrammer.Guardian.identifier(),
+                ],
               ),
               TypeFactory.keyword("any"),
             ),

package/src/programmers/http/HttpAssertHeadersProgrammer.ts

@@ -13,7 +13,7 @@ export namespace HttpAssertHeadersProgrammer {
   export const write =
     (project: IProject) =>
     (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string): ts.ArrowFunction =>
+    (type: ts.Type, name?: string, init?: ts.Expression): ts.ArrowFunction =>
       ts.factory.createArrowFunction(
         undefined,
         undefined,
@@ -24,6 +24,7 @@ export namespace HttpAssertHeadersProgrammer {
               HttpHeadersProgrammer.INPUT_TYPE,
             ),
           ),
+          AssertProgrammer.Guardian.parameter(init),
         ],
         ts.factory.createTypeReferenceNode(
           `typia.Resolved<${
@@ -67,7 +68,10 @@ export namespace HttpAssertHeadersProgrammer {
               ts.factory.createCallExpression(
                 ts.factory.createIdentifier("assert"),
                 undefined,
-                [ts.factory.createIdentifier("output")],
+                [
+                  ts.factory.createIdentifier("output"),
+                  AssertProgrammer.Guardian.identifier(),
+                ],
               ),
               TypeFactory.keyword("any"),
             ),

package/src/programmers/http/HttpAssertQueryProgrammer.ts

@@ -13,7 +13,7 @@ export namespace HttpAssertQueryProgrammer {
   export const write =
     (project: IProject) =>
     (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string): ts.ArrowFunction =>
+    (type: ts.Type, name?: string, init?: ts.Expression): ts.ArrowFunction =>
       ts.factory.createArrowFunction(
         undefined,
         undefined,
@@ -22,6 +22,7 @@ export namespace HttpAssertQueryProgrammer {
             "input",
             ts.factory.createTypeReferenceNode(HttpQueryProgrammer.INPUT_TYPE),
           ),
+          AssertProgrammer.Guardian.parameter(init),
         ],
         ts.factory.createTypeReferenceNode(
           `typia.Resolved<${
@@ -65,7 +66,10 @@ export namespace HttpAssertQueryProgrammer {
               ts.factory.createCallExpression(
                 ts.factory.createIdentifier("assert"),
                 undefined,
-                [ts.factory.createIdentifier("output")],
+                [
+                  ts.factory.createIdentifier("output"),
+                  AssertProgrammer.Guardian.identifier(),
+                ],
               ),
               TypeFactory.keyword("any"),
             ),