@goast/typescript 0.3.1 → 0.3.3

package/cjs/lib/generators/services/k6-clients/k6-client-generator.js

@@ -0,0 +1,311 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultTypeScriptK6ClientGenerator = void 0;
+const path_1 = require("path");
+const core_1 = require("@goast/core");
+const ast_1 = require("../../../ast");
+const file_builder_1 = require("../../../file-builder");
+const file_generator_1 = require("../../file-generator");
+class DefaultTypeScriptK6ClientGenerator extends file_generator_1.TypeScriptFileGenerator {
+    generate(ctx) {
+        const responseModels = this.generateResponseModels(ctx);
+        const filePath = this.getFilePath(ctx);
+        const name = this.getClassName(ctx);
+        file_builder_1.TypeScriptFileBuilder.generate({
+            logName: `k6 client ${name}`,
+            filePath,
+            options: ctx.config,
+            generator: (b) => b.append(this.getClientFileContent(ctx)),
+        });
+        return {
+            filePath,
+            component: name,
+            responseModels,
+        };
+    }
+    // #region Response Model
+    generateResponseModels(ctx) {
+        const result = {};
+        const filePath = this.getResponseModelFilePath(ctx);
+        const builder = new file_builder_1.TypeScriptFileBuilder(filePath, ctx.config);
+        for (const endpoint of ctx.service.endpoints) {
+            const name = this.getResponseModelName(ctx, endpoint);
+            builder.appendLine(this.getResponseModelFileContent(ctx, endpoint));
+            result[endpoint.id] = { component: name, filePath };
+        }
+        builder.writeToFile();
+        return result;
+    }
+    getResponseModelFileContent(ctx, endpoint) {
+        const result = (0, core_1.appendValueGroup)([]);
+        const statusCodes = this.getEndpointStatusCodes(ctx, endpoint);
+        let statusCodeType;
+        const statusCodesTypeName = (0, core_1.toCasing)(`${endpoint.name}_StatusCodes`, ctx.config.typeNameCasing);
+        result.values.push(ast_1.ts.typeAlias(statusCodesTypeName, ast_1.ts.unionType(Object.keys(statusCodes))));
+        if (ctx.config.strictResponseTypes) {
+            statusCodeType = ast_1.ts.reference(statusCodesTypeName);
+        }
+        else {
+            statusCodeType = ctx.refs.httpStatusCode();
+        }
+        result.values.push(ast_1.ts.typeAlias(this.getResponseModelName(ctx, endpoint), ast_1.ts.intersectionType([
+            ast_1.ts.unionType([
+                ...Object.entries(statusCodes).map(([key, value]) => {
+                    return ast_1.ts.intersectionType([
+                        ast_1.ts.refs.omit([ast_1.ts.refs.k6.response(), ast_1.ts.string('json')]),
+                        ast_1.ts.objectType({
+                            members: [
+                                ast_1.ts.property('status', { type: key }),
+                                ast_1.ts.method('json', {
+                                    returnType: value.type,
+                                }),
+                                ast_1.ts.method('json', {
+                                    parameters: [ast_1.ts.parameter('selector', { type: ast_1.ts.refs.string() })],
+                                    returnType: ast_1.ts.refs.k6.jsonValue(),
+                                }),
+                            ],
+                        }),
+                    ]);
+                }),
+                !ctx.config.strictResponseTypes
+                    ? ast_1.ts.intersectionType([
+                        ast_1.ts.refs.k6.response(),
+                        ast_1.ts.objectType({
+                            members: [
+                                ast_1.ts.property('status', {
+                                    type: ast_1.ts.refs.exclude([ctx.refs.httpStatusCode(), ast_1.ts.reference(statusCodesTypeName)]),
+                                }),
+                            ],
+                        }),
+                    ])
+                    : null,
+            ]),
+            ast_1.ts.objectType({ members: [ast_1.ts.property('status', { type: 'TStatus' })] }),
+        ]), {
+            doc: ast_1.ts.doc({
+                description: `Response model for operation ${this.getEndpointMethodName(ctx, endpoint)}`,
+                tags: [endpoint.deprecated ? ast_1.ts.docTag('deprecated') : null],
+            }),
+            export: true,
+            generics: [
+                ast_1.ts.genericParameter('TStatus', {
+                    constraint: statusCodeType,
+                    default: statusCodeType,
+                }),
+            ],
+        }));
+        return result;
+    }
+    getEndpointStatusCodes(ctx, endpoint) {
+        return Object.fromEntries([
+            ...Object.entries(ctx.config.defaultStatusCodeResponseTypes).map(([key, value]) => {
+                var _a;
+                return [
+                    key,
+                    {
+                        parser: (_a = value === null || value === void 0 ? void 0 : value.parser) !== null && _a !== void 0 ? _a : 'text',
+                        type: typeof (value === null || value === void 0 ? void 0 : value.type) === 'function'
+                            ? this.getSchemaType(ctx, value.type(ctx.data.schemas))
+                            : (value !== null && value !== void 0 ? value : ast_1.ts.refs.never()),
+                    },
+                ];
+            }),
+            ...endpoint.responses
+                .filter((x) => x.statusCode)
+                .map((x) => {
+                var _a;
+                return [
+                    x.statusCode,
+                    {
+                        type: this.getSchemaType(ctx, (_a = x.contentOptions[0]) === null || _a === void 0 ? void 0 : _a.schema, { fallback: ast_1.ts.refs.never() }),
+                    },
+                ];
+            }),
+        ]);
+    }
+    // #endregion
+    getClientFileContent(ctx) {
+        const code = (0, core_1.appendValueGroup)([], '\n');
+        for (const endpoint of ctx.service.endpoints) {
+            if (endpoint.parameters.length > 0 || endpoint.requestBody !== undefined) {
+                code.values.push(this.getEndpointParamsType(ctx, endpoint));
+            }
+        }
+        code.values.push((0, core_1.appendValueGroup)(ctx.service.endpoints.map((e) => ast_1.ts.variable(this.getEndpointPathPropertyName(ctx, e), {
+            readonly: true,
+            value: ast_1.ts.string(e.path),
+        }))));
+        code.values.push(this.getClass(ctx));
+        return code;
+    }
+    getEndpointParamsType(ctx, endpoint) {
+        const type = ast_1.ts.doc({
+            description: `Parameters for operation ${this.getEndpointMethodName(ctx, endpoint)}`,
+            tags: [ast_1.ts.docTag('typedef', this.getEndpointParamsTypeName(ctx, endpoint))],
+        });
+        for (const parameter of endpoint.parameters) {
+            const schema = parameter.schema;
+            const name = (0, core_1.toCasing)(parameter.name, ctx.config.propertyNameCasing);
+            type.tags.push(ast_1.ts.docTag('property', parameter.required ? name : `[${name}]`, {
+                type: schema
+                    ? (b) => b.appendModelUsage(ctx.input.typescript.models[schema.id], { type: 'js-doc' })
+                    : this.getAnyType(ctx),
+                text: (parameter.deprecated ? 'Deprecated: ' : '') + parameter.description,
+            }));
+        }
+        if (endpoint.requestBody !== undefined) {
+            const body = endpoint.requestBody;
+            const schema = body.content[0].schema;
+            type.tags.push(ast_1.ts.docTag('property', body.required ? 'body' : '[body]', {
+                type: schema
+                    ? (b) => b.appendModelUsage(ctx.input.typescript.models[schema.id], { type: 'js-doc' })
+                    : this.getAnyType(ctx),
+                text: body.description,
+            }));
+        }
+        return type;
+    }
+    getClass(ctx) {
+        return ast_1.ts.class(this.getClassName(ctx), {
+            doc: ast_1.ts.doc({
+                description: ctx.service.description,
+                tags: [
+                    ast_1.ts.docTag('property', 'rootUrl', 'The root URL for this client.', {
+                        type: ast_1.ts.refs.string(),
+                    }),
+                    ctx.service.endpoints.length === 0 || ctx.service.endpoints.some((x) => !x.deprecated)
+                        ? null
+                        : ast_1.ts.docTag('deprecated'),
+                ],
+            }),
+            export: true,
+            members: [
+                ast_1.ts.constructor({
+                    doc: ast_1.ts.doc({
+                        description: 'Creates a new instance of the client.',
+                        tags: [
+                            ast_1.ts.docTag('param', 'rootUrl', 'The root URL for this client.', { type: ast_1.ts.refs.string() }),
+                            ast_1.ts.docTag('param', '[defaultK6ParamsFactory]', 'A factory function that returns the default K6 parameters.', { type: ast_1.ts.functionType({ returnType: ast_1.ts.refs.k6.params({ importType: 'js-doc' }) }) }),
+                        ],
+                    }),
+                    parameters: [ast_1.ts.constructorParameter('rootUrl'), ast_1.ts.constructorParameter('defaultK6ParamsFactory')],
+                    body: (0, core_1.builderTemplate) `this.rootUrl = rootUrl;
+                  this._defaultK6ParamsFactory = defaultK6ParamsFactory;`,
+                }),
+                ...ctx.service.endpoints.map((e) => this.getEndpointMethod(ctx, e)),
+                this.getGetK6ParamsMethod(ctx),
+            ],
+        });
+    }
+    getEndpointMethod(ctx, endpoint) {
+        var _a, _b, _c, _d;
+        const hasParams = this.hasEndpointParams(ctx, endpoint);
+        const paramsOptional = !endpoint.parameters.some((p) => p.required) && !((_a = endpoint.requestBody) === null || _a === void 0 ? void 0 : _a.required);
+        const responseModelType = ast_1.ts.reference(this.getResponseModelName(ctx, endpoint), this.getResponseModelFilePath(ctx), { importType: 'js-doc' });
+        const returnType = responseModelType;
+        const accept = (_d = (_c = (_b = this.getEndpointSuccessResponse(ctx, endpoint)) === null || _b === void 0 ? void 0 : _b.contentOptions[0]) === null || _c === void 0 ? void 0 : _c.type) !== null && _d !== void 0 ? _d : '*/*';
+        return ast_1.ts.method(this.getEndpointMethodName(ctx, endpoint), {
+            async: ctx.config.async,
+            parameters: [hasParams ? ast_1.ts.parameter('params') : null, ast_1.ts.parameter('k6Params')],
+            doc: ast_1.ts.doc({
+                description: endpoint.description,
+                tags: [
+                    hasParams
+                        ? ast_1.ts.docTag('param', paramsOptional ? '[params]' : 'params', {
+                            type: ast_1.ts.reference(this.getEndpointParamsTypeName(ctx, endpoint)),
+                        })
+                        : null,
+                    ast_1.ts.docTag('param', '[k6Params]', {
+                        type: ast_1.ts.refs.k6.params({ importType: 'js-doc' }),
+                    }),
+                    ast_1.ts.docTag('returns', {
+                        type: ctx.config.async ? ast_1.ts.refs.promise([returnType]) : returnType,
+                    }),
+                    endpoint.deprecated ? ast_1.ts.docTag('deprecated') : null,
+                ],
+            }),
+            body: (0, core_1.appendValueGroup)([
+                (0, core_1.builderTemplate) `const rb = new ${ctx.refs.requestBuilder()}(this.rootUrl, ${this.getEndpointPathPropertyName(ctx, endpoint)}, '${endpoint.method}');`,
+                hasParams
+                    ? (b) => {
+                        var _a;
+                        return b.appendIf(paramsOptional, 'if (params) ').parenthesizeIf(paramsOptional, '{}', (0, core_1.appendValueGroup)([
+                            ...endpoint.parameters
+                                .filter((p) => p.target === 'path' || p.target === 'query' || p.target === 'header')
+                                .map((p) => {
+                                const options = ast_1.ts.object({
+                                    members: [
+                                        p.style !== undefined ? ast_1.ts.property('style', { value: ast_1.ts.string(p.style) }) : null,
+                                        p.explode !== undefined ? ast_1.ts.property('explode', { value: ast_1.ts.toNode(p.explode) }) : null,
+                                    ],
+                                });
+                                return (0, core_1.builderTemplate) `rb.${p.target}(${ast_1.ts.string(p.name)}, params.${(0, core_1.toCasing)(p.name, ctx.config.propertyNameCasing)}, ${options});`;
+                            }),
+                            endpoint.requestBody
+                                ? (0, core_1.builderTemplate) `rb.body(params.body, ${ast_1.ts.string((_a = endpoint.requestBody.content[0].type) !== null && _a !== void 0 ? _a : 'application/json')});`
+                                : null,
+                        ], '\n'), { multiline: true });
+                    }
+                    : null,
+                '',
+                (0, core_1.builderTemplate) `return /** @type {${returnType}} */ (${core_1.builderTemplate.indent `
+              ${ctx.config.async ? 'await rb.buildAsync' : 'rb.build'}({${core_1.builderTemplate.indent `
+                accept: ${ast_1.ts.string(accept)},
+                params: this.getK6Params(k6Params),`}
+              })`}
+            );`,
+            ], '\n'),
+        });
+    }
+    getGetK6ParamsMethod(ctx) {
+        return ast_1.ts.method('getK6Params', {
+            doc: ast_1.ts.doc({
+                tags: [
+                    ast_1.ts.docTag('private'),
+                    ast_1.ts.docTag('param', '[k6Params]', { type: ast_1.ts.refs.k6.params({ importType: 'js-doc' }) }),
+                ],
+            }),
+            parameters: [ast_1.ts.parameter('k6Params')],
+            body: (0, core_1.builderTemplate) `return Object.assign({}, this._defaultK6ParamsFactory ? this._defaultK6ParamsFactory() : {}, k6Params);`,
+        });
+    }
+    getEndpointSuccessResponse(ctx, endpoint) {
+        var _a;
+        return ((_a = endpoint.responses.find((x) => x.statusCode && x.statusCode >= 200 && x.statusCode < 300)) !== null && _a !== void 0 ? _a : endpoint.responses.find((x) => x.statusCode === undefined));
+    }
+    getSchemaType(ctx, schema, options) {
+        var _a;
+        const output = schema && ctx.input.typescript.models[schema.id];
+        if (!output)
+            return (_a = options === null || options === void 0 ? void 0 : options.fallback) !== null && _a !== void 0 ? _a : this.getAnyType(ctx);
+        return (b) => b.appendModelUsage(output, options);
+    }
+    getClassName(ctx) {
+        var _a;
+        return (0, core_1.toCasing)(ctx.service.name, (_a = ctx.config.clientNameCasing) !== null && _a !== void 0 ? _a : ctx.config.typeNameCasing);
+    }
+    getResponseModelName(ctx, endpoint) {
+        return (0, core_1.toCasing)(`${this.getEndpointMethodName(ctx, endpoint)}ApiResponse`, ctx.config.typeNameCasing);
+    }
+    getEndpointParamsTypeName(ctx, endpoint) {
+        return (0, core_1.toCasing)(this.getEndpointMethodName(ctx, endpoint) + '_Params', ctx.config.typeNameCasing);
+    }
+    getEndpointPathPropertyName(ctx, endpoint) {
+        return (0, core_1.toCasing)(this.getEndpointMethodName(ctx, endpoint) + '_Path', ctx.config.constantNameCasing);
+    }
+    getEndpointMethodName(ctx, endpoint) {
+        return (0, core_1.toCasing)(endpoint.name, ctx.config.functionNameCasing);
+    }
+    getFilePath(ctx) {
+        var _a;
+        return (0, path_1.resolve)(ctx.config.outputDir, ctx.config.clientDir, `${(0, core_1.toCasing)(ctx.service.name, (_a = ctx.config.clientFileNameCasing) !== null && _a !== void 0 ? _a : ctx.config.fileNameCasing)}.js`);
+    }
+    getResponseModelFilePath(ctx) {
+        var _a;
+        return (0, path_1.resolve)(ctx.config.outputDir, ctx.config.responseModelsDir, `${(0, core_1.toCasing)(ctx.service.name, (_a = ctx.config.responseModelFileNameCasing) !== null && _a !== void 0 ? _a : ctx.config.fileNameCasing)}.ts`);
+    }
+    hasEndpointParams(ctx, endpoint) {
+        return endpoint.parameters.length > 0 || endpoint.requestBody !== undefined;
+    }
+}
+exports.DefaultTypeScriptK6ClientGenerator = DefaultTypeScriptK6ClientGenerator;

