@goast/kotlin 0.2.8 → 0.3.0

package/esm/lib/generators/services/spring-controllers/spring-controllers-generator.js

@@ -9,15 +9,20 @@ export class KotlinSpringControllersGenerator extends OpenApiServicesGenerationP
     }
     initResult() {
         return {
-            services: {},
+            kotlin: {
+                services: {},
+            },
         };
     }
     generateService(ctx, service) {
         const serviceGenerator = this._serviceGeneratorFactory.create();
-        return serviceGenerator.generate(Object.assign(Object.assign({}, ctx), { service }));
+        return serviceGenerator.generate({
+            ...ctx,
+            service,
+        });
     }
     addServiceResult(ctx, service, result) {
-        ctx.output.services[service.id] = result;
+        ctx.output.kotlin.services[service.id] = result;
     }
     buildContext(context, config) {
         context.data.services = context.data.services.filter((x) => x.name !== 'exclude-from-generation');

package/esm/lib/import-collection.js

@@ -6,7 +6,7 @@ export const defaultImportCollectionOptions = {
 export class ImportCollection {
     constructor(options = {}) {
         this._imports = new Map();
-        this._options = Object.assign(Object.assign({}, defaultImportCollectionOptions), options);
+        this._options = { ...defaultImportCollectionOptions, ...options };
     }
     get hasImports() {
         return this._imports.size > 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goast/kotlin",
-  "version": "0.2.8",
+  "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

@@ -5,4 +5,3 @@ export * from './lib/file-builder';
 export * from './lib/import-collection';
 export * from './lib/utils';
 export * from './lib/ast';
-export * as kt from './lib/ast/references';

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

@@ -17,7 +17,7 @@ export declare class KtAnnotation<TBuilder extends SourceBuilder, TInjects exten
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-export declare const ktAnnotation: (<TBuilder extends SourceBuilder<never>>($class: Options<TBuilder>['class'], $arguments?: Options<TBuilder>['arguments'], options?: Prettify<Omit<Options<TBuilder>, 'class' | 'arguments'>>) => KtAnnotation<TBuilder, never>) & {
+export declare const ktAnnotation: (<TBuilder extends SourceBuilder>($class: Options<TBuilder>["class"], $arguments?: Options<TBuilder>["arguments"], options?: Prettify<Omit<Options<TBuilder>, "class" | "arguments">>) => KtAnnotation<TBuilder, never>) & {
     write: typeof writeKtAnnotations;
 };
 export {};

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

@@ -13,10 +13,8 @@ export declare class KtArgument<TBuilder extends SourceBuilder, TInjects extends
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-export declare const ktArgument: (<TBuilder extends SourceBuilder<never>>(value: Options<TBuilder>['value'], options?: Prettify<Omit<Options<TBuilder>, 'value'>>) => KtArgument<TBuilder, never>) & {
-    named: <TBuilder_1 extends SourceBuilder<never>>(name: Nullable<string>, value: KtValue<TBuilder_1>, options?: {
-        inject?: import("@goast/core").AstNodeInject<TBuilder_1, "" | Injects> | undefined;
-    } | undefined) => KtArgument<TBuilder_1, never>;
+export declare const ktArgument: (<TBuilder extends SourceBuilder>(value: Options<TBuilder>["value"], options?: Prettify<Omit<Options<TBuilder>, "value">>) => KtArgument<TBuilder, never>) & {
+    named: <TBuilder extends SourceBuilder>(name: Options<TBuilder>["name"], value: Options<TBuilder>["value"], options?: Prettify<Omit<Options<TBuilder>, "value" | "name">>) => KtArgument<TBuilder, never>;
     write: typeof writeKtArguments;
 };
 export {};

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

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

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

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

package/types/lib/ast/nodes/collection-literal.d.ts

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

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

@@ -28,7 +28,7 @@ export declare class KtConstructor<TBuilder extends SourceBuilder, TInjects exte
     writeAsPrimary(builder: TBuilder): void;
     protected onWriteAsPrimary(builder: TBuilder): void;
 }
-export declare const ktConstructor: (<TBuilder extends SourceBuilder<never>>(parameters?: Options<TBuilder>['parameters'], body?: Options<TBuilder>['body'], options?: Prettify<Omit<Options<TBuilder>, 'parameters' | 'body'>>) => KtConstructor<TBuilder, never>) & {
+export declare const ktConstructor: (<TBuilder extends SourceBuilder>(parameters?: Options<TBuilder>["parameters"], body?: Options<TBuilder>["body"], options?: Prettify<Omit<Options<TBuilder>, "parameters" | "body">>) => KtConstructor<TBuilder, never>) & {
     write: typeof writeKtNodes;
 };
 export {};

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

@@ -29,6 +29,6 @@ type _KtDocTagArgsMap<TBuilder extends SourceBuilder> = {
 type _KtDocTagArgs<TTagName extends StringSuggestions<keyof _KtDocTagArgsMap<TBuilder>>, TBuilder extends SourceBuilder> = TTagName extends keyof _KtDocTagArgsMap<TBuilder> ? _KtDocTagArgsMap<TBuilder>[TTagName] extends (...args: any[]) => any ? ParametersWithOverloads<_KtDocTagArgsMap<TBuilder>[TTagName]> : never : [options?: _KtDocTagOpt<TBuilder>];
 declare function createDocTag<TTagName extends StringSuggestions<keyof _KtDocTagArgsMap<TBuilder>>, TBuilder extends SourceBuilder>(tag: TTagName, ...args: _KtDocTagArgs<TTagName, TBuilder>): KtDocTag<TBuilder>;
 export declare const ktDocTag: typeof createDocTag & {
-    write: <TBuilder extends SourceBuilder<never>>(builder: TBuilder, nodes: SingleOrMultiple<Nullable<KtAppendValue<TBuilder>>>) => void;
+    write: <TBuilder extends SourceBuilder>(builder: TBuilder, nodes: SingleOrMultiple<Nullable<KtAppendValue<TBuilder>>>) => void;
 };
 export {};

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

@@ -19,7 +19,7 @@ declare function getDoc<TBuilder extends SourceBuilder>(baseDoc: KtDoc<TBuilder>
     parameters?: Nullable<Nullable<KtParameter<TBuilder> | BasicAppendValue<TBuilder>>[]>;
     generics?: Nullable<Nullable<KtGenericParameter<TBuilder> | BasicAppendValue<TBuilder>>[]>;
 }): KtDoc<TBuilder> | null;
-export declare const ktDoc: (<TBuilder extends SourceBuilder<never>>(description?: Options<TBuilder>['description'], tags?: Options<TBuilder>['tags'], options?: Prettify<Omit<Options<TBuilder>, 'description' | 'tags'>>) => KtDoc<TBuilder, never>) & {
+export declare const ktDoc: (<TBuilder extends SourceBuilder>(description?: Options<TBuilder>["description"], tags?: Options<TBuilder>["tags"], options?: Prettify<Omit<Options<TBuilder>, "description" | "tags">>) => KtDoc<TBuilder, never>) & {
     write: typeof writeKtNodes;
     get: typeof getDoc;
 };

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

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

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

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

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

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

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

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

package/types/lib/ast/nodes/init-block.d.ts

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

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

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

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

@@ -15,7 +15,7 @@ export declare class KtLambdaType<TBuilder extends SourceBuilder, TInjects exten
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-export declare const ktLambdaType: (<TBuilder extends SourceBuilder<never>>(parameters: Options<TBuilder>['parameters'], returnType: Options<TBuilder>['returnType'], options?: Omit<Options<TBuilder>, 'parameters' | 'returnType'>) => KtLambdaType<TBuilder, never>) & {
+export declare const ktLambdaType: (<TBuilder extends SourceBuilder>(parameters: Options<TBuilder>["parameters"], returnType: Options<TBuilder>["returnType"], options?: Omit<Options<TBuilder>, "parameters" | "returnType">) => KtLambdaType<TBuilder, never>) & {
     write: typeof writeKtNodes;
 };
 export {};

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

@@ -14,7 +14,7 @@ export declare class KtLambda<TBuilder extends SourceBuilder, TInjects extends s
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-export declare const ktLambda: (<TBuilder extends SourceBuilder<never>>(args: Options<TBuilder>['arguments'], body: Options<TBuilder>['body'], options?: Omit<Options<TBuilder>, 'arguments' | 'body'>) => KtLambda<TBuilder, never>) & {
+export declare const ktLambda: (<TBuilder extends SourceBuilder>(args: Options<TBuilder>["arguments"], body: Options<TBuilder>["body"], options?: Omit<Options<TBuilder>, "arguments" | "body">) => KtLambda<TBuilder, never>) & {
     write: typeof writeKtNodes;
 };
 export {};

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

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

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

@@ -31,18 +31,8 @@ export declare class KtParameter<TBuilder extends SourceBuilder, TInjects extend
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-export declare const ktParameter: (<TBuilder extends SourceBuilder<never>>(name: KtParameter<TBuilder>['name'], type: KtParameter<TBuilder>['type'], options?: Prettify<Omit<Options<TBuilder>, 'name' | 'type' | 'accessModifier' | 'property' | 'propertyDescription' | 'override'>>) => KtParameter<TBuilder, never>) & {
-    class: <TBuilder_1 extends SourceBuilder<never>>(name: string, type: KtType<TBuilder_1>, options?: {
-        default?: Nullable<KtValue<TBuilder_1>>;
-        description?: Nullable<BasicAppendValue<TBuilder_1>>;
-        inject?: import("@goast/core").AstNodeInject<TBuilder_1, "" | Injects> | undefined;
-        annotations?: Nullable<Nullable<KtAnnotation<TBuilder_1, never>>[]>;
-        property?: Nullable<'readonly' | 'mutable'>;
-        vararg?: Nullable<boolean>;
-        accessModifier?: Nullable<KtAccessModifier>;
-        propertyDescription?: Nullable<BasicAppendValue<TBuilder_1>>;
-        override?: Nullable<boolean>;
-    } | undefined) => KtParameter<TBuilder_1, never>;
+export declare const ktParameter: (<TBuilder extends SourceBuilder>(name: KtParameter<TBuilder>["name"], type: KtParameter<TBuilder>["type"], options?: Prettify<Omit<Options<TBuilder>, "name" | "type" | "accessModifier" | "property" | "propertyDescription" | "override">>) => KtParameter<TBuilder, never>) & {
+    class: <TBuilder extends SourceBuilder>(name: KtParameter<TBuilder>["name"], type: KtParameter<TBuilder>["type"], options?: Prettify<Omit<Options<TBuilder>, "name" | "type">>) => KtParameter<TBuilder, never>;
     write: typeof writeKtParameters;
 };
 export {};

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

@@ -67,21 +67,9 @@ export declare class KtProperty<TBuilder extends SourceBuilder, TInjects extends
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-export declare const ktProperty: (<TBuilder extends SourceBuilder<never>>(name: Options<TBuilder>['name'], options?: Prettify<Omit<Options<TBuilder>, 'name'>>) => KtProperty<TBuilder, never>) & {
-    getter: <TBuilder_1 extends SourceBuilder<never>>(options?: {
-        accessModifier?: Nullable<KtAccessModifier>;
-        annotations?: Nullable<Nullable<KtAnnotation<TBuilder_1, never>>[]>;
-        body?: Nullable<AppendValue<TBuilder_1>>;
-        singleExpression?: Nullable<boolean>;
-        inject?: import("@goast/core").AstNodeInject<TBuilder_1, "" | AccessorInjects> | undefined;
-    } | undefined) => KtPropertyGetter<TBuilder_1>;
-    setter: <TBuilder_2 extends SourceBuilder<never>>(options?: {
-        accessModifier?: Nullable<KtAccessModifier>;
-        annotations?: Nullable<Nullable<KtAnnotation<TBuilder_2, never>>[]>;
-        body?: Nullable<AppendValue<TBuilder_2>>;
-        singleExpression?: Nullable<boolean>;
-        inject?: import("@goast/core").AstNodeInject<TBuilder_2, "" | AccessorInjects> | undefined;
-    } | undefined) => KtPropertySetter<TBuilder_2>;
+export declare const ktProperty: (<TBuilder extends SourceBuilder>(name: Options<TBuilder>["name"], options?: Prettify<Omit<Options<TBuilder>, "name">>) => KtProperty<TBuilder, never>) & {
+    getter: <TBuilder extends SourceBuilder>(options?: AccessorOptions<TBuilder>) => KtPropertyGetter<TBuilder>;
+    setter: <TBuilder extends SourceBuilder>(options?: AccessorOptions<TBuilder>) => KtPropertySetter<TBuilder>;
     write: typeof writeKtNodes;
 };
 export {};

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

@@ -29,35 +29,19 @@ export declare class KtReference<TBuilder extends SourceBuilder, TInjects extend
     protected onWrite(builder: TBuilder): void;
     static registerAddImportHandler<TBuilder extends SourceBuilder>(builderClass: _AddImportHandler<TBuilder>['builderClass'], handler: _AddImportHandler<TBuilder>['handler']): void;
 }
-export declare const ktReference: (<TBuilder extends SourceBuilder<never>>(name: Options<TBuilder>['name'], packageName?: Options<TBuilder>['packageName'], options?: Prettify<Omit<Options<TBuilder>, 'name' | 'packageName'>>) => KtReference<TBuilder, never>) & {
-    factory: (name: string, packageName?: Nullable<string>) => (<TBuilder_1 extends SourceBuilder<never>>(options?: {
-        nullable?: Nullable<boolean>;
-        inject?: import("@goast/core").AstNodeInject<TBuilder_1, ""> | undefined;
-        generics?: Nullable<Nullable<KtType<TBuilder_1>>[]>;
-        classReference?: Nullable<boolean>;
-        subReference?: Nullable<KtReference<TBuilder_1, never> | KtCall<TBuilder_1, never>>;
-    } | undefined) => KtReference<TBuilder_1, never>) & {
+export declare const ktReference: (<TBuilder extends SourceBuilder>(name: Options<TBuilder>["name"], packageName?: Options<TBuilder>["packageName"], options?: Prettify<Omit<Options<TBuilder>, "name" | "packageName">>) => KtReference<TBuilder, never>) & {
+    factory: (name: string, packageName?: Nullable<string>) => (<TBuilder extends SourceBuilder>(options?: Prettify<Omit<Options<TBuilder>, "name" | "packageName">>) => KtReference<TBuilder, never>) & {
         refName: string;
         packageName: Nullable<string>;
-        matches: (value: unknown) => value is KtReference<never, never>;
+        matches: (value: unknown) => value is KtReference<never>;
     };
-    genericFactory: <TGenericCount extends number | number[]>(name: string, packageName?: Nullable<string>) => (<TBuilder_2 extends SourceBuilder<never>>(generics: TupleWithCount<KtType<TBuilder_2>, TGenericCount>, options?: {
-        nullable?: Nullable<boolean>;
-        inject?: import("@goast/core").AstNodeInject<TBuilder_2, ""> | undefined;
-        classReference?: Nullable<boolean>;
-        subReference?: Nullable<KtReference<TBuilder_2, never> | KtCall<TBuilder_2, never>>;
-    } | undefined) => KtReference<TBuilder_2, never>) & {
+    genericFactory: <TGenericCount extends number | number[]>(name: string, packageName?: Nullable<string>) => (<TBuilder extends SourceBuilder>(generics: TupleWithCount<KtType<TBuilder>, TGenericCount>, options?: Prettify<Omit<Options<TBuilder>, "name" | "packageName" | "generics">>) => KtReference<TBuilder, never>) & {
         refName: string;
         packageName: Nullable<string>;
-        infer: <TBuilder_3 extends SourceBuilder<never>>(options?: {
-            nullable?: Nullable<boolean>;
-            inject?: import("@goast/core").AstNodeInject<TBuilder_3, ""> | undefined;
-            classReference?: Nullable<boolean>;
-            subReference?: Nullable<KtReference<TBuilder_3, never> | KtCall<TBuilder_3, never>>;
-        } | undefined) => KtReference<TBuilder_3, never>;
-        matches: (value: unknown) => value is KtReference<never, never>;
+        infer: <TBuilder extends SourceBuilder>(options?: Prettify<Omit<Options<TBuilder>, "name" | "packageName" | "generics">>) => KtReference<TBuilder, never>;
+        matches: (value: unknown) => value is KtReference<never>;
     };
     write: typeof writeKtNodes;
-    import: <TBuilder_4 extends SourceBuilder<never>>(builder: TBuilder_4, references: KtReference<TBuilder_4, never>[]) => void;
+    import: <TBuilder extends SourceBuilder>(builder: TBuilder, references: KtReference<TBuilder>[]) => void;
 };
 export {};

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

@@ -24,7 +24,7 @@ export declare class KtString<TBuilder extends SourceBuilder, TInjects extends s
         index: number;
     }[];
 }
-export declare const ktString: (<TBuilder extends SourceBuilder<never>>(value: Options<TBuilder>['value'], options?: Prettify<Omit<Options<TBuilder>, 'value'>>) => KtString<TBuilder, never>) & {
+export declare const ktString: (<TBuilder extends SourceBuilder>(value: Options<TBuilder>["value"], options?: Prettify<Omit<Options<TBuilder>, "value">>) => KtString<TBuilder, never>) & {
     write: typeof writeKtNodes;
 };
 export {};

package/types/lib/ast/references/jackson.d.ts

@@ -1,77 +1,91 @@
-export declare const jsonTypeInfo: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(options?: {
-    nullable?: import("@goast/core").Nullable<boolean>;
-    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+export declare const jsonTypeInfo: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: import("@goast/core").Prettify<Omit<{
+    name: string;
+    packageName?: import("@goast/core").Nullable<string>;
     generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index").Type<TBuilder>>[]>;
+    nullable?: import("@goast/core").Nullable<boolean>;
     classReference?: import("@goast/core").Nullable<boolean>;
     subReference?: import("@goast/core").Nullable<import("../nodes/reference").KtReference<TBuilder, never> | import("../_index").Call<TBuilder, never>>;
-} | undefined) => import("../nodes/reference").KtReference<TBuilder, never>) & {
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+}, "name" | "packageName">>) => import("../nodes/reference").KtReference<TBuilder, never>) & {
     refName: string;
     packageName: import("@goast/core").Nullable<string>;
-    matches: (value: unknown) => value is import("../nodes/reference").KtReference<never, never>;
+    matches: (value: unknown) => value is import("../nodes/reference").KtReference<never>;
 };
-export declare const jsonSubTypes: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(options?: {
-    nullable?: import("@goast/core").Nullable<boolean>;
-    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+export declare const jsonSubTypes: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: import("@goast/core").Prettify<Omit<{
+    name: string;
+    packageName?: import("@goast/core").Nullable<string>;
     generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index").Type<TBuilder>>[]>;
+    nullable?: import("@goast/core").Nullable<boolean>;
     classReference?: import("@goast/core").Nullable<boolean>;
     subReference?: import("@goast/core").Nullable<import("../nodes/reference").KtReference<TBuilder, never> | import("../_index").Call<TBuilder, never>>;
-} | undefined) => import("../nodes/reference").KtReference<TBuilder, never>) & {
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+}, "name" | "packageName">>) => import("../nodes/reference").KtReference<TBuilder, never>) & {
     refName: string;
     packageName: import("@goast/core").Nullable<string>;
-    matches: (value: unknown) => value is import("../nodes/reference").KtReference<never, never>;
+    matches: (value: unknown) => value is import("../nodes/reference").KtReference<never>;
 };
-export declare const jsonProperty: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(options?: {
-    nullable?: import("@goast/core").Nullable<boolean>;
-    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+export declare const jsonProperty: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: import("@goast/core").Prettify<Omit<{
+    name: string;
+    packageName?: import("@goast/core").Nullable<string>;
     generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index").Type<TBuilder>>[]>;
+    nullable?: import("@goast/core").Nullable<boolean>;
     classReference?: import("@goast/core").Nullable<boolean>;
     subReference?: import("@goast/core").Nullable<import("../nodes/reference").KtReference<TBuilder, never> | import("../_index").Call<TBuilder, never>>;
-} | undefined) => import("../nodes/reference").KtReference<TBuilder, never>) & {
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+}, "name" | "packageName">>) => import("../nodes/reference").KtReference<TBuilder, never>) & {
     refName: string;
     packageName: import("@goast/core").Nullable<string>;
-    matches: (value: unknown) => value is import("../nodes/reference").KtReference<never, never>;
+    matches: (value: unknown) => value is import("../nodes/reference").KtReference<never>;
 };
-export declare const jsonInclude: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(options?: {
-    nullable?: import("@goast/core").Nullable<boolean>;
-    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+export declare const jsonInclude: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: import("@goast/core").Prettify<Omit<{
+    name: string;
+    packageName?: import("@goast/core").Nullable<string>;
     generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index").Type<TBuilder>>[]>;
+    nullable?: import("@goast/core").Nullable<boolean>;
     classReference?: import("@goast/core").Nullable<boolean>;
     subReference?: import("@goast/core").Nullable<import("../nodes/reference").KtReference<TBuilder, never> | import("../_index").Call<TBuilder, never>>;
-} | undefined) => import("../nodes/reference").KtReference<TBuilder, never>) & {
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+}, "name" | "packageName">>) => import("../nodes/reference").KtReference<TBuilder, never>) & {
     refName: string;
     packageName: import("@goast/core").Nullable<string>;
-    matches: (value: unknown) => value is import("../nodes/reference").KtReference<never, never>;
+    matches: (value: unknown) => value is import("../nodes/reference").KtReference<never>;
 };
-export declare const jsonIgnore: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(options?: {
-    nullable?: import("@goast/core").Nullable<boolean>;
-    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+export declare const jsonIgnore: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: import("@goast/core").Prettify<Omit<{
+    name: string;
+    packageName?: import("@goast/core").Nullable<string>;
     generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index").Type<TBuilder>>[]>;
+    nullable?: import("@goast/core").Nullable<boolean>;
     classReference?: import("@goast/core").Nullable<boolean>;
     subReference?: import("@goast/core").Nullable<import("../nodes/reference").KtReference<TBuilder, never> | import("../_index").Call<TBuilder, never>>;
-} | undefined) => import("../nodes/reference").KtReference<TBuilder, never>) & {
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+}, "name" | "packageName">>) => import("../nodes/reference").KtReference<TBuilder, never>) & {
     refName: string;
     packageName: import("@goast/core").Nullable<string>;
-    matches: (value: unknown) => value is import("../nodes/reference").KtReference<never, never>;
+    matches: (value: unknown) => value is import("../nodes/reference").KtReference<never>;
 };
-export declare const jsonAnySetter: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(options?: {
-    nullable?: import("@goast/core").Nullable<boolean>;
-    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+export declare const jsonAnySetter: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: import("@goast/core").Prettify<Omit<{
+    name: string;
+    packageName?: import("@goast/core").Nullable<string>;
     generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index").Type<TBuilder>>[]>;
+    nullable?: import("@goast/core").Nullable<boolean>;
     classReference?: import("@goast/core").Nullable<boolean>;
     subReference?: import("@goast/core").Nullable<import("../nodes/reference").KtReference<TBuilder, never> | import("../_index").Call<TBuilder, never>>;
-} | undefined) => import("../nodes/reference").KtReference<TBuilder, never>) & {
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+}, "name" | "packageName">>) => import("../nodes/reference").KtReference<TBuilder, never>) & {
     refName: string;
     packageName: import("@goast/core").Nullable<string>;
-    matches: (value: unknown) => value is import("../nodes/reference").KtReference<never, never>;
+    matches: (value: unknown) => value is import("../nodes/reference").KtReference<never>;
 };
