@goast/typescript 0.0.4 → 0.2.0

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

@@ -3,6 +3,10 @@ export type TypeScriptComponentOutput = {
     filePath?: string;
     imports: TypeScriptImport[];
 };
+export type TypeScriptExportOutput = {
+    component: string;
+    filePath: string;
+};
 export type TypeScriptImportKind = 'module' | 'file';
 export type TypeScriptImport = {
     kind: TypeScriptImportKind;

package/types/lib/config.d.ts

@@ -2,11 +2,14 @@ import { DefaultGenerationProviderConfig, OpenApiGeneratorConfig, StringCasing,
 import { ImportModuleTransformer } from './utils';
 export type TypeScriptGeneratorConfig = OpenApiGeneratorConfig & {
     importModuleTransformer: ImportModuleTransformer;
+    fileNameCasing: StringCasing | StringCasingWithOptions;
     typeNameCasing: StringCasing | StringCasingWithOptions;
-    methodNameCasing: StringCasing | StringCasingWithOptions;
+    functionNameCasing: StringCasing | StringCasingWithOptions;
     propertyNameCasing: StringCasing | StringCasingWithOptions;
     enumValueNameCasing: StringCasing | StringCasingWithOptions;
-    constantCasing: StringCasing | StringCasingWithOptions;
+    constantNameCasing: StringCasing | StringCasingWithOptions;
+    paramNameCasing: StringCasing | StringCasingWithOptions;
+    genericParamNameCasing: StringCasing | StringCasingWithOptions;
     preferUnknown: boolean;
     useSingleQuotes: boolean;
 };

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

@@ -1,110 +1,33 @@
-import { Nullable, SourceBuilder, TextOrBuilderFn } from '@goast/core';
+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';
-export declare class TypeScriptFileBuilder extends SourceBuilder {
+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>;
+export declare class TypeScriptFileBuilder<TAdditionalAppends = never> extends SourceBuilder<TypeScriptAppends<TAdditionalAppends>> {
     readonly filePath: string | undefined;
     readonly imports: ImportExportCollection;
     get options(): TypeScriptGeneratorConfig;
-    constructor(filePath: string | undefined, options: TypeScriptGeneratorConfig);
+    constructor(filePath?: string, options?: TypeScriptGeneratorConfig);
     addImport(name: string, moduleNameOrfilePath: string): this;
     addExport(name: string, filePath: string): this;
     clear(): void;
     toString(addPadding?: boolean): string;
-    appendGenericArguments(...genericArguments: Nullable<TextOrBuilderFn<this>>[]): this;
-    appendParameter(parameter: Nullable<TextOrBuilderFn<this>> | TypeScriptParameterOptions): this | undefined;
-    appendParameters(...parameters: (Nullable<TextOrBuilderFn<this>> | TypeScriptParameterOptions)[]): this;
-    appendObjectLiteral(...properties: Nullable<TextOrBuilderFn<this>>[]): this;
-    appendArrayLiteral(...items: Nullable<TextOrBuilderFn<this>>[]): this;
-    appendCodeBlock(...content: Nullable<TextOrBuilderFn<this>>[]): this;
-    appendComment(style: '/***/' | '/**/' | '//', comment: Nullable<TextOrBuilderFn<this>>): this;
-    appendDocumentation(documentation: Nullable<TextOrBuilderFn<this>>): this;
+    protected appendSingle(value: TypeScriptAppendParam<this, TAdditionalAppends>): void;
     appendModelUsage(type: TypeScriptModelGeneratorOutput): this;
-    appendExternalTypeUsage(type: TypeScriptExternalTypeOptions): this;
-    appendTypeDeclaration(options: TypeScriptTypeDeclarationOptions): this;
-    appendAnnotation(options: TypeScriptAnnotationOptions): this;
-    appendAnnotations(annotations: TypeScriptAnnotationOptions[], separator: string): this;
-    appendClass(options: TypeScriptClassOptions): this;
-    appendConstructor(options: TypeScriptConstructorOptions): this;
-    appendMethod(options: TypeScriptMethodOptions): this;
-    appendProperty(options: TypeScriptPropertyOptions): this;
-    appendFunction(options: TypeScriptFunctionOptions): this;
+    writeToFile(filePath?: string): void;
+    static generate(options: {
+        filePath: string;
+        logName?: Nullable<string>;
+        options?: TypeScriptGeneratorConfig;
+        generator: (builder: TypeScriptFileBuilder) => void;
+    }): void;
+    static tryGenerate({ filePath, generator, options, logName, }: {
+        filePath: Nullable<string>;
+        logName?: Nullable<string>;
+        options?: TypeScriptGeneratorConfig;
+        generator: (builder: TypeScriptFileBuilder) => void;
+    }): void;
 }
-export type TypeScriptTypeDeclarationOptions = {
-    documentation?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>;
-    omitExport?: boolean;
-    name: string;
-    type: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>;
-};
-export type TypeScriptExternalTypeOptions = {
-    name: string;
-    module: string;
-};
-export type TypeScriptAnnotationOptions = {
-    name: string;
-    module?: string;
-    args?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>[];
-};
-export type TypeScriptClassOptions = {
-    documentation?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>;
-    annotations?: TypeScriptAnnotationOptions[];
-    omitExport?: boolean;
-    isAbstract?: boolean;
-    name: string;
-    genericArguments?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>[];
-    extends?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>;
-    implements?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>[];
-    body?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>;
-};
-export type TypeScriptConstructorOptions = {
-    documentation?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>;
-    annotations?: TypeScriptAnnotationOptions[];
-    parameters?: (Nullable<TextOrBuilderFn<TypeScriptFileBuilder>> | TypeScriptParameterOptions)[];
-    body?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>;
-};
-export type TypeScriptParameterOptions = {
-    name: string;
-    isOptional?: boolean;
-    type?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>> | TypeScriptExternalTypeOptions;
-    genericArguments?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>[];
-    defaultValue?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>;
-};
-export type TypeScriptMethodOptions = {
-    documentation?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>;
-    annotations?: TypeScriptAnnotationOptions[];
-    accessibility?: 'public' | 'protected' | 'private';
-    isAbstract?: boolean;
-    isStatic?: boolean;
-    isAsync?: boolean;
-    name: string;
-    genericArguments?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>[];
-    parameters?: (Nullable<TextOrBuilderFn<TypeScriptFileBuilder>> | TypeScriptParameterOptions)[];
-    returnType?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>;
-    body?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>;
-};
-export type TypeScriptPropertyOptions = {
-    documentation?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>;
-    annotations?: TypeScriptAnnotationOptions[];
-    accessibility?: 'public' | 'protected' | 'private';
-    isAbstract?: boolean;
-    isStatic?: boolean;
-    isReadonly?: boolean;
-    isOptional?: boolean;
-    kind?: 'property' | 'getter' | 'setter' | 'getter-setter';
-    name: string;
-    type?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>;
-    initializer?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>;
-    getter?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>;
-    getterAnnotations?: TypeScriptAnnotationOptions[];
-    setter?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>;
-    setterAnnotations?: TypeScriptAnnotationOptions[];
-};
-export type TypeScriptFunctionOptions = {
-    kind?: 'function' | 'arrow-function';
-    isAsync?: boolean;
-    name?: string;
-    parameters: (Nullable<TextOrBuilderFn<TypeScriptFileBuilder>> | TypeScriptParameterOptions)[];
-    returnType?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>;
-    body?: Nullable<TextOrBuilderFn<TypeScriptFileBuilder>>;
-    singleLine?: boolean;
-};

package/types/lib/generators/file-generator.d.ts

@@ -1,11 +1,7 @@
-import { OpenApiGenerationProviderContext, OpenApiGeneratorInput } from '@goast/core';
+import { OpenApiGenerationProviderContext, OpenApiGeneratorInput, SourceBuilder } from '@goast/core';
+import { ts } from '../ast';
 import { TypeScriptGeneratorConfig } from '../config';
 export declare abstract class TypeScriptFileGenerator<TContext extends OpenApiGenerationProviderContext<OpenApiGeneratorInput, TypeScriptGeneratorConfig>, TOutput> {
     abstract generate(context: TContext): TOutput;
-    protected getAnyType(context: TContext): string;
-    protected toTypeName(context: TContext, name: string): string;
-    protected toMethodName(context: TContext, name: string): string;
-    protected toPropertyName(context: TContext, name: string, keepCasing?: boolean): string;
-    protected toEnumValueName(context: TContext, name: string): string;
-    protected toStringLiteral(context: TContext, text: string): string;
+    protected getAnyType(context: TContext): ts.Reference<SourceBuilder>;
 }

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

@@ -2,3 +2,4 @@ export * from './file-generator';
 export * from './models';
 export * from './services/angular-services';
 export * from './services/fetch-clients';
+export * from './services/easy-network-stub';

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

@@ -1,5 +1,6 @@
-import { ApiSchema, ApiSchemaProperty, ArrayLikeApiSchema, CombinedLikeApiSchema, ObjectLikeApiSchema } from '@goast/core';
+import { ApiSchema, AppendValueGroup, ArrayLikeApiSchema, CombinedLikeApiSchema, Nullable, ObjectLikeApiSchema } from '@goast/core';
 import { TypeScriptModelGeneratorContext, TypeScriptModelGeneratorOutput } from './models';
+import { ts } from '../../ast';
 import { TypeScriptFileBuilder } from '../../file-builder';
 import { TypeScriptFileGenerator } from '../file-generator';
 type Context = TypeScriptModelGeneratorContext;
@@ -10,31 +11,25 @@ export interface TypeScriptModelGenerator<TOutput extends Output = Output> {
 }
 export declare class DefaultTypeScriptModelGenerator extends TypeScriptFileGenerator<Context, Output> implements TypeScriptModelGenerator {
     generate(ctx: Context): Output;
-    protected generateFileContent(ctx: Context, builder: Builder): void;
-    protected generateEnum(ctx: Context, builder: Builder): void;
-    protected generateEnumSignature(ctx: Context, builder: Builder): void;
-    protected generateEnumValues(ctx: Context, builder: Builder): void;
-    protected generateInterface(ctx: Context, builder: Builder, schema: ApiSchema<'object'>): void;
-    protected generateInterfaceSignature(ctx: Context, builder: Builder): void;
-    protected generateInterfaceContent(ctx: Context, builder: Builder, schema: ApiSchema<'object'>): void;
-    protected generateTypeAlias(ctx: Context, builder: Builder): void;
-    protected generateTypeAliasSignature(ctx: Context, builder: Builder): void;
-    protected generateTypeUsage(ctx: Context, builder: Builder, schema: ApiSchema): void;
-    protected generateType(ctx: Context, builder: Builder, schema: ApiSchema): void;
-    protected generateArrayType(ctx: Context, builder: Builder, schema: ArrayLikeApiSchema): void;
-    protected generateCombinedType(ctx: Context, builder: Builder, schema: CombinedLikeApiSchema): void;
-    protected generateOneOfType(ctx: Context, builder: Builder, schema: ApiSchema<'oneOf'>): void;
-    protected generateMultiType(ctx: Context, builder: Builder, schema: ApiSchema<'multi-type'>): void;
-    protected generateObjectType(ctx: Context, builder: Builder, schema: ObjectLikeApiSchema): void;
-    protected generateObjectTypeProperties(ctx: Context, builder: Builder, schema: ObjectLikeApiSchema): void;
-    protected generateObjectTypeAdditionalProperties(ctx: Context, builder: Builder, schema: ObjectLikeApiSchema): void;
-    protected generateEnumType(ctx: Context, builder: Builder, schema: ApiSchema): void;
-    protected generateTypeDocumentation(ctx: Context, builder: Builder): void;
-    protected generatePropertyDocumentation(ctx: Context, builder: Builder, property: ApiSchemaProperty): void;
-    protected generateDocumentation(ctx: Context, builder: Builder, schema: ApiSchema): void;
+    protected getFileContent(ctx: Context): AppendValueGroup<Builder>;
+    protected getEnum(ctx: Context): ts.Enum<import("@goast/core").SourceBuilder<never>, never>;
+    protected getInterface(ctx: Context, schema: ObjectLikeApiSchema): ts.Interface<Builder, never>;
+    protected getTypeAlias(ctx: Context, schema: ApiSchema): ts.TypeAlias<Builder>;
+    protected getIndexer(ctx: Context, schema: ObjectLikeApiSchema): ts.Indexer<Builder, never> | null;
+    protected getProperties(ctx: Context, schema: ObjectLikeApiSchema): (import("../../ast/nodes/property").TsAccessorProperty<Builder, ""> | import("../../ast/nodes/property").TsSimpleProperty<Builder, "">)[];
+    protected getType(ctx: Context, schema: Nullable<ApiSchema>, skipSchemas?: boolean): ts.Type<Builder> | null;
+    protected getArrayType(ctx: Context, schema: ArrayLikeApiSchema): ts.Type<Builder>;
+    protected getObjectType(ctx: Context, schema: ObjectLikeApiSchema): ts.Type<Builder>;
+    protected getCombinedType(ctx: Context, schema: CombinedLikeApiSchema): ts.Type<Builder>;
+    protected getOneOfType(ctx: Context, schema: ApiSchema<'oneOf'>): ts.Type<Builder>;
+    protected getMultiType(ctx: Context, schema: ApiSchema<'multi-type'>): ts.Type<Builder>;
     protected shouldGenerateTypeDeclaration(ctx: Context, schema: ApiSchema): boolean;
     protected resolveInterfaceSchema(ctx: Context): ApiSchema<'object'> | undefined;
     protected getDeclarationTypeName(ctx: Context, schema: ApiSchema): string;
+    protected getDiscriminatorGenericParamName(ctx: Context, schema: ApiSchema): string;
+    protected getInheritedSchemas(ctx: Context, schema: ApiSchema): (ApiSchema<import("@goast/core").ApiSchemaKind> & {
+        discriminator: import("@goast/core").ApiSchemaDiscriminator;
+    })[];
     protected getFilePath(ctx: Context, schema: ApiSchema): string;
 }
 export {};

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

@@ -1,4 +1,4 @@
-import { ApiSchema, OpenApiGeneratorContext, OpenApiSchemasGenerationProviderBase, Factory } from '@goast/core';
+import { ApiSchema, OpenApiGeneratorContext, OpenApiSchemasGenerationProviderBase, Factory, AppendValueGroup } from '@goast/core';
 import { TypeScriptModelGenerator } from './model-generator';
 import { TypeScriptModelGeneratorOutput, TypeScriptModelsGeneratorConfig, TypeScriptModelsGeneratorContext, TypeScriptModelsGeneratorInput, TypeScriptModelsGeneratorOutput } from './models';
 import { TypeScriptFileBuilder } from '../../file-builder';
@@ -15,9 +15,8 @@ export declare class TypeScriptModelsGenerator extends OpenApiSchemasGenerationP
     onGenerate(ctx: Context): Output;
     protected generateSchema(ctx: Context, schema: ApiSchema): SchemaOutput;
     protected addSchemaResult(ctx: Context, schema: ApiSchema, result: SchemaOutput): void;
-    protected generateIndexFile(ctx: Context): string | undefined;
-    protected getIndexFilePath(ctx: Context): string;
-    protected shouldGenerateIndexFile(ctx: Context): boolean;
-    protected generateIndexFileContent(ctx: Context, builder: TypeScriptFileBuilder): void;
+    protected generateIndexFile(ctx: Context): string | null;
+    protected getIndexFilePath(ctx: Context): string | null;
+    protected getIndexFileContent(ctx: Context): AppendValueGroup<TypeScriptFileBuilder>;
 }
 export {};

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

@@ -1,9 +1,7 @@
-import { ApiSchema, DefaultGenerationProviderConfig, OpenApiSchemasGenerationProviderContext, Nullable, StringCasing, StringCasingWithOptions } from '@goast/core';
+import { ApiSchema, DefaultGenerationProviderConfig, OpenApiSchemasGenerationProviderContext, Nullable } from '@goast/core';
 import { TypeScriptComponentOutput } from '../../common-results';
 import { TypeScriptGeneratorConfig } from '../../config';
 export type TypeScriptModelGeneratorConfig = TypeScriptGeneratorConfig & {
-    fileNameCasing: StringCasing | StringCasingWithOptions;
-    typeNameCasing: StringCasing | StringCasingWithOptions;
     enumGeneration: 'union' | 'prefer-enum';
     immutableTypes: boolean;
     inlineUnnamedSchemas: boolean;
@@ -20,7 +18,9 @@ export type TypeScriptModelsGeneratorOutput = {
     models: {
         [schemaId: string]: TypeScriptModelGeneratorOutput;
     };
-    modelIndexFilePath: Nullable<string>;
+    indexFiles: {
+        models: Nullable<string>;
+    };
 };
 export type TypeScriptModelGeneratorOutput = TypeScriptComponentOutput;
 export type TypeScriptModelsGeneratorContext = OpenApiSchemasGenerationProviderContext<TypeScriptModelsGeneratorInput, TypeScriptModelsGeneratorOutput, TypeScriptModelsGeneratorConfig, TypeScriptModelGeneratorOutput>;

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

@@ -1,6 +1,8 @@
-import { ApiEndpoint, TextOrBuilderFn } from '@goast/core';
+import { ApiEndpoint, ApiSchema, AppendValueGroup } from '@goast/core';
 import { TypeScriptAngularServiceGeneratorContext, TypeScriptAngularServiceGeneratorOutput } from './models';
-import { TypeScriptClassOptions, TypeScriptConstructorOptions, TypeScriptExternalTypeOptions, TypeScriptFileBuilder, TypeScriptMethodOptions, TypeScriptParameterOptions, TypeScriptPropertyOptions } from '../../../file-builder';
+import { ts } from '../../../ast';
+import { TypeScriptExportOutput } from '../../../common-results';
+import { TypeScriptFileBuilder } from '../../../file-builder';
 import { TypeScriptFileGenerator } from '../../file-generator';
 type Context = TypeScriptAngularServiceGeneratorContext;
 type Output = TypeScriptAngularServiceGeneratorOutput;
@@ -9,45 +11,23 @@ export interface TypeScriptAngularServiceGenerator<TOutput extends Output = Outp
     generate(ctx: Context): TOutput;
 }
 export declare class DefaultTypeScriptAngularServiceGenerator extends TypeScriptFileGenerator<Context, Output> implements TypeScriptAngularServiceGenerator {
-    protected readonly httpClientType: TypeScriptExternalTypeOptions;
-    protected readonly httpContextType: TypeScriptExternalTypeOptions;
-    protected readonly httpResponseType: TypeScriptExternalTypeOptions;
-    protected readonly observableType: TypeScriptExternalTypeOptions;
-    protected readonly rxjsFilterType: TypeScriptExternalTypeOptions;
-    protected readonly rxjsMapType: TypeScriptExternalTypeOptions;
-    protected getApiConfigurationType(ctx: Context): TypeScriptExternalTypeOptions;
-    protected getBaseServiceType(ctx: Context): TypeScriptExternalTypeOptions;
-    protected getStrictHttpResponseType(ctx: Context): TypeScriptExternalTypeOptions;
-    protected getRequestBuilderType(ctx: Context): TypeScriptExternalTypeOptions;
     generate(ctx: Context): Output;
-    protected generateServiceFileContent(ctx: Context, builder: Builder): void;
-    protected generateEndpointParamsType(ctx: Context, builder: Builder, endpoint: ApiEndpoint): void;
-    protected generateClass(ctx: Context, builder: Builder): void;
-    protected generateClassContent(ctx: Context, builder: Builder): void;
-    protected generateConstructor(ctx: Context, builder: Builder): void;
-    protected generateConstructorContent(ctx: Context, builder: Builder): void;
-    protected generateEndpoint(ctx: Context, builder: Builder, endpoint: ApiEndpoint): void;
-    protected generateEndpointPathProperty(ctx: Context, builder: Builder, endpoint: ApiEndpoint): void;
-    protected generateEndpointResponseMethod(ctx: Context, builder: Builder, endpoint: ApiEndpoint): void;
-    protected generateEndpointResponseMethodContent(ctx: Context, builder: Builder, endpoint: ApiEndpoint): void;
-    protected generateEndpointMethod(ctx: Context, builder: Builder, endpoint: ApiEndpoint): void;
-    protected generateEndpointMethodContent(ctx: Context, builder: Builder, endpoint: ApiEndpoint): void;
-    protected getClassOptions(ctx: Context): TypeScriptClassOptions;
-    protected getConstructorOptions(ctx: Context): TypeScriptConstructorOptions;
-    protected getEndpointPathPropertyOptions(ctx: Context, endpoint: ApiEndpoint): TypeScriptPropertyOptions;
-    protected getEndpointMethodParams(ctx: Context, endpoint: ApiEndpoint): (TextOrBuilderFn<Builder> | TypeScriptParameterOptions)[];
-    protected generateEndpointSuccessResponseSchema(ctx: Context, builder: Builder, endpoint: ApiEndpoint): void;
-    protected getEndpointResponseMethodOptions(ctx: Context, endpoint: ApiEndpoint): TypeScriptMethodOptions;
-    protected getEndpointMethodOptions(ctx: Context, endpoint: ApiEndpoint): TypeScriptMethodOptions;
+    protected generateResponseModels(ctx: Context): Record<string, TypeScriptExportOutput>;
+    protected getResponseModelFileContent(ctx: Context, endpoint: ApiEndpoint): AppendValueGroup<Builder>;
+    protected getEndpointStatusCodes(ctx: Context, endpoint: ApiEndpoint): Record<number, ts.Type<Builder>>;
+    protected getServiceFileContent(ctx: Context): AppendValueGroup<Builder>;
+    protected getEndpointParamsType(ctx: Context, endpoint: ApiEndpoint): ts.TypeAlias<Builder>;
+    protected getClass(ctx: Context): ts.Class<Builder>;
+    protected getEndpointMethod(ctx: Context, endpoint: ApiEndpoint): ts.Method<Builder>;
     protected getEndpointSuccessResponse(ctx: Context, endpoint: ApiEndpoint): import("@goast/core").ApiResponse | undefined;
     protected getServiceClassName(ctx: Context): string;
-    protected hasEndpointParams(ctx: Context, endpoint: ApiEndpoint): boolean;
+    protected getResponseModelName(ctx: Context, endpoint: ApiEndpoint): string;
     protected getEndpointParamsTypeName(ctx: Context, endpoint: ApiEndpoint): string;
     protected getEndpointPathPropertyName(ctx: Context, endpoint: ApiEndpoint): string;
     protected getEndpointMethodName(ctx: Context, endpoint: ApiEndpoint): string;
-    protected getEndpointResponseMethodName(ctx: Context, endpoint: ApiEndpoint): string;
     protected getServiceFilePath(ctx: Context): string;
-    protected getResponseModelsFilePath(ctx: Context): string;
-    protected getUtilsDirPath(ctx: Context): string;
+    protected getResponseModelFilePath(ctx: Context): string;
+    protected hasEndpointParams(ctx: Context, endpoint: ApiEndpoint): boolean;
+    protected getSchemaType(ctx: Context, schema: ApiSchema | undefined, fallback?: ts.Type<Builder>): ts.Type<Builder>;
 }
 export {};

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

@@ -1,4 +1,4 @@
-import { ApiService, Factory, OpenApiGeneratorContext, OpenApiServicesGenerationProviderBase } from '@goast/core';
+import { ApiService, AppendValueGroup, Factory, OpenApiGeneratorContext, OpenApiServicesGenerationProviderBase } from '@goast/core';
 import { TypeScriptAngularServiceGenerator } from './angular-service-generator';
 import { TypeScriptAngularServicesGeneratorInput, TypeScriptAngularServicesGeneratorOutput, TypeScriptAngularServicesGeneratorConfig, TypeScriptAngularServiceGeneratorOutput, TypeScriptAngularServicesGeneratorContext } from './models';
 import { TypeScriptFileBuilder } from '../../../file-builder';
@@ -15,15 +15,17 @@ export declare class TypeScriptAngularServicesGenerator extends OpenApiServicesG
     onGenerate(ctx: Context): Output;
     protected generateService(ctx: Context, service: ApiService): ServiceOutput;
     protected addServiceResult(ctx: Context, service: ApiService, result: ServiceOutput): void;
-    protected generateServicesIndexFile(ctx: Context): string | undefined;
-    protected getServicesIndexFilePath(ctx: Context): string;
-    protected shouldGenerateServicesIndexFile(ctx: Context): boolean;
-    protected generateServicesIndexFileContent(ctx: Context, builder: TypeScriptFileBuilder): void;
-    protected generateResponseModelsIndexFile(ctx: Context): string | undefined;
-    protected getResponseModelsIndexFilePath(ctx: Context): string;
-    protected shouldGenerateResponseModelsIndexFile(ctx: Context): boolean;
-    protected generateResponseModelsIndexFileContent(ctx: Context, builder: TypeScriptFileBuilder): void;
-    protected copyUtilsFiles(ctx: Context): void;
+    protected generateUtilsFiles(ctx: Context): void;
+    protected getApiConfigurationFileContent(ctx: Context): AppendValueGroup<TypeScriptFileBuilder>;
+    protected getApiBaseServiceFileContent(ctx: Context): AppendValueGroup<TypeScriptFileBuilder>;
+    protected getHttpStatusCodeFileContent(ctx: Context): AppendValueGroup<TypeScriptFileBuilder>;
+    protected getProvideFnFileContent(ctx: Context): AppendValueGroup<TypeScriptFileBuilder>;
     protected getRootUrl(ctx: Context): string;
+    protected generateIndexFiles(ctx: Context): Output['indexFiles'];
+    protected getServicesIndexFileContent(ctx: Context): AppendValueGroup<TypeScriptFileBuilder>;
+    protected getResponseModelsIndexFileContent(ctx: Context): AppendValueGroup<TypeScriptFileBuilder>;
+    protected getServicesIndexFilePath(ctx: Context): string | null;
+    protected getResponseModelsIndexFilePath(ctx: Context): string | null;
+    private copyFile;
 }
 export {};

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

@@ -1,41 +1,86 @@
-import { ApiEndpoint, ApiService, DefaultGenerationProviderConfig, Nullable, OpenApiServicesGenerationProviderContext, RequiredProperties, StringCasing, StringCasingWithOptions } from '@goast/core';
-import { TypeScriptComponentOutput } from '../../../common-results';
+import { ApiEndpoint, ApiSchema, ApiService, DefaultGenerationProviderConfig, Nullable, OpenApiServicesGenerationProviderContext, StringCasing, StringCasingWithOptions } from '@goast/core';
+import { getReferenceFactories } from './refs';
+import { ts } from '../../../ast';
+import { TypeScriptExportOutput } from '../../../common-results';
 import { TypeScriptGeneratorConfig } from '../../../config';
-import { TypeScriptModelsGeneratorOutput } from '../../models';
+import { TypeScriptFileBuilder } from '../../../file-builder';
+import { TypeScriptModelGeneratorOutput } from '../../models';
 export type TypeScriptAngularServicesGeneratorConfig = TypeScriptGeneratorConfig & {
-    fileNameCasing: StringCasing | StringCasingWithOptions;
-    responseModelsFileNameCasing: StringCasing | StringCasingWithOptions;
-    exposeResponseMethods: boolean;
-    exposePathProperties: boolean;
-    clientMethodFlavor: 'default' | 'response-handler';
+    responseModelFileNameCasing: StringCasing | StringCasingWithOptions;
+    /**
+     * How the services should be provided in the Angular application.
+     * - `root` - provides all the services using `Injectable({ providedIn: 'root' })`
+     * - `provide-fn` - generates a function `provideApiClients` that provides the services
+     * - `module` - generates an angular module `ApiClientModule` that provides the services
+     * @default 'root'
+     */
+    provideKind: 'root' | 'provide-fn';
+    /**
+     * The domain name of the API. Used as a prefix for exported components (e.g. `ApiConfiguration`).
+     */
+    domainName?: string;
+    /**
+     * Whether to use strict response types for the services.
+     * If enabled only the status codes are included that are defined in the OpenAPI specification or the `defaultStatusCodeResponseTypes` option.
+     * @default true
+     */
+    strictResponseTypes: boolean;
+    /**
+     * The default response types for status codes that are not defined in the OpenAPI specification.
+     * @example
+     * {
+     *   400: schemas =>
+     *     schemas.find(s => s.name === 'BadRequestResponse')
+     *       ?? throwExp('BadRequestResponse not found'),
+     *   404: 'never',
+     *   500: ts.refs.any(),
+     * }
+     * @default
+     * {
+     *   401: ts.refs.never(),
+     *   403: ts.refs.never(),
+     *   500: ts.refs.never(),
+     * }
+     */
+    defaultStatusCodeResponseTypes: Record<number, Exclude<ts.Type<TypeScriptFileBuilder>, Function> | ((schemas: readonly ApiSchema[]) => ApiSchema)>;
+    /**
+     * The possible status codes that any API endpoint can return.
+     * This is only used when `strictResponseTypes` is set to `false`;
+     * @default
+     * [100, 101, 102, 103, 200, 201, 202, 203, 204, 205, 206, 207, 208, 226, 300, 301, 302, 303, 304, 305, 306, 307, 308, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 421, 422, 423, 424, 425, 426, 428, 429, 431, 451, 500, 501, 502, 503, 504, 505, 506, 507, 508, 510, 511]
+     */
+    possibleStatusCodes: number[];
     rootUrl?: string | RegExp | ((rootUrl: string) => string);
     pathModifier?: RegExp | ((path: string, endpoint: ApiEndpoint) => string);
     servicesDirPath: string;
-    responseModelsDirPath: Nullable<string>;
-    utilsDirPath: string;
-    indexFilePath: Nullable<string>;
+    servicesIndexFilePath: Nullable<string>;
+    responseModelsDirPath: string;
     responseModelsIndexFilePath: Nullable<string>;
+    utilsDirPath: string;
 };
 export declare const defaultTypeScriptAngularServicesGeneratorConfig: DefaultGenerationProviderConfig<TypeScriptAngularServicesGeneratorConfig>;
-export type TypeScriptAngularServicesGeneratorInput = TypeScriptModelsGeneratorOutput;
+export type TypeScriptAngularServicesGeneratorInput = {
+    models: {
+        [schemaId: string]: TypeScriptModelGeneratorOutput;
+    };
+};
 export type TypeScriptAngularServicesGeneratorOutput = {
     services: {
         [serviceId: string]: TypeScriptAngularServiceGeneratorOutput;
     };
-    servicesIndexFilePath: string | undefined;
-    responseModelsIndexFilePath: string | undefined;
+    indexFiles: {
+        services: Nullable<string>;
+        responseModels: Nullable<string>;
+    };
 };
-export type x = Omit<TypeScriptComponentOutput, 'additionalImports'>;
-export type TypeScriptAngularServiceGeneratorOutput = RequiredProperties<TypeScriptComponentOutput, 'filePath'> & {
+export type TypeScriptAngularServiceGeneratorOutput = TypeScriptExportOutput & {
     responseModels: {
-        [operationId: string]: TypeScriptComponentOutput & {
-            statusCodes: {
-                [statusCode: string]: TypeScriptComponentOutput;
-            };
-        };
+        [operationId: string]: TypeScriptExportOutput;
     };
 };
-export type TypeScriptAngularServicesGeneratorContext = OpenApiServicesGenerationProviderContext<TypeScriptAngularServicesGeneratorInput, TypeScriptAngularServicesGeneratorOutput, TypeScriptAngularServicesGeneratorConfig, TypeScriptAngularServiceGeneratorOutput>;
+export type TypeScriptAngularServicesGeneratorContext = OpenApiServicesGenerationProviderContext<TypeScriptAngularServicesGeneratorInput, TypeScriptAngularServicesGeneratorOutput, TypeScriptAngularServicesGeneratorConfig, TypeScriptAngularServiceGeneratorOutput> & {
+    refs: ReturnType<typeof getReferenceFactories>;
+};
 export type TypeScriptAngularServiceGeneratorContext = TypeScriptAngularServicesGeneratorContext & {
     readonly service: ApiService;
 };

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

@@ -0,0 +1,34 @@
+import { ts } from '../../../ast';
+import type { TypeScriptAngularServicesGeneratorConfig } from './models';
+export declare function getReferenceFactories(options: TypeScriptAngularServicesGeneratorConfig): {
+    requestBuilder: (<TBuilder extends import("@goast/core").SourceBuilder<never>>() => ts.Reference<TBuilder, never>) & {
+        refName: string;
+        moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+    } & {
+        moduleNameOrfilePath: string;
+    };
+    apiConfiguration: (<TBuilder extends import("@goast/core").SourceBuilder<never>>() => ts.Reference<TBuilder, never>) & {
+        refName: string;
+        moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+    } & {
+        moduleNameOrfilePath: string;
+    };
+    apiBaseService: (<TBuilder extends import("@goast/core").SourceBuilder<never>>() => ts.Reference<TBuilder, never>) & {
+        refName: string;
+        moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+    } & {
+        moduleNameOrfilePath: string;
+    };
+    httpStatusCode: (<TBuilder extends import("@goast/core").SourceBuilder<never>>() => ts.Reference<TBuilder, never>) & {
+        refName: string;
+        moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+    } & {
+        moduleNameOrfilePath: string;
+    };
+    provide: (<TBuilder extends import("@goast/core").SourceBuilder<never>>() => ts.Reference<TBuilder, never>) & {
+        refName: string;
+        moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+    } & {
+        moduleNameOrfilePath: string;
+    };
+};

package/types/lib/generators/services/easy-network-stub/easy-network-stub-generator.d.ts

@@ -0,0 +1,32 @@
+import { ApiEndpoint, ApiSchema, AppendValueGroup } from '@goast/core';
+import { TypeScriptEasyNetworkStubGeneratorContext, TypeScriptEasyNetworkStubGeneratorOutput } from './models';
+import { ts } from '../../../ast';
+import { TypeScriptFileBuilder } from '../../../file-builder';
+import { TypeScriptFileGenerator } from '../../file-generator';
+type Context = TypeScriptEasyNetworkStubGeneratorContext;
+type Output = TypeScriptEasyNetworkStubGeneratorOutput;
+type Builder = TypeScriptFileBuilder;
+export interface TypeScriptEasyNetworkStubGenerator<TOutput extends Output = Output> {
+    generate(ctx: Context): TOutput;
+}
+export declare class DefaultTypeScriptEasyNetworkStubGenerator extends TypeScriptFileGenerator<Context, Output> implements TypeScriptEasyNetworkStubGenerator {
+    generate(ctx: Context): Output;
+    protected getStubFileContent(ctx: Context): AppendValueGroup<Builder>;
+    protected getResponderVariable(ctx: Context, endpoint: ApiEndpoint): ts.Variable<Builder>;
+    protected getStubClass(ctx: Context): ts.Class<Builder>;
+    protected getEndpointRequestsType(ctx: Context, endpoint: ApiEndpoint, options?: {
+        readonly?: boolean;
+    }): ts.Type<Builder>;
+    protected getEndpointStubMethod(ctx: Context, endpoint: ApiEndpoint): ts.Method<Builder>;
+    protected getStubFilePath(ctx: Context): string;
+    protected getResponderVariableName(ctx: Context, endpoint: ApiEndpoint): string;
+    protected getStubClassName(ctx: Context): string;
+    protected getEndpointPathPropertyName(ctx: Context, endpoint: ApiEndpoint): string;
+    protected getEndpointRequestsFieldName(ctx: Context, endpoint: ApiEndpoint): string;
+    protected getEndpointRequestsPropertyName(ctx: Context, endpoint: ApiEndpoint): string;
+    protected getEndpointStubMethodName(ctx: Context, endpoint: ApiEndpoint): string;
+    protected getStubRoute(ctx: Context, endpoint: ApiEndpoint): string;
+    protected getEndpointStatusCodes(ctx: Context, endpoint: ApiEndpoint): Record<number, ts.Type<Builder>>;
+    protected getSchemaType(ctx: Context, schema: ApiSchema | undefined, fallback?: ts.Type<Builder>): ts.Type<Builder>;
+}
+export {};

package/types/lib/generators/services/easy-network-stub/easy-network-stubs-generator.d.ts

@@ -0,0 +1,25 @@
+import { ApiService, AppendValueGroup, Factory, OpenApiGeneratorContext, OpenApiServicesGenerationProviderBase } from '@goast/core';
+import { TypeScriptEasyNetworkStubGenerator } from './easy-network-stub-generator';
+import { TypeScriptEasyNetworkStubsGeneratorInput, TypeScriptEasyNetworkStubsGeneratorOutput, TypeScriptEasyNetworkStubsGeneratorConfig, TypeScriptEasyNetworkStubGeneratorOutput, TypeScriptEasyNetworkStubsGeneratorContext } from './models';
+import { TypeScriptExportOutput } from '../../../common-results';
+import { TypeScriptFileBuilder } from '../../../file-builder';
+type Input = TypeScriptEasyNetworkStubsGeneratorInput;
+type Output = TypeScriptEasyNetworkStubsGeneratorOutput;
+type Config = TypeScriptEasyNetworkStubsGeneratorConfig;
+type ServiceOutput = TypeScriptEasyNetworkStubGeneratorOutput;
+type Context = TypeScriptEasyNetworkStubsGeneratorContext;
+export declare class TypeScriptEasyNetworkStubsGenerator extends OpenApiServicesGenerationProviderBase<Input, Output, Config, ServiceOutput, Context> {
+    private readonly _generatorFactory;
+    constructor(generatorFactory?: Factory<TypeScriptEasyNetworkStubGenerator, []>);
+    protected initResult(): Output;
+    protected buildContext(context: OpenApiGeneratorContext<Input>, config?: Partial<Config> | undefined): Context;
+    onGenerate(ctx: Context): Output;
+    protected generateService(ctx: Context, service: ApiService): TypeScriptExportOutput;
+    protected addServiceResult(ctx: Context, service: ApiService, result: TypeScriptExportOutput): void;
+    protected generateUtilsFiles(ctx: Context): void;
+    protected generateIndexFiles(ctx: Context): Output['indexFiles'];
+    protected getStubsIndexFileContent(ctx: Context): AppendValueGroup<TypeScriptFileBuilder>;
+    protected getStubsIndexFilePath(ctx: Context): string | null;
+    private copyFile;
+}
+export {};

package/types/lib/generators/services/easy-network-stub/index.d.ts

@@ -0,0 +1,3 @@
+export * from './easy-network-stub-generator';
+export * from './easy-network-stubs-generator';
+export * from './models';