@goast/typescript 0.8.0 → 0.9.0-beta.2

package/{script → dist}/src/ast/nodes/interface.d.ts

@@ -1,13 +1,13 @@
 import { type AstNodeOptions, type BasicAppendValue, type Nullable, type Prettify, type SourceBuilder } from '@goast/core';
-import { TsNode } from '../node.js';
-import { writeTsNodes } from '../utils/write-ts-nodes.js';
-import { type TsDecorator } from './decorator.js';
-import { type TsDoc } from './doc.js';
-import { type TsGenericParameter } from './generic-parameter.js';
-import type { TsIndexer } from './indexer.js';
-import type { TsMethod } from './method.js';
-import type { TsProperty } from './property.js';
-import type { TsReference } from './reference.js';
+import { TsNode } from '../node.ts';
+import { writeTsNodes } from '../utils/write-ts-nodes.ts';
+import { type TsDecorator } from './decorator.ts';
+import { type TsDoc } from './doc.ts';
+import { type TsGenericParameter } from './generic-parameter.ts';
+import type { TsIndexer } from './indexer.ts';
+import type { TsMethod } from './method.ts';
+import type { TsProperty } from './property.ts';
+import type { TsReference } from './reference.ts';
 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>>;
@@ -30,9 +30,8 @@ export declare class TsInterface<TBuilder extends SourceBuilder, TInjects extend
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-declare const createInterface: <TBuilder extends SourceBuilder>(name: Options<TBuilder>["name"], options?: Prettify<Omit<Options<TBuilder>, "name">>) => TsInterface<TBuilder>;
+declare const createInterface: <TBuilder extends SourceBuilder>(name: Options<TBuilder>['name'], options?: Prettify<Omit<Options<TBuilder>, 'name'>>) => TsInterface<TBuilder>;
 export declare const tsInterface: typeof createInterface & {
     write: typeof writeTsNodes;
 };
 export {};
-//# sourceMappingURL=interface.d.ts.map

package/{esm → dist}/src/ast/nodes/interface.js

