@goast/typescript 0.0.1

package/esm/lib/generators/services/fetch-clients/fetch-client-generator.js

@@ -0,0 +1,236 @@
+import { dirname, resolve } from 'path';
+import { ensureDirSync, writeFileSync } from 'fs-extra';
+import { getEndpointUrlPreview, notNullish, toCasing } from '@goast/core';
+import { TypeScriptFileBuilder } from '../../../file-builder';
+import { TypeScriptFileGenerator } from '../../file-generator';
+export class DefaultTypeScriptFetchClientGenerator extends TypeScriptFileGenerator {
+    generate(ctx) {
+        const result = {};
+        let builder;
+        if (this.shouldGenerateInterface(ctx)) {
+            const filePath = this.getInterfaceFilePath(ctx);
+            const name = this.getInterfaceName(ctx);
+            console.log(`Generating interface ${name} in ${filePath}...`);
+            ensureDirSync(dirname(filePath));
+            builder = new TypeScriptFileBuilder(filePath, ctx.config);
+            this.generateInterface(ctx, builder);
+            writeFileSync(filePath, builder.toString());
+            result.interface = { filePath, component: name, imports: [{ kind: 'file', name, modulePath: filePath }] };
+        }
+        if (this.shouldGenerateClass(ctx)) {
+            const filePath = this.getClassFilePath(ctx);
+            const name = this.getClassName(ctx);
+            console.log(`Generating class ${name} in ${filePath}...`);
+            ensureDirSync(dirname(filePath));
+            if (!builder || builder.filePath !== filePath) {
+                builder = new TypeScriptFileBuilder(filePath, ctx.config);
+            }
+            this.generateDefaultOptions(ctx, builder);
+            this.generateClass(ctx, builder);
+            writeFileSync(filePath, builder.toString());
+            result.class = { filePath, component: name, imports: [{ kind: 'file', name, modulePath: filePath }] };
+        }
+        return result;
+    }
+    generateInterface(ctx, builder) {
+        builder
+            .ensurePreviousLineEmpty()
+            .append((builder) => this.generateInterfaceDocumentation(ctx, builder))
+            .ensureCurrentLineEmpty()
+            .append((builder) => this.generateInterfaceSignature(ctx, builder))
+            .append(' ')
+            .parenthesize('{}', (builder) => this.generateInterfaceContent(ctx, builder))
+            .appendLine();
+    }
+    generateInterfaceDocumentation(ctx, builder) {
+        if (ctx.service.description) {
+            builder.appendLine('/**').appendLineWithLinePrefix(' *', ctx.service.description).appendLine(' */');
+        }
+    }
+    generateInterfaceSignature(ctx, builder) {
+        builder.append('export interface ').append(this.getInterfaceName(ctx));
+    }
+    generateInterfaceContent(ctx, builder) {
+        builder.forEach(ctx.service.endpoints, (builder, endpoint) => this.generateInterfaceServiceMethod(ctx, builder, endpoint));
+    }
+    generateInterfaceServiceMethod(ctx, builder, endpoint) {
+        builder
+            .ensurePreviousLineEmpty()
+            .append((builder) => this.generateServiceMethodDocumentation(ctx, builder, endpoint))
+            .ensureCurrentLineEmpty()
+            .append((builder) => this.generateServiceMethodSignature(ctx, builder, endpoint))
+            .appendLine(';');
+    }
+    generateDefaultOptions(ctx, builder) {
+        const baseUrl = ctx.service.endpoints
+            .map((x) => { var _a, _b, _c; return (_c = (_b = (_a = x.$src) === null || _a === void 0 ? void 0 : _a.document.servers) === null || _b === void 0 ? void 0 : _b.find((x) => x.url)) === null || _c === void 0 ? void 0 : _c.url; })
+            .find((x) => !!x);
+        builder
+            .ensurePreviousLineEmpty()
+            .addImport('FetchClientOptions', this.getUtilPath(ctx, 'types.ts'))
+            .append('export const ', this.getDefaultOptionsConstantName(ctx), ': FetchClientOptions = ')
+            .parenthesize('{}', (builder) => builder.appendLineIf(notNullish(baseUrl), 'baseUrl: ', this.toStringLiteral(ctx, baseUrl !== null && baseUrl !== void 0 ? baseUrl : ''), ','), { indent: true, multiline: true });
+    }
+    generateClass(ctx, builder) {
+        builder
+            .ensurePreviousLineEmpty()
+            .append((builder) => this.generateClassDocumentation(ctx, builder))
+            .ensureCurrentLineEmpty()
+            .append((builder) => this.generateClassSignature(ctx, builder))
+            .append(' ')
+            .parenthesize('{}', (builder) => this.generateClassContent(ctx, builder))
+            .appendLine();
+    }
+    generateClassDocumentation(ctx, builder) {
+        if (ctx.service.description) {
+            builder.appendLine('/**').appendLineWithLinePrefix(' *', ctx.service.description).appendLine(' */');
+        }
+    }
+    generateClassSignature(ctx, builder) {
+        builder
+            .append('export class ')
+            .append(this.getClassName(ctx))
+            .appendIf(this.shouldGenerateInterface(ctx), (builder) => builder.addImport(this.getInterfaceName(ctx), this.getInterfaceFilePath(ctx)))
+            .append(' implements ', this.getInterfaceName(ctx));
+    }
+    generateClassContent(ctx, builder) {
+        builder
+            .append((builder) => this.generateClassFields(ctx, builder))
+            .append((builder) => this.generateClassConstructor(ctx, builder))
+            .forEach(ctx.service.endpoints, (builder, endpoint) => this.generateClassServiceMethod(ctx, builder, endpoint));
+    }
+    generateClassFields(ctx, builder) {
+        builder.ensureCurrentLineEmpty().appendLine('private readonly _options: FetchClientOptions;');
+    }
+    generateClassConstructor(ctx, builder) {
+        builder
+            .ensurePreviousLineEmpty()
+            .append('constructor(options?: FetchClientOptions)')
+            .parenthesize('{}', (builder) => this.generateClassConstructorContent(ctx, builder), {
+            indent: true,
+            multiline: true,
+        });
+    }
+    generateClassConstructorContent(ctx, builder) {
+        builder.appendLine('this._options = { ...', this.getDefaultOptionsConstantName(ctx), ', ...options };');
+    }
+    generateClassServiceMethod(ctx, builder, endpoint) {
+        builder
+            .ensurePreviousLineEmpty()
+            .append((builder) => this.generateServiceMethodDocumentation(ctx, builder, endpoint))
+            .ensureCurrentLineEmpty()
+            .append((builder) => this.generateServiceMethodSignature(ctx, builder, endpoint))
+            .append(' ')
+            .parenthesize('{}', (builder) => this.generateServiceMethodContent(ctx, builder, endpoint), {
+            indent: true,
+            multiline: true,
+        })
+            .appendLine();
+    }
+    generateServiceMethodDocumentation(ctx, builder, endpoint) {
+        var _a;
+        const hasParams = endpoint.parameters.some((p) => p.target === 'path' || p.target === 'query') ||
+            (!!endpoint.requestBody && ((_a = endpoint.requestBody) === null || _a === void 0 ? void 0 : _a.content.length) > 0);
+        builder.appendComment('/***/', (builder) => {
+            var _a;
+            return builder
+                .appendLine((_a = endpoint.description) !== null && _a !== void 0 ? _a : '[No description was provided by the API]')
+                .appendLine(`@see ${getEndpointUrlPreview(endpoint)}`)
+                .appendLineIf(hasParams, `@param params Parameters for the endpoint.`)
+                .append(`@returns The response of the call to the endpoint.`);
+        });
+    }
+    generateServiceMethodSignature(ctx, builder, endpoint) {
+        builder
+            .append(toCasing(endpoint.name, ctx.config.methodCasing))
+            .parenthesize('()', (builder) => this.generateServiceMethodParameters(ctx, builder, endpoint))
+            .append(': ')
+            .append((builder) => this.generateServiceMethodReturnValue(ctx, builder, endpoint));
+    }
+    generateServiceMethodParameters(ctx, builder, endpoint) {
+        var _a, _b, _c;
+        const params = endpoint.parameters.filter((x) => x.target === 'path' || x.target === 'query');
+        const bodySchemaId = (_c = (_b = (_a = endpoint.requestBody) === null || _a === void 0 ? void 0 : _a.content[0]) === null || _b === void 0 ? void 0 : _b.schema) === null || _c === void 0 ? void 0 : _c.id;
+        builder
+            .appendLineIf(params.length > 0 && !!bodySchemaId)
+            .if(params.length > 0, (builder) => builder
+            .append('params: ')
+            .parenthesize('{}', (builder) => builder.forEach(params, (builder, parameter) => {
+            var _a;
+            return builder.appendLine(`${this.toPropertyName(ctx, parameter.name)}: ${this.getTypeName(ctx, builder, (_a = parameter.schema) === null || _a === void 0 ? void 0 : _a.id)};`);
+        }), { indent: true, multiline: true }))
+            .appendLineIf(params.length > 0 && !!bodySchemaId, ',')
+            .appendIf(!!bodySchemaId, (builder) => builder.append(`body: ${this.getTypeName(ctx, builder, bodySchemaId)}`))
+            .appendLineIf(params.length > 0 && !!bodySchemaId);
+    }
+    generateServiceMethodReturnValue(ctx, builder, endpoint) {
+        var _a, _b, _c;
+        const successResponse = (_a = endpoint.responses.find((x) => x.statusCode === 200)) !== null && _a !== void 0 ? _a : endpoint.responses.find((x) => x.statusCode && x.statusCode > 200 && x.statusCode < 300);
+        const schema = (_c = (_b = successResponse === null || successResponse === void 0 ? void 0 : successResponse.contentOptions) === null || _b === void 0 ? void 0 : _b.find((x) => x.schema !== undefined)) === null || _c === void 0 ? void 0 : _c.schema;
+        builder.append('Promise').parenthesize('<>', (builder) => this.generateTypedResponse(ctx, builder, schema));
+    }
+    generateTypedResponse(ctx, builder, schema) {
+        builder
+            .addImport('TypedResponse', this.getUtilPath(ctx, 'types.ts'))
+            .append('TypedResponse')
+            .parenthesize('<>', (builder) => builder.append(this.getTypeName(ctx, builder, schema === null || schema === void 0 ? void 0 : schema.id)));
+    }
+    generateServiceMethodContent(ctx, builder, endpoint) {
+        builder
+            .addImport('UrlBuilder', this.getUtilPath(ctx, 'url-builder.ts'))
+            .appendLine('const url = new UrlBuilder(this._options.baseUrl)')
+            .indent((builder) => builder
+            .appendLine(`.withPath(${this.toStringLiteral(ctx, endpoint.path)})`)
+            .forEach(endpoint.parameters.filter((x) => x.target === 'path' || x.target === 'query'), (builder, parameter) => builder
+            .appendIf(parameter.target === 'path', `.withPathParam`)
+            .appendIf(parameter.target === 'query', `.withQueryParam`)
+            .parenthesize('()', `${this.toStringLiteral(ctx, parameter.name)}, params.${this.toPropertyName(ctx, parameter.name)}`)
+            .appendLine())
+            .appendLine('.build();'))
+            .append('return (this._options.fetch ?? fetch)')
+            .parenthesize('()', (builder) => builder.append('url, ').parenthesize('{}', (builder) => {
+            var _a, _b;
+            return builder
+                .appendLine('method: ', this.toStringLiteral(ctx, toCasing(endpoint.method, 'all-upper')), ',')
+                .appendLine('headers: this._options.headers,')
+                .appendLineIf(!!((_b = (_a = endpoint.requestBody) === null || _a === void 0 ? void 0 : _a.content[0]) === null || _b === void 0 ? void 0 : _b.schema), 'body: JSON.stringify(body),');
+        }, { indent: true, multiline: true }), { indent: false })
+            .appendLine(' as ', (builder) => this.generateServiceMethodReturnValue(ctx, builder, endpoint), ';');
+    }
+    getTypeName(ctx, builder, schemaId) {
+        if (!schemaId) {
+            return this.getAnyType(ctx);
+        }
+        const modelInfo = ctx.input.models[schemaId];
+        if (!modelInfo) {
+            return this.getAnyType(ctx);
+        }
+        modelInfo.imports.forEach((x) => builder.addImport(x.name, x.modulePath));
+        return modelInfo.component;
+    }
+    shouldGenerateInterface(ctx) {
+        return ctx.config.clientFileKind === 'interface' || ctx.config.clientFileKind === 'class-and-interface';
+    }
+    shouldGenerateClass(ctx) {
+        return ctx.config.clientFileKind === 'class' || ctx.config.clientFileKind === 'class-and-interface';
+    }
+    getInterfaceName(ctx) {
+        return toCasing(ctx.service.name, ctx.config.interfaceNameCasing);
+    }
+    getClassName(ctx) {
+        return toCasing(ctx.service.name, ctx.config.classNameCasing);
+    }
+    getDefaultOptionsConstantName(ctx) {
+        return toCasing(this.getClassName(ctx) + '-default-options', ctx.config.constantCasing);
+    }
+    getInterfaceFilePath(ctx) {
+        var _a, _b;
+        return resolve(ctx.config.outputDir, (_a = ctx.config.clientInterfaceDirPath) !== null && _a !== void 0 ? _a : ctx.config.clientDirPath, `${toCasing(ctx.service.name, (_b = ctx.config.interfaceFileNameCasing) !== null && _b !== void 0 ? _b : ctx.config.fileNameCasing)}.ts`);
+    }
+    getClassFilePath(ctx) {
+        return resolve(ctx.config.outputDir, ctx.config.clientDirPath, `${toCasing(ctx.service.name, ctx.config.fileNameCasing)}.ts`);
+    }
+    getUtilPath(ctx, fileName) {
+        return resolve(ctx.config.outputDir, ctx.config.utilsDirPath, fileName);
+    }
+}

