@goast/typescript 0.0.4 → 0.2.0

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

@@ -0,0 +1,20 @@
+import { SourceBuilder, AstNodeOptions, Nullable, ArrayItem, Prettify } from '@goast/core';
+import { TsArgument } from './argument';
+import { TsType, TsValue } from './types';
+import { TsNode } from '../node';
+import { writeTsNodes } from '../utils/write-ts-nodes';
+type Injects = never;
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | Injects>, {
+    path: Nullable<TsType<TBuilder> | TsValue<TBuilder>>[];
+    arguments?: Nullable<Nullable<TsArgument<TBuilder> | TsValue<TBuilder>>[]>;
+}>;
+export declare class TsCall<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    path: (TsType<TBuilder> | TsValue<TBuilder>)[];
+    arguments: (TsArgument<TBuilder> | TsValue<TBuilder>)[] | null;
+    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>) & {
+    write: typeof writeTsNodes;
+};
+export {};

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

@@ -0,0 +1,41 @@
+import { AstNodeOptions, BasicAppendValue, Nullable, Prettify, SourceBuilder } from '@goast/core';
+import { TsConstructor } from './constructor';
+import { TsDecorator } from './decorator';
+import { TsDoc } from './doc';
+import { TsGenericParameter } from './generic-parameter';
+import { TsIndexer } from './indexer';
+import { TsMethod } from './method';
+import { TsProperty } from './property';
+import { TsReference } from './reference';
+import { TsNode } from '../node';
+import { writeTsNodes } from '../utils/write-ts-nodes';
+type Injects = 'doc' | 'decorators' | 'modifiers' | 'name' | 'generics' | 'extends' | 'implements' | 'body' | 'members';
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | Injects>, {
+    doc?: Nullable<TsDoc<TBuilder>>;
+    decorators?: Nullable<Nullable<TsDecorator<TBuilder>>[]>;
+    export?: Nullable<boolean>;
+    abstract?: Nullable<boolean>;
+    name: string;
+    generics?: Nullable<Nullable<TsGenericParameter<TBuilder> | BasicAppendValue<TBuilder>>[]>;
+    extends?: Nullable<TsReference<TBuilder> | BasicAppendValue<TBuilder>>;
+    implements?: Nullable<Nullable<TsReference<TBuilder> | BasicAppendValue<TBuilder>>[]>;
+    members?: Nullable<Nullable<Member<TBuilder>>[]>;
+}>;
+type Member<TBuilder extends SourceBuilder> = TsProperty<TBuilder> | TsMethod<TBuilder> | TsIndexer<TBuilder> | TsConstructor<TBuilder> | BasicAppendValue<TBuilder>;
+export declare class TsClass<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    doc: TsDoc<TBuilder> | null;
+    decorators: TsDecorator<TBuilder>[];
+    export: boolean;
+    abstract: boolean;
+    name: string;
+    generics: (TsGenericParameter<TBuilder> | BasicAppendValue<TBuilder>)[];
+    extends: TsReference<TBuilder> | BasicAppendValue<TBuilder> | null;
+    implements: (TsReference<TBuilder> | BasicAppendValue<TBuilder>)[];
+    members: Member<TBuilder>[];
+    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>) & {
+    write: typeof writeTsNodes;
+};
+export {};

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

@@ -0,0 +1,19 @@
+import { AstNodeOptions, Nullable, Prettify, SourceBuilder } from '@goast/core';
+import { TsParameter } from './parameter';
+import { TsAccessModifier } from '../common';
+import { writeTsParameters } from '../utils/write-ts-parameters';
+type Injects = 'modifiers';
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsParameter<TBuilder, TInjects | Injects>, {
+    accessModifier?: Nullable<TsAccessModifier>;
+    readonly?: Nullable<boolean>;
+}>;
+export declare class TsConstructorParameter<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsParameter<TBuilder, TInjects | Injects> {
+    accessModifier: TsAccessModifier | null;
+    readonly: boolean;
+    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>) & {
+    write: typeof writeTsParameters;
+};
+export {};

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

