@mediusinc/mng-commons-data-api 5.0.0-rc.0

package/lib/helpers/get-all-params.d.ts

@@ -0,0 +1,69 @@
+import { Observable } from 'rxjs';
+import { DataListFilter, DataListParams, DataListResult } from '@mediusinc/mng-commons/core';
+import { GetAllParamsFilterMatchType, GetAllParamsType, GetAllParamsUrlQueryType } from '../models/request-params.model';
+/**
+ * Converts a filter match mode to its corresponding enum value.
+ *
+ * @param {string} matchMode - The filter match mode from data list filter to convert.
+ * @returns {GetAllParamsFilterMatchType} - The converted enum value.
+ * @throws {CommonsInternalError} - If the filter match mode is not supported.
+ */
+export declare function toGetAllParamsFilterMatchMode(matchMode: string): GetAllParamsFilterMatchType;
+/**
+ * Converts given parameters of a DataListParams object into a get all request param object with values as URL query string representation.
+ *
+ * @param {DataListParams} params - The parameters to convert.
+ * @typeparam Sorts - The type of the sorting options for the data list.
+ * @typeparam Filters - The type of the filters for the data list.
+ * @returns {GetAllParamsUrlQueryType<Filters>} - Get all request param object with values as URL query string representation.
+ */
+export declare function toGetAllParamsAsUrlQuery<Sorts, Filters extends keyof any>(params: DataListParams<Sorts, Filters>): GetAllParamsUrlQueryType<Filters>;
+/**
+ * Converts given parameters of a DataListParams object into a get all request param object with values as objects for POST requests.
+ *
+ * @param {DataListParams} params - The parameters to convert.
+ * @typeparam Sorts - The type of the sorting options for the data list.
+ * @typeparam Filters - The type of the filters for the data list.
+ * @returns {GetAllParamsType<Sorts, Filters>} - Get all request param object with values as objects for POST requests.
+ */
+export declare function toGetAllParams<Sorts, Filters extends keyof any>(params: DataListParams<Sorts, Filters>): GetAllParamsType<Sorts, Filters>;
+/**
+ * Converts DataListParams to sort query URL representation.
+ *
+ * @param {DataListParams} params - The params object with sort property to convert.
+ * @returns {string | undefined} - The formatted sort query URL param or undefined.
+ */
+export declare function toGetAllSortAsQueryUrl(params?: DataListParams<any, any>): string | undefined;
+/**
+ * Converts a DataListFilter object to a query URL string.
+ *
+ * @param {DataListFilter} filter - The filter object from params to convert.
+ * @returns {string|undefined} - The formatted filter query URL param or undefined.
+ */
+export declare function toGetAllFilterAsQueryUrl(filter?: DataListFilter): string | undefined;
+/**
+ * Executes the "getAll" on API service with request parameters.
+ * Get all is expected to be executed via GET method using params as URL queries.
+ *
+ * @param {Service} service - The API service instance.
+ * @param {Function} getAllFn - The "getAll" function on provided service instance.
+ * @param {Object} params - The data list params.
+ * @returns {Observable<<DataListResult<Item>>>} An observable with data list result.
+ */
+export declare function executeGetAll<Service, Item, Sorts, Filters extends keyof any>(service: Service, getAllFn: (requestParameters: GetAllParamsUrlQueryType<Filters>) => Observable<{
+    data?: Item[];
+    totalCount?: number;
+}>, params: DataListParams<Sorts, Filters>): Observable<DataListResult<Item>>;
+/**
+ * Executes the "getAll" on API service with request parameters.
+ * Get all is expected to be executed via POST method using params as object in body of request.
+ *
+ * @param {Service} service - The API service instance.
+ * @param {Function} getAllFn - The "getAll" function on provided service instance.
+ * @param {Object} params - The data list params.
+ * @returns {Observable<<DataListResult<Item>>>} An observable with data list result.
+ */
+export declare function executeGetAllAsPost<Service, Item, Sorts, Filters extends keyof any>(service: Service, getAllFn: (requestParameters: GetAllParamsType<Sorts, Filters>) => Observable<{
+    data?: Item[];
+    totalCount?: number;
+}>, params: DataListParams<Sorts, Filters>): Observable<DataListResult<Item>>;

