@goast/typescript 0.0.1

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

@@ -0,0 +1,11 @@
+import { OpenApiGenerationProviderContext, OpenApiGeneratorInput } from '@goast/core';
+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;
+}

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

@@ -0,0 +1,4 @@
+export * from './file-generator';
+export * from './models';
+export * from './services/angular-services';
+export * from './services/fetch-clients';

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

@@ -0,0 +1,3 @@
+export * from './model-generator';
+export * from './models';
+export * from './models-generator';

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

@@ -0,0 +1,40 @@
+import { ApiSchema, ApiSchemaProperty, ArrayLikeApiSchema, CombinedLikeApiSchema, ObjectLikeApiSchema } from '@goast/core';
+import { TypeScriptModelGeneratorContext, TypeScriptModelGeneratorOutput } from './models';
+import { TypeScriptFileBuilder } from '../../file-builder';
+import { TypeScriptFileGenerator } from '../file-generator';
+type Context = TypeScriptModelGeneratorContext;
+type Output = TypeScriptModelGeneratorOutput;
+type Builder = TypeScriptFileBuilder;
+export interface TypeScriptModelGenerator<TOutput extends Output = Output> {
+    generate(ctx: Context): TOutput;
+}
+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 shouldGenerateTypeDeclaration(ctx: Context, schema: ApiSchema): boolean;
+    protected resolveInterfaceSchema(ctx: Context): ApiSchema<'object'> | undefined;
+    protected getDeclarationTypeName(ctx: Context, schema: ApiSchema): string;
+    protected getFilePath(ctx: Context, schema: ApiSchema): string;
+}
+export {};

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

@@ -0,0 +1,23 @@
+import { ApiSchema, OpenApiGeneratorContext, OpenApiSchemasGenerationProviderBase, Factory } from '@goast/core';
+import { TypeScriptModelGenerator } from './model-generator';
+import { TypeScriptModelGeneratorOutput, TypeScriptModelsGeneratorConfig, TypeScriptModelsGeneratorContext, TypeScriptModelsGeneratorInput, TypeScriptModelsGeneratorOutput } from './models';
+import { TypeScriptFileBuilder } from '../../file-builder';
+type Input = TypeScriptModelsGeneratorInput;
+type Output = TypeScriptModelsGeneratorOutput;
+type Config = TypeScriptModelsGeneratorConfig;
+type SchemaOutput = TypeScriptModelGeneratorOutput;
+type Context = TypeScriptModelsGeneratorContext;
+export declare class TypeScriptModelsGenerator extends OpenApiSchemasGenerationProviderBase<Input, Output, Config, SchemaOutput, Context> {
+    private readonly _modelGeneratorFactory;
+    constructor(modelGeneratorFactory?: Factory<TypeScriptModelGenerator, []>);
+    protected initResult(): Output;
+    protected buildContext(context: OpenApiGeneratorContext<TypeScriptModelsGeneratorInput>, config?: Partial<Config> | undefined): Context;
+    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;
+}
+export {};

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

@@ -0,0 +1,29 @@
+import { ApiSchema, DefaultGenerationProviderConfig, OpenApiSchemasGenerationProviderContext, Nullable, StringCasing, StringCasingWithOptions } 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;
+    modelsDirPath: string;
+    typeDeclaration: 'type' | 'prefer-interface';
+};
+export type TypeScriptModelsGeneratorConfig = TypeScriptModelGeneratorConfig & {
+    indexFilePath: string | null;
+};
+export declare const defaultTypeScriptModelGeneratorConfig: DefaultGenerationProviderConfig<TypeScriptModelGeneratorConfig>;
+export declare const defaultTypeScriptModelsGeneratorConfig: DefaultGenerationProviderConfig<TypeScriptModelsGeneratorConfig>;
+export type TypeScriptModelsGeneratorInput = {};
+export type TypeScriptModelsGeneratorOutput = {
+    models: {
+        [schemaId: string]: TypeScriptModelGeneratorOutput;
+    };
+    modelIndexFilePath: Nullable<string>;
+};
+export type TypeScriptModelGeneratorOutput = TypeScriptComponentOutput;
+export type TypeScriptModelsGeneratorContext = OpenApiSchemasGenerationProviderContext<TypeScriptModelsGeneratorInput, TypeScriptModelsGeneratorOutput, TypeScriptModelsGeneratorConfig, TypeScriptModelGeneratorOutput>;
+export type TypeScriptModelGeneratorContext = TypeScriptModelsGeneratorContext & {
+    schema: ApiSchema;
+};

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

