typia 6.10.0-dev.20240906 → 6.10.0-dev.20240908

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typia",
-  "version": "6.10.0-dev.20240906",
+  "version": "6.10.0-dev.20240908",
   "description": "Superfast runtime validators with only one line",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -83,7 +83,7 @@
     "@trivago/prettier-plugin-sort-imports": "^4.3.0",
     "@types/inquirer": "^8.2.5",
     "@types/node": "^18.15.12",
-    "@types/ts-expose-internals": "npm:ts-expose-internals@5.5.3",
+    "@types/ts-expose-internals": "npm:ts-expose-internals@5.5.4",
     "@typescript-eslint/eslint-plugin": "^7.1.1",
     "@typescript-eslint/parser": "^7.1.1",
     "chalk": "^4.0.0",

package/src/factories/MetadataFactory.ts

@@ -22,6 +22,7 @@ export namespace MetadataFactory {
     escape: boolean;
     constant: boolean;
     absorb: boolean;
+    functional?: boolean;
     validate?: Validator;
     onError?: (node: ts.Node | undefined, message: string) => void;
   }

package/src/factories/MetadataTypeTagSchemaFactory.ts

@@ -1,59 +1,59 @@
-import { Metadata } from "../schemas/metadata/Metadata";
-import { MetadataObject } from "../schemas/metadata/MetadataObject";
-
-export namespace MetadataTypeTagSchemaFactory {
-  export const object =
-    (report: (msg: string) => false) =>
-    (obj: MetadataObject): object | undefined => {
-      if (obj.recursive) {
-        report(`${obj.name} has recursive type`);
-        return undefined;
-      }
-      const output: any = {};
-      for (const p of obj.properties) {
-        const key: string | null = p.key.getSoleLiteral()!;
-        if (key === null) {
-          report(`${obj.name} has non-literal key type: ${p.key.getName()}`);
-          continue;
-        }
-        output[key] = iterate(report)({ object: obj, key })(p.value);
-      }
-      return output;
-    };
-
-  const iterate =
-    (report: (msg: string) => false) =>
-    (parent: { object: MetadataObject; key: string }) =>
-    (meta: Metadata): any => {
-      if (
-        meta.any ||
-        meta.atomics.length ||
-        meta.arrays.length ||
-        meta.natives.length ||
-        meta.functional
-      )
-        report(`${parent.object.name}.${parent.key} has non-literal type`);
-      else if (meta.size() > 1)
-        report(`${parent.object.name}.${parent.key} has union type`);
-      else if (meta.size() === 0)
-        if (meta.nullable) return null;
-        else if (meta.isRequired() === true)
-          report(`${parent.object.name}.${parent.key} has non-literal type`);
-        else return undefined;
-      else if (meta.constants.length)
-        return meta.constants[0]!.values[0]!.value;
-      else if (meta.tuples.length) {
-        const tuple = meta.tuples[0]!;
-        if (tuple.type.isRest())
-          report(`${parent.object.name}.${parent.key} has rest tuple type`);
-        else if (tuple.type.recursive)
-          report(
-            `${parent.object.name}.${parent.key} has recursive tuple type`,
-          );
-        else if (tuple.type.elements.some((e) => e.required === false))
-          report(`${parent.object.name}.${parent.key} has optional tuple type`);
-        return tuple.type.elements.map(iterate(report)(parent));
-      } else if (meta.objects.length) return object(report)(meta.objects[0]!);
-      else report(`${parent.object.name}.${parent.key} has non-literal type`);
-    };
-}
+import { Metadata } from "../schemas/metadata/Metadata";
+import { MetadataObject } from "../schemas/metadata/MetadataObject";
+
+export namespace MetadataTypeTagSchemaFactory {
+  export const object =
+    (report: (msg: string) => false) =>
+    (obj: MetadataObject): object | undefined => {
+      if (obj.recursive) {
+        report(`${obj.name} has recursive type`);
+        return undefined;
+      }
+      const output: any = {};
+      for (const p of obj.properties) {
+        const key: string | null = p.key.getSoleLiteral()!;
+        if (key === null) {
+          report(`${obj.name} has non-literal key type: ${p.key.getName()}`);
+          continue;
+        }
+        output[key] = iterate(report)({ object: obj, key })(p.value);
+      }
+      return output;
+    };
+
+  const iterate =
+    (report: (msg: string) => false) =>
+    (parent: { object: MetadataObject; key: string }) =>
+    (meta: Metadata): any => {
+      if (
+        meta.any ||
+        meta.atomics.length ||
+        meta.arrays.length ||
+        meta.natives.length ||
+        meta.functions.length
+      )
+        report(`${parent.object.name}.${parent.key} has non-literal type`);
+      else if (meta.size() > 1)
+        report(`${parent.object.name}.${parent.key} has union type`);
+      else if (meta.size() === 0)
+        if (meta.nullable) return null;
+        else if (meta.isRequired() === true)
+          report(`${parent.object.name}.${parent.key} has non-literal type`);
+        else return undefined;
+      else if (meta.constants.length)
+        return meta.constants[0]!.values[0]!.value;
+      else if (meta.tuples.length) {
+        const tuple = meta.tuples[0]!;
+        if (tuple.type.isRest())
+          report(`${parent.object.name}.${parent.key} has rest tuple type`);
+        else if (tuple.type.recursive)
+          report(
+            `${parent.object.name}.${parent.key} has recursive tuple type`,
+          );
+        else if (tuple.type.elements.some((e) => e.required === false))
+          report(`${parent.object.name}.${parent.key} has optional tuple type`);
+        return tuple.type.elements.map(iterate(report)(parent));
+      } else if (meta.objects.length) return object(report)(meta.objects[0]!);
+      else report(`${parent.object.name}.${parent.key} has non-literal type`);
+    };
+}