package/lib/models/request-params.model.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Default (expected) type without filters, which are "dynamic" keys.
+ */
+export type GetAllParamsDefaultWoFiltersType<Sort = GetAllParamsSortType[] | string, GlobalFilter = GetAllParamsGlobalFilterType | string> = {
+    offset?: number;
+    limit?: number;
+    globalFilter?: GlobalFilter;
+    sort?: Sort;
+};
+/**
+ * Represents the sort direction type for a get all request params (ascending or descending).
+ */
+export type GetAllParamsSortDirectionType = 'ASCENDING' | 'DESCENDING';
+/**
+ * Represents the sort type for a get all request params.
+ *
+ * @typeparam Property The type of the property to sort by.
+ * @typeparam Direction The type of the sort direction.
+ */
+export type GetAllParamsSortType<Property = string, Direction = GetAllParamsSortDirectionType> = {
+    property: Property;
+    direction: Direction;
+};
+/**
+ * Represents the possible match types for filters in get all request params.
+ */
+export type GetAllParamsFilterMatchType = 'EQUALS' | 'NOT_EQUALS' | 'BETWEEN' | 'CONTAINS' | 'NOT_CONTAINS' | 'STARTS_WITH' | 'ENDS_WITH' | 'IN' | 'NOT_IN' | 'LESS_THAN' | 'LESS_THAN_OR_EQUAL_TO' | 'GREATER_THAN' | 'GREATER_THAN_OR_EQUAL_TO' | 'EXISTS' | 'DOES_NOT_EXIST';
+/**
+ * Describes the possible case sensitivity for filter in get all request params.
+ */
+export type GetAllParamsFilterCaseSensitivityType = 'CASE_SENSITIVE' | 'CASE_INSENSITIVE';
+/**
+ * Describes the global filter (search) in get all request params.
+ */
+export type GetAllParamsGlobalFilterType<CaseSensitivity = GetAllParamsFilterCaseSensitivityType> = {
+    value: string;
+    caseSensitivity?: CaseSensitivity;
+};
+/**
+ * Describes the filters in get all request params.
+ */
+export type GetAllParamsFiltersType<FilterType, FilterProperties extends keyof any> = {
+    [P in FilterProperties]: FilterType;
+};
+/**
+ * Represents a filter type for get all request params.
+ */
+export type GetAllParamsFilterType<Value, CaseSensitivity = GetAllParamsFilterCaseSensitivityType, MatchType = GetAllParamsFilterMatchType> = {
+    value?: Value;
+    values?: Array<Value>;
+    caseSensitivity?: CaseSensitivity;
+    filterMatchType: MatchType;
+};
+/**
+ * Describes get all params with values as objects (for POST requests).
+ */
+export type GetAllParamsType<Sorts = string, Filters extends keyof any = string> = GetAllParamsDefaultWoFiltersType<GetAllParamsSortType<Sorts>[], GetAllParamsGlobalFilterType> & GetAllParamsFiltersType<GetAllParamsFilterType<any>, Filters>;
+/**
+ * Describes get all params with values as URL queries (for GET requests).
+ */
+export type GetAllParamsUrlQueryType<Filters extends keyof any> = GetAllParamsDefaultWoFiltersType<string, string> & GetAllParamsFiltersType<string, Filters>;

package/lib/types/extract-get-all-params.type.d.ts

@@ -0,0 +1,14 @@
+import { GetAllParamsDefaultWoFiltersType, GetAllParamsSortType } from '../models/request-params.model';
+/**
+ * Represents the type definition for the `GetAllParamsDefaultWoFiltersType` class - excludes offset, limit, search and sort properties.
+ * All other properties are expected to be filters.
+ *
+ * @typeparam Request - The type parameter representing the extended GetAllParamsDefaultWoFiltersType object.
+ */
+export type ExtractGetAllParamsFilterType<Request extends GetAllParamsDefaultWoFiltersType> = keyof Omit<Request, 'offset' | 'limit' | 'globalFilter' | 'sort'>;
+/**
+ * Represents the type definition for the `GetAllParamsDefaultWoFiltersType` class - extracts allowed sort properties (usually an enum) on property key within array type.
+ *
+ * @typeparam Request - The type parameter representing the extended GetAllParamsDefaultWoFiltersType object.
+ */
+export type ExtractGetAllParamsSortType<Request extends GetAllParamsDefaultWoFiltersType<GetAllParamsSortType<any, any>[] | string, any>> = NonNullable<Request['sort']> extends Array<infer U> | string ? ('property' extends keyof U ? NonNullable<U['property']> : never) : never;