package/cjs/lib/generators/services/k6-clients/k6-clients-generator.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeScriptK6ClientsGenerator = void 0;
+const path_1 = require("path");
+const fs_extra_1 = require("fs-extra");
+const core_1 = require("@goast/core");
+const k6_client_generator_1 = require("./k6-client-generator");
+const models_1 = require("./models");
+const refs_1 = require("./refs");
+const ast_1 = require("../../../ast");
+const file_builder_1 = require("../../../file-builder");
+class TypeScriptK6ClientsGenerator extends core_1.OpenApiServicesGenerationProviderBase {
+    constructor(clientGeneratorFactory) {
+        super();
+        this._clientGeneratorFactory =
+            clientGeneratorFactory !== null && clientGeneratorFactory !== void 0 ? clientGeneratorFactory : core_1.Factory.fromValue(new k6_client_generator_1.DefaultTypeScriptK6ClientGenerator());
+    }
+    initResult() {
+        return {
+            typescript: {
+                k6Clients: {},
+                indexFiles: {
+                    k6Clients: undefined,
+                    k6ResponseModels: undefined,
+                },
+            },
+        };
+    }
+    buildContext(context, config) {
+        const providerContext = this.getProviderContext(context, config, models_1.defaultTypeScriptK6ClientsGeneratorConfig);
+        return Object.assign(providerContext, {
+            refs: (0, refs_1.getReferenceFactories)(providerContext.config),
+        });
+    }
+    onGenerate(ctx) {
+        const output = super.onGenerate(ctx);
+        this.generateUtilsFiles(ctx);
+        output.typescript.indexFiles = this.generateIndexFiles(ctx);
+        return output;
+    }
+    generateService(ctx, service) {
+        const clientGenerator = this._clientGeneratorFactory.create();
+        return clientGenerator.generate({
+            ...ctx,
+            service,
+        });
+    }
+    addServiceResult(ctx, service, result) {
+        ctx.output.typescript.k6Clients[service.id] = result;
+    }
+    generateUtilsFiles(ctx) {
+        const sourceDir = (0, path_1.resolve)((0, path_1.dirname)(require.resolve('@goast/typescript')), '../assets/client/k6');
+        const targetDir = (0, path_1.resolve)(ctx.config.outputDir, ctx.config.utilsDir);
+        (0, fs_extra_1.ensureDirSync)(targetDir);
+        this.copyFile('Request Builder', sourceDir, targetDir, 'request-builder.js');
+        if (!ctx.config.strictResponseTypes) {
+            file_builder_1.TypeScriptFileBuilder.generate({
+                logName: 'http status codes',
+                filePath: (0, path_1.resolve)(targetDir, 'http-status-code.ts'),
+                options: ctx.config,
+                generator: (b) => b.append(this.getHttpStatusCodeFileContent(ctx)),
+            });
+        }
+    }
+    getHttpStatusCodeFileContent(ctx) {
+        return (0, core_1.appendValueGroup)([
+            ast_1.ts.typeAlias('HttpStatusCode', ast_1.ts.unionType(ctx.config.possibleStatusCodes), {
+                doc: ast_1.ts.doc({ description: 'The possible status codes that any API endpoint can return.' }),
+                export: true,
+            }),
+        ], '\n');
+    }
+    generateIndexFiles(ctx) {
+        const clientsIndexFilePath = this.getIndexFilePath(ctx);
+        const responseModelsIndexFilePath = this.getResponseModelsIndexFilePath(ctx);
+        file_builder_1.TypeScriptFileBuilder.tryGenerate({
+            logName: 'clients index file',
+            filePath: clientsIndexFilePath,
+            options: ctx.config,
+            generator: (b) => b.append(this.getIndexFileContent(ctx)),
+        });
+        file_builder_1.TypeScriptFileBuilder.tryGenerate({
+            logName: 'response models index file',
+            filePath: responseModelsIndexFilePath,
+            options: ctx.config,
+            generator: (b) => b.append(this.getResponseModelsIndexFileContent(ctx)),
+        });
+        return {
+            k6Clients: clientsIndexFilePath,
+            k6ResponseModels: responseModelsIndexFilePath,
+        };
+    }
+    getIndexFilePath(ctx) {
+        return ctx.config.clientsIndexFile ? (0, path_1.resolve)(ctx.config.outputDir, ctx.config.clientsIndexFile) : null;
+    }
+    getResponseModelsIndexFilePath(ctx) {
+        return ctx.config.responseModelsIndexFile
+            ? (0, path_1.resolve)(ctx.config.outputDir, ctx.config.responseModelsIndexFile)
+            : null;
+    }
+    getIndexFileContent(ctx) {
+        return (0, core_1.appendValueGroup)(Object.values(ctx.output.typescript.k6Clients).map((x) => ast_1.ts.export(x.component, x.filePath)));
+    }
+    getResponseModelsIndexFileContent(ctx) {
+        return (0, core_1.appendValueGroup)(Object.values(ctx.output.typescript.k6Clients)
+            .flatMap((x) => Object.values(x.responseModels))
+            .map((x) => ast_1.ts.export(x.component, x.filePath)));
+    }
+    copyFile(logName, sourceDir, targetDir, fileName) {
+        const source = (0, path_1.resolve)(sourceDir, fileName);
+        const target = (0, path_1.resolve)(targetDir, fileName);
+        console.log(`Generating ${logName} to ${target}...`);
+        (0, fs_extra_1.copyFileSync)(source, target);
+    }
+}
+exports.TypeScriptK6ClientsGenerator = TypeScriptK6ClientsGenerator;