-export declare const jsonAnyGetter: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(options?: {
-    nullable?: import("@goast/core").Nullable<boolean>;
-    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+export declare const jsonAnyGetter: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: import("@goast/core").Prettify<Omit<{
+    name: string;
+    packageName?: import("@goast/core").Nullable<string>;
     generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index").Type<TBuilder>>[]>;
+    nullable?: import("@goast/core").Nullable<boolean>;
     classReference?: import("@goast/core").Nullable<boolean>;
     subReference?: import("@goast/core").Nullable<import("../nodes/reference").KtReference<TBuilder, never> | import("../_index").Call<TBuilder, never>>;
-} | undefined) => import("../nodes/reference").KtReference<TBuilder, never>) & {
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+}, "name" | "packageName">>) => import("../nodes/reference").KtReference<TBuilder, never>) & {
     refName: string;
     packageName: import("@goast/core").Nullable<string>;
-    matches: (value: unknown) => value is import("../nodes/reference").KtReference<never, never>;
+    matches: (value: unknown) => value is import("../nodes/reference").KtReference<never>;
 };

package/types/lib/ast/references/jakarta.d.ts

@@ -1,33 +1,39 @@
-export declare const generated: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(options?: {
-    nullable?: import("@goast/core").Nullable<boolean>;
-    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+export declare const generated: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: import("@goast/core").Prettify<Omit<{
+    name: string;
+    packageName?: import("@goast/core").Nullable<string>;
     generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index").Type<TBuilder>>[]>;
+    nullable?: import("@goast/core").Nullable<boolean>;
     classReference?: import("@goast/core").Nullable<boolean>;
     subReference?: import("@goast/core").Nullable<import("../nodes/reference").KtReference<TBuilder, never> | import("../_index").Call<TBuilder, never>>;
-} | undefined) => import("../nodes/reference").KtReference<TBuilder, never>) & {
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+}, "name" | "packageName">>) => import("../nodes/reference").KtReference<TBuilder, never>) & {
     refName: string;
     packageName: import("@goast/core").Nullable<string>;
-    matches: (value: unknown) => value is import("../nodes/reference").KtReference<never, never>;
+    matches: (value: unknown) => value is import("../nodes/reference").KtReference<never>;
 };
