@goast/typescript 0.0.5 → 0.2.1

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

@@ -0,0 +1,53 @@
+import { SourceBuilder, AstNodeOptions, AppendValue, Nullable } from '@goast/core';
+import { TsDecorator } from './decorator';
+import { TsDoc } from './doc';
+import { TsProperty } from './property';
+import { TsType } from './types';
+import { TsAccessModifier } from '../common';
+import { TsNode } from '../node';
+type Injects = never;
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | Injects>, {
+    propertyName?: Nullable<string>;
+    doc?: Nullable<TsDoc<TBuilder>>;
+    type?: Nullable<TsType<TBuilder>>;
+    decorators?: Nullable<Nullable<TsDecorator<TBuilder>>[]>;
+    body?: Nullable<AppendValue<TBuilder>>;
+    accessModifier?: Nullable<TsAccessModifier>;
+    static?: Nullable<boolean>;
+    abstract?: Nullable<boolean>;
+    override?: Nullable<boolean>;
+}>;
+declare abstract class TsPropertyAccessor<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    private _propertyName;
+    private _type;
+    private _accessModifier;
+    private _static;
+    private _abstract;
+    private _override;
+    doc: TsDoc<TBuilder> | null;
+    decorators: TsDecorator<TBuilder>[];
+    body: AppendValue<TBuilder> | null;
+    get propertyName(): string;
+    set propertyName(value: string | null);
+    get type(): TsType<TBuilder> | null;
+    set type(value: TsType<TBuilder> | null);
+    get accessModifier(): TsAccessModifier | null;
+    set accessModifier(value: TsAccessModifier | null);
+    get static(): boolean;
+    set static(value: boolean);
+    get abstract(): boolean;
+    set abstract(value: boolean);
+    get override(): boolean;
+    set override(value: boolean);
+    protected property?: TsProperty<TBuilder>;
+    constructor(options: Options<TBuilder, TInjects>);
+}
+export declare class TsPropertySetter<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsPropertyAccessor<TBuilder, TInjects> {
+    protected onWrite(builder: TBuilder): void;
+}
+export declare class TsPropertyGetter<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsPropertyAccessor<TBuilder, TInjects> {
+    protected onWrite(builder: TBuilder): void;
+}
+export declare const createPropertySetter: <TBuilder extends SourceBuilder<never>>(options?: Options<TBuilder>) => TsPropertySetter<TBuilder, never>;
+export declare const createPropertyGetter: <TBuilder extends SourceBuilder<never>>(options?: Options<TBuilder>) => TsPropertyGetter<TBuilder, never>;
+export {};

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

