@cparra/apexdocs 2.25.0 → 3.0.0-alpha.10

package/src/core/markdown/templates/enum-template.ts

@@ -0,0 +1,12 @@
+export const enumMarkdownTemplate = `
+{{ heading headingLevel heading }}
+
+{{> typeDocumentation }}
+
+{{ heading values.headingLevel values.heading }}
+| Value | Description |
+|-------|-------------|
+{{#each values.value}}
+| {{value}} | {{description}} |
+{{/each}}
+`.trim();

package/src/core/markdown/templates/fieldsPartialTemplate.ts

@@ -0,0 +1,23 @@
+export const fieldsPartialTemplate = `
+{{ heading headingLevel heading }}
+{{#each value}}
+{{{ heading headingLevel (inlineCode heading) }}}
+
+{{#if inherited}}
+*Inherited*
+{{/if}}
+
+{{#> documentablePartialTemplate }}
+
+{{ heading signature.headingLevel signature.heading }}
+{{ code signature.value }}
+
+{{ heading type.headingLevel type.heading }}
+{{link type.value}}
+
+{{/documentablePartialTemplate}}
+
+{{#unless @last}}---{{/unless}}
+
+{{/each}}
+`.trim();

package/src/core/markdown/templates/grouped-members-partial-template.ts

@@ -0,0 +1,6 @@
+export const groupedMembersPartialTemplate = `
+{{ heading headingLevel heading }}
+{{#each value}}
+{{> (lookup .. "subTemplate") this}}
+{{/each}}
+`.trim();

package/src/core/markdown/templates/hookable.ts

@@ -0,0 +1,7 @@
+export const hookableTemplate = `
+{{#if frontmatter}}
+{{{frontmatter}}}
+{{/if}}
+
+{{{content}}}
+`.trim();

package/src/core/markdown/templates/interface-template.ts

@@ -0,0 +1,16 @@
+export const interfaceMarkdownTemplate = `
+{{ heading headingLevel heading }}
+
+{{> typeDocumentation }}
+
+{{#if extends}}
+**Extends**
+{{#each extends}}
+{{link this}}{{#unless @last}}, {{/unless}}
+{{/each}}
+{{/if}}
+
+{{#if methods}}
+{{> methodsPartialTemplate methods}}
+{{/if}}
+`.trim();

package/src/core/markdown/templates/methods-partial-template.ts

@@ -0,0 +1,43 @@
+export const methodsPartialTemplate = `
+{{ heading headingLevel heading }}
+{{#each value}}
+{{{ heading headingLevel (inlineCode heading) }}}
+
+{{#if inherited}}
+*Inherited*
+{{/if}}
+
+{{#> documentablePartialTemplate}}
+
+{{ heading signature.headingLevel signature.heading }}
+{{ code signature.value }}
+
+{{#if parameters.value}}
+{{ heading parameters.headingLevel parameters.heading }}
+| Name | Type | Description |
+|------|------|-------------|
+{{#each parameters.value}}
+| {{name}} | {{link type}} | {{{renderContent description}}} |
+{{/each}}
+{{/if}}
+
+{{ heading returnType.headingLevel returnType.heading }}
+**{{link returnType.value.type}}**
+
+{{#if returnType.value.description}}
+{{returnType.value.description}}
+{{/if}}
+
+{{#if throws.value}}
+{{ heading throws.headingLevel throws.heading }}
+{{#each throws.value}}
+{{link this.type}}: {{this.description}}
+
+{{/each}}
+{{/if}}
+{{/documentablePartialTemplate}}
+
+{{#unless @last}}---{{/unless}}
+
+{{/each}}
+`.trim();

package/src/core/markdown/templates/reference-guide.ts

@@ -0,0 +1,14 @@
+export const referenceGuideTemplate = `
+# Apex Reference Guide
+
+{{#each this}}
+## {{@key}}
+
+{{#each this}}
+### {{link title}}
+
+{{{renderContent description}}}
+
+{{/each}}
+{{/each}}
+`.trim();

package/src/core/markdown/templates/template.ts