package/cjs/lib/generators/services/k6-clients/models.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultTypeScriptK6ClientsGeneratorConfig = void 0;
+const config_1 = require("../../../config");
+exports.defaultTypeScriptK6ClientsGeneratorConfig = {
+    ...config_1.defaultTypeScriptGeneratorConfig,
+    importModuleTransformer: 'js-extension',
+    strictResponseTypes: true,
+    defaultStatusCodeResponseTypes: {
+        401: null,
+        403: null,
+        500: null,
+    },
+    possibleStatusCodes: [
+        100, 101, 102, 103, 200, 201, 202, 203, 204, 205, 206, 207, 208, 226, 300, 301, 302, 303, 304, 305, 306, 307, 308,
+        400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 421, 422, 423, 424, 425,
+        426, 428, 429, 431, 451, 500, 501, 502, 503, 504, 505, 506, 507, 508, 510, 511,
+    ],
+    clientFileNameCasing: { casing: 'kebab', suffix: '-client' },
+    responseModelFileNameCasing: { casing: 'kebab', suffix: '-responses' },
+    clientNameCasing: { casing: 'pascal', suffix: 'Client' },
+    clientDir: 'clients',
+    responseModelsDir: 'models/responses',
+    clientsIndexFile: 'clients.js',
+    responseModelsIndexFile: 'responses.ts',
+    utilsDir: 'utils',
+    async: true,
+};