@@ -0,0 +1,84 @@
+import { AstNodeOptions, Nullable, Prettify, SourceBuilder } from '@goast/core';
+import { TsDecorator } from './decorator';
+import { TsDoc } from './doc';
+import { TsPropertyGetter, TsPropertySetter } from './property-accessor';
+import { TsType, TsValue } from './types';
+import { TsAccessModifier } from '../common';
+import { TsNode } from '../node';
+import { writeTsNodes } from '../utils/write-ts-nodes';
+type BaseInjects = never;
+type BaseOptions<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | BaseInjects>, {
+    name: string;
+    doc?: Nullable<TsDoc<TBuilder>>;
+    decorators?: Nullable<Nullable<TsDecorator<TBuilder>>[]>;
+    type?: Nullable<TsType<TBuilder>>;
+    accessModifier?: Nullable<TsAccessModifier>;
+    static?: Nullable<boolean>;
+    abstract?: Nullable<boolean>;
+    override?: Nullable<boolean>;
+}>;
+type SimpleOptions<TBuilder extends SourceBuilder, TInjects extends string = never> = BaseOptions<TBuilder, TInjects> & {
+    value?: Nullable<TsValue<TBuilder>>;
+    readonly?: Nullable<boolean>;
+    optional?: Nullable<boolean>;
+};
+type AccessorOptions<TBuilder extends SourceBuilder, TInjects extends string = never> = BaseOptions<TBuilder, TInjects> & {
+    get?: Nullable<TsPropertyGetter<TBuilder>>;
+    set?: Nullable<TsPropertySetter<TBuilder>>;
+};
+export declare abstract class TsProperty<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | BaseInjects> {
+    name: string;
+    doc: TsDoc<TBuilder> | null;
+    decorators: TsDecorator<TBuilder>[];
+    type: TsType<TBuilder> | null;
+    accessModifier: TsAccessModifier | null;
+    static: boolean | null;
+    abstract: boolean | null;
+    override: boolean | null;
+    constructor(options: BaseOptions<TBuilder, TInjects>);
+}
+export declare class TsSimpleProperty<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsProperty<TBuilder, TInjects> {
+    value: TsValue<TBuilder> | null;
+    readonly: boolean;
+    optional: boolean;
+    constructor(options: SimpleOptions<TBuilder, TInjects>);
+    protected onWrite(builder: TBuilder): void;
+}
+export declare class TsAccessorProperty<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsProperty<TBuilder, TInjects> {
+    private _get;
+    private _set;
+    get get(): TsPropertyGetter<TBuilder> | null;
+    set get(value: TsPropertyGetter<TBuilder> | null);
+    get set(): TsPropertySetter<TBuilder> | null;
+    set set(value: TsPropertySetter<TBuilder> | null);
+    constructor(options: AccessorOptions<TBuilder, TInjects>);
+    protected onWrite(builder: TBuilder): void;
+}
+export declare const tsProperty: (<TBuilder extends SourceBuilder<never>>(name: BaseOptions<TBuilder>['name'], options?: Prettify<Omit<SimpleOptions<TBuilder>, 'name'>> | Prettify<Omit<AccessorOptions<TBuilder>, 'name'>>) => TsAccessorProperty<TBuilder, ""> | TsSimpleProperty<TBuilder, "">) & {
+    write: typeof writeTsNodes;
+    getter: <TBuilder_1 extends SourceBuilder<never>>(options?: {
+        propertyName?: Nullable<string>;
+        doc?: Nullable<TsDoc<TBuilder_1, never>>;
+        type?: Nullable<TsType<TBuilder_1>>;
+        decorators?: Nullable<Nullable<TsDecorator<TBuilder_1, never>>[]>;
+        body?: Nullable<import("@goast/core").AppendValue<TBuilder_1>>;
+        accessModifier?: Nullable<TsAccessModifier>;
+        static?: Nullable<boolean>;
+        abstract?: Nullable<boolean>;
+        override?: Nullable<boolean>;
+        inject?: import("@goast/core").AstNodeInject<TBuilder_1, ""> | undefined;
+    } | undefined) => TsPropertyGetter<TBuilder_1, never>;
+    setter: <TBuilder_2 extends SourceBuilder<never>>(options?: {
+        propertyName?: Nullable<string>;
+        doc?: Nullable<TsDoc<TBuilder_2, never>>;
+        type?: Nullable<TsType<TBuilder_2>>;
+        decorators?: Nullable<Nullable<TsDecorator<TBuilder_2, never>>[]>;
+        body?: Nullable<import("@goast/core").AppendValue<TBuilder_2>>;
+        accessModifier?: Nullable<TsAccessModifier>;
+        static?: Nullable<boolean>;
+        abstract?: Nullable<boolean>;
+        override?: Nullable<boolean>;
+        inject?: import("@goast/core").AstNodeInject<TBuilder_2, ""> | undefined;
+    } | undefined) => TsPropertySetter<TBuilder_2, never>;
+};
+export {};

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

