@goast/typescript 0.3.1 → 0.3.3

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

@@ -1,5 +1,6 @@
 import { AstNodeOptions, Nullable, Prettify, SourceBuilder, TupleWithCount } from '@goast/core';
 import { TsType } from './types';
+import { TypeScriptImportType } from '../../common-results';
 import { TsNode } from '../node';
 import { writeTsNodes } from '../utils/write-ts-nodes';
 type Injects = never;
@@ -7,7 +8,11 @@ type Options<TBuilder extends SourceBuilder, TInjects extends string = never> =
     name: string;
     moduleNameOrfilePath?: Nullable<string>;
     generics?: Nullable<Nullable<TsType<TBuilder>>[]>;
+    importType?: Nullable<TypeScriptImportType>;
 }>;
+type FactoryOptions<TBuilder extends SourceBuilder> = {
+    importType?: Nullable<TypeScriptImportType>;
+};
 type _AddImportHandler<T> = {
     builderClass: abstract new (...args: any[]) => T;
     handler: (builder: T, reference: TsReference<any>) => void;
@@ -17,11 +22,12 @@ export declare class TsReference<TBuilder extends SourceBuilder, TInjects extend
     name: string;
     moduleNameOrfilePath: string | null;
     generics: TsType<TBuilder>[];
+    importType: TypeScriptImportType;
     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>() => TsReference<TBuilder, never>) & {
+declare function _createFactory(name: string, moduleNameOrfilePath?: Nullable<string>): (<TBuilder extends SourceBuilder>(options?: FactoryOptions<TBuilder>) => TsReference<TBuilder, never>) & {
     refName: string;
     moduleNameOrfilePath: Nullable<string>;
 };
@@ -29,7 +35,7 @@ declare function createFactory(name: string, moduleNameOrfilePath: string): Retu
     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>(generics: TupleWithCount<TsType<TBuilder>, TGenericCount>) => TsReference<TBuilder, never>) & {
+declare function _createGenericFactory<TGenericCount extends number | number[]>(name: string, moduleNameOrfilePath?: Nullable<string>): (<TBuilder extends SourceBuilder>(generics: TupleWithCount<TsType<TBuilder>, TGenericCount>, options?: FactoryOptions<TBuilder>) => TsReference<TBuilder, never>) & {
     refName: string;
     moduleNameOrfilePath: Nullable<string>;
     infer: <TBuilder extends SourceBuilder>() => TsReference<TBuilder, never>;

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

@@ -1,41 +1,55 @@
-export declare const inject: (<TBuilder extends import("@goast/core").SourceBuilder>() => import("../nodes/reference").TsReference<TBuilder, never>) & {
+export declare const inject: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: {
+    importType?: import("@goast/core").Nullable<import("../../common-results").TypeScriptImportType>;
+}) => 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>() => import("../nodes/reference").TsReference<TBuilder, never>) & {
+export declare const injectable: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: {
+    importType?: import("@goast/core").Nullable<import("../../common-results").TypeScriptImportType>;
+}) => 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>() => import("../nodes/reference").TsReference<TBuilder, never>) & {
+export declare const provider: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: {
+    importType?: import("@goast/core").Nullable<import("../../common-results").TypeScriptImportType>;
+}) => 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>() => import("../nodes/reference").TsReference<TBuilder, never>) & {
+export declare const httpClient: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: {
+    importType?: import("@goast/core").Nullable<import("../../common-results").TypeScriptImportType>;
+}) => 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>() => import("../nodes/reference").TsReference<TBuilder, never>) & {
+export declare const httpContext: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: {
+    importType?: import("@goast/core").Nullable<import("../../common-results").TypeScriptImportType>;
+}) => 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>(generics: [import("../_index").Type<TBuilder>]) => import("../nodes/reference").TsReference<TBuilder, never>) & {
+export declare const httpResponse: (<TBuilder extends import("@goast/core").SourceBuilder>(generics: [import("../_index").Type<TBuilder>], options?: {
+    importType?: import("@goast/core").Nullable<import("../../common-results").TypeScriptImportType>;
+} | undefined) => import("../nodes/reference").TsReference<TBuilder, never>) & {
     refName: string;
     moduleNameOrfilePath: import("@goast/core").Nullable<string>;
     infer: <TBuilder extends import("@goast/core").SourceBuilder>() => import("../nodes/reference").TsReference<TBuilder, never>;
 } & {
     moduleNameOrfilePath: string;
 };
-export declare const httpErrorResponse: (<TBuilder extends import("@goast/core").SourceBuilder>() => import("../nodes/reference").TsReference<TBuilder, never>) & {
+export declare const httpErrorResponse: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: {
+    importType?: import("@goast/core").Nullable<import("../../common-results").TypeScriptImportType>;
+}) => import("../nodes/reference").TsReference<TBuilder, never>) & {
     refName: string;
     moduleNameOrfilePath: import("@goast/core").Nullable<string>;
 } & {

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

@@ -1,23 +1,31 @@
-export declare const easyNetworkStub: (<TBuilder extends import("@goast/core").SourceBuilder>() => import("../nodes/reference").TsReference<TBuilder, never>) & {
+export declare const easyNetworkStub: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: {
+    importType?: import("@goast/core").Nullable<import("../../common-results").TypeScriptImportType>;
+}) => 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>() => import("../nodes/reference").TsReference<TBuilder, never>) & {
+export declare const httpMethod: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: {
+    importType?: import("@goast/core").Nullable<import("../../common-results").TypeScriptImportType>;
+}) => 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>(generics: [import("../_index").Type<TBuilder>, import("../_index").Type<TBuilder>]) => import("../nodes/reference").TsReference<TBuilder, never>) & {
+export declare const routeResponseCallback: (<TBuilder extends import("@goast/core").SourceBuilder>(generics: [import("../_index").Type<TBuilder>, import("../_index").Type<TBuilder>], options?: {
+    importType?: import("@goast/core").Nullable<import("../../common-results").TypeScriptImportType>;
+} | undefined) => import("../nodes/reference").TsReference<TBuilder, never>) & {
     refName: string;
     moduleNameOrfilePath: import("@goast/core").Nullable<string>;
     infer: <TBuilder extends import("@goast/core").SourceBuilder>() => import("../nodes/reference").TsReference<TBuilder, never>;
 } & {
     moduleNameOrfilePath: string;
 };
-export declare const errorResponse: (<TBuilder extends import("@goast/core").SourceBuilder>(generics: [import("../_index").Type<TBuilder>]) => import("../nodes/reference").TsReference<TBuilder, never>) & {
+export declare const errorResponse: (<TBuilder extends import("@goast/core").SourceBuilder>(generics: [import("../_index").Type<TBuilder>], options?: {
+    importType?: import("@goast/core").Nullable<import("../../common-results").TypeScriptImportType>;
+} | undefined) => import("../nodes/reference").TsReference<TBuilder, never>) & {
     refName: string;
     moduleNameOrfilePath: import("@goast/core").Nullable<string>;
     infer: <TBuilder extends import("@goast/core").SourceBuilder>() => import("../nodes/reference").TsReference<TBuilder, never>;

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

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

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

@@ -0,0 +1,24 @@
+export declare const jsonValue: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: {
+    importType?: import("@goast/core").Nullable<import("../../common-results").TypeScriptImportType>;
+}) => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+} & {
+    moduleNameOrfilePath: string;
+};
+export declare const response: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: {
+    importType?: import("@goast/core").Nullable<import("../../common-results").TypeScriptImportType>;
+}) => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+} & {
+    moduleNameOrfilePath: string;
+};
+export declare const params: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: {
+    importType?: import("@goast/core").Nullable<import("../../common-results").TypeScriptImportType>;
+}) => import("../nodes/reference").TsReference<TBuilder, never>) & {
+    refName: string;
+    moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+} & {
+    moduleNameOrfilePath: string;
+};

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

