/// <summary>Initializes a new instance of the <see cref="ClientGeneratorBase{TOperationModel, TParameterModel, TResponseModel}"/> class.</summary>
/// <param name="document">The document.</param>
/// <param name="settings">The code generator settings.</param>
/// <param name="resolver">The type resolver.</param>
protected ClientGeneratorBase(OpenApiDocument document, CodeGeneratorSettingsBase settings, TypeResolverBase resolver)
{
_document = document;
Resolver = resolver;
settings.SchemaType = document.SchemaType; // enforce Swagger schema output
}
public ReturnTypeModel(JsonSchema4 parameter, TypeResolverBase resolver)
{
_parameter = parameter;
_resolver = resolver;
Type = _resolver.Resolve(_parameter.ActualTypeSchema, _parameter.IsNullable(SchemaType.JsonSchema), null);
}
public ReturnTypeModel(JsonSchema parameter, TypeResolverBase resolver)
{
this._parameter = parameter;
this._resolver = resolver;
this.Type = this._resolver.Resolve(this._parameter.ActualTypeSchema, this._parameter.IsNullable(SchemaType.JsonSchema), null);
}
/// <summary>Initializes a new instance of the <see cref="TypeScriptOperationModel" /> class.</summary>
/// <param name="operation">The operation.</param>
/// <param name="settings">The settings.</param>
/// <param name="generator">The generator.</param>
/// <param name="resolver">The resolver.</param>
public TypeScriptOperationModel(
SwaggerOperation operation,
SwaggerToTypeScriptClientGeneratorSettings settings,
SwaggerToTypeScriptClientGenerator generator,
TypeResolverBase resolver)
: base(null, operation, resolver, generator, settings)
{
_operation = operation;
_settings = settings;
_generator = generator;
var parameters = GetActualParameters();
if (settings.GenerateOptionalParameters)
{
parameters = parameters
.OrderBy(p => p.Position ?? 0)
.OrderBy(p => !p.IsRequired)
.ToList();
}
Parameters = parameters
.Select(parameter =>
new TypeScriptParameterModel(parameter.Name,
GetParameterVariableName(parameter, _operation.Parameters), ResolveParameterType(parameter),
parameter, parameters, _settings, _generator, resolver))
.ToList();
}
internal string GenerateFile <TGenerator>(SwaggerService service, TypeResolverBase <TGenerator> resolver)
where TGenerator : TypeGeneratorBase
{
var clients = string.Empty;
var operations = GetOperations(service, resolver);
var clientClasses = new List <string>();
if (BaseSettings.OperationNameGenerator.SupportsMultipleClients)
{
foreach (var controllerOperations in operations.GroupBy(o => BaseSettings.OperationNameGenerator.GetClientName(service, o.Path, o.HttpMethod, o.Operation)))
{
var controllerName = GetClassName(controllerOperations.Key);
clients += RenderClientCode(controllerName, controllerOperations.ToList()) + "\n\n";
clientClasses.Add(controllerName);
}
}
else
{
var controllerName = GetClassName(string.Empty);
clients = RenderClientCode(controllerName, operations);
clientClasses.Add(controllerName);
}
return(RenderFile(clients, clientClasses.ToArray())
.Replace("\r", string.Empty)
.Replace("\n\n\n\n", "\n\n")
.Replace("\n\n\n", "\n\n"));
}
/// <summary>Initializes a new instance of the <see cref="ClassTemplateModelBase" /> class.</summary>
/// <param name="resolver">The resolver.</param>
/// <param name="schema">The schema.</param>
/// <param name="rootObject">The root object.</param>
protected ClassTemplateModelBase(TypeResolverBase resolver, JsonSchema schema, object rootObject)
{
_schema = schema;
_rootObject = rootObject;
_resolver = resolver;
SchemaTitle = _schema?.Title;
}
public OperationModel(string name, SigSpecOperation operation, TypeResolverBase resolver)
{
_operation = operation;
Name = name;
ReturnType = operation.ReturnType != null ? new ReturnTypeModel(_operation.ReturnType, resolver) : null;
Parameters = operation.Parameters.Select(o => new ParameterModel(o.Key, o.Value, resolver));
}
/// <summary>Initializes a new instance of the <see cref="CSharpParameterModel" /> class.</summary>
/// <param name="parameterName">Name of the parameter.</param>
/// <param name="variableName">Name of the variable.</param>
/// <param name="typeName">The type name.</param>
/// <param name="parameter">The parameter.</param>
/// <param name="allParameters">All parameters.</param>
/// <param name="settings">The settings.</param>
/// <param name="generator">The client generator base.</param>
/// <param name="typeResolver">The type resolver.</param>
public CSharpParameterModel(
string parameterName,
string variableName,
string typeName,
OpenApiParameter parameter,
IList <OpenApiParameter> allParameters,
CodeGeneratorSettingsBase settings,
IClientGenerator generator,
TypeResolverBase typeResolver)
: base(parameterName, variableName, typeName, parameter, allParameters, settings, generator, typeResolver)
{
}
/// <summary>Initializes a new instance of the <see cref="TypeScriptParameterModel" /> class.</summary>
/// <param name="parameterName">Name of the parameter.</param>
/// <param name="variableName">Name of the variable.</param>
/// <param name="typeName">The type name.</param>
/// <param name="parameter">The parameter.</param>
/// <param name="allParameters">All parameters.</param>
/// <param name="settings">The settings.</param>
/// <param name="generator">The client generator base.</param>
/// <param name="typeResolver">The type resolver.</param>
public TypeScriptParameterModel(
string parameterName,
string variableName,
string typeName,
OpenApiParameter parameter,
IList <OpenApiParameter> allParameters,
TypeScriptClientGeneratorSettings settings,
TypeScriptClientGenerator generator,
TypeResolverBase typeResolver)
: base(parameterName, variableName, typeName, parameter, allParameters, settings.TypeScriptGeneratorSettings, generator, typeResolver)
{
_settings = settings;
}
/// <summary>Initializes a new instance of the <see cref="PropertyModelBase"/> class.</summary>
/// <param name="property">The property.</param>
/// <param name="classTemplateModel">The class template model.</param>
/// <param name="typeResolver">The type resolver.</param>
/// <param name="settings">The settings.</param>
protected PropertyModelBase(
JsonSchemaProperty property,
ClassTemplateModelBase classTemplateModel,
TypeResolverBase typeResolver,
CodeGeneratorSettingsBase settings)
{
_classTemplateModel = classTemplateModel;
_property = property;
_settings = settings;
_typeResolver = typeResolver;
PropertyName = _settings.PropertyNameGenerator.Generate(_property);
}
/// <summary>Initializes a new instance of the <see cref="ParameterModelBase" /> class.</summary>
/// <param name="parameterName">Name of the parameter.</param>
/// <param name="variableName">Name of the variable.</param>
/// <param name="typeName">The type name.</param>
/// <param name="parameter">The parameter.</param>
/// <param name="allParameters">All parameters.</param>
/// <param name="settings">The settings.</param>
/// <param name="generator">The client generator base.</param>
/// <param name="typeResolver">The type resolver.</param>
protected ParameterModelBase(string parameterName, string variableName, string typeName,
SwaggerParameter parameter, IList <SwaggerParameter> allParameters, CodeGeneratorSettingsBase settings,
IClientGenerator generator, TypeResolverBase typeResolver)
{
_allParameters = allParameters;
_parameter = parameter;
_settings = settings;
_generator = generator;
_typeResolver = typeResolver;
Type = typeName;
Name = parameterName;
VariableName = variableName;
}
/// <summary>Initializes a new instance of the <see cref="ResponseModelBase" /> class.</summary>
/// <param name="operationModel">The operation model.</param>
/// <param name="statusCode">The status code.</param>
/// <param name="response">The response.</param>
/// <param name="isPrimarySuccessResponse">Specifies whether this is the success response.</param>
/// <param name="exceptionSchema">The exception schema.</param>
/// <param name="resolver">The resolver.</param>
/// <param name="settings">The settings.</param>
/// <param name="generator">The client generator.</param>
protected ResponseModelBase(IOperationModel operationModel,
string statusCode, SwaggerResponse response, bool isPrimarySuccessResponse,
JsonSchema4 exceptionSchema, TypeResolverBase resolver, CodeGeneratorSettingsBase settings, IClientGenerator generator)
{
_response = response;
_exceptionSchema = exceptionSchema;
_generator = generator;
_settings = settings;
_resolver = resolver;
_operationModel = operationModel;
IsPrimarySuccessResponse = isPrimarySuccessResponse;
StatusCode = statusCode;
}
private string ResolveParameterType <TGenerator>(SwaggerParameter parameter, TypeResolverBase <TGenerator> resolver)
where TGenerator : TypeGeneratorBase
{
var schema = parameter.ActualSchema;
if (parameter.CollectionFormat == SwaggerParameterCollectionFormat.Multi)
{
schema = new JsonSchema4 {
Type = JsonObjectType.Array, Item = schema
}
}
;
return(resolver.Resolve(schema, parameter.IsRequired == false || parameter.IsNullable(BaseSettings.CodeGeneratorSettings.PropertyNullHandling), parameter.Name));
}
private string ResolveParameterType <TGenerator>(SwaggerParameter parameter, TypeResolverBase <TGenerator> resolver)
where TGenerator : TypeGeneratorBase
{
var schema = parameter.ActualParameterSchema;
if (parameter.CollectionFormat == SwaggerParameterCollectionFormat.Multi)
{
schema = new JsonSchema4 {
Type = JsonObjectType.Array, Item = schema
}
}
;
return(resolver.Resolve(schema, !parameter.IsRequired && parameter.IsNullable, parameter.Name));
}
private string ResolveParameterType <TGenerator>(SwaggerParameter parameter, TypeResolverBase <TGenerator> resolver)
where TGenerator : TypeGeneratorBase
{
var schema = parameter.ActualSchema;
if (parameter.CollectionFormat == SwaggerParameterCollectionFormat.Multi && !schema.Type.HasFlag(JsonObjectType.Array))
{
schema = new JsonSchema4 {
Type = JsonObjectType.Array, Item = schema
}
}
;
var typeNameHint = ConversionUtilities.ConvertToUpperCamelCase(parameter.Name);
return(resolver.Resolve(schema, parameter.IsRequired == false || parameter.IsNullable(BaseSettings.CodeGeneratorSettings.NullHandling), typeNameHint));
}
/// <summary>Initializes a new instance of the <see cref="ResponseModelBase" /> class.</summary>
/// <param name="operationModel">The operation model.</param>
/// <param name="operation">The operation.</param>
/// <param name="statusCode">The status code.</param>
/// <param name="response">The response.</param>
/// <param name="isPrimarySuccessResponse">Specifies whether this is the success response.</param>
/// <param name="exceptionSchema">The exception schema.</param>
/// <param name="resolver">The resolver.</param>
/// <param name="settings">The settings.</param>
/// <param name="generator">The client generator.</param>
protected ResponseModelBase(IOperationModel operationModel,
OpenApiOperation operation,
string statusCode, OpenApiResponse response, bool isPrimarySuccessResponse,
JsonSchema exceptionSchema, TypeResolverBase resolver, CodeGeneratorSettingsBase settings, IClientGenerator generator)
{
_response = response;
_operation = operation;
_exceptionSchema = exceptionSchema;
_generator = generator;
_settings = settings;
_resolver = resolver;
_operationModel = operationModel;
StatusCode = statusCode;
IsPrimarySuccessResponse = isPrimarySuccessResponse;
ActualResponseSchema = response.Schema?.ActualSchema;
}
/// <summary>Initializes a new instance of the <see cref="ParameterModelBase" /> class.</summary>
/// <param name="parameterName">Name of the parameter.</param>
/// <param name="variableName">Name of the variable.</param>
/// <param name="typeName">The type name.</param>
/// <param name="parameter">The parameter.</param>
/// <param name="allParameters">All parameters.</param>
/// <param name="settings">The settings.</param>
/// <param name="generator">The client generator base.</param>
/// <param name="typeResolver">The type resolver.</param>
protected ParameterModelBase(string parameterName, string variableName, string typeName,
SwaggerParameter parameter, IList <SwaggerParameter> allParameters, CodeGeneratorSettingsBase settings,
IClientGenerator generator, TypeResolverBase typeResolver)
{
_allParameters = allParameters;
_parameter = parameter;
_settings = settings;
_generator = generator;
_typeResolver = typeResolver;
Type = typeName;
Name = parameterName;
VariableName = variableName;
var propertyNameGenerator = settings?.PropertyNameGenerator ?? throw new InvalidOperationException("PropertyNameGenerator not set.");
_properties = _parameter.ActualSchema.ActualProperties
.Select(p => new PropertyModel(p.Key, p.Value, propertyNameGenerator.Generate(p.Value)))
.ToList();
}
/// <summary>Initializes a new instance of the <see cref="OperationModelBase{TParameterModel, TResponseModel}"/> class.</summary>
/// <param name="exceptionSchema">The exception schema.</param>
/// <param name="operation">The operation.</param>
/// <param name="resolver">The resolver.</param>
/// <param name="generator">The generator.</param>
/// <param name="settings">The settings.</param>
protected OperationModelBase(JsonSchema exceptionSchema, OpenApiOperation operation, TypeResolverBase resolver, IClientGenerator generator, ClientGeneratorBaseSettings settings)
{
_operation = operation;
_resolver = resolver;
_generator = generator;
_settings = settings;
var responses = _operation.ActualResponses
.Select(response => CreateResponseModel(operation, response.Key, response.Value, exceptionSchema, generator, resolver, settings))
.ToList();
var defaultResponse = responses.SingleOrDefault(r => r.StatusCode == "default");
if (defaultResponse != null)
{
responses.Remove(defaultResponse);
}
Responses = responses;
DefaultResponse = defaultResponse;
}
internal string GenerateFile <TGenerator>(SwaggerService service, TypeResolverBase <TGenerator> resolver)
where TGenerator : TypeGeneratorBase
{
var operations = GetOperations(service, resolver);
var clients = string.Empty;
if (BaseSettings.OperationGenerationMode == OperationGenerationMode.MultipleClientsFromPathSegments)
{
foreach (var controllerOperations in operations.GroupBy(o => o.MvcControllerName))
{
clients += RenderClientCode(controllerOperations.Key, controllerOperations);
}
}
else
{
clients = RenderClientCode(string.Empty, operations);
}
return(RenderFile(clients)
.Replace("\r", string.Empty)
.Replace("\n\n\n\n", "\n\n")
.Replace("\n\n\n", "\n\n"));
}
internal List <OperationModel> GetOperations <TGenerator>(SwaggerService service, TypeResolverBase <TGenerator> resolver)
where TGenerator : TypeGeneratorBase
{
service.GenerateOperationIds();
var operations = service.Paths
.SelectMany(pair => pair.Value.Select(p => new { Path = pair.Key.Trim('/'), HttpMethod = p.Key, Operation = p.Value }))
.Select(tuple =>
{
var pathSegments = tuple.Path.Split('/').Where(p => !p.Contains("{")).Reverse().ToArray();
var mvcControllerName = pathSegments.Length >= 2 ? pathSegments[1] : "Unknown";
var mvcActionName = pathSegments.Length >= 1 ? pathSegments[0] : "Unknown";
var operation = tuple.Operation;
var responses = operation.Responses.Select(r => new ResponseModel
{
StatusCode = r.Key,
IsSuccess = HttpUtilities.IsSuccessStatusCode(r.Key),
Type = GetType(r.Value.Schema, "Response"),
TypeIsDate = GetType(r.Value.Schema, "Response") == "Date"
}).ToList();
var defaultResponse = responses.SingleOrDefault(r => r.StatusCode == "default");
if (defaultResponse != null)
{
responses.Remove(defaultResponse);
}
return(new OperationModel
{
Id = operation.OperationId,
Path = tuple.Path,
HttpMethodUpper = ConvertToUpperStartIdentifier(tuple.HttpMethod.ToString()),
HttpMethodLower = ConvertToLowerStartIdentifier(tuple.HttpMethod.ToString()),
IsGetOrDelete = tuple.HttpMethod == SwaggerOperationMethod.Get || tuple.HttpMethod == SwaggerOperationMethod.Delete,
Summary = RemoveLineBreaks(operation.Summary),
MvcActionName = mvcActionName,
MvcControllerName = mvcControllerName,
OperationNameLower =
ConvertToLowerStartIdentifier(BaseSettings.OperationGenerationMode == OperationGenerationMode.MultipleClientsFromPathSegments
? mvcActionName
: operation.OperationId),
OperationNameUpper =
ConvertToUpperStartIdentifier(BaseSettings.OperationGenerationMode == OperationGenerationMode.MultipleClientsFromPathSegments
? mvcActionName
: operation.OperationId),
ResultType = GetResultType(operation),
ResultDescription = GetResultDescription(operation),
ExceptionType = GetExceptionType(operation),
Responses = responses,
DefaultResponse = defaultResponse,
Parameters = operation.Parameters.Select(p =>
{
if (p.ActualSchema.Type == JsonObjectType.File)
{
p.ActualSchema.Type = JsonObjectType.String; // TODO: Implement File type handling
}
return new ParameterModel
{
Schema = p.ActualSchema,
Name = p.Name,
VariableNameLower = ConvertToLowerStartIdentifier(p.Name.Replace("-", "_")),
Kind = p.Kind,
IsOptional = !p.IsRequired,
Type = resolver.Resolve(p.ActualSchema, p.IsRequired, p.Name),
IsLast = operation.Parameters.LastOrDefault() == p,
Description = RemoveLineBreaks(p.Description)
};
}).ToList(),
});
}).ToList();
return(operations);
}
/// <summary>Initializes a new instance of the <see cref="CSharpResponseModel"/> class.</summary>
/// <param name="operationModel">The operation model.</param>
/// <param name="operation">The operation.</param>
/// <param name="statusCode">The status code.</param>
/// <param name="response">The response.</param>
/// <param name="isPrimarySuccessResponse">Specifies whether this is the success response.</param>
/// <param name="exceptionSchema">The exception schema.</param>
/// <param name="generator">The client generator.</param>
/// <param name="resolver">The resolver.</param>
/// <param name="settings">The settings.</param>
public CSharpResponseModel(IOperationModel operationModel, SwaggerOperation operation, string statusCode, SwaggerResponse response,
bool isPrimarySuccessResponse, JsonSchema4 exceptionSchema, IClientGenerator generator, TypeResolverBase resolver, CodeGeneratorSettingsBase settings)
: base(operationModel, operation, statusCode, response, isPrimarySuccessResponse, exceptionSchema, resolver, settings, generator)
{
}
/// <summary>Creates the response model.</summary>
/// <param name="operation">The operation.</param>
/// <param name="statusCode">The status code.</param>
/// <param name="response">The response.</param>
/// <param name="exceptionSchema">The exception schema.</param>
/// <param name="generator">The generator.</param>
/// <param name="resolver">The resolver.</param>
/// <param name="settings">The settings.</param>
/// <returns>The response model.</returns>
protected abstract TResponseModel CreateResponseModel(OpenApiOperation operation, string statusCode, OpenApiResponse response, JsonSchema exceptionSchema, IClientGenerator generator,
TypeResolverBase resolver, ClientGeneratorBaseSettings settings);
internal List <OperationModel> GetOperations <TGenerator>(SwaggerService service, TypeResolverBase <TGenerator> resolver)
where TGenerator : TypeGeneratorBase
{
service.GenerateOperationIds();
var operations = service.Paths
.SelectMany(pair => pair.Value.Select(p => new { Path = pair.Key.Trim('/'), HttpMethod = p.Key, Operation = p.Value }))
.Select(tuple =>
{
var operation = tuple.Operation;
var responses = operation.Responses.Select(response => new ResponseModel(response, this)).ToList();
var defaultResponse = responses.SingleOrDefault(r => r.StatusCode == "default");
if (defaultResponse != null)
{
responses.Remove(defaultResponse);
}
return(new OperationModel
{
Path = tuple.Path,
HttpMethod = tuple.HttpMethod,
Operation = tuple.Operation,
OperationName = BaseSettings.OperationNameGenerator.GetOperationName(service, tuple.Path, tuple.HttpMethod, tuple.Operation),
ResultType = GetResultType(operation),
HasResultType = HasResultType(operation),
ResultDescription = GetResultDescription(operation),
ExceptionType = GetExceptionType(operation),
HasFormParameters = operation.Parameters.Any(p => p.Kind == SwaggerParameterKind.FormData),
Responses = responses,
DefaultResponse = defaultResponse,
Parameters = operation.Parameters.Select(p =>
{
if (p.ActualSchema.Type == JsonObjectType.File)
{
p.ActualSchema.Type = JsonObjectType.String; // TODO: Implement File type handling
}
return new ParameterModel(ResolveParameterType(p, resolver), operation, p, BaseSettings.CodeGeneratorSettings);
}).ToList(),
});
}).ToList();
return(operations);
}
public HubModel(string path, SigSpecHub hub, TypeResolverBase resolver)
{
_path = path;
_hub = hub;
_resolver = resolver;
}
public DotvvmTypeScriptOperationModel(SwaggerOperation operation, SwaggerToTypeScriptClientGeneratorSettings settings, SwaggerToTypeScriptClientGenerator generator, TypeResolverBase resolver) : base(operation, settings, generator, resolver)
{
var parameters = operation.ActualParameters.ToList();
if (settings.GenerateOptionalParameters)
{
parameters = parameters.OrderBy(p => !p.IsRequired).ToList();
}
var newParameters = parameters.Select(parameter =>
new DotvvmTypeScriptParameterModel(parameter.Name, GetParameterVariableName(parameter, operation.Parameters),
ResolveParameterType(parameter), parameter, parameters,
settings,
generator,
this)
);
Parameters = new List <TypeScriptParameterModel>(newParameters);
}
/// <summary>Creates the response model.</summary>
/// <param name="statusCode">The status code.</param>
/// <param name="response">The response.</param>
/// <param name="exceptionSchema">The exception schema.</param>
/// <param name="generator">The generator.</param>
/// <param name="resolver">The resolver.</param>
/// <param name="settings">The settings.</param>
/// <returns>The response model.</returns>
protected abstract TResponseModel CreateResponseModel(string statusCode, SwaggerResponse response, JsonSchema4 exceptionSchema, IClientGenerator generator,
TypeResolverBase resolver, ClientGeneratorBaseSettings settings);
/// <summary>Gets the default value code.</summary>
/// <param name="schema">The schema.</param>
/// <param name="allowsNull">Specifies whether the default value assignment also allows null.</param>
/// <param name="targetType">The type of the target.</param>
/// <param name="typeNameHint">The type name hint to use when generating the type and the type name is missing.</param>
/// <param name="useSchemaDefault">if set to <c>true</c> uses the default value from the schema if available.</param>
/// <param name="typeResolver">The type resolver.</param>
/// <returns>The code.</returns>
public override string GetDefaultValue(JsonSchema4 schema, bool allowsNull, string targetType, string typeNameHint, bool useSchemaDefault, TypeResolverBase typeResolver)
{
var value = base.GetDefaultValue(schema, allowsNull, targetType, typeNameHint, useSchemaDefault, typeResolver);
if (value == null)
{
schema = schema.ActualSchema;
if (schema != null && allowsNull == false)
{
if (schema.IsArray)
{
return("[]");
}
if (schema.IsDictionary)
{
return("{}");
}
if (schema.Type.HasFlag(JsonObjectType.Object) && !schema.IsAbstract)
{
return("new " + targetType + "()");
}
}
}
return(value);
}
/// <summary>Creates the response model.</summary>
/// <param name="statusCode">The status code.</param>
/// <param name="response">The response.</param>
/// <param name="exceptionSchema">The exception schema.</param>
/// <param name="generator">The generator.</param>
/// <param name="resolver">The resolver.</param>
/// <param name="settings">The settings.</param>
/// <returns></returns>
protected override CSharpResponseModel CreateResponseModel(string statusCode, SwaggerResponse response, JsonSchema4 exceptionSchema, IClientGenerator generator, TypeResolverBase resolver, ClientGeneratorBaseSettings settings)
{
return(new CSharpResponseModel(this, statusCode, response, response == GetSuccessResponse(), exceptionSchema, generator, resolver, settings.CodeGeneratorSettings));
}
/// <summary>Initializes a new instance of the <see cref="CSharpValueGenerator" /> class.</summary>
/// <param name="typeResolver">The type resolver.</param>
/// <param name="settings">The settings.</param>
public CSharpValueGenerator(TypeResolverBase typeResolver, CSharpGeneratorSettings settings)
: base(typeResolver, settings.EnumNameGenerator)
{
_settings = settings;
}
/// <summary>Creates the response model.</summary>
/// <param name="operation">The operation.</param>
/// <param name="statusCode">The status code.</param>
/// <param name="response">The response.</param>
/// <param name="exceptionSchema">The exception schema.</param>
/// <param name="generator">The generator.</param>
/// <param name="resolver">The resolver.</param>
/// <param name="settings">The settings.</param>
/// <returns></returns>
protected override TypeScriptResponseModel CreateResponseModel(SwaggerOperation operation, string statusCode, SwaggerResponse response,
JsonSchema4 exceptionSchema, IClientGenerator generator, TypeResolverBase resolver, ClientGeneratorBaseSettings settings)
{
return(new TypeScriptResponseModel(this, operation, statusCode, response, response == GetSuccessResponse().Value,
exceptionSchema, generator, resolver, (SwaggerToTypeScriptClientGeneratorSettings)settings));
}