package/cjs/lib/generators/services/k6-clients/refs.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getReferenceFactories = getReferenceFactories;
+const path_1 = require("path");
+const ast_1 = require("../../../ast");
+function getReferenceFactories(options) {
+    const utilsDirPath = (0, path_1.resolve)(options.outputDir, options.utilsDir);
+    return {
+        requestBuilder: ast_1.ts.reference.factory('RequestBuilder', (0, path_1.join)(utilsDirPath, 'request-builder.js')),
+        httpStatusCode: ast_1.ts.reference.factory('HttpStatusCode', (0, path_1.join)(utilsDirPath, 'http-status-code.ts')),
+    };
+}

package/cjs/lib/import-collection.js

@@ -12,31 +12,53 @@ exports.defaultImportExportCollectionOptions = {
 class ImportExportCollection {
     constructor(options) {
         this._imports = new Map();
+        this._typeImports = new Map();
+        this._jsDocImports = new Map();
         this._exports = new Map();
         this._options = { ...exports.defaultImportExportCollectionOptions, ...options };
     }
     get hasImports() {
-        return this._imports.size > 0;
+        return this._imports.size > 0 || this._typeImports.size > 0 || this._jsDocImports.size > 0;
     }
     get hasExports() {
         return this._exports.size > 0;
     }
     get imports() {
-        return Array.from(this._imports.entries())
+        return [
+            ...this.toImport('import', this._imports),
+            ...this.toImport('type-import', this._typeImports),
+            ...this.toImport('js-doc', this._jsDocImports),
+        ];
+    }
+    toImport(type, map) {
+        return Array.from(map.entries())
             .map(([fromModule, importNames]) => Array.from(importNames).map((importName) => ({
             kind: this.getImportKind(fromModule),
+            type,
             modulePath: fromModule,
             name: importName,
         })))
             .flat();
     }
-    addImport(importName, fromModule) {
-        const existingImport = this._imports.get(fromModule);
+    addImport(importName, fromModule, options) {
+        var _a;
+        const map = this.getImportMap((_a = options === null || options === void 0 ? void 0 : options.type) !== null && _a !== void 0 ? _a : 'import');
+        const existingImport = map.get(fromModule);
         if (existingImport) {
             existingImport.add(importName);
         }
         else {
-            this._imports.set(fromModule, new Set([importName]));
+            map.set(fromModule, new Set([importName]));
+        }
+    }
+    getImportMap(type) {
+        switch (type) {
+            case 'import':
+                return this._imports;
+            case 'type-import':
+                return this._typeImports;
+            case 'js-doc':
+                return this._jsDocImports;
         }
     }
     addExport(exportName, fromModule) {
@@ -59,14 +81,34 @@ class ImportExportCollection {
     }
     writeTo(builder) {
         const { filePath, importModuleTransformer, useSingleQuotes } = this._options;
+        let hasPrevious = false;
         if (this._imports.size > 0) {
             const sortedImports = this.sortAndResolve(this._imports, filePath, importModuleTransformer);
             this.writeImportsExports(builder, 'import', sortedImports, { useSingleQuotes });
+            hasPrevious = true;
         }
-        if (this._imports.size > 0 && this._exports.size > 0) {
-            builder.appendLine();
+        if (this._typeImports.size > 0) {
+            if (hasPrevious) {
+                builder.appendLine();
+            }
+            const sortedImports = this.sortAndResolve(this._typeImports, filePath, importModuleTransformer);
+            this.writeImportsExports(builder, 'import type', sortedImports, { useSingleQuotes });
+            hasPrevious = true;
+        }
+        if (this._jsDocImports.size > 0) {
+            if (hasPrevious) {
+                builder.appendLine();
+            }
+            const sortedImports = this.sortAndResolve(this._jsDocImports, filePath, importModuleTransformer);
+            builder.appendLine('/**');
+            this.writeImportsExports(builder, ' * @import', sortedImports, { useSingleQuotes });
+            builder.appendLine(' */');
+            hasPrevious = true;
         }
         if (this._exports.size > 0) {
+            if (hasPrevious) {
+                builder.appendLine();
+            }
             const sortedExports = this.sortAndResolve(this._exports, filePath, importModuleTransformer);
             this.writeImportsExports(builder, 'export', sortedExports, { useSingleQuotes });
         }

package/esm/lib/ast/nodes/method.js

@@ -8,7 +8,7 @@ import { TsNode } from '../node';
 import { writeTsNode, writeTsNodes } from '../utils/write-ts-nodes';
 export class TsMethod extends TsNode {
     constructor(options) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
         super(options);
         this.doc = (_a = options.doc) !== null && _a !== void 0 ? _a : null;
         this.decorators = (_c = (_b = options.decorators) === null || _b === void 0 ? void 0 : _b.filter(notNullish)) !== null && _c !== void 0 ? _c : [];
@@ -16,12 +16,13 @@ export class TsMethod extends TsNode {
         this.static = (_e = options.static) !== null && _e !== void 0 ? _e : false;
         this.abstract = (_f = options.abstract) !== null && _f !== void 0 ? _f : false;
         this.override = (_g = options.override) !== null && _g !== void 0 ? _g : false;
+        this.async = (_h = options.async) !== null && _h !== void 0 ? _h : false;
         this.name = options.name;
-        this.optional = (_h = options.optional) !== null && _h !== void 0 ? _h : false;
-        this.generics = (_k = (_j = options.generics) === null || _j === void 0 ? void 0 : _j.filter(notNullish)) !== null && _k !== void 0 ? _k : [];
-        this.parameters = (_m = (_l = options.parameters) === null || _l === void 0 ? void 0 : _l.filter(notNullish)) !== null && _m !== void 0 ? _m : [];
-        this.returnType = (_o = options.returnType) !== null && _o !== void 0 ? _o : null;
-        this.body = (_p = options.body) !== null && _p !== void 0 ? _p : null;
+        this.optional = (_j = options.optional) !== null && _j !== void 0 ? _j : false;
+        this.generics = (_l = (_k = options.generics) === null || _k === void 0 ? void 0 : _k.filter(notNullish)) !== null && _l !== void 0 ? _l : [];
+        this.parameters = (_o = (_m = options.parameters) === null || _m === void 0 ? void 0 : _m.filter(notNullish)) !== null && _o !== void 0 ? _o : [];
+        this.returnType = (_p = options.returnType) !== null && _p !== void 0 ? _p : null;
+        this.body = (_q = options.body) !== null && _q !== void 0 ? _q : null;
     }
     onWrite(builder) {
         const isInObjectDeclaration = this.getParentNode(builder) instanceof TsObject;
@@ -40,6 +41,8 @@ export class TsMethod extends TsNode {
             builder.append('abstract ');
         if (this.override)
             builder.append('override ');
+        if (this.async)
+            builder.append('async ');
         builder.append(this.inject.afterModifiers);
         builder.append(this.inject.beforeName, this.name, this.inject.afterName);
         if (this.optional)

package/esm/lib/ast/nodes/reference.js

@@ -5,11 +5,12 @@ import { writeTsGenericParameters } from '../utils/write-ts-generic-parameters';
 import { writeTsNodes } from '../utils/write-ts-nodes';
 export class TsReference extends TsNode {
     constructor(options) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         super(options);
         this.name = options.name;
         this.moduleNameOrfilePath = (_a = options.moduleNameOrfilePath) !== null && _a !== void 0 ? _a : null;
         this.generics = (_c = (_b = options.generics) === null || _b === void 0 ? void 0 : _b.filter(notNullish)) !== null && _c !== void 0 ? _c : [];
+        this.importType = (_d = options.importType) !== null && _d !== void 0 ? _d : 'import';
     }
     onWrite(builder) {
         builder.append(this.name);
@@ -29,12 +30,16 @@ export class TsReference extends TsNode {
 TsReference.addImportHandlers = [
     {
         builderClass: TypeScriptFileBuilder,
-        handler: (builder, reference) => builder.addImport(reference.name, reference.moduleNameOrfilePath),
+        handler: (builder, reference) => {
+            if (reference.moduleNameOrfilePath) {
+                builder.addImport(reference.name, reference.moduleNameOrfilePath, { type: reference.importType });
+            }
+        },
     },
 ];
 const createReference = (name, moduleNameOrfilePath, options) => new TsReference({ ...options, name, moduleNameOrfilePath });
 function _createFactory(name, moduleNameOrfilePath) {
-    return Object.assign(() => createReference(name, moduleNameOrfilePath), {
+    return Object.assign((options) => createReference(name, moduleNameOrfilePath, options), {
         refName: name,
         moduleNameOrfilePath,
     });
@@ -43,7 +48,7 @@ function createFactory(name, moduleNameOrfilePath) {
     return _createFactory(name, moduleNameOrfilePath);
 }
 function _createGenericFactory(name, moduleNameOrfilePath) {
-    return Object.assign((generics) => createReference(name, moduleNameOrfilePath, { generics }), {
+    return Object.assign((generics, options) => createReference(name, moduleNameOrfilePath, { ...options, generics }), {
         refName: name,
         moduleNameOrfilePath,
         infer: () => createReference(name, moduleNameOrfilePath),

package/esm/lib/ast/references/index.js

@@ -4,4 +4,6 @@ import * as angular_1 from './angular';
 export { angular_1 as angular };
 import * as rxjs_1 from './rxjs';
 export { rxjs_1 as rxjs };
+import * as k6_1 from './k6';
+export { k6_1 as k6 };
 export * from './typescript';

package/esm/lib/ast/references/k6.js

@@ -0,0 +1,6 @@
+import { tsReference } from '../nodes/reference';
+// k6
+export const jsonValue = tsReference.factory('JSONValue', 'k6');
+// h6/http
+export const response = tsReference.factory('Response', 'k6/http');
+export const params = tsReference.factory('Params', 'k6/http');