-export declare const valid: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(options?: {
-    nullable?: import("@goast/core").Nullable<boolean>;
-    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+export declare const valid: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: import("@goast/core").Prettify<Omit<{
+    name: string;
+    packageName?: import("@goast/core").Nullable<string>;
     generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index").Type<TBuilder>>[]>;
+    nullable?: import("@goast/core").Nullable<boolean>;
     classReference?: import("@goast/core").Nullable<boolean>;
     subReference?: import("@goast/core").Nullable<import("../nodes/reference").KtReference<TBuilder, never> | import("../_index").Call<TBuilder, never>>;
-} | undefined) => import("../nodes/reference").KtReference<TBuilder, never>) & {
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+}, "name" | "packageName">>) => import("../nodes/reference").KtReference<TBuilder, never>) & {
     refName: string;
     packageName: import("@goast/core").Nullable<string>;
-    matches: (value: unknown) => value is import("../nodes/reference").KtReference<never, never>;
+    matches: (value: unknown) => value is import("../nodes/reference").KtReference<never>;
 };
-export declare const pattern: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(options?: {
-    nullable?: import("@goast/core").Nullable<boolean>;
-    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+export declare const pattern: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: import("@goast/core").Prettify<Omit<{
+    name: string;
+    packageName?: import("@goast/core").Nullable<string>;
     generics?: import("@goast/core").Nullable<import("@goast/core").Nullable<import("../_index").Type<TBuilder>>[]>;
+    nullable?: import("@goast/core").Nullable<boolean>;
     classReference?: import("@goast/core").Nullable<boolean>;
     subReference?: import("@goast/core").Nullable<import("../nodes/reference").KtReference<TBuilder, never> | import("../_index").Call<TBuilder, never>>;
-} | undefined) => import("../nodes/reference").KtReference<TBuilder, never>) & {
+    inject?: import("@goast/core").AstNodeInject<TBuilder, ""> | undefined;
+}, "name" | "packageName">>) => import("../nodes/reference").KtReference<TBuilder, never>) & {
     refName: string;
     packageName: import("@goast/core").Nullable<string>;
-    matches: (value: unknown) => value is import("../nodes/reference").KtReference<never, never>;
+    matches: (value: unknown) => value is import("../nodes/reference").KtReference<never>;
 };