diff --git a/.dependency-cruiser.js b/.dependency-cruiser.js
index b40abf12..4ac156df 100644
--- a/.dependency-cruiser.js
+++ b/.dependency-cruiser.js
@@ -20,6 +20,16 @@ module.exports = {
         path: "^src/internal",
       },
     },
+    {
+      name: "Don't dependent on typescript from Walker",
+      severity: "error",
+      from: {
+        path: "^src/internal/OpenApiTools",
+      },
+      to: {
+        path: "typescript",
+      },
+    },
     {
       name: "not-to-test",
       comment:
diff --git a/.prettierrc.cjs b/.prettierrc.cjs
deleted file mode 100644
index d15a357b..00000000
--- a/.prettierrc.cjs
+++ /dev/null
@@ -1,10 +0,0 @@
-module.exports = {
-  printWidth: 144,
-  trailingComma: "all",
-  tabWidth: 2,
-  useTabs: false,
-  arrowParens: "avoid",
-  bracketSpacing: true,
-  singleQuote: false,
-  semi: true,
-};
diff --git a/.prettierrc.json b/.prettierrc.json
new file mode 100644
index 00000000..5adcb5be
--- /dev/null
+++ b/.prettierrc.json
@@ -0,0 +1,10 @@
+{
+  "printWidth": 144,
+  "trailingComma": "all",
+  "tabWidth": 2,
+  "useTabs": false,
+  "arrowParens": "avoid",
+  "bracketSpacing": true,
+  "singleQuote": false,
+  "semi": true
+}
diff --git a/package.json b/package.json
index c354c829..8d344bb9 100644
--- a/package.json
+++ b/package.json
@@ -40,6 +40,7 @@
   "scripts": {
     "build": "yarn ts ./scripts/build.ts",
     "clean": "yarn ts ./scripts/clean.ts",
+    "generate:test:code": "yarn build && yarn test:code:gen",
     "format:code": "prettier \"**/*.{js,jsx,ts,tsx,json,yml,yaml,md,html}\" --write",
     "format:code:eslint": "eslint \"**/*.{ts,tsx}\" --fix",
     "format:yarn:lock": "yarn-deduplicate yarn.lock --strategy highest",
@@ -73,7 +74,7 @@
     "node-fetch": "2.6.1"
   },
   "dependencies": {
-    "@himenon/path-oriented-data-structure": "0.1.3",
+    "@himenon/path-oriented-data-structure": "0.2.1",
     "@types/json-schema": "7.0.7",
     "ajv": "8.0.5",
     "dot-prop": "6.0.1",
diff --git a/scripts/testCodeGen.ts b/scripts/testCodeGen.ts
index bd6088d3..a527d3ca 100644
--- a/scripts/testCodeGen.ts
+++ b/scripts/testCodeGen.ts
@@ -1,13 +1,29 @@
 import * as fs from "fs";
 import { posix as path } from "path";
 
+import prettier from "prettier";
+
 import { CodeGenerator } from "../lib";
 import * as Templates from "../lib/templates";
 import type * as Types from "../lib/types";
 
+const prettierConfig = require("../.prettierrc.json");
+
+const codeFormat = (code: string): string => {
+  try {
+    return prettier.format(code, {
+      ...prettierConfig,
+      parser: "babel",
+    });
+  } catch (error) {
+    console.log("Failed code format");
+    return code;
+  }
+};
+
 const writeText = (filename: string, text: string): void => {
   fs.mkdirSync(path.dirname(filename), { recursive: true });
-  fs.writeFileSync(filename, text, { encoding: "utf-8" });
+  fs.writeFileSync(filename, codeFormat(text), { encoding: "utf-8" });
   console.log(`Generate Code : ${filename}`);
 };
 
@@ -97,26 +113,44 @@ const generateParameter = (inputFilename: string, outputFilename: string) => {
   writeText(outputFilename, JSON.stringify(codeGenerator.getCodeGeneratorParamsArray(), null, 2));
 };
 
-const main = () => {
+const generateAdvancedTestCode = async (inputFilename: string, outputDir: string): Promise<void> => {
+  const codeGenerator = new CodeGenerator(inputFilename);
+
+  await codeGenerator.init();
+
+  const typeDefCode = codeGenerator.generateCode([
+    {
+      kind: "advanced",
+      generator: Templates.TypeDef.generator,
+    },
+  ]);
+  writeText(path.join(outputDir, "types.ts"), typeDefCode);
+};
+
+const main = async () => {
   generateTypedefCodeOnly("test/api.test.domain/index.yml", "test/code/typedef-only/api.test.domain.ts", true);
-  generateTypedefCodeOnly("test/infer.domain/index.yml", "test/code/typedef-only/infer.domain.ts", false);
+  await generateAdvancedTestCode("test/api.test.domain/index.yml", "test/code/advanced/api.test.domain.ts");
+  // generateTypedefCodeOnly("test/infer.domain/index.yml", "test/code/typedef-only/infer.domain.ts", false);
 
-  generateTemplateCodeOnly("test/api.test.domain/index.yml", "test/code/template-only/api.test.domain.ts", true, { sync: false });
-  generateTemplateCodeOnly("test/api.test.domain/index.yml", "test/code/template-only/sync-api.test.domain.ts", true, { sync: true });
-  generateTemplateCodeOnly("test/infer.domain/index.yml", "test/code/template-only/infer.domain.ts", false, { sync: true });
+  // generateTemplateCodeOnly("test/api.test.domain/index.yml", "test/code/template-only/api.test.domain.ts", true, { sync: false });
+  // generateTemplateCodeOnly("test/api.test.domain/index.yml", "test/code/template-only/sync-api.test.domain.ts", true, { sync: true });
+  // generateTemplateCodeOnly("test/infer.domain/index.yml", "test/code/template-only/infer.domain.ts", false, { sync: true });
 
-  generateTypedefWithTemplateCode("test/api.test.domain/index.yml", "test/code/typedef-with-template/api.test.domain.ts", true, {
-    sync: false,
-  });
-  generateTypedefWithTemplateCode("test/api.test.domain/index.yml", "test/code/typedef-with-template/sync-api.test.domain.ts", true, {
-    sync: true,
-  });
-  generateTypedefWithTemplateCode("test/infer.domain/index.yml", "test/code/typedef-with-template/infer.domain.ts", false, { sync: false });
+  // generateTypedefWithTemplateCode("test/api.test.domain/index.yml", "test/code/typedef-with-template/api.test.domain.ts", true, {
+  //   sync: false,
+  // });
+  // generateTypedefWithTemplateCode("test/api.test.domain/index.yml", "test/code/typedef-with-template/sync-api.test.domain.ts", true, {
+  //   sync: true,
+  // });
+  // generateTypedefWithTemplateCode("test/infer.domain/index.yml", "test/code/typedef-with-template/infer.domain.ts", false, { sync: false });
 
-  generateSplitCode("test/api.test.domain/index.yml", "test/code/split");
+  // generateSplitCode("test/api.test.domain/index.yml", "test/code/split");
 
-  generateParameter("test/api.test.domain/index.yml", "test/code/parameter/api.test.domain.json");
-  generateParameter("test/infer.domain/index.yml", "test/code/parameter/infer.domain.json");
+  // generateParameter("test/api.test.domain/index.yml", "test/code/parameter/api.test.domain.json");
+  // generateParameter("test/infer.domain/index.yml", "test/code/parameter/infer.domain.json");
 };
 
-main();
+main().catch(error => {
+  console.error(error);
+  process.exit(1);
+});
diff --git a/src/api.ts b/src/api.ts
index 8f4108cf..23463385 100644
--- a/src/api.ts
+++ b/src/api.ts
@@ -3,3 +3,4 @@ export * as OpenApiTools from "./internal/OpenApiTools";
 export { FileSystem } from "./internal/FileSystem";
 export * as ResolveReference from "./internal/ResolveReference";
 export * as Validator from "./internal/Validator";
+export * as Reference from "./reference-resolver";
diff --git a/src/code-templates/typedef/StructToTypeNode.ts b/src/code-templates/typedef/StructToTypeNode.ts
new file mode 100644
index 00000000..e69de29b
diff --git a/src/code-templates/typedef/components/ConvertToolKit.ts b/src/code-templates/typedef/components/ConvertToolKit.ts
new file mode 100644
index 00000000..31b8b84b
--- /dev/null
+++ b/src/code-templates/typedef/components/ConvertToolKit.ts
@@ -0,0 +1,14 @@
+import ts from "typescript";
+
+import type { OpenApi } from "../../../types";
+import { JsonSchemaToTypeDefinition } from "../../../utils";
+
+export interface ConvertToolkit {
+  generateTypeNode: (schema: OpenApi.Schema | OpenApi.Reference | OpenApi.JSONSchemaDefinition) => ts.TypeNode;
+}
+
+const converter = new JsonSchemaToTypeDefinition.Converter();
+
+export const ConvertToolkit: ConvertToolkit = {
+  generateTypeNode: converter.generateTypeNode.bind(converter),
+};
diff --git a/src/code-templates/typedef/components/Reference.ts b/src/code-templates/typedef/components/Reference.ts
new file mode 100644
index 00000000..717132f8
--- /dev/null
+++ b/src/code-templates/typedef/components/Reference.ts
@@ -0,0 +1,19 @@
+import ts from "typescript";
+
+import { OpenApi } from "../../../types";
+import type { InitializeParams } from "./types";
+
+export interface Payload {
+  entryPoint: string;
+  currentPoint: string;
+  schemas: Record<string, OpenApi.Schema | OpenApi.Reference>;
+}
+
+export class Convert {
+  constructor(private readonly params: InitializeParams) {}
+  public generateTypeNode(schema: OpenApi.Reference): ts.TypeNode {
+
+    this.params.accessor.getChildByPaths("", "OpenApiSchema");
+    return this.params.toolkit.generateTypeNode(schema);
+  }
+}
diff --git a/src/code-templates/typedef/components/Schema.ts b/src/code-templates/typedef/components/Schema.ts
new file mode 100644
index 00000000..60360ed1
--- /dev/null
+++ b/src/code-templates/typedef/components/Schema.ts
@@ -0,0 +1,16 @@
+import ts from "typescript";
+
+import { TsGenerator } from "../../../api";
+import { OpenApi } from "../../../types";
+import type { InitializeParams } from "./types";
+
+export class Convert {
+  constructor(private readonly params: InitializeParams) {}
+  public generateStatement(name: string, schema: OpenApi.Schema | OpenApi.Reference | boolean): ts.Statement {
+    return TsGenerator.factory.TypeAliasDeclaration.create({
+      export: true,
+      name: name,
+      type: this.params.toolkit.generateTypeNode(schema),
+    });
+  }
+}
diff --git a/src/code-templates/typedef/components/Schemas.ts b/src/code-templates/typedef/components/Schemas.ts
new file mode 100644
index 00000000..12b52e7e
--- /dev/null
+++ b/src/code-templates/typedef/components/Schemas.ts
@@ -0,0 +1,36 @@
+import type ts from "typescript";
+
+import { TsGenerator } from "../../../api";
+import { AbstractStruct, OpenApi } from "../../../types";
+import * as Schema from "./Schema";
+import type { InitializeParams } from "./types";
+
+export interface Payload {
+  entryPoint: string;
+  currentPoint: string;
+  schemas: Record<string, OpenApi.Schema | OpenApi.Reference>;
+}
+
+export class Convert {
+  private readonly schema = new Schema.Convert(this.params);
+  constructor(private readonly params: InitializeParams) {}
+  public generateNamespace(schemaLocations: { [currentPoint: string]: AbstractStruct.SchemaLocation }): ts.Statement {
+    const statements: ts.Statement[] = Object.values(schemaLocations).map((schemaLocation) => {
+      if (schemaLocation.kind === "common") {
+        return this.schema.generateStatement(schemaLocation.name, schemaLocation.schema);
+      } else {
+        const ref = schemaLocation.schema.$ref;
+        const resolvedSchema = this.params.resolver.getSchema(schemaLocation.currentPoint, ref);
+        if (!resolvedSchema) {
+          throw new Error(resolvedSchema);
+        }
+        return this.schema.generateStatement("名前を決める関数を入れる", resolvedSchema);
+      }
+    });
+    return TsGenerator.factory.Namespace.create({
+      export: true,
+      name: "Schemas",
+      statements: statements,
+    });
+  }
+}
diff --git a/src/code-templates/typedef/components/index.ts b/src/code-templates/typedef/components/index.ts
new file mode 100644
index 00000000..862d55cf
--- /dev/null
+++ b/src/code-templates/typedef/components/index.ts
@@ -0,0 +1 @@
+export * as Schemas from "./Schemas";
diff --git a/src/code-templates/typedef/components/types.ts b/src/code-templates/typedef/components/types.ts
new file mode 100644
index 00000000..2cf575bf
--- /dev/null
+++ b/src/code-templates/typedef/components/types.ts
@@ -0,0 +1,10 @@
+import type { ParsedSchema } from "../../../types";
+import type { ConvertToolkit } from "./ConvertToolKit";
+import type { Resolver } from "../../../reference-resolver";
+
+export interface InitializeParams {
+  readonly entryPoint: string;
+  readonly accessor: ParsedSchema.Accessor;
+  readonly toolkit: ConvertToolkit;
+  readonly resolver: Resolver;
+}
diff --git a/src/code-templates/typedef/index.ts b/src/code-templates/typedef/index.ts
new file mode 100644
index 00000000..43e587a5
--- /dev/null
+++ b/src/code-templates/typedef/index.ts
@@ -0,0 +1,36 @@
+import type { AbstractStruct, CodeGenerator } from "../../types";
+import * as Components from "./components";
+import { ConvertToolkit } from "./components/ConvertToolKit";
+import type { InitializeParams } from "./components/types";
+
+export interface Option {}
+
+export const generator: CodeGenerator.AdvancedGenerateFunction<Option> = (payload, option?: Option): CodeGenerator.IntermediateCode[] => {
+  const { accessor, entryPoint } = payload;
+  const schemaPaths = accessor.operator.getNodePaths("OpenApiSchema");
+
+  // TODO 短くする
+  const schemaLocations: { [currentPath: string]: AbstractStruct.SchemaLocation } = {};
+  schemaPaths.map(currentPoint => {
+    const item = accessor.getChildByPaths(currentPoint, "OpenApiSchema");
+    if (!item) {
+      return;
+    }
+    if (item.value.kind === "common") {
+      schemaLocations[currentPoint] = item.value;
+    } else if (item.value.kind === "remote-reference") {
+      schemaLocations[currentPoint] = item.value;
+    }
+  });
+  const initializeParams: InitializeParams = {
+    accessor: payload.accessor,
+    entryPoint: payload.entryPoint,
+    toolkit: ConvertToolkit,
+    resolver: payload.resolver,
+  };
+  const converter = {
+    schemas: new Components.Schemas.Convert(initializeParams),
+  };
+
+  return [converter.schemas.generateNamespace(schemaLocations)];
+};
diff --git a/src/index.ts b/src/index.ts
index ca022235..392730f0 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -10,11 +10,19 @@ export interface Option {
 export class CodeGenerator {
   private rootSchema: Types.OpenApi.Document;
   private resolvedReferenceDocument: Types.OpenApi.Document;
+  private referenceResolver: Api.Reference.Resolver;
   private parser: Api.OpenApiTools.Parser;
   constructor(private readonly entryPoint: string, option?: Option) {
     this.rootSchema = Api.FileSystem.loadJsonOrYaml(entryPoint);
     this.resolvedReferenceDocument = Api.ResolveReference.resolve(entryPoint, entryPoint, JSON.parse(JSON.stringify(this.rootSchema)));
     this.parser = this.createParser();
+    this.referenceResolver = new Api.Reference.Resolver(this.entryPoint, {
+      loadJsonOrYaml: Api.FileSystem.loadJsonOrYaml.bind(Api.FileSystem),
+    });
+  }
+
+  public async init(): Promise<void> {
+    await this.referenceResolver.init();
   }
 
   private createParser(): Api.OpenApiTools.Parser {
@@ -42,9 +50,22 @@ export class CodeGenerator {
     const create = () => {
       const statements = this.parser.getOpenApiTypeDefinitionStatements();
       generatorTemplates?.forEach(generatorTemplate => {
-        const payload = this.parser.getCodeGeneratorParamsArray(allowOperationIds);
-        const extraStatements = Api.TsGenerator.Utils.convertIntermediateCodes(generatorTemplate.generator(payload, generatorTemplate.option));
-        statements.push(...extraStatements);
+        if (generatorTemplate.kind === "advanced") {
+          const extraStatements = Api.TsGenerator.Utils.convertIntermediateCodes(
+            generatorTemplate.generator(
+              { accessor: this.parser.accessor, entryPoint: this.entryPoint, resolver: this.referenceResolver },
+              generatorTemplate.option,
+            ),
+          );
+          statements.push(...extraStatements);
+        } else {
+          const payload = this.parser.getCodeGeneratorParamsArray(allowOperationIds);
+          generatorTemplate.generator;
+          const extraStatements = Api.TsGenerator.Utils.convertIntermediateCodes(
+            generatorTemplate.generator(payload, generatorTemplate.option),
+          );
+          statements.push(...extraStatements);
+        }
       });
       return statements;
     };
@@ -62,6 +83,14 @@ export class CodeGenerator {
     const create = () => {
       return generatorTemplates
         .map(generatorTemplate => {
+          if (generatorTemplate.kind === "advanced") {
+            return Api.TsGenerator.Utils.convertIntermediateCodes(
+              generatorTemplate?.generator(
+                { accessor: this.parser.accessor, entryPoint: this.entryPoint, resolver: this.referenceResolver },
+                generatorTemplate.option,
+              ),
+            );
+          }
           return Api.TsGenerator.Utils.convertIntermediateCodes(generatorTemplate?.generator(payload, generatorTemplate.option));
         })
         .flat();
diff --git a/src/internal/FileSystem/index.ts b/src/internal/FileSystem/index.ts
index 2b4c0b6f..7f8c6361 100644
--- a/src/internal/FileSystem/index.ts
+++ b/src/internal/FileSystem/index.ts
@@ -6,11 +6,6 @@ import * as yaml from "js-yaml";
 
 import { UnSupportError } from "../Exception";
 
-export interface Type {
-  existSync: (entrypoint: string) => boolean;
-  loadJsonOrYaml: (entryPoint: string) => any;
-}
-
 export class FileSystem {
   private static FRAGMENT = "#/";
   private static internalLoadJsonOrYaml(filename: string): any {
diff --git a/src/internal/OpenApiTools/ConverterContext.ts b/src/internal/OpenApiTools/ConverterContext.ts
index 819b7f4c..a929dfa8 100644
--- a/src/internal/OpenApiTools/ConverterContext.ts
+++ b/src/internal/OpenApiTools/ConverterContext.ts
@@ -1,42 +1,12 @@
 import * as Utils from "../../utils";
-/**
- * ユーザーが利用できる各種変換オプション
- */
-// export interface Options {
-
-// }
+import type { ConverterContext } from "./types/context";
 
-export interface Types {
-  /**
-   * operationIdに対するescape
-   */
-  escapeOperationIdText: (operationId: string) => string;
-  /**
-   * interface/namespace/typeAliasのnameをescapeする
-   * import/exportなどの予約語も裁く
-   */
-  escapeDeclarationText: (text: string) => string;
-  /**
-   * 非破壊: PropertySignatureのname用のescape
-   */
-  escapePropertySignatureName: (text: string) => string;
-  /**
-   * 破壊: TypeReferenceのname用のescape
-   */
-  escapeTypeReferenceNodeName: (text: string) => string;
-  generateResponseName: (operationId: string, statusCode: string) => string;
-  generateArgumentParamsTypeDeclaration: (operationId: string) => string;
-  generateRequestContentTypeName: (operationId: string) => string;
-  generateResponseContentTypeName: (operationId: string) => string;
-  generateParameterName: (operationId: string) => string;
-  generateRequestBodyName: (operationId: string) => string;
-  generateFunctionName: (operationId: string) => string;
-}
+export type Types = ConverterContext;
 
 /**
  * ユーザーが利用できる各種変換オプション
  */
-export const create = (): Types => {
+export const create = (): ConverterContext => {
   const convertReservedWord = (word: string): string => {
     if (["import", "export"].includes(word)) {
       return word + "_";
diff --git a/src/internal/OpenApiTools/Parser.ts b/src/internal/OpenApiTools/Parser.ts
index aebd3d39..d9d9990c 100644
--- a/src/internal/OpenApiTools/Parser.ts
+++ b/src/internal/OpenApiTools/Parser.ts
@@ -1,33 +1,43 @@
 import ts from "typescript";
 
-import type { CodeGenerator, OpenApi } from "../../types";
+import type { CodeGenerator, OpenApi, ParsedSchema } from "../../types";
 import * as TypeScriptCodeGenerator from "../TsGenerator";
 import * as Headers from "./components/Headers";
 import * as Parameters from "./components/Parameters";
 import * as RequestBodies from "./components/RequestBodies";
 import * as Responses from "./components/Responses";
 import * as Schemas from "./components/Schemas";
+import * as Schemas2 from "./components2/Schemas";
 import * as ConvertContext from "./ConverterContext";
 import * as Extractor from "./Extractor";
 import * as Paths from "./paths";
+import * as StructContext from "./StructContext";
 import * as TypeNodeContext from "./TypeNodeContext";
-import { Store } from "./Walker";
+import * as Walker from "./Walker";
+import * as Walker2 from "./Walker2";
 
 export class Parser {
   private currentPoint: string;
-  private convertContext: ConvertContext.Types;
-  private store: Store;
+  private converterContext = ConvertContext.create();
+  private store: Walker.Store;
+  private store2: Walker2.Store;
   private factory: TypeScriptCodeGenerator.Factory.Type;
+  private schemaLocator: Schemas2.Locator;
   constructor(private entryPoint: string, private rootSchema: OpenApi.Document, noReferenceOpenApiSchema: OpenApi.Document) {
     this.currentPoint = entryPoint;
-    this.convertContext = ConvertContext.create();
     this.factory = TypeScriptCodeGenerator.Factory.create();
-    this.store = new Store(this.factory, noReferenceOpenApiSchema);
+    this.store = new Walker.Store(this.factory, noReferenceOpenApiSchema);
+    this.store2 = new Walker2.Store(noReferenceOpenApiSchema);
+    this.schemaLocator = new Schemas2.Locator({
+      entryPoint,
+      store: this.store2,
+    });
     this.initialize();
   }
 
   private initialize(): void {
-    const toTypeNodeContext = TypeNodeContext.create(this.entryPoint, this.store, this.factory, this.convertContext);
+    const toTypeNodeContext = TypeNodeContext.create(this.entryPoint, this.store, this.factory, this.converterContext);
+    const structContext = StructContext.create(this.entryPoint, this.store, this.factory, this.converterContext);
     const rootSchema = this.rootSchema;
     if (rootSchema.components) {
       if (rootSchema.components.schemas) {
@@ -38,8 +48,9 @@ export class Parser {
           this.factory,
           rootSchema.components.schemas,
           toTypeNodeContext,
-          this.convertContext,
+          this.converterContext,
         );
+        this.schemaLocator.determine(this.currentPoint, rootSchema.components.schemas);
       }
       if (rootSchema.components.headers) {
         Headers.generateNamespace(
@@ -49,7 +60,7 @@ export class Parser {
           this.factory,
           rootSchema.components.headers,
           toTypeNodeContext,
-          this.convertContext,
+          this.converterContext,
         );
       }
       if (rootSchema.components.responses) {
@@ -60,7 +71,7 @@ export class Parser {
           this.factory,
           rootSchema.components.responses,
           toTypeNodeContext,
-          this.convertContext,
+          this.converterContext,
         );
       }
       if (rootSchema.components.parameters) {
@@ -71,7 +82,7 @@ export class Parser {
           this.factory,
           rootSchema.components.parameters,
           toTypeNodeContext,
-          this.convertContext,
+          this.converterContext,
         );
       }
       if (rootSchema.components.requestBodies) {
@@ -82,7 +93,7 @@ export class Parser {
           this.factory,
           rootSchema.components.requestBodies,
           toTypeNodeContext,
-          this.convertContext,
+          this.converterContext,
         );
       }
       // if (rootSchema.components.securitySchemes) {
@@ -109,15 +120,27 @@ export class Parser {
         this.factory,
         rootSchema.paths,
         toTypeNodeContext,
-        this.convertContext,
+        this.converterContext,
       );
     }
+    this.store2.debugAbstractDataStruct();
+  }
+
+  /**
+   * 抽象化されたAccessor
+   */
+  public get accessor(): ParsedSchema.Accessor {
+    return this.store2.accessor;
   }
 
   public getCodeGeneratorParamsArray(allowOperationIds?: string[]): CodeGenerator.Params[] {
-    return Extractor.generateCodeGeneratorParamsArray(this.store, this.convertContext, allowOperationIds);
+    return Extractor.generateCodeGeneratorParamsArray(this.store, this.converterContext, allowOperationIds);
   }
 
+  /**
+   *
+   * @returns 依存を排除する
+   */
   public getOpenApiTypeDefinitionStatements(): ts.Statement[] {
     return this.store.getRootStatements();
   }
diff --git a/src/internal/OpenApiTools/StructContext.ts b/src/internal/OpenApiTools/StructContext.ts
new file mode 100644
index 00000000..5e2437fe
--- /dev/null
+++ b/src/internal/OpenApiTools/StructContext.ts
@@ -0,0 +1,153 @@
+import * as Path from "path";
+
+import ts from "typescript";
+
+import { DevelopmentError } from "../Exception";
+import * as TypeScriptCodeGenerator from "../TsGenerator";
+import type { ConverterContext } from "./types/context";
+import * as ToTypeNode from "./toTypeNode";
+import type * as Walker from "./Walker";
+
+export interface ReferencePathSet {
+  pathArray: string[];
+  base: string;
+}
+
+const generatePath = (entryPoint: string, currentPoint: string, referencePath: string): ReferencePathSet => {
+  const ext = Path.extname(currentPoint); // .yml
+  const from = Path.relative(Path.dirname(entryPoint), currentPoint).replace(ext, ""); // components/schemas/A/B
+  const base = Path.dirname(from).replace(Path.sep, "/");
+  const result = Path.posix.relative(base, referencePath); // remoteの場合? localの場合 referencePath.split("/")
+  const pathArray = result.split("/");
+  return {
+    pathArray,
+    base,
+  };
+};
+
+const calculateReferencePath = (store: Walker.Store, base: string, pathArray: string[]): ToTypeNode.ResolveReferencePath => {
+  let names: string[] = [];
+  let unresolvedPaths: string[] = [];
+  pathArray.reduce((previous, lastPath, index) => {
+    const current = Path.posix.join(previous, lastPath);
+    // ディレクトリが深い場合は相対パスが`..`を繰り返す可能性があり、
+    // その場合はすでに登録されたnamesを削除する
+    if (lastPath === ".." && names.length > 0) {
+      names = names.slice(0, names.length - 1);
+    }
+    const isFinalPath = index === pathArray.length - 1;
+    if (isFinalPath) {
+      const statement = store.getStatement(current, "interface");
+      const statement2 = store.getStatement(current, "typeAlias");
+      const statement3 = store.getStatement(current, "namespace");
+      if (statement) {
+        names.push(statement.name);
+        return current;
+      } else if (statement2) {
+        names.push(statement2.name);
+        return current;
+      } else if (statement3) {
+        names.push(statement3.name);
+        return current;
+      } else {
+        unresolvedPaths.push(lastPath);
+      }
+    } else {
+      const statement = store.getStatement(current, "namespace");
+      if (statement) {
+        unresolvedPaths = unresolvedPaths.slice(0, unresolvedPaths.length - 1);
+        names.push(statement.name);
+      } else {
+        unresolvedPaths.push(lastPath);
+      }
+    }
+    return current;
+  }, base);
+  if (names.length === 0) {
+    throw new DevelopmentError("Local Reference Error \n" + JSON.stringify({ pathArray, names, base }, null, 2));
+  }
+  return {
+    name: names.join("."),
+    maybeResolvedName: names.concat(unresolvedPaths).join("."),
+    unresolvedPaths,
+  };
+};
+
+export const create = (
+  entryPoint: string,
+  store: Walker.Store,
+  factory: TypeScriptCodeGenerator.Factory.Type,
+  converterContext: ConverterContext,
+): ToTypeNode.Context => {
+  const resolveReferencePath: ToTypeNode.Context["resolveReferencePath"] = (currentPoint, referencePath) => {
+    const { pathArray, base } = generatePath(entryPoint, currentPoint, referencePath);
+    return calculateReferencePath(store, base, pathArray);
+  };
+  const setReferenceHandler: ToTypeNode.Context["setReferenceHandler"] = (currentPoint, reference) => {
+    if (store.hasStatement(reference.path, ["interface", "typeAlias"])) {
+      return;
+    }
+    if (reference.type === "remote") {
+      const typeNode = ToTypeNode.convert(
+        entryPoint,
+        reference.referencePoint,
+        factory,
+        reference.data,
+        {
+          setReferenceHandler,
+          resolveReferencePath,
+        },
+        converterContext,
+      );
+      if (ts.isTypeLiteralNode(typeNode)) {
+        store.addStatement(reference.path, {
+          kind: "interface",
+          name: reference.name,
+          value: factory.InterfaceDeclaration.create({
+            export: true,
+            name: reference.name,
+            members: typeNode.members,
+          }),
+        });
+      } else {
+        const value = factory.TypeAliasDeclaration.create({
+          export: true,
+          name: converterContext.escapeDeclarationText(reference.name),
+          type: ToTypeNode.convert(
+            entryPoint,
+            reference.referencePoint,
+            factory,
+            reference.data,
+            {
+              setReferenceHandler,
+              resolveReferencePath,
+            },
+            converterContext,
+          ),
+        });
+        store.addStatement(reference.path, {
+          name: reference.name,
+          kind: "typeAlias",
+          value,
+        });
+      }
+    } else if (reference.type === "local") {
+      if (!store.isAfterDefined(reference.path)) {
+        const { maybeResolvedName } = resolveReferencePath(currentPoint, reference.path);
+        const value = factory.TypeAliasDeclaration.create({
+          export: true,
+          name: converterContext.escapeDeclarationText(reference.name),
+          type: factory.TypeReferenceNode.create({
+            name: converterContext.escapeTypeReferenceNodeName(maybeResolvedName),
+          }),
+        });
+        store.addStatement(reference.path, {
+          name: reference.name,
+          kind: "typeAlias",
+          value,
+        });
+      }
+    }
+  };
+  return { setReferenceHandler: setReferenceHandler, resolveReferencePath: resolveReferencePath };
+};
diff --git a/src/internal/OpenApiTools/TypeNodeContext.ts b/src/internal/OpenApiTools/TypeNodeContext.ts
index 0270a813..a11e0df2 100644
--- a/src/internal/OpenApiTools/TypeNodeContext.ts
+++ b/src/internal/OpenApiTools/TypeNodeContext.ts
@@ -4,7 +4,7 @@ import ts from "typescript";
 
 import { DevelopmentError } from "../Exception";
 import * as TypeScriptCodeGenerator from "../TsGenerator";
-import * as ConverterContext from "./ConverterContext";
+import type { ConverterContext } from "./types/context";
 import * as ToTypeNode from "./toTypeNode";
 import type * as Walker from "./Walker";
 
@@ -77,11 +77,19 @@ export const create = (
   entryPoint: string,
   store: Walker.Store,
   factory: TypeScriptCodeGenerator.Factory.Type,
-  converterContext: ConverterContext.Types,
+  converterContext: ConverterContext,
 ): ToTypeNode.Context => {
   const resolveReferencePath: ToTypeNode.Context["resolveReferencePath"] = (currentPoint, referencePath) => {
     const { pathArray, base } = generatePath(entryPoint, currentPoint, referencePath);
-    return calculateReferencePath(store, base, pathArray);
+    const r = calculateReferencePath(store, base, pathArray);
+
+    console.log({
+      currentPoint,
+      referencePoint: referencePath,
+      expectResult: r.name,
+      expectResult2: r.maybeResolvedName,
+    })
+    return r;
   };
   const setReferenceHandler: ToTypeNode.Context["setReferenceHandler"] = (currentPoint, reference) => {
     if (store.hasStatement(reference.path, ["interface", "typeAlias"])) {
diff --git a/src/internal/OpenApiTools/Walker2/Definition.ts b/src/internal/OpenApiTools/Walker2/Definition.ts
new file mode 100644
index 00000000..c5ce0bbd
--- /dev/null
+++ b/src/internal/OpenApiTools/Walker2/Definition.ts
@@ -0,0 +1,11 @@
+export type ComponentName = "schemas" | "headers" | "responses" | "parameters" | "requestBodies" | "securitySchemes" | "pathItems";
+
+export const componentNames: ComponentName[] = [
+  "schemas",
+  "headers",
+  "responses",
+  "parameters",
+  "requestBodies",
+  "securitySchemes",
+  "pathItems",
+];
diff --git a/src/internal/OpenApiTools/Walker2/Operation.ts b/src/internal/OpenApiTools/Walker2/Operation.ts
new file mode 100644
index 00000000..74eb864b
--- /dev/null
+++ b/src/internal/OpenApiTools/Walker2/Operation.ts
@@ -0,0 +1,46 @@
+import { EOL } from "os";
+
+import type { CodeGenerator, OpenApi } from "../../../types";
+
+const httpMethodList = ["get", "put", "post", "delete", "options", "head", "patch", "trace"] as const;
+
+export interface State {
+  [operationId: string]: CodeGenerator.OpenApiOperation;
+}
+
+type UniqueParameterMap = Record<string, OpenApi.Parameter>;
+
+const uniqParameters = (rawParameters: OpenApi.Parameter[]): OpenApi.Parameter[] => {
+  const parameterMap = rawParameters.reduce<UniqueParameterMap>((all, parameter) => {
+    return { ...all, [`${parameter.in}:${parameter.name}`]: parameter };
+  }, {});
+  return Object.values(parameterMap);
+};
+
+export const create = (rootSchema: OpenApi.Document): State => {
+  const paths = rootSchema.paths || {};
+  const state: State = {};
+  Object.entries(paths).forEach(([requestUri, pathItem]) => {
+    httpMethodList.forEach(httpMethod => {
+      const operation = pathItem[httpMethod];
+      if (!operation) {
+        return;
+      }
+      if (!operation.operationId) {
+        return;
+      }
+      const parameters = [...(pathItem.parameters || []), ...(operation.parameters || [])] as OpenApi.Parameter[];
+
+      state[operation.operationId] = {
+        httpMethod,
+        requestUri,
+        comment: [operation.summary, operation.description].filter(Boolean).join(EOL),
+        deprecated: !!operation.deprecated,
+        requestBody: operation.requestBody as OpenApi.RequestBody,
+        parameters: uniqParameters(parameters),
+        responses: operation.responses as CodeGenerator.OpenApiResponses,
+      };
+    });
+  });
+  return state;
+};
diff --git a/src/internal/OpenApiTools/Walker2/State.ts b/src/internal/OpenApiTools/Walker2/State.ts
new file mode 100644
index 00000000..b8969b35
--- /dev/null
+++ b/src/internal/OpenApiTools/Walker2/State.ts
@@ -0,0 +1,42 @@
+import ts from "typescript";
+
+import type { OpenApi } from "../../../types";
+
+export type {
+  OperatorType,
+  GetChildByPaths,
+  Instance,
+  ComponentProperty,
+  DirectoryTreeProperty,
+  AbstractDataStructureNodeProperty,
+} from "./structure";
+
+export interface OperationState {
+  requestUri: string;
+  httpMethod: string;
+  parameterName?: string;
+  requestBodyName?: string;
+}
+
+export interface Type {
+  document: OpenApi.Document;
+  additionalStatements: ts.Statement[];
+  operations: {
+    [operationId: string]: OperationState;
+  };
+}
+
+export const createDefaultOperationState = (httpMethod: string, requestUri: string, state: Partial<OperationState>): OperationState => {
+  return {
+    httpMethod: httpMethod,
+    requestUri: requestUri,
+    parameterName: state.parameterName,
+    requestBodyName: state.parameterName,
+  };
+};
+
+export const createDefaultState = (rootDocument: OpenApi.Document): Type => ({
+  document: rootDocument,
+  additionalStatements: [],
+  operations: {},
+});
diff --git a/src/internal/OpenApiTools/Walker2/Store.ts b/src/internal/OpenApiTools/Walker2/Store.ts
new file mode 100644
index 00000000..21822a67
--- /dev/null
+++ b/src/internal/OpenApiTools/Walker2/Store.ts
@@ -0,0 +1,45 @@
+import * as fs from "fs";
+import * as Path from "path";
+
+import type { OpenApi, ParsedSchema, AbstractStruct } from "../../../types";
+import * as Def from "./Definition";
+import * as State from "./State";
+import * as Structure from "./structure";
+
+export { Structure };
+
+class Store {
+  private state: State.Type;
+  private operator: Structure.OperatorType;
+  private getChildByPaths: Structure.GetChildByPaths;
+  constructor(rootDocument: OpenApi.Document) {
+    this.state = State.createDefaultState(rootDocument);
+    const { operator, getChildByPaths } = Structure.create();
+    this.operator = operator;
+    this.getChildByPaths = getChildByPaths;
+  }
+  public determineSchemaLocation(path: string, abstractDataStruct: AbstractStruct.SchemaLocation): void {
+    const targetPath = Path.posix.relative("components", path);
+    this.operator.set(targetPath, new Structure.OpenApiSchema.Item({ name: path, value: abstractDataStruct }));
+  }
+  public createDirectory(componentName: Def.ComponentName, componentProperty: Structure.DirectoryTreeProperty): void {
+    this.operator.set(`${componentName}`, Structure.createInstance(componentProperty));
+  }
+  public isPossession(path: string): boolean {
+    return !!this.operator.getChildByPaths(path, Structure.OpenApiSchema.Kind);
+  }
+  public debugAbstractDataStruct() {
+    const data = this.operator.getHierarchy();
+    console.log("output debug/hierarchy.json");
+    fs.writeFileSync("debug/hierarchy.json", JSON.stringify(data, null, 2), { encoding: "utf-8" });
+    fs.writeFileSync("debug/paths.json", JSON.stringify(this.operator.getNodePaths("OpenApiSchema"), null, 2), { encoding: "utf-8" });
+  }
+  public get accessor(): ParsedSchema.Accessor {
+    return {
+      operator: this.operator,
+      getChildByPaths: this.getChildByPaths,
+    };
+  }
+}
+
+export { Store };
diff --git a/src/internal/OpenApiTools/Walker2/index.ts b/src/internal/OpenApiTools/Walker2/index.ts
new file mode 100644
index 00000000..810effcf
--- /dev/null
+++ b/src/internal/OpenApiTools/Walker2/index.ts
@@ -0,0 +1,3 @@
+export { Store, Structure } from "./Store";
+export * as State from "./State";
+export * as Def from "./Definition";
diff --git a/src/internal/OpenApiTools/Walker2/structure/DataStructure.ts b/src/internal/OpenApiTools/Walker2/structure/DataStructure.ts
new file mode 100644
index 00000000..8296f270
--- /dev/null
+++ b/src/internal/OpenApiTools/Walker2/structure/DataStructure.ts
@@ -0,0 +1,21 @@
+import type { Operator } from "@himenon/path-oriented-data-structure";
+
+import * as OpenApiSchema from "./OpenApiSchema";
+import * as Directory from "./Directory";
+
+export { OpenApiSchema as AbstractDataStructure, Directory };
+
+export type Kind = OpenApiSchema.Kind | Directory.Kind;
+
+export type GetChild<T extends Kind> = T extends OpenApiSchema.Kind
+  ? OpenApiSchema.Item
+  : T extends Directory.Kind
+  ? Directory.Item
+  : never;
+
+// Type Safe method
+export const createGetChildByPaths = (operator: Operator<string>) => <T extends Kind>(path: string, kind: T): GetChild<T> | undefined => {
+  return operator.getChildByPaths(path, kind) as GetChild<T> | undefined;
+};
+
+export type GetChildByPaths = <T extends Kind>(path: string, kind: T) => GetChild<T> | undefined;
diff --git a/src/internal/OpenApiTools/Walker2/structure/Directory.ts b/src/internal/OpenApiTools/Walker2/structure/Directory.ts
new file mode 100644
index 00000000..d8610290
--- /dev/null
+++ b/src/internal/OpenApiTools/Walker2/structure/Directory.ts
@@ -0,0 +1,16 @@
+import { Tree as BaseTree } from "@himenon/path-oriented-data-structure";
+
+export type Kind = "directory";
+export const Kind: Kind = "directory";
+
+export interface Property {
+  name: string;
+  comment?: string;
+  deprecated?: boolean;
+}
+
+export class Item extends BaseTree<Kind> {
+  constructor(public property: Property) {
+    super("directory", property.name);
+  }
+}
diff --git a/src/internal/OpenApiTools/Walker2/structure/OpenApiSchema.ts b/src/internal/OpenApiTools/Walker2/structure/OpenApiSchema.ts
new file mode 100644
index 00000000..3d088253
--- /dev/null
+++ b/src/internal/OpenApiTools/Walker2/structure/OpenApiSchema.ts
@@ -0,0 +1,19 @@
+import { Node as BaseNode } from "@himenon/path-oriented-data-structure";
+
+import type { AbstractStruct } from "../../../../types";
+
+export type Kind = "OpenApiSchema";
+export const Kind: Kind = "OpenApiSchema";
+
+export interface Property {
+  name: string;
+  value: AbstractStruct.SchemaLocation;
+}
+
+export class Item extends BaseNode<Kind> {
+  public value: AbstractStruct.SchemaLocation;
+  constructor(property: Property) {
+    super("OpenApiSchema", property.name);
+    this.value = property.value;
+  }
+}
diff --git a/src/internal/OpenApiTools/Walker2/structure/index.ts b/src/internal/OpenApiTools/Walker2/structure/index.ts
new file mode 100644
index 00000000..c802d47d
--- /dev/null
+++ b/src/internal/OpenApiTools/Walker2/structure/index.ts
@@ -0,0 +1,42 @@
+import { Operator } from "@himenon/path-oriented-data-structure";
+
+import * as OpenApiSchema from "./OpenApiSchema";
+import * as DataStructure from "./DataStructure";
+import * as Directory from "./Directory";
+
+export { DataStructure, OpenApiSchema, Directory };
+
+export interface AbstractDataStructureNodeProperty extends OpenApiSchema.Property {
+  kind: OpenApiSchema.Kind;
+}
+
+export interface DirectoryTreeProperty extends Directory.Property {
+  kind: Directory.Kind;
+}
+
+export type ComponentProperty = AbstractDataStructureNodeProperty | DirectoryTreeProperty;
+
+export type Instance = OpenApiSchema.Item | Directory.Item;
+
+export const createInstance = (componentProperty: ComponentProperty): Instance => {
+  if (componentProperty.kind === "OpenApiSchema") {
+    return new OpenApiSchema.Item(componentProperty);
+  }
+  if (componentProperty.kind === "directory") {
+    return new Directory.Item(componentProperty);
+  }
+
+  throw new Error("not registers");
+};
+
+export const create = () => {
+  const operator = new Operator(Directory.Kind);
+  return {
+    operator,
+    getChildByPaths: DataStructure.createGetChildByPaths(operator),
+  };
+};
+
+export type OperatorType = Operator<Directory.Kind>;
+
+export type GetChildByPaths = DataStructure.GetChildByPaths;
diff --git a/src/internal/OpenApiTools/components2/Reference.ts b/src/internal/OpenApiTools/components2/Reference.ts
new file mode 100644
index 00000000..19192697
--- /dev/null
+++ b/src/internal/OpenApiTools/components2/Reference.ts
@@ -0,0 +1,147 @@
+import { posix as path } from "path";
+
+import type { OpenApi } from "../../../types";
+import type { InitializeParams } from "./types";
+
+export type LocalReferencePattern =
+  | "#/components/schemas/"
+  | "#/components/responses/"
+  | "#/components/parameters/"
+  | "#/components/examples/"
+  | "#/components/requestBodies/"
+  | "#/components/headers/"
+  | "#/components/securitySchemes/"
+  | "#/components/links/"
+  | "#/components/callbacks/"
+  | "#/components/pathItems/";
+
+export interface LocalReference {
+  type: "local";
+  /**
+   * @example #/components/schemas/Hoge -> Hoge
+   */
+  name: string;
+  /**
+   * startsWith `components`
+   * components/headers/hoge/fuga
+   */
+  path: string;
+}
+
+export interface RemoteReference {
+  type: "remote";
+  /**
+   * file path
+   */
+  referencePoint: string;
+  /**
+   * startsWith `components`
+   * components/headers/hoge/fuga
+   */
+  path: string;
+  /**
+   * From filename - extension
+   * @example a/b/c/Hoge.yml -> Hoge
+   */
+  name: string;
+  /**
+   * If "componentName" exists, you can create an alias for the type.
+   * If it does not exist, you need to define the type directly.
+   */
+  componentName?: "schemas" | "headers" | "responses" | "parameters" | "requestBodies" | "securitySchemes" | "pathItems";
+}
+
+export class Locator {
+  private readonly localRefMap = {
+    "#/components/schemas/": "components/schemas",
+    "#/components/responses/": "components/responses",
+    "#/components/parameters/": "components/parameters",
+    "#/components/examples/": "components/examples",
+    "#/components/requestBodies/": "components/requestBodies",
+    "#/components/headers/": "components/headers",
+    "#/components/securitySchemes/": "components/securitySchemes",
+    "#/components/links/": "components/links",
+    "#/components/callbacks/": "components/callbacks",
+    "#/components/pathItems/": "components/pathItems",
+  } as const;
+
+  private readonly localReferencePatterns: LocalReferencePattern[] = [
+    "#/components/schemas/",
+    "#/components/responses/",
+    "#/components/parameters/",
+    "#/components/examples/",
+    "#/components/requestBodies/",
+    "#/components/headers/",
+    "#/components/securitySchemes/",
+    "#/components/links/",
+    "#/components/callbacks/",
+    "#/components/pathItems/",
+  ];
+
+  constructor(private readonly params: InitializeParams) {}
+
+  private generateReferencePoint(currentPoint: string, reference: OpenApi.Reference): string {
+    const basedir = path.dirname(currentPoint);
+    const ref = reference.$ref;
+    const referencePoint = path.join(basedir, ref);
+    return referencePoint;
+  }
+
+  private generateRemoteReference(referencePoint: string): RemoteReference {
+    const relativePathFromEntryPoint = path.relative(path.dirname(this.params.entryPoint), referencePoint); // components/hoge/fuga.yml
+    const ext = path.extname(relativePathFromEntryPoint); // .yml
+    const pathArray: string[] = relativePathFromEntryPoint.replace(ext, "").split(path.sep); // ["components", "hoge", "fuga"]
+    const targetPath: string = pathArray.join("/"); // components/hoge/fuga
+    const schemaName = pathArray[pathArray.length - 1]; // fuga
+    const componentName = pathArray[0] === "components" ? pathArray[1] : "";
+
+    if (!targetPath.startsWith("components")) {
+      throw new Error(`TargetPath is not start "components":\n${targetPath}`);
+    }
+    return {
+      type: "remote",
+      referencePoint,
+      path: targetPath,
+      name: schemaName,
+      componentName: ["schemas", "headers", "responses", "parameters", "requestBodies", "securitySchemes", "pathItems"].includes(componentName)
+        ? (componentName as RemoteReference["componentName"])
+        : undefined,
+    };
+  }
+
+  private generateLocalReference(ref: string): LocalReference | undefined {
+    const localReferencePattern = this.getLocalReference(ref);
+    if (!localReferencePattern) {
+      return;
+    }
+    const name = ref.split(localReferencePattern)[1];
+    const localPath = path.join(this.localRefMap[localReferencePattern], name);
+    if (!localPath.startsWith("components")) {
+      throw new Error(`LocalPath is not start "components":\n${localPath}`);
+    }
+    return {
+      type: "local",
+      name: name,
+      path: localPath,
+    };
+  }
+
+  private getLocalReference(ref: string): LocalReferencePattern | undefined {
+    let localReferencePattern: LocalReferencePattern | undefined;
+    this.localReferencePatterns.forEach(referencePattern => {
+      if (new RegExp("^" + referencePattern).test(ref)) {
+        localReferencePattern = referencePattern;
+      }
+    });
+    return localReferencePattern;
+  }
+
+  public search(currentPoint: string, schema: OpenApi.Reference): LocalReference | RemoteReference {
+    const localReference = this.generateLocalReference(schema.$ref);
+    if (localReference) {
+      return localReference;
+    }
+    const referencePoint = this.generateReferencePoint(currentPoint, schema);
+    return this.generateRemoteReference(referencePoint);
+  }
+}
diff --git a/src/internal/OpenApiTools/components2/Schema.ts b/src/internal/OpenApiTools/components2/Schema.ts
new file mode 100644
index 00000000..e69de29b
diff --git a/src/internal/OpenApiTools/components2/Schemas.ts b/src/internal/OpenApiTools/components2/Schemas.ts
new file mode 100644
index 00000000..e3d5b097
--- /dev/null
+++ b/src/internal/OpenApiTools/components2/Schemas.ts
@@ -0,0 +1,62 @@
+import type { OpenApi } from "../../../types";
+import { ReferencePath } from "../../../utils";
+import * as Guard from "../Guard";
+import * as InferredType from "../InferredType";
+import * as Name from "../Name";
+import * as Reference from "./Reference";
+import type { InitializeParams } from "./types";
+
+export class Locator {
+  private basePath = "components/schemas";
+  public reference: Reference.Locator = new Reference.Locator(this.params);
+  constructor(private readonly params: InitializeParams) {
+    this.params.store.createDirectory("schemas", {
+      kind: "directory",
+      name: Name.Components.Schemas,
+    });
+  }
+
+  public determine(currentPoint: string, schemas: Record<string, OpenApi.Schema | OpenApi.Reference>) {
+    Object.entries(schemas).forEach(([name, schema]) => {
+      if (Guard.isReference(schema)) {
+        this.determineByReference(currentPoint, name, schema);
+      } else {
+        this.determineByCommon(currentPoint, name, schema);
+      }
+    });
+  }
+
+  private determineByCommon(currentPoint: string, name: string, inputSchema: OpenApi.Schema) {
+    const schema = InferredType.getInferredType(inputSchema);
+    if (schema) {
+      const path = `${this.basePath}/${name}`;
+      this.params.store.determineSchemaLocation(path, {
+        kind: "common",
+        name: name,
+        schema: schema,
+      });
+    }
+  }
+
+  private determineByReference(currentPoint: string, name: string, schema: OpenApi.Reference) {
+    const reference = this.reference.search(currentPoint, schema);
+    if (reference.type === "local") {
+      this.params.store.determineSchemaLocation(`${this.basePath}/${name}`, {
+        kind: "local-reference",
+        schema: schema,
+        currentPoint,
+      });
+      return;
+    } else if (reference.type === "remote") {
+      if (this.params.store.isPossession(`${this.basePath}/${name}`)) {
+        return;
+      }
+      this.params.store.determineSchemaLocation(reference.path, {
+        kind: "remote-reference",
+        schema: schema,
+        currentPoint,
+      });
+      return;
+    }
+  }
+}
diff --git a/src/internal/OpenApiTools/components2/types.ts b/src/internal/OpenApiTools/components2/types.ts
new file mode 100644
index 00000000..9079e64a
--- /dev/null
+++ b/src/internal/OpenApiTools/components2/types.ts
@@ -0,0 +1,6 @@
+import type * as Walker from "../Walker2";
+
+export interface InitializeParams {
+  readonly entryPoint: string;
+  readonly store: Walker.Store;
+}
diff --git a/src/internal/OpenApiTools/index.ts b/src/internal/OpenApiTools/index.ts
index 8c01bbaf..ea7d57db 100644
--- a/src/internal/OpenApiTools/index.ts
+++ b/src/internal/OpenApiTools/index.ts
@@ -1,2 +1,4 @@
 export * as Comment from "./Comment";
 export { Parser } from "./Parser";
+export * as Guard from "./Guard";
+export * as InferredType from "./InferredType";
diff --git a/src/internal/OpenApiTools/toTypeNode.ts b/src/internal/OpenApiTools/toTypeNode.ts
index 76014ca1..a70ff4f3 100644
--- a/src/internal/OpenApiTools/toTypeNode.ts
+++ b/src/internal/OpenApiTools/toTypeNode.ts
@@ -6,7 +6,7 @@ import { UnSupportError } from "../Exception";
 import * as Logger from "../Logger";
 import { Factory } from "../TsGenerator";
 import * as Reference from "./components/Reference";
-import * as ConverterContext from "./ConverterContext";
+import { ConverterContext } from "./types/context";
 import * as Guard from "./Guard";
 import * as InferredType from "./InferredType";
 import { ObjectSchemaWithAdditionalProperties } from "./types";
@@ -28,7 +28,7 @@ export type Convert = (
   factory: Factory.Type,
   schema: OpenApi.Schema | OpenApi.Reference | OpenApi.JSONSchemaDefinition,
   setReference: Context,
-  convertContext: ConverterContext.Types,
+  convertContext: ConverterContext,
   option?: Option,
 ) => ts.TypeNode;
 
@@ -43,7 +43,7 @@ export const generateMultiTypeNode = (
   schemas: OpenApi.JSONSchema[],
   setReference: Context,
   convert: Convert,
-  convertContext: ConverterContext.Types,
+  convertContext: ConverterContext,
   multiType: "oneOf" | "allOf" | "anyOf",
 ): ts.TypeNode => {
   const typeNodes = schemas.map(schema => convert(entryPoint, currentPoint, factory, schema, setReference, convertContext));
@@ -81,7 +81,7 @@ export const convert: Convert = (
   factory: Factory.Type,
   schema: OpenApi.Schema | OpenApi.Reference | OpenApi.JSONSchemaDefinition,
   context: Context,
-  converterContext: ConverterContext.Types,
+  converterContext: ConverterContext,
   option?: Option,
 ): ts.TypeNode => {
   if (typeof schema === "boolean") {
@@ -253,7 +253,7 @@ export const convertAdditionalProperties = (
   factory: Factory.Type,
   schema: ObjectSchemaWithAdditionalProperties,
   setReference: Context,
-  convertContext: ConverterContext.Types,
+  convertContext: ConverterContext,
 ): ts.IndexSignatureDeclaration => {
   // // https://swagger.io/docs/specification/data-models/dictionaries/#free-form
   if (schema.additionalProperties === true) {
diff --git a/src/internal/OpenApiTools/types/context.ts b/src/internal/OpenApiTools/types/context.ts
new file mode 100644
index 00000000..39677a37
--- /dev/null
+++ b/src/internal/OpenApiTools/types/context.ts
@@ -0,0 +1,26 @@
+export interface ConverterContext {
+  /**
+   * operationIdに対するescape
+   */
+  escapeOperationIdText: (operationId: string) => string;
+  /**
+   * interface/namespace/typeAliasのnameをescapeする
+   * import/exportなどの予約語も裁く
+   */
+  escapeDeclarationText: (text: string) => string;
+  /**
+   * 非破壊: PropertySignatureのname用のescape
+   */
+  escapePropertySignatureName: (text: string) => string;
+  /**
+   * 破壊: TypeReferenceのname用のescape
+   */
+  escapeTypeReferenceNodeName: (text: string) => string;
+  generateResponseName: (operationId: string, statusCode: string) => string;
+  generateArgumentParamsTypeDeclaration: (operationId: string) => string;
+  generateRequestContentTypeName: (operationId: string) => string;
+  generateResponseContentTypeName: (operationId: string) => string;
+  generateParameterName: (operationId: string) => string;
+  generateRequestBodyName: (operationId: string) => string;
+  generateFunctionName: (operationId: string) => string;
+}
diff --git a/src/internal/OpenApiTools/types/tmp.ts b/src/internal/OpenApiTools/types/tmp.ts
new file mode 100644
index 00000000..3b6d2235
--- /dev/null
+++ b/src/internal/OpenApiTools/types/tmp.ts
@@ -0,0 +1,32 @@
+// import type { OpenApi } from "../../../types";
+// import type { AbstractStruct } from "../../../types";
+// import * as Reference from "../components2/Reference";
+// import { ConverterContext } from "./context";
+
+// export interface Option {
+//   parent?: any;
+// }
+
+// // export interface ResolveReferencePath {
+// //   name: string;
+// //   maybeResolvedName: string;
+// //   unresolvedPaths: string[];
+// // }
+
+// // export type Convert = (
+// //   payload: Payload,
+// //   schema: OpenApi.Schema | OpenApi.Reference | OpenApi.JSONSchemaDefinition,
+// //   option?: Option,
+// // ) => AbstractStruct.SchemaLocation;
+
+// // export interface Context {
+// //   setReferenceHandler: (currentPoint: string, reference: Reference.Type<OpenApi.Schema | OpenApi.JSONSchemaDefinition>) => void;
+// //   resolveReferencePath: (currentPoint: string, referencePath: string) => ResolveReferencePath;
+// // }
+
+// // export interface Payload {
+// //   entryPoint: string;
+// //   currentPoint: string;
+// //   context: Context;
+// //   converterContext: ConverterContext;
+// // }
diff --git a/src/internal/TsGenerator/index.ts b/src/internal/TsGenerator/index.ts
index fd51620d..a93e1d2d 100644
--- a/src/internal/TsGenerator/index.ts
+++ b/src/internal/TsGenerator/index.ts
@@ -6,6 +6,8 @@ import { CreateFunction, traverse } from "./traverse";
 
 export * as Utils from "./utils";
 
+export const factory = Factory.create();
+
 export { CreateFunction, Factory };
 
 export type TransformerFactory<T extends ts.Node> = ts.TransformerFactory<T>;
diff --git a/src/reference-resolver/PrimitiveTypeGuard.ts b/src/reference-resolver/PrimitiveTypeGuard.ts
new file mode 100644
index 00000000..670f1d24
--- /dev/null
+++ b/src/reference-resolver/PrimitiveTypeGuard.ts
@@ -0,0 +1,7 @@
+export const isObject = (value: any): value is Record<string, any> => {
+  return !!value && value !== null && !Array.isArray(value) && typeof value === "object";
+};
+
+export const isArray = (value: any): value is any[] => {
+  return !!value && Array.isArray(value);
+};
diff --git a/src/reference-resolver/index.ts b/src/reference-resolver/index.ts
new file mode 100644
index 00000000..feaa760a
--- /dev/null
+++ b/src/reference-resolver/index.ts
@@ -0,0 +1,110 @@
+import * as fs from "fs";
+
+import DotProp from "dot-prop";
+
+import { OpenApiTools } from "../api";
+import { OpenApi } from "../types";
+import { ReferencePath } from "../utils";
+import * as PrimitiveTypeGuard from "./PrimitiveTypeGuard";
+
+export type ResolvedReference = Record<string, any>;
+
+export interface Infra {
+  loadJsonOrYaml: (entryPoint: string) => any;
+}
+
+export class Resolver {
+  private resolvedLocalReferenceState: ResolvedReference = {};
+  private resolvedRemoteReferenceState: ResolvedReference = {};
+  private document: OpenApi.Document | undefined;
+  constructor(private readonly entryPoint: string, private infra: Infra) {}
+  public async init(): Promise<void> {
+    this.document = this.infra.loadJsonOrYaml(this.entryPoint);
+    await this.resolveReference();
+  }
+
+  private async resolveReference(): Promise<void> {
+    if (!this.document) {
+      return;
+    }
+    await this.resolveValue(this.entryPoint, this.document, "OpenApiSchema");
+    fs.writeFileSync("debug/resolved-local-reference-schema.json", JSON.stringify(this.resolvedLocalReferenceState, null, 2), {
+      encoding: "utf-8",
+    });
+    fs.writeFileSync("debug/resolved-remote-reference-schema.json", JSON.stringify(this.resolvedRemoteReferenceState, null, 2), {
+      encoding: "utf-8",
+    });
+  }
+
+  private isLocalReference($ref: string): boolean {
+    return $ref.startsWith("#");
+  }
+
+  private async resolveValue(currentPoint: string, value: any, parentKey?: string): Promise<any> {
+    if (OpenApiTools.Guard.isReference(value)) {
+      if (this.isLocalReference(value.$ref)) {
+        return this.resolveLocalReference(currentPoint, value, parentKey);
+      } else {
+        return this.resolveRemoteReference(currentPoint, value, parentKey);
+      }
+    } else if (PrimitiveTypeGuard.isArray(value)) {
+      return value.map((item, idx) => this.resolveValue(currentPoint, item, [parentKey, idx].join(".")));
+    } else if (PrimitiveTypeGuard.isObject(value)) {
+      Object.entries(value).forEach(async ([k, v]) => {
+        value[k] = await this.resolveValue(currentPoint, v, [parentKey, k].join("."));
+      });
+    }
+    return value;
+  }
+
+  private async resolveLocalReference(currentPoint: string, obj: OpenApi.Reference, parentKey?: string): Promise<any> {
+    if (!this.document) {
+      throw new Error(`Uninitialized Error`);
+    }
+    const localReference = ReferencePath.generateLocalReference(obj.$ref);
+    if (!localReference) {
+      throw new Error(`Not found local reference: ${obj.$ref}`);
+    }
+    const referencePoint = localReference.path;
+    const data = DotProp.get(this.document, referencePoint.replace(/\//g, "."));
+    const resolvedValue = await this.resolveValue(currentPoint, data);
+    this.resolvedLocalReferenceState[referencePoint] = resolvedValue;
+    return resolvedValue;
+  }
+
+  private async resolveRemoteReference(currentPoint: string, obj: OpenApi.Reference, parentKey?: string): Promise<any> {
+    if (obj.$ref.startsWith("http")) {
+      throw new Error("これから");
+    } else {
+      const referencePoint = ReferencePath.generateReferencePoint(currentPoint, obj.$ref);
+      const data = this.infra.loadJsonOrYaml(referencePoint);
+      const resolvedValue = await this.resolveValue(referencePoint, data);
+      this.resolvedRemoteReferenceState[referencePoint] = resolvedValue;
+      return resolvedValue;
+    }
+  }
+
+  private findSchema(currentPoint: string, $ref: string) {
+    if (this.isLocalReference($ref)) {
+      const searchPoint = ReferencePath.normalizeLocalReferencePoint($ref);
+      return this.resolvedLocalReferenceState[searchPoint];
+    } else {
+      const searchPoint = ReferencePath.normalizeRemoteReferencePoint(currentPoint, $ref);
+      return this.resolvedRemoteReferenceState[searchPoint];
+    }
+  }
+
+  public getSchema(currentPoint: string, $ref: string) {
+    const result = this.findSchema(currentPoint, $ref);
+    if (!result) {
+      console.log({
+        currentPoint,
+        $ref,
+        localSearchPoint: ReferencePath.normalizeLocalReferencePoint($ref),
+        remoteSearchPoint: ReferencePath.normalizeRemoteReferencePoint(currentPoint, $ref),
+      });
+      throw new Error("Not found schema");
+    }
+    return result;
+  }
+}
diff --git a/src/templates.ts b/src/templates.ts
index 65c4447e..ec4d56ca 100644
--- a/src/templates.ts
+++ b/src/templates.ts
@@ -1 +1,2 @@
 export * as ApiClient from "./code-templates/api-client";
+export * as TypeDef from "./code-templates/typedef";
diff --git a/src/typedef/AbstractStruct.ts b/src/typedef/AbstractStruct.ts
new file mode 100644
index 00000000..7b1209af
--- /dev/null
+++ b/src/typedef/AbstractStruct.ts
@@ -0,0 +1,29 @@
+import type * as OpenApi from "./OpenApi";
+
+export interface LocalReferenceSchemaLocation {
+  kind: "local-reference";
+  schema: OpenApi.Reference;
+  currentPoint: string;
+}
+
+export interface RemoteReferenceSchema {
+  kind: "remote-reference";
+  schema: OpenApi.Reference;
+  currentPoint: string;
+}
+/**
+ * 
+ * Schemas:
+ *   Hoge:             // name
+ *     type: object    // schema
+ *     properties:
+ *       key1:
+ *         type: string
+ */
+export interface NamedSchemaLocation {
+  kind: "common";
+  name: string;
+  schema: OpenApi.Schema | OpenApi.JSONSchema | boolean;
+}
+
+export type SchemaLocation = NamedSchemaLocation | LocalReferenceSchemaLocation | RemoteReferenceSchema;
diff --git a/src/typedef/CodeGenerator.ts b/src/typedef/CodeGenerator.ts
index 866182c3..f294c0c3 100644
--- a/src/typedef/CodeGenerator.ts
+++ b/src/typedef/CodeGenerator.ts
@@ -1,6 +1,8 @@
 import type ts from "typescript";
 
 import type * as OpenApi from "./OpenApi";
+import type * as ParsedSchema from "./ParsedSchema";
+import type { Resolver } from "../reference-resolver";
 
 export type PickedParameter = Pick<OpenApi.Parameter, "name" | "in" | "required" | "style" | "explode">;
 
@@ -58,6 +60,14 @@ export interface Params {
  */
 export type IntermediateCode = string | ts.Statement;
 
+export interface GeneratorPayload {
+  accessor: ParsedSchema.Accessor;
+  resolver: Resolver;
+  entryPoint: string;
+}
+
+export type AdvancedGenerateFunction<Option = {}> = (payload: GeneratorPayload, option?: Option) => IntermediateCode[];
+
 export type GenerateFunction<Option = {}> = (payload: Params[], option?: Option) => IntermediateCode[];
 
 export interface OutputConfiguration {
@@ -67,7 +77,16 @@ export interface OutputConfiguration {
   transform?: (params: IntermediateCode) => IntermediateCode[];
 }
 
-export interface CustomGenerator<T> {
+export interface AdvancedCustomGenerator<T> {
+  kind: "advanced";
+  generator: AdvancedGenerateFunction<T>;
+  option?: T;
+}
+
+export interface BasicCustomGenerator<T> {
+  kind?: "basic";
   generator: GenerateFunction<T>;
   option?: T;
 }
+
+export type CustomGenerator<T> = BasicCustomGenerator<T> | AdvancedCustomGenerator<T>;
diff --git a/src/typedef/ParsedSchema.ts b/src/typedef/ParsedSchema.ts
new file mode 100644
index 00000000..4e8cf85d
--- /dev/null
+++ b/src/typedef/ParsedSchema.ts
@@ -0,0 +1,8 @@
+import type * as PathOrientedDataStructure from "@himenon/path-oriented-data-structure";
+
+import type * as Walker from "../internal/OpenApiTools/Walker2";
+
+export interface Accessor {
+  operator: PathOrientedDataStructure.Operator<Walker.Structure.Directory.Kind>;
+  getChildByPaths: Walker.Structure.GetChildByPaths;
+}
diff --git a/src/types.ts b/src/types.ts
index 3e7650d1..d9e20fcc 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -2,3 +2,5 @@ export * as CodeGenerator from "./typedef/CodeGenerator";
 export * as OpenApi from "./typedef/OpenApi";
 export * as OpenApiSchemaParser from "./typedef/OpenApiSchemaParser";
 export * as Validator from "./typedef/Validator";
+export * as ParsedSchema from "./typedef/ParsedSchema";
+export * as AbstractStruct from "./typedef/AbstractStruct";
diff --git a/src/utility/ConvertContext.ts b/src/utility/ConvertContext.ts
new file mode 100644
index 00000000..426d15da
--- /dev/null
+++ b/src/utility/ConvertContext.ts
@@ -0,0 +1,58 @@
+import { posix as path } from "path";
+
+import { ParsedSchema } from "../types";
+
+export interface ReferencePathSet {
+  pathArray: string[];
+  base: string;
+}
+
+export interface ResolveReferencePath {
+  name: string;
+  maybeResolvedName: string;
+  unresolvedPaths: string[];
+}
+
+export class ConvertContext {
+  constructor(private accessor: ParsedSchema.Accessor, private entryPoint: string) {}
+
+  private generatePath(currentPoint: string, referencePath: string): ReferencePathSet {
+    const ext = path.extname(currentPoint); // .yml
+    const from = path.relative(path.dirname(this.entryPoint), currentPoint).replace(ext, ""); // components/schemas/A/B
+    const dirname = path.dirname(from).replace(path.sep, "/");
+    const result = path.relative(dirname, referencePath); // remoteの場合? localの場合 referencePath.split("/")
+    const pathArray = result.split("/");
+    return {
+      pathArray,
+      base: dirname,
+    };
+  }
+
+  private calculateReferencePath(base: string, pathArray: string[]): ResolveReferencePath {
+    let names: string[] = [];
+    let unresolvedPaths: string[] = [];
+    pathArray.reduce((previous, lastPath, index) => {
+      const current = path.join(previous, lastPath);
+      // ディレクトリが深い場合は相対パスが`..`を繰り返す可能性があり、
+      // その場合はすでに登録されたnamesを削除する
+      if (lastPath === ".." && names.length > 0) {
+        names = names.slice(0, names.length - 1);
+      }
+      const isFinalPath = index === pathArray.length - 1;
+      return current;
+    }, base);
+    if (names.length === 0) {
+      throw new Error("Local Reference Error \n" + JSON.stringify({ pathArray, names, base }, null, 2));
+    }
+    return {
+      name: names.join("."),
+      maybeResolvedName: names.concat(unresolvedPaths).join("."),
+      unresolvedPaths,
+    };
+  }
+
+  public resolveReferencePath(currentPoint: string, referencePath: string) {
+    const { pathArray, base } = this.generatePath(currentPoint, referencePath);
+    return this.calculateReferencePath(base, pathArray);
+  }
+}
diff --git a/src/utility/JsonSchemaToTypeDefinition.ts b/src/utility/JsonSchemaToTypeDefinition.ts
new file mode 100644
index 00000000..4e0582e9
--- /dev/null
+++ b/src/utility/JsonSchemaToTypeDefinition.ts
@@ -0,0 +1,178 @@
+import ts from "typescript";
+
+import { TsGenerator } from "../api";
+import type { OpenApi } from "../types";
+import { OpenApiType } from "../utils";
+
+const factory = TsGenerator.factory;
+
+export class Converter {
+  public generateMultiTypeNode(schemas: OpenApi.JSONSchema[], multiType: "oneOf" | "allOf" | "anyOf"): ts.TypeNode {
+    const typeNodes = schemas.map(schema => this.generateTypeNode(schema));
+    if (multiType === "oneOf") {
+      return factory.UnionTypeNode.create({
+        typeNodes,
+      });
+    }
+    if (multiType === "allOf") {
+      return factory.IntersectionTypeNode.create({
+        typeNodes,
+      });
+    }
+    // TODO Feature Development: Calculate intersection types
+    return factory.TypeNode.create({ type: "never" });
+  }
+
+  public generateTypeNode(schema: OpenApi.Schema | OpenApi.Reference | OpenApi.JSONSchemaDefinition): ts.TypeNode {
+    if (typeof schema === "boolean") {
+      // https://swagger.io/docs/specification/data-models/dictionaries/#free-form
+      return factory.TypeNode.create({
+        type: "object",
+        value: [],
+      });
+    }
+    if (OpenApiType.Guard.isReference(schema)) {
+      return factory.TypeNode.create({
+        type: "any",
+      });
+    }
+
+    if (OpenApiType.Guard.isOneOfSchema(schema)) {
+      return this.generateMultiTypeNode(schema.oneOf, "oneOf");
+    }
+    if (OpenApiType.Guard.isAllOfSchema(schema)) {
+      return this.generateMultiTypeNode(schema.allOf, "allOf");
+    }
+    if (OpenApiType.Guard.isAnyOfSchema(schema)) {
+      return this.generateMultiTypeNode(schema.anyOf, "anyOf");
+    }
+    if (OpenApiType.Guard.isHasNoMembersObject(schema)) {
+      return factory.TypeNode.create({
+        type: "object",
+        value: [],
+      });
+    }
+    return this.convertTypeNodeBySchemaType(schema);
+  }
+
+  // private convertTypeNodeByReference(schema: OpenApi.Reference): ts.TypeNode {
+  //   const reference = Reference.generate<OpenApi.Schema | OpenApi.JSONSchemaDefinition>(entryPoint, currentPoint, schema);
+  // }
+
+  /**
+   * schema.typeを利用してTypeNodeへ変換する
+   */
+  private convertTypeNodeBySchemaType(schema: OpenApi.Schema | OpenApi.JSONSchema): ts.TypeNode {
+    switch (schema.type) {
+      case "boolean": {
+        const typeNode = factory.TypeNode.create({
+          type: "boolean",
+        });
+        return this.nullable(typeNode, !!schema.nullable);
+      }
+      case "null": {
+        return factory.TypeNode.create({
+          type: schema.type,
+        });
+      }
+      case "integer":
+      case "number": {
+        const items = schema.enum;
+        let typeNode: ts.TypeNode;
+        if (items && OpenApiType.Guard.isNumberArray(items)) {
+          typeNode = factory.TypeNode.create({
+            type: schema.type,
+            enum: items,
+          });
+        } else {
+          typeNode = factory.TypeNode.create({
+            type: schema.type,
+          });
+        }
+        return this.nullable(typeNode, !!schema.nullable);
+      }
+      case "string": {
+        const items = schema.enum;
+        let typeNode: ts.TypeNode;
+        if (items && OpenApiType.Guard.isStringArray(items)) {
+          typeNode = factory.TypeNode.create({
+            type: schema.type,
+            enum: items,
+          });
+        } else {
+          typeNode = factory.TypeNode.create({
+            type: schema.type,
+          });
+        }
+        return this.nullable(typeNode, !!schema.nullable);
+      }
+      case "array": {
+        if (Array.isArray(schema.items) || typeof schema.items === "boolean") {
+          throw new Error(`schema.items = ${JSON.stringify(schema.items)}`);
+        }
+        const typeNode = factory.TypeNode.create({
+          type: schema.type,
+          value: schema.items
+            ? this.generateTypeNode(schema.items)
+            : factory.TypeNode.create({
+                type: "undefined",
+              }),
+        });
+        return this.nullable(typeNode, !!schema.nullable);
+      }
+      case "object": {
+        const required: string[] = schema.required || [];
+        // // https://swagger.io/docs/specification/data-models/dictionaries/#free-form
+        if (schema.additionalProperties === true) {
+          return factory.TypeNode.create({
+            type: schema.type,
+            value: [],
+          });
+        }
+        const value: ts.PropertySignature[] = Object.entries(schema.properties || {}).map(([name, jsonSchema]) => {
+          return factory.PropertySignature.create({
+            // TODO nameの正規化
+            name: name,
+            type: this.generateTypeNode(jsonSchema),
+            optional: !required.includes(name),
+            comment: (typeof jsonSchema !== "boolean" ? jsonSchema.description : undefined),
+          });
+        });
+        if (schema.additionalProperties) {
+          const additionalProperties = factory.IndexSignatureDeclaration.create({
+            name: "key",
+            type: this.generateTypeNode(schema.additionalProperties),
+          });
+          return factory.TypeNode.create({
+            type: schema.type,
+            value: [...value, additionalProperties],
+          });
+        }
+        const typeNode = factory.TypeNode.create({
+          type: schema.type,
+          value,
+        });
+        return this.nullable(typeNode, !!schema.nullable);
+      }
+      default:
+        break;
+    }
+    return factory.TypeNode.create({
+      type: "any",
+    });
+  }
+
+  private nullable = (typeNode: ts.TypeNode, nullable: boolean): ts.TypeNode => {
+    if (nullable) {
+      return factory.UnionTypeNode.create({
+        typeNodes: [
+          typeNode,
+          factory.TypeNode.create({
+            type: "null",
+          }),
+        ],
+      });
+    }
+    return typeNode;
+  };
+}
diff --git a/src/utility/LevelName.ts b/src/utility/LevelName.ts
new file mode 100644
index 00000000..ad08543b
--- /dev/null
+++ b/src/utility/LevelName.ts
@@ -0,0 +1,57 @@
+import { posix as path } from "path";
+
+type Component =
+  | "schemas"
+  | "responses"
+  | "parameters"
+  | "examples"
+  | "requestBodies"
+  | "headers"
+  | "securitySchemes"
+  | "links"
+  | "callbacks"
+  | "pathItems";
+
+const componentMap: Record<string, Component> = {
+  "components/schemas": "schemas",
+  "components/responses": "responses",
+  "components/parameters": "parameters",
+  "components/examples": "examples",
+  "components/requestBodies": "requestBodies",
+  "components/headers": "headers",
+  "components/securitySchemes": "securitySchemes",
+  "components/links": "links",
+  "components/callbacks": "callbacks",
+  "components/pathItems": "pathItems",
+};
+
+const detectBaseComponent = (p: string): Component | undefined => {
+  const key = path.normalize(p).split("/").slice(0, 2).join("/");
+  return componentMap[key];
+};
+
+const generateAbsoluteName = (point: string): string => {
+  const pointArray = point.split("/");
+  const newPointArray = pointArray.slice(1).map((text, idx) => {
+    if (idx === 0) {
+      return text.charAt(0).toUpperCase() + text.slice(1);
+    }
+    return text;
+  });
+  return newPointArray.join(".");
+}
+
+const generateRelativeName = (point: string): string => {
+  return point.split("/").join(".");
+}
+
+export const makeAliasName = (entryPoint: string, currentPoint: string, referencePoint: string): string => {
+  const relativeCurrentPoint = path.relative(path.dirname(entryPoint), currentPoint);
+  const isSameBaseComponent = detectBaseComponent(relativeCurrentPoint) === detectBaseComponent(referencePoint);
+  if (isSameBaseComponent) {
+    const relativePoint = path.relative(path.dirname(relativeCurrentPoint), referencePoint);
+    return generateRelativeName(relativePoint);
+  }
+ 
+  return generateAbsoluteName(referencePoint);
+};
diff --git a/src/utility/NamedContext.ts b/src/utility/NamedContext.ts
new file mode 100644
index 00000000..1b3dc43a
--- /dev/null
+++ b/src/utility/NamedContext.ts
@@ -0,0 +1,47 @@
+export interface NamedContext {
+  parameterName(operationId: string): string;
+  requestBodyName(operationId: string): string;
+  argumentParamsTypeDeclaration(operationId: string): string;
+  responseName(operationId: string, statusCode: string): string;
+  requestContentType(operationId: string): string;
+  responseContentType(operationId: string): string;
+  isAvailableVariableName(text: string): boolean;
+  escapeText(text: string): string;
+}
+
+export class NamedContext implements NamedContext {
+  public static parameterName(operationId: string): string {
+    return `Parameter$${operationId}`;
+  }
+
+  public static requestBodyName(operationId: string): string {
+    return `RequestBody$${operationId}`;
+  }
+
+  public static argumentParamsTypeDeclaration(operationId: string): string {
+    return `Params$${operationId}`;
+  }
+
+  public static responseName(operationId: string, statusCode: string): string {
+    return `Response$${operationId}$Status$${statusCode}`;
+  }
+
+  public static requestContentType(operationId: string): string {
+    return `RequestContentType$${operationId}`;
+  }
+
+  public static responseContentType(operationId: string): string {
+    return `ResponseContentType$${operationId}`;
+  }
+
+  public static isAvailableVariableName(text: string): boolean {
+    return /^[A-Za-z_0-9\s]+$/.test(text);
+  }
+
+  public static escapeText(text: string): string {
+    if (this.isAvailableVariableName(text)) {
+      return text;
+    }
+    return `"${text}"`;
+  }
+}
diff --git a/src/utility/OpenApiType/Guard.ts b/src/utility/OpenApiType/Guard.ts
new file mode 100644
index 00000000..e49089ab
--- /dev/null
+++ b/src/utility/OpenApiType/Guard.ts
@@ -0,0 +1,62 @@
+import type { OpenApi } from "../../types";
+import * as Types from "./types";
+
+export const isReference = (data: any): data is OpenApi.Reference => {
+  if (typeof data !== "object" || data === null) {
+    return false;
+  }
+  return typeof data.$ref === "string";
+};
+
+export const isUnSupportSchema = (schema: OpenApi.Schema): schema is Types.UnSupportSchema => {
+  return Array.isArray(schema.type);
+};
+
+export const isObjectSchema = (schema: OpenApi.Schema): schema is Types.ObjectSchema => {
+  return schema.type === "object";
+};
+
+export const isHasNoMembersObject = (schema: OpenApi.Schema): boolean => {
+  return Object.keys(schema).length === 0;
+};
+
+export const isArraySchema = (schema: OpenApi.Schema): schema is Types.ArraySchema => {
+  return schema.type === "array";
+};
+
+export const isPrimitiveSchema = (schema: OpenApi.Schema): schema is Types.PrimitiveSchema => {
+  if (typeof schema.type !== "string") {
+    return false;
+  }
+  if (schema.type === "object") {
+    return false;
+  }
+  if (schema.type === "array") {
+    return false;
+  }
+  return true;
+};
+
+export const isNumberArray = (list: any[]): list is number[] => {
+  return !list.some(item => typeof item !== "number");
+};
+
+export const isStringArray = (list: any[]): list is string[] => {
+  return !list.some(item => typeof item !== "string");
+};
+
+export const isObjectSchemaWithAdditionalProperties = (schema: Types.ObjectSchema): schema is Types.ObjectSchemaWithAdditionalProperties => {
+  return !!schema.additionalProperties;
+};
+
+export const isOneOfSchema = (schema: OpenApi.Schema): schema is Types.OneOfSchema => {
+  return !!schema.oneOf && typeof schema.oneOf !== "boolean" && Array.isArray(schema.oneOf);
+};
+
+export const isAllOfSchema = (schema: OpenApi.Schema): schema is Types.AllOfSchema => {
+  return !!schema.allOf && typeof schema.allOf !== "boolean" && Array.isArray(schema.allOf);
+};
+
+export const isAnyOfSchema = (schema: OpenApi.Schema): schema is Types.AnyOfSchema => {
+  return !!schema.anyOf && typeof schema.anyOf !== "boolean" && Array.isArray(schema.anyOf);
+};
diff --git a/src/utility/OpenApiType/index.ts b/src/utility/OpenApiType/index.ts
new file mode 100644
index 00000000..1cdc82db
--- /dev/null
+++ b/src/utility/OpenApiType/index.ts
@@ -0,0 +1 @@
+export * as Guard from "./Guard";
diff --git a/src/utility/OpenApiType/types.ts b/src/utility/OpenApiType/types.ts
new file mode 100644
index 00000000..aa38426c
--- /dev/null
+++ b/src/utility/OpenApiType/types.ts
@@ -0,0 +1,33 @@
+import type { OpenApi } from "../../types";
+
+export interface UnSupportSchema extends Omit<OpenApi.Schema, "type"> {
+  type: OpenApi.JSONSchemaTypeName[];
+}
+
+export interface OneOfSchema extends Omit<OpenApi.Schema, "oneOf"> {
+  oneOf: OpenApi.JSONSchema[];
+}
+
+export interface AllOfSchema extends Omit<OpenApi.Schema, "allOf"> {
+  allOf: OpenApi.JSONSchema[];
+}
+
+export interface AnyOfSchema extends Omit<OpenApi.Schema, "anyOf"> {
+  anyOf: OpenApi.JSONSchema[];
+}
+
+export interface ObjectSchema extends Omit<OpenApi.Schema, "type"> {
+  type: "object";
+}
+
+export interface ObjectSchemaWithAdditionalProperties extends ObjectSchema {
+  additionalProperties: OpenApi.JSONSchemaDefinition;
+}
+
+export interface ArraySchema extends Omit<OpenApi.Schema, "type"> {
+  type: "array";
+}
+
+export interface PrimitiveSchema extends Omit<OpenApi.Schema, "type"> {
+  type: "string" | "number" | "integer" | "boolean" | "null";
+}
diff --git a/src/utility/ReferencePath.ts b/src/utility/ReferencePath.ts
new file mode 100644
index 00000000..f94ddc9c
--- /dev/null
+++ b/src/utility/ReferencePath.ts
@@ -0,0 +1,116 @@
+import { posix as path } from "path";
+
+export type LocalReferencePattern =
+  | "#/components/schemas/"
+  | "#/components/responses/"
+  | "#/components/parameters/"
+  | "#/components/examples/"
+  | "#/components/requestBodies/"
+  | "#/components/headers/"
+  | "#/components/securitySchemes/"
+  | "#/components/links/"
+  | "#/components/callbacks/"
+  | "#/components/pathItems/";
+
+export interface LocalReference {
+  type: "local";
+  /**
+   * @example #/components/schemas/Hoge -> Hoge
+   */
+  name: string;
+  /**
+   * startsWith `components`
+   * components/headers/hoge/fuga
+   */
+  path: string;
+}
+
+export interface RemoteReference {
+  type: "remote";
+  /**
+   * file path
+   */
+  referencePoint: string;
+  /**
+   * startsWith `components`
+   * components/headers/hoge/fuga
+   */
+  path: string;
+  /**
+   * From filename - extension
+   * @example a/b/c/Hoge.yml -> Hoge
+   */
+  name: string;
+  /**
+   * If "componentName" exists, you can create an alias for the type.
+   * If it does not exist, you need to define the type directly.
+   */
+  componentName?: "schemas" | "headers" | "responses" | "parameters" | "requestBodies" | "securitySchemes" | "pathItems";
+}
+
+const localReferencePatterns: LocalReferencePattern[] = [
+  "#/components/schemas/",
+  "#/components/responses/",
+  "#/components/parameters/",
+  "#/components/examples/",
+  "#/components/requestBodies/",
+  "#/components/headers/",
+  "#/components/securitySchemes/",
+  "#/components/links/",
+  "#/components/callbacks/",
+  "#/components/pathItems/",
+];
+
+const localRefMap = {
+  "#/components/schemas/": "components/schemas",
+  "#/components/responses/": "components/responses",
+  "#/components/parameters/": "components/parameters",
+  "#/components/examples/": "components/examples",
+  "#/components/requestBodies/": "components/requestBodies",
+  "#/components/headers/": "components/headers",
+  "#/components/securitySchemes/": "components/securitySchemes",
+  "#/components/links/": "components/links",
+  "#/components/callbacks/": "components/callbacks",
+  "#/components/pathItems/": "components/pathItems",
+} as const;
+
+const getLocalReference = (ref: string): LocalReferencePattern | undefined => {
+  let localReferencePattern: LocalReferencePattern | undefined;
+  localReferencePatterns.forEach(referencePattern => {
+    if (new RegExp("^" + referencePattern).test(ref)) {
+      localReferencePattern = referencePattern;
+    }
+  });
+  return localReferencePattern;
+};
+
+export const generateLocalReference = (ref: string): LocalReference | undefined => {
+  const localReferencePattern = getLocalReference(ref);
+  if (!localReferencePattern) {
+    return;
+  }
+  const name = ref.split(localReferencePattern)[1];
+  const localPath = path.join(localRefMap[localReferencePattern], name);
+  if (!localPath.startsWith("components")) {
+    throw new Error(`LocalPath is not start "components":\n${localPath}`);
+  }
+  return {
+    type: "local",
+    name: name,
+    path: localPath,
+  };
+};
+
+export const generateReferencePoint = (currentPoint: string, ref: string): string => {
+  const basedir = path.dirname(currentPoint);
+  const referencePoint = path.join(basedir, ref);
+  return referencePoint;
+};
+
+export const normalizeLocalReferencePoint = (referencePoint: string): string => {
+  return path.relative("#", referencePoint);
+};
+
+export const normalizeRemoteReferencePoint = (currentPoint: string, referencePoint: string): string => {
+  return path.join(path.dirname(currentPoint), referencePoint);
+};
diff --git a/src/utility/TextContext.ts b/src/utility/TextContext.ts
new file mode 100644
index 00000000..00008645
--- /dev/null
+++ b/src/utility/TextContext.ts
@@ -0,0 +1,63 @@
+import type { NamedContext } from "./NamedContext";
+
+export class TextContext {
+  constructor(private namedContext: NamedContext) {}
+  public convertReservedWord(word: string): string {
+    if (["import", "export"].includes(word)) {
+      return word + "_";
+    }
+    return word;
+  }
+  public convertString(text: string): string {
+    if (this.namedContext.isAvailableVariableName(text)) {
+      return text;
+    }
+    return text.replace(/-/g, "$").replace(/\//g, "$");
+  }
+  /**
+   * operationIdに対するescape
+   */
+  public escapeOperationIdText(operationId: string): string {
+    return this.convertString(operationId);
+  }
+  /**
+   * interface/namespace/typeAliasのnameをescapeする
+   * import/exportなどの予約語も裁く
+   */
+  public escapeDeclarationText(text: string): string {
+    return this.convertReservedWord(this.convertString(text));
+  }
+  /**
+   * 非破壊: PropertySignatureのname用のescape
+   */
+  public escapePropertySignatureName(text: string): string {
+    return this.namedContext.escapeText(text);
+  }
+  /**
+   * 破壊: TypeReferenceのname用のescape
+   */
+  public escapeTypeReferenceNodeName(text: string): string {
+    return this.convertString(text);
+  }
+  public generateResponseName(operationId: string, statusCode: string): string {
+    return this.namedContext.responseName(this.convertString(operationId), statusCode);
+  }
+  public generateArgumentParamsTypeDeclaration(operationId: string): string {
+    return this.namedContext.argumentParamsTypeDeclaration(this.convertString(operationId));
+  }
+  public generateRequestContentTypeName(operationId: string): string {
+    return this.namedContext.requestContentType(this.convertString(operationId));
+  }
+  public generateResponseContentTypeName(operationId: string): string {
+    return this.namedContext.responseContentType(this.convertString(operationId));
+  }
+  public generateParameterName(operationId: string): string {
+    return this.namedContext.parameterName(this.convertString(operationId));
+  }
+  public generateRequestBodyName(operationId: string): string {
+    return this.namedContext.requestBodyName(this.convertString(operationId));
+  }
+  public generateFunctionName(operationId: string): string {
+    return this.convertString(operationId);
+  }
+}
diff --git a/src/utility/__tests__/LevelName-test.ts b/src/utility/__tests__/LevelName-test.ts
new file mode 100644
index 00000000..acbf1ea7
--- /dev/null
+++ b/src/utility/__tests__/LevelName-test.ts
@@ -0,0 +1,234 @@
+import * as LevelName from "../LevelName";
+
+interface TestData {
+  currentPoint: string;
+  referencePoint: string;
+  expectResult: string;
+}
+
+const list: TestData[] = [
+  {
+    currentPoint: "test/api.test.domain/index.yml",
+    referencePoint: "components/schemas/StringType",
+    expectResult: "Schemas.StringType",
+  },
+  {
+    currentPoint: "test/api.test.domain/index.yml",
+    referencePoint: "components/schemas/NumberType",
+    expectResult: "Schemas.NumberType",
+  },
+  {
+    currentPoint: "test/api.test.domain/index.yml",
+    referencePoint: "components/schemas/BooleanType",
+    expectResult: "Schemas.BooleanType",
+  },
+  {
+    currentPoint: "test/api.test.domain/index.yml",
+    referencePoint: "components/schemas/BooleanType",
+    expectResult: "Schemas.BooleanType",
+  },
+  {
+    currentPoint: "test/api.test.domain/index.yml",
+    referencePoint: "components/schemas/ObjectHasPropertiesType",
+    expectResult: "Schemas.ObjectHasPropertiesType",
+  },
+  {
+    currentPoint: "test/api.test.domain/index.yml",
+    referencePoint: "components/schemas/StringType",
+    expectResult: "Schemas.StringType",
+  },
+  {
+    currentPoint: "test/api.test.domain/index.yml",
+    referencePoint: "components/schemas/NumberType",
+    expectResult: "Schemas.NumberType",
+  },
+  {
+    currentPoint: "test/api.test.domain/index.yml",
+    referencePoint: "components/schemas/BooleanType",
+    expectResult: "Schemas.BooleanType",
+  },
+  {
+    currentPoint: "test/api.test.domain/index.yml",
+    referencePoint: "components/schemas/BooleanType",
+    expectResult: "Schemas.BooleanType",
+  },
+  {
+    currentPoint: "test/api.test.domain/index.yml",
+    referencePoint: "components/schemas/ObjectHasPropertiesType",
+    expectResult: "Schemas.ObjectHasPropertiesType",
+  },
+  {
+    currentPoint: "test/api.test.domain/index.yml",
+    referencePoint: "components/schemas/StringType",
+    expectResult: "Schemas.StringType",
+  },
+  {
+    currentPoint: "test/api.test.domain/index.yml",
+    referencePoint: "components/schemas/NumberType",
+    expectResult: "Schemas.NumberType",
+  },
+  {
+    currentPoint: "test/api.test.domain/index.yml",
+    referencePoint: "components/schemas/ObjectHasPropertiesType",
+    expectResult: "Schemas.ObjectHasPropertiesType",
+  },
+  {
+    currentPoint: "test/api.test.domain/index.yml",
+    referencePoint: "components/schemas/LocalRefObjectProperties",
+    expectResult: "Schemas.LocalRefObjectProperties",
+  },
+  {
+    currentPoint: "test/api.test.domain/index.yml",
+    referencePoint: "components/schemas/StringType",
+    expectResult: "Schemas.StringType",
+  },
+  {
+    currentPoint: "test/api.test.domain/index.yml",
+    referencePoint: "components/schemas/NumberType",
+    expectResult: "Schemas.NumberType",
+  },
+  {
+    currentPoint: "test/api.test.domain/index.yml",
+    referencePoint: "components/schemas/ObjectHasPropertiesType",
+    expectResult: "Schemas.ObjectHasPropertiesType",
+  },
+  {
+    currentPoint: "test/api.test.domain/index.yml",
+    referencePoint: "components/schemas/LocalRefObjectProperties",
+    expectResult: "Schemas.LocalRefObjectProperties",
+  },
+  {
+    currentPoint: "test/api.test.domain/index.yml",
+    referencePoint: "components/schemas/UnresolvedTarget1",
+    expectResult: "Schemas.UnresolvedTarget1",
+  },
+  {
+    currentPoint: "test/api.test.domain/index.yml",
+    referencePoint: "components/schemas/UnresolvedTarget2",
+    expectResult: "Schemas.UnresolvedTarget2",
+  },
+  {
+    currentPoint: "test/api.test.domain/index.yml",
+    referencePoint: "components/schemas/UnresolvedTarget3",
+    expectResult: "Schemas.UnresolvedTarget3",
+  },
+  {
+    currentPoint: "test/api.test.domain/index.yml",
+    referencePoint: "components/schemas/UnresolvedTarget4",
+    expectResult: "Schemas.UnresolvedTarget4",
+  },
+  {
+    currentPoint: "test/api.test.domain/index.yml",
+    referencePoint: "components/schemas/UnresolvedTarget5",
+    expectResult: "Schemas.UnresolvedTarget5",
+  },
+  {
+    currentPoint: "test/api.test.domain/index.yml",
+    referencePoint: "components/schemas/RemoteString",
+    expectResult: "Schemas.RemoteString",
+  },
+  {
+    currentPoint: "test/api.test.domain/index.yml",
+    referencePoint: "components/schemas/Level1/RemoteBoolean",
+    expectResult: "Schemas.Level1.RemoteBoolean",
+  },
+  {
+    currentPoint: "test/api.test.domain/index.yml",
+    referencePoint: "components/schemas/Level1/Level2/RemoteNumber",
+    expectResult: "Schemas.Level1.Level2.RemoteNumber",
+  },
+  {
+    currentPoint: "test/api.test.domain/index.yml",
+    referencePoint: "components/schemas/Level1/Level2/Level3/RemoteArray",
+    expectResult: "Schemas.Level1.Level2.Level3.RemoteArray",
+  },
+  {
+    currentPoint: "test/api.test.domain/index.yml",
+    referencePoint: "components/schemas/Level1/Level2/Level3/Level4/RemoteObject",
+    expectResult: "Schemas.Level1.Level2.Level3.Level4.RemoteObject",
+  },
+  {
+    currentPoint: "test/api.test.domain/index.yml",
+    referencePoint: "components/schemas/DirectRef/ForHeader",
+    expectResult: "Schemas.DirectRef.ForHeader",
+  },
+  {
+    currentPoint: "test/api.test.domain/index.yml",
+    referencePoint: "components/schemas/StringDateTimeType",
+    expectResult: "Schemas.StringDateTimeType",
+  },
+  {
+    currentPoint: "test/api.test.domain/index.yml",
+    referencePoint: "components/schemas/ObjectHasPropertiesType",
+    expectResult: "Schemas.ObjectHasPropertiesType",
+  },
+  {
+    currentPoint: "test/api.test.domain/index.yml",
+    referencePoint: "components/schemas/DirectRef/ForResponse",
+    expectResult: "Schemas.DirectRef.ForResponse",
+  },
+  {
+    currentPoint: "test/api.test.domain/components/responses/ResponseA.yml",
+    referencePoint: "components/headers/A",
+    expectResult: "Headers.A",
+  },
+  {
+    currentPoint: "test/api.test.domain/index.yml",
+    referencePoint: "components/parameters/A",
+    expectResult: "Parameters.A",
+  },
+  {
+    currentPoint: "test/api.test.domain/index.yml",
+    referencePoint: "components/parameters/level1/B",
+    expectResult: "Parameters.level1.B",
+  },
+  {
+    currentPoint: "test/api.test.domain/index.yml",
+    referencePoint: "components/schemas/DirectRef/ForParameters",
+    expectResult: "Schemas.DirectRef.ForParameters",
+  },
+  {
+    currentPoint: "test/api.test.domain/index.yml",
+    referencePoint: "components/schemas/StringHasEnumType",
+    expectResult: "Schemas.StringHasEnumType",
+  },
+  {
+    currentPoint: "test/api.test.domain/index.yml",
+    referencePoint: "components/schemas/DirectRef/ForRequestBody",
+    expectResult: "Schemas.DirectRef.ForRequestBody",
+  },
+  {
+    currentPoint: "test/api.test.domain/components/parameters/ForPathItems/FullRemoteReference.yml",
+    referencePoint: "components/schemas/FullRemoteReference/ForParameters",
+    expectResult: "Schemas.FullRemoteReference.ForParameters",
+  },
+  {
+    currentPoint: "testls /api.test.domain/components/responses/ForPathItems/FullRemoteReference.yml",
+    referencePoint: "components/headers/A",
+    expectResult: "Headers.A",
+  },
+  {
+    currentPoint: "test/api.test.domain/components/schemas/Item.yml",
+    referencePoint: "components/schemas/Child",
+    expectResult: "Child",
+  },
+  {
+    currentPoint: "test/api.test.domain/index.yml",
+    referencePoint: "components/schemas/Item",
+    expectResult: "Schemas.Item",
+  },
+  {
+    currentPoint: "test/api.test.domain/index.yml",
+    referencePoint: "components/schemas/ObjectHasPropertiesType",
+    expectResult: "Schemas.ObjectHasPropertiesType",
+  },
+];
+
+describe("Create Alias Name", () => {
+  test("LevelName", () => {
+    const entryPoint = "test/api.test.domain/index.yml";
+    list.forEach(item => {
+      expect(LevelName.makeAliasName(entryPoint, item.currentPoint, item.referencePoint)).toBe(item.expectResult);
+    });
+  });
+});
diff --git a/src/utility/__tests__/ReferencePath-test.ts b/src/utility/__tests__/ReferencePath-test.ts
new file mode 100644
index 00000000..dcbd1797
--- /dev/null
+++ b/src/utility/__tests__/ReferencePath-test.ts
@@ -0,0 +1,26 @@
+import * as ReferencePath from "../ReferencePath";
+
+describe("ReferencePath test", () => {
+  test("normalizeLocalReferencePoint", () => {
+    expect(ReferencePath.normalizeLocalReferencePoint("#/a/b/c")).toBe("a/b/c");
+  });
+  test("normalizeRemoteReferencePoint", () => {
+    expect(ReferencePath.normalizeRemoteReferencePoint("a.yml", "d.yml")).toBe("d.yml");
+    expect(ReferencePath.normalizeRemoteReferencePoint("a.yml", "./d.yml")).toBe("d.yml");
+    expect(ReferencePath.normalizeRemoteReferencePoint("./a.yml", "d.yml")).toBe("d.yml");
+    expect(ReferencePath.normalizeRemoteReferencePoint("./a.yml", "./d.yml")).toBe("d.yml");
+
+    expect(ReferencePath.normalizeRemoteReferencePoint("a/b.yml", "../d.yml")).toBe("d.yml");
+    expect(ReferencePath.normalizeRemoteReferencePoint("./a/b.yml", "../d.yml")).toBe("d.yml");
+
+    expect(ReferencePath.normalizeRemoteReferencePoint("a/b.yml", "d.yml")).toBe("a/d.yml");
+    expect(ReferencePath.normalizeRemoteReferencePoint("a/b.yml", "./d.yml")).toBe("a/d.yml");
+    expect(ReferencePath.normalizeRemoteReferencePoint("./a/b.yml", "d.yml")).toBe("a/d.yml");
+    expect(ReferencePath.normalizeRemoteReferencePoint("./a/b.yml", "./d.yml")).toBe("a/d.yml");
+
+    expect(ReferencePath.normalizeRemoteReferencePoint("a/b/c.yml", "./d.yml")).toBe("a/b/d.yml");
+    expect(ReferencePath.normalizeRemoteReferencePoint("a/b/c.yml", "./d.yml")).toBe("a/b/d.yml");
+    expect(ReferencePath.normalizeRemoteReferencePoint("a/b/c.yml", "./d.yml")).toBe("a/b/d.yml");
+    expect(ReferencePath.normalizeRemoteReferencePoint("a/b/c.yml", "./d.yml")).toBe("a/b/d.yml");
+  });
+});
diff --git a/src/utility/index.ts b/src/utility/index.ts
new file mode 100644
index 00000000..2ac54941
--- /dev/null
+++ b/src/utility/index.ts
@@ -0,0 +1,25 @@
+export * from "./ConvertContext";
+export * from "./NamedContext";
+export * as OpenApiType from "./OpenApiType";
+export * as ReferencePath from "./ReferencePath";
+
+export * as JsonSchemaToTypeDefinition from "./JsonSchemaToTypeDefinition";
+
+export const parameterName = (operationId: string): string => `Parameter$${operationId}`;
+export const requestBodyName = (operationId: string): string => `RequestBody$${operationId}`;
+export const argumentParamsTypeDeclaration = (operationId: string): string => `Params$${operationId}`;
+export const responseName = (operationId: string, statusCode: string): string => `Response$${operationId}$Status$${statusCode}`;
+export const requestContentType = (operationId: string): string => `RequestContentType$${operationId}`;
+export const responseContentType = (operationId: string): string => `ResponseContentType$${operationId}`;
+
+export const isAvailableVariableName = (text: string): boolean => {
+  return /^[A-Za-z_0-9\s]+$/.test(text);
+};
+
+export const escapeText = (text: string): string => {
+  if (isAvailableVariableName(text)) {
+    return text;
+  }
+  return `"${text}"`;
+};
+
diff --git a/src/utils.ts b/src/utils.ts
index 57483911..ab41b3d9 100644
--- a/src/utils.ts
+++ b/src/utils.ts
@@ -1,17 +1 @@
-export const parameterName = (operationId: string): string => `Parameter$${operationId}`;
-export const requestBodyName = (operationId: string): string => `RequestBody$${operationId}`;
-export const argumentParamsTypeDeclaration = (operationId: string): string => `Params$${operationId}`;
-export const responseName = (operationId: string, statusCode: string): string => `Response$${operationId}$Status$${statusCode}`;
-export const requestContentType = (operationId: string): string => `RequestContentType$${operationId}`;
-export const responseContentType = (operationId: string): string => `ResponseContentType$${operationId}`;
-
-export const isAvailableVariableName = (text: string): boolean => {
-  return /^[A-Za-z_0-9\s]+$/.test(text);
-};
-
-export const escapeText = (text: string): string => {
-  if (isAvailableVariableName(text)) {
-    return text;
-  }
-  return `"${text}"`;
-};
+export * from "./utility";
diff --git a/yarn.lock b/yarn.lock
index 36a15d78..a1a177ea 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -553,10 +553,10 @@
     minimatch "^3.0.4"
     strip-json-comments "^3.1.1"
 
-"@himenon/path-oriented-data-structure@0.1.3":
-  version "0.1.3"
-  resolved "https://registry.yarnpkg.com/@himenon/path-oriented-data-structure/-/path-oriented-data-structure-0.1.3.tgz#a9298afd0097e2f5e466a2f86318c887e82570ed"
-  integrity sha512-1QaIv/cFdpg5GkpG6pQgrYgDouRO7dzz3djiSKLgd2+GjqMG0TsVvUaAxtIo7Y6Hqdk/pL7u7U+cYf80ww9tcw==
+"@himenon/path-oriented-data-structure@0.2.1":
+  version "0.2.1"
+  resolved "https://registry.yarnpkg.com/@himenon/path-oriented-data-structure/-/path-oriented-data-structure-0.2.1.tgz#abf7df54dd1436942c7851881dd55e2a78d87747"
+  integrity sha512-TbrbcmJW/E60xA5GPZAf9pBDDUYGbOFL83D/ovDvGxt1s3UkUPbeTced6FbwanCtWM/ZpEHQuX32Z7a7Q25rRg==
 
 "@istanbuljs/load-nyc-config@^1.0.0":
   version "1.0.0"