@devlearning/swagger-generator 1.0.13 → 1.0.16

package/dist/src/generator.js

@@ -1,425 +0,0 @@
-import { ApiNextJsWriter } from './generators-writers/nextjs/api-nextjs-writer.js';
-import { ApiAngularWriter } from './generators-writers/angular/api-angular-writer.js';
-import { SingleBar, Presets } from 'cli-progress';
-import { ModelNextJsWriter } from './generators-writers/nextjs/model-nextjs-writer.js';
-import { ModelAngularWriter } from './generators-writers/angular/model-angular-writer.js';
-import pkg from '../package.json' assert { type: 'json' };
-const contentTypeApplicationJson = 'application/json';
-const contentTypeMultipartFormData = 'multipart/form-data';
-export class Generator {
-    _swagger;
-    _outputDirectory;
-    _outputFormat;
-    _dateLibrary;
-    _apis = [];
-    _models = [];
-    _barApis = new SingleBar({
-        format: '{bar} {percentage}% | {message} {value}/{total} Elapsed: {duration_formatted}',
-        barCompleteChar: '\u2588',
-        barIncompleteChar: '\u2591',
-        hideCursor: true,
-        barsize: 20,
-    }, Presets.shades_classic);
-    _barModels = new SingleBar({
-        format: '{bar} {percentage}% | {message} {value}/{total} Elapsed: {duration_formatted}',
-        barCompleteChar: '\u2588',
-        barIncompleteChar: '\u2591',
-        hideCursor: true,
-        barsize: 20,
-    }, Presets.shades_classic);
-    constructor(swagger, outputDirectory, outputFormat, dateLibrary) {
-        this._swagger = swagger;
-        this._outputDirectory = outputDirectory;
-        this._outputFormat = outputFormat;
-        this._dateLibrary = dateLibrary;
-    }
-    generate() {
-        console.info(`%c[Swagger API Generator] Version ${pkg.version}`, 'color: #4CAF50; font-weight: bold;');
-        console.info('%c[Swagger API Generator] %cStarting to parse Swagger JSON file...', 'color: #4CAF50; font-weight: bold;', 'color: #2196F3;');
-        this.computeApi();
-        this.generateApi();
-        this.computeModel();
-        this.generateModel();
-        console.info('%c[Swagger Generator] %cSwagger file generated successfully!', 'color: #4CAF50; font-weight: bold;', 'color: #00C853;');
-    }
-    computeApi() {
-        this._barApis.start(Object.getOwnPropertyNames(this._swagger.paths).length, 0);
-        for (let index = 0; index < Object.getOwnPropertyNames(this._swagger.paths).length; index++) {
-            const apiName = Object.getOwnPropertyNames(this._swagger.paths)[index];
-            this._barApis.update(index, { message: `Apis parsing... ${apiName}` });
-            const apiSwaggerMethodKey = this._swagger.paths[apiName];
-            const apiMethod = Object.getOwnPropertyNames(apiSwaggerMethodKey)[0];
-            const apiSwaggerMethod = apiSwaggerMethodKey[apiMethod];
-            // console.debug(`\tAPI - ${apiName} - ${apiMethod}`);
-            let apiDto = {
-                name: apiName,
-                url: apiName.replace('{version}', '1'),
-                method: apiMethod,
-                parameters: this.computeParameters(apiName, apiSwaggerMethod),
-                returnType: this.computeReturnType(apiSwaggerMethod),
-                swaggerMethodKey: apiSwaggerMethodKey,
-                swaggerMethod: apiSwaggerMethod,
-                haveRequest: apiSwaggerMethod.requestBody != null,
-                isMultiPart: apiSwaggerMethod.requestBody != null && apiSwaggerMethod.requestBody.content[contentTypeMultipartFormData] != null,
-            };
-            this._apis.push(apiDto);
-        }
-    }
-    computeModel() {
-        this._barModels.start(Object.getOwnPropertyNames(this._swagger.paths).length, 0);
-        let usedTypes = [];
-        let usedMultiPart = [];
-        for (let index = 0; index < Object.getOwnPropertyNames(this._swagger.paths).length; index++) {
-            const apiName = Object.getOwnPropertyNames(this._swagger.paths)[index];
-            const apiSwaggerMethodKey = this._swagger.paths[apiName];
-            const apiMethod = Object.getOwnPropertyNames(apiSwaggerMethodKey)[0];
-            const apiSwaggerMethod = apiSwaggerMethodKey[apiMethod];
-            // if (apiName == "/api/v{version}/TicketFile/Create") {
-            //   debugger
-            // }
-            let parametersRefType = apiSwaggerMethod.parameters?.filter(x => x.in == 'query' && x.schema?.$ref != null).map(x => x.schema.$ref.replace('#/components/schemas/', ''));
-            if (parametersRefType) {
-                usedTypes = usedTypes.concat(parametersRefType);
-                this._barModels.update(index, { message: `Models parsing... ${usedTypes}` });
-                if (apiSwaggerMethod.responses[200].content[contentTypeApplicationJson]?.schema.$ref != null) {
-                    usedTypes.push(apiSwaggerMethod.responses[200].content[contentTypeApplicationJson].schema.$ref.replace('#/components/schemas/', ''));
-                }
-                if (apiSwaggerMethod.requestBody?.content[contentTypeApplicationJson]?.schema?.$ref) {
-                    usedTypes.push(apiSwaggerMethod.requestBody?.content[contentTypeApplicationJson]?.schema?.$ref.replace('#/components/schemas/', ''));
-                }
-                if (apiSwaggerMethod.requestBody?.content[contentTypeMultipartFormData]?.schema != null) {
-                    usedMultiPart.push(apiName);
-                }
-            }
-        }
-        this.retrieveNestedObjects(usedTypes);
-        usedTypes = [...new Set(usedTypes.map(item => item))]; // [ 'A', 'B']
-        let models = ``;
-        if (this._swagger.components != null
-            && this._swagger.components != undefined
-            && this._swagger.components.schemas != null
-            && this._swagger.components.schemas != undefined) {
-            for (let index = 0; index < Object.getOwnPropertyNames(this._swagger.components.schemas).length; index++) {
-                const modelName = Object.getOwnPropertyNames(this._swagger.components.schemas)[index];
-                if (usedTypes.indexOf(modelName) < 0) {
-                    // console.debug(`\tModel SKIP - ${modelName}`);
-                    continue;
-                }
-                ;
-                const swaggerComponent = this._swagger.components.schemas[modelName];
-                // console.debug(`\tModel - ${modelName}`);
-                this._models.push({
-                    modelType: swaggerComponent.type == 'integer' ? 'enum' : 'class',
-                    name: modelName,
-                    properties: (swaggerComponent.type == 'object') ? this.retrieveComponentProperties(swaggerComponent) : [],
-                    enumValues: (swaggerComponent.type == 'integer') ? this.retrieveEnumValues(modelName, swaggerComponent) : [],
-                });
-            }
-        }
-        usedMultiPart.forEach(apiName => {
-            const swaggerMethod = this._swagger.paths[apiName];
-            const method = Object.getOwnPropertyNames(swaggerMethod)[0];
-            const swaggerMethodInfo = swaggerMethod[method];
-            this._models.push({
-                modelType: 'class',
-                name: this.getApiNameNormalized(apiName),
-                properties: this.retrieveComponentProperties(swaggerMethodInfo.requestBody.content[contentTypeMultipartFormData].schema),
-                enumValues: [],
-            });
-        });
-    }
-    generateApi() {
-        this._barApis.update(this._apis.length, { message: `Api generating...` });
-        if (this._outputFormat == 'angular') {
-            const apiWriter = new ApiAngularWriter(this._outputDirectory);
-            apiWriter.write(this._apis);
-        }
-        else if (this._outputFormat == 'next') {
-            const apiWriter = new ApiNextJsWriter(this._outputDirectory);
-            apiWriter.write(this._apis);
-        }
-        this._barApis.update(this._apis.length, { message: `Api gerated` });
-        this._barApis.stop();
-    }
-    generateModel() {
-        this._barModels.update(this._apis.length, { message: `Model generation...` });
-        if (this._outputFormat == 'angular') {
-            const apiWriter = new ModelAngularWriter(this._outputDirectory);
-            apiWriter.write(this._models);
-        }
-        else if (this._outputFormat == 'next') {
-            const apiWriter = new ModelNextJsWriter(this._outputDirectory);
-            apiWriter.write(this._models);
-        }
-        this._barModels.update(this._apis.length, { message: `Model generated` });
-        this._barModels.stop();
-    }
-    computeParameters(apiName, swaggerMethod) {
-        if (!apiName)
-            return [];
-        if (!swaggerMethod || swaggerMethod == null)
-            return [];
-        let parameters = [];
-        if (swaggerMethod.requestBody != null && swaggerMethod.requestBody.content[contentTypeMultipartFormData] != null) {
-            var modelName = this.getApiNameNormalized(apiName);
-            parameters.push({
-                name: 'request',
-                typeName: modelName,
-                nullable: false,
-                isQuery: false,
-                isEnum: false,
-                isNativeType: false,
-            });
-        }
-        else {
-            if (swaggerMethod.requestBody != null) {
-                parameters.push({
-                    name: 'request',
-                    typeName: swaggerMethod.requestBody.content[contentTypeApplicationJson].schema.$ref.replace('#/components/schemas/', ''),
-                    nullable: false,
-                    isQuery: false,
-                    isEnum: false,
-                    isNativeType: false,
-                });
-            }
-            else {
-                swaggerMethod.parameters?.filter(x => x.in == 'query').forEach(parameter => {
-                    if (parameter.schema.$ref != null) {
-                        parameters.push({
-                            name: this.toFirstLetterLowercase(parameter.name),
-                            typeName: parameter.schema.$ref.replace('#/components/schemas/', ''),
-                            nullable: !parameter.required,
-                            swaggerParameter: parameter,
-                            isQuery: true,
-                            isEnum: this.isEnum(parameter.schema.$ref),
-                            isNativeType: false,
-                        });
-                    }
-                    else {
-                        parameters.push({
-                            name: this.toFirstLetterLowercase(parameter.name),
-                            typeName: this.getNativeType(parameter.schema),
-                            nullable: !parameter.required,
-                            swaggerParameter: parameter,
-                            isQuery: true,
-                            isEnum: false,
-                            isNativeType: true,
-                        });
-                    }
-                });
-            }
-        }
-        return parameters;
-    }
-    computeReturnType(swaggerMethod) {
-        if (swaggerMethod.responses[200] == null) {
-            return {
-                typeName: 'void',
-                nullable: false,
-            };
-        }
-        try {
-            if (swaggerMethod.responses[200].content[contentTypeApplicationJson].schema.$ref != null)
-                return {
-                    typeName: this.getObjectName(swaggerMethod.responses[200]?.content[contentTypeApplicationJson].schema.$ref),
-                    nullable: false,
-                    isNativeType: false,
-                };
-        }
-        catch (error) {
-            const errorMessage = "\t\tAttenzione forse hai dimenticato IActionResult e non hai tipizzato il tipo restituito dal servizio";
-            console.error(`%c${errorMessage}`, 'color: red');
-            throw new Error(errorMessage);
-        }
-        if (swaggerMethod.responses[200]?.content[contentTypeApplicationJson].schema.type != null) {
-            let schema = swaggerMethod.responses[200]?.content[contentTypeApplicationJson].schema;
-            if (schema.type == 'array') {
-                if (schema.items.$ref != null) {
-                    return {
-                        typeName: `${this.getObjectName(schema.items.$ref)}[]`,
-                        nullable: false,
-                        isNativeType: false,
-                    };
-                }
-            }
-            else {
-                return {
-                    typeName: this.getNativeType(swaggerMethod.responses[200]?.content[contentTypeApplicationJson].schema),
-                    nullable: false,
-                    isNativeType: true,
-                };
-            }
-            // if (swaggerComponentProperty.items.$ref != null)
-            //   return `${this.getObjectName(swaggerComponentProperty.items.$ref)}[]`;
-        }
-        else {
-            return {
-                typeName: this.getNativeType(swaggerMethod.responses[200]?.content[contentTypeApplicationJson].schema),
-                nullable: false,
-                isNativeType: true,
-            };
-        }
-    }
-    retrieveType(swaggerComponentProperty) {
-        if (swaggerComponentProperty.$ref != null)
-            return {
-                typeName: swaggerComponentProperty.$ref.replace('#/components/schemas/', ''),
-                isNativeType: false,
-                nullable: false,
-            };
-        if (swaggerComponentProperty.type != null && swaggerComponentProperty.type == 'array')
-            if (swaggerComponentProperty.items.$ref != null)
-                return {
-                    typeName: `${this.getObjectName(swaggerComponentProperty.items.$ref)}[]`,
-                    isNativeType: false,
-                    nullable: false,
-                };
-            else
-                return {
-                    typeName: this.getNativeType(swaggerComponentProperty),
-                    isNativeType: false,
-                    nullable: true,
-                };
-        if (swaggerComponentProperty.type != null)
-            return {
-                typeName: this.getNativeType(swaggerComponentProperty),
-                isNativeType: false,
-                nullable: true,
-            };
-        if (swaggerComponentProperty.type == null)
-            return {
-                typeName: 'null',
-                isNativeType: false,
-                nullable: true,
-            };
-        console.error("unmanaged swaggerMethodInfo", swaggerComponentProperty);
-        throw new Error("unmanaged swaggerMethodInfo");
-    }
-    parametrizeObject(objectName) {
-        let component = this._swagger.components.schemas[this.getObjectName(objectName)];
-        if (component == null || component.properties == null)
-            return ``;
-        console.debug(component.properties);
-        return ``;
-    }
-    isEnum(objectName) {
-        let component = this._swagger.components.schemas[this.getObjectName(objectName)];
-        return component.enum != null;
-    }
-    isDate(schema) {
-        return schema.type == 'string' && schema.format == 'date-time';
-    }
-    getObjectName(ref) {
-        return ref.replace('#/components/schemas/', '');
-    }
-    retrieveComponentProperties(swaggerCopmponent) {
-        if (swaggerCopmponent.properties == null)
-            return [];
-        let properties = [];
-        for (let index = 0; index < Object.getOwnPropertyNames(swaggerCopmponent.properties).length; index++) {
-            const propertyName = Object.getOwnPropertyNames(swaggerCopmponent.properties)[index];
-            const type = this.retrieveType(swaggerCopmponent.properties[propertyName]);
-            properties.push({
-                ...type,
-                name: propertyName,
-                nullable: true,
-            });
-        }
-        return properties;
-    }
-    // retrieveSchemaProperties(schema: SwaggerSchema) {
-    //   if (schema.properties == null) return [];
-    //   let properties: PropertyDto[] = [];
-    //   for (let j = 0; j < Object.getOwnPropertyNames(schema.properties).length; j++) {
-    //     let propertyName = Object.getOwnPropertyNames(schema.properties)[j];
-    //     properties +=
-    //       `
-    // ${this.toFirstLetterLowercase(propertyName)}: ${this.retrieveType(schema.properties[propertyName])} | undefined;`
-    //   }
-    //   return properties;
-    // }
-    retrieveEnumValues(name, swaggerCopmponent) {
-        if (swaggerCopmponent.enum == null)
-            return [];
-        let values = [];
-        for (let index = 0; index < swaggerCopmponent.enum.length; index++) {
-            values.push({
-                name: swaggerCopmponent.enum[index].split('-')[0].trim(),
-                value: swaggerCopmponent.enum[index].split('-')[1].trim(),
-            });
-        }
-        return values;
-    }
-    retrieveNestedObjects(usedTypes) {
-        for (let i = 0; i < usedTypes.length; i++) {
-            const swaggerCopmponent = this._swagger.components.schemas[usedTypes[i]];
-            // const name = usedTypes[i]
-            // const modelName = <string>Object.getOwnPropertyNames(this._swagger.components.schemas)[name];
-            this.retrieveNestedObjectsRecursive(swaggerCopmponent, usedTypes);
-        }
-    }
-    retrieveNestedObjectsRecursive(swaggerComponent, usedTypes) {
-        if (!swaggerComponent.properties)
-            return;
-        for (let j = 0; j < Object.getOwnPropertyNames(swaggerComponent.properties).length; j++) {
-            const propertyName = Object.getOwnPropertyNames(swaggerComponent.properties)[j];
-            let nestedUsedType = '';
-            if (swaggerComponent.properties[propertyName].$ref != null) {
-                nestedUsedType = swaggerComponent.properties[propertyName].$ref.replace('#/components/schemas/', '');
-            }
-            else if (swaggerComponent.properties[propertyName].type == 'array' && swaggerComponent.properties[propertyName].items.$ref != null) {
-                nestedUsedType = swaggerComponent.properties[propertyName].items.$ref.replace('#/components/schemas/', '');
-            }
-            if (nestedUsedType != '' && usedTypes.findIndex(x => x == nestedUsedType) == -1) {
-                usedTypes.push(nestedUsedType);
-                let nested = this._swagger.components.schemas[nestedUsedType];
-                this.retrieveNestedObjectsRecursive(nested, usedTypes);
-            }
-        }
-    }
-    getNativeType(schema) {
-        let nativeType = 'n.d.';
-        if (schema.$ref != null) {
-            debugger;
-        }
-        else if (schema.type == 'array') {
-            nativeType = this.getNativeType(schema.items);
-            nativeType += '[]';
-        }
-        else {
-            if (schema.type == 'integer')
-                nativeType = 'number';
-            if (schema.type == 'string' && schema.format == null)
-                nativeType = 'string';
-            if (schema.type == 'string' && schema.format == 'date-time')
-                nativeType = this._dateLibrary == 'moment' ? 'moment.Moment' : 'Date';
-            if (schema.type == 'string' && schema.format == 'uuid')
-                nativeType = 'string';
-            if (schema.type == 'string' && schema.format == 'binary')
-                nativeType = 'File';
-            if (schema.type == 'number')
-                nativeType = 'number';
-            if (schema.type == 'boolean')
-                nativeType = 'boolean';
-            if (schema.type == 'object')
-                nativeType = 'any';
-        }
-        if (nativeType.indexOf('n.d') == -1) {
-            return nativeType;
-        }
-        else {
-            console.error("unmanaged schema type", schema);
-            throw new Error("unmanaged schema");
-        }
-    }
-    getApiNameNormalized(apiName) {
-        let normalizedApiName = apiName.replace('/api/v{version}/', '').replaceAll('/', '_');
-        if (normalizedApiName.charAt(0) == '_') {
-            normalizedApiName = normalizedApiName.slice(1);
-        }
-        return this.toFirstLetterLowercase(normalizedApiName);
-    }
-    toFirstLetterLowercase(value) {
-        return value.charAt(0).toLowerCase() + value.slice(1);
-    }
-}