package/esm/lib/generators/services/fetch-clients/fetch-clients-generator.js

@@ -0,0 +1,79 @@
+import { dirname, resolve } from 'path';
+import { ensureDirSync, writeFileSync, copyFileSync, readdirSync } from 'fs-extra';
+import { OpenApiServicesGenerationProviderBase, Factory } from '@goast/core';
+import { DefaultTypeScriptFetchClientGenerator } from './fetch-client-generator';
+import { defaultTypeScriptFetchClientsGeneratorConfig, } from './models';
+import { TypeScriptFileBuilder } from '../../../file-builder';
+import { ImportExportCollection } from '../../../import-collection';
+export class TypeScriptClientsGenerator extends OpenApiServicesGenerationProviderBase {
+    constructor(clientGeneratorFactory) {
+        super();
+        this._clientGeneratorFactory =
+            clientGeneratorFactory !== null && clientGeneratorFactory !== void 0 ? clientGeneratorFactory : Factory.fromValue(new DefaultTypeScriptFetchClientGenerator());
+    }
+    initResult() {
+        return {
+            clients: {},
+            clientIndexFilePath: undefined,
+            clientInterfaceIndexFilePath: undefined,
+        };
+    }
+    buildContext(context, config) {
+        return this.getProviderContext(context, config, defaultTypeScriptFetchClientsGeneratorConfig);
+    }
+    onGenerate(ctx) {
+        this.copyUtilsFiles(ctx);
+        const output = super.onGenerate(ctx);
+        output.clientIndexFilePath = this.generateIndexFile(ctx);
+        return output;
+    }
+    generateService(ctx, service) {
+        const clientGenerator = this._clientGeneratorFactory.create();
+        return clientGenerator.generate(Object.assign(Object.assign({}, ctx), { service }));
+    }
+    addServiceResult(ctx, service, result) {
+        ctx.output.clients[service.id] = result;
+    }
+    generateIndexFile(ctx) {
+        if (!this.shouldGenerateIndexFile(ctx)) {
+            return undefined;
+        }
+        const filePath = this.getIndexFilePath(ctx);
+        console.log(`Generating index file to ${filePath}...`);
+        ensureDirSync(dirname(filePath));
+        const builder = new TypeScriptFileBuilder(filePath, ctx.config);
+        this.generateIndexFileContent(ctx, builder);
+        writeFileSync(filePath, builder.toString());
+        return filePath;
+    }
+    getIndexFilePath(ctx) {
+        var _a;
+        return resolve(ctx.config.outputDir, (_a = ctx.config.indexFilePath) !== null && _a !== void 0 ? _a : 'clients.ts');
+    }
+    shouldGenerateIndexFile(ctx) {
+        return ctx.config.indexFilePath !== null;
+    }
+    generateIndexFileContent(ctx, builder) {
+        var _a, _b;
+        const exports = new ImportExportCollection();
+        for (const clientId in ctx.output.clients) {
+            const client = ctx.output.clients[clientId];
+            if ((_a = client.class) === null || _a === void 0 ? void 0 : _a.filePath) {
+                exports.addExport(client.class.component, client.class.filePath);
+            }
+            if ((_b = client.interface) === null || _b === void 0 ? void 0 : _b.filePath) {
+                exports.addExport(client.interface.component, client.interface.filePath);
+            }
+        }
+        exports.writeTo(builder);
+    }
+    copyUtilsFiles(ctx) {
+        const sourceDir = resolve(dirname(require.resolve('@goast/typescript')), '../assets/client/fetch');
+        const targetDir = resolve(ctx.config.outputDir, ctx.config.utilsDirPath);
+        ensureDirSync(targetDir);
+        const files = readdirSync(sourceDir);
+        for (const file of files) {
+            copyFileSync(resolve(sourceDir, file), resolve(targetDir, file));
+        }
+    }
+}