@@ -0,0 +1,25 @@
+import { AppendValue, AstNodeOptions, BasicAppendValue, Nullable, SourceBuilder } from '@goast/core';
+import { TsConstructorParameter } from './constructor-parameter';
+import { TsDecorator } from './decorator';
+import { TsDoc } from './doc';
+import { TsNode } from '../node';
+import { writeTsNodes } from '../utils/write-ts-nodes';
+type Injects = 'params' | 'doc' | 'decorators' | 'body';
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | Injects>, {
+    doc?: Nullable<TsDoc<TBuilder>>;
+    decorators?: Nullable<Nullable<TsDecorator<TBuilder>>[]>;
+    parameters?: Nullable<Nullable<TsConstructorParameter<TBuilder> | BasicAppendValue<TBuilder>>[]>;
+    body?: Nullable<AppendValue<TBuilder>>;
+}>;
+export declare class TsConstructor<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    doc: TsDoc<TBuilder> | null;
+    decorators: TsDecorator<TBuilder>[];
+    parameters: (TsConstructorParameter<TBuilder> | BasicAppendValue<TBuilder>)[];
+    body: AppendValue<TBuilder> | null;
+    constructor(options: Options<TBuilder, TInjects>);
+    protected onWrite(builder: TBuilder): void;
+}
+export declare const tsConstructor: (<TBuilder extends SourceBuilder<never>>(options?: Options<TBuilder>) => TsConstructor<TBuilder, never>) & {
+    write: typeof writeTsNodes;
+};
+export {};

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

@@ -0,0 +1,22 @@
+import { AppendValue, AstNodeOptions, BasicAppendValue, Nullable, Prettify, SingleOrMultiple, SourceBuilder } from '@goast/core';
+import { TsArgument } from './argument';
+import { TsReference } from './reference';
+import { TsValue } from './types';
+import { TsNode } from '../node';
+type Injects = 'function' | 'arguments';
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | Injects>, {
+    function: TsReference<TBuilder> | BasicAppendValue<TBuilder>;
+    arguments?: Nullable<Nullable<TsArgument<TBuilder> | TsValue<TBuilder>>[]>;
+}>;
+export declare class TsDecorator<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    function: TsReference<TBuilder> | BasicAppendValue<TBuilder>;
+    arguments: (TsArgument<TBuilder> | TsValue<TBuilder>)[] | null;
+    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?: {
+        multiline?: boolean;
+    }) => void;
+};
+export {};

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