@@ -0,0 +1,114 @@
+import Handlebars from 'handlebars';
+import { CodeBlock, RenderableContent, StringOrLink } from '../adapters/types';
+import { isCodeBlock, isEmptyLine, isInlineCode } from '../adapters/type-utils';
+import { typeDocPartial } from './type-doc-partial';
+import { documentablePartialTemplate } from './documentable-partial-template';
+import { methodsPartialTemplate } from './methods-partial-template';
+import { groupedMembersPartialTemplate } from './grouped-members-partial-template';
+import { constructorsPartialTemplate } from './constructors-partial-template';
+import { fieldsPartialTemplate } from './fieldsPartialTemplate';
+import { classMarkdownTemplate } from './class-template';
+import { enumMarkdownTemplate } from './enum-template';
+import { interfaceMarkdownTemplate } from './interface-template';
+
+export type CompilationRequest = {
+  template: string;
+  source: unknown;
+};
+
+export class Template {
+  private static instance: Template;
+
+  private constructor() {
+    Handlebars.registerPartial('typeDocumentation', typeDocPartial);
+    Handlebars.registerPartial('documentablePartialTemplate', documentablePartialTemplate);
+    Handlebars.registerPartial('methodsPartialTemplate', methodsPartialTemplate);
+    Handlebars.registerPartial('constructorsPartialTemplate', constructorsPartialTemplate);
+    Handlebars.registerPartial('groupedMembersPartialTemplate', groupedMembersPartialTemplate);
+    Handlebars.registerPartial('fieldsPartialTemplate', fieldsPartialTemplate);
+    Handlebars.registerPartial('classTemplate', classMarkdownTemplate);
+    Handlebars.registerPartial('enumTemplate', enumMarkdownTemplate);
+    Handlebars.registerPartial('interfaceTemplate', interfaceMarkdownTemplate);
+
+    Handlebars.registerHelper('link', link);
+    Handlebars.registerHelper('code', convertCodeBlock);
+    Handlebars.registerHelper('renderContent', resolveRenderableContent);
+    Handlebars.registerHelper('heading', heading);
+    Handlebars.registerHelper('inlineCode', inlineCode);
+    Handlebars.registerHelper('splitAndCapitalize', splitAndCapitalize);
+  }
+
+  public static getInstance(): Template {
+    if (!Template.instance) {
+      Template.instance = new Template();
+    }
+    return Template.instance;
+  }
+
+  compile(request: CompilationRequest): string {
+    const compiled = Handlebars.compile(request.template);
+    return (
+      compiled(request.source)
+        .trim()
+        // clean up extra newlines
+        .replace(/\n{3,}/g, '\n\n')
+    );
+  }
+}
+
+const splitAndCapitalize = (text: string) => {
+  const words = text.split(/[-_]+/);
+  const capitalizedWords = [];
+  for (const word of words) {
+    capitalizedWords.push(word.charAt(0).toUpperCase() + word.slice(1));
+  }
+  return capitalizedWords.join(' ');
+};
+
+const heading = (level: number, text: string) => {
+  return `${'#'.repeat(level)} ${text}`;
+};
+
+const inlineCode = (text: string) => {
+  return new Handlebars.SafeString(`\`${text}\``);
+};
+
+const convertCodeBlock = (codeBlock: CodeBlock): Handlebars.SafeString => {
+  return new Handlebars.SafeString(
+    `
+\`\`\`${codeBlock.language}
+${codeBlock.content.join('\n')}
+\`\`\`
+  `.trim(),
+  );
+};
+
+const resolveRenderableContent = (description?: RenderableContent[]): string => {
+  if (!description) {
+    return '';
+  }
+
+  function reduceDescription(acc: string, curr: RenderableContent) {
+    if (isEmptyLine(curr)) {
+      return acc + '\n';
+    }
+    if (isCodeBlock(curr)) {
+      return acc + convertCodeBlock(curr) + '\n';
+    }
+    if (isInlineCode(curr)) {
+      return acc + inlineCode(curr.content).toString() + ' ';
+    } else {
+      return acc + Handlebars.escapeExpression(link(curr)).trim() + ' ';
+    }
+  }
+
+  return description.reduce(reduceDescription, '').trim();
+};
+
+const link = (source: StringOrLink): string => {
+  if (typeof source === 'string') {
+    return source;
+  } else {
+    return `[${source.title}](${source.url})`;
+  }
+};