package/esm/lib/generators/services/fetch-clients/index.js

@@ -0,0 +1,3 @@
+export * from './fetch-client-generator';
+export * from './fetch-clients-generator';
+export * from './models';

package/esm/lib/generators/services/fetch-clients/models.js

@@ -0,0 +1,2 @@
+import { defaultTypeScriptGeneratorConfig } from '../../../config';
+export const defaultTypeScriptFetchClientsGeneratorConfig = Object.assign(Object.assign({}, defaultTypeScriptGeneratorConfig), { fileNameCasing: { casing: 'kebab', suffix: '-client' }, interfaceFileNameCasing: null, classNameCasing: { casing: 'pascal', suffix: 'Client' }, interfaceNameCasing: { prefix: 'I', casing: 'pascal', suffix: 'Client' }, methodCasing: 'camel', clientFileKind: 'class', clientDirPath: 'clients', clientInterfaceDirPath: 'clients/interfaces', indexFilePath: 'clients.ts', interfaceIndexFilePath: 'clients.ts', utilsDirPath: 'utils' });

package/esm/lib/import-collection.js

@@ -0,0 +1,112 @@
+import { extname } from 'path';
+import { StringBuilder } from '@goast/core';
+import { getModulePathRelativeToFile } from './utils';
+export class ImportExportCollection {
+    constructor() {
+        this._imports = new Map();
+        this._exports = new Map();
+    }
+    get hasImports() {
+        return this._imports.size > 0;
+    }
+    get hasExports() {
+        return this._exports.size > 0;
+    }
+    get imports() {
+        return Array.from(this._imports.entries())
+            .map(([fromModule, importNames]) => Array.from(importNames).map((importName) => ({
+            kind: this.getImportKind(fromModule),
+            modulePath: fromModule,
+            name: importName,
+        })))
+            .flat();
+    }
+    addImport(importName, fromModule) {
+        const existingImport = this._imports.get(fromModule);
+        if (existingImport) {
+            existingImport.add(importName);
+        }
+        else {
+            this._imports.set(fromModule, new Set([importName]));
+        }
+    }
+    addExport(exportName, fromModule) {
+        const existingExport = this._exports.get(fromModule);
+        if (existingExport) {
+            existingExport.add(exportName);
+        }
+        else {
+            this._exports.set(fromModule, new Set([exportName]));
+        }
+    }
+    clear() {
+        this._imports.clear();
+        this._exports.clear();
+    }
+    toString(options, filePath, importModuleTransformer) {
+        const builder = new StringBuilder(options);
+        this.writeTo(builder, filePath, importModuleTransformer);
+        return builder.toString();
+    }
+    writeTo(builder, filePath, importModuleTransformer) {
+        if (!filePath) {
+            filePath = builder.filePath;
+        }
+        if (!importModuleTransformer) {
+            importModuleTransformer = builder.options.importModuleTransformer;
+            if (!importModuleTransformer) {
+                throw new Error('importModuleTransformer is required');
+            }
+        }
+        if (this._imports.size > 0) {
+            const sortedImports = this.sortAndResolve(this._imports, filePath, importModuleTransformer);
+            this.writeImportsExports(builder, 'import', sortedImports);
+        }
+        if (this._imports.size > 0 && this._exports.size > 0) {
+            builder.appendLine();
+        }
+        if (this._exports.size > 0) {
+            const sortedExports = this.sortAndResolve(this._exports, filePath, importModuleTransformer);
+            this.writeImportsExports(builder, 'export', sortedExports);
+        }
+    }
+    writeImportsExports(builder, keyword, data) {
+        const moduleData = [];
+        const fileData = [];
+        for (const x of data) {
+            if (x[1] === 'module') {
+                moduleData.push(x);
+            }
+            else {
+                fileData.push(x);
+            }
+        }
+        for (const [fromModule, _, names] of moduleData) {
+            builder.appendLine(`${keyword} { ${names.join(', ')} } from '${fromModule}';`);
+        }
+        if (moduleData.length > 0 && fileData.length > 0) {
+            builder.appendLine();
+        }
+        for (const [fromModule, _, names] of fileData) {
+            builder.appendLine(`${keyword} { ${names.join(', ')} } from '${fromModule}';`);
+        }
+    }
+    sortAndResolve(data, filePath, importModuleTransformer) {
+        return Array.from(data.entries())
+            .sort(([fromModuleA], [fromModuleB]) => fromModuleA.localeCompare(fromModuleB))
+            .map(([fromModule, names]) => [...this.resolveModulePath(fromModule, filePath, importModuleTransformer), Array.from(names).sort()]);
+    }
+    getImportKind(fromModule) {
+        const extName = extname(fromModule).toUpperCase();
+        return extName === '.TS' || extName === '.JS' || extName === '.JSON' ? 'file' : 'module';
+    }
+    resolveModulePath(fromModule, filePath, importModuleTransformer) {
+        const kind = this.getImportKind(fromModule);
+        return [
+            filePath && kind === 'file'
+                ? getModulePathRelativeToFile(filePath, fromModule, importModuleTransformer)
+                : fromModule,
+            kind,
+        ];
+    }
+}

