@goast/typescript 0.3.6 → 0.3.7

package/assets/client/angular/angular-service.utils.ts

@@ -1,6 +1,8 @@
-import { HttpErrorResponse, HttpEvent, HttpResponse } from '@angular/common/http';
+import { HttpErrorResponse, HttpResponse } from '@angular/common/http';
 import { Observable, Subscription, filter, take, map, catchError, EMPTY } from 'rxjs';
 
+import type { HttpEvent } from '@angular/common/http';
+
 export type AbortablePromise<T> = Omit<Promise<T>, 'then' | 'catch' | 'finally'> & {
   abort(): void;
   then<TResult1 = T, TResult2 = never>(

package/assets/client/angular/request-builder.ts

@@ -1,4 +1,6 @@
-import { HttpRequest, HttpParameterCodec, HttpParams, HttpHeaders, HttpContext } from '@angular/common/http';
+import { HttpRequest, HttpParams, HttpHeaders, HttpContext } from '@angular/common/http';
+
+import type { HttpParameterCodec } from '@angular/common/http';
 
 /**
  * Custom parameter codec to correctly handle the plus sign in parameter

package/assets/stubs/easy-network-stub/easy-network-stub.utils.ts

@@ -1,4 +1,6 @@
-import { EasyNetworkStub, ErrorResponse, HttpMethod, RouteResponseCallback } from 'easy-network-stub';
+import { EasyNetworkStub } from 'easy-network-stub';
+
+import type { HttpMethod, RouteResponseCallback, ErrorResponse } from 'easy-network-stub';
 
 /**
  * Options for the `EasyNetworkStubWrapper`.

package/cjs/lib/ast/nodes/export.js

@@ -6,16 +6,18 @@ const node_1 = require("../node");
 const write_ts_nodes_1 = require("../utils/write-ts-nodes");
 class TsExport extends node_1.TsNode {
     constructor(options) {
+        var _a;
         super(options);
         this.name = options.name;
         this.filePath = options.filePath;
+        this.kind = (_a = options.kind) !== null && _a !== void 0 ? _a : 'export';
     }
     onWrite(builder) {
         if (builder instanceof file_builder_1.TypeScriptFileBuilder) {
-            builder.addExport(this.name, this.filePath);
+            builder.addExport(this.name, this.filePath, { type: this.kind });
         }
         else {
-            builder.appendLine(`export { ${this.name} } from '${this.filePath}';`);
+            builder.appendLine(this.kind === 'type-export' ? 'export type' : 'export', ` { ${this.name} } from '${this.filePath}';`);
         }
     }
 }

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

@@ -42,24 +42,24 @@ TsReference.addImportHandlers = [
     },
 ];
 const createReference = (name, moduleNameOrfilePath, options) => new TsReference({ ...options, name, moduleNameOrfilePath });
-function _createFactory(name, moduleNameOrfilePath) {
-    return Object.assign((options) => createReference(name, moduleNameOrfilePath, options), {
+function _createFactory(name, moduleNameOrfilePath, defaultOptions) {
+    return Object.assign((options) => createReference(name, moduleNameOrfilePath, { ...defaultOptions, ...options }), {
         refName: name,
         moduleNameOrfilePath,
     });
 }
-function createFactory(name, moduleNameOrfilePath) {
-    return _createFactory(name, moduleNameOrfilePath);
+function createFactory(name, moduleNameOrfilePath, defaultOptions) {
+    return _createFactory(name, moduleNameOrfilePath, defaultOptions);
 }
-function _createGenericFactory(name, moduleNameOrfilePath) {
-    return Object.assign((generics, options) => createReference(name, moduleNameOrfilePath, { ...options, generics }), {
+function _createGenericFactory(name, moduleNameOrfilePath, defaultOptions) {
+    return Object.assign((generics, options) => createReference(name, moduleNameOrfilePath, { ...defaultOptions, ...options, generics }), {
         refName: name,
         moduleNameOrfilePath,
         infer: () => createReference(name, moduleNameOrfilePath),
     });
 }
-function createGenericFactory(name, moduleNameOrfilePath) {
-    return _createGenericFactory(name, moduleNameOrfilePath);
+function createGenericFactory(name, moduleNameOrfilePath, defaultOptions) {
+    return _createGenericFactory(name, moduleNameOrfilePath, defaultOptions);
 }
 exports.tsReference = Object.assign(createReference, {
     factory: createFactory,

package/cjs/lib/ast/references/angular.js

@@ -5,7 +5,7 @@ const reference_1 = require("../nodes/reference");
 // @angular/core
 exports.inject = reference_1.tsReference.factory('inject', '@angular/core');
 exports.injectable = reference_1.tsReference.factory('Injectable', '@angular/core');
-exports.provider = reference_1.tsReference.factory('Provider', '@angular/core');
+exports.provider = reference_1.tsReference.factory('Provider', '@angular/core', { importType: 'type-import' });
 // @angular/common/http
 exports.httpClient = reference_1.tsReference.factory('HttpClient', '@angular/common/http');
 exports.httpContext = reference_1.tsReference.factory('HttpContext', '@angular/common/http');

package/cjs/lib/ast/references/easy-network-stub.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.errorResponse = exports.routeResponseCallback = exports.httpMethod = exports.easyNetworkStub = void 0;
 const reference_1 = require("../nodes/reference");
 exports.easyNetworkStub = reference_1.tsReference.factory('EasyNetworkStub', 'easy-network-stub');
-exports.httpMethod = reference_1.tsReference.factory('HttpMethod', 'easy-network-stub');
-exports.routeResponseCallback = reference_1.tsReference.genericFactory('RouteResponseCallback', 'easy-network-stub');
+exports.httpMethod = reference_1.tsReference.factory('HttpMethod', 'easy-network-stub', { importType: 'type-import' });
+exports.routeResponseCallback = reference_1.tsReference.genericFactory('RouteResponseCallback', 'easy-network-stub', {
+    importType: 'type-import',
+});
 exports.errorResponse = reference_1.tsReference.genericFactory('ErrorResponse', 'easy-network-stub');

package/cjs/lib/file-builder.js

@@ -28,8 +28,8 @@ class TypeScriptFileBuilder extends core_1.SourceBuilder {
         this.imports.addImport(name, moduleNameOrfilePath, options);
         return this;
     }
-    addExport(name, filePath) {
-        this.imports.addExport(name, filePath);
+    addExport(name, filePath, options) {
+        this.imports.addExport(name, filePath, options);
         return this;
     }
     clear() {
@@ -63,7 +63,7 @@ class TypeScriptFileBuilder extends core_1.SourceBuilder {
     appendModelUsage(type, options) {
         this.append(type.component);
         for (const i of type.imports) {
-            this.addImport(i.name, i.modulePath, options);
+            this.addImport(i.name, i.modulePath, { ...i, ...options });
         }
         return this;
     }

package/cjs/lib/generators/models/model-generator.js

@@ -18,14 +18,26 @@ class DefaultTypeScriptModelGenerator extends file_generator_1.TypeScriptFileGen
                 options: ctx.config,
                 generator: (b) => b.append(fileContent),
             });
+            const exports = fileContent.values.filter((x) => typeof x === 'object' && x !== null && 'export' in x && x.export === true && 'name' in x);
+            const node = exports.find((x) => x.name === name);
             return {
                 component: name,
                 filePath,
-                imports: [{ kind: 'file', name, modulePath: filePath, type: 'import' }],
-                additionalExports: fileContent.values
-                    .filter((x) => typeof x === 'object' && x !== null && 'export' in x && x.export === true && 'name' in x)
+                imports: [
+                    {
+                        kind: 'file',
+                        name,
+                        modulePath: filePath,
+                        type: node instanceof ast_1.ts.Interface || node instanceof ast_1.ts.TypeAlias ? 'type-import' : 'import',
+                    },
+                ],
+                additionalExports: exports
                     .filter((x) => x.name !== name)
-                    .map((x) => x.name),
+                    .map((x) => ({
+                    name: x.name,
+                    type: x instanceof ast_1.ts.TypeAlias || x instanceof ast_1.ts.Interface ? 'type-export' : 'export',
+                })),
+                kind: this.getNodeKind(node),
             };
         }
         else {
@@ -36,6 +48,17 @@ class DefaultTypeScriptModelGenerator extends file_generator_1.TypeScriptFileGen
             return { component: builder.toString(false), imports };
         }
     }
+    getNodeKind(node) {
+        if (node instanceof ast_1.ts.Interface)
+            return 'interface';
+        if (node instanceof ast_1.ts.TypeAlias)
+            return 'type';
+        if (node instanceof ast_1.ts.Enum)
+            return 'enum';
+        if (node instanceof ast_1.ts.Class)
+            return 'class';
+        return undefined;
+    }
     getFileContent(ctx) {
         var _a;
         const content = (0, core_1.appendValueGroup)([], '\n');
@@ -158,13 +181,17 @@ class DefaultTypeScriptModelGenerator extends file_generator_1.TypeScriptFileGen
             return this.getAnyType(ctx);
         schema = (0, core_1.getSchemaReference)(schema, ['description']);
         if ((options === null || options === void 0 ? void 0 : options.useBaseType) && ctx.schema.inheritedSchemas.some((x) => x.id === schema.id)) {
-            return ast_1.ts.reference(this.getBaseTypeName(ctx, schema), this.getFilePath(ctx, schema));
+            return ast_1.ts.reference(this.getBaseTypeName(ctx, schema), this.getFilePath(ctx, schema), {
+                importType: 'type-import',
+            });
         }
         if (!(options === null || options === void 0 ? void 0 : options.skipSchemas) && this.shouldGenerateTypeDeclaration(ctx, schema)) {
             if (schema.id === ctx.schema.id) {
                 return null;
             }
-            return ast_1.ts.reference(this.getDeclarationTypeName(ctx, schema), this.getFilePath(ctx, schema));
+            return ast_1.ts.reference(this.getDeclarationTypeName(ctx, schema), this.getFilePath(ctx, schema), {
+                importType: 'type-import',
+            });
         }
         if (schema.enum) {
             return ast_1.ts.unionType(schema.enum.map((x) => ast_1.ts.toNode(x)));

package/cjs/lib/generators/models/models-generator.js

@@ -57,7 +57,12 @@ class TypeScriptModelsGenerator extends core_1.OpenApiSchemasGenerationProviderB
             const { filePath } = x;
             if (!filePath)
                 return [];
-            return [ast_1.ts.export(x.component, filePath), ...((_b = (_a = x.additionalExports) === null || _a === void 0 ? void 0 : _a.map((e) => ast_1.ts.export(e, filePath))) !== null && _b !== void 0 ? _b : [])];
+            return [
+                ast_1.ts.export(x.component, filePath, {
+                    kind: x.kind === 'type' || x.kind === 'interface' ? 'type-export' : 'export',
+                }),
+                ...((_b = (_a = x.additionalExports) === null || _a === void 0 ? void 0 : _a.map((e) => typeof e === 'string' ? ast_1.ts.export(e, filePath) : ast_1.ts.export(e.name, filePath, { kind: e.type }))) !== null && _b !== void 0 ? _b : []),
+            ];
         }));
     }
 }

package/cjs/lib/generators/services/angular-services/angular-service-generator.js

@@ -187,7 +187,7 @@ class DefaultTypeScriptAngularServiceGenerator extends file_generator_1.TypeScri
         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));
+        const responseModelType = ast_1.ts.reference(this.getResponseModelName(ctx, endpoint), this.getResponseModelFilePath(ctx), { importType: 'type-import' });
         const returnType = ctx.refs.abortablePromise([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 : '*/*';
         const responseType = this.contentTypeToResponseType(accept);

package/cjs/lib/generators/services/angular-services/angular-services-generator.js

@@ -199,7 +199,7 @@ class TypeScriptAngularServicesGenerator extends core_1.OpenApiServicesGeneratio
     getResponseModelsIndexFileContent(ctx) {
         return (0, core_1.appendValueGroup)(Object.values(ctx.output.typescript.services)
             .flatMap((x) => Object.values(x.responseModels))
-            .map((x) => ast_1.ts.export(x.component, x.filePath)));
+            .map((x) => ast_1.ts.export(x.component, x.filePath, { kind: 'type-export' })));
     }
     getServicesIndexFilePath(ctx) {
         return ctx.config.servicesIndexFile ? (0, path_1.resolve)(ctx.config.outputDir, ctx.config.servicesIndexFile) : null;

package/cjs/lib/generators/services/angular-services/refs.js

@@ -10,7 +10,7 @@ function getReferenceFactories(options) {
     const utilsDirPath = (0, path_1.resolve)(options.outputDir, options.utilsDir);
     return {
         // angular-service.utils.ts
-        abortablePromise: ast_1.ts.reference.genericFactory('AbortablePromise', (0, path_1.join)(utilsDirPath, 'angular-service.utils.ts')),
+        abortablePromise: ast_1.ts.reference.genericFactory('AbortablePromise', (0, path_1.join)(utilsDirPath, 'angular-service.utils.ts'), { importType: 'type-import' }),
         waitForResponse: ast_1.ts.reference.genericFactory('waitForResponse', (0, path_1.join)(utilsDirPath, 'angular-service.utils.ts')),
         // request-builder.ts
         requestBuilder: ast_1.ts.reference.factory('RequestBuilder', (0, path_1.join)(utilsDirPath, 'request-builder.ts')),
@@ -19,7 +19,9 @@ function getReferenceFactories(options) {
         // api-base-service.ts - generated in angular-service-generator.ts
         apiBaseService: ast_1.ts.reference.factory('ApiBaseService', (0, path_1.join)(utilsDirPath, 'api-base-service.ts')),
         // http-status-code.ts - generated in angular-services-generator.ts
-        httpStatusCode: ast_1.ts.reference.factory('HttpStatusCode', (0, path_1.join)(utilsDirPath, 'http-status-code.ts')),
+        httpStatusCode: ast_1.ts.reference.factory('HttpStatusCode', (0, path_1.join)(utilsDirPath, 'http-status-code.ts'), {
+            importType: 'type-import',
+        }),
         // provide.ts - generated in angular-services-generator.ts
         provide: ast_1.ts.reference.factory((0, core_1.toCasing)(`provide_${(_b = options.domainName) !== null && _b !== void 0 ? _b : ''}_Api`, options.functionNameCasing), (0, path_1.join)(utilsDirPath, 'provide.ts')),
     };

package/cjs/lib/generators/services/easy-network-stub/refs.js

@@ -9,14 +9,20 @@ function getReferenceFactories(options) {
     const easyNetworkStubUtilsPath = (0, path_1.join)(utilsDirPath, 'easy-network-stub.utils.ts');
     return {
         // easy-network-stub.utils.ts
-        easyNetworkStubWrapperOptions: ast_1.ts.reference.factory('EasyNetworkStubWrapperOptions', easyNetworkStubUtilsPath),
-        stubRequestItem: ast_1.ts.reference.factory('StubRequestItem', easyNetworkStubUtilsPath),
-        stubRequestInfo: ast_1.ts.reference.genericFactory('StubRequestInfo', easyNetworkStubUtilsPath),
-        strictRouteResponseCallback: ast_1.ts.reference.genericFactory('StrictRouteResponseCallback', easyNetworkStubUtilsPath),
+        easyNetworkStubWrapperOptions: ast_1.ts.reference.factory('EasyNetworkStubWrapperOptions', easyNetworkStubUtilsPath, {
+            importType: 'type-import',
+        }),
+        stubRequestItem: ast_1.ts.reference.factory('StubRequestItem', easyNetworkStubUtilsPath, { importType: 'type-import' }),
+        stubRequestInfo: ast_1.ts.reference.genericFactory('StubRequestInfo', easyNetworkStubUtilsPath, {
+            importType: 'type-import',
+        }),
+        strictRouteResponseCallback: ast_1.ts.reference.genericFactory('StrictRouteResponseCallback', easyNetworkStubUtilsPath, { importType: 'type-import' }),
         getStubResponder: ast_1.ts.reference.genericFactory('getStubResponder', easyNetworkStubUtilsPath),
         easyNetworkStubWrapper: ast_1.ts.reference.factory('EasyNetworkStubWrapper', easyNetworkStubUtilsPath),
         easyNetworkStubBase: ast_1.ts.reference.factory('EasyNetworkStubBase', easyNetworkStubUtilsPath),
-        easyNetworkStubGroup: ast_1.ts.reference.genericFactory('EasyNetworkStubGroup', easyNetworkStubUtilsPath),
+        easyNetworkStubGroup: ast_1.ts.reference.genericFactory('EasyNetworkStubGroup', easyNetworkStubUtilsPath, {
+            importType: 'type-import',
+        }),
         createEasyNetworkStubGroup: ast_1.ts.reference.genericFactory('createEasyNetworkStubGroup', easyNetworkStubUtilsPath),
     };
 }

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

@@ -9,8 +9,8 @@ function getReferenceFactories(options) {
     const fetchClientUtilsPath = (0, path_1.resolve)(utilsDirPath, 'fetch-client.utils.ts');
     return {
         // fetch-client.utils.ts
-        typedResponse: ast_1.ts.reference.genericFactory('TypedResponse', fetchClientUtilsPath),
-        fetchClientOptions: ast_1.ts.reference.factory('FetchClientOptions', fetchClientUtilsPath),
+        typedResponse: ast_1.ts.reference.genericFactory('TypedResponse', fetchClientUtilsPath, { importType: 'type-import' }),
+        fetchClientOptions: ast_1.ts.reference.factory('FetchClientOptions', fetchClientUtilsPath, { importType: 'type-import' }),
         urlBuilder: ast_1.ts.reference.factory('UrlBuilder', fetchClientUtilsPath),
     };
 }

package/cjs/lib/import-collection.js

@@ -15,13 +15,14 @@ class ImportExportCollection {
         this._typeImports = new Map();
         this._jsDocImports = new Map();
         this._exports = new Map();
+        this._typeExports = new Map();
         this._options = { ...exports.defaultImportExportCollectionOptions, ...options };
     }
     get hasImports() {
         return this._imports.size > 0 || this._typeImports.size > 0 || this._jsDocImports.size > 0;
     }
     get hasExports() {
-        return this._exports.size > 0;
+        return this._exports.size > 0 || this._typeExports.size > 0;
     }
     get imports() {
         return [
@@ -51,28 +52,23 @@ class ImportExportCollection {
             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) {
-        const existingExport = this._exports.get(fromModule);
+    addExport(exportName, fromModule, options) {
+        var _a;
+        const map = this.getExportMap((_a = options === null || options === void 0 ? void 0 : options.type) !== null && _a !== void 0 ? _a : 'export');
+        const existingExport = map.get(fromModule);
         if (existingExport) {
             existingExport.add(exportName);
         }
         else {
-            this._exports.set(fromModule, new Set([exportName]));
+            map.set(fromModule, new Set([exportName]));
         }
     }
     clear() {
         this._imports.clear();
+        this._typeImports.clear();
+        this._jsDocImports.clear();
         this._exports.clear();
+        this._typeExports.clear();
     }
     toString(options) {
         const builder = new core_1.StringBuilder(options);
@@ -111,6 +107,15 @@ class ImportExportCollection {
             }
             const sortedExports = this.sortAndResolve(this._exports, filePath, importModuleTransformer);
             this.writeImportsExports(builder, 'export', sortedExports, { useSingleQuotes });
+            hasPrevious = true;
+        }
+        if (this._typeExports.size > 0) {
+            if (hasPrevious) {
+                builder.appendLine();
+            }
+            const sortedExports = this.sortAndResolve(this._typeExports, filePath, importModuleTransformer);
+            this.writeImportsExports(builder, 'export type', sortedExports, { useSingleQuotes });
+            hasPrevious = true;
         }
     }
     writeImportsExports(builder, keyword, data, options) {
@@ -153,5 +158,23 @@ class ImportExportCollection {
             kind,
         ];
     }
+    getImportMap(type) {
+        switch (type) {
+            case 'import':
+                return this._imports;
+            case 'type-import':
+                return this._typeImports;
+            case 'js-doc':
+                return this._jsDocImports;
+        }
+    }
+    getExportMap(type) {
+        switch (type) {
+            case 'export':
+                return this._exports;
+            case 'type-export':
+                return this._typeExports;
+        }
+    }
 }
 exports.ImportExportCollection = ImportExportCollection;

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

@@ -3,16 +3,18 @@ import { TsNode } from '../node';
 import { writeTsNodes } from '../utils/write-ts-nodes';
 export class TsExport extends TsNode {
     constructor(options) {
+        var _a;
         super(options);
         this.name = options.name;
         this.filePath = options.filePath;
+        this.kind = (_a = options.kind) !== null && _a !== void 0 ? _a : 'export';
     }
     onWrite(builder) {
         if (builder instanceof TypeScriptFileBuilder) {
-            builder.addExport(this.name, this.filePath);
+            builder.addExport(this.name, this.filePath, { type: this.kind });
         }
         else {
-            builder.appendLine(`export { ${this.name} } from '${this.filePath}';`);
+            builder.appendLine(this.kind === 'type-export' ? 'export type' : 'export', ` { ${this.name} } from '${this.filePath}';`);
         }
     }
 }

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

@@ -38,24 +38,24 @@ TsReference.addImportHandlers = [
     },
 ];
 const createReference = (name, moduleNameOrfilePath, options) => new TsReference({ ...options, name, moduleNameOrfilePath });
-function _createFactory(name, moduleNameOrfilePath) {
-    return Object.assign((options) => createReference(name, moduleNameOrfilePath, options), {
+function _createFactory(name, moduleNameOrfilePath, defaultOptions) {
+    return Object.assign((options) => createReference(name, moduleNameOrfilePath, { ...defaultOptions, ...options }), {
         refName: name,
         moduleNameOrfilePath,
     });
 }
-function createFactory(name, moduleNameOrfilePath) {
-    return _createFactory(name, moduleNameOrfilePath);
+function createFactory(name, moduleNameOrfilePath, defaultOptions) {
+    return _createFactory(name, moduleNameOrfilePath, defaultOptions);
 }
-function _createGenericFactory(name, moduleNameOrfilePath) {
-    return Object.assign((generics, options) => createReference(name, moduleNameOrfilePath, { ...options, generics }), {
+function _createGenericFactory(name, moduleNameOrfilePath, defaultOptions) {
+    return Object.assign((generics, options) => createReference(name, moduleNameOrfilePath, { ...defaultOptions, ...options, generics }), {
         refName: name,
         moduleNameOrfilePath,
         infer: () => createReference(name, moduleNameOrfilePath),
     });
 }
-function createGenericFactory(name, moduleNameOrfilePath) {
-    return _createGenericFactory(name, moduleNameOrfilePath);
+function createGenericFactory(name, moduleNameOrfilePath, defaultOptions) {
+    return _createGenericFactory(name, moduleNameOrfilePath, defaultOptions);
 }
 export const tsReference = Object.assign(createReference, {
     factory: createFactory,

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

@@ -2,7 +2,7 @@ import { tsReference } from '../nodes/reference';
 // @angular/core
 export const inject = tsReference.factory('inject', '@angular/core');
 export const injectable = tsReference.factory('Injectable', '@angular/core');
-export const provider = tsReference.factory('Provider', '@angular/core');
+export const provider = tsReference.factory('Provider', '@angular/core', { importType: 'type-import' });
 // @angular/common/http
 export const httpClient = tsReference.factory('HttpClient', '@angular/common/http');
 export const httpContext = tsReference.factory('HttpContext', '@angular/common/http');

package/esm/lib/ast/references/easy-network-stub.js

@@ -1,5 +1,7 @@
 import { tsReference } from '../nodes/reference';
 export const easyNetworkStub = tsReference.factory('EasyNetworkStub', 'easy-network-stub');
-export const httpMethod = tsReference.factory('HttpMethod', 'easy-network-stub');
-export const routeResponseCallback = tsReference.genericFactory('RouteResponseCallback', 'easy-network-stub');
+export const httpMethod = tsReference.factory('HttpMethod', 'easy-network-stub', { importType: 'type-import' });
+export const routeResponseCallback = tsReference.genericFactory('RouteResponseCallback', 'easy-network-stub', {
+    importType: 'type-import',
+});
 export const errorResponse = tsReference.genericFactory('ErrorResponse', 'easy-network-stub');

package/esm/lib/file-builder.js

@@ -24,8 +24,8 @@ export class TypeScriptFileBuilder extends SourceBuilder {
         this.imports.addImport(name, moduleNameOrfilePath, options);
         return this;
     }
-    addExport(name, filePath) {
-        this.imports.addExport(name, filePath);
+    addExport(name, filePath, options) {
+        this.imports.addExport(name, filePath, options);
         return this;
     }
     clear() {
@@ -59,7 +59,7 @@ export class TypeScriptFileBuilder extends SourceBuilder {
     appendModelUsage(type, options) {
         this.append(type.component);
         for (const i of type.imports) {
-            this.addImport(i.name, i.modulePath, options);
+            this.addImport(i.name, i.modulePath, { ...i, ...options });
         }
         return this;
     }

package/esm/lib/generators/models/model-generator.js

@@ -15,14 +15,26 @@ export class DefaultTypeScriptModelGenerator extends TypeScriptFileGenerator {
                 options: ctx.config,
                 generator: (b) => b.append(fileContent),
             });
+            const exports = fileContent.values.filter((x) => typeof x === 'object' && x !== null && 'export' in x && x.export === true && 'name' in x);
+            const node = exports.find((x) => x.name === name);
             return {
                 component: name,
                 filePath,
-                imports: [{ kind: 'file', name, modulePath: filePath, type: 'import' }],
-                additionalExports: fileContent.values
-                    .filter((x) => typeof x === 'object' && x !== null && 'export' in x && x.export === true && 'name' in x)
+                imports: [
+                    {
+                        kind: 'file',
+                        name,
+                        modulePath: filePath,
+                        type: node instanceof ts.Interface || node instanceof ts.TypeAlias ? 'type-import' : 'import',
+                    },
+                ],
+                additionalExports: exports
                     .filter((x) => x.name !== name)
-                    .map((x) => x.name),
+                    .map((x) => ({
+                    name: x.name,
+                    type: x instanceof ts.TypeAlias || x instanceof ts.Interface ? 'type-export' : 'export',
+                })),
+                kind: this.getNodeKind(node),
             };
         }
         else {
@@ -33,6 +45,17 @@ export class DefaultTypeScriptModelGenerator extends TypeScriptFileGenerator {
             return { component: builder.toString(false), imports };
         }
     }
+    getNodeKind(node) {
+        if (node instanceof ts.Interface)
+            return 'interface';
+        if (node instanceof ts.TypeAlias)
+            return 'type';
+        if (node instanceof ts.Enum)
+            return 'enum';
+        if (node instanceof ts.Class)
+            return 'class';
+        return undefined;
+    }
     getFileContent(ctx) {
         var _a;
         const content = appendValueGroup([], '\n');
@@ -155,13 +178,17 @@ export class DefaultTypeScriptModelGenerator extends TypeScriptFileGenerator {
             return this.getAnyType(ctx);
         schema = getSchemaReference(schema, ['description']);
         if ((options === null || options === void 0 ? void 0 : options.useBaseType) && ctx.schema.inheritedSchemas.some((x) => x.id === schema.id)) {
-            return ts.reference(this.getBaseTypeName(ctx, schema), this.getFilePath(ctx, schema));
+            return ts.reference(this.getBaseTypeName(ctx, schema), this.getFilePath(ctx, schema), {
+                importType: 'type-import',
+            });
         }
         if (!(options === null || options === void 0 ? void 0 : options.skipSchemas) && this.shouldGenerateTypeDeclaration(ctx, schema)) {
             if (schema.id === ctx.schema.id) {
                 return null;
             }
-            return ts.reference(this.getDeclarationTypeName(ctx, schema), this.getFilePath(ctx, schema));
+            return ts.reference(this.getDeclarationTypeName(ctx, schema), this.getFilePath(ctx, schema), {
+                importType: 'type-import',
+            });
         }
         if (schema.enum) {
             return ts.unionType(schema.enum.map((x) => ts.toNode(x)));

package/esm/lib/generators/models/models-generator.js

@@ -54,7 +54,12 @@ export class TypeScriptModelsGenerator extends OpenApiSchemasGenerationProviderB
             const { filePath } = x;
             if (!filePath)
                 return [];
-            return [ts.export(x.component, filePath), ...((_b = (_a = x.additionalExports) === null || _a === void 0 ? void 0 : _a.map((e) => ts.export(e, filePath))) !== null && _b !== void 0 ? _b : [])];
+            return [
+                ts.export(x.component, filePath, {
+                    kind: x.kind === 'type' || x.kind === 'interface' ? 'type-export' : 'export',
+                }),
+                ...((_b = (_a = x.additionalExports) === null || _a === void 0 ? void 0 : _a.map((e) => typeof e === 'string' ? ts.export(e, filePath) : ts.export(e.name, filePath, { kind: e.type }))) !== null && _b !== void 0 ? _b : []),
+            ];
         }));
     }
 }

package/esm/lib/generators/services/angular-services/angular-service-generator.js

@@ -184,7 +184,7 @@ export class DefaultTypeScriptAngularServiceGenerator extends TypeScriptFileGene
         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 = ts.reference(this.getResponseModelName(ctx, endpoint), this.getResponseModelFilePath(ctx));
+        const responseModelType = ts.reference(this.getResponseModelName(ctx, endpoint), this.getResponseModelFilePath(ctx), { importType: 'type-import' });
         const returnType = ctx.refs.abortablePromise([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 : '*/*';
         const responseType = this.contentTypeToResponseType(accept);

package/esm/lib/generators/services/angular-services/angular-services-generator.js

@@ -196,7 +196,7 @@ export class TypeScriptAngularServicesGenerator extends OpenApiServicesGeneratio
     getResponseModelsIndexFileContent(ctx) {
         return appendValueGroup(Object.values(ctx.output.typescript.services)
             .flatMap((x) => Object.values(x.responseModels))
-            .map((x) => ts.export(x.component, x.filePath)));
+            .map((x) => ts.export(x.component, x.filePath, { kind: 'type-export' })));
     }
     getServicesIndexFilePath(ctx) {
         return ctx.config.servicesIndexFile ? resolve(ctx.config.outputDir, ctx.config.servicesIndexFile) : null;

package/esm/lib/generators/services/angular-services/refs.js

@@ -7,7 +7,7 @@ export function getReferenceFactories(options) {
     const utilsDirPath = resolve(options.outputDir, options.utilsDir);
     return {
         // angular-service.utils.ts
-        abortablePromise: ts.reference.genericFactory('AbortablePromise', join(utilsDirPath, 'angular-service.utils.ts')),
+        abortablePromise: ts.reference.genericFactory('AbortablePromise', join(utilsDirPath, 'angular-service.utils.ts'), { importType: 'type-import' }),
         waitForResponse: ts.reference.genericFactory('waitForResponse', join(utilsDirPath, 'angular-service.utils.ts')),
         // request-builder.ts
         requestBuilder: ts.reference.factory('RequestBuilder', join(utilsDirPath, 'request-builder.ts')),
@@ -16,7 +16,9 @@ export function getReferenceFactories(options) {
         // api-base-service.ts - generated in angular-service-generator.ts
         apiBaseService: ts.reference.factory('ApiBaseService', join(utilsDirPath, 'api-base-service.ts')),
         // http-status-code.ts - generated in angular-services-generator.ts
-        httpStatusCode: ts.reference.factory('HttpStatusCode', join(utilsDirPath, 'http-status-code.ts')),
+        httpStatusCode: ts.reference.factory('HttpStatusCode', join(utilsDirPath, 'http-status-code.ts'), {
+            importType: 'type-import',
+        }),
         // provide.ts - generated in angular-services-generator.ts
         provide: ts.reference.factory(toCasing(`provide_${(_b = options.domainName) !== null && _b !== void 0 ? _b : ''}_Api`, options.functionNameCasing), join(utilsDirPath, 'provide.ts')),
     };

package/esm/lib/generators/services/easy-network-stub/refs.js

@@ -6,14 +6,20 @@ export function getReferenceFactories(options) {
     const easyNetworkStubUtilsPath = join(utilsDirPath, 'easy-network-stub.utils.ts');
     return {
         // easy-network-stub.utils.ts
-        easyNetworkStubWrapperOptions: ts.reference.factory('EasyNetworkStubWrapperOptions', easyNetworkStubUtilsPath),
-        stubRequestItem: ts.reference.factory('StubRequestItem', easyNetworkStubUtilsPath),
-        stubRequestInfo: ts.reference.genericFactory('StubRequestInfo', easyNetworkStubUtilsPath),
-        strictRouteResponseCallback: ts.reference.genericFactory('StrictRouteResponseCallback', easyNetworkStubUtilsPath),
+        easyNetworkStubWrapperOptions: ts.reference.factory('EasyNetworkStubWrapperOptions', easyNetworkStubUtilsPath, {
+            importType: 'type-import',
+        }),
+        stubRequestItem: ts.reference.factory('StubRequestItem', easyNetworkStubUtilsPath, { importType: 'type-import' }),
+        stubRequestInfo: ts.reference.genericFactory('StubRequestInfo', easyNetworkStubUtilsPath, {
+            importType: 'type-import',
+        }),
+        strictRouteResponseCallback: ts.reference.genericFactory('StrictRouteResponseCallback', easyNetworkStubUtilsPath, { importType: 'type-import' }),
         getStubResponder: ts.reference.genericFactory('getStubResponder', easyNetworkStubUtilsPath),
         easyNetworkStubWrapper: ts.reference.factory('EasyNetworkStubWrapper', easyNetworkStubUtilsPath),
         easyNetworkStubBase: ts.reference.factory('EasyNetworkStubBase', easyNetworkStubUtilsPath),
-        easyNetworkStubGroup: ts.reference.genericFactory('EasyNetworkStubGroup', easyNetworkStubUtilsPath),
+        easyNetworkStubGroup: ts.reference.genericFactory('EasyNetworkStubGroup', easyNetworkStubUtilsPath, {
+            importType: 'type-import',
+        }),
         createEasyNetworkStubGroup: ts.reference.genericFactory('createEasyNetworkStubGroup', easyNetworkStubUtilsPath),
     };
 }

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

@@ -6,8 +6,8 @@ export function getReferenceFactories(options) {
     const fetchClientUtilsPath = resolve(utilsDirPath, 'fetch-client.utils.ts');
     return {
         // fetch-client.utils.ts
-        typedResponse: ts.reference.genericFactory('TypedResponse', fetchClientUtilsPath),
-        fetchClientOptions: ts.reference.factory('FetchClientOptions', fetchClientUtilsPath),
+        typedResponse: ts.reference.genericFactory('TypedResponse', fetchClientUtilsPath, { importType: 'type-import' }),
+        fetchClientOptions: ts.reference.factory('FetchClientOptions', fetchClientUtilsPath, { importType: 'type-import' }),
         urlBuilder: ts.reference.factory('UrlBuilder', fetchClientUtilsPath),
     };
 }

package/esm/lib/import-collection.js

@@ -12,13 +12,14 @@ export class ImportExportCollection {
         this._typeImports = new Map();
         this._jsDocImports = new Map();
         this._exports = new Map();
+        this._typeExports = new Map();
         this._options = { ...defaultImportExportCollectionOptions, ...options };
     }
     get hasImports() {
         return this._imports.size > 0 || this._typeImports.size > 0 || this._jsDocImports.size > 0;
     }
     get hasExports() {
-        return this._exports.size > 0;
+        return this._exports.size > 0 || this._typeExports.size > 0;
     }
     get imports() {
         return [
@@ -48,28 +49,23 @@ export class ImportExportCollection {
             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) {
-        const existingExport = this._exports.get(fromModule);
+    addExport(exportName, fromModule, options) {
+        var _a;
+        const map = this.getExportMap((_a = options === null || options === void 0 ? void 0 : options.type) !== null && _a !== void 0 ? _a : 'export');
+        const existingExport = map.get(fromModule);
         if (existingExport) {
             existingExport.add(exportName);
         }
         else {
-            this._exports.set(fromModule, new Set([exportName]));
+            map.set(fromModule, new Set([exportName]));
         }
     }
     clear() {
         this._imports.clear();
+        this._typeImports.clear();
+        this._jsDocImports.clear();
         this._exports.clear();
+        this._typeExports.clear();
     }
     toString(options) {
         const builder = new StringBuilder(options);
@@ -108,6 +104,15 @@ export class ImportExportCollection {
             }
             const sortedExports = this.sortAndResolve(this._exports, filePath, importModuleTransformer);
             this.writeImportsExports(builder, 'export', sortedExports, { useSingleQuotes });
+            hasPrevious = true;
+        }
+        if (this._typeExports.size > 0) {
+            if (hasPrevious) {
+                builder.appendLine();
+            }
+            const sortedExports = this.sortAndResolve(this._typeExports, filePath, importModuleTransformer);
+            this.writeImportsExports(builder, 'export type', sortedExports, { useSingleQuotes });
+            hasPrevious = true;
         }
     }
     writeImportsExports(builder, keyword, data, options) {
@@ -150,4 +155,22 @@ export class ImportExportCollection {
             kind,
         ];
     }
+    getImportMap(type) {
+        switch (type) {
+            case 'import':
+                return this._imports;
+            case 'type-import':
+                return this._typeImports;
+            case 'js-doc':
+                return this._jsDocImports;
+        }
+    }
+    getExportMap(type) {
+        switch (type) {
+            case 'export':
+                return this._exports;
+            case 'type-export':
+                return this._typeExports;
+        }
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goast/typescript",
-  "version": "0.3.6",
+  "version": "0.3.7",
   "repository": "https://github.com/MaSch0212/goast.git",
   "description": "Provides gOAst generators for generating TypeScript code from OpenAPI specifications.",
   "keywords": [

package/types/lib/ast/nodes/export.d.ts

@@ -1,14 +1,17 @@
-import { AstNodeOptions, Prettify, SourceBuilder } from '@goast/core';
+import { AstNodeOptions, Nullable, Prettify, SourceBuilder } from '@goast/core';
+import { TypeScriptExportType } from '../../common-results';
 import { TsNode } from '../node';
 import { writeTsNodes } from '../utils/write-ts-nodes';
 type Injects = never;
 type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | Injects>, {
     name: string;
     filePath: string;
+    kind?: Nullable<TypeScriptExportType>;
 }>;
 export declare class TsExport<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
     name: string;
     filePath: string;
+    kind: TypeScriptExportType;
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }

package/types/lib/ast/nodes/reference.d.ts

@@ -27,23 +27,35 @@ export declare class TsReference<TBuilder extends SourceBuilder, TInjects extend
     protected onWrite(builder: TBuilder): void;
     static registerAddImportHandler<TBuilder extends SourceBuilder>(builderClass: _AddImportHandler<TBuilder>['builderClass'], handler: _AddImportHandler<TBuilder>['handler']): void;
 }
-declare function _createFactory(name: string, moduleNameOrfilePath?: Nullable<string>): (<TBuilder extends SourceBuilder>(options?: FactoryOptions<TBuilder>) => TsReference<TBuilder, never>) & {
+declare function _createFactory(name: string, moduleNameOrfilePath?: Nullable<string>, defaultOptions?: {
+    importType?: Nullable<TypeScriptImportType>;
+}): (<TBuilder extends SourceBuilder>(options?: FactoryOptions<TBuilder>) => TsReference<TBuilder, never>) & {
     refName: string;
     moduleNameOrfilePath: Nullable<string>;
 };
-declare function createFactory(name: string, moduleNameOrfilePath: string): ReturnType<typeof _createFactory> & {
+declare function createFactory(name: string, moduleNameOrfilePath: string, defaultOptions?: {
+    importType?: Nullable<TypeScriptImportType>;
+}): ReturnType<typeof _createFactory> & {
     moduleNameOrfilePath: string;
 };
-declare function createFactory(name: string, moduleNameOrfilePath?: Nullable<string>): ReturnType<typeof _createFactory>;
-declare function _createGenericFactory<TGenericCount extends number | number[]>(name: string, moduleNameOrfilePath?: Nullable<string>): (<TBuilder extends SourceBuilder>(generics: TupleWithCount<TsType<TBuilder>, TGenericCount>, options?: FactoryOptions<TBuilder>) => TsReference<TBuilder, never>) & {
+declare function createFactory(name: string, moduleNameOrfilePath?: Nullable<string>, defaultOptions?: {
+    importType?: Nullable<TypeScriptImportType>;
+}): ReturnType<typeof _createFactory>;
+declare function _createGenericFactory<TGenericCount extends number | number[]>(name: string, moduleNameOrfilePath?: Nullable<string>, defaultOptions?: {
+    importType?: Nullable<TypeScriptImportType>;
+}): (<TBuilder extends SourceBuilder>(generics: TupleWithCount<TsType<TBuilder>, TGenericCount>, options?: FactoryOptions<TBuilder>) => TsReference<TBuilder, never>) & {
     refName: string;
     moduleNameOrfilePath: Nullable<string>;
     infer: <TBuilder extends SourceBuilder>() => TsReference<TBuilder, never>;
 };
-declare function createGenericFactory<TGenericCount extends number | number[]>(name: string, moduleNameOrfilePath: string): ReturnType<typeof _createGenericFactory<TGenericCount>> & {
+declare function createGenericFactory<TGenericCount extends number | number[]>(name: string, moduleNameOrfilePath: string, defaultOptions?: {
+    importType?: Nullable<TypeScriptImportType>;
+}): ReturnType<typeof _createGenericFactory<TGenericCount>> & {
     moduleNameOrfilePath: string;
 };
-declare function createGenericFactory<TGenericCount extends number | number[]>(name: string, moduleNameOrfilePath?: Nullable<string>): ReturnType<typeof _createGenericFactory<TGenericCount>>;
+declare function createGenericFactory<TGenericCount extends number | number[]>(name: string, moduleNameOrfilePath?: Nullable<string>, defaultOptions?: {
+    importType?: Nullable<TypeScriptImportType>;
+}): ReturnType<typeof _createGenericFactory<TGenericCount>>;
 export declare const tsReference: (<TBuilder extends SourceBuilder>(name: Options<TBuilder>["name"], moduleNameOrfilePath?: Options<TBuilder>["moduleNameOrfilePath"], options?: Prettify<Omit<Options<TBuilder>, "name" | "moduleNameOrfilePath">>) => TsReference<TBuilder, never>) & {
     factory: typeof createFactory;
     genericFactory: typeof createGenericFactory;

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

@@ -1,15 +1,21 @@
+import { TypeScriptExportOptions } from './import-collection';
+export type TypeScriptComponentOutputKind = 'interface' | 'type' | 'enum' | 'class' | 'function' | 'variable';
 export type TypeScriptComponentOutput = {
     component: string;
     filePath?: string;
     imports: TypeScriptImport[];
-    additionalExports?: string[];
+    additionalExports?: string[] | ({
+        name: string;
+    } & TypeScriptExportOptions)[];
+    kind?: TypeScriptComponentOutputKind;
 };
 export type TypeScriptExportOutput = {
     component: string;
     filePath: string;
-};
+} & TypeScriptExportOptions;
 export type TypeScriptImportKind = 'module' | 'file';
 export type TypeScriptImportType = 'import' | 'type-import' | 'js-doc';
+export type TypeScriptExportType = 'export' | 'type-export';
 export type TypeScriptImport = {
     kind: TypeScriptImportKind;
     type: TypeScriptImportType;

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

@@ -2,7 +2,7 @@ import { AppendParam, AppendValue, Nullable, SourceBuilder } from '@goast/core';
 import { TsNode } from './ast/node';
 import { TypeScriptGeneratorConfig } from './config';
 import { TypeScriptModelGeneratorOutput } from './generators';
-import { ImportExportCollection, TypeScriptImportOptions } from './import-collection';
+import { ImportExportCollection, TypeScriptExportOptions, TypeScriptImportOptions } from './import-collection';
 export type TypeScriptAppends<TAdditionalAppends> = TsNode<TypeScriptFileBuilder> | TAdditionalAppends;
 export type TypeScriptAppendParam<TBuilder extends TypeScriptFileBuilder, TAdditionalAppends> = AppendParam<TBuilder, TypeScriptAppends<TAdditionalAppends>>;
 export declare function isTypeScriptAppendValue<TBuilder extends TypeScriptFileBuilder = TypeScriptFileBuilder>(value: unknown): value is AppendValue<TBuilder>;
@@ -12,7 +12,7 @@ export declare class TypeScriptFileBuilder<TAdditionalAppends = never> extends S
     get options(): TypeScriptGeneratorConfig;
     constructor(filePath?: string, options?: TypeScriptGeneratorConfig);
     addImport(name: string, moduleNameOrfilePath: string, options?: TypeScriptImportOptions): this;
-    addExport(name: string, filePath: string): this;
+    addExport(name: string, filePath: string, options?: TypeScriptExportOptions): this;
     clear(): void;
     toString(addPadding?: boolean): string;
     protected appendSingle(value: TypeScriptAppendParam<this, TAdditionalAppends>): void;

package/types/lib/generators/models/model-generator.d.ts

@@ -1,6 +1,7 @@
 import { ApiSchema, AppendValueGroup, ArrayLikeApiSchema, CombinedLikeApiSchema, Nullable, ObjectLikeApiSchema } from '@goast/core';
 import { TypeScriptModelGeneratorContext, TypeScriptModelGeneratorOutput } from './models';
 import { ts } from '../../ast';
+import { TypeScriptComponentOutputKind } from '../../common-results';
 import { TypeScriptFileBuilder } from '../../file-builder';
 import { TypeScriptFileGenerator } from '../file-generator';
 type Context = TypeScriptModelGeneratorContext;
@@ -11,6 +12,7 @@ export interface TypeScriptModelGenerator<TOutput extends Output = Output> {
 }
 export declare class DefaultTypeScriptModelGenerator extends TypeScriptFileGenerator<Context, Output> implements TypeScriptModelGenerator {
     generate(ctx: Context): Output;
+    protected getNodeKind(node: unknown): TypeScriptComponentOutputKind | undefined;
     protected getFileContent(ctx: Context): AppendValueGroup<Builder>;
     protected getEnum(ctx: Context): ts.Enum<import("@goast/core").SourceBuilder<never>, never>;
     protected getInterface(ctx: Context, schema: ObjectLikeApiSchema): ts.Interface<Builder, never>;

package/types/lib/import-collection.d.ts

@@ -1,5 +1,5 @@
 import { SourceBuilderOptions, StringBuilder } from '@goast/core';
-import { TypeScriptImport, TypeScriptImportKind, TypeScriptImportType } from './common-results';
+import { TypeScriptExportType, TypeScriptImport, TypeScriptImportKind, TypeScriptImportType } from './common-results';
 import { ImportModuleTransformer } from './utils';
 export type ImportExportCollectionOptions = {
     filePath?: string;
@@ -10,11 +10,15 @@ export declare const defaultImportExportCollectionOptions: ImportExportCollectio
 export type TypeScriptImportOptions = {
     type?: TypeScriptImportType;
 };
+export type TypeScriptExportOptions = {
+    type?: TypeScriptExportType;
+};
 export declare class ImportExportCollection {
     private readonly _imports;
     private readonly _typeImports;
     private readonly _jsDocImports;
     private readonly _exports;
+    private readonly _typeExports;
     private readonly _options;
     constructor(options?: Partial<ImportExportCollectionOptions>);
     get hasImports(): boolean;
@@ -22,15 +26,16 @@ export declare class ImportExportCollection {
     get imports(): TypeScriptImport[];
     private toImport;
     addImport(importName: string, fromModule: string, options?: TypeScriptImportOptions): void;
-    getImportMap(type: TypeScriptImportType): Map<string, Set<string>>;
-    addExport(exportName: string, fromModule: string): void;
+    addExport(exportName: string, fromModule: string, options?: TypeScriptExportOptions): void;
     clear(): void;
     toString(options: Partial<SourceBuilderOptions>): string;
     writeTo(builder: StringBuilder): void;
-    protected writeImportsExports(builder: StringBuilder, keyword: 'import' | 'export' | 'import type' | ' * @import', data: (readonly [string, TypeScriptImportKind, string[]])[], options: {
+    protected writeImportsExports(builder: StringBuilder, keyword: 'import' | 'export' | 'import type' | 'export type' | ' * @import', data: (readonly [string, TypeScriptImportKind, string[]])[], options: {
         useSingleQuotes: boolean;
     }): void;
     protected sortAndResolve(data: Map<string, Set<string>>, filePath: string | undefined, importModuleTransformer: ImportModuleTransformer): (readonly [string, TypeScriptImportKind, string[]])[];
     protected getImportKind(fromModule: string): TypeScriptImportKind;
     protected resolveModulePath(fromModule: string, filePath: string | undefined, importModuleTransformer: ImportModuleTransformer): [string, TypeScriptImportKind];
+    protected getImportMap(type: TypeScriptImportType): Map<string, Set<string>>;
+    protected getExportMap(type: TypeScriptExportType): Map<string, Set<string>>;
 }