private IApplicationBuilder _builder = default!;

private NpgsqlRestOptions? _npgsqlRestoptions;

private const string Enabled = "dartclient";

private const string Module = "dartclient_module";

// SQL-file directory grouping writes tsclient_module — reuse it so both generators group identically.

private const string TsModuleFallback = "tsclient_module";

private const string IncludeStatusCode = "dartclient_status_code";

private const string SseEvents = "dartclient_events";

private const string IncludeParseUrl = "dartclient_parse_url";

private const string IncludeParseRequest = "dartclient_parse_request";

private const string ExportUrl = "dartclient_export_url";

private const string UrlOnly = "dartclient_url_only";

public void Setup(IApplicationBuilder builder, NpgsqlRestOptions npgsqlRestoptions)

{

_builder = builder;

_npgsqlRestoptions = npgsqlRestoptions;

}

private int _filesCreated;

private static string? GetModule(RoutineEndpoint endpoint) =>

endpoint.CustomParameters?.GetValueOrDefault(Module) ??

endpoint.CustomParameters?.GetValueOrDefault(TsModuleFallback);

public void Cleanup(RoutineEndpoint[] endpoints)

{

if (options.FilePath is null)

{

return;

}

_filesCreated = 0;

var containsModuleParam = endpoints.Any(e => GetModule(e) is not null);

if (!options.BySchema && containsModuleParam)

{

Run(endpoints, options.FilePath);

}

else

{

if (!options.FilePath.Contains("{0}"))

{

Logger?.LogError("DartClient Option FilePath doesn't contain {{0}} formatter and BySchema options is true. Some files may be overwritten! Existing...");

return;

}

HashSet<string> processedModules = [];

if (containsModuleParam)

{

foreach (var group in endpoints.GroupBy(GetModule))

{

if (group.Key is null)

{

continue;

}

if (!processedModules.Contains(group.Key))

{

processedModules.Add(group.Key);

}

var filename = string.Format(options.FilePath, group.Key);

Run([.. group], filename);

}

}

foreach (var group in endpoints.GroupBy(e => e.Routine.Schema))

{

var filename = string.Format(options.FilePath, ConvertToSnakeCase(group.Key));

RoutineEndpoint[] groupArray = [.. group.Where(g =>

GetModule(g) is null ||

!processedModules.Contains(GetModule(g) ?? "")

)];

if (groupArray.Length == 0)

{

continue;

}

Run([.. groupArray], filename);

}

}

if (_filesCreated > 0)

{

Logger?.LogDebug("DartClient: Created {count} Dart file(s)", _filesCreated);

}

}

private sealed record DartField(

string DartName,

string JsonKey,

string DartType,

string ReadExpr,

string WriteExpr,

bool OmitNullInJson);

private void Run(RoutineEndpoint[] endpoints, string? fileName)