package/esm/lib/utils.js

@@ -0,0 +1,48 @@
+import { dirname, relative } from 'path';
+function doubleQuotedToSingleQuoted(value) {
+    return `'${value.slice(1, -1).replace(/'/g, "\\'")}'`;
+}
+export function toTypeScriptStringLiteral(value, useSingleQuotes) {
+    return useSingleQuotes ? doubleQuotedToSingleQuoted(JSON.stringify(value)) : JSON.stringify(value);
+}
+export function toTypeScriptPropertyName(value, useSingleQuotes) {
+    if (value.match(/^[a-zA-Z_$][a-zA-Z_$0-9]*$/)) {
+        return value;
+    }
+    return useSingleQuotes ? doubleQuotedToSingleQuoted(JSON.stringify(value)) : JSON.stringify(value);
+}
+export function getModulePathRelativeToFile(from, to, transformer) {
+    return transformModulePath(relative(dirname(from), to).replace(/\\/g, '/'), transformer);
+}
+export function getModulePathRelativeToDirectory(from, to, transformer) {
+    return transformModulePath(relative(from, to).replace(/\\/g, '/'), transformer);
+}
+function transformModulePath(modulePath, transformer) {
+    if (!modulePath.startsWith('.')) {
+        modulePath = `./${modulePath}`;
+    }
+    if (transformer === 'omit-extension') {
+        return modulePath.replace(/\.[^/.]+$/, '');
+    }
+    else if (transformer === 'js-extension') {
+        return modulePath.replace(/\.[^/.]+$/, '.js');
+    }
+    else if (typeof transformer === 'function') {
+        return transformer(modulePath);
+    }
+    return modulePath;
+}
+export function modifyString(value, modifier, ...args) {
+    var _a;
+    if (typeof modifier === 'string') {
+        return modifier;
+    }
+    if (modifier instanceof RegExp) {
+        const match = value.match(modifier);
+        return (_a = match === null || match === void 0 ? void 0 : match[0]) !== null && _a !== void 0 ? _a : value;
+    }
+    if (typeof modifier === 'function') {
+        return modifier(value, ...args);
+    }
+    return value;
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@goast/typescript",
+  "version": "0.0.1",
+  "repository": "https://github.com/MaSch0212/goast.git",
+  "author": {
+    "name": "Marc Schmidt (MaSch0212)",
+    "url": "https://github.com/MaSch0212"
+  },
+  "license": "MIT",
+  "type": "module",
+  "dependencies": {
+    "fs-extra": "^11.1.1",
+    "node-fetch": "^2.6.11",
+    "yaml": "^2.3.1",
+    "@goast/core": "0.1.1",
+    "tslib": "^2.3.0"
+  },
+  "module": "./esm/index.js",
+  "main": "./cjs/index.js",
+  "types": "./types/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./esm/index.js",
+      "require": "./cjs/index.js",
+      "types": "./types/index.d.ts"
+    },
+    "./package.json": "./package.json"
+  }
+}