@@ -0,0 +1,73 @@
+import { AstNodeOptions, BasicAppendValue, Nullable, ParametersWithOverloads, Prettify, SourceBuilder, StringSuggestions } from '@goast/core';
+import { TsType } from './types';
+import { TsNode } from '../node';
+import { writeTsNodes } from '../utils/write-ts-nodes';
+type Injects = never;
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | Injects>, {
+    tag: string;
+    type?: Nullable<TsType<TBuilder>>;
+    text?: Nullable<BasicAppendValue<TBuilder>>;
+}>;
+export declare class TsDocTag<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    tag: string;
+    type: TsType<TBuilder> | null;
+    text: BasicAppendValue<TBuilder> | null;
+    constructor(options: Options<TBuilder, TInjects>);
+    protected onWrite(builder: TBuilder): void;
+}
+type _TsDocTagOpt<TBuilder extends SourceBuilder> = Prettify<Omit<Options<TBuilder>, 'tag'>>;
+type _TsDocTagArgsMap<TBuilder extends SourceBuilder> = {
+    access(access: StringSuggestions<'package' | 'private' | 'protected' | 'public'>, options?: _TsDocTagOpt<TBuilder>): never;
+    author(authorName: BasicAppendValue<TBuilder>, options?: _TsDocTagOpt<TBuilder>): never;
+    author(authorName: BasicAppendValue<TBuilder>, emailAddress: BasicAppendValue<TBuilder>, options?: _TsDocTagOpt<TBuilder>): never;
+    borrows(thatNamepath: BasicAppendValue<TBuilder>, thisNamepath: BasicAppendValue<TBuilder>, options?: _TsDocTagOpt<TBuilder>): never;
+    params(paramName: BasicAppendValue<TBuilder>, paramDescription: BasicAppendValue<TBuilder>, options?: _TsDocTagOpt<TBuilder>): never;
+    example(caption: BasicAppendValue<TBuilder>, code: BasicAppendValue<TBuilder>, options?: _TsDocTagOpt<TBuilder>): never;
+    example(code: BasicAppendValue<TBuilder>, options?: _TsDocTagOpt<TBuilder>): never;
+    exports(moduleName: BasicAppendValue<TBuilder>, exportName: BasicAppendValue<TBuilder>, options?: _TsDocTagOpt<TBuilder>): never;
+    kind(kindName: StringSuggestions<'class' | 'constant' | 'event' | 'external' | 'file' | 'function' | 'member' | 'mixin' | 'module' | 'namespace' | 'typedef'>, options?: _TsDocTagOpt<TBuilder>): never;
+    license(identifier: BasicAppendValue<TBuilder>, options?: _TsDocTagOpt<TBuilder>): never;
+    listens(eventName: BasicAppendValue<TBuilder>, options?: _TsDocTagOpt<TBuilder>): never;
+    mixes(otherObjectPath: BasicAppendValue<TBuilder>, options?: _TsDocTagOpt<TBuilder>): never;
+    mixin(mixinName: BasicAppendValue<TBuilder>, options?: _TsDocTagOpt<TBuilder>): never;
+    requires(moduleName: BasicAppendValue<TBuilder>, options?: _TsDocTagOpt<TBuilder>): never;
+    variation(variationNumber: BasicAppendValue<TBuilder>, options?: _TsDocTagOpt<TBuilder>): never;
+} & {
+    [K in 'virtual' | 'abstract']: (options?: _TsDocTagOpt<TBuilder>) => never;
+} & {
+    [K in 'alias' | 'augments' | 'callback' | 'extends' | 'lends' | 'name' | 'see' | 'this']: (namePath: BasicAppendValue<TBuilder>, options?: _TsDocTagOpt<TBuilder>) => never;
+} & {
+    [K in 'async' | 'generator' | 'global' | 'hideconstructor' | 'ignore' | 'inheritdoc' | 'inner' | 'instance' | 'override' | 'static' | 'enum' | 'package' | 'private' | 'protected' | 'implements' | 'type']: (options?: _TsDocTagOpt<TBuilder>) => never;
+} & {
+    [K in 'class' | 'constructor' | 'const' | 'function' | 'func' | 'method' | 'constant' | 'member' | 'constructs' | 'interface' | 'var' | 'yield' | 'yields' | 'module' | 'namespace' | 'typedef']: {
+        (name: BasicAppendValue<TBuilder>, options?: _TsDocTagOpt<TBuilder>): never;
+        (options?: _TsDocTagOpt<TBuilder>): never;
+    };
+} & {
+    [K in 'return' | 'returns' | 'throws' | 'exception' | 'classdesc' | 'copyright' | 'deprecated' | 'desc' | 'description' | 'file' | 'fileoverview' | 'overview' | 'public' | 'readonly' | 'since' | 'summary' | 'todo' | 'tutorial' | 'version']: {
+        (description: BasicAppendValue<TBuilder>, options?: _TsDocTagOpt<TBuilder>): never;
+        (options?: _TsDocTagOpt<TBuilder>): never;
+    };
+} & {
+    [K in 'default' | 'defaultvalue']: {
+        (value: BasicAppendValue<TBuilder>, options?: _TsDocTagOpt<TBuilder>): never;
+        (options?: _TsDocTagOpt<TBuilder>): never;
+    };
+} & {
+    [K in 'event' | 'fires']: (className: BasicAppendValue<TBuilder>, eventName: BasicAppendValue<TBuilder>, options?: _TsDocTagOpt<TBuilder>) => never;
+} & {
+    [K in 'external' | 'host']: (nameOfExternal: BasicAppendValue<TBuilder>, options?: _TsDocTagOpt<TBuilder>) => never;
+} & {
+    [K in 'memberof' | 'memberof!']: (parentNamepath: BasicAppendValue<TBuilder>, options?: _TsDocTagOpt<TBuilder>) => never;
+} & {
+    [K in 'param' | 'arg' | 'argument' | 'prop' | 'property' | 'template']: {
+        (name: BasicAppendValue<TBuilder>, description: BasicAppendValue<TBuilder>, options?: _TsDocTagOpt<TBuilder>): never;
+        (name: BasicAppendValue<TBuilder>, options?: _TsDocTagOpt<TBuilder>): never;
+    };
+};
+type _TsDocTagArgs<TTagName extends StringSuggestions<keyof _TsDocTagArgsMap<TBuilder>>, TBuilder extends SourceBuilder> = TTagName extends keyof _TsDocTagArgsMap<TBuilder> ? _TsDocTagArgsMap<TBuilder>[TTagName] extends (...args: any[]) => any ? ParametersWithOverloads<_TsDocTagArgsMap<TBuilder>[TTagName]> : never : [options?: _TsDocTagOpt<TBuilder>];
+declare function createDocTag<TTagName extends StringSuggestions<keyof _TsDocTagArgsMap<TBuilder>>, TBuilder extends SourceBuilder>(tag: TTagName, ...args: _TsDocTagArgs<TTagName, TBuilder>): TsDocTag<TBuilder>;
+export declare const tsDocTag: typeof createDocTag & {
+    write: typeof writeTsNodes;
+};
+export {};

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