package/dist/src/generators-writers/angular/api-angular-writer.js

@@ -1,113 +0,0 @@
-import fs from 'fs';
-import { API_POST, API_PRE } from './constants.js';
-import { Utils } from '../utils.js';
-export class ApiAngularWriter {
-    _outputDirectory;
-    constructor(_outputDirectory) {
-        this._outputDirectory = _outputDirectory;
-    }
-    write(apis) {
-        let apiString = '';
-        apis.forEach(api => {
-            apiString += this._apiString(api);
-        });
-        this._writeFile(apiString);
-    }
-    _apiString(api) {
-        let apiNameNormalized = Utils.getApiNameNormalized(api.name);
-        let parametersString = this._parameters(api);
-        let queryParametersPreparation = this._queryParametersPreparation(api);
-        let requestPreparation = this._requestPreparation(api);
-        let queryParameters = this._queryParameters(api);
-        let returnTypeString = this._returnType(api);
-        let haveRequest = api.haveRequest;
-        let method = api.method.toLowerCase();
-        let httpOptions = api.isMultiPart ? 'httpOptionsMultiPart' : 'httpOptions';
-        let apiString = `
-  public ${apiNameNormalized}(${parametersString}): Observable<${returnTypeString}> {
-    ${queryParametersPreparation}${requestPreparation}return this._http.${method}<${returnTypeString}>(\`\${this._baseUrl}${api.url}${queryParameters}\`${haveRequest ? ', wrappedRequest' : ''}, ${httpOptions})
-      .pipe(
-        map(x => this._handleResponse(x)),
-        catchError((err, obs) => this._handleError(err, <Observable<any>>obs))
-      );
-  }
-`;
-        return apiString;
-    }
-    _parameters(api) {
-        let parametersString = '';
-        api.parameters.forEach(parameter => {
-            const prefixType = parameter.isEnum || !parameter.isNativeType ? 'Models.' : '';
-            parametersString += `${parameter.name}${parameter.nullable ? '?' : ''}: ${prefixType}${parameter.typeName}, `;
-        });
-        if (api.parameters.length > 0)
-            parametersString = parametersString.substring(0, parametersString.length - 2);
-        return parametersString;
-    }
-    _returnType(api) {
-        const prefixType = !api.returnType?.isNativeType ? 'Models.' : '';
-        return api.returnType ? `${prefixType}${api.returnType.typeName}` : 'any';
-    }
-    _queryParametersPreparation(api) {
-        let queryParametersPreparation = '';
-        api.parameters.forEach(parameter => {
-            if (parameter.isQuery) {
-                queryParametersPreparation += this._queryParametersPreparationStatement(parameter);
-            }
-        });
-        return queryParametersPreparation;
-    }
-    _queryParametersPreparationStatement(parameter) {
-        if (parameter.nullable) {
-            if (Utils.isDate(parameter.swaggerParameter?.schema)) {
-                return `let ${parameter.name}Param: string = ${parameter.name} != null && ${parameter.name} != undefined && ${parameter.name}.isValid() ? encodeURIComponent(this._momentToString(${parameter.name})) : '';
-      `;
-            }
-            else {
-                return `let ${parameter.name}Param: string = ${parameter.name} != null && ${parameter.name} != undefined ? encodeURIComponent('' + ${parameter.name}) : '';
-      `;
-            }
-        }
-        else {
-            if (Utils.isDate(parameter.swaggerParameter?.schema)) {
-                return `let ${parameter.name}Param: string = encodeURIComponent(this._momentToString(${parameter.name}));
-      `;
-            }
-            else {
-                return `let ${parameter.name}Param: string = encodeURIComponent('' + ${parameter.name});
-      `;
-            }
-        }
-    }
-    _queryParameters(api) {
-        let queryParameters = '';
-        api.parameters.forEach(parameter => {
-            if (parameter.isQuery) {
-                queryParameters += this._queryParametersStatement(parameter);
-            }
-        });
-        if (queryParameters.length > 0) {
-            queryParameters = '?' + queryParameters.substring(0, queryParameters.length - 1);
-        }
-        return queryParameters;
-    }
-    _queryParametersStatement(parameter) {
-        if (parameter.swaggerParameter == null)
-            return '';
-        if (!parameter.isQuery)
-            return '';
-        return `${parameter.name}=\${${parameter.name}Param}&`;
-    }
-    _requestPreparation(api) {
-        if (!api.haveRequest) {
-            return '';
-        }
-        return `let wrappedRequest = this._handleRequest(request);
-    `;
-    }
-    _writeFile(apis) {
-        fs.writeFileSync(this._outputDirectory + "/api.autogenerated.ts", `${API_PRE}
-${apis}
-${API_POST}`, { flag: 'w' });
-    }
-}