package/types/index.d.ts

@@ -0,0 +1,6 @@
+export * from './lib/common-results';
+export * from './lib/config';
+export * from './lib/generators';
+export * from './lib/file-builder';
+export * from './lib/import-collection';
+export * from './lib/utils';

package/types/lib/common-results.d.ts

@@ -0,0 +1,11 @@
+export type TypeScriptComponentOutput = {
+    component: string;
+    filePath?: string;
+    imports: TypeScriptImport[];
+};
+export type TypeScriptImportKind = 'module' | 'file';
+export type TypeScriptImport = {
+    kind: TypeScriptImportKind;
+    modulePath: string;
+    name: string;
+};

package/types/lib/config.d.ts

@@ -0,0 +1,13 @@
+import { DefaultGenerationProviderConfig, OpenApiGeneratorConfig, StringCasing, StringCasingWithOptions } from '@goast/core';
+import { ImportModuleTransformer } from './utils';
+export type TypeScriptGeneratorConfig = OpenApiGeneratorConfig & {
+    importModuleTransformer: ImportModuleTransformer;
+    typeNameCasing: StringCasing | StringCasingWithOptions;
+    methodNameCasing: StringCasing | StringCasingWithOptions;
+    propertyNameCasing: StringCasing | StringCasingWithOptions;
+    enumValueNameCasing: StringCasing | StringCasingWithOptions;
+    constantCasing: StringCasing | StringCasingWithOptions;
+    preferUnknown: boolean;
+    useSingleQuotes: boolean;
+};
+export declare const defaultTypeScriptGeneratorConfig: DefaultGenerationProviderConfig<TypeScriptGeneratorConfig>;