@@ -0,0 +1,28 @@
+import { AstNodeOptions, BasicAppendValue, Nullable, SourceBuilder } from '@goast/core';
+import { TsDocTag } from './doc-tag';
+import { TsGenericParameter } from './generic-parameter';
+import { TsParameter } from './parameter';
+import { TsNode } from '../node';
+import { writeTsNodes } from '../utils/write-ts-nodes';
+type Injects = never;
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | Injects>, {
+    description?: Nullable<BasicAppendValue<TBuilder>>;
+    tags?: Nullable<Nullable<TsDocTag<TBuilder>>[]>;
+}>;
+export declare class TsDoc<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    description: BasicAppendValue<TBuilder> | null;
+    tags: TsDocTag<TBuilder>[];
+    constructor(options: Options<TBuilder, TInjects>);
+    protected onWrite(builder: TBuilder): void;
+}
+declare function getDoc<TBuilder extends SourceBuilder>(baseDoc: TsDoc<TBuilder> | null, options: {
+    parameters?: Nullable<Nullable<TsParameter<TBuilder> | BasicAppendValue<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>) & {
+    write: typeof writeTsNodes;
+    get: typeof getDoc;
+    isEmpty: typeof isDocEmpty;
+};
+export {};

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

@@ -0,0 +1,21 @@
+import { SourceBuilder, AstNodeOptions, Nullable, AppendValue, SingleOrMultiple, Prettify, BasicAppendValue } from '@goast/core';
+import { TsDoc } from './doc';
+import { TsString } from './string';
+import { TsNode } from '../node';
+type Injects = 'doc' | 'name' | 'value';
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | Injects>, {
+    doc?: Nullable<TsDoc<TBuilder>>;
+    name: string;
+    value?: Nullable<TsString<TBuilder> | BasicAppendValue<TBuilder>>;
+}>;
+export declare class TsEnumValue<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    doc: TsDoc<TBuilder> | null;
+    name: string;
+    value: TsString<TBuilder> | BasicAppendValue<TBuilder> | null;
+    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 {};

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

@@ -0,0 +1,26 @@
+import { AstNodeOptions, Nullable, Prettify, SourceBuilder } from '@goast/core';
+import { TsDoc } from './doc';
+import { TsEnumValue } from './enum-value';
+import { TsNode } from '../node';
+import { writeTsNodes } from '../utils/write-ts-nodes';
+type Injects = 'doc' | 'modifiers' | 'name' | 'body' | 'members';
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | Injects>, {
+    doc?: Nullable<TsDoc<TBuilder>>;
+    export?: Nullable<boolean>;
+    const?: Nullable<boolean>;
+    name: string;
+    members?: Nullable<Nullable<TsEnumValue<TBuilder>>[]>;
+}>;
+export declare class TsEnum<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    doc: TsDoc<TBuilder> | null;
+    export: boolean;
+    const: boolean;
+    name: string;
+    members: TsEnumValue<TBuilder>[];
+    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>) & {
+    write: typeof writeTsNodes;
+};
+export {};

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

@@ -0,0 +1,19 @@
+import { AstNodeOptions, Prettify, SourceBuilder } from '@goast/core';
+import { TsNode } from '../node';
+import { writeTsNodes } from '../utils/write-ts-nodes';
+type Injects = never;
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | Injects>, {
+    name: string;
+    filePath: string;
+}>;
+export declare class TsExport<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    name: string;
+    filePath: string;
+    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>) & {
+    write: typeof writeTsNodes;
+};
+export {};

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