package/openapi/README.mustache

@@ -0,0 +1,226 @@
+## {{npmName}}@{{npmVersion}}
+
+### Building
+
+To install the required dependencies and to build the typescript sources run:
+```
+npm install
+npm run build
+```
+
+### publishing
+
+First build the package then run ```npm publish dist``` (don't forget to specify the `dist` folder!)
+
+### consuming
+
+Navigate to the folder of your consuming project and run one of next commands.
+
+_published:_
+
+```
+npm install {{npmName}}@{{npmVersion}} --save
+```
+
+_without publishing (not recommended):_
+
+```
+npm install PATH_TO_GENERATED_PACKAGE/dist.tgz --save
+```
+
+_It's important to take the tgz file, otherwise you'll get trouble with links on windows_
+
+_using `npm link`:_
+
+In PATH_TO_GENERATED_PACKAGE/dist:
+```
+npm link
+```
+
+In your project:
+```
+npm link {{npmName}}
+```
+
+__Note for Windows users:__ The Angular CLI has troubles to use linked npm packages.
+Please refer to this issue https://github.com/angular/angular-cli/issues/8284 for a solution / workaround.
+Published packages are not effected by this issue.
+
+
+#### General usage
+
+In your Angular project:
+
+
+```
+// without configuring providers
+import { {{apiModuleClassName}} } from '{{npmName}}';
+import { HttpClientModule } from '@angular/common/http';
+
+@NgModule({
+    imports: [
+        {{apiModuleClassName}},
+        // make sure to import the HttpClientModule in the AppModule only,
+        // see https://github.com/angular/angular/issues/20575
+        HttpClientModule
+    ],
+    declarations: [ AppComponent ],
+    providers: [],
+    bootstrap: [ AppComponent ]
+})
+export class AppModule {}
+```
+
+```
+// configuring providers
+import { {{apiModuleClassName}}, {{configurationClassName}}, {{configurationParametersInterfaceName}} } from '{{npmName}}';
+
+export function apiConfigFactory (): {{configurationClassName}} {
+  const params: {{configurationParametersInterfaceName}} = {
+    // set configuration parameters here.
+  }
+  return new {{configurationClassName}}(params);
+}
+
+@NgModule({
+    imports: [ {{apiModuleClassName}}.forRoot(apiConfigFactory) ],
+    declarations: [ AppComponent ],
+    providers: [],
+    bootstrap: [ AppComponent ]
+})
+export class AppModule {}
+```
+
+```
+// configuring providers with an authentication service that manages your access tokens
+import { {{apiModuleClassName}}, {{configurationClassName}} } from '{{npmName}}';
+
+@NgModule({
+    imports: [ {{apiModuleClassName}} ],
+    declarations: [ AppComponent ],
+    providers: [
+      {
+        provide: {{configurationClassName}},
+        useFactory: (authService: AuthService) => new {{configurationClassName}}(
+          {
+            basePath: environment.apiUrl,
+            accessToken: authService.getAccessToken.bind(authService)
+          }
+        ),
+        deps: [AuthService],
+        multi: false
+      }
+    ],
+    bootstrap: [ AppComponent ]
+})
+export class AppModule {}
+```
+
+```
+import { DefaultApi } from '{{npmName}}';
+
+export class AppComponent {
+    constructor(private apiGateway: DefaultApi) { }
+}
+```
+
+Note: The {{apiModuleClassName}} is restricted to being instantiated once app wide.
+This is to ensure that all services are treated as singletons.
+
+#### Using multiple OpenAPI files / APIs / {{apiModuleClassName}}s
+In order to use multiple `{{apiModuleClassName}}s` generated from different OpenAPI files,
+you can create an alias name when importing the modules
+in order to avoid naming conflicts:
+```
+import { {{apiModuleClassName}} } from 'my-api-path';
+import { {{apiModuleClassName}} as OtherApiModule } from 'my-other-api-path';
+import { HttpClientModule } from '@angular/common/http';
+
+@NgModule({
+  imports: [
+    {{apiModuleClassName}},
+    OtherApiModule,
+    // make sure to import the HttpClientModule in the AppModule only,
+    // see https://github.com/angular/angular/issues/20575
+    HttpClientModule
+  ]
+})
+export class AppModule {
+
+}
+```
+
+
+### Set service base path
+If different than the generated base path, during app bootstrap, you can provide the base path to your service.
+
+```
+import { BASE_PATH } from '{{npmName}}';
+
+bootstrap(AppComponent, [
+    { provide: BASE_PATH, useValue: 'https://your-web-service.com' },
+]);
+```
+or
+
+```
+import { BASE_PATH } from '{{npmName}}';
+
+@NgModule({
+    imports: [],
+    declarations: [ AppComponent ],
+    providers: [ provide: BASE_PATH, useValue: 'https://your-web-service.com' ],
+    bootstrap: [ AppComponent ]
+})
+export class AppModule {}
+```
+
+
+#### Using @angular/cli
+First extend your `src/environments/*.ts` files by adding the corresponding base path:
+
+```
+export const environment = {
+  production: false,
+  API_BASE_PATH: 'http://127.0.0.1:8080'
+};
+```
+
+In the src/app/app.module.ts:
+```
+import { BASE_PATH } from '{{npmName}}';
+import { environment } from '../environments/environment';
+
+@NgModule({
+  declarations: [
+    AppComponent
+  ],
+  imports: [ ],
+  providers: [{ provide: BASE_PATH, useValue: environment.API_BASE_PATH }],
+  bootstrap: [ AppComponent ]
+})
+export class AppModule { }
+```
+
+### Customizing path parameter encoding
+
+Without further customization, only [path-parameters][parameter-locations-url] of [style][style-values-url] 'simple'
+and Dates for format 'date-time' are encoded correctly.
+
+Other styles (e.g. "matrix") are not that easy to encode
+and thus are best delegated to other libraries (e.g.: [@honoluluhenk/http-param-expander]).
+
+To implement your own parameter encoding (or call another library),
+pass an arrow-function or method-reference to the `encodeParam` property of the Configuration-object
+(see [General Usage](#general-usage) above).
+
+Example value for use in your Configuration-Provider:
+```typescript
+new Configuration({
+    encodeParam: (param: Param) => myFancyParamEncoder(param),
+})
+```
+
+[parameter-locations-url]: https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#parameter-locations
+[style-values-url]: https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#style-values
+[@honoluluhenk/http-param-expander]: https://www.npmjs.com/package/@honoluluhenk/http-param-expander

package/openapi/api.module.mustache

@@ -0,0 +1,39 @@
+import { NgModule, ModuleWithProviders, SkipSelf, Optional } from '@angular/core';
+import { {{configurationClassName}} } from './configuration';
+import { HttpClient } from '@angular/common/http';
+
+{{#isProvidedInNone}}
+{{#apiInfo}}
+{{#apis}}
+import { {{classname}} } from './{{importPath}}';
+{{/apis}}
+{{/apiInfo}}
+{{/isProvidedInNone}}
+
+@NgModule({
+  imports:      [],
+  declarations: [],
+  exports:      [],
+  providers: [{{#isProvidedInNone}}
+    {{#apiInfo}}{{#apis}}{{classname}}{{^-last}},
+    {{/-last}}{{/apis}}{{/apiInfo}} {{/isProvidedInNone}}]
+})
+export class {{apiModuleClassName}} {
+    public static forRoot(configurationFactory: () => {{configurationClassName}}): ModuleWithProviders{{#enforceGenericModuleWithProviders}}<{{apiModuleClassName}}>{{/enforceGenericModuleWithProviders}} {
+        return {
+            ngModule: {{apiModuleClassName}},
+            providers: [ { provide: {{configurationClassName}}, useFactory: configurationFactory } ]
+        };
+    }
+
+    constructor( @Optional() @SkipSelf() parentModule: {{apiModuleClassName}},
+                 @Optional() http: HttpClient) {
+        if (parentModule) {
+            throw new Error('{{apiModuleClassName}} is already loaded. Import in your base AppModule only.');
+        }
+        if (!http) {
+            throw new Error('You need to import the HttpClientModule in your AppModule! \n' +
+            'See also https://github.com/angular/angular/issues/20575');
+        }
+    }
+}

package/openapi/api.service.mustache

@@ -0,0 +1,253 @@
+{{>licenseInfo}}
+
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/ban-types */
+
+import {Injectable} from '@angular/core';
+import {HttpParams, HttpResponse} from '@angular/common/http';
+import {Observable} from 'rxjs';
+
+{{#imports}}
+import { {{classname}} } from '{{filename}}';
+{{/imports}}
+
+import {BaseApiService} from './base-api.service';
+import {COLLECTION_FORMATS}                     from '../variables';
+import {addToHttpParams, getResponseType, selectHeaderAccept {{#hasSomeFormParams}}, canConsumeForm{{/hasSomeFormParams}}} from '../helpers';
+
+{{#withInterfaces}}
+import {
+    {{classname}}Interface{{#useSingleRequestParameter}}{{#operations}}{{#operation}}{{#allParams.0}},
+    {{#prefixParameterInterfaces}}{{classname}}{{/prefixParameterInterfaces}}{{operationIdCamelCase}}RequestParams{{/allParams.0}}{{/operation}}{{/operations}}{{/useSingleRequestParameter}}
+} from './{{classFilename}}Interface';
+{{/withInterfaces}}
+
+{{#operations}}
+
+{{^withInterfaces}}
+{{#useSingleRequestParameter}}
+{{#operation}}
+{{#allParams.0}}
+export interface {{#prefixParameterInterfaces}}{{classname}}{{/prefixParameterInterfaces}}{{operationIdCamelCase}}RequestParams {
+{{#allParams}}
+    {{#description}}/** {{.}} */
+    {{/description}}{{paramName}}{{^required}}?{{/required}}: {{{dataType}}}{{#isNullable}} | null{{/isNullable}};
+{{/allParams}}
+}
+
+{{/allParams.0}}
+{{/operation}}
+{{/useSingleRequestParameter}}
+{{/withInterfaces}}
+
+{{#description}}
+/**
+ * {{&description}}
+ */
+{{/description}}
+{{#isProvidedInNone}}
+@Injectable()
+{{/isProvidedInNone}}
+{{^isProvidedInNone}}
+@Injectable({
+  providedIn: '{{providedIn}}'
+})
+{{/isProvidedInNone}}
+{{#withInterfaces}}
+export class {{classname}} extends BaseApiService implements {{classname}}Interface {
+{{/withInterfaces}}
+{{^withInterfaces}}
+export class {{classname}} extends BaseApiService {
+{{/withInterfaces}}
+
+{{#operation}}
+    /**
+{{#summary}}
+     * {{.}}
+{{/summary}}
+{{#notes}}
+     * {{.}}
+{{/notes}}
+     {{^useSingleRequestParameter}}
+     {{#allParams}}
+     * @param {{paramName}} {{description}}
+     {{/allParams}}
+     {{/useSingleRequestParameter}}
+     {{#useSingleRequestParameter}}
+     {{#allParams.0}}
+     * @param requestParameters
+     {{/allParams.0}}
+     {{/useSingleRequestParameter}}
+     * @param observe set whether or not to return the data Observable as the body or response. defaults to returning the body.
+     {{#isDeprecated}}
+     * @deprecated
+     {{/isDeprecated}}
+     */
+    public {{nickname}}({{^useSingleRequestParameter}}{{#allParams}}{{paramName}}{{^required}}?{{/required}}: {{{dataType}}}, {{/allParams}}{{/useSingleRequestParameter}}{{#useSingleRequestParameter}}{{#allParams.0}}requestParameters: {{#prefixParameterInterfaces}}{{classname}}{{/prefixParameterInterfaces}}{{operationIdCamelCase}}RequestParams, {{/allParams.0}}{{/useSingleRequestParameter}}observe?: 'body'): Observable<{{#returnType}}{{{returnType}}}{{#isResponseTypeFile}}|undefined{{/isResponseTypeFile}}{{/returnType}}{{^returnType}}any{{/returnType}}>;
+    public {{nickname}}({{^useSingleRequestParameter}}{{#allParams}}{{paramName}}{{^required}}?{{/required}}: {{{dataType}}}, {{/allParams}}{{/useSingleRequestParameter}}{{#useSingleRequestParameter}}{{#allParams.0}}requestParameters: {{#prefixParameterInterfaces}}{{classname}}{{/prefixParameterInterfaces}}{{operationIdCamelCase}}RequestParams, {{/allParams.0}}{{/useSingleRequestParameter}}observe?: 'response'): Observable<HttpResponse<{{#returnType}}{{{returnType}}}{{#isResponseTypeFile}}|undefined{{/isResponseTypeFile}}{{/returnType}}{{^returnType}}any{{/returnType}}>>;
+    public {{nickname}}({{^useSingleRequestParameter}}{{#allParams}}{{paramName}}{{^required}}?{{/required}}: {{{dataType}}}, {{/allParams}}{{/useSingleRequestParameter}}{{#useSingleRequestParameter}}{{#allParams.0}}requestParameters: {{#prefixParameterInterfaces}}{{classname}}{{/prefixParameterInterfaces}}{{operationIdCamelCase}}RequestParams, {{/allParams.0}}{{/useSingleRequestParameter}}observe: 'body' | 'response' = 'body'): Observable<any> {
+{{#allParams}}
+{{#useSingleRequestParameter}}
+        const {{paramName}} = requestParameters.{{paramName}};
+{{/useSingleRequestParameter}}
+{{#required}}
+        if ({{paramName}} === null || {{paramName}} === undefined) {
+            throw new Error('Required parameter {{paramName}} was null or undefined when calling {{nickname}}.');
+        }
+{{/required}}
+{{/allParams}}
+
+{{#hasQueryParamsOrAuth}}
+        let localVarQueryParameters = new HttpParams({encoder: this.encoder});
+{{#queryParams}}
+        {{#isArray}}
+        if ({{paramName}}) {
+        {{#isQueryParamObjectFormatJson}}
+        localVarQueryParameters = addToHttpParams(localVarQueryParameters,
+            {{paramName}}, '{{baseName}}');
+        {{/isQueryParamObjectFormatJson}}
+        {{^isQueryParamObjectFormatJson}}
+        {{#isCollectionFormatMulti}}
+            {{paramName}}.forEach((element) => {
+                localVarQueryParameters = addToHttpParams(localVarQueryParameters,
+                  element, '{{baseName}}');
+            })
+        {{/isCollectionFormatMulti}}
+        {{^isCollectionFormatMulti}}
+            localVarQueryParameters = addToHttpParams(localVarQueryParameters,
+                [...{{paramName}}].join(COLLECTION_FORMATS['{{collectionFormat}}']), '{{baseName}}');
+        {{/isCollectionFormatMulti}}
+        {{/isQueryParamObjectFormatJson}}
+        }
+        {{/isArray}}
+        {{^isArray}}
+        if ({{paramName}} !== undefined && {{paramName}} !== null) {
+          localVarQueryParameters = addToHttpParams(localVarQueryParameters,
+            {{paramName}}, '{{baseName}}');
+        }
+        {{/isArray}}
+{{/queryParams}}
+
+{{/hasQueryParamsOrAuth}}
+        let localVarHeaders = this.defaultHeaders;
+{{#headerParams}}
+        {{#isArray}}
+        if ({{paramName}}) {
+            localVarHeaders = localVarHeaders.set('{{baseName}}', [...{{paramName}}].join(COLLECTION_FORMATS['{{collectionFormat}}']));
+        }
+        {{/isArray}}
+        {{^isArray}}
+        if ({{paramName}} !== undefined && {{paramName}} !== null) {
+            localVarHeaders = localVarHeaders.set('{{baseName}}', String({{paramName}}));
+        }
+        {{/isArray}}
+{{/headerParams}}
+        const localVarHttpHeaderAcceptSelected = selectHeaderAccept([
+    {{#produces}}
+            '{{{mediaType}}}'{{^-last}},{{/-last}}
+    {{/produces}}
+        ], {}, this.configuration);
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+
+{{#bodyParam}}
+{{- duplicated below, don't forget to change}}
+        // to determine the Content-Type header
+        const consumes: string[] = [
+            {{#consumes}}
+            '{{{mediaType}}}'{{^-last}},{{/-last}}
+            {{/consumes}}
+        ];
+{{/bodyParam}}
+{{#hasFormParams}}
+{{^bodyParam}}
+        // to determine the Content-Type header
+        const consumes: string[] = [
+            {{#consumes}}
+            '{{{mediaType}}}'{{^-last}},{{/-last}}
+            {{/consumes}}
+        ];
+{{/bodyParam}}
+{{/hasFormParams}}
+{{#bodyParam}}
+        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);
+        if (httpContentTypeSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);
+        }
+{{/bodyParam}}
+
+{{#hasFormParams}}
+        const canConsumeForm = this.canConsumeForm(consumes);
+
+        let localVarFormParams: { append(param: string, value: any): any; };
+        let localVarUseForm = false;
+        let localVarConvertFormParamsToString = false;
+{{#formParams}}
+{{#isFile}}
+        // use FormData to transmit files using content-type "multipart/form-data"
+        // see https://stackoverflow.com/questions/4007969/application-x-www-form-urlencoded-or-multipart-form-data
+        localVarUseForm = canConsumeForm;
+{{/isFile}}
+{{/formParams}}
+        if (localVarUseForm) {
+            localVarFormParams = new FormData();
+        } else {
+            localVarFormParams = new HttpParams({encoder: this.encoder});
+        }
+
+{{#formParams}}
+        {{#isArray}}
+        if ({{paramName}}) {
+        {{#isCollectionFormatMulti}}
+            {{paramName}}.forEach((element) => {
+                localVarFormParams = localVarFormParams.append('{{baseName}}', <any>element) as any || localVarFormParams;
+            })
+        {{/isCollectionFormatMulti}}
+        {{^isCollectionFormatMulti}}
+            if (localVarUseForm) {
+                {{paramName}}.forEach((element) => {
+                    localVarFormParams = localVarFormParams.append('{{baseName}}', <any>element) as any || localVarFormParams;
+            })
+            } else {
+                localVarFormParams = localVarFormParams.append('{{baseName}}', [...{{paramName}}].join(COLLECTION_FORMATS['{{collectionFormat}}'])) as any || localVarFormParams;
+            }
+        {{/isCollectionFormatMulti}}
+        }
+        {{/isArray}}
+        {{^isArray}}
+        if ({{paramName}} !== undefined) {
+            localVarFormParams = localVarFormParams.append('{{baseName}}', {{^isModel}}<any>{{paramName}}{{/isModel}}{{#isModel}}localVarUseForm ? new Blob([JSON.stringify({{paramName}})], {type: 'application/json'}) : <any>{{paramName}}{{/isModel}}) as any || localVarFormParams;
+        }
+        {{/isArray}}
+{{/formParams}}
+
+{{/hasFormParams}}
+        let localVarPath = `{{{path}}}`;
+        return this.httpClient.request{{^isResponseFile}}<{{#returnType}}{{{returnType}}}{{#isResponseTypeFile}}|undefined{{/isResponseTypeFile}}{{/returnType}}{{^returnType}}any{{/returnType}}>{{/isResponseFile}}('{{httpMethod}}', `${this.configuration.basePath}${localVarPath}`,
+            {
+    {{#bodyParam}}
+                body: {{paramName}},
+    {{/bodyParam}}
+    {{^bodyParam}}
+    {{#hasFormParams}}
+                body: localVarConvertFormParamsToString ? localVarFormParams.toString() : localVarFormParams,
+    {{/hasFormParams}}
+    {{/bodyParam}}
+    {{#hasQueryParamsOrAuth}}
+                params: localVarQueryParameters,
+    {{/hasQueryParamsOrAuth}}
+    {{#isResponseFile}}
+                responseType: "blob",
+    {{/isResponseFile}}
+    {{^isResponseFile}}
+                responseType: <any>getResponseType(localVarHttpHeaderAcceptSelected, this.configuration),
+    {{/isResponseFile}}
+                withCredentials: this.configuration.withCredentials,
+                headers: localVarHeaders,
+                observe: <any>observe
+            }
+        );
+    }
+
+{{/operation}}}
+{{/operations}}