["ExportTypes"] = false,

["NpgsqlRest:ClientCodeGen:ExportTypes"] = "Emit interfaces with the `export` keyword so they can be imported by other modules. When true and CreateSeparateTypeFile is true, the separate type file becomes an importable module ({name}Types.ts) instead of an ambient {name}Types.d.ts, and the client file imports the named types from it. No effect when SkipTypes is true.",

// Emit interfaces with the `export` keyword so they can be imported by other modules. When true and CreateSeparateTypeFile is true, the separate type file becomes an importable module ({name}Types.ts) instead of an ambient {name}Types.d.ts, and the client file imports the named types from it. No effect when SkipTypes is true.

//

"ExportTypes": false,

//

/// <summary>

/// Output path for TsClient generated files with ExportTypes=true + separate type file (used by tests)

/// </summary>

public static string TsClientExportOutputPath { get; } = Path.Combine(Path.GetTempPath(), "NpgsqlRestTests", "TsClientExport");

// TsClient configuration for ExportTypes testing - exported interfaces in a separate importable module

new TsClient(new TsClientOptions

{

FilePath = Path.Combine(TsClientExportOutputPath, "{0}.ts"),

FileOverwrite = true,

BySchema = true,

IncludeHost = false,

CreateSeparateTypeFile = true,

ExportTypes = true,

CommentHeader = CommentHeader.None,

HeaderLines = [],

SkipSchemas = ["public", "custom_param_schema", "my_schema", "custom_table_param_schema", ""],

IncludeStatusCode = false

}),

namespace NpgsqlRestTests

public static partial class Database

{

public static void TsClientExportTypesTests()

{

script.Append("""

}

}

namespace NpgsqlRestTests.TsClientTests

[Collection("TestFixture")]

public class ExportTypesTests

{

// ExportTypes = true with CreateSeparateTypeFile = true: interfaces live in an importable

// module {name}Types.ts (not an ambient .d.ts), emitted as `export interface`, and the

// client file imports them by name.

private const string ExpectedClient = """

private const string ExpectedTypes = """

[Fact]

public void Test_ExportTypes_ClientFile()

{

var filePath = Path.Combine(Setup.Program.TsClientExportOutputPath, "search_products.ts");

File.Exists(filePath).Should().BeTrue($"Expected file at {filePath}");

var content = File.ReadAllText(filePath);

content.Should().Be(ExpectedClient);

}

[Fact]

public void Test_ExportTypes_TypeFile_IsImportableModule()

{

// Importable module: {name}Types.ts, not the ambient {name}Types.d.ts.

var tsPath = Path.Combine(Setup.Program.TsClientExportOutputPath, "search_productsTypes.ts");

var dtsPath = Path.Combine(Setup.Program.TsClientExportOutputPath, "search_productsTypes.d.ts");

File.Exists(tsPath).Should().BeTrue($"Expected importable type module at {tsPath}");

File.Exists(dtsPath).Should().BeFalse($"Ambient declaration file should not be produced at {dtsPath}");

var content = File.ReadAllText(tsPath);

content.Should().Be(ExpectedTypes);

}

}

The TypeScript client generator (`NpgsqlRest.TsClient`) previously emitted its request/response (and composite) interfaces as plain `interface` declarations: module-private when inlined into the client file (`CreateSeparateTypeFile: false`), or ambient/global in the separate `{name}Types.d.ts` file (the default). Neither form could be imported by other modules. The new **`ExportTypes`** option (config `NpgsqlRest:ClientCodeGen:ExportTypes`, default `false`) emits them as `export interface` so they can be imported:

- **Inline** (`CreateSeparateTypeFile: false`) — interfaces are emitted as `export interface` in the same file as the functions.

- **Separate file** (`CreateSeparateTypeFile: true`) — the type file becomes an importable module **`{name}Types.ts`** (`export interface …`) instead of an ambient **`{name}Types.d.ts`**, and the generated client file gets an `import type { … } from "./{name}Types";` referencing the named types.

Has no effect when `SkipTypes` is `true`. Defaulting to `false` keeps existing output byte-for-byte unchanged.

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

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

// 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}");

}

}

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

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

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

resp.Insert(0, $"{interfaceDecl} {responseName} {{{Environment.NewLine}");

interfaceBuilder.AppendLine($"{(options.ExportTypes ? "export interface" : "interface")} {interfaceName} {{");

/// <summary>

/// Extracts the names of `export interface {name} {` declarations from generated type-file content,

/// so the client file can import them. Top-level declarations only — indented field lines and inline

/// object types never start with the keyword, so they are not matched.

/// </summary>

private static List<string> ExtractExportedTypeNames(string typeFileContent)

{

const string prefix = "export interface ";

var names = new List<string>();

foreach (var rawLine in typeFileContent.Split('\n'))

{

var line = rawLine.TrimStart();

if (!line.StartsWith(prefix, StringComparison.Ordinal))

{

continue;

}

var rest = line.Substring(prefix.Length);

var brace = rest.IndexOf('{');

var name = (brace >= 0 ? rest.Substring(0, brace) : rest).Trim();

if (name.Length > 0 && !names.Contains(name))

{

names.Add(name);

}

}

return names;

}

/// <summary>

/// Emit request/response (and composite) interfaces with the `export` keyword so they can be imported by other modules.

/// When false (default), interfaces are emitted as plain `interface` declarations (module-private when inline, ambient/global in the separate `.d.ts` file).

/// When true and CreateSeparateTypeFile is true, the separate type file becomes an importable module (`{name}Types.ts` with `export interface`) instead of an ambient `{name}Types.d.ts`, and the generated client file imports the named types from it.

/// Has no effect when SkipTypes is true.

/// </summary>

public bool ExportTypes { get; set; } = false;