private IApplicationBuilder _builder = default!;

private NpgsqlRestOptions? _npgsqlRestoptions;

private const string Enabled = "tsclient";

private const string Module = "tsclient_module";

private const string SseEvents = "tsclient_events";

private const string IncludeParseUrl = "tsclient_parse_url";

private const string IncludeParseRequest = "tsclient_parse_request";

private const string IncludeStatusCode = "tsclient_status_code";

private const string ExportUrl = "tsclient_export_url";

private const string UrlOnly = "tsclient_url_only";

public void Setup(IApplicationBuilder builder, NpgsqlRestOptions npgsqlRestoptions)

{

_builder = builder;

_npgsqlRestoptions = npgsqlRestoptions;

}

private int _filesCreated;

public void Cleanup(RoutineEndpoint[] endpoints)

{

if (options.FilePath is null)

{

return;

}

_filesCreated = 0;

var containsModuleParam = endpoints.Any(e => e.CustomParameters?.ContainsKey(Module) is true);

if (!options.BySchema && containsModuleParam)

{

Run(endpoints, options.FilePath);

}

else

{

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

{

Logger?.LogError("TsClient 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(e => e.CustomParameters?.GetValueOrDefault(Module)))

{

if (group.Key is null)

{

continue;

}

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

{

processedModules.Add(group.Key);

}

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

if (options.SkipTypes && filename.EndsWith(".ts"))

{

filename = filename[..^3] + ".js";

}

Run([.. group], filename);

}

}

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

{

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

if (options.SkipTypes && filename.EndsWith(".ts"))

{

filename = filename[..^3] + ".js";

}

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

(g.CustomParameters?.ContainsKey(Module) is false) ||

(g.CustomParameters?.GetValueOrDefault(Module) is null) ||

(!processedModules.Contains(g.CustomParameters?.GetValueOrDefault(Module) ?? ""))

)];

if (groupArray.Length == 0)

{

continue;

}

Run([.. groupArray], filename);

}

}

if (_filesCreated > 0)

{

Logger?.LogDebug("TsClient: Created {count} {type} file(s)", _filesCreated, options.SkipTypes ? "JavaScript" : "TypeScript");

}

}

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 interfaces to avoid duplicates

// Key: composite type identifier (schema.typename), Value: generated interface name

Dictionary<string, string> compositeTypeInterfaces = [];

StringBuilder contentHeader = new();

StringBuilder content = new();

StringBuilder interfaces = new();

StringBuilder compositeInterfaces = new();

bool needsStatusTypes = false;

// Plain `interface` (module-private inline / ambient in .d.ts) vs exported `export interface` (importable module).

var interfaceDecl = options.ExportTypes ? "export interface" : "interface";

foreach (var import in options.CustomImports)

{

contentHeader.AppendLine(import);

}

if (filtered.Where(e => e.RequestParamType == RequestParamType.QueryString).Any())

{

contentHeader.AppendLine(

options.ImportBaseUrlFrom is not null ?

string.Format("import {{ baseUrl }} from \"{0}\";", options.ImportBaseUrlFrom) :

string.Format("const baseUrl = \"{0}\";", GetHost()));

bool haveParseQuery = filtered

.Where(e => e.RequestParamType == RequestParamType.QueryString &&

e.Routine.ParamCount > 0 &&

e.Routine.ParamCount > (e.PathParameters?.Length ?? 0))

.Any();

if (haveParseQuery)

{

if (!options.SkipTypes)

{

contentHeader.AppendLine(options.ImportParseQueryFrom is not null ?

string.Format(

"import {{ parseQuery }} from \"{0}\";", options.ImportParseQueryFrom) :

"""

}

else

{

contentHeader.AppendLine(options.ImportParseQueryFrom is not null ?

string.Format(

"import {{ parseQuery }} from \"{0}\";", options.ImportParseQueryFrom) :

"""

}

}

}

else

{

contentHeader.AppendLine(

options.ImportBaseUrlFrom is not null ?

string.Format("import {{ baseUrl }} from \"{0}\";", options.ImportBaseUrlFrom) :

string.Format("const baseUrl = \"{0}\";", GetHost()));

}

if (options.ExportUrls)

{

contentHeader.AppendLine();

}

bool handled = false;

var lastContentHeaderWasUrl = 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;

}

}

// Emit type aliases for error and result types when needed

if (needsStatusTypes && !options.SkipTypes)