{

if (fileName is null)

{

return;

}

// Internal-only endpoints have no public HTTP route (404), so a generated client function for one

// would be dead — e.g. a bare-`@mcp` MCP-only routine. Exclude them from the REST client.

RoutineEndpoint[] filtered = [.. endpoints.Where(e => e.InternalOnly is false && e.CustomParameters.ParameterEnabled(Enabled) is not false)];

Dictionary<string, string> modelsDict = [];

Dictionary<string, int> names = [];

// Track generated composite type model classes to avoid duplicates

// Key: composite field signature, Value: generated class name

Dictionary<string, string> compositeTypeModels = [];

// Reserve the status/scaffold class names so a model class can never collide with them.

HashSet<string> usedModelNames = [options.ErrorTypeName, options.ResultTypeName, "SseSubscription"];

List<string> compositeModels = [];

List<string> models = [];

List<string> urlFunctions = [];

List<string> sseFactories = [];

List<string> functions = [];

bool needsStatusTypes = false;

bool needsQuery = false;

bool needsHttp = false;

bool needsSend = false;

bool needsSendParse = false;

bool needsSendMultipart = false;

bool needsSse = false;

bool needsConvert = false;

bool handled = false;

foreach (var endpoint in filtered

.Where(e => e.Routine.Type == RoutineType.Table || e.Routine.Type == RoutineType.View)

.OrderBy(e => e.Routine.Schema)

.ThenBy(e => e.Routine.Type)

.ThenBy(e => e.Routine.Name))

{

if (Handle(endpoint) && !handled)

{

handled = true;

}

}

foreach (var endpoint in filtered

.Where(e => !(e.Routine.Type == RoutineType.Table || e.Routine.Type == RoutineType.View))

.OrderBy(e => e.Routine.Schema)

.ThenBy(e => e.Routine.Name))

{

if (Handle(endpoint) && !handled)

{

handled = true;

}

}

if (!handled)

{

if (filtered.Length == 0 && options.FileOverwrite)

{

if (File.Exists(fileName))

{

try

{

File.Delete(fileName);

Logger?.LogTrace("Deleted file: {fileName}", fileName);

}

catch (Exception ex)

{

Logger?.LogError(ex, "Failed to delete file: {fileName}", fileName);

try

{

File.WriteAllText(fileName, "// No endpoints found.");

}

catch (Exception ex2)

{

Logger?.LogError(ex2, "Failed to empty file: {fileName}", fileName);

}

}

}

}

return;

}

if (!options.FileOverwrite && File.Exists(fileName))

{

return;

}

var dir = Path.GetDirectoryName(fileName);

if (dir is not null && !Directory.Exists(dir))

{

Directory.CreateDirectory(dir);

}

List<string> modelBlocks = [];

if (needsStatusTypes)

{

modelBlocks.Add(GetStatusClasses());

}

modelBlocks.AddRange(compositeModels);

modelBlocks.AddRange(models);

var baseNoExt = Path.GetFileNameWithoutExtension(fileName);

var separateModels = options.SeparateModelsFile && modelBlocks.Count > 0;

if (needsSse)

{

// The SSE scaffold uses utf8.decoder and LineSplitter.

needsConvert = true;

}

List<string> imports = [];

if (needsSse)

{

imports.Add("import 'dart:async';");

}

if (needsConvert)

{

imports.Add("import 'dart:convert';");

}

if (needsSse)

{

imports.Add("import 'dart:math' as math;");

}

if (needsHttp)

{

imports.Add("import 'package:http/http.dart' as http;");

}

foreach (var import in options.CustomImports)

{

imports.Add(import);

}

if (options.ImportBaseUrlFrom is not null)

{

imports.Add($"import '{options.ImportBaseUrlFrom}';");

}

if (separateModels)

{

imports.Add($"import '{baseNoExt}_models.dart';");

imports.Add($"export '{baseNoExt}_models.dart';");

}

List<string> blocks = [];

var headerBlock = GetHeaderBlock();

if (headerBlock is not null)

{

blocks.Add(headerBlock);

}

if (imports.Count > 0)

{

blocks.Add(string.Join(Environment.NewLine, imports));

}

if (options.ImportBaseUrlFrom is null)

{

blocks.Add($"String baseUrl = '{GetHost()}';");

}

if (needsHttp)

{

blocks.Add(ClientScaffold);

}

if (needsSend)

{

blocks.Add(needsSendParse ? SendScaffoldWithParse : SendScaffold);

}

if (needsSendMultipart)

{

blocks.Add(SendMultipartScaffold);

}

if (needsQuery)

{

blocks.Add(QueryScaffold);

}

if (needsSse)

{

blocks.Add(SseScaffold);

}

if (needsStatusTypes)

{

blocks.Add(GetErrorHelper());

}

blocks.AddRange(urlFunctions);

blocks.AddRange(sseFactories);

if (!separateModels)

{

blocks.AddRange(modelBlocks);

}

blocks.AddRange(functions);

File.WriteAllText(fileName, string.Concat(string.Join(string.Concat(Environment.NewLine, Environment.NewLine), blocks), Environment.NewLine));

_filesCreated++;

Logger?.LogTrace("Created Dart file: {fileName}", fileName);

if (separateModels)

{

var modelsFileName = Path.Combine(dir ?? "", string.Concat(baseNoExt, "_models.dart"));

List<string> modelFileBlocks = [];

if (headerBlock is not null)

{

modelFileBlocks.Add(headerBlock);

}

modelFileBlocks.AddRange(modelBlocks);

File.WriteAllText(modelsFileName, string.Concat(string.Join(string.Concat(Environment.NewLine, Environment.NewLine), modelFileBlocks), Environment.NewLine));

_filesCreated++;

Logger?.LogTrace("Created Dart models file: {modelsFileName}", modelsFileName);

}

return;

string? GetHeaderBlock()

{

if (options.HeaderLines.Count == 0)

{

return null;

}

var now = DateTime.Now.ToString("O");

var text = string.Join(Environment.NewLine, options.HeaderLines.Select(l => string.Format(l, now).Trim())).Trim();

return text.Length == 0 ? null : text;

}

bool Handle(RoutineEndpoint endpoint)

{

Routine routine = endpoint.Routine;

var eventsStreamingEnabled = endpoint.SseEventsPath is not null;

if (endpoint.CustomParameters.ParameterEnabled(SseEvents) is false)

{

eventsStreamingEnabled = false;

}

var includeParseUrlParam = endpoint.CustomParameters.ParameterEnabled(IncludeParseUrl) ?? options.IncludeParseUrlParam;

var includeParseRequestParam = endpoint.CustomParameters.ParameterEnabled(IncludeParseRequest) ?? options.IncludeParseRequestParam;

var includeStatusCode = endpoint.CustomParameters.ParameterEnabled(IncludeStatusCode) ?? options.IncludeStatusCode;

var exportUrl = endpoint.CustomParameters.ParameterEnabled(ExportUrl) ?? options.ExportUrls;

var urlOnly = endpoint.CustomParameters.ParameterEnabled(UrlOnly) is true;

if (urlOnly)

{

exportUrl = true;

}

if (options.SkipRoutineNames.Contains(routine.Name))

{

return false;

}

if (options.SkipSchemas.Contains(routine.Schema))

{

return false;

}

if (options.SkipPaths.Contains(endpoint.Path))

{

return false;

}

string? name;

try

{

if (options.UseRoutineNameInsteadOfEndpoint)

{

name = options.IncludeSchemaInNames ? string.Concat(routine.Schema, "/", routine.Name) : routine.Name;

}

else

{

string pathName;

if (string.IsNullOrEmpty(_npgsqlRestoptions?.UrlPathPrefix) || _npgsqlRestoptions.UrlPathPrefix.Length > endpoint.Path.Length)

{

pathName = endpoint.Path;

}

else

{

pathName = endpoint.Path[_npgsqlRestoptions.UrlPathPrefix.Length..];

}

name = options.IncludeSchemaInNames ? string.Concat(routine.Schema, "/", pathName) : pathName;

}

}

catch

{

name = options.IncludeSchemaInNames ? string.Concat(routine.Schema, "/", routine.Name) : routine.Name;

}

if (name.Length < 3)

{

name = options.IncludeSchemaInNames ? string.Concat(routine.Schema, "/", routine.Name) : routine.Name;

}

var routineType = routine.Type;

var paramCount = routine.ParamCount;

var isVoid = routine.IsVoid;

var returnsSet = routine.ReturnsSet;

var columnCount = routine.ColumnCount;

var returnsRecordType = routine.ReturnsRecordType;

var columnsTypeDescriptor = routine.ColumnsTypeDescriptor;

var returnsUnnamedSet = routine.ReturnsUnnamedSet;

if (endpoint.Login)

{

isVoid = false;

returnsSet = false;

columnCount = 1;

returnsRecordType = false;

columnsTypeDescriptor = [new TypeDescriptor("text")];

}

if (endpoint.Logout)

{

isVoid = true;

}

if (routineType == RoutineType.Table || routineType == RoutineType.View)

{

name = string.Concat(name, "-", endpoint.Method.ToString().ToLowerInvariant());

}

if (names.TryGetValue(name, out var count))

{

names[name] = count + 1;

name = string.Concat(name, "-", count);

}

else

{

names.Add(name, 1);

}

name = SanitizeDartName(name);

var pascal = ConvertToPascalCase(name);

var camel = EscapeDartIdentifier(ConvertToCamelCase(name));

// A top-level function must not collide with the module-scaffold declarations.

if (camel is "baseUrl" or "httpClient")

{

camel = string.Concat(camel, "_");

}

if (options.SkipFunctionNames.Contains(camel))

{

return false;

}

// Request fields

string? requestName = null;

List<(DartField Field, bool IsPathParam, bool IsBodyParam, bool HasDefault)> requestFields = [];

Dictionary<string, string> paramFieldByName = new(StringComparer.OrdinalIgnoreCase);

var seenFieldNames = new HashSet<string>(StringComparer.Ordinal);

string? bodyParameterDartName = null;

string? bodyParameterDartType = null;

int requestParamCount = 0;

for (var i = 0; i < paramCount; i++)

{

var parameter = routine.Parameters[i];

var descriptor = parameter.TypeDescriptor;

if (options.OmitAutomaticParameters && endpoint.OmitParameterFromGeneratedRequest(parameter))

{

continue;

}

var dartName = EscapeDartIdentifier(ConvertToCamelCase(SanitizeDartName(parameter.ConvertedName)));

// Skip duplicate parameter names (e.g., when multiple HTTP custom types share field names)

if (!seenFieldNames.Add(dartName))

{

continue;

}

requestParamCount++;

paramFieldByName[parameter.ConvertedName] = dartName;

paramFieldByName.TryAdd(parameter.ActualName, dartName);

var hasDefault = descriptor.HasDefault || descriptor.CustomType is not null;

var isPathParam = endpoint.PathParameters is not null &&

(endpoint.PathParameters.Contains(parameter.ConvertedName, StringComparer.OrdinalIgnoreCase) ||

endpoint.PathParameters.Contains(parameter.ActualName, StringComparer.OrdinalIgnoreCase));

var isBodyParam = endpoint.IsBodyParameter(parameter);

var dartType = GetDartType(descriptor);

var field = new DartField(

dartName,

parameter.ConvertedName,

NullableType(dartType),

GetReadExpr(descriptor, parameter.ConvertedName),

GetWriteExpr(descriptor, dartName),

hasDefault);

requestFields.Add((field, isPathParam, isBodyParam, hasDefault));

if (isBodyParam)

{

bodyParameterDartName = dartName;

bodyParameterDartType = dartType;

}

}

if (requestParamCount > 0)

{

requestName = EscapeDartClassName(string.Concat(options.ModelPrefix, pascal, "Request", options.ModelSuffix));

requestName = AddModel(requestName, [.. requestFields.Select(f => f.Field)]);

}

// Response

string responseName = "void";

bool json = false;

bool responseIsRaw = false;

string[]? payloadLines = null;

string JsonDecodeExpr = "jsonDecode(utf8.decode(response.bodyBytes))";

// proxy_out: always returns the raw upstream response (function runs first, then proxies

// to upstream). Void proxy pass-through likewise. There is no typed Dart shape for those,

// so the generated function returns http.Response directly. Transform proxies (non-void

// @proxy routines) return processed data and fall through to normal handling.

if ((endpoint.IsProxyOut || (endpoint.IsProxy && routine.IsVoid)) && !urlOnly)

{

responseIsRaw = true;

includeStatusCode = false;

responseName = "http.Response";

payloadLines = ["response"];

}

else if (routine.IsMultiCommand && routine.MultiCommandInfo is not null && !urlOnly)

{

// Multi-command SQL file: generate response class with one field per command result

List<DartField> mcFields = [];

foreach (var cmdInfo in routine.MultiCommandInfo)

{

if (cmdInfo.IsSkipped)

{

continue;

}

var fieldName = EscapeDartIdentifier(ConvertToCamelCase(SanitizeDartName(cmdInfo.Name)));

if (cmdInfo.ColumnCount == 0)

{

// Void command → rows affected count

mcFields.Add(new DartField(fieldName, cmdInfo.Name, "int?",

$"(json['{cmdInfo.Name}'] as num?)?.toInt()", fieldName, false));

}

else if (cmdInfo.ColumnCount == 1 && cmdInfo.ReturnsUnnamedSet)

{

// Single column with UnnamedSingleColumnSet — flat list or scalar with @single

var elem = GetElementInfo(cmdInfo.ColumnTypeDescriptors[0]);

if (cmdInfo.IsSingle)

{

mcFields.Add(new DartField(fieldName, cmdInfo.Name, NullableType(elem.Type),

GetReadExpr(cmdInfo.ColumnTypeDescriptors[0], cmdInfo.Name, forceScalar: true),

fieldName, false));

}

else

{

mcFields.Add(new DartField(fieldName, cmdInfo.Name, NullableType($"List<{elem.Type}>"),

elem.Conversion is null

? $"json['{cmdInfo.Name}'] as List?"

: $"(json['{cmdInfo.Name}'] as List?)?.map((e) => {elem.Conversion}).toList()",

fieldName, false));

}

}

else

{

// Named columns — nested class, list or single object with @single

List<DartField> cmdFields = [];

for (int ci = 0; ci < cmdInfo.ColumnCount; ci++)

{

var colName = cmdInfo.ColumnNames[ci];

var colDartName = EscapeDartIdentifier(ConvertToCamelCase(SanitizeDartName(colName)));

var colDescriptor = cmdInfo.ColumnTypeDescriptors[ci];

cmdFields.Add(new DartField(colDartName, colName,

NullableType(GetDartType(colDescriptor)),

GetReadExpr(colDescriptor, colName),

GetWriteExpr(colDescriptor, colDartName), false));

}

var cmdClassName = EscapeDartClassName(string.Concat(

options.ModelPrefix, pascal, ConvertToPascalCase(SanitizeDartName(cmdInfo.Name)), "Result", options.ModelSuffix));

cmdClassName = AddModel(cmdClassName, cmdFields);

if (cmdInfo.IsSingle)

{

mcFields.Add(new DartField(fieldName, cmdInfo.Name, string.Concat(cmdClassName, "?"),

$"json['{cmdInfo.Name}'] == null ? null : {cmdClassName}.fromJson(json['{cmdInfo.Name}'] as Map<String, dynamic>)",

$"{fieldName}?.toJson()", false));

}

else

{

mcFields.Add(new DartField(fieldName, cmdInfo.Name, $"List<{cmdClassName}>?",

$"(json['{cmdInfo.Name}'] as List?)?.map((e) => {cmdClassName}.fromJson(e as Map<String, dynamic>)).toList()",

$"{fieldName}?.map((e) => e.toJson()).toList()", false));

}

}

}

responseName = EscapeDartClassName(string.Concat(options.ModelPrefix, pascal, "Response", options.ModelSuffix));

responseName = AddModel(responseName, mcFields);

json = true;

payloadLines = [$"{responseName}.fromJson({JsonDecodeExpr} as Map<String, dynamic>)"];

}

else if (!isVoid && !urlOnly)

{

if (endpoint.Upload)

{

var uploadName = EscapeDartClassName(string.Concat(options.ModelPrefix, pascal, "Response", options.ModelSuffix));

if (!usedModelNames.Contains(uploadName))

{

usedModelNames.Add(uploadName);

models.Add(RenderUploadModel(uploadName));

}

responseName = $"List<{uploadName}>";

// Note: json flag stays false because upload endpoints use multipart form data,

// and the Content-Type header is set by the multipart request itself.

payloadLines =

[

$"({JsonDecodeExpr} as List)",

$".map((e) => {uploadName}.fromJson(e as Map<String, dynamic>))",

".toList()",

];

}

else if (returnsSet == false && columnCount == 1 && !returnsRecordType)

{

var descriptor = columnsTypeDescriptor[0];

if (descriptor.IsArray)

{

json = true;

var elem = GetElementInfo(descriptor);

responseName = $"List<{elem.Type}>";

payloadLines = elem.Conversion is null

? [$"{JsonDecodeExpr} as List"]

:

[

$"({JsonDecodeExpr} as List)",

$".map((e) => {elem.Conversion})",

".toList()",

];

}

else

{

if ((descriptor.IsDate || descriptor.IsDateTime) && options.UseDateTimeType)

{

responseName = "DateTime";

payloadLines = ["DateTime.parse(utf8.decode(response.bodyBytes))"];

}

else if (descriptor.IsNumeric)

{

responseName = IsIntegerFamily(descriptor) ? "int" : "double";

payloadLines = [$"{responseName}.parse(utf8.decode(response.bodyBytes))"];

}

else if (descriptor.IsBoolean)

{

responseName = "bool";

payloadLines = ["utf8.decode(response.bodyBytes) == 't'"];

}

else if (descriptor.IsJson)

{

responseName = options.DefaultJsonType;

payloadLines = [JsonDecodeExpr];

}

else

{

responseName = "String";

payloadLines = ["utf8.decode(response.bodyBytes)"];

}

}

}

else

{

json = true;

if (returnsUnnamedSet)

{

var descriptor = columnCount > 0 ? columnsTypeDescriptor[0] : new TypeDescriptor("text");

var elem = GetElementInfo(descriptor);

if (returnsSet && !endpoint.ReturnSingleRecord)

{

responseName = $"List<{elem.Type}>";

payloadLines = elem.Conversion is null

? [$"{JsonDecodeExpr} as List"]

:

[

$"({JsonDecodeExpr} as List)",

$".map((e) => {elem.Conversion})",

".toList()",

];

}

else

{

responseName = elem.Type;

payloadLines = [GetScalarJsonExpr(descriptor, JsonDecodeExpr)];

}

}

else

{

List<DartField> responseFields = [];

// Check if nested JSON for composite types is enabled

// When false (default), composite fields are flattened in the JSON response

// When true, composite fields are nested under their column name

var useNestedCompositeTypes = endpoint.NestedJsonForCompositeTypes == true;

// Collect column indices to skip (expanded composite columns) - only when using nested types

HashSet<int> skipIndices = [];

if (useNestedCompositeTypes && routine.CompositeColumnInfo is not null)

{

foreach (var kvp in routine.CompositeColumnInfo)

{

// Skip all expanded column indices except the first one (which becomes the composite property)

foreach (var idx in kvp.Value.ExpandedColumnIndices.Skip(1))

{

skipIndices.Add(idx);

}

}

}

for (var i = 0; i < columnCount; i++)

{

// Skip expanded composite columns (only when nested types are enabled)

if (skipIndices.Contains(i))

{

continue;

}

// Nested composite column - only generate a nested class when NestedJsonForCompositeTypes is true

if (useNestedCompositeTypes &&

routine.CompositeColumnInfo is not null &&

routine.CompositeColumnInfo.TryGetValue(i, out var compositeInfo))

{

var compositeClassName = GetOrCreateCompositeModel(

compositeInfo.FieldNames,

compositeInfo.FieldDescriptors,

compositeInfo.ConvertedColumnName,

compositeTypeModels,

compositeModels);

responseFields.Add(CompositeField(compositeInfo.ConvertedColumnName, compositeClassName));

continue;

}

// Array of composite types

if (routine.ArrayCompositeColumnInfo is not null &&

routine.ArrayCompositeColumnInfo.TryGetValue(i, out var arrayCompositeInfo))

{

var compositeClassName = GetOrCreateCompositeModel(

arrayCompositeInfo.FieldNames,

arrayCompositeInfo.FieldDescriptors,

routine.ColumnNames[i],

compositeTypeModels,

compositeModels);

responseFields.Add(CompositeArrayField(routine.ColumnNames[i], compositeClassName));

continue;

}

var descriptor = columnsTypeDescriptor[i];

// SQL file composite type column: expand fields to match actual JSON response

if (descriptor.IsCompositeType &&

descriptor.CompositeFieldNames is not null &&

descriptor.CompositeFieldDescriptors is not null)

{

if (useNestedCompositeTypes)

{

// Nested mode: generate nested class under column name

var compositeClassName = GetOrCreateCompositeModel(

descriptor.CompositeFieldNames,

descriptor.CompositeFieldDescriptors,

routine.ColumnNames[i],

compositeTypeModels,

compositeModels);

responseFields.Add(CompositeField(routine.ColumnNames[i], compositeClassName));

}

else

{

// Flat mode: inline each composite field as a separate property

for (var fi = 0; fi < descriptor.CompositeFieldNames.Length; fi++)

{

var fieldName = ConvertToCamelCase(descriptor.CompositeFieldNames[fi]);

var fieldDescriptor = descriptor.CompositeFieldDescriptors[fi];

// Handle nested composite fields

if (fieldDescriptor.CompositeFieldNames is not null &&

fieldDescriptor.CompositeFieldDescriptors is not null)

{

var nestedClassName = GetOrCreateCompositeModel(

fieldDescriptor.CompositeFieldNames,

fieldDescriptor.CompositeFieldDescriptors,

fieldName,

compositeTypeModels,

compositeModels);

responseFields.Add(CompositeField(fieldName, nestedClassName));

}

else if (fieldDescriptor.ArrayCompositeFieldNames is not null &&

fieldDescriptor.ArrayCompositeFieldDescriptors is not null)

{

var nestedClassName = GetOrCreateCompositeModel(

fieldDescriptor.ArrayCompositeFieldNames,

fieldDescriptor.ArrayCompositeFieldDescriptors,

fieldName,

compositeTypeModels,

compositeModels);

responseFields.Add(CompositeArrayField(fieldName, nestedClassName));

}

else

{

responseFields.Add(PlainField(fieldName, fieldDescriptor));

}

}

}

continue;

}

responseFields.Add(PlainField(routine.ColumnNames[i], descriptor));

}

responseName = EscapeDartClassName(string.Concat(options.ModelPrefix, pascal, "Response", options.ModelSuffix));

responseName = AddModel(responseName, responseFields);

if (returnsSet && !endpoint.ReturnSingleRecord)

{

payloadLines =

[

$"({JsonDecodeExpr} as List)",

$".map((e) => {responseName}.fromJson(e as Map<String, dynamic>))",

".toList()",

];

responseName = $"List<{responseName}>";

}

else

{

payloadLines = [$"{responseName}.fromJson({JsonDecodeExpr} as Map<String, dynamic>)"];

}

}

}

}

if (includeStatusCode)

{

needsStatusTypes = true;

}

// Headers

Dictionary<string, string> headersDict = [];