@@ -6,58 +6,22 @@ import { tsDecorator } from './decorator.js';
 import { tsDoc } from './doc.js';
 import { tsGenericParameter } from './generic-parameter.js';
 export class TsInterface extends TsNode {
+    doc;
+    decorators;
+    export;
+    name;
+    generics;
+    extends;
+    members;
     constructor(options) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
         super(options);
-        Object.defineProperty(this, "doc", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "decorators", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "export", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "name", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "generics", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "extends", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "members", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.doc = (_a = options.doc) !== null && _a !== void 0 ? _a : null;
-        this.decorators = (_c = (_b = options.decorators) === null || _b === void 0 ? void 0 : _b.filter(notNullish)) !== null && _c !== void 0 ? _c : [];
-        this.export = (_d = options.export) !== null && _d !== void 0 ? _d : false;
+        this.doc = options.doc ?? null;
+        this.decorators = options.decorators?.filter(notNullish) ?? [];
+        this.export = options.export ?? false;
         this.name = options.name;
-        this.generics = (_f = (_e = options.generics) === null || _e === void 0 ? void 0 : _e.filter(notNullish)) !== null && _f !== void 0 ? _f : [];
-        this.extends = (_h = (_g = options.extends) === null || _g === void 0 ? void 0 : _g.filter(notNullish)) !== null && _h !== void 0 ? _h : [];
-        this.members = (_k = (_j = options.members) === null || _j === void 0 ? void 0 : _j.filter(notNullish)) !== null && _k !== void 0 ? _k : [];
+        this.generics = options.generics?.filter(notNullish) ?? [];
+        this.extends = options.extends?.filter(notNullish) ?? [];
+        this.members = options.members?.filter(notNullish) ?? [];
     }
     onWrite(builder) {
         builder.append(this.inject.beforeDoc);

package/{script → dist}/src/ast/nodes/intersection-type.d.ts

@@ -1,7 +1,7 @@
 import { type AstNodeOptions, type Nullable, type Prettify, type SourceBuilder } from '@goast/core';
-import { TsNode } from '../node.js';
-import { writeTsNodes } from '../utils/write-ts-nodes.js';
-import type { TsType } from './types.js';
+import { TsNode } from '../node.ts';
+import { writeTsNodes } from '../utils/write-ts-nodes.ts';
+import type { TsType } from './types.ts';
 type Injects = never;
 type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | Injects>, {
     types: Nullable<TsType<TBuilder>>[];
@@ -11,9 +11,8 @@ export declare class TsIntersectionType<TBuilder extends SourceBuilder, TInjects
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-declare const createIntersectionType: <TBuilder extends SourceBuilder>(types: Options<TBuilder>["types"], options?: Prettify<Omit<Options<TBuilder>, "types">>) => TsIntersectionType<TBuilder>;
+declare const createIntersectionType: <TBuilder extends SourceBuilder>(types: Options<TBuilder>['types'], options?: Prettify<Omit<Options<TBuilder>, 'types'>>) => TsIntersectionType<TBuilder>;
 export declare const tsIntersectionType: typeof createIntersectionType & {
     write: typeof writeTsNodes;
 };
 export {};
-//# sourceMappingURL=intersection-type.d.ts.map

package/{esm → dist}/src/ast/nodes/intersection-type.js

@@ -2,14 +2,9 @@ import { notNullish } from '@goast/core';
 import { TsNode } from '../node.js';
 import { writeTsNode, writeTsNodes } from '../utils/write-ts-nodes.js';
 export class TsIntersectionType extends TsNode {
+    types;
     constructor(options) {
         super(options);
-        Object.defineProperty(this, "types", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         this.types = options.types.filter(notNullish);
     }
     onWrite(builder) {

package/{esm → dist}/src/ast/nodes/lookup-type.d.ts

@@ -1,7 +1,7 @@
 import type { AstNodeOptions, SourceBuilder } from '@goast/core';
-import { TsNode } from '../node.js';
-import { writeTsNodes } from '../utils/write-ts-nodes.js';
-import type { TsType } from './types.js';
+import { TsNode } from '../node.ts';
+import { writeTsNodes } from '../utils/write-ts-nodes.ts';
+import type { TsType } from './types.ts';
 type Injects = 'type' | 'index';
 type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | Injects>, {
     type: TsType<TBuilder>;
@@ -13,9 +13,8 @@ export declare class TsLookupType<TBuilder extends SourceBuilder, TInjects exten
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-declare const createLookupType: <TBuilder extends SourceBuilder>(type: Options<TBuilder>["type"], index: Options<TBuilder>["index"], options?: Omit<Options<TBuilder>, "type" | "index">) => TsLookupType<TBuilder>;
+declare const createLookupType: <TBuilder extends SourceBuilder>(type: Options<TBuilder>['type'], index: Options<TBuilder>['index'], options?: Omit<Options<TBuilder>, 'type' | 'index'>) => TsLookupType<TBuilder>;
 export declare const tsLookupType: typeof createLookupType & {
     write: typeof writeTsNodes;
 };
 export {};
-//# sourceMappingURL=lookup-type.d.ts.map

package/{esm → dist}/src/ast/nodes/lookup-type.js

@@ -1,20 +1,10 @@
 import { TsNode } from '../node.js';
 import { writeTsNode, writeTsNodes } from '../utils/write-ts-nodes.js';
 export class TsLookupType extends TsNode {
+    type;
+    index;
     constructor(options) {
         super(options);
-        Object.defineProperty(this, "type", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "index", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         this.type = options.type;
         this.index = options.index;
     }

package/{script → dist}/src/ast/nodes/method.d.ts

@@ -1,12 +1,12 @@
 import { type AppendValue, type AstNodeOptions, type BasicAppendValue, type Nullable, type Prettify, type SourceBuilder } from '@goast/core';
-import type { TsAccessModifier } from '../common.js';
-import { TsNode } from '../node.js';
-import { writeTsNodes } from '../utils/write-ts-nodes.js';
-import { type TsDecorator } from './decorator.js';
-import { type TsDoc } from './doc.js';
-import { type TsGenericParameter } from './generic-parameter.js';
-import { type TsParameter } from './parameter.js';
-import type { TsType } from './types.js';
+import type { TsAccessModifier } from '../common.ts';
+import { TsNode } from '../node.ts';
+import { writeTsNodes } from '../utils/write-ts-nodes.ts';
+import { type TsDecorator } from './decorator.ts';
+import { type TsDoc } from './doc.ts';
+import { type TsGenericParameter } from './generic-parameter.ts';
+import { type TsParameter } from './parameter.ts';
+import type { TsType } from './types.ts';
 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>>;
@@ -40,9 +40,8 @@ export declare class TsMethod<TBuilder extends SourceBuilder, TInjects extends s
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-export declare const createMethod: <TBuilder extends SourceBuilder>(name: Options<TBuilder>["name"], options?: Prettify<Omit<Options<TBuilder>, "name">>) => TsMethod<TBuilder>;
+export declare const createMethod: <TBuilder extends SourceBuilder>(name: Options<TBuilder>['name'], options?: Prettify<Omit<Options<TBuilder>, 'name'>>) => TsMethod<TBuilder>;
 export declare const tsMethod: typeof createMethod & {
     write: typeof writeTsNodes;
 };
 export {};
-//# sourceMappingURL=method.d.ts.map

package/dist/src/ast/nodes/method.js

@@ -0,0 +1,92 @@
+import { notNullish, } from '@goast/core';
+import { TsNode } from '../node.js';
+import { writeTsNode, writeTsNodes } from '../utils/write-ts-nodes.js';
+import { tsDecorator } from './decorator.js';
+import { tsDoc } from './doc.js';
+import { tsGenericParameter } from './generic-parameter.js';
+import { TsObject } from './object.js';
+import { tsParameter } from './parameter.js';
+export class TsMethod extends TsNode {
+    doc;
+    decorators;
+    accessModifier;
+    static;
+    abstract;
+    override;
+    async;
+    name;
+    optional;
+    generics;
+    parameters;
+    returnType;
+    body;
+    constructor(options) {
+        super(options);
+        this.doc = options.doc ?? null;
+        this.decorators = options.decorators?.filter(notNullish) ?? [];
+        this.accessModifier = options.accessModifier ?? null;
+        this.static = options.static ?? false;
+        this.abstract = options.abstract ?? false;
+        this.override = options.override ?? false;
+        this.async = options.async ?? false;
+        this.name = options.name;
+        this.optional = options.optional ?? false;
+        this.generics = options.generics?.filter(notNullish) ?? [];
+        this.parameters = options.parameters?.filter(notNullish) ?? [];
+        this.returnType = options.returnType ?? null;
+        this.body = options.body ?? null;
+    }
+    onWrite(builder) {
+        const isInObjectDeclaration = this.getParentNode(builder) instanceof TsObject;
+        builder.append(this.inject.beforeDoc);
+        tsDoc.write(builder, tsDoc.get(this.doc, { generics: this.generics, parameters: this.parameters }));
+        builder.append(this.inject.afterDoc);
+        builder.append(this.inject.beforeDecorators);
+        tsDecorator.write(builder, this.decorators, { multiline: true });
+        builder.append(this.inject.afterDecorators);
+        builder.append(this.inject.beforeModifiers);
+        if (this.accessModifier)
+            builder.append(this.accessModifier, ' ');
+        if (this.static)
+            builder.append('static ');
+        if (this.abstract)
+            builder.append('abstract ');
+        if (this.override)
+            builder.append('override ');
+        if (this.async)
+            builder.append('async ');
+        builder.append(this.inject.afterModifiers);
+        builder.append(this.inject.beforeName, this.name, this.inject.afterName);
+        if (this.optional)
+            builder.append('?');
+        builder.append(this.inject.beforeGenerics);
+        tsGenericParameter.write(builder, this.generics);
+        builder.append(this.inject.afterGenerics);
+        builder.append(this.inject.beforeParams);
+        tsParameter.write(builder, this.parameters);
+        builder.append(this.inject.afterParams);
+        if (this.returnType) {
+            builder.append(': ');
+            builder.append(this.inject.beforeReturnType);
+            writeTsNode(builder, this.returnType);
+            builder.append(this.inject.afterReturnType);
+        }
+        if (this.body) {
+            builder.append(' ');
+            builder.append(this.inject.beforeBody);
+            builder.parenthesize('{}', this.body, { multiline: !!this.body });
+            builder.append(this.inject.afterBody);
+        }
+        else if (!isInObjectDeclaration) {
+            builder.append(';');
+        }
+        if (isInObjectDeclaration) {
+            builder.append(',');
+        }
+        builder.appendLine();
+    }
+}
+export const createMethod = (name, options) => new TsMethod({ ...options, name });
+export const tsMethod = Object.assign(createMethod, {
+    write: writeTsNodes,
+});

package/{script → dist}/src/ast/nodes/object-type.d.ts

@@ -1,9 +1,9 @@
 import { type AstNodeOptions, type BasicAppendValue, type Nullable, type SourceBuilder } from '@goast/core';
-import { TsNode } from '../node.js';
-import { writeTsNodes } from '../utils/write-ts-nodes.js';
-import type { TsIndexer } from './indexer.js';
-import type { TsMethod } from './method.js';
-import type { TsProperty } from './property.js';
+import { TsNode } from '../node.ts';
+import { writeTsNodes } from '../utils/write-ts-nodes.ts';
+import type { TsIndexer } from './indexer.ts';
+import type { TsMethod } from './method.ts';
+import type { TsProperty } from './property.ts';
 type Injects = never;
 type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | Injects>, {
     members?: Nullable<Nullable<Member<TBuilder>>[]>;
@@ -19,4 +19,3 @@ export declare const tsObjectType: typeof createObjectType & {
     write: typeof writeTsNodes;
 };
 export {};
-//# sourceMappingURL=object-type.d.ts.map

package/{esm → dist}/src/ast/nodes/object-type.js

@@ -3,16 +3,10 @@ import { TsNode } from '../node.js';
 import { writeTsMembers } from '../utils/write-ts-members.js';
 import { writeTsNodes } from '../utils/write-ts-nodes.js';
 export class TsObjectType extends TsNode {
+    members;
     constructor(options) {
-        var _a, _b;
         super(options);
-        Object.defineProperty(this, "members", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.members = (_b = (_a = options.members) === null || _a === void 0 ? void 0 : _a.filter(notNullish)) !== null && _b !== void 0 ? _b : [];
+        this.members = options.members?.filter(notNullish) ?? [];
     }
     onWrite(builder) {
         builder.parenthesize('{}', (b) => {
@@ -20,7 +14,7 @@ export class TsObjectType extends TsNode {
         }, { multiline: this.members.length > 0 });
     }
 }
-const createObjectType = (options) => new TsObjectType(options !== null && options !== void 0 ? options : {});
+const createObjectType = (options) => new TsObjectType(options ?? {});
 export const tsObjectType = Object.assign(createObjectType, {
     write: writeTsNodes,
 });

package/{esm → dist}/src/ast/nodes/object.d.ts

@@ -1,8 +1,8 @@
 import { type AstNodeOptions, type BasicAppendValue, type Nullable, type SourceBuilder } from '@goast/core';
-import { TsNode } from '../node.js';
-import { writeTsNodes } from '../utils/write-ts-nodes.js';
-import type { TsMethod } from './method.js';
-import type { TsProperty } from './property.js';
+import { TsNode } from '../node.ts';
+import { writeTsNodes } from '../utils/write-ts-nodes.ts';
+import type { TsMethod } from './method.ts';
+import type { TsProperty } from './property.ts';
 type Injects = never;
 type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | Injects>, {
     members?: Nullable<Nullable<Member<TBuilder>>[]>;
@@ -18,4 +18,3 @@ export declare const tsObject: typeof createObject & {
     write: typeof writeTsNodes;
 };
 export {};
-//# sourceMappingURL=object.d.ts.map

package/{esm → dist}/src/ast/nodes/object.js

@@ -3,16 +3,10 @@ import { TsNode } from '../node.js';
 import { writeTsMembers } from '../utils/write-ts-members.js';
 import { writeTsNodes } from '../utils/write-ts-nodes.js';
 export class TsObject extends TsNode {
+    members;
     constructor(options) {
-        var _a, _b;
         super(options);
-        Object.defineProperty(this, "members", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.members = (_b = (_a = options.members) === null || _a === void 0 ? void 0 : _a.filter(notNullish)) !== null && _b !== void 0 ? _b : [];
+        this.members = options.members?.filter(notNullish) ?? [];
     }
     onWrite(builder) {
         builder.parenthesize('{}', (b) => {
@@ -20,7 +14,7 @@ export class TsObject extends TsNode {
         }, { multiline: this.members.length > 0 });
     }
 }
-const createObject = (options) => new TsObject(options !== null && options !== void 0 ? options : {});
+const createObject = (options) => new TsObject(options ?? {});
 export const tsObject = Object.assign(createObject, {
     write: writeTsNodes,
 });

package/{script → dist}/src/ast/nodes/parameter.d.ts

@@ -1,8 +1,8 @@
 import { type AstNodeOptions, type BasicAppendValue, type Nullable, type Prettify, type SourceBuilder } from '@goast/core';
-import { TsNode } from '../node.js';
-import { writeTsParameters } from '../utils/write-ts-parameters.js';
-import { type TsDecorator } from './decorator.js';
-import type { TsType, TsValue } from './types.js';
+import { TsNode } from '../node.ts';
+import { writeTsParameters } from '../utils/write-ts-parameters.ts';
+import { type TsDecorator } from './decorator.ts';
+import type { TsType, TsValue } from './types.ts';
 type Injects = 'decorators' | 'name' | 'type' | 'default';
 type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | Injects>, {
     name: string;
@@ -22,9 +22,8 @@ export declare class TsParameter<TBuilder extends SourceBuilder, TInjects extend
     constructor(options: Options<TBuilder, TInjects>);
     protected onWrite(builder: TBuilder): void;
 }
-declare const createParameter: <TBuilder extends SourceBuilder>(name: Options<TBuilder>["name"], options?: Prettify<Omit<Options<TBuilder>, "name">>) => TsParameter<TBuilder>;
+declare const createParameter: <TBuilder extends SourceBuilder>(name: Options<TBuilder>['name'], options?: Prettify<Omit<Options<TBuilder>, 'name'>>) => TsParameter<TBuilder>;
 export declare const tsParameter: typeof createParameter & {
     write: typeof writeTsParameters;
 };
 export {};
-//# sourceMappingURL=parameter.d.ts.map

package/dist/src/ast/nodes/parameter.js

@@ -0,0 +1,46 @@
+import { notNullish, } from '@goast/core';
+import { TsNode } from '../node.js';
+import { writeTsNode } from '../utils/write-ts-nodes.js';
+import { writeTsParameters } from '../utils/write-ts-parameters.js';
+import { tsDecorator } from './decorator.js';
+export class TsParameter extends TsNode {
+    name;
+    description;
+    decorators;
+    type;
+    optional;
+    default;
+    constructor(options) {
+        super(options);
+        this.name = options.name;
+        this.description = options.description ?? null;
+        this.decorators = options.decorators?.filter(notNullish) ?? [];
+        this.type = options.type ?? null;
+        this.optional = options.optional ?? false;
+        this.default = options.default ?? null;
+    }
+    onWrite(builder) {
+        builder.append(this.inject.beforeDecorators);
+        tsDecorator.write(builder, this.decorators);
+        builder.append(this.inject.afterDecorators);
+        builder.append(this.inject.beforeName, this.name, this.inject.afterName);
+        if (this.optional)
+            builder.append('?');
+        if (this.type) {
+            builder.append(': ');
+            builder.append(this.inject.beforeType);
+            writeTsNode(builder, this.type);
+            builder.append(this.inject.afterType);
+        }
+        if (this.default) {
+            builder.append(' = ');
+            builder.append(this.inject.beforeDefault);
+            writeTsNode(builder, this.default);
+            builder.append(this.inject.afterDefault);
+        }
+    }
+}
+const createParameter = (name, options) => new TsParameter({ ...options, name });
+export const tsParameter = Object.assign(createParameter, {
+    write: writeTsParameters,
+});

package/{esm → dist}/src/ast/nodes/property-accessor.d.ts

@@ -1,10 +1,10 @@
 import { type AppendValue, type AstNodeOptions, type Nullable, type SourceBuilder } from '@goast/core';
-import type { TsAccessModifier } from '../common.js';
-import { TsNode } from '../node.js';
-import { type TsDecorator } from './decorator.js';
-import { type TsDoc } from './doc.js';
-import type { TsProperty } from './property.js';
-import type { TsType } from './types.js';
+import type { TsAccessModifier } from '../common.ts';
+import { TsNode } from '../node.ts';
+import { type TsDecorator } from './decorator.ts';
+import { type TsDoc } from './doc.ts';
+import type { TsProperty } from './property.ts';
+import type { TsType } from './types.ts';
 type Injects = never;
 type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | Injects>, {
     propertyName?: Nullable<string>;
@@ -51,4 +51,3 @@ export declare class TsPropertyGetter<TBuilder extends SourceBuilder, TInjects e
 export declare const createPropertySetter: <TBuilder extends SourceBuilder>(options?: Options<TBuilder>) => TsPropertySetter<TBuilder>;
 export declare const createPropertyGetter: <TBuilder extends SourceBuilder>(options?: Options<TBuilder>) => TsPropertyGetter<TBuilder>;
 export {};
-//# sourceMappingURL=property-accessor.d.ts.map

package/dist/src/ast/nodes/property-accessor.js

@@ -0,0 +1,124 @@
+import { notNullish } from '@goast/core';
+import { TsNode } from '../node.js';
+import { writeTsNode } from '../utils/write-ts-nodes.js';
+import { tsDecorator } from './decorator.js';
+import { tsDoc } from './doc.js';
+class TsPropertyAccessor extends TsNode {
+    _propertyName;
+    _type;
+    _accessModifier;
+    _static;
+    _abstract;
+    _override;
+    doc;
+    decorators;
+    body;
+    get propertyName() {
+        return this.property?.name ?? this._propertyName ?? 'someProperty';
+    }
+    set propertyName(value) {
+        this._propertyName = value;
+    }
+    get type() {
+        return this.property?.type ?? this._type;
+    }
+    set type(value) {
+        this._type = value;
+    }
+    get accessModifier() {
+        return this.property?.accessModifier ?? this._accessModifier;
+    }
+    set accessModifier(value) {
+        this._accessModifier = value;
+    }
+    get static() {
+        return this.property?.static ?? this._static;
+    }
+    set static(value) {
+        this._static = value;
+    }
+    get abstract() {
+        return this.property?.abstract ?? this._abstract;
+    }
+    set abstract(value) {
+        this._abstract = value;
+    }
+    get override() {
+        return this.property?.override ?? this._override;
+    }
+    set override(value) {
+        this._override = value;
+    }
+    property;
+    constructor(options) {
+        super(options);
+        this._propertyName = options.propertyName ?? null;
+        this.doc = options.doc ?? null;
+        this._type = options.type ?? null;
+        this.decorators = options.decorators?.filter(notNullish) ?? [];
+        this.body = options.body ?? null;
+        this._accessModifier = options.accessModifier ?? null;
+        this._static = options.static ?? false;
+        this._abstract = options.abstract ?? false;
+        this._override = options.override ?? false;
+    }
+}
+export class TsPropertySetter extends TsPropertyAccessor {
+    onWrite(builder) {
+        tsDoc.write(builder, this.doc);
+        tsDecorator.write(builder, this.decorators);
+        if (this.accessModifier)
+            builder.append(this.accessModifier, ' ');
+        if (this.static)
+            builder.append('static ');
+        if (this.abstract)
+            builder.append('abstract ');
+        if (this.override)
+            builder.append('override ');
+        builder.append('set ', this.propertyName);
+        builder.parenthesize('()', (b) => {
+            b.append('value');
+            if (this.type !== null) {
+                b.append(': ');
+                writeTsNode(b, this.type);
+            }
+        });
+        if (this.body !== null) {
+            builder.append(' ');
+            builder.parenthesize('{}', this.body, { multiline: true });
+        }
+        else {
+            builder.append(';');
+        }
+        builder.appendLine();
+    }
+}
+export class TsPropertyGetter extends TsPropertyAccessor {
+    onWrite(builder) {
+        tsDoc.write(builder, this.doc);
+        tsDecorator.write(builder, this.decorators);
+        if (this.accessModifier)
+            builder.append(this.accessModifier, ' ');
+        if (this.static)
+            builder.append('static ');
+        if (this.abstract)
+            builder.append('abstract ');
+        if (this.override)
+            builder.append('override ');
+        builder.append('get ', this.propertyName, '()');
+        if (this.type) {
+            builder.append(': ');
+            writeTsNode(builder, this.type);
+        }
+        if (this.body !== null) {
+            builder.append(' ');
+            builder.parenthesize('{}', this.body, { multiline: true });
+        }
+        else {
+            builder.append(';');
+        }
+        builder.appendLine();
+    }
+}
+export const createPropertySetter = (options) => new TsPropertySetter(options ?? {});
+export const createPropertyGetter = (options) => new TsPropertyGetter(options ?? {});