@goast/typescript 0.2.20 → 0.3.0

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

@@ -15,7 +15,7 @@ export class DefaultTypeScriptFetchClientGenerator extends TypeScriptFileGenerat
                 options: ctx.config,
                 generator: (b) => b.append(this.getInterfaceFileContent(ctx)),
             });
-            result.interface = { filePath, component: name };
+            result.clientInterface = { filePath, component: name };
         }
         if (this.shouldGenerateClass(ctx)) {
             const filePath = this.getClassFilePath(ctx);
@@ -26,7 +26,7 @@ export class DefaultTypeScriptFetchClientGenerator extends TypeScriptFileGenerat
                 options: ctx.config,
                 generator: (b) => b.append(this.getClassFileContent(ctx)),
             });
-            result.class = { filePath, component: name };
+            result.client = { filePath, component: name };
         }
         return result;
     }
@@ -53,7 +53,7 @@ export class DefaultTypeScriptFetchClientGenerator extends TypeScriptFileGenerat
         const params = endpoint.parameters.filter((x) => x.target === 'path' || x.target === 'query');
         const bodySchema = (_b = (_a = endpoint.requestBody) === null || _a === void 0 ? void 0 : _a.content[0]) === null || _b === void 0 ? void 0 : _b.schema;
         const responseSchema = this.getResponseSchema(ctx, endpoint);