package/src/factories/ProtobufFactory.ts

@@ -62,7 +62,7 @@ export namespace ProtobufFactory {
     // PROHIBIT ANY TYPE
     if (meta.any) noSupport("any type");
     // PROHIBIT FUNCTIONAL TYPE
-    if (meta.functional) noSupport("functional type");
+    if (meta.functions.length) noSupport("functional type");
     // PROHIBIT TUPLE TYPE
     if (meta.tuples.length) noSupport("tuple type");
     // PROHIBIT SET TYPE

package/src/factories/TypeFactory.ts

@@ -4,7 +4,7 @@ export namespace TypeFactory {
   export const isFunction = (type: ts.Type): boolean =>
     getFunction(type) !== null;
 
-  const getFunction = (type: ts.Type) => {
+  export const getFunction = (type: ts.Type) => {
     const node = type.symbol?.declarations?.[0];
     if (node === undefined) return null;
 

package/src/factories/internal/metadata/emplace_metadata_object.ts

@@ -29,6 +29,7 @@ export const emplace_metadata_object =
 
     // PREPARE ASSETS
     const isClass: boolean = parent.isClass();
+    const isProperty = significant(!!options.functional);
     const pred: (node: ts.Declaration) => boolean = isClass
       ? (node) => {
           const kind: ts.SyntaxKind | undefined = node
@@ -162,12 +163,15 @@ export const emplace_metadata_object =
     return obj;
   };
 
-const isProperty = (node: ts.Declaration) =>
-  ts.isParameter(node) ||
-  ts.isPropertyDeclaration(node) ||
-  ts.isPropertyAssignment(node) ||
-  ts.isPropertySignature(node) ||
-  ts.isTypeLiteralNode(node);
+const significant = (functional: boolean) =>
+  functional
+    ? (node: ts.Declaration) => !ts.isAccessor(node)
+    : (node: ts.Declaration) =>
+        ts.isParameter(node) ||
+        ts.isPropertyDeclaration(node) ||
+        ts.isPropertyAssignment(node) ||
+        ts.isPropertySignature(node) ||
+        ts.isTypeLiteralNode(node);
 
 const iterate_optional_coalesce = (meta: Metadata, type: ts.Type): void => {
   if (type.isUnionOrIntersection())

package/src/factories/internal/metadata/explore_metadata.ts

@@ -1,28 +1,28 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { emend_metadata_atomics } from "./emend_metadata_atomics";
-import { iterate_metadata } from "./iterate_metadata";
-
-export const explore_metadata =
-  (checker: ts.TypeChecker) =>
-  (options: MetadataFactory.IOptions) =>
-  (collection: MetadataCollection) =>
-  (errors: MetadataFactory.IError[]) =>
-  (type: ts.Type | null, explore: MetadataFactory.IExplore): Metadata => {
-    // CONSTRUCT METADATA
-    const meta: Metadata = Metadata.initialize(explore.escaped);
-    if (type === null) return meta;
-
-    // ITERATE TYPESCRIPT TYPES
-    iterate_metadata(checker)(options)(collection)(errors)(meta, type, explore);
-    emend_metadata_atomics(meta);
-    if (meta.escaped) {
-      emend_metadata_atomics(meta.escaped.original);
-      emend_metadata_atomics(meta.escaped.returns);
-    }
-    return meta;
-  };
+import ts from "typescript";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { emend_metadata_atomics } from "./emend_metadata_atomics";
+import { iterate_metadata } from "./iterate_metadata";
+
+export const explore_metadata =
+  (checker: ts.TypeChecker) =>
+  (options: MetadataFactory.IOptions) =>
+  (collection: MetadataCollection) =>
+  (errors: MetadataFactory.IError[]) =>
+  (type: ts.Type | null, explore: MetadataFactory.IExplore): Metadata => {
+    // CONSTRUCT METADATA
+    const meta: Metadata = Metadata.initialize(explore.escaped);
+    if (type === null) return meta;
+
+    // ITERATE TYPESCRIPT TYPES
+    iterate_metadata(checker)(options)(collection)(errors)(meta, type, explore);
+    emend_metadata_atomics(meta);
+    if (meta.escaped) {
+      emend_metadata_atomics(meta.escaped.original);
+      emend_metadata_atomics(meta.escaped.returns);
+    }
+    return meta;
+  };

package/src/factories/internal/metadata/iterate_metadata.ts

@@ -11,6 +11,7 @@ import { iterate_metadata_atomic } from "./iterate_metadata_atomic";
 import { iterate_metadata_coalesce } from "./iterate_metadata_coalesce";
 import { iterate_metadata_constant } from "./iterate_metadata_constant";
 import { iterate_metadata_escape } from "./iterate_metadata_escape";
+import { iterate_metadata_function } from "./iterate_metadata_function";
 import { iterate_metadata_intersection } from "./iterate_metadata_intersection";
 import { iterate_metadata_map } from "./iterate_metadata_map";
 import { iterate_metadata_native } from "./iterate_metadata_native";
@@ -62,6 +63,11 @@ export const iterate_metadata =
 
     // ITERATE CASES
     iterate_metadata_coalesce(meta, type) ||
+      iterate_metadata_function(checker)(options)(collection)(errors)(
+        meta,
+        type,
+        explore,
+      ) ||
       iterate_metadata_constant(checker)(options)(meta, type) ||
       iterate_metadata_template(checker)(options)(collection)(errors)(
         meta,

package/src/factories/internal/metadata/iterate_metadata_coalesce.ts

@@ -4,8 +4,6 @@ import { Metadata } from "../../../schemas/metadata/Metadata";
 
 import { Writable } from "../../../typings/Writable";
 
-import { TypeFactory } from "../../TypeFactory";
-
 export const iterate_metadata_coalesce = (
   meta: Metadata,
   type: ts.Type,
@@ -25,9 +23,6 @@ export const iterate_metadata_coalesce = (
   ) {
     Writable(meta).required = false;
     return true;
-  } else if (TypeFactory.isFunction(type) === true) {
-    Writable(meta).functional = true;
-    return true;
   }
   return false;
 };

package/src/factories/internal/metadata/iterate_metadata_function.ts

@@ -0,0 +1,85 @@
+import ts from "typescript";
+
+import { FunctionalGeneralProgrammer } from "../../../programmers/functional/internal/FunctionalGeneralProgrammer";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataFunction } from "../../../schemas/metadata/MetadataFunction";
+import { MetadataParameter } from "../../../schemas/metadata/MetadataParameter";
+
+import { CommentFactory } from "../../CommentFactory";
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { TypeFactory } from "../../TypeFactory";
+import { explore_metadata } from "./explore_metadata";
+
+export const iterate_metadata_function =
+  (checker: ts.TypeChecker) =>
+  (options: MetadataFactory.IOptions) =>
+  (collection: MetadataCollection) =>
+  (errors: MetadataFactory.IError[]) =>
+  (
+    metadata: Metadata,
+    type: ts.Type,
+    explore: MetadataFactory.IExplore,
+  ): boolean => {
+    const declaration: ts.SignatureDeclaration | null =
+      TypeFactory.getFunction(type);
+    if (declaration === null) return false;
+    else if (!options.functional) {
+      if (metadata.functions.length === 0)
+        metadata.functions.push(
+          MetadataFunction.create({
+            parameters: [],
+            output: Metadata.initialize(),
+            async: false,
+          }),
+        );
+    } else {
+      const [signature] = type.getCallSignatures();
+      if (signature === undefined || signature.declaration === undefined)
+        metadata.functions.push(
+          MetadataFunction.create({
+            parameters: [],
+            output: Metadata.initialize(),
+            async: false,
+          }),
+        );
+      else {
+        const { async }: FunctionalGeneralProgrammer.IOutput =
+          FunctionalGeneralProgrammer.getReturnType(checker)(declaration);
+        metadata.functions.push(
+          MetadataFunction.create({
+            parameters: signature.parameters.map((p) =>
+              MetadataParameter.create({
+                name: p.name,
+                type: explore_metadata(checker)(options)(collection)(errors)(
+                  checker.getTypeOfSymbol(p),
+                  {
+                    ...explore,
+                    top: false,
+                  },
+                ),
+                description: CommentFactory.description(p) ?? null,
+                jsDocTags: p?.getJsDocTags() ?? [],
+              }),
+            ),
+            async,
+            output: explore_metadata(checker)({
+              ...options,
+              functional: false,
+            })(collection)(errors)(
+              async
+                ? (signature.getReturnType().aliasTypeArguments?.[0] ??
+                    checker.getTypeFromTypeNode(TypeFactory.keyword("any")))
+                : signature.getReturnType(),
+              {
+                ...explore,
+                top: false,
+              },
+            ),
+          }),
+        );
+      }
+    }
+    return true;
+  };

package/src/functional/Namespace/index.ts

@@ -14,6 +14,7 @@ export * as http from "./http";
 export * as notations from "./notations";
 export * as misc from "./misc";
 export * as protobuf from "./protobuf";
+export * as llm from "./llm";
 
 export { is };
 

package/src/functional/Namespace/llm.ts

@@ -0,0 +1,20 @@
+import { ILlmApplication } from "@samchon/openapi";
+
+import { LlmSchemaSeparator } from "@samchon/openapi/lib/utils/LlmSchemaSeparator";
+
+export const application = () => ({
+  finalize: (
+    app: ILlmApplication,
+    options?: ILlmApplication.IOptions,
+  ): void => {
+    app.options = {
+      separate: options?.separate ?? null,
+    };
+    if (app.options.separate === null) return;
+    for (const func of app.functions)
+      func.separated = LlmSchemaSeparator.parameters({
+        parameters: func.parameters,
+        predicator: app.options.separate,
+      });
+  },
+});

package/src/llm.ts

@@ -1,16 +1,172 @@
 import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
 
-export function application(): never;
-export function application<T extends object>(): ILlmApplication;
+import * as Namespace from "./functional/Namespace";
+
+/**
+ * > You must configure the generic argument `App`.
+ *
+ * TypeScript functions to LLM function schemas.
+ *
+ * Creates an application of LLM (Large Language Model) function calling schemas from
+ * a TypeScript class or interface type containig the target functions to be called by
+ * the LLM function calling feature.
+ *
+ * If you put the returned {@link ILlmApplication.functions} objects to the LLM provider
+ * like [OpenAI (ChatGPT)](https://openai.com/), the LLM will automatically select the
+ * proper function and fill its arguments from the conversation (maybe chatting text)
+ * with user (human). This is the concept of the LLM function calling.
+ *
+ * By the way, there can be some parameters (or their nested properties) which must be
+ * composed by human, not by LLM. File uploading feature or some sensitive information
+ * like secrety key (password) are the examples. In that case, you can separate the
+ * function parameters to both LLM and human sides by configuring the
+ * {@link ILlmApplication.IOptions.separate} property. The separated parameters are
+ * assigned to the {@link ILlmFunction.separated} property.
+ *
+ * For reference, the actual function call execution is not by LLM, but by you.
+ * When the LLM selects the proper function and fills the arguments, you just call
+ * the function with the LLM prepared arguments. And then informs the return value to
+ * the LLM by system prompt. The LLM will continue the next conversation based on
+ * the return value.
+ *
+ * Additionally, if you've configured {@link ILlmApplication.IOptions.separate},
+ * so that the parameters are separated to human and LLM sides, you can merge these
+ * humand and LLM sides' parameters into one through {@link HttpLlm.mergeParameters}
+ * before the actual LLM function call execution.
+ *
+ * @template App Target class or interface type collecting the functions to call
+ * @param options Options for the LLM application construction
+ * @returns Application of LLM function calling schemas
+ * @reference https://platform.openai.com/docs/guides/function-calling
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+function application(options?: ILlmApplication.IOptions): never;
+
+/**
+ * TypeScript functions to LLM function schemas.
+ *
+ * Creates an application of LLM (Large Language Model) function calling schemas from
+ * a TypeScript class or interface type containig the target functions to be called by
+ * the LLM function calling feature.
+ *
+ * If you put the returned {@link ILlmApplication.functions} objects to the LLM provider
+ * like [OpenAI (ChatGPT)](https://openai.com/), the LLM will automatically select the
+ * proper function and fill its arguments from the conversation (maybe chatting text)
+ * with user (human). This is the concept of the LLM function calling.
+ *
+ * By the way, there can be some parameters (or their nested properties) which must be
+ * composed by human, not by LLM. File uploading feature or some sensitive information
+ * like secrety key (password) are the examples. In that case, you can separate the
+ * function parameters to both LLM and human sides by configuring the
+ * {@link ILlmApplication.IOptions.separate} property. The separated parameters are
+ * assigned to the {@link ILlmFunction.separated} property.
+ *
+ * For reference, the actual function call execution is not by LLM, but by you.
+ * When the LLM selects the proper function and fills the arguments, you just call
+ * the function with the LLM prepared arguments. And then informs the return value to
+ * the LLM by system prompt. The LLM will continue the next conversation based on
+ * the return value.
+ *
+ * Additionally, if you've configured {@link ILlmApplication.IOptions.separate},
+ * so that the parameters are separated to human and LLM sides, you can merge these
+ * humand and LLM sides' parameters into one through {@link HttpLlm.mergeParameters}
+ * before the actual LLM function call execution.
+ *
+ * @template App Target class or interface type collecting the functions to call
+ * @param options Options for the LLM application construction
+ * @returns Application of LLM function calling schemas
+ * @reference https://platform.openai.com/docs/guides/function-calling
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+function application<App extends object>(
+  options?: ILlmApplication.IOptions,
+): ILlmApplication;
 
 /**
  * @internal
  */
-export function application(): never {
+function application(): never {
   halt("application");
 }
 
+const applicationPure = /** @__PURE__ */ Object.assign<typeof application, {}>(
+  application,
+  /** @__PURE__ */ Namespace.llm.application(),
+);
+export { applicationPure as application };
+
+/**
+ * > You must configure the generic argument `T`.
+ *
+ * TypeScript type to LLM type schema.
+ *
+ * Creates an LLM (Large Language Model) type schema, a type metadata that is used in the
+ * [LLM function calling](@reference https://platform.openai.com/docs/guides/function-calling),
+ * from a TypeScript type.
+ *
+ * The returned {@link ILlmSchema} type is similar to the OpenAPI v3.0 based JSON schema
+ * definition, but it is more simplified for the LLM function calling by remmoving the
+ * {@link OpenApiV3.IJson.IReference reference} type embodied by the
+ * {@link OpenApiV3.IJson.IReference.$ref `$ref`} proeprty.
+ *
+ * If you actually want to perform the LLM function calling with TypeScript functions,
+ * you can do it with the {@link application} function. Let's enjoy the
+ * LLM function calling with native TypeScript functions and types.
+ *
+ * > **What LLM function calling is?
+ * >
+ * > LLM (Large Language Model) selects propert function and fill the arguments,
+ * > but actuall function call execution is not by LLM, but by you.
+ * >
+ * > In nowadays, most LLM (Large Language Model) like OpenAI are supporting
+ * > "function calling" feature. The "function calling" means that LLM automatically selects
+ * > a proper function and compose parameter values from the user's chatting text.
+ * >
+ * > When LLM selects the proper function and its arguments, you just call the function
+ * > with the arguments. And then informs the return value to the LLM by system prompt,
+ * > LLM will continue the next conversation based on the return value.
+ *
+ * @template T Target type
+ * @returns LLM schema
+ * @reference https://platform.openai.com/docs/guides/function-calling
+ * @author Jeongho Nam - https://github.com/samchon
+ */
 export function schema(): never;
+
+/**
+ * TypeScript type to LLM type schema.
+ *
+ * Creates an LLM (Large Language Model) type schema, a type metadata that is used in the
+ * [LLM function calling](@reference https://platform.openai.com/docs/guides/function-calling),
+ * from a TypeScript type.
+ *
+ * The returned {@link ILlmSchema} type is similar to the OpenAPI v3.0 based JSON schema
+ * definition, but it is more simplified for the LLM function calling by remmoving the
+ * {@link OpenApiV3.IJson.IReference reference} type embodied by the
+ * {@link OpenApiV3.IJson.IReference.$ref `$ref`} proeprty.
+ *
+ * If you actually want to perform the LLM function calling with TypeScript functions,
+ * you can do it with the {@link application} function. Let's enjoy the
+ * LLM function calling with native TypeScript functions and types.
+ *
+ * > **What LLM function calling is?
+ * >
+ * > LLM (Large Language Model) selects propert function and fill the arguments,
+ * > but actuall function call execution is not by LLM, but by you.
+ * >
+ * > In nowadays, most LLM (Large Language Model) like OpenAI are supporting
+ * > "function calling" feature. The "function calling" means that LLM automatically selects
+ * > a proper function and compose parameter values from the user's chatting text.
+ * >
+ * > When LLM selects the proper function and its arguments, you just call the function
+ * > with the arguments. And then informs the return value to the LLM by system prompt,
+ * > LLM will continue the next conversation based on the return value.
+ *
+ * @template T Target type
+ * @returns LLM schema
+ * @reference https://platform.openai.com/docs/guides/function-calling
+ * @author Jeongho Nam - https://github.com/samchon
+ */
 export function schema<T>(): ILlmSchema;
 
 /**

package/src/programmers/CheckerProgrammer.ts

@@ -331,7 +331,7 @@ export namespace CheckerProgrammer {
         );
 
       // FUNCTIONAL
-      if (meta.functional === true)
+      if (meta.functions.length)
         if (OptionPredicator.functional(project.options) || meta.size() !== 1)
           add(
             true,

package/src/programmers/RandomProgrammer.ts

@@ -276,7 +276,7 @@ export namespace RandomProgrammer {
         expressions.push(ts.factory.createStringLiteral("any type used..."));
 
       // NULL COALESCING
-      if (meta.isRequired() === false || meta.functional === true)
+      if (meta.isRequired() === false || meta.functions.length)
         expressions.push(ts.factory.createIdentifier("undefined"));
       if (meta.nullable === true) expressions.push(ts.factory.createNull());
 

package/src/programmers/functional/internal/FunctionalGeneralProgrammer.ts

@@ -9,7 +9,9 @@ export namespace FunctionalGeneralProgrammer {
   }
   export const getReturnType =
     (checker: ts.TypeChecker) =>
-    (declaration: ts.FunctionDeclaration): IOutput => {
+    (
+      declaration: ts.FunctionDeclaration | ts.SignatureDeclaration,
+    ): IOutput => {
       const signature: ts.Signature | undefined =
         checker.getSignatureFromDeclaration(declaration);
       const type: ts.Type =