@mediusinc/mng-commons 5.0.0-rc.0-c31d5206 → 5.0.0-rc.0

package/lib/utils/model.util.d.ts

@@ -1,10 +0,0 @@
-import { ILookupDescriptor } from '../descriptors/interfaces';
-import { ClassAttributeDef } from '../models';
-import { ClassType } from '../types';
-export declare class ModelUtil {
-    static findIdAttribute<T>(classType?: ClassType<T>): string | null;
-    static findTitleAttribute<T>(classType?: ClassType<T>): string | null;
-    static getAttributeDef<T>(classType?: ClassType<T>): ClassAttributeDef[] | null;
-    private static findAttributeByTypeAndName;
-    static trySetLookupItemsProperties<T>(lookup: ILookupDescriptor<T>, idAsTrack?: boolean): void;
-}

package/lib/utils/notification.util.d.ts

@@ -1,13 +0,0 @@
-import { TranslateService } from '@ngx-translate/core';
-import { Message, MessageService } from 'primeng/api';
-import { ActionDescriptor } from '../descriptors/action';
-import { TableDescriptorInst } from '../descriptors/table';
-import { IMngError } from '../models';
-export declare class NotificationUtil {
-    static notification(messageService: MessageService, title?: string, message?: string, severity?: 'success' | 'warn' | 'error', icon?: string): Message;
-    static tableNotificationError(translate: TranslateService, table: TableDescriptorInst<any>, error: any, messageService: MessageService): Message;
-    static actionNotificationSuccess(translate: TranslateService, action: ActionDescriptor, functionName: string, messageService: MessageService, customTitleKey?: string, customMessageKey?: string, item?: any): Message;
-    static actionNotificationError(translate: TranslateService, action: ActionDescriptor, error: IMngError, functionName: string, messageService: MessageService, item?: any, severity?: 'warn' | 'error'): Message;
-    static getFormEditorInfoMessage(translate: TranslateService, title: string, message: string, params?: any): Message;
-    static getFormEditorWarningMessage(translate: TranslateService, title: string, message: string): Message;
-}

package/lib/utils/object.util.d.ts

@@ -1,30 +0,0 @@
-import { ClassType } from '../types';
-interface DeepCopyPropsOptions {
-    mapGettersToProperties?: boolean;
-}
-export interface DeepCopyOptions<P = object> extends DeepCopyPropsOptions {
-    objectPrototype?: ClassType<P>;
-}
-export declare class ObjectUtil {
-    static deepCopy<T = object, P = object>(obj: T, options: DeepCopyOptions<P> & {
-        mapGettersToProperties: true;
-    }): T | Record<string, any>;
-    static deepCopy<T = object, P = object>(obj: T, options: DeepCopyOptions<P> & {
-        objectPrototype: ClassType<P>;
-    } & {
-        mapGettersToProperties?: false;
-    }): P;
-    static deepCopy<T = object, P = object>(obj: T, options: DeepCopyOptions<P> & {
-        objectPrototype: ClassType<P>;
-    } & {
-        mapGettersToProperties: true;
-    }): P | Record<string, any>;
-    static deepCopy<T = object, P = object>(obj: T, options?: DeepCopyOptions<P>): T;
-    static deepMerge(target: Record<string, any>, source: Record<string, any>): Record<string, any>;
-    private static isObject;
-    private static handleProp;
-    static getProperties(obj: object): string[];
-    static getGetters(obj: any): string[];
-    static getPropertyByPath(value: any, path: string): any | undefined;
-}
-export {};

package/lib/utils/route.util.d.ts