-        return ts.method(toCasing(endpoint.name, ctx.config.methodCasing), {
+        return ts.method(toCasing(endpoint.name, ctx.config.functionNameCasing), {
             doc: ts.doc({ description: endpoint.description, tags: [endpoint.deprecated ? ts.docTag('deprecated') : null] }),
             parameters: [
                 params.length > 0
@@ -129,11 +129,11 @@ export class DefaultTypeScriptFetchClientGenerator extends TypeScriptFileGenerat
         });
     }
     getServiceMethod(ctx, endpoint) {
-        var _a, _b;
+        var _a, _b, _c;
         const method = this.getInterfaceEndpointMethod(ctx, endpoint);
         method.accessModifier = 'public';
         method.body = appendValueGroup([
-            s `const url = new ${ctx.refs.urlBuilder()}(this.options.baseUrl)${s.indent `
+            s `const url = new ${ctx.refs.urlBuilder()}(this.options.baseUrl)${s.indent `
           .withPath(${ts.string(endpoint.path)})${(b) => b.forEach(endpoint.parameters, (b, p) => {
                 switch (p.target) {
                     case 'path':
@@ -143,7 +143,7 @@ export class DefaultTypeScriptFetchClientGenerator extends TypeScriptFileGenerat
                         b.append(s `\n.withQueryParam(${ts.string(p.name)}, params.${toCasing(p.name, ctx.config.paramNameCasing)})`);
                         break;
                 }
-            })}
+            })}
           .build();`}`,
             s `const response = (this.options.fetch ?? fetch)(url, ${ts.object({
                 members: [
@@ -153,13 +153,13 @@ export class DefaultTypeScriptFetchClientGenerator extends TypeScriptFileGenerat
                 ],
             })});`,
             s `Object.defineProperty(response, 'isVoidResponse', { value: ${this.getResponseSchema(ctx, endpoint) ? 'false' : 'true'} });`,
-            s `return response as unknown as ${method.returnType};`,
+            s `return response as unknown as ${(_c = method.returnType) !== null && _c !== void 0 ? _c : 'unknown'};`,
         ], '\n');
         return method;
     }
     // #endregion
     getSchemaType(ctx, schema, fallback) {
-        const output = schema && ctx.input.models[schema.id];
+        const output = schema && ctx.input.typescript.models[schema.id];
         if (!output)
             return fallback !== null && fallback !== void 0 ? fallback : this.getAnyType(ctx);
         return (b) => b.appendModelUsage(output);
@@ -171,23 +171,26 @@ export class DefaultTypeScriptFetchClientGenerator extends TypeScriptFileGenerat
         return ctx.config.clientFileKind === 'class' || ctx.config.clientFileKind === 'class-and-interface';
     }
     getInterfaceName(ctx) {
-        return toCasing(ctx.service.name, ctx.config.interfaceNameCasing);
+        var _a;
+        return toCasing(ctx.service.name, (_a = ctx.config.clientInterfaceNameCasing) !== null && _a !== void 0 ? _a : ctx.config.typeNameCasing);
     }
     getClassName(ctx) {
-        return toCasing(ctx.service.name, ctx.config.classNameCasing);
+        var _a;
+        return toCasing(ctx.service.name, (_a = ctx.config.clientNameCasing) !== null && _a !== void 0 ? _a : ctx.config.typeNameCasing);
     }
     getDefaultOptionsConstantName(ctx) {
         return toCasing(this.getClassName(ctx) + '-default-options', ctx.config.constantNameCasing);
     }
     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`);
+        return resolve(ctx.config.outputDir, (_a = ctx.config.clientInterfaceDir) !== null && _a !== void 0 ? _a : ctx.config.clientDir, `${toCasing(ctx.service.name, (_b = ctx.config.clientInterfaceFileNameCasing) !== 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`);
+        var _a;
+        return resolve(ctx.config.outputDir, ctx.config.clientDir, `${toCasing(ctx.service.name, (_a = ctx.config.clientFileNameCasing) !== null && _a !== void 0 ? _a : ctx.config.fileNameCasing)}.ts`);
     }
     getUtilPath(ctx, fileName) {
-        return resolve(ctx.config.outputDir, ctx.config.utilsDirPath, fileName);
+        return resolve(ctx.config.outputDir, ctx.config.utilsDir, fileName);
     }
     getResponseSchema(ctx, endpoint) {
         var _a, _b, _c;

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

@@ -6,7 +6,7 @@ import { defaultTypeScriptFetchClientsGeneratorConfig, } from './models';
 import { getReferenceFactories } from './refs';
 import { ts } from '../../../ast';
 import { TypeScriptFileBuilder } from '../../../file-builder';
-export class TypeScriptClientsGenerator extends OpenApiServicesGenerationProviderBase {
+export class TypeScriptFetchClientsGenerator extends OpenApiServicesGenerationProviderBase {
     constructor(clientGeneratorFactory) {
         super();
         this._clientGeneratorFactory =
@@ -14,9 +14,12 @@ export class TypeScriptClientsGenerator extends OpenApiServicesGenerationProvide
     }
     initResult() {
         return {
-            clients: {},
-            indexFiles: {
-                clients: undefined,
+            typescript: {
+                clients: {},
+                indexFiles: {
+                    clients: undefined,
+                    clientInterfaces: undefined,
+                },
             },
         };
     }
@@ -29,15 +32,19 @@ export class TypeScriptClientsGenerator extends OpenApiServicesGenerationProvide
     onGenerate(ctx) {
         this.copyUtilsFiles(ctx);
         const output = super.onGenerate(ctx);
-        output.indexFiles.clients = this.generateIndexFile(ctx);
+        output.typescript.indexFiles.clients = this.generateIndexFile(ctx);
+        output.typescript.indexFiles.clientInterfaces = this.generateInterfaceIndexFile(ctx);
         return output;
     }
     generateService(ctx, service) {
         const clientGenerator = this._clientGeneratorFactory.create();
-        return clientGenerator.generate(Object.assign(Object.assign({}, ctx), { service }));
+        return clientGenerator.generate({
+            ...ctx,
+            service,
+        });
     }
     addServiceResult(ctx, service, result) {
-        ctx.output.clients[service.id] = result;
+        ctx.output.typescript.clients[service.id] = result;
     }
     generateIndexFile(ctx) {
         const filePath = this.getIndexFilePath(ctx);
@@ -49,18 +56,46 @@ export class TypeScriptClientsGenerator extends OpenApiServicesGenerationProvide
         });
         return filePath;
     }
+    generateInterfaceIndexFile(ctx) {
+        const filePath = this.getInterfaceIndexFilePath(ctx);
+        const clientsFilePath = this.getIndexFilePath(ctx);
+        if (filePath && filePath === clientsFilePath) {
+            return clientsFilePath;
+        }
+        TypeScriptFileBuilder.tryGenerate({
+            logName: 'client interfaces index file',
+            filePath,
+            options: ctx.config,
+            generator: (b) => b.append(this.getInterfaceIndexFileContent(ctx)),
+        });
+        return filePath;
+    }
     getIndexFilePath(ctx) {
-        return ctx.config.indexFilePath ? resolve(ctx.config.outputDir, ctx.config.indexFilePath) : null;
+        return ctx.config.clientsIndexFile ? resolve(ctx.config.outputDir, ctx.config.clientsIndexFile) : null;
+    }
+    getInterfaceIndexFilePath(ctx) {
+        return ctx.config.clientInterfacesIndexFile
+            ? resolve(ctx.config.outputDir, ctx.config.clientInterfacesIndexFile)
+            : null;
     }
     getIndexFileContent(ctx) {
-        return appendValueGroup(Object.values(ctx.output.clients)
-            .flatMap((c) => [c.class, c.interface])
+        const cIndexPath = this.getIndexFilePath(ctx);
+        const iIndexPath = this.getInterfaceIndexFilePath(ctx);
+        return appendValueGroup((iIndexPath && iIndexPath === cIndexPath
+            ? Object.values(ctx.output.typescript.clients).flatMap((c) => [c.client, c.clientInterface])
+            : Object.values(ctx.output.typescript.clients).map((c) => c.client))
+            .filter(notNullish)
+            .map((x) => ts.export(x.component, x.filePath)));
+    }
+    getInterfaceIndexFileContent(ctx) {
+        return appendValueGroup(Object.values(ctx.output.typescript.clients)
+            .map((c) => c.clientInterface)
             .filter(notNullish)
             .map((x) => ts.export(x.component, x.filePath)));
     }
     copyUtilsFiles(ctx) {
         const sourceDir = resolve(dirname(require.resolve('@goast/typescript')), '../assets/client/fetch');
-        const targetDir = resolve(ctx.config.outputDir, ctx.config.utilsDirPath);
+        const targetDir = resolve(ctx.config.outputDir, ctx.config.utilsDir);
         ensureDirSync(targetDir);
         const files = readdirSync(sourceDir);
         for (const file of files) {

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

@@ -1,2 +1,14 @@
 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' });
+export const defaultTypeScriptFetchClientsGeneratorConfig = {
+    ...defaultTypeScriptGeneratorConfig,
+    clientFileNameCasing: { casing: 'kebab', suffix: '-client' },
+    clientInterfaceFileNameCasing: undefined,
+    clientNameCasing: { casing: 'pascal', suffix: 'Client' },
+    clientInterfaceNameCasing: { prefix: 'I', casing: 'pascal', suffix: 'Client' },
+    clientFileKind: 'class',
+    clientDir: 'clients',
+    clientInterfaceDir: 'clients/interfaces',
+    clientsIndexFile: 'clients.ts',
+    clientInterfacesIndexFile: 'clients.ts',
+    utilsDir: 'utils',
+};

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

@@ -2,7 +2,7 @@ import { resolve } from 'path';
 import { ts } from '../../../ast';
 // See packages/typescript/assets/client/fetch for reference
 export function getReferenceFactories(options) {
-    const utilsDirPath = resolve(options.outputDir, options.utilsDirPath);
+    const utilsDirPath = resolve(options.outputDir, options.utilsDir);
     const fetchClientUtilsPath = resolve(utilsDirPath, 'fetch-client.utils.ts');
     return {
         // fetch-client.utils.ts

package/esm/lib/import-collection.js

@@ -10,7 +10,7 @@ export class ImportExportCollection {
     constructor(options) {
         this._imports = new Map();
         this._exports = new Map();
-        this._options = Object.assign(Object.assign({}, defaultImportExportCollectionOptions), options);
+        this._options = { ...defaultImportExportCollectionOptions, ...options };
     }
     get hasImports() {
         return this._imports.size > 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goast/typescript",
-  "version": "0.2.20",
+  "version": "0.3.0",
   "repository": "https://github.com/MaSch0212/goast.git",
   "author": {
     "name": "Marc Schmidt (MaSch0212)",
@@ -10,11 +10,12 @@
   "type": "module",
   "dependencies": {
     "fs-extra": "^11.2.0",
-    "node-fetch": "^2.7.0",
-    "yaml": "^2.4.1",
-    "@goast/core": "0.2.2",
-    "tslib": "2.6.2"
+    "node-fetch": "^3.3.2",
+    "yaml": "^2.4.5",
+    "@goast/core": "0.3.0",
+    "tslib": "2.6.3"
   },
+  "packageManager": "pnpm@9.5.0",
   "module": "./esm/index.js",
   "main": "./cjs/index.js",
   "types": "./types/index.d.ts",
@@ -26,4 +27,4 @@
     },
     "./package.json": "./package.json"
   }
-}
+}

package/types/index.d.ts

@@ -1,3 +1,4 @@
+export * from './lib/ast';
 export * from './lib/common-results';
 export * from './lib/config';
 export * from './lib/generators';

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

@@ -11,7 +11,7 @@ export declare class TsArgument<TBuilder extends SourceBuilder, TInjects extends
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-export declare const tsArgument: (<TBuilder extends SourceBuilder<never>>(value: Options<TBuilder>['value'], options?: Prettify<Omit<Options<TBuilder>, 'value'>>) => TsArgument<TBuilder, never>) & {
+export declare const tsArgument: (<TBuilder extends SourceBuilder>(value: Options<TBuilder>["value"], options?: Prettify<Omit<Options<TBuilder>, "value">>) => TsArgument<TBuilder, never>) & {
     write: typeof writeTsParameters;
 };
 export {};

package/types/lib/ast/nodes/array-type.d.ts

@@ -13,7 +13,7 @@ export declare class TsArrayType<TBuilder extends SourceBuilder, TInjects extend
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-export declare const tsArrayType: (<TBuilder extends SourceBuilder<never>>(type: Options<TBuilder>['type'], options?: Prettify<Omit<Options<TBuilder>, 'type'>>) => TsArrayType<TBuilder, never>) & {
+export declare const tsArrayType: (<TBuilder extends SourceBuilder>(type: Options<TBuilder>["type"], options?: Prettify<Omit<Options<TBuilder>, "type">>) => TsArrayType<TBuilder, never>) & {
     write: typeof writeTsNodes;
 };
 export {};

package/types/lib/ast/nodes/arrow-function.d.ts

@@ -23,7 +23,7 @@ export declare class TsArrowFunction<TBuilder extends SourceBuilder, TInjects ex
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-export declare const tsArrowFunction: (<TBuilder extends SourceBuilder<never>>(options?: Options<TBuilder>) => TsArrowFunction<TBuilder, never>) & {
+export declare const tsArrowFunction: (<TBuilder extends SourceBuilder>(options?: Options<TBuilder>) => TsArrowFunction<TBuilder, never>) & {
     write: typeof writeTsNodes;
 };
 export {};

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

@@ -14,7 +14,7 @@ export declare class TsCall<TBuilder extends SourceBuilder, TInjects extends str
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-export declare const tsCall: (<TBuilder extends SourceBuilder<never>>(path: Options<TBuilder>['path'] | ArrayItem<Options<TBuilder>['path']>, args?: Options<TBuilder>['arguments'], options?: Prettify<Omit<Options<TBuilder>, 'path' | 'arguments'>>) => TsCall<TBuilder, never>) & {
+export declare const tsCall: (<TBuilder extends SourceBuilder>(path: Options<TBuilder>["path"] | ArrayItem<Options<TBuilder>["path"]>, args?: Options<TBuilder>["arguments"], options?: Prettify<Omit<Options<TBuilder>, "path" | "arguments">>) => TsCall<TBuilder, never>) & {
     write: typeof writeTsNodes;
 };
 export {};

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

@@ -35,7 +35,7 @@ export declare class TsClass<TBuilder extends SourceBuilder, TInjects extends st
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-export declare const tsClass: (<TBuilder extends SourceBuilder<never>>(name: Options<TBuilder>['name'], options?: Prettify<Omit<Options<TBuilder>, 'name'>>) => TsClass<TBuilder, never>) & {
+export declare const tsClass: (<TBuilder extends SourceBuilder>(name: Options<TBuilder>["name"], options?: Prettify<Omit<Options<TBuilder>, "name">>) => TsClass<TBuilder, never>) & {
     write: typeof writeTsNodes;
 };
 export {};

package/types/lib/ast/nodes/constructor-parameter.d.ts

@@ -13,7 +13,7 @@ export declare class TsConstructorParameter<TBuilder extends SourceBuilder, TInj
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-export declare const tsConstructorParameter: (<TBuilder extends SourceBuilder<never>>(name: Options<TBuilder>['name'], options?: Prettify<Omit<Options<TBuilder>, 'name'>>) => TsConstructorParameter<TBuilder, never>) & {
+export declare const tsConstructorParameter: (<TBuilder extends SourceBuilder>(name: Options<TBuilder>["name"], options?: Prettify<Omit<Options<TBuilder>, "name">>) => TsConstructorParameter<TBuilder, never>) & {
     write: typeof writeTsParameters;
 };
 export {};

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

@@ -19,7 +19,7 @@ export declare class TsConstructor<TBuilder extends SourceBuilder, TInjects exte
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-export declare const tsConstructor: (<TBuilder extends SourceBuilder<never>>(options?: Options<TBuilder>) => TsConstructor<TBuilder, never>) & {
+export declare const tsConstructor: (<TBuilder extends SourceBuilder>(options?: Options<TBuilder>) => TsConstructor<TBuilder, never>) & {
     write: typeof writeTsNodes;
 };
 export {};

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

@@ -14,8 +14,8 @@ export declare class TsDecorator<TBuilder extends SourceBuilder, TInjects extend
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-export declare const tsDecorator: (<TBuilder extends SourceBuilder<never>>(fn: Options<TBuilder>['function'], args?: Options<TBuilder>['arguments'], options?: Prettify<Omit<Options<TBuilder>, 'function' | 'arguments'>>) => TsDecorator<TBuilder, never>) & {
-    write: <TBuilder_1 extends SourceBuilder<never>>(builder: TBuilder_1, nodes: SingleOrMultiple<Nullable<TsDecorator<TBuilder_1, never> | AppendValue<TBuilder_1>>>, options?: {
+export declare const tsDecorator: (<TBuilder extends SourceBuilder>(fn: Options<TBuilder>["function"], args?: Options<TBuilder>["arguments"], options?: Prettify<Omit<Options<TBuilder>, "function" | "arguments">>) => TsDecorator<TBuilder, never>) & {
+    write: <TBuilder extends SourceBuilder>(builder: TBuilder, nodes: SingleOrMultiple<Nullable<TsDecorator<TBuilder> | AppendValue<TBuilder>>>, options?: {
         multiline?: boolean;
     }) => void;
 };

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

@@ -20,7 +20,7 @@ declare function getDoc<TBuilder extends SourceBuilder>(baseDoc: TsDoc<TBuilder>
     generics?: Nullable<Nullable<TsGenericParameter<TBuilder> | BasicAppendValue<TBuilder>>[]>;
 }): TsDoc<TBuilder> | null;
 declare function isDocEmpty(doc: Nullable<TsDoc<SourceBuilder>>): boolean;
-export declare const tsDoc: (<TBuilder extends SourceBuilder<never>>(options?: Options<TBuilder>) => TsDoc<TBuilder, never>) & {
+export declare const tsDoc: (<TBuilder extends SourceBuilder>(options?: Options<TBuilder>) => TsDoc<TBuilder, never>) & {
     write: typeof writeTsNodes;
     get: typeof getDoc;
     isEmpty: typeof isDocEmpty;

package/types/lib/ast/nodes/enum-value.d.ts

@@ -15,7 +15,7 @@ export declare class TsEnumValue<TBuilder extends SourceBuilder, TInjects extend
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-export declare const tsEnumValue: (<TBuilder extends SourceBuilder<never>>(name: Options<TBuilder>['name'], options?: Prettify<Omit<Options<TBuilder>, 'name'>>) => TsEnumValue<TBuilder, never>) & {
-    write: <TBuilder_1 extends SourceBuilder<never>>(builder: TBuilder_1, nodes: SingleOrMultiple<Nullable<TsEnumValue<TBuilder_1, never> | AppendValue<TBuilder_1>>>) => void;
+export declare const tsEnumValue: (<TBuilder extends SourceBuilder>(name: Options<TBuilder>["name"], options?: Prettify<Omit<Options<TBuilder>, "name">>) => TsEnumValue<TBuilder, never>) & {
+    write: <TBuilder extends SourceBuilder>(builder: TBuilder, nodes: SingleOrMultiple<Nullable<TsEnumValue<TBuilder> | AppendValue<TBuilder>>>) => void;
 };
 export {};

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

@@ -20,7 +20,7 @@ export declare class TsEnum<TBuilder extends SourceBuilder, TInjects extends str
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-export declare const tsEnum: (<TBuilder extends SourceBuilder<never>>(name: Options<TBuilder>['name'], options?: Prettify<Omit<Options<TBuilder>, 'name'>>) => TsEnum<TBuilder, never>) & {
+export declare const tsEnum: (<TBuilder extends SourceBuilder>(name: Options<TBuilder>["name"], options?: Prettify<Omit<Options<TBuilder>, "name">>) => TsEnum<TBuilder, never>) & {
     write: typeof writeTsNodes;
 };
 export {};

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

@@ -12,8 +12,8 @@ export declare class TsExport<TBuilder extends SourceBuilder, TInjects extends s
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-export declare const createExport: <TBuilder extends SourceBuilder<never>>(name: Options<TBuilder>['name'], filePath: Options<TBuilder>['filePath'], options?: Prettify<Omit<Options<TBuilder>, 'name' | 'filePath'>>) => TsExport<TBuilder, never>;
-export declare const tsExport: (<TBuilder extends SourceBuilder<never>>(name: Options<TBuilder>['name'], filePath: Options<TBuilder>['filePath'], options?: Prettify<Omit<Options<TBuilder>, 'name' | 'filePath'>>) => TsExport<TBuilder, never>) & {
+export declare const createExport: <TBuilder extends SourceBuilder>(name: Options<TBuilder>["name"], filePath: Options<TBuilder>["filePath"], options?: Prettify<Omit<Options<TBuilder>, "name" | "filePath">>) => TsExport<TBuilder, never>;
+export declare const tsExport: (<TBuilder extends SourceBuilder>(name: Options<TBuilder>["name"], filePath: Options<TBuilder>["filePath"], options?: Prettify<Omit<Options<TBuilder>, "name" | "filePath">>) => TsExport<TBuilder, never>) & {
     write: typeof writeTsNodes;
 };
 export {};

package/types/lib/ast/nodes/function-type.d.ts

@@ -17,7 +17,7 @@ export declare class TsFunctionType<TBuilder extends SourceBuilder, TInjects ext
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-export declare const tsFunctionType: (<TBuilder extends SourceBuilder<never>>(options?: Options<TBuilder>) => TsFunctionType<TBuilder, never>) & {
+export declare const tsFunctionType: (<TBuilder extends SourceBuilder>(options?: Options<TBuilder>) => TsFunctionType<TBuilder, never>) & {
     write: typeof writeTsNodes;
 };
 export {};

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

@@ -29,7 +29,7 @@ export declare class TsFunction<TBuilder extends SourceBuilder, TInjects extends
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-export declare const tsFunction: (<TBuilder extends SourceBuilder<never>>(name: Options<TBuilder>['name'], options?: Prettify<Omit<Options<TBuilder>, 'name'>>) => TsFunction<TBuilder, never>) & {
+export declare const tsFunction: (<TBuilder extends SourceBuilder>(name: Options<TBuilder>["name"], options?: Prettify<Omit<Options<TBuilder>, "name">>) => TsFunction<TBuilder, never>) & {
     write: typeof writeTsNodes;
 };
 export {};

package/types/lib/ast/nodes/generic-parameter.d.ts

@@ -19,7 +19,7 @@ export declare class TsGenericParameter<TBuilder extends SourceBuilder, TInjects
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-export declare const tsGenericParameter: (<TBuilder extends SourceBuilder<never>>(name: Options<TBuilder>['name'], options?: Prettify<Omit<Options<TBuilder>, 'name'>>) => TsGenericParameter<TBuilder, never>) & {
+export declare const tsGenericParameter: (<TBuilder extends SourceBuilder>(name: Options<TBuilder>["name"], options?: Prettify<Omit<Options<TBuilder>, "name">>) => TsGenericParameter<TBuilder, never>) & {
     write: typeof writeTsGenericParameters;
 };
 export {};

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

@@ -17,7 +17,7 @@ export declare class TsIndexer<TBuilder extends SourceBuilder, TInjects extends
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-export declare const tsIndexer: (<TBuilder extends SourceBuilder<never>>(keyType: Options<TBuilder>['keyType'], valueType: Options<TBuilder>['valueType'], options?: Prettify<Omit<Options<TBuilder>, 'keyType' | 'valueType'>>) => TsIndexer<TBuilder, never>) & {
+export declare const tsIndexer: (<TBuilder extends SourceBuilder>(keyType: Options<TBuilder>["keyType"], valueType: Options<TBuilder>["valueType"], options?: Prettify<Omit<Options<TBuilder>, "keyType" | "valueType">>) => TsIndexer<TBuilder, never>) & {
     write: typeof writeTsNodes;
 };
 export {};

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

@@ -30,7 +30,7 @@ export declare class TsInterface<TBuilder extends SourceBuilder, TInjects extend
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-export declare const tsInterface: (<TBuilder extends SourceBuilder<never>>(name: Options<TBuilder>['name'], options?: Prettify<Omit<Options<TBuilder>, 'name'>>) => TsInterface<TBuilder, never>) & {
+export declare const tsInterface: (<TBuilder extends SourceBuilder>(name: Options<TBuilder>["name"], options?: Prettify<Omit<Options<TBuilder>, "name">>) => TsInterface<TBuilder, never>) & {
     write: typeof writeTsNodes;
 };
 export {};

package/types/lib/ast/nodes/intersection-type.d.ts

@@ -11,7 +11,7 @@ export declare class TsIntersectionType<TBuilder extends SourceBuilder, TInjects
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-export declare const tsIntersectionType: (<TBuilder extends SourceBuilder<never>>(types: Options<TBuilder>['types'], options?: Prettify<Omit<Options<TBuilder>, 'types'>>) => TsIntersectionType<TBuilder, never>) & {
+export declare const tsIntersectionType: (<TBuilder extends SourceBuilder>(types: Options<TBuilder>["types"], options?: Prettify<Omit<Options<TBuilder>, "types">>) => TsIntersectionType<TBuilder, never>) & {
     write: typeof writeTsNodes;
 };
 export {};

package/types/lib/ast/nodes/lookup-type.d.ts

@@ -13,7 +13,7 @@ export declare class TsLookupType<TBuilder extends SourceBuilder, TInjects exten
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-export declare const tsLookupType: (<TBuilder extends SourceBuilder<never>>(type: Options<TBuilder>['type'], index: Options<TBuilder>['index'], options?: Omit<Options<TBuilder>, 'type' | 'index'>) => TsLookupType<TBuilder, never>) & {
+export declare const tsLookupType: (<TBuilder extends SourceBuilder>(type: Options<TBuilder>["type"], index: Options<TBuilder>["index"], options?: Omit<Options<TBuilder>, "type" | "index">) => TsLookupType<TBuilder, never>) & {
     write: typeof writeTsNodes;
 };
 export {};

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

@@ -38,8 +38,8 @@ export declare class TsMethod<TBuilder extends SourceBuilder, TInjects extends s
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-export declare const createMethod: <TBuilder extends SourceBuilder<never>>(name: Options<TBuilder>['name'], options?: Prettify<Omit<Options<TBuilder>, 'name'>>) => TsMethod<TBuilder, never>;
-export declare const tsMethod: (<TBuilder extends SourceBuilder<never>>(name: Options<TBuilder>['name'], options?: Prettify<Omit<Options<TBuilder>, 'name'>>) => TsMethod<TBuilder, never>) & {
+export declare const createMethod: <TBuilder extends SourceBuilder>(name: Options<TBuilder>["name"], options?: Prettify<Omit<Options<TBuilder>, "name">>) => TsMethod<TBuilder, never>;
+export declare const tsMethod: (<TBuilder extends SourceBuilder>(name: Options<TBuilder>["name"], options?: Prettify<Omit<Options<TBuilder>, "name">>) => TsMethod<TBuilder, never>) & {
     write: typeof writeTsNodes;
 };
 export {};

package/types/lib/ast/nodes/object-type.d.ts

@@ -14,7 +14,7 @@ export declare class TsObjectType<TBuilder extends SourceBuilder, TInjects exten
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-export declare const tsObjectType: (<TBuilder extends SourceBuilder<never>>(options?: Options<TBuilder>) => TsObjectType<TBuilder, never>) & {
+export declare const tsObjectType: (<TBuilder extends SourceBuilder>(options?: Options<TBuilder>) => TsObjectType<TBuilder, never>) & {
     write: typeof writeTsNodes;
 };
 export {};

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

@@ -13,7 +13,7 @@ export declare class TsObject<TBuilder extends SourceBuilder, TInjects extends s
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-export declare const tsObject: (<TBuilder extends SourceBuilder<never>>(options?: Options<TBuilder>) => TsObject<TBuilder, never>) & {
+export declare const tsObject: (<TBuilder extends SourceBuilder>(options?: Options<TBuilder>) => TsObject<TBuilder, never>) & {
     write: typeof writeTsNodes;
 };
 export {};

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

@@ -22,7 +22,7 @@ export declare class TsParameter<TBuilder extends SourceBuilder, TInjects extend
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-export declare const tsParameter: (<TBuilder extends SourceBuilder<never>>(name: Options<TBuilder>['name'], options?: Prettify<Omit<Options<TBuilder>, 'name'>>) => TsParameter<TBuilder, never>) & {
+export declare const tsParameter: (<TBuilder extends SourceBuilder>(name: Options<TBuilder>["name"], options?: Prettify<Omit<Options<TBuilder>, "name">>) => TsParameter<TBuilder, never>) & {
     write: typeof writeTsParameters;
 };
 export {};

package/types/lib/ast/nodes/property-accessor.d.ts

@@ -48,6 +48,6 @@ export declare class TsPropertySetter<TBuilder extends SourceBuilder, TInjects e
 export declare class TsPropertyGetter<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsPropertyAccessor<TBuilder, TInjects> {
     protected onWrite(builder: TBuilder): void;
 }
-export declare const createPropertySetter: <TBuilder extends SourceBuilder<never>>(options?: Options<TBuilder>) => TsPropertySetter<TBuilder, never>;
-export declare const createPropertyGetter: <TBuilder extends SourceBuilder<never>>(options?: Options<TBuilder>) => TsPropertyGetter<TBuilder, never>;
+export declare const createPropertySetter: <TBuilder extends SourceBuilder>(options?: Options<TBuilder>) => TsPropertySetter<TBuilder, never>;
+export declare const createPropertyGetter: <TBuilder extends SourceBuilder>(options?: Options<TBuilder>) => TsPropertyGetter<TBuilder, never>;
 export {};

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

@@ -54,31 +54,31 @@ export declare class TsAccessorProperty<TBuilder extends SourceBuilder, TInjects
     constructor(options: AccessorOptions<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-export declare const tsProperty: (<TBuilder extends SourceBuilder<never>>(name: BaseOptions<TBuilder>['name'], options?: Prettify<Omit<SimpleOptions<TBuilder>, 'name'>> | Prettify<Omit<AccessorOptions<TBuilder>, 'name'>>) => TsAccessorProperty<TBuilder, ""> | TsSimpleProperty<TBuilder, "">) & {
+export declare const tsProperty: (<TBuilder extends SourceBuilder>(name: BaseOptions<TBuilder>["name"], options?: Prettify<Omit<SimpleOptions<TBuilder>, "name">> | Prettify<Omit<AccessorOptions<TBuilder>, "name">>) => TsAccessorProperty<TBuilder, ""> | TsSimpleProperty<TBuilder, "">) & {
     write: typeof writeTsNodes;
-    getter: <TBuilder_1 extends SourceBuilder<never>>(options?: {
+    getter: <TBuilder extends SourceBuilder>(options?: {
         propertyName?: Nullable<string>;
-        doc?: Nullable<TsDoc<TBuilder_1, never>>;
-        type?: Nullable<TsType<TBuilder_1>>;
-        decorators?: Nullable<Nullable<TsDecorator<TBuilder_1, never>>[]>;
-        body?: Nullable<import("@goast/core").AppendValue<TBuilder_1>>;
+        doc?: Nullable<TsDoc<TBuilder, never>>;
+        type?: Nullable<TsType<TBuilder>>;
+        decorators?: Nullable<Nullable<TsDecorator<TBuilder, never>>[]>;
+        body?: Nullable<import("@goast/core").AppendValue<TBuilder>>;
         accessModifier?: Nullable<TsAccessModifier>;
         static?: Nullable<boolean>;
         abstract?: Nullable<boolean>;
         override?: Nullable<boolean>;
-        inject?: import("@goast/core").AstNodeInject<TBuilder_1, ""> | undefined;
-    } | undefined) => TsPropertyGetter<TBuilder_1, never>;
-    setter: <TBuilder_2 extends SourceBuilder<never>>(options?: {
+        inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+    }) => TsPropertyGetter<TBuilder, never>;
+    setter: <TBuilder extends SourceBuilder>(options?: {
         propertyName?: Nullable<string>;
-        doc?: Nullable<TsDoc<TBuilder_2, never>>;
-        type?: Nullable<TsType<TBuilder_2>>;
-        decorators?: Nullable<Nullable<TsDecorator<TBuilder_2, never>>[]>;
-        body?: Nullable<import("@goast/core").AppendValue<TBuilder_2>>;
+        doc?: Nullable<TsDoc<TBuilder, never>>;
+        type?: Nullable<TsType<TBuilder>>;
+        decorators?: Nullable<Nullable<TsDecorator<TBuilder, never>>[]>;
+        body?: Nullable<import("@goast/core").AppendValue<TBuilder>>;
         accessModifier?: Nullable<TsAccessModifier>;
         static?: Nullable<boolean>;
         abstract?: Nullable<boolean>;
         override?: Nullable<boolean>;
-        inject?: import("@goast/core").AstNodeInject<TBuilder_2, ""> | undefined;
-    } | undefined) => TsPropertySetter<TBuilder_2, never>;
+        inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+    }) => TsPropertySetter<TBuilder, never>;
 };
 export {};