@@ -1,28 +1,38 @@
-export declare const observable: (<TBuilder extends import("@goast/core").SourceBuilder>() => import("../nodes/reference").TsReference<TBuilder, never>) & {
+export declare const observable: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: {
+    importType?: import("@goast/core").Nullable<import("../../common-results").TypeScriptImportType>;
+}) => 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>() => import("../nodes/reference").TsReference<TBuilder, never>) & {
+export declare const firstValueFrom: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: {
+    importType?: import("@goast/core").Nullable<import("../../common-results").TypeScriptImportType>;
+}) => 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>() => import("../nodes/reference").TsReference<TBuilder, never>) & {
+export declare const filter: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: {
+    importType?: import("@goast/core").Nullable<import("../../common-results").TypeScriptImportType>;
+}) => 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>() => import("../nodes/reference").TsReference<TBuilder, never>) & {
+export declare const map: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: {
+    importType?: import("@goast/core").Nullable<import("../../common-results").TypeScriptImportType>;
+}) => 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>() => import("../nodes/reference").TsReference<TBuilder, never>) & {
+export declare const take: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: {
+    importType?: import("@goast/core").Nullable<import("../../common-results").TypeScriptImportType>;
+}) => import("../nodes/reference").TsReference<TBuilder, never>) & {
     refName: string;
     moduleNameOrfilePath: import("@goast/core").Nullable<string>;
 } & {

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

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

package/types/lib/common-results.d.ts

@@ -9,8 +9,10 @@ export type TypeScriptExportOutput = {
     filePath: string;
 };
 export type TypeScriptImportKind = 'module' | 'file';
+export type TypeScriptImportType = 'import' | 'type-import' | 'js-doc';
 export type TypeScriptImport = {
     kind: TypeScriptImportKind;
+    type: TypeScriptImportType;
     modulePath: string;
     name: string;
 };

package/types/lib/file-builder.d.ts

@@ -2,7 +2,7 @@ import { AppendParam, AppendValue, Nullable, SourceBuilder } from '@goast/core';
 import { TsNode } from './ast/node';
 import { TypeScriptGeneratorConfig } from './config';
 import { TypeScriptModelGeneratorOutput } from './generators';
-import { ImportExportCollection } from './import-collection';
+import { ImportExportCollection, TypeScriptImportOptions } from './import-collection';
 export type TypeScriptAppends<TAdditionalAppends> = TsNode<TypeScriptFileBuilder> | TAdditionalAppends;
 export type TypeScriptAppendParam<TBuilder extends TypeScriptFileBuilder, TAdditionalAppends> = AppendParam<TBuilder, TypeScriptAppends<TAdditionalAppends>>;
 export declare function isTypeScriptAppendValue<TBuilder extends TypeScriptFileBuilder = TypeScriptFileBuilder>(value: unknown): value is AppendValue<TBuilder>;
@@ -11,12 +11,12 @@ export declare class TypeScriptFileBuilder<TAdditionalAppends = never> extends S
     readonly imports: ImportExportCollection;
     get options(): TypeScriptGeneratorConfig;
     constructor(filePath?: string, options?: TypeScriptGeneratorConfig);
-    addImport(name: string, moduleNameOrfilePath: string): this;
+    addImport(name: string, moduleNameOrfilePath: string, options?: TypeScriptImportOptions): this;
     addExport(name: string, filePath: string): this;
     clear(): void;
     toString(addPadding?: boolean): string;
     protected appendSingle(value: TypeScriptAppendParam<this, TAdditionalAppends>): void;
-    appendModelUsage(type: TypeScriptModelGeneratorOutput): this;
+    appendModelUsage(type: TypeScriptModelGeneratorOutput, options?: TypeScriptImportOptions): this;
     writeToFile(filePath?: string): void;
     static generate(options: {
         filePath: string;

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

@@ -1,5 +1,6 @@
 export * from './file-generator';
 export * from './models';
 export * from './services/angular-services';
-export * from './services/fetch-clients';
 export * from './services/easy-network-stub';
+export * from './services/fetch-clients';
+export * from './services/k6-clients';

package/types/lib/generators/services/angular-services/refs.d.ts

@@ -1,45 +1,59 @@
 import { ts } from '../../../ast';
 import type { TypeScriptAngularServicesGeneratorConfig } from './models';
 export declare function getReferenceFactories(options: TypeScriptAngularServicesGeneratorConfig): {
-    abortablePromise: (<TBuilder extends import("@goast/core").SourceBuilder>(generics: [ts.Type<TBuilder>]) => ts.Reference<TBuilder, never>) & {
+    abortablePromise: (<TBuilder extends import("@goast/core").SourceBuilder>(generics: [ts.Type<TBuilder>], options?: {
+        importType?: import("@goast/core").Nullable<import("../../../common-results").TypeScriptImportType>;
+    } | undefined) => ts.Reference<TBuilder, never>) & {
         refName: string;
         moduleNameOrfilePath: import("@goast/core").Nullable<string>;
         infer: <TBuilder extends import("@goast/core").SourceBuilder>() => ts.Reference<TBuilder, never>;
     } & {
         moduleNameOrfilePath: string;
     };
-    waitForResponse: (<TBuilder extends import("@goast/core").SourceBuilder>(generics: [ts.Type<TBuilder>]) => ts.Reference<TBuilder, never>) & {
+    waitForResponse: (<TBuilder extends import("@goast/core").SourceBuilder>(generics: [ts.Type<TBuilder>], options?: {
+        importType?: import("@goast/core").Nullable<import("../../../common-results").TypeScriptImportType>;
+    } | undefined) => ts.Reference<TBuilder, never>) & {
         refName: string;
         moduleNameOrfilePath: import("@goast/core").Nullable<string>;
         infer: <TBuilder extends import("@goast/core").SourceBuilder>() => ts.Reference<TBuilder, never>;
     } & {
         moduleNameOrfilePath: string;
     };
-    requestBuilder: (<TBuilder extends import("@goast/core").SourceBuilder>() => ts.Reference<TBuilder, never>) & {
+    requestBuilder: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: {
+        importType?: import("@goast/core").Nullable<import("../../../common-results").TypeScriptImportType>;
+    }) => ts.Reference<TBuilder, never>) & {
         refName: string;
         moduleNameOrfilePath: import("@goast/core").Nullable<string>;
     } & {
         moduleNameOrfilePath: string;
     };
-    apiConfiguration: (<TBuilder extends import("@goast/core").SourceBuilder>() => ts.Reference<TBuilder, never>) & {
+    apiConfiguration: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: {
+        importType?: import("@goast/core").Nullable<import("../../../common-results").TypeScriptImportType>;
+    }) => ts.Reference<TBuilder, never>) & {
         refName: string;
         moduleNameOrfilePath: import("@goast/core").Nullable<string>;
     } & {
         moduleNameOrfilePath: string;
     };
-    apiBaseService: (<TBuilder extends import("@goast/core").SourceBuilder>() => ts.Reference<TBuilder, never>) & {
+    apiBaseService: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: {
+        importType?: import("@goast/core").Nullable<import("../../../common-results").TypeScriptImportType>;
+    }) => ts.Reference<TBuilder, never>) & {
         refName: string;
         moduleNameOrfilePath: import("@goast/core").Nullable<string>;
     } & {
         moduleNameOrfilePath: string;
     };
-    httpStatusCode: (<TBuilder extends import("@goast/core").SourceBuilder>() => ts.Reference<TBuilder, never>) & {
+    httpStatusCode: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: {
+        importType?: import("@goast/core").Nullable<import("../../../common-results").TypeScriptImportType>;
+    }) => ts.Reference<TBuilder, never>) & {
         refName: string;
         moduleNameOrfilePath: import("@goast/core").Nullable<string>;
     } & {
         moduleNameOrfilePath: string;
     };
-    provide: (<TBuilder extends import("@goast/core").SourceBuilder>() => ts.Reference<TBuilder, never>) & {
+    provide: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: {
+        importType?: import("@goast/core").Nullable<import("../../../common-results").TypeScriptImportType>;
+    }) => ts.Reference<TBuilder, never>) & {
         refName: string;
         moduleNameOrfilePath: import("@goast/core").Nullable<string>;
     } & {