@@ -1,37 +0,0 @@
-import { MenuItem } from 'primeng/api';
-import { MngMenuItem } from '../models';
-export declare class RouteUtil {
-    static removeEmptyPathSegments(path: Array<string>): string[];
-    static appendPathToBasePath(basePath: Array<string>, path: Array<string>): string[];
-    static doesUrlMatchRouterLink(link: Array<string> | string, url: Array<string> | string): boolean;
-    static adjustMenuLazyChildrenRouterLinks(rootMenuItem: MenuItem, lazyChildren: Array<MngMenuItem>): {
-        index?: number | undefined;
-        key?: string | undefined;
-        id?: string | undefined;
-        positionIndex?: number | undefined;
-        label?: string | undefined;
-        icon?: string | undefined;
-        items?: MngMenuItem[] | undefined;
-        guards?: any[] | undefined;
-        permissions?: import("@mediusinc/mng-commons").APermissions | undefined;
-        separator?: boolean | undefined;
-        className?: string | undefined;
-        badge?: string | undefined;
-        badgeClassName?: string | undefined;
-        visible?: boolean | undefined;
-        disabled?: boolean | undefined;
-        routerLink?: string | string[] | null | undefined;
-        href?: string | undefined;
-        target?: string | undefined;
-        queryParams?: {
-            [k: string]: any;
-        } | undefined;
-        fragment?: string | undefined;
-        queryParamsHandling?: import("@angular/router").QueryParamsHandling | undefined;
-        preserveFragment?: boolean | undefined;
-        skipLocationChange?: boolean | undefined;
-        replaceUrl?: boolean | undefined;
-        updated?: boolean | undefined;
-        lazyChildren?: boolean | undefined;
-    }[];
-}

package/lib/utils/tableview.util.d.ts

@@ -1,53 +0,0 @@
-import { ColumnDescriptor } from '../descriptors/table';
-import { ColumnDisplayTypeEnum, ColumnTypeEnum, FieldInputTypeEnum } from '../descriptors/types';
-import { ClassAttributeDef } from '../models';
-import { TableviewAttributeDef } from '../models/tableview-attr.model';
-import { ClassType } from '../types';
-export declare class TableviewUtil {
-    private static _dateRegex;
-    private static _dateTimeRegex;
-    /**
-     * returns attributes from class type and extends to typed def with column and field enum type
-     * @param type class type
-     */
-    static getAttributeDefMap<T>(type: ClassType<T>): TableviewAttributeDef[];
-    /**
-     * expands AttributeDef to TableviewAttributeDef with defined input and column enum type
-     * @param attributes open api specification model
-     */
-    static expandAttributeDefWithTableviewTypes(attributes?: Array<ClassAttributeDef> | null): TableviewAttributeDef[];
-    /**
-     * converts column to number or date on value based
-     * @param column column to be transformed
-     * @param value value to check if applicable
-     */
-    static stringColumnConverter(column: ColumnDescriptor<any, any>, value: any): ColumnDescriptor<any, any>;
-    /**
-     * converts string type to column type enum, default is string
-     * @param propertyType
-     */
-    static toColumnType(propertyType: string): ColumnTypeEnum;
-    static toColumnDisplayType(columnType: ColumnTypeEnum, propertyType: string): ColumnDisplayTypeEnum;
-    /**
-     * converts string type to type enum, default is text
-     * @param property
-     */
-    static toFieldInputType(property: string): FieldInputTypeEnum;
-    /**
-     * convert column type to equivalent field input type
-     * @param type column type
-     * @param displayType column display type
-     */
-    static toFieldInputTypeFromColumnType(type: ColumnTypeEnum, displayType?: ColumnDisplayTypeEnum): FieldInputTypeEnum;
-    /**
-     * generates table layout preferences key used when saving preferences to localstorage
-     * @param typeName string, required
-     * @param url string, required
-     * @param trackProperty string, not required
-     */
-    static generateTableLayoutPrefsKey(typeName: string, url: string, trackProperty?: string): string;
-    /**
-     * Flatten an object of unknown type, used for generating fields and columns in dynamic tableviews
-     */
-    static flattenObject(objectModel: any): string[];
-}

package/lib/validators/field.validator.d.ts

@@ -1,3 +0,0 @@
-import { MngFieldValidator } from '../types';
-export declare const minDateValidator: (min: Date) => MngFieldValidator;
-export declare const maxDateValidator: (max: Date) => MngFieldValidator;

package/lib/validators/index.d.ts

@@ -1 +0,0 @@
-export * from './field.validator';

package/openapi/angular/README.mustache

@@ -1,226 +0,0 @@
-## {{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/angular/api.module.mustache

@@ -1,39 +0,0 @@
-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/angular/api.service.mustache

@@ -1,253 +0,0 @@
-{{>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}}