@goast/typescript 0.2.19 → 0.3.0

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

@@ -21,7 +21,7 @@ export declare class TsReference<TBuilder extends SourceBuilder, TInjects extend
     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>) & {
+declare function _createFactory(name: string, moduleNameOrfilePath?: Nullable<string>): (<TBuilder extends SourceBuilder>() => TsReference<TBuilder, never>) & {
     refName: string;
     moduleNameOrfilePath: Nullable<string>;
 };
@@ -29,16 +29,16 @@ 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<never>>(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>) => TsReference<TBuilder, never>) & {
     refName: string;
     moduleNameOrfilePath: Nullable<string>;
-    infer: <TBuilder_1 extends SourceBuilder<never>>() => TsReference<TBuilder_1, never>;
+    infer: <TBuilder extends SourceBuilder>() => TsReference<TBuilder, 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>) & {
+export declare const tsReference: (<TBuilder extends SourceBuilder>(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;

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

@@ -12,7 +12,7 @@ export declare class TsString<TBuilder extends SourceBuilder, TInjects extends s
     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>) & {
+export declare const tsString: (<TBuilder extends SourceBuilder>(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

@@ -13,7 +13,7 @@ export declare class TsTuple<TBuilder extends SourceBuilder, TInjects extends st
     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>) & {
+export declare const tsTuple: (<TBuilder extends SourceBuilder>(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

@@ -21,7 +21,7 @@ export declare class TsTypeAlias<TBuilder extends SourceBuilder, TInjects extend
     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>) & {
+export declare const tsTypeAlias: (<TBuilder extends SourceBuilder>(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

@@ -11,8 +11,8 @@ export declare class TsTypeof<TBuilder extends SourceBuilder, TInjects extends s
     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>) & {
+export declare const createTypeof: <TBuilder extends SourceBuilder>(value: Options<TBuilder>["value"], options?: Omit<Options<TBuilder>, "value">) => TsTypeof<TBuilder, never>;
+export declare const tsTypeof: (<TBuilder extends SourceBuilder>(value: Options<TBuilder>["value"], options?: Omit<Options<TBuilder>, "value">) => TsTypeof<TBuilder, never>) & {
     write: typeof writeTsNodes;
 };
 export {};

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

@@ -11,7 +11,7 @@ export declare class TsUnionType<TBuilder extends SourceBuilder, TInjects extend
     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>) & {
+export declare const tsUnionType: (<TBuilder extends SourceBuilder>(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

@@ -22,7 +22,7 @@ export declare class TsVariable<TBuilder extends SourceBuilder, TInjects extends
     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>) & {
+export declare const tsVariable: (<TBuilder extends SourceBuilder>(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

@@ -1,41 +1,41 @@
-export declare const inject: (<TBuilder extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder, never>) & {
+export declare const inject: (<TBuilder extends import("@goast/core").SourceBuilder>() => 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>) & {
+export declare const injectable: (<TBuilder extends import("@goast/core").SourceBuilder>() => 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>) & {
+export declare const provider: (<TBuilder extends import("@goast/core").SourceBuilder>() => 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>) & {
+export declare const httpClient: (<TBuilder extends import("@goast/core").SourceBuilder>() => 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>) & {
+export declare const httpContext: (<TBuilder extends import("@goast/core").SourceBuilder>() => 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>) & {
+export declare const httpResponse: (<TBuilder extends import("@goast/core").SourceBuilder>(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>;
+    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<never>>() => import("../nodes/reference").TsReference<TBuilder, never>) & {
+export declare const httpErrorResponse: (<TBuilder extends import("@goast/core").SourceBuilder>() => 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,26 +1,26 @@
-export declare const easyNetworkStub: (<TBuilder extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder, never>) & {
+export declare const easyNetworkStub: (<TBuilder extends import("@goast/core").SourceBuilder>() => 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>) & {
+export declare const httpMethod: (<TBuilder extends import("@goast/core").SourceBuilder>() => 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>) & {
+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>) & {
     refName: string;
     moduleNameOrfilePath: import("@goast/core").Nullable<string>;
-    infer: <TBuilder_1 extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder_1, never>;
+    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<never>>(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>]) => 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>;
+    infer: <TBuilder extends import("@goast/core").SourceBuilder>() => import("../nodes/reference").TsReference<TBuilder, never>;
 } & {
     moduleNameOrfilePath: string;
 };

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

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

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

@@ -1,133 +1,133 @@
-export declare const any: (<TBuilder extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder, never>) & {
+export declare const any: (<TBuilder extends import("@goast/core").SourceBuilder>() => 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>) & {
+export declare const unknown: (<TBuilder extends import("@goast/core").SourceBuilder>() => 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>) & {
+export declare const void_: (<TBuilder extends import("@goast/core").SourceBuilder>() => 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>) & {
+export declare const never: (<TBuilder extends import("@goast/core").SourceBuilder>() => 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>) & {
+export declare const number: (<TBuilder extends import("@goast/core").SourceBuilder>() => 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>) & {
+export declare const string: (<TBuilder extends import("@goast/core").SourceBuilder>() => 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>) & {
+export declare const boolean: (<TBuilder extends import("@goast/core").SourceBuilder>() => 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>) & {
+export declare const bigint: (<TBuilder extends import("@goast/core").SourceBuilder>() => 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>) & {
+export declare const symbol: (<TBuilder extends import("@goast/core").SourceBuilder>() => 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>) & {
+export declare const object: (<TBuilder extends import("@goast/core").SourceBuilder>() => 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>) & {
+export declare const undefined_: (<TBuilder extends import("@goast/core").SourceBuilder>() => 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>) & {
+export declare const null_: (<TBuilder extends import("@goast/core").SourceBuilder>() => 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>) & {
+export declare const array: (<TBuilder extends import("@goast/core").SourceBuilder>(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>;
+    infer: <TBuilder extends import("@goast/core").SourceBuilder>() => import("../nodes/reference").TsReference<TBuilder, 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>) & {
+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>) & {
     refName: string;
     moduleNameOrfilePath: import("@goast/core").Nullable<string>;
-    infer: <TBuilder_1 extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder_1, never>;
+    infer: <TBuilder extends import("@goast/core").SourceBuilder>() => import("../nodes/reference").TsReference<TBuilder, 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>) & {
+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>) & {
     refName: string;
     moduleNameOrfilePath: import("@goast/core").Nullable<string>;
-    infer: <TBuilder_1 extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder_1, never>;
+    infer: <TBuilder extends import("@goast/core").SourceBuilder>() => import("../nodes/reference").TsReference<TBuilder, never>;
 };
-export declare const set: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(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>]) => 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>;
+    infer: <TBuilder extends import("@goast/core").SourceBuilder>() => import("../nodes/reference").TsReference<TBuilder, never>;
 };
-export declare const promise: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(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>]) => 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>;
+    infer: <TBuilder extends import("@goast/core").SourceBuilder>() => import("../nodes/reference").TsReference<TBuilder, never>;
 };
-export declare const readonlyArray: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(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>]) => 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>;
+    infer: <TBuilder extends import("@goast/core").SourceBuilder>() => import("../nodes/reference").TsReference<TBuilder, never>;
 };
-export declare const readonly: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(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>]) => 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>;
+    infer: <TBuilder extends import("@goast/core").SourceBuilder>() => import("../nodes/reference").TsReference<TBuilder, never>;
 };
-export declare const partial: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(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>]) => 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>;
+    infer: <TBuilder extends import("@goast/core").SourceBuilder>() => import("../nodes/reference").TsReference<TBuilder, never>;
 };
-export declare const required: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(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>]) => 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>;
+    infer: <TBuilder extends import("@goast/core").SourceBuilder>() => import("../nodes/reference").TsReference<TBuilder, 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>) & {
+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>) & {
     refName: string;
     moduleNameOrfilePath: import("@goast/core").Nullable<string>;
-    infer: <TBuilder_1 extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder_1, never>;
+    infer: <TBuilder extends import("@goast/core").SourceBuilder>() => import("../nodes/reference").TsReference<TBuilder, 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>) & {
+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>) & {
     refName: string;
     moduleNameOrfilePath: import("@goast/core").Nullable<string>;
-    infer: <TBuilder_1 extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder_1, never>;
+    infer: <TBuilder extends import("@goast/core").SourceBuilder>() => import("../nodes/reference").TsReference<TBuilder, 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>) & {
+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>) & {
     refName: string;
     moduleNameOrfilePath: import("@goast/core").Nullable<string>;
-    infer: <TBuilder_1 extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder_1, never>;
+    infer: <TBuilder extends import("@goast/core").SourceBuilder>() => import("../nodes/reference").TsReference<TBuilder, 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>) & {
+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>) & {
     refName: string;
     moduleNameOrfilePath: import("@goast/core").Nullable<string>;
-    infer: <TBuilder_1 extends import("@goast/core").SourceBuilder<never>>() => import("../nodes/reference").TsReference<TBuilder_1, never>;
+    infer: <TBuilder extends import("@goast/core").SourceBuilder>() => import("../nodes/reference").TsReference<TBuilder, never>;
 };
-export declare const nonNullable: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(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>]) => 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>;
+    infer: <TBuilder extends import("@goast/core").SourceBuilder>() => import("../nodes/reference").TsReference<TBuilder, never>;
 };
-export declare const parameters: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(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>]) => 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>;
+    infer: <TBuilder extends import("@goast/core").SourceBuilder>() => import("../nodes/reference").TsReference<TBuilder, never>;
 };
-export declare const returnType: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(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>]) => 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>;
+    infer: <TBuilder extends import("@goast/core").SourceBuilder>() => import("../nodes/reference").TsReference<TBuilder, never>;
 };
-export declare const instanceType: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(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>]) => 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>;
+    infer: <TBuilder extends import("@goast/core").SourceBuilder>() => import("../nodes/reference").TsReference<TBuilder, never>;
 };

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

@@ -2,6 +2,7 @@ export type TypeScriptComponentOutput = {
     component: string;
     filePath?: string;
     imports: TypeScriptImport[];
+    additionalExports?: string[];
 };
 export type TypeScriptExportOutput = {
     component: string;

package/types/lib/config.d.ts

@@ -1,16 +1,60 @@
-import { DefaultGenerationProviderConfig, OpenApiGeneratorConfig, StringCasing, StringCasingWithOptions } from '@goast/core';
+import { DefaultGenerationProviderConfig, ExtendedStringCasing, OpenApiGeneratorConfig } from '@goast/core';
 import { ImportModuleTransformer } from './utils';
 export type TypeScriptGeneratorConfig = OpenApiGeneratorConfig & {
+    /**
+     * The transformer to use for transforming import module paths.
+     * @default 'omit-extension'
+     */
     importModuleTransformer: ImportModuleTransformer;
-    fileNameCasing: StringCasing | StringCasingWithOptions;
-    typeNameCasing: StringCasing | StringCasingWithOptions;
-    functionNameCasing: StringCasing | StringCasingWithOptions;
-    propertyNameCasing: StringCasing | StringCasingWithOptions;
-    enumValueNameCasing: StringCasing | StringCasingWithOptions;
-    constantNameCasing: StringCasing | StringCasingWithOptions;
-    paramNameCasing: StringCasing | StringCasingWithOptions;
-    genericParamNameCasing: StringCasing | StringCasingWithOptions;
+    /**
+     * The casing to use for file names.
+     * @default 'kebab'
+     */
+    fileNameCasing: ExtendedStringCasing;
+    /**
+     * The casing to use for type names.
+     * @default 'pascal'
+     */
+    typeNameCasing: ExtendedStringCasing;
+    /**
+     * The casing to use for function names.
+     * @default 'camel'
+     */
+    functionNameCasing: ExtendedStringCasing;
+    /**
+     * The casing to use for property names.
+     * @default 'camel'
+     */
+    propertyNameCasing: ExtendedStringCasing;
+    /**
+     * The casing to use for enum value names.
+     * @default 'pascal'
+     */
+    enumValueNameCasing: ExtendedStringCasing;
+    /**
+     * The casing to use for constant names.
+     * @default { casing: 'snake', wordCasing: 'all-upper' }
+     */
+    constantNameCasing: ExtendedStringCasing;
+    /**
+     * The casing to use for generic parameter names.
+     * @default { casing: 'pascal', prefix: 'T' }
+     */
+    genericParamNameCasing: ExtendedStringCasing;
+    /**
+     * The casing to use for parameter names.
+     * @default 'camel'
+     */
+    paramNameCasing: ExtendedStringCasing;
+    /**
+     * Whether to prefer `unknown` over `any`.
+     * @default true
+     */
     preferUnknown: boolean;
+    /**
+     * Whether to use single quotes for strings.
+     * @default true
+     */
     useSingleQuotes: boolean;
 };
 export declare const defaultTypeScriptGeneratorConfig: DefaultGenerationProviderConfig<TypeScriptGeneratorConfig>;

package/types/lib/generators/models/model-generator.d.ts

@@ -35,7 +35,7 @@ export declare class DefaultTypeScriptModelGenerator extends TypeScriptFileGener
     protected getDiscriminatorTypeName(ctx: Context, schema: ApiSchema): string;
     protected getBaseTypeName(ctx: Context, schema: ApiSchema): string;
     protected getInheritedSchemas(ctx: Context, schema: ApiSchema): (ApiSchema<import("@goast/core").ApiSchemaKind> & {
-        discriminator: import("@goast/core").ApiSchemaDiscriminator;
+        discriminator: NonNullable<ApiSchema["discriminator"]>;
     })[];
     protected getFilePath(ctx: Context, schema: ApiSchema): string;
 }

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

@@ -1,25 +1,60 @@
-import { ApiSchema, DefaultGenerationProviderConfig, OpenApiSchemasGenerationProviderContext, Nullable } from '@goast/core';
+import { ApiSchema, DefaultGenerationProviderConfig, OpenApiSchemasGenerationProviderContext, Nullable, ExtendedStringCasing } from '@goast/core';
 import { TypeScriptComponentOutput } from '../../common-results';
 import { TypeScriptGeneratorConfig } from '../../config';
 export type TypeScriptModelGeneratorConfig = TypeScriptGeneratorConfig & {
+    /**
+     * Determines how to generate enums.
+     * - 'union': Generate enums as union types.
+     * - 'prefer-enum': Generate enums as enums if possible, otherwise as union types.
+     * @default 'union'
+     */
     enumGeneration: 'union' | 'prefer-enum';
+    /**
+     * Whether to generate immutable types.
+     * @default false
+     */
     immutableTypes: boolean;
+    /**
+     * Whether to inline unnamed schemas. If false, unnamed schemas will be generated as separate types.
+     * @default true
+     */
     inlineUnnamedSchemas: boolean;
-    modelsDirPath: string;
+    /**
+     * The directory where the models should be saved. The path is relative to the output directory.
+     * @default 'models'
+     */
+    modelsDir: string;
+    /**
+     * The casing of the model file names. If nullish, the `fileNameCasing` is used.
+     * @default undefined
+     */
+    modelFileNameCasing: Nullable<ExtendedStringCasing>;
+    /**
+     * Determines how to declare types.
+     * - 'type': Always declare types as `type`.
+     * - 'prefer-interface': Prefer `interface` over `type` if possible.
+     * @default 'type'
+     */
     typeDeclaration: 'type' | 'prefer-interface';
 };
 export type TypeScriptModelsGeneratorConfig = TypeScriptModelGeneratorConfig & {
-    indexFilePath: string | null;
+    /**
+     * The path to the index file where all models should be exported. If nullish, no index file will be generated.
+     * @default 'models.ts'
+     */
+    modelsIndexFile: Nullable<string>;
 };
 export declare const defaultTypeScriptModelGeneratorConfig: DefaultGenerationProviderConfig<TypeScriptModelGeneratorConfig>;
 export declare const defaultTypeScriptModelsGeneratorConfig: DefaultGenerationProviderConfig<TypeScriptModelsGeneratorConfig>;
 export type TypeScriptModelsGeneratorInput = {};
 export type TypeScriptModelsGeneratorOutput = {
-    models: {
-        [schemaId: string]: TypeScriptModelGeneratorOutput;
-    };
-    indexFiles: {
-        models: Nullable<string>;
+    typescript: {
+        models: {
+            [schemaId: string]: TypeScriptModelGeneratorOutput;
+        };
+        indexFiles: {
+            models: Nullable<string>;
+        };
     };
 };
 export type TypeScriptModelGeneratorOutput = TypeScriptComponentOutput;

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

@@ -21,7 +21,7 @@ export declare class TypeScriptAngularServicesGenerator extends OpenApiServicesG
     protected getHttpStatusCodeFileContent(ctx: Context): AppendValueGroup<TypeScriptFileBuilder>;
     protected getProvideFnFileContent(ctx: Context): AppendValueGroup<TypeScriptFileBuilder>;
     protected getRootUrl(ctx: Context): string;
-    protected generateIndexFiles(ctx: Context): Output['indexFiles'];
+    protected generateIndexFiles(ctx: Context): Output['typescript']['indexFiles'];
     protected getServicesIndexFileContent(ctx: Context): AppendValueGroup<TypeScriptFileBuilder>;
     protected getResponseModelsIndexFileContent(ctx: Context): AppendValueGroup<TypeScriptFileBuilder>;
     protected getServicesIndexFilePath(ctx: Context): string | null;