package/dist/src/generators-writers/angular/constants.js

@@ -1,28 +0,0 @@
-export const API_PRE = `import { HttpClient } from '@angular/common/http';
-import { Observable, catchError, map } from 'rxjs';
-import * as Models from './model.autogenerated';
-import { HttpHeaders } from "@angular/common/http";
-
-export const httpOptions = {
-  headers: new HttpHeaders({ 'Content-Type': 'application/json' }),
-};
-
-export const httpOptionsMultipart = {};
-
-export abstract class ApiAutogeneratedService {
-  constructor(
-    public _http: HttpClient,
-    public _baseUrl: string,
-  ) { }
-
-  protected abstract _momentToString(moment: moment.Moment): string;
-  protected abstract _handleRequest<T>(request: T): T;
-  protected abstract _handleMultipart<T>(request: T): FormData;
-  protected abstract _handleResponse<T>(response: T): T;
-  protected abstract _handleError(error: any, obs: any): Observable<never>;
-`;
-export const API_POST = `}`;
-export const MODEL_PRE = `import * as moment from 'moment';
-  `;
-export const MODEL_POST = `
-`;

package/dist/src/generators-writers/angular/model-angular-writer.js

@@ -1,42 +0,0 @@
-import fs from 'fs';
-import { MODEL_POST, MODEL_PRE } from './constants.js';
-export class ModelAngularWriter {
-    _outputDirectory;
-    constructor(_outputDirectory) {
-        this._outputDirectory = _outputDirectory;
-    }
-    write(models) {
-        let modelString = '';
-        models.forEach(model => {
-            modelString += this._modelString(model);
-        });
-        this._writeFile(modelString);
-    }
-    _modelString(model) {
-        let modelString = `
-export ${model.modelType} ${model.name} {
-${this._properties(model)}${this._enumValues(model)}
-}
-`;
-        return modelString;
-    }
-    _properties(model) {
-        let propertiesString = '';
-        model.properties.forEach(property => {
-            propertiesString += `  ${property.name}${property.nullable ? '?' : ''}: ${property.typeName};\n`;
-        });
-        return propertiesString.trimEnd();
-    }
-    _enumValues(model) {
-        let enumValuesString = '';
-        model.enumValues.forEach(enumValue => {
-            enumValuesString += `  ${enumValue.name} = ${enumValue.value},\n`;
-        });
-        return enumValuesString.trimEnd();
-    }
-    _writeFile(models) {
-        fs.writeFileSync(this._outputDirectory + "/model.autogenerated.ts", `${MODEL_PRE}
-  ${models}
-  ${MODEL_POST}`, { flag: 'w' });
-    }
-}