@@ -0,0 +1,23 @@
+import { AstNodeOptions, BasicAppendValue, Nullable, SourceBuilder } from '@goast/core';
+import { TsGenericParameter } from './generic-parameter';
+import { TsParameter } from './parameter';
+import { TsType } from './types';
+import { TsNode } from '../node';
+import { writeTsNodes } from '../utils/write-ts-nodes';
+type Injects = 'generics' | 'params' | 'returnType';
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | Injects>, {
+    generics?: Nullable<Nullable<TsGenericParameter<TBuilder> | BasicAppendValue<TBuilder>>[]>;
+    parameters?: Nullable<Nullable<TsParameter<TBuilder> | BasicAppendValue<TBuilder>>[]>;
+    returnType?: Nullable<TsType<TBuilder>>;
+}>;
+export declare class TsFunctionType<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    generics: (TsGenericParameter<TBuilder> | BasicAppendValue<TBuilder>)[];
+    parameters: (TsParameter<TBuilder> | BasicAppendValue<TBuilder>)[];
+    returnType: TsType<TBuilder> | null;
+    constructor(options: Options<TBuilder, TInjects>);
+    protected onWrite(builder: TBuilder): void;
+}
+export declare const tsFunctionType: (<TBuilder extends SourceBuilder<never>>(options?: Options<TBuilder>) => TsFunctionType<TBuilder, never>) & {
+    write: typeof writeTsNodes;
+};
+export {};

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

@@ -0,0 +1,35 @@
+import { AppendValue, AstNodeOptions, Nullable, Prettify, SourceBuilder } from '@goast/core';
+import { TsDecorator } from './decorator';
+import { TsDoc } from './doc';
+import { TsGenericParameter } from './generic-parameter';
+import { TsParameter } from './parameter';
+import { TsType } from './types';
+import { TsNode } from '../node';
+import { writeTsNodes } from '../utils/write-ts-nodes';
+type Injects = 'doc' | 'decorators' | 'modifiers' | 'name' | 'generics' | 'params' | 'returnType' | 'body';
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | Injects>, {
+    doc?: Nullable<TsDoc<TBuilder>>;
+    decorators?: Nullable<Nullable<TsDecorator<TBuilder>>[]>;
+    export?: boolean;
+    name: string;
+    generics?: Nullable<Nullable<TsGenericParameter<TBuilder>>[]>;
+    parameters?: Nullable<Nullable<TsParameter<TBuilder>>[]>;
+    returnType?: Nullable<TsType<TBuilder>>;
+    body?: Nullable<AppendValue<TBuilder>>;
+}>;
+export declare class TsFunction<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    doc: TsDoc<TBuilder> | null;
+    decorators: TsDecorator<TBuilder>[];
+    export: boolean;
+    name: string;
+    generics: TsGenericParameter<TBuilder>[];
+    parameters: TsParameter<TBuilder>[];
+    returnType: TsType<TBuilder> | null;
+    body: AppendValue<TBuilder> | null;
+    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>) & {
+    write: typeof writeTsNodes;
+};
+export {};

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

@@ -0,0 +1,25 @@
+import { AstNodeOptions, BasicAppendValue, Nullable, Prettify, SourceBuilder } from '@goast/core';
+import { TsType } from './types';
+import { TsNode } from '../node';
+import { writeTsGenericParameters } from '../utils/write-ts-generic-parameters';
+type Injects = 'modifiers' | 'name' | 'constraint' | 'default';
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | Injects>, {
+    description?: Nullable<BasicAppendValue<TBuilder>>;
+    const?: Nullable<boolean>;
+    name: string;
+    constraint?: Nullable<TsType<TBuilder>>;
+    default?: Nullable<TsType<TBuilder>>;
+}>;
+export declare class TsGenericParameter<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    description: BasicAppendValue<TBuilder> | null;
+    const: boolean;
+    name: string;
+    constraint: TsType<TBuilder> | null;
+    default: TsType<TBuilder> | null;
+    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>) & {
+    write: typeof writeTsGenericParameters;
+};
+export {};

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

@@ -0,0 +1,23 @@
+import { AstNodeOptions, Nullable, Prettify, SourceBuilder } from '@goast/core';
+import { TsType } from './types';
+import { TsNode } from '../node';
+import { writeTsNodes } from '../utils/write-ts-nodes';
+type Injects = never;
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | Injects>, {
+    keyName?: Nullable<string>;
+    keyType: TsType<TBuilder>;
+    valueType: TsType<TBuilder>;
+    readonly?: Nullable<boolean>;
+}>;
+export declare class TsIndexer<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    keyName: string;
+    keyType: TsType<TBuilder>;
+    valueType: TsType<TBuilder>;
+    readonly: boolean;
+    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>) & {
+    write: typeof writeTsNodes;
+};
+export {};

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