package/types/lib/file-builder.d.ts

@@ -0,0 +1,110 @@
+import { Nullable, SourceBuilder, TextOrBuilderFn } from '@goast/core';
+import { TypeScriptGeneratorConfig } from './config';
+import { TypeScriptModelGeneratorOutput } from './generators';
+import { ImportExportCollection } from './import-collection';
+export declare class TypeScriptFileBuilder extends SourceBuilder {
+    readonly filePath: string | undefined;
+    readonly imports: ImportExportCollection;
+    get options(): TypeScriptGeneratorConfig;
+    constructor(filePath: string | undefined, options: TypeScriptGeneratorConfig);
+    addImport(name: string, moduleNameOrfilePath: string): this;
+    addExport(name: string, filePath: string): this;
+    clear(): void;
+    toString(addPadding?: boolean): string;
+    appendGenericArguments(...genericArguments: Nullable<TextOrBuilderFn<this>>[]): this;
+    appendParameter(parameter: Nullable<TextOrBuilderFn<this>> | TypeScriptParameterOptions): this | undefined;
+    appendParameters(...parameters: (Nullable<TextOrBuilderFn<this>> | TypeScriptParameterOptions)[]): this;
+    appendObjectLiteral(...properties: Nullable<TextOrBuilderFn<this>>[]): this;
+    appendArrayLiteral(...items: Nullable<TextOrBuilderFn<this>>[]): this;
+    appendCodeBlock(...content: Nullable<TextOrBuilderFn<this>>[]): this;
+    appendComment(style: '/***/' | '/**/' | '//', comment: Nullable<TextOrBuilderFn<this>>): this;
+    appendDocumentation(documentation: Nullable<TextOrBuilderFn<this>>): this;
+    appendModelUsage(type: TypeScriptModelGeneratorOutput): this;
+    appendExternalTypeUsage(type: TypeScriptExternalTypeOptions): this;
+    appendTypeDeclaration(options: TypeScriptTypeDeclarationOptions): this;
+    appendAnnotation(options: TypeScriptAnnotationOptions): this;
+    appendAnnotations(annotations: TypeScriptAnnotationOptions[], separator: string): this;
+    appendClass(options: TypeScriptClassOptions): this;
+    appendConstructor(options: TypeScriptConstructorOptions): this;
+    appendMethod(options: TypeScriptMethodOptions): this;
+    appendProperty(options: TypeScriptPropertyOptions): this;
+    appendFunction(options: TypeScriptFunctionOptions): this;
+}
+export type TypeScriptTypeDeclarationOptions = {
+    documentation?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>;
+    omitExport?: boolean;
+    name: string;
+    type: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>;
+};
+export type TypeScriptExternalTypeOptions = {
+    name: string;
+    module: string;
+};
+export type TypeScriptAnnotationOptions = {
+    name: string;
+    module?: string;
+    args?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>[];
+};
+export type TypeScriptClassOptions = {
+    documentation?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>;
+    annotations?: TypeScriptAnnotationOptions[];
+    omitExport?: boolean;
+    isAbstract?: boolean;
+    name: string;
+    genericArguments?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>[];
+    extends?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>;
+    implements?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>[];
+    body?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>;
+};
+export type TypeScriptConstructorOptions = {
+    documentation?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>;
+    annotations?: TypeScriptAnnotationOptions[];
+    parameters?: (Nullable<TextOrBuilderFn<TypeScriptFileBuilder>> | TypeScriptParameterOptions)[];
+    body?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>;
+};
+export type TypeScriptParameterOptions = {
+    name: string;
+    isOptional?: boolean;
+    type?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>> | TypeScriptExternalTypeOptions;
+    genericArguments?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>[];
+    defaultValue?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>;
+};
+export type TypeScriptMethodOptions = {
+    documentation?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>;
+    annotations?: TypeScriptAnnotationOptions[];
+    accessibility?: 'public' | 'protected' | 'private';
+    isAbstract?: boolean;
+    isStatic?: boolean;
+    isAsync?: boolean;
+    name: string;
+    genericArguments?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>[];
+    parameters?: (Nullable<TextOrBuilderFn<TypeScriptFileBuilder>> | TypeScriptParameterOptions)[];
+    returnType?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>;
+    body?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>;
+};
+export type TypeScriptPropertyOptions = {
+    documentation?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>;
+    annotations?: TypeScriptAnnotationOptions[];
+    accessibility?: 'public' | 'protected' | 'private';
+    isAbstract?: boolean;
+    isStatic?: boolean;
+    isReadonly?: boolean;
+    isOptional?: boolean;
+    kind?: 'property' | 'getter' | 'setter' | 'getter-setter';
+    name: string;
+    type?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>;
+    initializer?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>;
+    getter?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>;
+    getterAnnotations?: TypeScriptAnnotationOptions[];
+    setter?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>;
+    setterAnnotations?: TypeScriptAnnotationOptions[];
+};
+export type TypeScriptFunctionOptions = {
+    kind?: 'function' | 'arrow-function';
+    isAsync?: boolean;
+    name?: string;
+    parameters: (Nullable<TextOrBuilderFn<TypeScriptFileBuilder>> | TypeScriptParameterOptions)[];
+    returnType?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>;
+    body?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>;
+    singleLine?: boolean;
+};