@@ -0,0 +1,46 @@
+import { AstNodeOptions, Nullable, Prettify, SourceBuilder, TupleWithCount } 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>, {
+    name: string;
+    moduleNameOrfilePath?: Nullable<string>;
+    generics?: Nullable<Nullable<TsType<TBuilder>>[]>;
+}>;
+type _AddImportHandler<T> = {
+    builderClass: abstract new (...args: any[]) => T;
+    handler: (builder: T, reference: TsReference<any>) => void;
+};
+export declare class TsReference<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    private static readonly addImportHandlers;
+    name: string;
+    moduleNameOrfilePath: string | null;
+    generics: TsType<TBuilder>[];
+    constructor(options: Options<TBuilder, TInjects>);
+    protected onWrite(builder: TBuilder): void;
+    static registerAddImportHandler<TBuilder extends SourceBuilder>(builderClass: _AddImportHandler<TBuilder>['builderClass'], handler: _AddImportHandler<TBuilder>['handler']): void;
+}
+declare function _createFactory(name: string, moduleNameOrfilePath?: Nullable<string>): (<TBuilder extends SourceBuilder<never>>() => TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: Nullable<string>;
+};
+declare function createFactory(name: string, moduleNameOrfilePath: string): ReturnType<typeof _createFactory> & {
+    moduleNameOrfilePath: string;
+};
+declare function createFactory(name: string, moduleNameOrfilePath?: Nullable<string>): ReturnType<typeof _createFactory>;
+declare function _createGenericFactory<TGenericCount extends number | number[]>(name: string, moduleNameOrfilePath?: Nullable<string>): (<TBuilder extends SourceBuilder<never>>(generics: TupleWithCount<TsType<TBuilder>, TGenericCount>) => TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: Nullable<string>;
+    infer: <TBuilder_1 extends SourceBuilder<never>>() => TsReference<TBuilder_1, never>;
+};
+declare function createGenericFactory<TGenericCount extends number | number[]>(name: string, moduleNameOrfilePath: string): ReturnType<typeof _createGenericFactory<TGenericCount>> & {
+    moduleNameOrfilePath: string;
+};
+declare function createGenericFactory<TGenericCount extends number | number[]>(name: string, moduleNameOrfilePath?: Nullable<string>): ReturnType<typeof _createGenericFactory<TGenericCount>>;
+export declare const tsReference: (<TBuilder extends SourceBuilder<never>>(name: Options<TBuilder>['name'], moduleNameOrfilePath?: Options<TBuilder>['moduleNameOrfilePath'], options?: Prettify<Omit<Options<TBuilder>, 'name' | 'moduleNameOrfilePath'>>) => TsReference<TBuilder, never>) & {
+    factory: typeof createFactory;
+    genericFactory: typeof createGenericFactory;
+    write: typeof writeTsNodes;
+};
+export {};

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

@@ -0,0 +1,18 @@
+import { AstNodeOptions, Nullable, 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>, {
+    value: string;
+    template?: Nullable<boolean>;
+}>;
+export declare class TsString<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    value: string;
+    template: boolean;
+    constructor(options: Options<TBuilder, TInjects>);
+    protected onWrite(builder: TBuilder): void;
+}
+export declare const tsString: (<TBuilder extends SourceBuilder<never>>(value: Options<TBuilder>['value'], options?: Prettify<Omit<Options<TBuilder>, 'value'>>) => TsString<TBuilder, never>) & {
+    write: typeof writeTsNodes;
+};
+export {};

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

@@ -0,0 +1,17 @@
+import { AstNodeOptions, Nullable, Prettify, SourceBuilder } from '@goast/core';
+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>, {
+    elements: Nullable<TsType<TBuilder> | TsValue<TBuilder>>[];
+}>;
+export declare class TsTuple<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    elements: (TsType<TBuilder> | TsValue<TBuilder>)[];
+    constructor(options: Options<TBuilder, TInjects>);
+    protected onWrite(builder: TBuilder): void;
+}
+export declare const tsTuple: (<TBuilder extends SourceBuilder<never>>(elements: Options<TBuilder>['elements'], options?: Prettify<Omit<Options<TBuilder>, 'elements'>>) => TsTuple<TBuilder, never>) & {
+    write: typeof writeTsNodes;
+};
+export {};

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

@@ -0,0 +1,27 @@
+import { AstNodeOptions, BasicAppendValue, Nullable, Prettify, SourceBuilder } from '@goast/core';
+import { TsDoc } from './doc';
+import { TsGenericParameter } from './generic-parameter';
+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>, {
+    name: string;
+    doc?: Nullable<TsDoc<TBuilder>>;
+    generics?: Nullable<Nullable<TsGenericParameter<TBuilder> | BasicAppendValue<TBuilder>>[]>;
+    type: TsType<TBuilder>;
+    export?: Nullable<boolean>;
+}>;
+export declare class TsTypeAlias<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    name: string;
+    doc: TsDoc<TBuilder> | null;
+    generics: (TsGenericParameter<TBuilder> | BasicAppendValue<TBuilder>)[];
+    type: TsType<TBuilder>;
+    export: boolean;
+    constructor(options: Options<TBuilder, TInjects>);
+    protected onWrite(builder: TBuilder): void;
+}
+export declare const tsTypeAlias: (<TBuilder extends SourceBuilder<never>>(name: Options<TBuilder>['name'], type: Options<TBuilder>['type'], options?: Prettify<Omit<Options<TBuilder>, 'name' | 'type'>>) => TsTypeAlias<TBuilder, never>) & {
+    write: typeof writeTsNodes;
+};
+export {};

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