@@ -0,0 +1,36 @@
+import { AstNodeOptions, BasicAppendValue, Nullable, Prettify, SourceBuilder } from '@goast/core';
+import { TsDecorator } from './decorator';
+import { TsDoc } from './doc';
+import { TsGenericParameter } from './generic-parameter';
+import { TsIndexer } from './indexer';
+import { TsMethod } from './method';
+import { TsProperty } from './property';
+import { TsReference } from './reference';
+import { TsNode } from '../node';
+import { writeTsNodes } from '../utils/write-ts-nodes';
+type Injects = 'doc' | 'decorators' | 'modifiers' | 'name' | 'generics' | 'extends' | 'body' | 'members';
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | Injects>, {
+    doc?: Nullable<TsDoc<TBuilder>>;
+    decorators?: Nullable<Nullable<TsDecorator<TBuilder>>[]>;
+    export?: Nullable<boolean>;
+    name: string;
+    generics?: Nullable<Nullable<TsGenericParameter<TBuilder> | BasicAppendValue<TBuilder>>[]>;
+    extends?: Nullable<Nullable<TsReference<TBuilder> | BasicAppendValue<TBuilder>>[]>;
+    members?: Nullable<Nullable<Member<TBuilder>>[]>;
+}>;
+type Member<TBuilder extends SourceBuilder> = TsIndexer<TBuilder> | TsProperty<TBuilder> | TsMethod<TBuilder> | BasicAppendValue<TBuilder>;
+export declare class TsInterface<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    doc: TsDoc<TBuilder> | null;
+    decorators: TsDecorator<TBuilder>[];
+    export: boolean;
+    name: string;
+    generics: (TsGenericParameter<TBuilder> | BasicAppendValue<TBuilder>)[];
+    extends: (TsReference<TBuilder> | BasicAppendValue<TBuilder>)[];
+    members: Member<TBuilder>[];
+    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>) & {
+    write: typeof writeTsNodes;
+};
+export {};

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

@@ -0,0 +1,17 @@
+import { AstNodeOptions, Nullable, Prettify, SourceBuilder } from '@goast/core';
+import { TsType } from './types';
+import { TsNode } from '../node';
+import { writeTsNodes } from '../utils/write-ts-nodes';
+type Injects = never;
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | Injects>, {
+    types: Nullable<TsType<TBuilder>>[];
+}>;
+export declare class TsIntersectionType<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    types: TsType<TBuilder>[];
+    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>) & {
+    write: typeof writeTsNodes;
+};
+export {};

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

@@ -0,0 +1,19 @@
+import { AstNodeOptions, SourceBuilder } from '@goast/core';
+import { TsType } from './types';
+import { TsNode } from '../node';
+import { writeTsNodes } from '../utils/write-ts-nodes';
+type Injects = 'type' | 'index';
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | Injects>, {
+    type: TsType<TBuilder>;
+    index: TsType<TBuilder>;
+}>;
+export declare class TsLookupType<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    type: TsType<TBuilder>;
+    index: TsType<TBuilder>;
+    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>) & {
+    write: typeof writeTsNodes;
+};
+export {};

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

@@ -0,0 +1,45 @@
+import { AppendValue, AstNodeOptions, BasicAppendValue, Nullable, Prettify, SourceBuilder } from '@goast/core';
+import { TsDecorator } from './decorator';
+import { TsDoc } from './doc';
+import { TsGenericParameter } from './generic-parameter';
+import { TsParameter } from './parameter';
+import { TsType } from './types';
+import { TsAccessModifier } from '../common';
+import { TsNode } from '../node';
+import { writeTsNodes } from '../utils/write-ts-nodes';
+type Injects = 'doc' | 'decorators' | 'modifiers' | 'name' | 'generics' | 'params' | 'returnType' | 'body';
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | Injects>, {
+    doc?: Nullable<TsDoc<TBuilder>>;
+    decorators?: Nullable<Nullable<TsDecorator<TBuilder>>[]>;
+    accessModifier?: Nullable<TsAccessModifier>;
+    static?: Nullable<boolean>;
+    abstract?: Nullable<boolean>;
+    override?: Nullable<boolean>;
+    name: string;
+    optional?: Nullable<boolean>;
+    generics?: Nullable<Nullable<TsGenericParameter<TBuilder> | BasicAppendValue<TBuilder>>[]>;
+    parameters?: Nullable<Nullable<TsParameter<TBuilder> | BasicAppendValue<TBuilder>>[]>;
+    returnType?: Nullable<TsType<TBuilder>>;
+    body?: Nullable<AppendValue<TBuilder>>;
+}>;
+export declare class TsMethod<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    doc: TsDoc<TBuilder> | null;
+    decorators: TsDecorator<TBuilder>[];
+    accessModifier: TsAccessModifier | null;
+    static: boolean;
+    abstract: boolean;
+    override: boolean;
+    name: string;
+    optional: boolean;
+    generics: (TsGenericParameter<TBuilder> | BasicAppendValue<TBuilder>)[];
+    parameters: (TsParameter<TBuilder> | BasicAppendValue<TBuilder>)[];
+    returnType: TsType<TBuilder> | null;
+    body: AppendValue<TBuilder> | null;
+    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>) & {
+    write: typeof writeTsNodes;
+};
+export {};

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