@@ -0,0 +1,53 @@
+import { ApiEndpoint, TextOrBuilderFn } from '@goast/core';
+import { TypeScriptAngularServiceGeneratorContext, TypeScriptAngularServiceGeneratorOutput } from './models';
+import { TypeScriptClassOptions, TypeScriptConstructorOptions, TypeScriptExternalTypeOptions, TypeScriptFileBuilder, TypeScriptMethodOptions, TypeScriptParameterOptions, TypeScriptPropertyOptions } from '../../../file-builder';
+import { TypeScriptFileGenerator } from '../../file-generator';
+type Context = TypeScriptAngularServiceGeneratorContext;
+type Output = TypeScriptAngularServiceGeneratorOutput;
+type Builder = TypeScriptFileBuilder;
+export interface TypeScriptAngularServiceGenerator<TOutput extends Output = Output> {
+    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 getEndpointSuccessResponse(ctx: Context, endpoint: ApiEndpoint): import("@goast/core").ApiResponse | undefined;
+    protected getServiceClassName(ctx: Context): string;
+    protected hasEndpointParams(ctx: Context, endpoint: ApiEndpoint): boolean;
+    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;
+}
+export {};

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

@@ -0,0 +1,29 @@
+import { ApiService, 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';
+type Input = TypeScriptAngularServicesGeneratorInput;
+type Output = TypeScriptAngularServicesGeneratorOutput;
+type Config = TypeScriptAngularServicesGeneratorConfig;
+type ServiceOutput = TypeScriptAngularServiceGeneratorOutput;
+type Context = TypeScriptAngularServicesGeneratorContext;
+export declare class TypeScriptAngularServicesGenerator extends OpenApiServicesGenerationProviderBase<Input, Output, Config, ServiceOutput, Context> {
+    private readonly _clientGeneratorFactory;
+    constructor(clientGeneratorFactory?: Factory<TypeScriptAngularServiceGenerator, []>);
+    protected initResult(): Output;
+    protected buildContext(context: OpenApiGeneratorContext<Input>, config?: Partial<Config> | undefined): Context;
+    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 getRootUrl(ctx: Context): string;
+}
+export {};

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

@@ -0,0 +1,3 @@
+export * from './angular-service-generator';
+export * from './angular-services-generator';
+export * from './models';

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

@@ -0,0 +1,41 @@
+import { ApiEndpoint, ApiService, DefaultGenerationProviderConfig, Nullable, OpenApiServicesGenerationProviderContext, RequiredProperties, StringCasing, StringCasingWithOptions } from '@goast/core';
+import { TypeScriptComponentOutput } from '../../../common-results';
+import { TypeScriptGeneratorConfig } from '../../../config';
+import { TypeScriptModelsGeneratorOutput } from '../../models';
+export type TypeScriptAngularServicesGeneratorConfig = TypeScriptGeneratorConfig & {
+    fileNameCasing: StringCasing | StringCasingWithOptions;
+    responseModelsFileNameCasing: StringCasing | StringCasingWithOptions;
+    exposeResponseMethods: boolean;
+    exposePathProperties: boolean;
+    clientMethodFlavor: 'default' | 'response-handler';
+    rootUrl?: string | RegExp | ((rootUrl: string) => string);
+    pathModifier?: RegExp | ((path: string, endpoint: ApiEndpoint) => string);
+    servicesDirPath: string;
+    responseModelsDirPath: Nullable<string>;
+    utilsDirPath: string;
+    indexFilePath: Nullable<string>;
+    responseModelsIndexFilePath: Nullable<string>;
+};
+export declare const defaultTypeScriptAngularServicesGeneratorConfig: DefaultGenerationProviderConfig<TypeScriptAngularServicesGeneratorConfig>;
+export type TypeScriptAngularServicesGeneratorInput = TypeScriptModelsGeneratorOutput;
+export type TypeScriptAngularServicesGeneratorOutput = {
+    services: {
+        [serviceId: string]: TypeScriptAngularServiceGeneratorOutput;
+    };
+    servicesIndexFilePath: string | undefined;
+    responseModelsIndexFilePath: string | undefined;
+};
+export type x = Omit<TypeScriptComponentOutput, 'additionalImports'>;
+export type TypeScriptAngularServiceGeneratorOutput = RequiredProperties<TypeScriptComponentOutput, 'filePath'> & {
+    responseModels: {
+        [operationId: string]: TypeScriptComponentOutput & {
+            statusCodes: {
+                [statusCode: string]: TypeScriptComponentOutput;
+            };
+        };
+    };
+};
+export type TypeScriptAngularServicesGeneratorContext = OpenApiServicesGenerationProviderContext<TypeScriptAngularServicesGeneratorInput, TypeScriptAngularServicesGeneratorOutput, TypeScriptAngularServicesGeneratorConfig, TypeScriptAngularServiceGeneratorOutput>;
+export type TypeScriptAngularServiceGeneratorContext = TypeScriptAngularServicesGeneratorContext & {
+    readonly service: ApiService;
+};

package/types/lib/generators/services/fetch-clients/fetch-client-generator.d.ts

@@ -0,0 +1,43 @@
+import { ApiEndpoint, ApiSchema } from '@goast/core';
+import { TypeScriptFetchClientGeneratorContext, TypeScriptFetchClientGeneratorOutput } from './models';
+import { TypeScriptFileBuilder } from '../../../file-builder';
+import { TypeScriptFileGenerator } from '../../file-generator';
+type Context = TypeScriptFetchClientGeneratorContext;
+type Output = TypeScriptFetchClientGeneratorOutput;
+type Builder = TypeScriptFileBuilder;
+export interface TypeScriptFetchClientGenerator<TOutput extends Output = Output> {
+    generate(ctx: Context): TOutput;
+}
+export declare class DefaultTypeScriptFetchClientGenerator extends TypeScriptFileGenerator<Context, Output> implements TypeScriptFetchClientGenerator {
+    generate(ctx: Context): Output;
+    protected generateInterface(ctx: Context, builder: Builder): void;
+    protected generateInterfaceDocumentation(ctx: Context, builder: Builder): void;
+    protected generateInterfaceSignature(ctx: Context, builder: Builder): void;
+    protected generateInterfaceContent(ctx: Context, builder: Builder): void;
+    protected generateInterfaceServiceMethod(ctx: Context, builder: Builder, endpoint: ApiEndpoint): void;
+    protected generateDefaultOptions(ctx: Context, builder: Builder): void;
+    protected generateClass(ctx: Context, builder: Builder): void;
+    protected generateClassDocumentation(ctx: Context, builder: Builder): void;
+    protected generateClassSignature(ctx: Context, builder: Builder): void;
+    protected generateClassContent(ctx: Context, builder: Builder): void;
+    protected generateClassFields(ctx: Context, builder: Builder): void;
+    protected generateClassConstructor(ctx: Context, builder: Builder): void;
+    protected generateClassConstructorContent(ctx: Context, builder: Builder): void;
+    protected generateClassServiceMethod(ctx: Context, builder: Builder, endpoint: ApiEndpoint): void;
+    protected generateServiceMethodDocumentation(ctx: Context, builder: Builder, endpoint: ApiEndpoint): void;
+    protected generateServiceMethodSignature(ctx: Context, builder: Builder, endpoint: ApiEndpoint): void;
+    protected generateServiceMethodParameters(ctx: Context, builder: Builder, endpoint: ApiEndpoint): void;
+    protected generateServiceMethodReturnValue(ctx: Context, builder: Builder, endpoint: ApiEndpoint): void;
+    protected generateTypedResponse(ctx: Context, builder: Builder, schema: ApiSchema | undefined): void;
+    protected generateServiceMethodContent(ctx: Context, builder: Builder, endpoint: ApiEndpoint): void;
+    protected getTypeName(ctx: Context, builder: Builder, schemaId: string | undefined): string;
+    protected shouldGenerateInterface(ctx: Context): boolean;
+    protected shouldGenerateClass(ctx: Context): boolean;
+    protected getInterfaceName(ctx: Context): string;
+    protected getClassName(ctx: Context): string;
+    protected getDefaultOptionsConstantName(ctx: Context): string;
+    protected getInterfaceFilePath(ctx: Context): string;
+    protected getClassFilePath(ctx: Context): string;
+    protected getUtilPath(ctx: Context, fileName: string): string;
+}
+export {};

package/types/lib/generators/services/fetch-clients/fetch-clients-generator.d.ts

@@ -0,0 +1,24 @@
+import { ApiService, OpenApiGeneratorContext, OpenApiServicesGenerationProviderBase, Factory } from '@goast/core';
+import { TypeScriptFetchClientGenerator } from './fetch-client-generator';
+import { TypeScriptFetchClientGeneratorOutput, TypeScriptFetchClientsGeneratorConfig, TypeScriptFetchClientsGeneratorContext, TypeScriptFetchClientsGeneratorInput, TypeScriptFetchClientsGeneratorOutput } from './models';
+import { TypeScriptFileBuilder } from '../../../file-builder';
+type Input = TypeScriptFetchClientsGeneratorInput;
+type Output = TypeScriptFetchClientsGeneratorOutput;
+type Config = TypeScriptFetchClientsGeneratorConfig;
+type ServiceOutput = TypeScriptFetchClientGeneratorOutput;
+type Context = TypeScriptFetchClientsGeneratorContext;
+export declare class TypeScriptClientsGenerator extends OpenApiServicesGenerationProviderBase<Input, Output, Config, ServiceOutput, Context> {
+    private readonly _clientGeneratorFactory;
+    constructor(clientGeneratorFactory?: Factory<TypeScriptFetchClientGenerator, []>);
+    protected initResult(): Output;
+    protected buildContext(context: OpenApiGeneratorContext<Input>, config?: Partial<Config> | undefined): Context;
+    onGenerate(ctx: Context): Output;
+    protected generateService(ctx: Context, service: ApiService): ServiceOutput;
+    protected addServiceResult(ctx: Context, service: ApiService, result: ServiceOutput): void;
+    protected generateIndexFile(ctx: Context): string | undefined;
+    protected getIndexFilePath(ctx: Context): string;
+    protected shouldGenerateIndexFile(ctx: Context): boolean;
+    protected generateIndexFileContent(ctx: Context, builder: TypeScriptFileBuilder): void;
+    private copyUtilsFiles;
+}
+export {};

package/types/lib/generators/services/fetch-clients/index.d.ts

@@ -0,0 +1,3 @@
+export * from './fetch-client-generator';
+export * from './fetch-clients-generator';
+export * from './models';

package/types/lib/generators/services/fetch-clients/models.d.ts

@@ -0,0 +1,34 @@
+import { ApiService, DefaultGenerationProviderConfig, OpenApiServicesGenerationProviderContext, StringCasing, StringCasingWithOptions, Nullable } from '@goast/core';
+import { TypeScriptComponentOutput } from '../../../common-results';
+import { TypeScriptGeneratorConfig } from '../../../config';
+import { TypeScriptModelsGeneratorOutput } from '../../models/models';
+export type TypeScriptFetchClientsGeneratorConfig = TypeScriptGeneratorConfig & {
+    fileNameCasing: StringCasing | StringCasingWithOptions;
+    interfaceFileNameCasing: Nullable<StringCasing | StringCasingWithOptions>;
+    classNameCasing: StringCasing | StringCasingWithOptions;
+    interfaceNameCasing: StringCasing | StringCasingWithOptions;
+    methodCasing: StringCasing | StringCasingWithOptions;
+    clientFileKind: 'interface' | 'class' | 'class-and-interface';
+    clientDirPath: string;
+    clientInterfaceDirPath: Nullable<string>;
+    indexFilePath: Nullable<string>;
+    interfaceIndexFilePath: Nullable<string>;
+    utilsDirPath: string;
+};
+export declare const defaultTypeScriptFetchClientsGeneratorConfig: DefaultGenerationProviderConfig<TypeScriptFetchClientsGeneratorConfig>;
+export type TypeScriptFetchClientsGeneratorInput = TypeScriptModelsGeneratorOutput;
+export type TypeScriptFetchClientsGeneratorOutput = {
+    clients: {
+        [serviceId: string]: TypeScriptFetchClientGeneratorOutput;
+    };
+    clientIndexFilePath: string | undefined;
+    clientInterfaceIndexFilePath: string | undefined;
+};
+export type TypeScriptFetchClientGeneratorOutput = {
+    class?: Omit<TypeScriptComponentOutput, 'additionalImports'>;
+    interface?: Omit<TypeScriptComponentOutput, 'additionalImports'>;
+};
+export type TypeScriptFetchClientsGeneratorContext = OpenApiServicesGenerationProviderContext<TypeScriptFetchClientsGeneratorInput, TypeScriptFetchClientsGeneratorOutput, TypeScriptFetchClientsGeneratorConfig, TypeScriptFetchClientGeneratorOutput>;
+export type TypeScriptFetchClientGeneratorContext = TypeScriptFetchClientsGeneratorContext & {
+    readonly service: ApiService;
+};

package/types/lib/import-collection.d.ts

@@ -0,0 +1,21 @@
+import { SourceBuilderOptions, StringBuilder } from '@goast/core';
+import { TypeScriptImport, TypeScriptImportKind } from './common-results';
+import { TypeScriptFileBuilder } from './file-builder';
+import { ImportModuleTransformer } from './utils';
+export declare class ImportExportCollection {
+    private readonly _imports;
+    private readonly _exports;
+    get hasImports(): boolean;
+    get hasExports(): boolean;
+    get imports(): TypeScriptImport[];
+    addImport(importName: string, fromModule: string): void;
+    addExport(exportName: string, fromModule: string): void;
+    clear(): void;
+    toString(options: Partial<SourceBuilderOptions>, filePath: string | undefined, importModuleTransformer: ImportModuleTransformer): string;
+    writeTo(builder: StringBuilder, filePath: string | undefined, importModuleTransformer: ImportModuleTransformer): void;
+    writeTo(builder: TypeScriptFileBuilder): void;
+    protected writeImportsExports(builder: StringBuilder, keyword: 'import' | 'export', data: (readonly [string, TypeScriptImportKind, string[]])[]): void;
+    protected sortAndResolve(data: Map<string, Set<string>>, filePath: string | undefined, importModuleTransformer: ImportModuleTransformer): (readonly [string, TypeScriptImportKind, string[]])[];
+    protected getImportKind(fromModule: string): TypeScriptImportKind;
+    protected resolveModulePath(fromModule: string, filePath: string | undefined, importModuleTransformer: ImportModuleTransformer): [string, TypeScriptImportKind];
+}

package/types/lib/utils.d.ts

@@ -0,0 +1,6 @@
+export type ImportModuleTransformer = 'omit-extension' | 'js-extension' | ((module: string) => string);
+export declare function toTypeScriptStringLiteral(value: string, useSingleQuotes: boolean): string;
+export declare function toTypeScriptPropertyName(value: string, useSingleQuotes: boolean): string;
+export declare function getModulePathRelativeToFile(from: string, to: string, transformer: ImportModuleTransformer): string;
+export declare function getModulePathRelativeToDirectory(from: string, to: string, transformer: ImportModuleTransformer): string;
+export declare function modifyString<TArgs extends any[]>(value: string, modifier: string | RegExp | ((value: string, ...args: TArgs) => string) | undefined, ...args: TArgs): string;