@@ -0,0 +1,18 @@
+import { SourceBuilder, AstNodeOptions } from '@goast/core';
+import { TsValue } from './types';
+import { TsNode } from '../node';
+import { writeTsNodes } from '../utils/write-ts-nodes';
+type Injects = 'value';
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<typeof TsNode<TBuilder, TInjects | Injects>, {
+    value: TsValue<TBuilder>;
+}>;
+export declare class TsTypeof<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    value: TsValue<TBuilder>;
+    constructor(options: Options<TBuilder, TInjects>);
+    protected onWrite(builder: TBuilder): void;
+}
+export declare const createTypeof: <TBuilder extends SourceBuilder<never>>(value: Options<TBuilder>['value'], options?: Omit<Options<TBuilder>, 'value'>) => TsTypeof<TBuilder, never>;
+export declare const tsTypeof: (<TBuilder extends SourceBuilder<never>>(value: Options<TBuilder>['value'], options?: Omit<Options<TBuilder>, 'value'>) => TsTypeof<TBuilder, never>) & {
+    write: typeof writeTsNodes;
+};
+export {};

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

@@ -0,0 +1,18 @@
+import type { TsArrayType } from './array-type';
+import type { TsArrowFunction } from './arrow-function';
+import type { TsCall } from './call';
+import type { TsClass } from './class';
+import type { TsFunction } from './function';
+import type { TsFunctionType } from './function-type';
+import type { TsIntersectionType } from './intersection-type';
+import type { TsLookupType } from './lookup-type';
+import type { TsObject } from './object';
+import type { TsObjectType } from './object-type';
+import type { TsReference } from './reference';
+import type { TsString } from './string';
+import type { TsTuple } from './tuple';
+import type { TsTypeof } from './typeof';
+import type { TsUnionType } from './union-type';
+import type { BasicAppendValue, SourceBuilder } from '@goast/core';
+export type TsType<TBuilder extends SourceBuilder> = BasicAppendValue<TBuilder> | TsIntersectionType<TBuilder> | TsUnionType<TBuilder> | TsArrayType<TBuilder> | TsFunctionType<TBuilder> | TsObjectType<TBuilder> | TsString<TBuilder> | TsLookupType<TBuilder> | TsTypeof<TBuilder> | TsReference<TBuilder>;
+export type TsValue<TBuilder extends SourceBuilder> = BasicAppendValue<TBuilder> | TsObject<TBuilder> | TsTuple<TBuilder> | TsString<TBuilder> | TsArrowFunction<TBuilder> | TsFunction<TBuilder> | TsClass<TBuilder> | TsCall<TBuilder> | TsReference<TBuilder>;

package/types/lib/ast/nodes/union-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 TsUnionType<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 tsUnionType: (<TBuilder extends SourceBuilder<never>>(types: Options<TBuilder>['types'], options?: Prettify<Omit<Options<TBuilder>, 'types'>>) => TsUnionType<TBuilder, never>) & {
+    write: typeof writeTsNodes;
+};
+export {};

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

@@ -0,0 +1,28 @@
+import { AstNodeOptions, Nullable, Prettify, SourceBuilder } from '@goast/core';
+import { TsDoc } from './doc';
+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>, {
+    name: string;
+    doc?: Nullable<TsDoc<TBuilder>>;
+    type?: Nullable<TsType<TBuilder>>;
+    value?: Nullable<TsValue<TBuilder>>;
+    export?: Nullable<boolean>;
+    readonly?: Nullable<boolean>;
+}>;
+export declare class TsVariable<TBuilder extends SourceBuilder, TInjects extends string = never> extends TsNode<TBuilder, TInjects | Injects> {
+    name: string;
+    doc: TsDoc<TBuilder> | null;
+    type: TsType<TBuilder> | null;
+    value: TsValue<TBuilder> | null;
+    export: boolean;
+    readonly: boolean;
+    constructor(options: Options<TBuilder, TInjects>);
+    protected onWrite(builder: TBuilder): void;
+}
+export declare const tsVariable: (<TBuilder extends SourceBuilder<never>>(name: Options<TBuilder>['name'], options?: Prettify<Omit<Options<TBuilder>, 'name'>>) => TsVariable<TBuilder, never>) & {
+    write: typeof writeTsNodes;
+};
+export {};

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

@@ -0,0 +1,37 @@
+export declare const inject: (<TBuilder extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+} & {
+    moduleNameOrfilePath: string;
+};
+export declare const injectable: (<TBuilder extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+} & {
+    moduleNameOrfilePath: string;
+};
+export declare const provider: (<TBuilder extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+} & {
+    moduleNameOrfilePath: string;
+};
+export declare const httpClient: (<TBuilder extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+} & {
+    moduleNameOrfilePath: string;
+};
+export declare const httpContext: (<TBuilder extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+} & {
+    moduleNameOrfilePath: string;
+};
+export declare const httpResponse: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(generics: [import("../_index").Type<TBuilder>]) => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+    infer: <TBuilder_1 extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder_1, never>;
+} & {
+    moduleNameOrfilePath: string;
+};