@@ -0,0 +1,20 @@
+import { AstNodeOptions, BasicAppendValue, Nullable, SourceBuilder } from '@goast/core';
+import { TsIndexer } from './indexer';
+import { TsMethod } from './method';
+import { TsProperty } from './property';
+import { TsNode } from '../node';
+import { writeTsNodes } from '../utils/write-ts-nodes';
+type Injects = never;
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | Injects>, {
+    members?: Nullable<Nullable<Member<TBuilder>>[]>;
+}>;
+type Member<TBuilder extends SourceBuilder> = TsProperty<TBuilder> | TsMethod<TBuilder> | TsIndexer<TBuilder> | BasicAppendValue<TBuilder>;
+export declare class TsObjectType<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    members: Member<TBuilder>[];
+    constructor(options: Options<TBuilder, TInjects>);
+    protected onWrite(builder: TBuilder): void;
+}
+export declare const tsObjectType: (<TBuilder extends SourceBuilder<never>>(options?: Options<TBuilder>) => TsObjectType<TBuilder, never>) & {
+    write: typeof writeTsNodes;
+};
+export {};

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

@@ -0,0 +1,19 @@
+import { AstNodeOptions, BasicAppendValue, Nullable, SourceBuilder } from '@goast/core';
+import { TsNode } from '../node';
+import { writeTsNodes } from '../utils/write-ts-nodes';
+import type { TsMethod } from './method';
+import type { TsProperty } from './property';
+type Injects = never;
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | Injects>, {
+    members?: Nullable<Nullable<Member<TBuilder>>[]>;
+}>;
+type Member<TBuilder extends SourceBuilder> = TsProperty<TBuilder> | TsMethod<TBuilder> | BasicAppendValue<TBuilder>;
+export declare class TsObject<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    members: Member<TBuilder>[];
+    constructor(options: Options<TBuilder, TInjects>);
+    protected onWrite(builder: TBuilder): void;
+}
+export declare const tsObject: (<TBuilder extends SourceBuilder<never>>(options?: Options<TBuilder>) => TsObject<TBuilder, never>) & {
+    write: typeof writeTsNodes;
+};
+export {};

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

@@ -0,0 +1,28 @@
+import { AstNodeOptions, BasicAppendValue, Nullable, Prettify, SourceBuilder } from '@goast/core';
+import { TsDecorator } from './decorator';
+import { TsType, TsValue } from './types';
+import { TsNode } from '../node';
+import { writeTsParameters } from '../utils/write-ts-parameters';
+type Injects = 'decorators' | 'name' | 'type' | 'default';
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | Injects>, {
+    name: string;
+    description?: Nullable<BasicAppendValue<TBuilder>>;
+    decorators?: Nullable<Nullable<TsDecorator<TBuilder>>[]>;
+    type?: Nullable<TsType<TBuilder>>;
+    optional?: Nullable<boolean>;
+    default?: Nullable<TsValue<TBuilder>>;
+}>;
+export declare class TsParameter<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    name: string;
+    description: BasicAppendValue<TBuilder> | null;
+    decorators: TsDecorator<TBuilder>[];
+    type: TsType<TBuilder> | null;
+    optional: boolean;
+    default: TsValue<TBuilder> | null;
+    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>) & {
+    write: typeof writeTsParameters;
+};
+export {};