@goast/kotlin 0.1.18 → 0.2.0

package/esm/lib/import-collection.js

@@ -1,7 +1,12 @@
 import { StringBuilder } from '@goast/core';
+import { defaultKotlinGeneratorConfig } from './config';
+export const defaultImportCollectionOptions = {
+    globalImports: defaultKotlinGeneratorConfig.globalImports,
+};
 export class ImportCollection {
-    constructor() {
+    constructor(options = {}) {
         this._imports = new Map();
+        this._options = Object.assign(Object.assign({}, defaultImportCollectionOptions), options);
     }
     get hasImports() {
         return this._imports.size > 0;
@@ -43,24 +48,28 @@ export class ImportCollection {
     }
     writeTo(builder) {
         if (this._imports.size > 0) {
-            const sortedImports = Array.from(this._imports.entries()).sort(([fromModuleA], [fromModuleB]) => {
-                if (isCoreImport(fromModuleA) && !isCoreImport(fromModuleB)) {
+            const globalPackages = this._options.globalImports
+                .filter((g) => g.endsWith('.*'))
+                .map((g) => g.substring(0, g.length - 2));
+            const globalImports = this._options.globalImports.filter((g) => !g.endsWith('.*'));
+            Array.from(this._imports.entries())
+                .filter(([packageName]) => !globalPackages.includes(packageName))
+                .flatMap(([packageName, importNames]) => Array.from(importNames).map((importName) => [packageName, importName]))
+                .map(([packageName, importName]) => `${packageName}.${importName}`)
+                .filter((importPath) => !globalImports.includes(importPath))
+                .sort((a, b) => {
+                if (isCoreImport(a) && !isCoreImport(b)) {
                     return 1;
                 }
-                else if (!isCoreImport(fromModuleA) && isCoreImport(fromModuleB)) {
+                else if (!isCoreImport(a) && isCoreImport(b)) {
                     return -1;
                 }
-                return fromModuleA.localeCompare(fromModuleB);
-            });
-            for (const [fromPackage, importNames] of sortedImports) {
-                const sortedImportNames = Array.from(importNames).sort();
-                for (const importName of sortedImportNames) {
-                    builder.appendLine(`import ${fromPackage}.${importName}`);
-                }
-            }
+                return a.localeCompare(b);
+            })
+                .forEach((importPath) => builder.appendLine(`import ${importPath}`));
         }
     }
 }
-function isCoreImport(packageName) {
-    return packageName.startsWith('kotlin.') || packageName.startsWith('java.') || packageName.startsWith('javax.');
+function isCoreImport(importPath) {
+    return importPath.startsWith('kotlin.') || importPath.startsWith('java.') || importPath.startsWith('javax.');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goast/kotlin",
-  "version": "0.1.18",
+  "version": "0.2.0",
   "repository": "https://github.com/MaSch0212/goast.git",
   "author": {
     "name": "Marc Schmidt (MaSch0212)",
@@ -9,11 +9,11 @@
   "license": "MIT",
   "type": "module",
   "dependencies": {
-    "fs-extra": "^11.1.1",
-    "node-fetch": "^2.6.11",
-    "yaml": "^2.3.1",
-    "@goast/core": "0.1.1",
-    "tslib": "^2.3.0"
+    "fs-extra": "^11.2.0",
+    "node-fetch": "^2.7.0",
+    "yaml": "^2.4.1",
+    "@goast/core": "0.2.0",
+    "tslib": "2.6.2"
   },
   "module": "./esm/index.js",
   "main": "./cjs/index.js",

package/types/index.d.ts

@@ -4,3 +4,5 @@ export * from './lib/generators';
 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/_index.d.ts

@@ -0,0 +1,28 @@
+export { KtAccessModifier as AccessModifier } from './common';
+export { KtNode as Node } from './node';
+export { KtAnnotation as Annotation, KtAnnotationTarget as AnnotationTarget, ktAnnotation as annotation, } from './nodes/annotation';
+export { KtArgument as Argument, ktArgument as argument } from './nodes/argument';
+export { KtCall as Call, ktCall as call } from './nodes/call';
+export { KtClass as Class, KtClassKind as ClassKind, KtClassMember as ClassMember, ktClass as class, } from './nodes/class';
+export { KtCollectionLiteral as CollectionLiteral, ktCollectionLiteral as collectionLiteral, } from './nodes/collection-literal';
+export { KtConstructor as Constructor, KtDelegateTarget as DelegateTarget, ktConstructor as constructor, } from './nodes/constructor';
+export { KtDoc as Doc, ktDoc as doc } from './nodes/doc';
+export { KtDocTag as DocTag, ktDocTag as docTag } from './nodes/doc-tag';
+export { KtEnum as Enum, KtEnumMember as EnumMember, ktEnum as enum } from './nodes/enum';
+export { KtEnumValue as EnumValue, KtEnumValueMember as EnumValueMember, ktEnumValue as enumValue, } from './nodes/enum-value';
+export { KtFunction as Function, ktFunction as function } from './nodes/function';
+export { KtGenericParameter as GenericParameter, ktGenericParameter as genericParameter, } from './nodes/generic-parameter';
+export { KtInitBlock as InitBlock, ktInitBlock as initBlock } from './nodes/init-block';
+export { KtInterface as Interface, KtInterfaceMember as InterfaceMember, ktInterface as interface, } from './nodes/interface';
+export { KtLambda as Lambda, ktLambda as lambda } from './nodes/lambda';
+export { KtLambdaType as LambdaType, ktLambdaType as lambdaType } from './nodes/lambda-type';
+export { KtObject as Object, KtObjectMember as ObjectMember, ktObject as object } from './nodes/object';
+export { KtParameter as Parameter, ktParameter as parameter } from './nodes/parameter';
+export { KtProperty as Property, KtPropertyAccessor as PropertyAccessor, KtPropertyGetter as PropertyGetter, KtPropertySetter as PropertySetter, ktProperty as property, } from './nodes/property';
+export { KtReference as Reference, ktReference as reference } from './nodes/reference';
+export { KtString as String, ktString as string } from './nodes/string';
+export { KtType as Type, KtValue as Value } from './nodes/types';
+export * as refs from './references';
+export { getKotlinBuilderOptions as getBuilderOptions } from './utils/get-kotlin-builder-options';
+export { toKtNode as toNode } from './utils/to-kt-node';
+export { writeKtNode as writeNode, writeKtNodes as writeNodes } from './utils/write-kt-node';

package/types/lib/ast/common.d.ts

@@ -0,0 +1 @@
+export type KtAccessModifier = 'public' | 'protected' | 'internal' | 'private';

package/types/lib/ast/index.d.ts

@@ -0,0 +1 @@
+export * as kt from './_index';

package/types/lib/ast/node.d.ts

@@ -0,0 +1,4 @@
+import { AstNode, AstNodeOptions, SourceBuilder } from '@goast/core';
+export declare abstract class KtNode<TBuilder extends SourceBuilder, TInjects extends string = never> extends AstNode<TBuilder, TInjects> {
+    constructor(options: AstNodeOptions<typeof AstNode<TBuilder, TInjects>>);
+}

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

@@ -0,0 +1,23 @@
+import { AstNodeOptions, Nullable, Prettify, SourceBuilder } from '@goast/core';
+import { KtArgument } from './argument';
+import { KtType, KtValue } from './types';
+import { KtNode } from '../node';
+import { writeKtAnnotations } from '../utils/write-kt-annotations';
+type Injects = 'class' | 'target' | 'arguments';
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof KtNode<TBuilder, TInjects | Injects>, {
+    class: KtType<TBuilder>;
+    arguments?: Nullable<Nullable<KtArgument<TBuilder> | KtValue<TBuilder>>[]>;
+    target?: Nullable<KtAnnotationTarget>;
+}>;
+export type KtAnnotationTarget = 'file' | 'property' | 'field' | 'get' | 'set' | 'receiver' | 'param' | 'setparam' | 'delegate';
+export declare class KtAnnotation<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<TBuilder, TInjects | Injects> {
+    class: KtType<TBuilder>;
+    arguments: (KtArgument<TBuilder> | KtValue<TBuilder>)[];
+    target: KtAnnotationTarget | null;
+    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>) & {
+    write: typeof writeKtAnnotations;
+};
+export {};

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

@@ -0,0 +1,22 @@
+import { AstNodeOptions, Nullable, Prettify, SourceBuilder } from '@goast/core';
+import { KtValue } from './types';
+import { KtNode } from '../node';
+import { writeKtArguments } from '../utils/write-kt-arguments';
+type Injects = 'name' | 'value';
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof KtNode<TBuilder, TInjects | Injects>, {
+    name?: Nullable<string>;
+    value: KtValue<TBuilder>;
+}>;
+export declare class KtArgument<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<TBuilder, TInjects | Injects> {
+    name: string | null;
+    value: KtValue<TBuilder>;
+    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>;
+    write: typeof writeKtArguments;
+};
+export {};

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

@@ -0,0 +1,22 @@
+import { ArrayItem, AstNodeOptions, Nullable, Prettify, SourceBuilder } from '@goast/core';
+import { KtArgument } from './argument';
+import { KtType, KtValue } from './types';
+import { KtNode } from '../node';
+import { writeKtNodes } from '../utils/write-kt-node';
+type Injects = never;
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof KtNode<TBuilder, TInjects | Injects>, {
+    path: Nullable<KtType<TBuilder> | KtValue<TBuilder>>[];
+    arguments?: Nullable<Nullable<KtArgument<TBuilder> | KtValue<TBuilder>>[]>;
+    infix?: boolean;
+}>;
+export declare class KtCall<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<TBuilder, TInjects | Injects> {
+    path: (KtType<TBuilder> | KtValue<TBuilder>)[];
+    arguments: (KtArgument<TBuilder> | KtValue<TBuilder>)[] | null;
+    infix: boolean;
+    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>) & {
+    write: typeof writeKtNodes;
+};
+export {};

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

@@ -0,0 +1,54 @@
+import { AppendValue, AstNodeOptions, BasicAppendValue, Nullable, Prettify, SourceBuilder } from '@goast/core';
+import { KtAnnotation } from './annotation';
+import { KtConstructor } from './constructor';
+import { KtDoc } from './doc';
+import { KtEnum } from './enum';
+import { KtFunction } from './function';
+import { KtGenericParameter } from './generic-parameter';
+import { KtInitBlock } from './init-block';
+import { KtInterface } from './interface';
+import { KtObject } from './object';
+import { KtProperty } from './property';
+import { KtType } from './types';
+import { KtAccessModifier } from '../common';
+import { KtNode } from '../node';
+import { writeKtNodes } from '../utils/write-kt-node';
+type Injects = 'doc' | 'annotations' | 'modifiers' | 'name' | 'generics' | 'primaryConstructor' | 'inheritList' | 'body' | 'members';
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof KtNode<TBuilder, TInjects | Injects>, {
+    doc?: Nullable<KtDoc<TBuilder>>;
+    annotations?: Nullable<Nullable<KtAnnotation<TBuilder>>[]>;
+    accessModifier?: Nullable<KtAccessModifier>;
+    open?: Nullable<boolean>;
+    abstract?: Nullable<boolean>;
+    classKind?: Nullable<KtClassKind>;
+    name: string;
+    generics?: Nullable<Nullable<KtGenericParameter<TBuilder> | BasicAppendValue<TBuilder>>[]>;
+    primaryConstructor?: Nullable<KtConstructor<TBuilder>>;
+    extends?: Nullable<KtType<TBuilder>>;
+    implements?: Nullable<Nullable<KtType<TBuilder>>[]>;
+    companionObject?: Nullable<KtObject<TBuilder>>;
+    members?: Nullable<Nullable<KtClassMember<TBuilder>>[]>;
+}>;
+export type KtClassKind = 'data' | 'value' | 'annotation' | 'sealed';
+export type KtClassMember<TBuilder extends SourceBuilder> = KtConstructor<TBuilder> | KtEnum<TBuilder> | KtInitBlock<TBuilder> | KtInterface<TBuilder> | KtProperty<TBuilder> | KtFunction<TBuilder> | KtClass<TBuilder> | AppendValue<TBuilder>;
+export declare class KtClass<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<TBuilder, TInjects | Injects> {
+    doc: KtDoc<TBuilder> | null;
+    annotations: KtAnnotation<TBuilder>[];
+    accessModifier: KtAccessModifier | null;
+    open: boolean;
+    abstract: boolean;
+    classKind: KtClassKind | null;
+    name: string;
+    generics: (KtGenericParameter<TBuilder> | BasicAppendValue<TBuilder>)[];
+    primaryConstructor: KtConstructor<TBuilder> | null;
+    extends: KtType<TBuilder> | null;
+    implements: KtType<TBuilder>[];
+    members: KtClassMember<TBuilder>[];
+    companionObject: Nullable<KtObject<TBuilder>>;
+    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>) & {
+    write: typeof writeKtNodes;
+};
+export {};

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

@@ -0,0 +1,17 @@
+import { SourceBuilder, AstNodeOptions, Nullable } from '@goast/core';
+import { KtValue } from './types';
+import { KtNode } from '../node';
+import { writeKtNodes } from '../utils/write-kt-node';
+type Injects = never;
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof KtNode<TBuilder, TInjects | Injects>, {
+    elements: Nullable<Nullable<KtValue<TBuilder>>[]>;
+}>;
+export declare class KtCollectionLiteral<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<TBuilder, TInjects | Injects> {
+    elements: KtValue<TBuilder>[];
+    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>) & {
+    write: typeof writeKtNodes;
+};
+export {};

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

@@ -0,0 +1,34 @@
+import { AppendValue, AstNodeOptions, BasicAppendValue, Nullable, Prettify, SourceBuilder } from '@goast/core';
+import { KtAnnotation } from './annotation';
+import { KtArgument } from './argument';
+import { KtParameter } from './parameter';
+import { KtValue } from './types';
+import { KtAccessModifier } from '../common';
+import { KtNode } from '../node';
+import { writeKtNodes } from '../utils/write-kt-node';
+type Injects = 'annotations' | 'modifiers' | 'params' | 'body' | 'delegate';
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof KtNode<TBuilder, TInjects | Injects>, {
+    accessModifier?: Nullable<KtAccessModifier>;
+    annotations?: Nullable<Nullable<KtAnnotation<TBuilder>>[]>;
+    parameters?: Nullable<Nullable<KtParameter<TBuilder> | BasicAppendValue<TBuilder>>[]>;
+    body?: Nullable<AppendValue<TBuilder>>;
+    delegateTarget?: Nullable<KtDelegateTarget>;
+    delegateArguments?: Nullable<Nullable<KtArgument<TBuilder> | KtValue<TBuilder>>[]>;
+}>;
+export type KtDelegateTarget = 'this' | 'super';
+export declare class KtConstructor<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<TBuilder, TInjects | Injects> {
+    accessModifier: KtAccessModifier | null;
+    annotations: KtAnnotation<TBuilder>[];
+    parameters: (KtParameter<TBuilder> | BasicAppendValue<TBuilder>)[];
+    body: AppendValue<TBuilder> | null;
+    delegateTarget: KtDelegateTarget | null;
+    delegateArguments: (KtArgument<TBuilder> | KtValue<TBuilder>)[];
+    constructor(options: Options<TBuilder, TInjects>);
+    protected onWrite(builder: TBuilder): void;
+    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>) & {
+    write: typeof writeKtNodes;
+};
+export {};

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

@@ -0,0 +1,34 @@
+import { SourceBuilder, AstNodeOptions, StringSuggestions, ParametersWithOverloads, Prettify, SingleOrMultiple, Nullable, BasicAppendValue } from '@goast/core';
+import { KtNode } from '../node';
+import { KtAppendValue } from '../utils/write-kt-node';
+type Injects = never;
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof KtNode<TBuilder, TInjects | Injects>, {
+    tag: string;
+    args?: Nullable<Nullable<BasicAppendValue<TBuilder>>[]>;
+    description?: Nullable<BasicAppendValue<TBuilder>>;
+}>;
+export declare class KtDocTag<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<TBuilder, TInjects | Injects> {
+    tag: string;
+    args: BasicAppendValue<TBuilder>[];
+    description: BasicAppendValue<TBuilder> | null;
+    constructor(options: Options<TBuilder, TInjects>);
+    protected onWrite(builder: TBuilder): void;
+}
+type _KtDocTagOpt<TBuilder extends SourceBuilder> = Prettify<Omit<Options<TBuilder>, 'tag'>>;
+type _KtDocTagArgsMap<TBuilder extends SourceBuilder> = {
+    suppress(options?: _KtDocTagOpt<TBuilder>): never;
+} & {
+    [K in 'return' | 'constructor' | 'receiver' | 'author' | 'since']: (description: BasicAppendValue<TBuilder>, options?: _KtDocTagOpt<TBuilder>) => never;
+} & {
+    [K in 'param' | 'property']: (name: string, description: BasicAppendValue<TBuilder>, options?: _KtDocTagOpt<TBuilder>) => never;
+} & {
+    [K in 'see' | 'sample']: (identifier: string, options?: _KtDocTagOpt<TBuilder>) => never;
+} & {
+    [K in 'throws' | 'exception']: ($class: BasicAppendValue<TBuilder>, description: BasicAppendValue<TBuilder>, options?: _KtDocTagOpt<TBuilder>) => never;
+};
+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;
+};
+export {};

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

@@ -0,0 +1,26 @@
+import { SourceBuilder, AstNodeOptions, Prettify, Nullable, BasicAppendValue } from '@goast/core';
+import { KtDocTag } from './doc-tag';
+import { KtGenericParameter } from './generic-parameter';
+import { KtParameter } from './parameter';
+import { KtNode } from '../node';
+import { writeKtNodes } from '../utils/write-kt-node';
+type Injects = never;
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof KtNode<TBuilder, TInjects | Injects>, {
+    description?: Nullable<BasicAppendValue<TBuilder>>;
+    tags?: Nullable<Nullable<KtDocTag<TBuilder>>[]>;
+}>;
+export declare class KtDoc<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<TBuilder, TInjects | Injects> {
+    description: BasicAppendValue<TBuilder> | null;
+    tags: KtDocTag<TBuilder>[];
+    constructor(options: Options<TBuilder, TInjects>);
+    protected onWrite(builder: TBuilder): void;
+}
+declare function getDoc<TBuilder extends SourceBuilder>(baseDoc: KtDoc<TBuilder> | null, options: {
+    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>) & {
+    write: typeof writeKtNodes;
+    get: typeof getDoc;
+};
+export {};

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

@@ -0,0 +1,30 @@
+import { AppendValue, AstNodeOptions, Nullable, Prettify, SourceBuilder } from '@goast/core';
+import { KtAnnotation } from './annotation';
+import { KtArgument } from './argument';
+import { KtDoc } from './doc';
+import { KtFunction } from './function';
+import { KtParameter } from './parameter';
+import { KtNode } from '../node';
+import { writeKtEnumValues } from '../utils/write-kt-enum-values';
+type Injects = 'doc' | 'annotations' | 'name' | 'arguments' | 'body' | 'members';
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof KtNode<TBuilder, TInjects | Injects>, {
+    name: string;
+    doc?: Nullable<KtDoc<TBuilder>>;
+    annotations?: Nullable<Nullable<KtAnnotation<TBuilder>>[]>;
+    arguments?: Nullable<Nullable<KtArgument<TBuilder> | AppendValue<TBuilder>>[]>;
+    members?: Nullable<Nullable<KtEnumValueMember<TBuilder>>[]>;
+}>;
+export type KtEnumValueMember<TBuilder extends SourceBuilder> = KtParameter<TBuilder> | KtFunction<TBuilder> | AppendValue<TBuilder>;
+export declare class KtEnumValue<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<TBuilder, TInjects | Injects> {
+    name: string;
+    doc: KtDoc<TBuilder> | null;
+    annotations: KtAnnotation<TBuilder>[];
+    arguments: (KtArgument<TBuilder> | AppendValue<TBuilder>)[];
+    members: KtEnumValueMember<TBuilder>[];
+    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>) & {
+    write: typeof writeKtEnumValues;
+};
+export {};

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

@@ -0,0 +1,45 @@
+import { AppendValue, AstNodeOptions, Nullable, Prettify, SourceBuilder } from '@goast/core';
+import { KtAnnotation } from './annotation';
+import { KtClass } from './class';
+import { KtConstructor } from './constructor';
+import { KtDoc } from './doc';
+import { KtEnumValue } from './enum-value';
+import { KtFunction } from './function';
+import { KtInitBlock } from './init-block';
+import { KtInterface } from './interface';
+import { KtObject } from './object';
+import { KtProperty } from './property';
+import { KtType } from './types';
+import { KtAccessModifier } from '../common';
+import { KtNode } from '../node';
+import { writeKtNodes } from '../utils/write-kt-node';
+type Injects = 'doc' | 'annotations' | 'modifiers' | 'name' | 'primaryConstructor' | 'implements' | 'body' | 'values' | 'members';
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof KtNode<TBuilder, TInjects | Injects>, {
+    name: string;
+    doc?: Nullable<KtDoc<TBuilder>>;
+    annotations?: Nullable<Nullable<KtAnnotation<TBuilder>>[]>;
+    accessModifier?: Nullable<KtAccessModifier>;
+    primaryConstructor?: Nullable<KtConstructor<TBuilder>>;
+    implements?: Nullable<Nullable<KtType<TBuilder>>[]>;
+    values?: Nullable<KtEnumValue<TBuilder>[]>;
+    members?: Nullable<Nullable<KtEnumMember<TBuilder>>[]>;
+    companionObject?: Nullable<KtObject<TBuilder>>;
+}>;
+export type KtEnumMember<TBuilder extends SourceBuilder> = KtConstructor<TBuilder> | KtEnum<TBuilder> | KtInitBlock<TBuilder> | KtInterface<TBuilder> | KtProperty<TBuilder> | KtFunction<TBuilder> | KtClass<TBuilder> | AppendValue<TBuilder>;
+export declare class KtEnum<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<TBuilder, TInjects | Injects> {
+    name: string;
+    doc: KtDoc<TBuilder> | null;
+    annotations: KtAnnotation<TBuilder>[];
+    accessModifier: KtAccessModifier | null;
+    primaryConstructor: KtConstructor<TBuilder> | null;
+    implements: KtType<TBuilder>[];
+    values: KtEnumValue<TBuilder>[];
+    members: KtEnumMember<TBuilder>[];
+    companionObject: KtObject<TBuilder> | null;
+    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>) & {
+    write: typeof writeKtNodes;
+};
+export {};

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

@@ -0,0 +1,58 @@
+import { SourceBuilder, AstNodeOptions, AppendValue, Prettify, Nullable, BasicAppendValue } from '@goast/core';
+import { KtAnnotation } from './annotation';
+import { KtDoc } from './doc';
+import { KtGenericParameter } from './generic-parameter';
+import { KtParameter } from './parameter';
+import { KtType } from './types';
+import { KtAccessModifier } from '../common';
+import { KtNode } from '../node';
+import { writeKtNodes } from '../utils/write-kt-node';
+type Injects = 'doc' | 'annotations' | 'modifiers' | 'generics' | 'receiverAnnotations' | 'receiverType' | 'name' | 'parameters' | 'returnType';
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof KtNode<TBuilder, TInjects | Injects>, {
+    name: string;
+    generics?: Nullable<Nullable<KtGenericParameter<TBuilder> | BasicAppendValue<TBuilder>>[]>;
+    parameters?: Nullable<Nullable<KtParameter<TBuilder> | BasicAppendValue<TBuilder>>[]>;
+    doc?: Nullable<KtDoc<TBuilder>>;
+    returnType?: Nullable<KtType<TBuilder>>;
+    body?: Nullable<AppendValue<TBuilder>>;
+    accessModifier?: Nullable<KtAccessModifier>;
+    annotations?: Nullable<Nullable<KtAnnotation<TBuilder>>[]>;
+    receiverType?: Nullable<KtType<TBuilder>>;
+    receiverAnnotations?: Nullable<Nullable<KtAnnotation<TBuilder>>[]>;
+    singleExpression?: Nullable<boolean>;
+    open?: Nullable<boolean>;
+    inline?: Nullable<boolean>;
+    infix?: Nullable<boolean>;
+    tailrec?: Nullable<boolean>;
+    suspend?: Nullable<boolean>;
+    operator?: Nullable<boolean>;
+    override?: Nullable<boolean>;
+    abstract?: Nullable<boolean>;
+}>;
+export declare class KtFunction<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<TBuilder, TInjects | Injects> {
+    name: string;
+    generics: (KtGenericParameter<TBuilder> | BasicAppendValue<TBuilder>)[];
+    parameters: (KtParameter<TBuilder> | BasicAppendValue<TBuilder>)[];
+    doc: KtDoc<TBuilder> | null;
+    returnType: KtType<TBuilder> | null;
+    body: AppendValue<TBuilder> | null;
+    accessModifier: KtAccessModifier | null;
+    annotations: KtAnnotation<TBuilder>[];
+    receiverType: KtType<TBuilder> | null;
+    receiverAnnotations: KtAnnotation<TBuilder>[];
+    singleExpression: boolean;
+    open: boolean;
+    inline: boolean;
+    infix: boolean;
+    tailrec: boolean;
+    suspend: boolean;
+    operator: boolean;
+    override: boolean;
+    abstract: boolean;
+    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>) & {
+    write: typeof writeKtNodes;
+};
+export {};

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

@@ -0,0 +1,21 @@
+import { AstNodeOptions, BasicAppendValue, Nullable, Prettify, SourceBuilder } from '@goast/core';
+import { KtType } from './types';
+import { KtNode } from '../node';
+import { writeKtGenericParameters } from '../utils/write-kt-generic-parameters';
+type Injects = 'name' | 'constraint';
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof KtNode<TBuilder, TInjects | Injects>, {
+    name: string;
+    description?: Nullable<BasicAppendValue<TBuilder>>;
+    constraint?: Nullable<KtType<TBuilder>>;
+}>;
+export declare class KtGenericParameter<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<TBuilder, TInjects | Injects> {
+    name: string;
+    description: BasicAppendValue<TBuilder> | null;
+    constraint: KtType<TBuilder> | null;
+    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>) & {
+    write: typeof writeKtGenericParameters;
+};
+export {};

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

@@ -0,0 +1,16 @@
+import { AppendValue, AstNodeOptions, Prettify, SourceBuilder } from '@goast/core';
+import { KtNode } from '../node';
+import { writeKtNodes } from '../utils/write-kt-node';
+type Injects = never;
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof KtNode<TBuilder, TInjects | Injects>, {
+    body: AppendValue<TBuilder>;
+}>;
+export declare class KtInitBlock<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<TBuilder, TInjects | Injects> {
+    body: AppendValue<TBuilder>;
+    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>) & {
+    write: typeof writeKtNodes;
+};
+export {};

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

@@ -0,0 +1,41 @@
+import { SourceBuilder, AppendValue, AstNodeOptions, Prettify, Nullable, BasicAppendValue } from '@goast/core';
+import { KtAnnotation } from './annotation';
+import { KtClass } from './class';
+import { KtDoc } from './doc';
+import { KtEnum } from './enum';
+import { KtFunction } from './function';
+import { KtGenericParameter } from './generic-parameter';
+import { KtObject } from './object';
+import { KtProperty } from './property';
+import { KtType } from './types';
+import { KtAccessModifier } from '../common';
+import { KtNode } from '../node';
+import { writeKtNodes } from '../utils/write-kt-node';
+type Injects = 'doc' | 'annotations' | 'modifiers' | 'name' | 'generics' | 'extends' | 'body' | 'members';
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof KtNode<TBuilder, TInjects | Injects>, {
+    doc?: Nullable<KtDoc<TBuilder>>;
+    annotations?: Nullable<Nullable<KtAnnotation<TBuilder>>[]>;
+    accessModifier?: Nullable<KtAccessModifier>;
+    name: string;
+    generics?: Nullable<Nullable<KtGenericParameter<TBuilder> | BasicAppendValue<TBuilder>>[]>;
+    extends?: Nullable<Nullable<KtType<TBuilder>>[]>;
+    members?: Nullable<Nullable<KtInterfaceMember<TBuilder>>[]>;
+    companionObject?: Nullable<KtObject<TBuilder>>;
+}>;
+export type KtInterfaceMember<TBuilder extends SourceBuilder> = KtEnum<TBuilder> | KtInterface<TBuilder> | KtProperty<TBuilder> | KtFunction<TBuilder> | KtClass<TBuilder> | AppendValue<TBuilder>;
+export declare class KtInterface<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<TBuilder, TInjects | Injects> {
+    doc: KtDoc<TBuilder> | null;
+    annotations: KtAnnotation<TBuilder>[];
+    accessModifier: KtAccessModifier | null;
+    name: string;
+    generics: (KtGenericParameter<TBuilder> | BasicAppendValue<TBuilder>)[];
+    extends: KtType<TBuilder>[];
+    members: KtInterfaceMember<TBuilder>[];
+    companionObject: KtObject<TBuilder> | null;
+    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>) & {
+    write: typeof writeKtNodes;
+};
+export {};

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

@@ -0,0 +1,21 @@
+import { SourceBuilder, AstNodeOptions, Nullable } from '@goast/core';
+import { KtType } from './types';
+import { KtNode } from '../node';
+import { writeKtNodes } from '../utils/write-kt-node';
+type Injects = 'extensionFor' | 'params' | 'returnType';
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof KtNode<TBuilder, TInjects | Injects>, {
+    extensionFor?: Nullable<KtType<TBuilder>>;
+    parameters?: Nullable<Nullable<KtType<TBuilder>>[]>;
+    returnType: KtType<TBuilder>;
+}>;
+export declare class KtLambdaType<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<TBuilder, TInjects | Injects> {
+    extensionFor: KtType<TBuilder> | null;
+    parameters: KtType<TBuilder>[];
+    returnType: KtType<TBuilder>;
+    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>) & {
+    write: typeof writeKtNodes;
+};
+export {};