package/types/lib/ast/references/easy-network-stub.d.ts

@@ -0,0 +1,26 @@
+export declare const easyNetworkStub: (<TBuilder extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+} & {
+    moduleNameOrfilePath: string;
+};
+export declare const httpMethod: (<TBuilder extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+} & {
+    moduleNameOrfilePath: string;
+};
+export declare const routeResponseCallback: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(generics: [import("../_index").Type<TBuilder>, import("../_index").Type<TBuilder>]) => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+    infer: <TBuilder_1 extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder_1, never>;
+} & {
+    moduleNameOrfilePath: string;
+};
+export declare const errorResponse: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(generics: [import("../_index").Type<TBuilder>]) => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+    infer: <TBuilder_1 extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder_1, never>;
+} & {
+    moduleNameOrfilePath: string;
+};

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

@@ -0,0 +1,4 @@
+export * as easyNetworkStub from './easy-network-stub';
+export * as angular from './angular';
+export * as rxjs from './rxjs';
+export * from './typescript';

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

@@ -0,0 +1,30 @@
+export declare const observable: (<TBuilder extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+} & {
+    moduleNameOrfilePath: string;
+};
+export declare const firstValueFrom: (<TBuilder extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+} & {
+    moduleNameOrfilePath: string;
+};
+export declare const filter: (<TBuilder extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+} & {
+    moduleNameOrfilePath: string;
+};
+export declare const map: (<TBuilder extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+} & {
+    moduleNameOrfilePath: string;
+};
+export declare const take: (<TBuilder extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+} & {
+    moduleNameOrfilePath: string;
+};

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

@@ -0,0 +1,133 @@
+export declare const any: (<TBuilder extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+};
+export declare const unknown: (<TBuilder extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+};
+export declare const void_: (<TBuilder extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+};
+export declare const never: (<TBuilder extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+};
+export declare const number: (<TBuilder extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+};
+export declare const string: (<TBuilder extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+};
+export declare const boolean: (<TBuilder extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+};
+export declare const bigint: (<TBuilder extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+};
+export declare const symbol: (<TBuilder extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+};
+export declare const object: (<TBuilder extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+};
+export declare const undefined_: (<TBuilder extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+};
+export declare const null_: (<TBuilder extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+};
+export declare const array: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(generics: [import("../_index").Type<TBuilder>]) => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+    infer: <TBuilder_1 extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder_1, never>;
+};
+export declare const record: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(generics: [import("../_index").Type<TBuilder>, import("../_index").Type<TBuilder>]) => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+    infer: <TBuilder_1 extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder_1, never>;
+};
+export declare const map: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(generics: [import("../_index").Type<TBuilder>, import("../_index").Type<TBuilder>]) => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+    infer: <TBuilder_1 extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder_1, never>;
+};
+export declare const set: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(generics: [import("../_index").Type<TBuilder>]) => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+    infer: <TBuilder_1 extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder_1, never>;
+};
+export declare const promise: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(generics: [import("../_index").Type<TBuilder>]) => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+    infer: <TBuilder_1 extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder_1, never>;
+};
+export declare const readonlyArray: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(generics: [import("../_index").Type<TBuilder>]) => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+    infer: <TBuilder_1 extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder_1, never>;
+};
+export declare const readonly: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(generics: [import("../_index").Type<TBuilder>]) => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+    infer: <TBuilder_1 extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder_1, never>;
+};
+export declare const partial: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(generics: [import("../_index").Type<TBuilder>]) => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+    infer: <TBuilder_1 extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder_1, never>;
+};
+export declare const required: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(generics: [import("../_index").Type<TBuilder>]) => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+    infer: <TBuilder_1 extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder_1, never>;
+};
+export declare const pick: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(generics: [import("../_index").Type<TBuilder>, import("../_index").Type<TBuilder>]) => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+    infer: <TBuilder_1 extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder_1, never>;
+};
+export declare const omit: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(generics: [import("../_index").Type<TBuilder>, import("../_index").Type<TBuilder>]) => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+    infer: <TBuilder_1 extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder_1, never>;
+};
+export declare const exclude: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(generics: [import("../_index").Type<TBuilder>, import("../_index").Type<TBuilder>]) => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+    infer: <TBuilder_1 extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder_1, never>;
+};
+export declare const extract: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(generics: [import("../_index").Type<TBuilder>, import("../_index").Type<TBuilder>]) => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+    infer: <TBuilder_1 extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder_1, never>;
+};
+export declare const nonNullable: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(generics: [import("../_index").Type<TBuilder>]) => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+    infer: <TBuilder_1 extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder_1, never>;
+};
+export declare const parameters: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(generics: [import("../_index").Type<TBuilder>]) => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+    infer: <TBuilder_1 extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder_1, never>;
+};
+export declare const returnType: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(generics: [import("../_index").Type<TBuilder>]) => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+    infer: <TBuilder_1 extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder_1, never>;
+};
+export declare const instanceType: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(generics: [import("../_index").Type<TBuilder>]) => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+    infer: <TBuilder_1 extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder_1, never>;
+};

