@mediusinc/mng-commons 4.0.0-rc.1 → 4.0.0-rc.3

package/openapi/angular/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}}

package/openapi/angular/apiInterface.mustache

@@ -0,0 +1,47 @@
+{{>licenseInfo}}
+
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/ban-types */
+
+import { Observable } from 'rxjs';
+
+{{#imports}}
+import { {{classname}} } from '../model/models';
+{{/imports}}
+
+{{#operations}}
+
+{{#useSingleRequestParameter}}
+{{#operation}}
+{{#allParams.0}}
+export interface {{#prefixParameterInterfaces}}{{classname}}{{/prefixParameterInterfaces}}{{operationIdCamelCase}}RequestParams {
+{{#allParams}}
+    {{paramName}}{{^required}}?{{/required}}: {{{dataType}}}{{#isNullable}} | null{{/isNullable}};
+{{/allParams}}
+}
+
+{{/allParams.0}}
+{{/operation}}
+{{/useSingleRequestParameter}}
+
+{{#description}}
+    /**
+    * {{&description}}
+    */
+{{/description}}
+export interface {{classname}}Interface {
+{{#operation}}
+    /**{{#summary}}
+     * {{.}}{{/summary}}{{#notes}}
+     * {{.}}{{/notes}}
+     {{^useSingleRequestParameter}}
+     {{#allParams}}* @param {{paramName}} {{description}}
+     {{/allParams}}{{/useSingleRequestParameter}}{{#useSingleRequestParameter}}{{#allParams.0}}* @param requestParameters
+     {{/allParams.0}}
+     * @param extraParams  Extra HTTP Request Parameters to be sent with the request.{{/useSingleRequestParameter}}{{#isDeprecated}}
+     * @deprecated{{/isDeprecated}}
+     */
+    {{nickname}}({{^useSingleRequestParameter}}{{#allParams}}{{paramName}}{{^required}}?{{/required}}: {{{dataType}}}, {{/allParams}}{{/useSingleRequestParameter}}{{#useSingleRequestParameter}}{{#allParams.0}}requestParameters: {{#prefixParameterInterfaces}}{{classname}}{{/prefixParameterInterfaces}}{{operationIdCamelCase}}RequestParams, {{/allParams.0}}{{/useSingleRequestParameter}}extraParams?: any): Observable<{{{returnType}}}{{^returnType}}{}{{/returnType}}>;
+
+{{/operation}}
+}
+{{/operations}}

package/openapi/angular/apis.mustache

@@ -0,0 +1,12 @@
+{{#apiInfo}}
+{{#apis}}
+{{#operations}}
+export * from './{{ classFilename }}';
+import { {{ classname }} } from './{{ classFilename }}';
+{{/operations}}
+{{#withInterfaces}}
+export * from './{{ classFilename }}Interface';
+{{/withInterfaces}}
+{{/apis}}
+export const APIS = [{{#apis}}{{#operations}}{{ classname }}{{/operations}}{{^-last}}, {{/-last}}{{/apis}}];
+{{/apiInfo}}

package/openapi/angular/configuration.mustache

@@ -0,0 +1,128 @@
+import {Injectable} from '@angular/core';
+import {HttpParameterCodec} from '@angular/common/http';
+import {Param} from './param';
+
+export interface {{configurationParametersInterfaceName}} {
+    basePath?: string;
+    withCredentials?: boolean;
+    /**
+     * Takes care of encoding query- and form-parameters.
+     */
+    encoder?: HttpParameterCodec;
+    /**
+     * Override the default method for encoding path parameters in various
+     * <a href="https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#style-values">styles</a>.
+     * <p>
+     * See {@link README.md} for more details
+     * </p>
+     */
+    encodeParam?: (param: Param) => string;
+}
+
+{{#isProvidedInNone}}
+@Injectable()
+{{/isProvidedInNone}}
+{{^isProvidedInNone}}
+@Injectable({
+    providedIn: '{{providedIn}}'
+})
+{{/isProvidedInNone}}
+export class {{configurationClassName}} {
+    basePath?: string;
+    withCredentials?: boolean;
+    /**
+     * Takes care of encoding query- and form-parameters.
+     */
+    encoder?: HttpParameterCodec;
+    /**
+     * Encoding of various path parameter
+     * <a href="https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#style-values">styles</a>.
+     * <p>
+     * See {@link README.md} for more details
+     * </p>
+     */
+    encodeParam: (param: Param) => string = param => this.defaultEncodeParam(param);
+
+    public init(config: {{configurationParametersInterfaceName}} | string = {}) {
+        if (typeof config === 'string') {
+            this.basePath = config;
+        } else {
+            this.basePath = config.basePath;
+            this.withCredentials = config.withCredentials;
+            this.encoder = config.encoder;
+            if (config.encodeParam) {
+                this.encodeParam = config.encodeParam;
+            }
+        }
+    }
+
+    /**
+     * Select the correct content-type to use for a request.
+     * Uses {@link {{configurationClassName}}#isJsonMime} to determine the correct content-type.
+     * If no content type is found return the first found type if the contentTypes is not empty
+     * @param contentTypes - the array of content types that are available for selection
+     * @returns the selected content-type or <code>undefined</code> if no selection could be made.
+     */
+    public selectHeaderContentType (contentTypes: string[]): string | undefined {
+        if (contentTypes.length === 0) {
+            return undefined;
+        }
+
+        const type = contentTypes.find((x: string) => this.isJsonMime(x));
+        if (type === undefined) {
+            return contentTypes[0];
+        }
+        return type;
+    }
+
+    /**
+     * Select the correct accept content-type to use for a request.
+     * Uses {@link {{configurationClassName}}#isJsonMime} to determine the correct accept content-type.
+     * If no content type is found return the first found type if the contentTypes is not empty
+     * @param accepts - the array of content types that are available for selection.
+     * @returns the selected content-type or <code>undefined</code> if no selection could be made.
+     */
+    public selectHeaderAccept(accepts: string[]): string | undefined {
+        if (accepts.length === 0) {
+            return undefined;
+        }
+
+        const type = accepts.find((x: string) => this.isJsonMime(x));
+        if (type === undefined) {
+            return accepts[0];
+        }
+        return type;
+    }
+
+    /**
+     * Check if the given MIME is a JSON MIME.
+     * JSON MIME examples:
+     *   application/json
+     *   application/json; charset=UTF8
+     *   APPLICATION/JSON
+     *   application/vnd.company+json
+     * @param mime - MIME (Multipurpose Internet Mail Extensions)
+     * @return True if the given MIME is JSON, false otherwise.
+     */
+    public isJsonMime(mime: string): boolean {
+        // eslint-disable-next-line no-control-regex
+        const jsonMime: RegExp = new RegExp('^(application\/json|[^;/ \t]+\/[^;/ \t]+[+]json)[ \t]*(;.*)?$', 'i');
+        return mime !== null && (jsonMime.test(mime) || mime.toLowerCase() === 'application/json-patch+json');
+    }
+
+    private defaultEncodeParam(param: Param): string {
+        // This implementation exists as fallback for missing configuration
+        // and for backwards compatibility to older typescript-angular generator versions.
+        // It only works for the 'simple' parameter style.
+        // Date-handling only works for the 'date-time' format.
+        // All other styles and Date-formats are probably handled incorrectly.
+        //
+        // But: if that's all you need (i.e.: the most common use-case): no need for customization!
+
+        const value = param.dataFormat === 'date-time' && param.value instanceof Date
+            ? (param.value as Date).toISOString()
+            : param.value;
+
+        return encodeURIComponent(String(value));
+    }
+}

package/openapi/angular/custom/base-api.service.mustache

@@ -0,0 +1,14 @@
+/* eslint-disable */
+
+import {HttpClient, HttpHeaders, HttpParameterCodec} from '@angular/common/http';
+import {inject} from '@angular/core';
+
+import { {{configurationClassName}} } from '../configuration';
+import {CustomHttpParameterCodec} from '../encoder';
+
+export class BaseApiService {
+    protected readonly httpClient = inject(HttpClient);
+    protected readonly configuration = inject({{configurationClassName}});
+    protected readonly encoder: HttpParameterCodec = this.configuration?.encoder ?? new CustomHttpParameterCodec();
+    public readonly defaultHeaders = new HttpHeaders();
+}

package/openapi/angular/custom/helpers.mustache

@@ -0,0 +1,71 @@
+// eslint-disable
+
+import {HttpContext, HttpParams} from '@angular/common/http';
+
+import { {{configurationClassName}} } from './configuration';
+
+export function addToHttpParams(httpParams: HttpParams, value: unknown, key?: string): HttpParams {
+    if (typeof value === 'object' && !(value instanceof Date)) {
+        httpParams = addToHttpParamsRecursive(httpParams, value);
+    } else {
+        httpParams = addToHttpParamsRecursive(httpParams, value, key);
+    }
+    return httpParams;
+}
+
+function addToHttpParamsRecursive(httpParams: HttpParams, value?: unknown, key?: string): HttpParams {
+    if (value == null) {
+        return httpParams;
+    }
+
+    if (typeof value === 'object') {
+        if (Array.isArray(value)) {
+            value.forEach(elem => (httpParams = addToHttpParamsRecursive(httpParams, elem, key)));
+        } else if (value instanceof Date) {
+            if (key != null) {
+                httpParams = httpParams.append(key, (value as Date).toISOString().substring(0, 10));
+            } else {
+                throw Error('key may not be null if value is Date');
+            }
+        } else {
+            Object.keys(value).forEach(k => (httpParams = addToHttpParamsRecursive(httpParams, value[k as keyof object], key != null ? `${key}.${k}` : k)));
+        }
+    } else if (key != null) {
+        httpParams = httpParams.append(key, String(value));
+    } else {
+        throw Error('key may not be null if value is not object or array');
+    }
+    return httpParams;
+}
+
+export function selectHeaderAccept(producesAccepts: string[], options?: {httpHeaderAccept?: string; context?: HttpContext}, configuration?: {{configurationClassName}}) {
+    let accept: string | undefined = options?.httpHeaderAccept;
+    if (accept === undefined) {
+        // to determine the Accept header
+        accept = configuration?.selectHeaderAccept(producesAccepts);
+    }
+    return accept;
+}
+
+export function getResponseType(selectedAcceptHeader?: string, configuration?: {{configurationClassName}}): 'text' | 'json' | 'blob' {
+    if (selectedAcceptHeader) {
+        if (selectedAcceptHeader.startsWith('text')) {
+            return 'text';
+        } else if (configuration?.isJsonMime(selectedAcceptHeader)) {
+            return 'json';
+        } else {
+            return 'blob';
+        }
+    }
+    return 'json';
+}
+
+export function canConsumeForm(consumes: string[]): boolean {
+    const form = 'multipart/form-data';
+    for (const consume of consumes) {
+        if (form === consume) {
+            return true;
+        }
+    }
+    return false;
+}

package/openapi/angular/custom/modelSchema.mustache

@@ -0,0 +1,46 @@
+import {Schema} from '../schema';
+
+{{#models}}
+{{#model}}
+export const ${{name}}Schema: Schema = {
+    name: '{{name}}',
+    {{#isEnum}}
+        // enums not yet generated
+    {{/isEnum}}
+    {{^isEnum}}
+        {{#isAlias}}
+            // aliases not yet generated
+        {{/isAlias}}
+        {{^isAlias}}
+            {{#taggedUnions}}
+                // tagged unions not yet generated
+            {{/taggedUnions}}
+            {{^taggedUnions}}
+                {{#oneOf}}
+                    // one of not yet generated
+                {{/oneOf}}
+                {{^oneOf}}
+                    properties: {
+                    {{#vars}}
+                        {{name}}: {
+                            type: '{{#isEnum}}{{{datatypeWithEnum}}}{{/isEnum}}{{^isEnum}}{{#isDate}}date{{/isDate}}{{^isDate}}{{#isDateTime}}date-time{{/isDateTime}}{{^isDateTime}}{{{dataType}}}{{/isDateTime}}{{/isDate}}{{/isEnum}}',{{#isReadOnly}}
+                            isReadOnly: true,{{/isReadOnly}}{{#required}}
+                            required: true,{{/required}}{{#isNullable}}
+                            isNullable: true,{{/isNullable}}{{#minLength}}
+                            minLength: {{.}},{{/minLength}}{{#maxLength}}
+                            maxLength: {{.}},{{/maxLength}}{{#minimum}}
+                            minimum: {{.}},{{/minimum}}{{#maximum}}
+                            maximum: {{.}},{{/maximum}}{{#exclusiveMinimum}}
+                            exclusiveMinimum: true,{{/exclusiveMinimum}}{{#exclusiveMaximum}}
+                            exclusiveMaximum: true,{{/exclusiveMaximum}}{{#pattern}}
+                            pattern: '{{{.}}}'{{/pattern}}
+                        },
+                    {{/vars}}
+                    }
+                {{/oneOf}}
+            {{/taggedUnions}}
+        {{/isAlias}}
+    {{/isEnum}}
+};
+{{/model}}
+{{/models}}

package/openapi/angular/custom/schema.mustache

@@ -0,0 +1,18 @@
+export interface Schema {
+    name: string;
+    properties?: Record<string, SchemaProperty>;
+}
+
+export interface SchemaProperty {
+    type: string;
+    isReadOnly?: boolean;
+    required?: boolean;
+    isNullable?: boolean;
+    minLength?: boolean;
+    maxLength?: boolean;
+    minimum?: boolean;
+    maximum?: boolean;
+    exclusiveMinimum?: boolean;
+    exclusiveMaximum?: boolean;
+    pattern?: string;
+}

package/openapi/angular/encoder.mustache

@@ -0,0 +1,20 @@
+import { HttpParameterCodec } from '@angular/common/http';
+
+/**
+ * Custom HttpParameterCodec
+ * Workaround for https://github.com/angular/angular/issues/18261
+ */
+export class CustomHttpParameterCodec implements HttpParameterCodec {
+    encodeKey(k: string): string {
+        return encodeURIComponent(k);
+    }
+    encodeValue(v: string): string {
+        return encodeURIComponent(v);
+    }
+    decodeKey(k: string): string {
+        return decodeURIComponent(k);
+    }
+    decodeValue(v: string): string {
+        return decodeURIComponent(v);
+    }
+}

package/openapi/angular/git_push.sh.mustache

@@ -0,0 +1,57 @@
+#!/bin/sh
+# ref: https://help.github.com/articles/adding-an-existing-project-to-github-using-the-command-line/
+#
+# Usage example: /bin/sh ./git_push.sh wing328 openapi-petstore-perl "minor update" "gitlab.com"
+
+git_user_id=$1
+git_repo_id=$2
+release_note=$3
+git_host=$4
+
+if [ "$git_host" = "" ]; then
+    git_host="{{{gitHost}}}"
+    echo "[INFO] No command line input provided. Set \$git_host to $git_host"
+fi
+
+if [ "$git_user_id" = "" ]; then
+    git_user_id="{{{gitUserId}}}"
+    echo "[INFO] No command line input provided. Set \$git_user_id to $git_user_id"
+fi
+
+if [ "$git_repo_id" = "" ]; then
+    git_repo_id="{{{gitRepoId}}}"
+    echo "[INFO] No command line input provided. Set \$git_repo_id to $git_repo_id"
+fi
+
+if [ "$release_note" = "" ]; then
+    release_note="{{{releaseNote}}}"
+    echo "[INFO] No command line input provided. Set \$release_note to $release_note"
+fi
+
+# Initialize the local directory as a Git repository
+git init
+
+# Adds the files in the local repository and stages them for commit.
+git add .
+
+# Commits the tracked changes and prepares them to be pushed to a remote repository.
+git commit -m "$release_note"
+
+# Sets the new remote
+git_remote=$(git remote)
+if [ "$git_remote" = "" ]; then # git remote not defined
+
+    if [ "$GIT_TOKEN" = "" ]; then
+        echo "[INFO] \$GIT_TOKEN (environment variable) is not set. Using the git credential in your environment."
+        git remote add origin https://${git_host}/${git_user_id}/${git_repo_id}.git
+    else
+        git remote add origin https://${git_user_id}:"${GIT_TOKEN}"@${git_host}/${git_user_id}/${git_repo_id}.git
+    fi
+
+fi
+
+git pull origin master
+
+# Pushes (Forces) the changes in the local repository up to the remote repository
+echo "Git pushing to https://${git_host}/${git_user_id}/${git_repo_id}.git"
+git push origin master 2>&1 | grep -v 'To https'