{

var errorTypeBody = options.ErrorType.EndsWith(" | undefined")

? options.ErrorType[..^12]

: options.ErrorType;

contentHeader.AppendLine();

contentHeader.AppendLine($"type {options.ErrorTypeName} = {errorTypeBody};");

contentHeader.AppendLine($"type {options.ResultTypeName}<T> = {{status: number, response: T, error: {options.ErrorTypeName} | undefined}};");

}

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);

}

// Insert composite type interfaces at the beginning of interfaces

if (compositeInterfaces.Length > 0)

{

interfaces.Insert(0, compositeInterfaces.ToString());

}

if (!options.CreateSeparateTypeFile)

{

if (!options.SkipTypes)

{

interfaces.AppendLine(content.ToString());

if (contentHeader.Length > 0)

{

contentHeader.AppendLine();

interfaces.Insert(0, contentHeader.ToString());

}

AddHeader(interfaces);

File.WriteAllText(fileName, interfaces.ToString());

_filesCreated++;

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

}

else

{

if (contentHeader.Length > 0)

{

content.Insert(0, contentHeader.ToString());

}

AddHeader(content);

File.WriteAllText(fileName, content.ToString());

_filesCreated++;

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

}

}

else

{

if (!options.SkipTypes)

{

// ExportTypes turns the separate file into an importable module (`{name}Types.ts` with `export interface`);

// otherwise it stays an ambient global declaration file (`{name}Types.d.ts`) referenced without an import.

var typeFile = fileName.Replace(".ts", options.ExportTypes ? "Types.ts" : "Types.d.ts");

if (options.ExportTypes)

{

var typeNames = ExtractExportedTypeNames(interfaces.ToString());

if (typeNames.Count > 0)

{

var moduleName = Path.GetFileNameWithoutExtension(typeFile);

contentHeader.Insert(0, $"import type {{ {string.Join(", ", typeNames)} }} from \"./{moduleName}\";{Environment.NewLine}");

}

}

AddHeader(interfaces);

File.WriteAllText(typeFile, interfaces.ToString());

Logger?.LogTrace("Created Typescript type file: {typeFile}", typeFile);

}

if (contentHeader.Length > 0)

{

content.Insert(0, contentHeader.ToString());

}

AddHeader(content);

File.WriteAllText(fileName, content.ToString());

if (!options.SkipTypes)

{

_filesCreated++;

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

}

else

{

_filesCreated++;

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

}

}

return;

void AddHeader(StringBuilder sb)