package/types/lib/ast/utils/get-type-script-builder-options.d.ts

@@ -0,0 +1,3 @@
+import { StringBuilder } from '@goast/core';
+import { TypeScriptGeneratorConfig } from '../../config';
+export declare function getTypeScriptBuilderOptions(builder: StringBuilder): TypeScriptGeneratorConfig;

package/types/lib/ast/utils/to-ts-node.d.ts

@@ -0,0 +1,8 @@
+import { SourceBuilder, BasicAppendValue } from '@goast/core';
+import { TsObject } from '../nodes/object';
+import { TsString } from '../nodes/string';
+import { TsTuple } from '../nodes/tuple';
+export declare function toTsNode<TBuilder extends SourceBuilder>(object: Record<string, unknown>): TsObject<TBuilder>;
+export declare function toTsNode<TBuilder extends SourceBuilder>(tuple: unknown[]): TsTuple<TBuilder>;
+export declare function toTsNode<TBuilder extends SourceBuilder>(string: string): TsString<TBuilder>;
+export declare function toTsNode<TBuilder extends SourceBuilder>(value: unknown): BasicAppendValue<TBuilder>;

package/types/lib/ast/utils/write-ts-generic-parameters.d.ts

@@ -0,0 +1,3 @@
+import { SourceBuilder, SingleOrMultiple, Nullable, AppendValue } from '@goast/core';
+import { TsNode } from '../node';
+export declare function writeTsGenericParameters<TBuilder extends SourceBuilder>(builder: TBuilder, nodes: SingleOrMultiple<Nullable<TsNode<TBuilder> | AppendValue<TBuilder>>>): void;

package/types/lib/ast/utils/write-ts-members.d.ts

@@ -0,0 +1,5 @@
+import { SourceBuilder, Nullable, AppendValue } from '@goast/core';
+import { TsNode } from '../node';
+export declare function writeTsMembers<TBuilder extends SourceBuilder>(builder: TBuilder, members: Nullable<AppendValue<TBuilder> | TsNode<TBuilder>>[], options?: {
+    alreadyHasMembers?: boolean;
+}): void;

package/types/lib/ast/utils/write-ts-nodes.d.ts

@@ -0,0 +1,6 @@
+import { SourceBuilder, Nullable, AppendValue, SingleOrMultiple, Separator } from '@goast/core';
+import { TsNode } from '../node';
+export declare function writeTsNode<TBuilder extends SourceBuilder>(builder: TBuilder, node: Nullable<AppendValue<TBuilder> | TsNode<TBuilder>>): void;
+export declare function writeTsNodes<TBuilder extends SourceBuilder>(builder: TBuilder, nodes: SingleOrMultiple<Nullable<AppendValue<TBuilder> | TsNode<TBuilder>>>, options?: {
+    separator?: Separator<TBuilder, AppendValue<TBuilder> | TsNode<TBuilder>>;
+}): void;

package/types/lib/ast/utils/write-ts-parameters.d.ts

@@ -0,0 +1,3 @@
+import { SourceBuilder, SingleOrMultiple, Nullable, AppendValue } from '@goast/core';
+import { TsNode } from '../node';
+export declare function writeTsParameters<TBuilder extends SourceBuilder>(builder: TBuilder, nodes: SingleOrMultiple<Nullable<TsNode<TBuilder> | AppendValue<TBuilder>>>): void;