package/src/core/markdown/templates/type-doc-partial.ts

@@ -0,0 +1,27 @@
+export const typeDocPartial = `
+{{#> documentablePartialTemplate}}
+
+{{#if doc.group}}
+**Group** {{doc.group}}
+{{/if}}
+
+{{#if doc.author}}
+**Author** {{doc.author}}
+{{/if}}
+
+{{#if doc.date}}
+**Date** {{doc.date}}
+{{/if}}
+
+{{#each doc.sees}}
+**See** {{link this}}
+
+{{/each}}
+
+{{#if namespace}}
+## Namespace
+{{namespace}}
+{{/if}}
+
+{{/documentablePartialTemplate}}
+`.trim();

package/src/core/markdown/utils.ts

@@ -0,0 +1,3 @@
+import { ParsedFile } from '../shared/types';
+
+export const parsedFilesToTypes = (parsedFiles: ParsedFile[]) => parsedFiles.map((parsedFile) => parsedFile.type);

package/src/{service → core/openapi}/__tests__/manifest-factory.spec.ts

@@ -1,7 +1,6 @@
 import { createManifest } from '../manifest-factory';
 import { Type } from '@cparra/apex-reflection';
 import { TypeParser } from '../parser';
-import ApexBundle from '../../model/apex-bundle';
 
 class TestParser implements TypeParser {
   parse(): Type[] {
@@ -10,7 +9,7 @@ class TestParser implements TypeParser {
 }
 
 it('creates a manifest from the result of a type parser', () => {
-  const manifest = createManifest(new TestParser(), (bundle: ApexBundle) => {
+  const manifest = createManifest(new TestParser(), () => {
     return {};
   });
   expect(manifest.types.length).toBe(0);

package/src/{transpiler → core}/openapi/__tests__/open-api-docs-processor.spec.ts

@@ -1,5 +1,5 @@
 import { OpenApiDocsProcessor } from '../open-api-docs-processor';
-import { Settings } from '../../../settings';
+import { Settings } from '../../settings';
 import { SettingsBuilder } from '../../../test-helpers/SettingsBuilder';
 import { DocCommentBuilder } from '../../../test-helpers/DocCommentBuilder';
 import { AnnotationBuilder } from '../../../test-helpers/AnnotationBuilder';

package/src/{model → core/openapi}/apex-type-wrappers/__tests__/ClassMirrorWrapper.spec.ts

@@ -1,7 +1,7 @@
-import { ClassMirrorBuilder } from '../../../test-helpers/ClassMirrorBuilder';
 import { ClassMirrorWrapper } from '../ClassMirrorWrapper';
-import { AnnotationBuilder } from '../../../test-helpers/AnnotationBuilder';
-import { MethodMirrorBuilder } from '../../../test-helpers/MethodMirrorBuilder';
+import { ClassMirrorBuilder } from '../../../../test-helpers/ClassMirrorBuilder';
+import { MethodMirrorBuilder } from '../../../../test-helpers/MethodMirrorBuilder';
+import { AnnotationBuilder } from '../../../../test-helpers/AnnotationBuilder';
 
 it('should return methods by annotation when they exist', function () {
   const classMirror = new ClassMirrorBuilder()

package/src/core/openapi/file-container.ts

@@ -0,0 +1,13 @@
+import { PageData } from '../shared/types';
+
+export class FileContainer {
+  _files: PageData[] = [];
+
+  files(): PageData[] {
+    return this._files;
+  }
+
+  pushFile(file: PageData): void {
+    this._files.push(file);
+  }
+}

package/src/{service → core/openapi}/manifest-factory.ts

@@ -1,7 +1,7 @@
-import Manifest from '../model/manifest';
+import Manifest from '../manifest';
 import { TypeParser } from './parser';
 import { ReflectionResult } from '@cparra/apex-reflection';
-import ApexBundle from '../model/apex-bundle';
+import { UnparsedSourceFile } from '../shared/types';
 
 /**
  * Builds a new Manifest object, sourcing its types from the received TypeParser.
@@ -10,7 +10,7 @@ import ApexBundle from '../model/apex-bundle';
  */
 export function createManifest(
   typeParser: TypeParser,
-  reflect: (apexBundle: ApexBundle) => ReflectionResult,
+  reflect: (apexBundle: UnparsedSourceFile) => ReflectionResult,
 ): Manifest {
   return new Manifest(typeParser.parse(reflect));
 }

package/src/{transpiler → core}/openapi/open-api-docs-processor.ts

@@ -1,19 +1,17 @@
-import ProcessorTypeTranspiler from '../processor-type-transpiler';
-import { FileContainer } from '../file-container';
+import { FileContainer } from './file-container';
 import { ClassMirror, Type } from '@cparra/apex-reflection';
-import { OpenapiTypeFile } from '../../model/openapi/openapi-type-file';
-import { Logger } from '../../util/logger';
-import { OpenApi } from '../../model/openapi/open-api';
-import { Settings } from '../../settings';
+import { Logger } from '#utils/logger';
+import { OpenApi } from './open-api';
+import { Settings } from '../settings';
 import { MethodParser } from './parsers/MethodParser';
-import { camel2title } from '../../util/string-utils';
+import { camel2title } from '#utils/string-utils';
+import { createOpenApiFile } from './openapi-type-file';
 
-export class OpenApiDocsProcessor extends ProcessorTypeTranspiler {
+export class OpenApiDocsProcessor {
   protected readonly _fileContainer: FileContainer;
   openApiModel: OpenApi;
 
   constructor() {
-    super();
     this._fileContainer = new FileContainer();
     const title = Settings.getInstance().getOpenApiTitle();
     if (!title) {
@@ -27,7 +25,7 @@ export class OpenApiDocsProcessor extends ProcessorTypeTranspiler {
   }
 
   onProcess(type: Type): void {
-    Logger.logSingle(`Processing ${type.name}`, false, 'green', false);
+    Logger.logSingle(`Processing ${type.name}`, 'green');
 
     const endpointPath = this.getEndpointPath(type);
     if (!endpointPath) {
@@ -68,7 +66,8 @@ export class OpenApiDocsProcessor extends ProcessorTypeTranspiler {
   }
 
   onAfterProcess: ((types: Type[]) => void) | undefined = () => {
-    this._fileContainer.pushFile(new OpenapiTypeFile(this.openApiModel));
+    const page = createOpenApiFile(Settings.getInstance().openApiFileName(), this.openApiModel);
+    this._fileContainer.pushFile(page);
   };
 
   private getEndpointPath(type: Type): string | null {

package/src/{model → core}/openapi/open-api-types.ts

@@ -56,14 +56,14 @@ export type RequestBodyContent = {
 
 export type MediaTypeObject = {
   schema?: SchemaObject;
-  example?: any;
+  example?: unknown;
   examples?: { [index: string]: ExampleObject };
 };
 
 export type ExampleObject = {
   summary?: string;
   description?: string;
-  value?: any;
+  value?: unknown;
 };
 
 // Responses

package/src/core/openapi/openapi-type-file.ts

@@ -0,0 +1,12 @@
+import { OpenApi } from './open-api';
+import { OpenApiPageData } from '../shared/types';
+
+export function createOpenApiFile(fileName: string, openApiModel: OpenApi): OpenApiPageData {
+  const content = JSON.stringify({ ...openApiModel, namespace: undefined }, null, 2);
+  return {
+    outputDocPath: '',
+    content,
+    frontmatter: null,
+    group: null,
+  };
+}

package/src/{service → core/openapi}/parser.ts

@@ -1,35 +1,21 @@
 import { ClassMirror, InterfaceMirror, ReflectionResult, Type } from '@cparra/apex-reflection';
-import ApexBundle from '../model/apex-bundle';
-import MetadataProcessor from './metadata-processor';
-import { Logger } from '../util/logger';
+import { Logger } from '#utils/logger';
+import { UnparsedSourceFile } from '../shared/types';
 
 export interface TypeParser {
-  parse(reflect: (apexBundle: ApexBundle) => ReflectionResult): Type[];
+  parse(reflect: (apexBundle: UnparsedSourceFile) => ReflectionResult): Type[];
 }
 
 type NameAware = { name: string };
 
 export class RawBodyParser implements TypeParser {
-  constructor(public typeBundles: ApexBundle[]) {}
+  constructor(public typeBundles: UnparsedSourceFile[]) {}
 
-  parse(reflect: (apexBundle: ApexBundle) => ReflectionResult): Type[] {
+  parse(reflect: (apexBundle: UnparsedSourceFile) => ReflectionResult): Type[] {
     const types = this.typeBundles
       .map((currentBundle) => {
         Logger.log(`Parsing file: ${currentBundle.filePath}`);
-        const result = reflect(currentBundle);
-        if (!!result.typeMirror && !!currentBundle.rawMetadataContent) {
-          // If successful and there is a metadata file
-          const metadataParams = MetadataProcessor.process(currentBundle.rawMetadataContent);
-          metadataParams.forEach((value, key) => {
-            const declaration = `${key}: ${value}`;
-            result.typeMirror?.annotations.push({
-              rawDeclaration: declaration,
-              name: declaration,
-              type: declaration,
-            });
-          });
-        }
-        return result;
+        return reflect(currentBundle);
       })
       .filter((reflectionResult) => {
         return reflectionResult.typeMirror;
@@ -60,7 +46,7 @@ export class RawBodyParser implements TypeParser {
         continue;
       }
 
-      // If reaching here then we are dealing with an interface
+      // At this stage, we can be sure we are dealing with an interface
       let typeAsInterface = currentType as InterfaceMirror;
       if (!typeAsInterface.extended_interfaces.length) {
         typesWithFields.push(currentType);

package/src/{transpiler → core}/openapi/parsers/Builder.ts

@@ -1,6 +1,6 @@
 import { Reference, ReferenceBuilder } from './ReferenceBuilder';
-import { ApexDocSchemaObject } from '../../../model/openapi/apex-doc-types';
-import { SchemaObject } from '../../../model/openapi/open-api-types';
+import { ApexDocSchemaObject } from '../../../core/openapi/apex-doc-types';
+import { SchemaObject } from '../../../core/openapi/open-api-types';
 
 export type ApexDocSchemaAware = {
   schema: ApexDocSchemaObject;
@@ -29,7 +29,7 @@ export abstract class Builder<T, K> {
     return schemaAware.schema;
   }
 
-  private isReferenceString = (targetObject: any): targetObject is string => {
+  private isReferenceString = (targetObject: unknown): targetObject is string => {
     return typeof targetObject === 'string' || targetObject instanceof String;
   };
 }

package/src/{transpiler → core}/openapi/parsers/MethodParser.ts

@@ -1,7 +1,7 @@
 import { ClassMirror, MethodMirror } from '@cparra/apex-reflection';
-import { OpenApi } from '../../../model/openapi/open-api';
+import { OpenApi } from '../../../core/openapi/open-api';
 import * as yaml from 'js-yaml';
-import { ClassMirrorWrapper } from '../../../model/apex-type-wrappers/ClassMirrorWrapper';
+import { ClassMirrorWrapper } from '../../../core/openapi/apex-type-wrappers/ClassMirrorWrapper';
 import { Reference, ReferenceBuilder } from './ReferenceBuilder';
 import { ParameterObjectBuilder } from './ParameterObjectBuilder';
 import { ResponsesBuilder } from './ResponsesBuilder';
@@ -9,11 +9,11 @@ import {
   ApexDocHttpRequestBody,
   ApexDocHttpResponse,
   ApexDocParameterObject,
-} from '../../../model/openapi/apex-doc-types';
+} from '../../../core/openapi/apex-doc-types';
 import { RequestBodyBuilder } from './RequestBodyBuilder';
 import { ApexDocSchemaAware } from './Builder';
-import { PropertiesObject, ReferenceObject } from '../../../model/openapi/open-api-types';
-import { MethodMirrorWrapper } from '../../../model/apex-type-wrappers/MethodMirrorWrapper';
+import { PropertiesObject, ReferenceObject } from '../../../core/openapi/open-api-types';
+import { MethodMirrorWrapper } from '../../../core/openapi/apex-type-wrappers/MethodMirrorWrapper';
 
 type FallbackMethodParser = (methodMirror: MethodMirror) => void;
 type AddToOpenApi<T extends ApexDocSchemaAware> = (input: T, urlValue: string, httpMethodKey: HttpOperations) => void;
@@ -95,7 +95,7 @@ export class MethodParser {
 
     for (const annotation of annotations) {
       // We expect the ApexDoc data representing this to be in YAML format.
-      const inYaml = annotation?.bodyLines.reduce((prev, current, _) => prev + '\n' + current);
+      const inYaml = annotation?.bodyLines.reduce((prev, current) => prev + '\n' + current);
 
       if (!inYaml) {
         return;

package/src/{transpiler → core}/openapi/parsers/ParameterObjectBuilder.ts

@@ -1,6 +1,6 @@
-import { ParameterObject } from '../../../model/openapi/open-api-types';
+import { ParameterObject } from '../../../core/openapi/open-api-types';
 import { Reference } from './ReferenceBuilder';
-import { ApexDocParameterObject } from '../../../model/openapi/apex-doc-types';
+import { ApexDocParameterObject } from '../../../core/openapi/apex-doc-types';
 import { Builder } from './Builder';
 
 export class ParameterObjectBuilder extends Builder<ParameterObject, ApexDocParameterObject> {

package/src/{transpiler → core}/openapi/parsers/ReferenceBuilder.ts

@@ -5,11 +5,11 @@ import {
   SchemaObject,
   SchemaObjectArray,
   SchemaObjectObject,
-} from '../../../model/openapi/open-api-types';
-import { TypeBundle, TypesRepository } from '../../../model/types-repository';
+} from '../../../core/openapi/open-api-types';
+import { TypeBundle, TypesRepository } from '../../../core/openapi/types-repository';
 import { ClassMirror, DocCommentAnnotation, FieldMirror, PropertyMirror } from '@cparra/apex-reflection';
 import { ListObjectType, ReferencedType } from '@cparra/apex-reflection';
-import { ApexDocSchemaObject } from '../../../model/openapi/apex-doc-types';
+import { ApexDocSchemaObject } from '../../../core/openapi/apex-doc-types';
 
 type TypeBundleWithIsCollectionAndReferenceOverrides = TypeBundle & {
   originalTypeName: string;
@@ -131,7 +131,7 @@ export class ReferenceBuilder {
     referencedComponents: ReferenceComponent[],
   ) {
     // This can be of type ApexDocSchemaObject
-    const inYaml = manuallyDefinedHttpSchema?.bodyLines.reduce((prev, current, _) => prev + '\n' + current);
+    const inYaml = manuallyDefinedHttpSchema?.bodyLines.reduce((prev, current) => prev + '\n' + current);
     const asJson = yaml.load(inYaml) as ApexDocSchemaObject;
     const isReferenceString = this.isReferenceString(asJson);
 
@@ -227,7 +227,7 @@ export class ReferenceBuilder {
         return { schema: { type: 'object' }, referenceComponents: [] };
       case 'object':
         return { schema: { type: 'object' }, referenceComponents: [] };
-      default:
+      default: {
         // If we got here we are dealing with a non-primitive (most likely a custom class or an SObject).
         const referencedType = TypesRepository.getInstance().getFromAllByName(typeName);
         if (!referencedType) {
@@ -243,6 +243,7 @@ export class ReferenceBuilder {
           schema: reference.entrypointReferenceObject,
           referenceComponents: [...reference.referenceComponents],
         };
+      }
     }
   }
 
@@ -266,7 +267,7 @@ type SchemaObjectReferencePair = {
 
 class ReferenceOverrides {
   static build(referenceAsString: string): ReferenceOverride[] {
-    const cleanedUpReference = referenceAsString.replace(/[\[\]]/g, '');
+    const cleanedUpReference = referenceAsString.replace(/[[\]]/g, '');
     const referenceStrings = cleanedUpReference.split(',').map((item) => item.replace(/\s/g, ''));
     return referenceStrings.map((item) => {
       const [propertyName, referenceName] = item.split(':');

package/src/{transpiler → core}/openapi/parsers/RequestBodyBuilder.ts

@@ -1,6 +1,6 @@
-import { RequestBody } from '../../../model/openapi/open-api-types';
+import { RequestBody } from '../../../core/openapi/open-api-types';
 import { Reference } from './ReferenceBuilder';
-import { ApexDocHttpRequestBody } from '../../../model/openapi/apex-doc-types';
+import { ApexDocHttpRequestBody } from '../../../core/openapi/apex-doc-types';
 import { Builder } from './Builder';
 
 /**

package/src/{transpiler → core}/openapi/parsers/ResponsesBuilder.ts

@@ -1,6 +1,6 @@
-import { ResponseObject } from '../../../model/openapi/open-api-types';
+import { ResponseObject } from '../../../core/openapi/open-api-types';
 import { Reference } from './ReferenceBuilder';
-import { ApexDocHttpResponse } from '../../../model/openapi/apex-doc-types';
+import { ApexDocHttpResponse } from '../../../core/openapi/apex-doc-types';
 import { Builder } from './Builder';
 
 export class ResponsesBuilder extends Builder<ResponseObject, ApexDocHttpResponse> {

package/src/{transpiler → core}/openapi/parsers/__tests__/MethodParser.spec.ts

@@ -1,7 +1,7 @@
 import { ClassMirrorBuilder } from '../../../../test-helpers/ClassMirrorBuilder';
 import { MethodMirrorBuilder } from '../../../../test-helpers/MethodMirrorBuilder';
 import { AnnotationBuilder } from '../../../../test-helpers/AnnotationBuilder';
-import { OpenApi } from '../../../../model/openapi/open-api';
+import { OpenApi } from '../../../../core/openapi/open-api';
 import { MethodParser } from '../MethodParser';
 import { DocCommentBuilder } from '../../../../test-helpers/DocCommentBuilder';
 

package/src/{transpiler → core}/openapi/parsers/__tests__/ParameterObjectBuilder.spec.ts

@@ -1,7 +1,7 @@
 import { ParameterObjectBuilder } from '../ParameterObjectBuilder';
 import { Reference } from '../ReferenceBuilder';
-import { ReferenceObject } from '../../../../model/openapi/open-api-types';
-import { ApexDocParameterObject } from '../../../../model/openapi/apex-doc-types';
+import { ReferenceObject } from '../../../../core/openapi/open-api-types';
+import { ApexDocParameterObject } from '../../../../core/openapi/apex-doc-types';
 
 jest.mock('../ReferenceBuilder', () => {
   return {

package/src/{transpiler → core}/openapi/parsers/__tests__/ReferenceBuilder.spec.ts

@@ -1,8 +1,8 @@
-import { TypesRepository } from '../../../../model/types-repository';
+import { TypesRepository } from '../../../../core/openapi/types-repository';
 import { ReferenceBuilder } from '../ReferenceBuilder';
 import { ClassMirrorBuilder } from '../../../../test-helpers/ClassMirrorBuilder';
 import { FieldMirrorBuilder } from '../../../../test-helpers/FieldMirrorBuilder';
-import { SchemaObjectArray, SchemaObjectObject } from '../../../../model/openapi/open-api-types';
+import { SchemaObjectArray, SchemaObjectObject } from '../../../../core/openapi/open-api-types';
 import { DocCommentBuilder } from '../../../../test-helpers/DocCommentBuilder';
 import { DocCommentAnnotationBuilder } from '../../../../test-helpers/DocCommentAnnotationBuilder';