{

if (options.HeaderLines.Count == 0)

{

return;

}

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

sb.Insert(0, string.Concat(string.Join(

Environment.NewLine,

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

);

}

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;

if (includeStatusCode)

{

needsStatusTypes = true;

}

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 paramTypeDescriptors = routine.ParamTypeDescriptor;

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 = SanitizeJavaScriptVariableName(name);

var pascal = ConvertToPascalCase(name);

var camel = ConvertToCamelCase(name);

if (options.SkipFunctionNames.Contains(camel))

{

return false;

}

content.AppendLine();

string? requestName = null;

string[] paramNames = new string[paramCount];

// Parameters that are filled server-side and cannot be set by the client are omitted from the

// generated request shape when OmitAutomaticParameters is enabled (interface, query, body).

bool[] omitParam = new bool[paramCount];

int requestParamCount = 0;

string? bodyParameterName = null;

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

{

var parameter = routine.Parameters[i];

var descriptor = parameter.TypeDescriptor;//paramTypeDescriptors[i];

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

{

omitParam[i] = true;

continue;

}

requestParamCount++;

var nameSuffix = (descriptor.HasDefault || descriptor.CustomType is not null) ? "?" : "";

paramNames[i] = QuoteJavaScriptVariableName($"{parameter.ConvertedName}{nameSuffix}");

if (endpoint.IsBodyParameter(parameter))

{

// Use the bare converted name for emission — NOT paramNames[i], which carries the TS

// optional "?" suffix (e.g. "responseBody?"). That suffix is only for the interface

// property declaration; it must not leak into the runtime property name used for the

// body expression (request.responseBody) or the query-exclusion key (["responseBody"]).

bodyParameterName = parameter.ConvertedName;

}

}

string requestDesc = "";

if (requestParamCount > 0)

{

StringBuilder req = new();

requestName = $"I{pascal}Request";

requestDesc = string.Concat(requestDesc, "{");

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

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

{

// Skip omitted (server-filled) parameters — their name was not assigned.

if (omitParam[i])

{

continue;

}

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

if (!seenParamNames.Add(paramNames[i]))

{

continue;

}

var descriptor = routine.Parameters[i].TypeDescriptor;

var type = GetTsType(descriptor, false);

req.AppendLine($" {paramNames[i]}: {type} | null;");

requestDesc = string.Concat(requestDesc, $"{paramNames[i]}: {type} | null;");

}

requestDesc = string.Concat(requestDesc, "}");

if (modelsDict.TryGetValue(req.ToString(), out var newName))

{

requestName = newName;

}

else

{

if (!options.SkipTypes)

{

if (options.UniqueModels)

{

modelsDict.Add(req.ToString(), requestName);

}

req.Insert(0, $"{interfaceDecl} {requestName} {{{Environment.NewLine}");

req.AppendLine("}");

req.AppendLine();

interfaces.Append(req);

}

}

}

string responseName = "void";

bool json = false;

string? returnExp = null;

string GetReturnExp(string responseExp)

{

if (includeStatusCode)

{

var errorCast = options.SkipTypes

? options.ErrorExpression

: $"{options.ErrorExpression} as {options.ErrorTypeName}";

return string.Concat(

"return {",

Environment.NewLine,

" status: response.status,",

Environment.NewLine,

" response: ",

(responseExp == "await response.text()" ?

"response.ok ? " + responseExp + " : undefined!" :

string.Concat("response.ok ? ", responseExp, " : undefined!")),

",",

Environment.NewLine,

$" error: !response.ok && response.headers.get(\"content-length\") !== \"0\" ? {errorCast} : undefined",

Environment.NewLine,

" };");

}

return string.Concat("return ", responseExp, ";");

}

// proxy_out: always returns raw upstream response (function runs first, then proxies to upstream).

// proxy pass-through: when the routine is void, returns raw upstream response.

// Transform proxies (non-void @proxy routines) return processed data — fall through to normal handling.

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

{

responseName = "Response";

returnExp = "return response;";

}

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

{

// Multi-command SQL file: generate response interface with one property per command result

responseName = $"I{pascal}Response";

StringBuilder mcResp = new();

mcResp.AppendLine($"{interfaceDecl} {responseName} {{");

foreach (var cmdInfo in routine.MultiCommandInfo)

{

if (cmdInfo.IsSkipped) continue;

if (cmdInfo.ColumnCount == 0)

{

// Void command → rows affected count

mcResp.AppendLine($" {cmdInfo.Name}: number;");

}

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

{

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

var tsType = GetTsType(cmdInfo.ColumnTypeDescriptors[0], true);

var arraySuffix = cmdInfo.IsSingle ? "" : "[]";

mcResp.AppendLine($" {cmdInfo.Name}: {tsType}{arraySuffix};");

}

else if (cmdInfo.ColumnCount == 1)

{

// Single column — object array or object with @single

var tsType = GetTsType(cmdInfo.ColumnTypeDescriptors[0], true);

var arraySuffix = cmdInfo.IsSingle ? "" : "[]";

mcResp.AppendLine($" {cmdInfo.Name}: {{ {cmdInfo.ColumnNames[0]}: {tsType} }}{arraySuffix};");

}

else

{

// Multiple columns — inline object type array or object with @single

var fields = new StringBuilder();

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

{

if (ci > 0) fields.Append(", ");

fields.Append(cmdInfo.ColumnNames[ci]);

fields.Append(": ");

fields.Append(GetTsType(cmdInfo.ColumnTypeDescriptors[ci], true));

}

var arraySuffix = cmdInfo.IsSingle ? "" : "[]";

mcResp.AppendLine($" {cmdInfo.Name}: {{ {fields} }}{arraySuffix};");

}

}

mcResp.AppendLine("}");

mcResp.AppendLine();

if (!options.SkipTypes)

{

interfaces.Append(mcResp);

}

returnExp = GetReturnExp($"await response.json() as {responseName}");

}

else if (!isVoid && !urlOnly)

{

if (endpoint.Upload)

{

responseName = $"I{pascal}Response";

StringBuilder resp = new();

resp.AppendLine($"{interfaceDecl} {responseName} {{");

resp.AppendLine(" type: string;");

resp.AppendLine(" fileName: string;");

resp.AppendLine(" contentType: string;");

resp.AppendLine(" size: number;");

resp.AppendLine(" success: boolean;");

resp.AppendLine(" status: string;");

resp.AppendLine(" [key: string]: string | number | boolean;");

resp.AppendLine("}");

resp.AppendLine();

interfaces.Append(resp);

responseName = string.Concat(responseName, "[]");

// Note: Don't set json = true here because upload endpoints use FormData,

// and the Content-Type header should be set automatically by the browser

if (!options.SkipTypes)

{

returnExp = GetReturnExp($"await response.json() as {responseName}");

}

else

{

returnExp = GetReturnExp("await response.json()");

}

}

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

{

var descriptor = columnsTypeDescriptor[0];

responseName = descriptor.IsJson ? "any" : GetTsType(descriptor, true);

if (descriptor.IsArray)

{

json = true;

//if (options.SkipTypes is false)

//{

// returnExp = GetReturnExp($"await response.json() as {responseName}[]");

//}

//else

//{

// returnExp = GetReturnExp("await response.json()");

//}

returnExp = GetReturnExp("await response.json()");

}

else

{

if (descriptor.IsDate || descriptor.IsDateTime)

{

returnExp = GetReturnExp("new Date(await response.text())");

}

else if (descriptor.IsNumeric)

{

returnExp = GetReturnExp("Number(await response.text())");

}

else if (descriptor.IsBoolean)

{

returnExp = GetReturnExp("await response.text() == \"t\"");

}

else if (descriptor.IsJson)

{

returnExp = GetReturnExp("await response.json()");

}

else

{

returnExp = GetReturnExp("await response.text()");

}

}

}

else

{

json = true;

if (returnsUnnamedSet)

{

if (columnCount > 0)

{

responseName = GetTsType(columnsTypeDescriptor[0], false);

}

else

{

responseName = "string[]";

}

}

else

{

StringBuilder resp = new();

responseName = $"I{pascal}Response";

// 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;

}

// Check if this is a nested composite column - only generate nested interface when NestedJsonForCompositeTypes is true

if (useNestedCompositeTypes &&

routine.CompositeColumnInfo is not null &&

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

{

// Generate interface for this composite type if not already done

var compositeInterfaceName = GetOrCreateCompositeInterface(

compositeInfo.FieldNames,

compositeInfo.FieldDescriptors,

compositeInfo.ConvertedColumnName,

compositeTypeInterfaces,

compositeInterfaces);

resp.AppendLine($" {compositeInfo.ConvertedColumnName}: {compositeInterfaceName} | null;");

continue;

}

// Check if this is an array of composite types

if (routine.ArrayCompositeColumnInfo is not null &&

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

{

// Generate interface for this composite type if not already done

var compositeInterfaceName = GetOrCreateCompositeInterface(

arrayCompositeInfo.FieldNames,

arrayCompositeInfo.FieldDescriptors,

routine.ColumnNames[i],

compositeTypeInterfaces,

compositeInterfaces);

resp.AppendLine($" {routine.ColumnNames[i]}: {compositeInterfaceName}[] | null;");

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 interface under column name

var compositeInterfaceName = GetOrCreateCompositeInterface(

descriptor.CompositeFieldNames,

descriptor.CompositeFieldDescriptors,

routine.ColumnNames[i],

compositeTypeInterfaces,

compositeInterfaces);

resp.AppendLine($" {routine.ColumnNames[i]}: {compositeInterfaceName} | null;");

}

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 nestedInterfaceName = GetOrCreateCompositeInterface(

fieldDescriptor.CompositeFieldNames,

fieldDescriptor.CompositeFieldDescriptors,

fieldName,

compositeTypeInterfaces,

compositeInterfaces);

resp.AppendLine($" {fieldName}: {nestedInterfaceName} | null;");

}

else if (fieldDescriptor.ArrayCompositeFieldNames is not null &&

fieldDescriptor.ArrayCompositeFieldDescriptors is not null)

{

var nestedInterfaceName = GetOrCreateCompositeInterface(

fieldDescriptor.ArrayCompositeFieldNames,

fieldDescriptor.ArrayCompositeFieldDescriptors,

fieldName,

compositeTypeInterfaces,

compositeInterfaces);

resp.AppendLine($" {fieldName}: {nestedInterfaceName}[] | null;");

}

else

{

var fieldType = GetTsType(fieldDescriptor, false);

resp.AppendLine($" {fieldName}: {fieldType} | null;");

}

}

}

continue;

}

var type = GetTsType(descriptor, false);