@typespec/emitter-framework 0.13.0-dev.1 → 0.13.0-dev.2

package/src/csharp/components/json-converter/json-converter-resolver.test.tsx

@@ -0,0 +1,120 @@
+import { Tester } from "#test/test-host.js";
+import { code, For, List, namekey, type Children } from "@alloy-js/core";
+import { createCSharpNamePolicy, SourceFile } from "@alloy-js/csharp";
+import { t, type TesterInstance } from "@typespec/compiler/testing";
+import { $ } from "@typespec/compiler/typekit";
+import { beforeEach, expect, it } from "vitest";
+import { Output } from "../../../core/components/output.jsx";
+import { Property } from "../property/property.jsx";
+import {
+  createJsonConverterResolver,
+  JsonConverterResolver,
+  useJsonConverterResolver,
+  type JsonConverterResolverOptions,
+} from "./json-converter-resolver.jsx";
+import { JsonConverter } from "./json-converter.jsx";
+
+let tester: TesterInstance;
+
+beforeEach(async () => {
+  tester = await Tester.createInstance();
+});
+
+function Wrapper(props: { children: Children }) {
+  const policy = createCSharpNamePolicy();
+  return (
+    <Output program={tester.program} namePolicy={policy}>
+      <SourceFile path="test.cs">{props.children}</SourceFile>
+    </Output>
+  );
+}
+
+const fakeJsonConverterKey = namekey("FakeJsonConverter");
+function FakeJsonConverter() {
+  return (
+    <JsonConverter
+      name={fakeJsonConverterKey}
+      type={$(tester.program).builtin.string}
+      decodeAndReturn={(reader) => {
+        return code`return ${reader}.GetString();`;
+      }}
+      encodeAndWrite={(writer, value) => {
+        return code`${writer}.WriteStringValue(${value});`;
+      }}
+    />
+  );
+}
+
+function createTestJsonConverterResolver() {
+  const option: JsonConverterResolverOptions = {
+    customConverters: [
+      {
+        type: $(tester.program).builtin.string,
+        encodeData: {
+          type: $(tester.program).builtin.string,
+          encoding: "fake-change",
+        },
+        info: {
+          converter: FakeJsonConverter,
+          namekey: fakeJsonConverterKey,
+        },
+      },
+    ],
+  };
+  return createJsonConverterResolver(option);
+}
+
+it("No resolved converters", async () => {
+  await tester.compile(t.code``);
+  expect(
+    <Wrapper>
+      <JsonConverterResolver.Provider value={createTestJsonConverterResolver()}>
+        {code`Resolved JsonConverter: ${useJsonConverterResolver()?.listResolvedJsonConverters().length}`}
+      </JsonConverterResolver.Provider>
+    </Wrapper>,
+  ).toRenderTo(`Resolved JsonConverter: 0`);
+});
+
+it("Resolve custom converter", async () => {
+  const r = await tester.compile(t.code`
+    model BaseModel {
+      @encode("fake-change", string)
+      ${t.modelProperty("prop1")}: string;
+    }
+  `);
+
+  expect(
+    <Wrapper>
+      <JsonConverterResolver.Provider value={createTestJsonConverterResolver()}>
+        <List>
+          <Property type={r.prop1} jsonAttributes />
+          <br />
+          <For each={useJsonConverterResolver()?.listResolvedJsonConverters() ?? []}>
+            {(x) => <>{x.converter}</>}
+          </For>
+        </List>
+      </JsonConverterResolver.Provider>
+    </Wrapper>,
+  ).toRenderTo(`
+    using System;
+    using System.Text.Json;
+    using System.Text.Json.Serialization;
+
+    [JsonPropertyName("prop1")]
+    [JsonConverter(typeof(FakeJsonConverter))]
+    public required string Prop1 { get; set; }
+
+
+    internal sealed class FakeJsonConverter : JsonConverter<string>
+    {
+        public override string Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            return reader.GetString();
+        }
+
+        public override void Write(Utf8JsonWriter writer, string value, JsonSerializerOptions options)
+        {
+            writer.WriteStringValue(value);
+        }
+    }`);
+});

package/src/csharp/components/json-converter/json-converter-resolver.tsx

@@ -0,0 +1,117 @@
+import { useTsp } from "#core/index.js";
+import { createContext, namekey, useContext, type Children, type Namekey } from "@alloy-js/core";
+import {
+  getTypeName,
+  type DurationKnownEncoding,
+  type EncodeData,
+  type Type,
+} from "@typespec/compiler";
+import { capitalize } from "@typespec/compiler/casing";
+import { getNullableUnionInnerType } from "../utils/nullable-util.js";
+import { TimeSpanIso8601JsonConverter, TimeSpanSecondsJsonConverter } from "./json-converter.jsx";
+
+interface JsonConverterInfo {
+  namekey: Namekey;
+  converter: Children;
+}
+
+/**
+ * Help to resolve JsonConverter for a given type with encoding:
+ *   1. Avoid unnecessary duplicate JsonConverter declaration for the same type with same encoding.
+ *   2. Provide resolved JsonConverters to be generated centralized properly as needed.
+ * */
+export interface useJsonConverterResolver {
+  resolveJsonConverter: (type: Type, encodeData: EncodeData) => JsonConverterInfo | undefined;
+  listResolvedJsonConverters: () => JsonConverterInfo[];
+}
+
+export const JsonConverterResolver = createContext<useJsonConverterResolver>();
+
+export function useJsonConverterResolver(): useJsonConverterResolver | undefined {
+  return useContext(JsonConverterResolver);
+}
+
+export interface JsonConverterResolverOptions {
+  /** Custom JSON converters besides the built-in ones for known encode*/
+  customConverters?: { type: Type; encodeData: EncodeData; info: JsonConverterInfo }[];
+}
+
+export function createJsonConverterResolver(
+  options?: JsonConverterResolverOptions,
+): useJsonConverterResolver {
+  const resolvedConverters = new Map<string, JsonConverterInfo>();
+  const customConverters = new Map<string, JsonConverterInfo>();
+
+  if (options?.customConverters) {
+    for (const item of options.customConverters) {
+      const key = getJsonConverterKey(item.type, item.encodeData);
+      customConverters.set(key, item.info);
+    }
+  }
+
+  return {
+    resolveJsonConverter: (type: Type, encodeData: EncodeData) => {
+      const key = getJsonConverterKey(type, encodeData);
+      const found = resolvedConverters.get(key);
+      if (found) {
+        return found;
+      } else {
+        const resolved = customConverters.get(key) ?? resolveKnownJsonConverter(type, encodeData);
+        if (resolved) {
+          resolvedConverters.set(key, resolved);
+          return resolved;
+        }
+      }
+      return undefined;
+    },
+    listResolvedJsonConverters: () => Array.from(resolvedConverters.values()),
+  };
+
+  function getJsonConverterKey(type: Type, encodeData: EncodeData) {
+    return `type:${getTypeName(type)}-encoding:${encodeData.encoding}-encodeType:${getTypeName(encodeData.type)}`;
+  }
+
+  function resolveKnownJsonConverter(
+    type: Type,
+    encodeData: EncodeData,
+  ): JsonConverterInfo | undefined {
+    const ENCODING_DURATION_SECONDS: DurationKnownEncoding = "seconds";
+    const ENCODING_DURATION_ISO8601: DurationKnownEncoding = "ISO8601";
+    const { $ } = useTsp();
+    // Unwrap nullable because JsonConverter<T> would handle null by default for us.
+    const unwrappedType = type.kind === "Union" ? (getNullableUnionInnerType(type) ?? type) : type;
+    if (
+      unwrappedType === $.builtin.duration &&
+      encodeData.encoding === ENCODING_DURATION_SECONDS &&
+      [
+        $.builtin.int16,
+        $.builtin.uint16,
+        $.builtin.int32,
+        $.builtin.uint32,
+        $.builtin.int64,
+        $.builtin.uint64,
+        $.builtin.float32,
+        $.builtin.float64,
+      ].includes(encodeData.type)
+    ) {
+      const capitalizedTypeName = capitalize(encodeData.type.name);
+      const key: Namekey = namekey(`TimeSpanSeconds${capitalizedTypeName}JsonConverter`);
+      return {
+        namekey: key,
+        converter: <TimeSpanSecondsJsonConverter name={key} encodeType={encodeData.type} />,
+      };
+    } else if (
+      unwrappedType === $.builtin.duration &&
+      encodeData.encoding === ENCODING_DURATION_ISO8601
+    ) {
+      const key = namekey(`TimeSpanIso8601JsonConverter`);
+      return {
+        namekey: key,
+        converter: <TimeSpanIso8601JsonConverter name={key} />,
+      };
+    } else {
+      // TODO: support other known encodings
+      return undefined;
+    }
+  }
+}

package/src/csharp/components/json-converter/json-converter.test.tsx

@@ -0,0 +1,141 @@
+import { Tester } from "#test/test-host.js";
+import { code, namekey, type Children } from "@alloy-js/core";
+import { createCSharpNamePolicy, SourceFile } from "@alloy-js/csharp";
+import { t, type TesterInstance } from "@typespec/compiler/testing";
+import { $ } from "@typespec/compiler/typekit";
+import { beforeEach, describe, expect, it } from "vitest";
+import { Output } from "../../../core/components/output.jsx";
+import {
+  JsonConverter,
+  TimeSpanIso8601JsonConverter,
+  TimeSpanSecondsJsonConverter,
+} from "./json-converter.jsx";
+
+let tester: TesterInstance;
+
+beforeEach(async () => {
+  tester = await Tester.createInstance();
+});
+
+function Wrapper(props: { children: Children }) {
+  const policy = createCSharpNamePolicy();
+  return (
+    <Output program={tester.program} namePolicy={policy}>
+      <SourceFile path="test.cs">{props.children}</SourceFile>
+    </Output>
+  );
+}
+
+const fakeJsonConverterKey = namekey("FakeJsonConverter");
+function FakeJsonConverter() {
+  return (
+    <JsonConverter
+      name={fakeJsonConverterKey}
+      type={$(tester.program).builtin.string}
+      decodeAndReturn={(reader) => {
+        return code`return ${reader}.GetString();`;
+      }}
+      encodeAndWrite={(writer, value) => {
+        return code`${writer}.WriteStringValue(${value});`;
+      }}
+    />
+  );
+}
+
+it("Custom JsonConverter", async () => {
+  await tester.compile(t.code``);
+  expect(
+    <Wrapper>
+      <FakeJsonConverter />
+    </Wrapper>,
+  ).toRenderTo(`
+    using System;
+    using System.Text.Json;
+    using System.Text.Json.Serialization;
+
+    internal sealed class FakeJsonConverter : JsonConverter<string>
+    {
+        public override string Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            return reader.GetString();
+        }
+
+        public override void Write(Utf8JsonWriter writer, string value, JsonSerializerOptions options)
+        {
+            writer.WriteStringValue(value);
+        }
+    }`);
+});
+
+describe("Known JsonConverters", () => {
+  it("TimeSpanIso8601JsonConverter", async () => {
+    await tester.compile(t.code``);
+    expect(
+      <Wrapper>
+        <TimeSpanIso8601JsonConverter />
+      </Wrapper>,
+    ).toRenderTo(`
+      using System;
+      using System.Text.Json;
+      using System.Text.Json.Serialization;
+      using System.Xml;
+
+      internal sealed class TimeSpanIso8601JsonConverter : JsonConverter<TimeSpan>
+      {
+          public override TimeSpan Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+          {
+              var isoString = reader.GetString();
+              if( isoString == null)
+              {
+                  throw new FormatException("Invalid ISO8601 duration string: null");
+              }
+              return XmlConvert.ToTimeSpan(isoString);
+          }
+
+          public override void Write(Utf8JsonWriter writer, TimeSpan value, JsonSerializerOptions options)
+          {
+              writer.WriteStringValue(XmlConvert.ToString(value));
+          }
+      }
+  `);
+  });
+
+  describe.each([
+    ["int16", "(short)", "GetInt16"],
+    ["uint16", "(ushort)", "GetUInt16"],
+    ["int32", "(int)", "GetInt32"],
+    ["uint32", "(uint)", "GetUInt32"],
+    ["int64", "(long)", "GetInt64"],
+    ["uint64", "(ulong)", "GetUInt64"],
+    ["float32", "(float)", "GetSingle"],
+    ["float64", "", "GetDouble"],
+  ] as const)("%s", (typeName, jsonWriteType, jsonReaderMethod) => {
+    it("TimeSpanSecondsJsonConverter", async () => {
+      await tester.compile(t.code``);
+      const type = $(tester.program).builtin[typeName];
+      expect(
+        <Wrapper>
+          <TimeSpanSecondsJsonConverter encodeType={type} />
+        </Wrapper>,
+      ).toRenderTo(`
+      using System;
+      using System.Text.Json;
+      using System.Text.Json.Serialization;
+
+      internal sealed class TimeSpanSeconds${typeName.charAt(0).toUpperCase() + typeName.slice(1)}JsonConverter : JsonConverter<TimeSpan>
+      {
+          public override TimeSpan Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+          {
+              var seconds = reader.${jsonReaderMethod}();
+              return TimeSpan.FromSeconds(seconds);
+          }
+
+          public override void Write(Utf8JsonWriter writer, TimeSpan value, JsonSerializerOptions options)
+          {
+              writer.WriteNumberValue(${jsonWriteType}value.TotalSeconds);
+          }
+      }
+  `);
+    });
+  });
+});

package/src/csharp/components/json-converter/json-converter.tsx

@@ -0,0 +1,146 @@
+import { useTsp } from "#core/index.js";
+import { code, List, namekey, type Namekey, type Refkey } from "@alloy-js/core";
+import type { Children } from "@alloy-js/core/jsx-runtime";
+import { ClassDeclaration, Method } from "@alloy-js/csharp";
+import System, { Xml } from "@alloy-js/csharp/global/System";
+import Json, { Serialization } from "@alloy-js/csharp/global/System/Text/Json";
+import { type Type } from "@typespec/compiler";
+import { capitalize } from "@typespec/compiler/casing";
+import { TypeExpression } from "../type-expression.jsx";
+
+interface JsonConverterProps {
+  name: string | Namekey;
+  type: Type;
+  refkey?: Refkey;
+  /** Decode and return value from reader*/
+  decodeAndReturn: (reader: Namekey, typeToConvert: Namekey, options: Namekey) => Children;
+  /** Encode the given value and send to writer*/
+  encodeAndWrite: (writer: Namekey, value: Namekey, options: Namekey) => Children;
+}
+
+/**
+ * Generate a Json converter class inheriting System.Text.Json.Serialization.JsonConverter<T> which can be used by System.Text.Json.Serialization.JsonConverterAttribute to provide custom serialization.
+ * @see https://learn.microsoft.com/en-us/dotnet/standard/serialization/system-text-json/converters-how-to#steps-to-follow-the-basic-pattern
+ */
+export function JsonConverter(props: JsonConverterProps) {
+  const readParamReader: Namekey = namekey("reader");
+  const readParamTypeToConvert: Namekey = namekey("typeToConvert");
+  const readParamOptions: Namekey = namekey("options");
+  const writeParamWriter: Namekey = namekey("writer");
+  const writeParamValue: Namekey = namekey("value");
+  const writeParamOptions: Namekey = namekey("options");
+  const propTypeExpression = code`${(<TypeExpression type={props.type} />)}`;
+  return (
+    <ClassDeclaration
+      refkey={props.refkey}
+      sealed
+      internal
+      name={props.name}
+      baseType={code`${Serialization.JsonConverter}<${propTypeExpression}>`}
+    >
+      <List doubleHardline>
+        <Method
+          name={"Read"}
+          public
+          override
+          parameters={[
+            {
+              name: readParamReader,
+              ref: true,
+              type: code`${Json.Utf8JsonReader}`,
+            },
+            { name: readParamTypeToConvert, type: code`${System.Type}` },
+            {
+              name: readParamOptions,
+              type: code`${Json.JsonSerializerOptions}`,
+            },
+          ]}
+          returns={propTypeExpression}
+        >
+          {code`${props.decodeAndReturn(readParamReader, readParamTypeToConvert, readParamOptions)}`}
+        </Method>
+        <Method
+          name={"Write"}
+          public
+          override
+          parameters={[
+            { name: writeParamWriter, type: code`${Json.Utf8JsonWriter}` },
+            {
+              name: writeParamValue,
+              type: propTypeExpression,
+            },
+            {
+              name: writeParamOptions,
+              type: code`${Json.JsonSerializerOptions}`,
+            },
+          ]}
+        >
+          {code`${props.encodeAndWrite(writeParamWriter, writeParamValue, writeParamOptions)}`}
+        </Method>
+      </List>
+    </ClassDeclaration>
+  );
+}
+
+export function TimeSpanSecondsJsonConverter(props: {
+  name?: string | Namekey;
+  refkey?: Refkey;
+  encodeType: Type;
+}) {
+  const { $ } = useTsp();
+  const map: Map<Type, { jsonWriteType: string; jsonReaderMethod: string }> = new Map([
+    [$.builtin.int16, { jsonWriteType: "short", jsonReaderMethod: "GetInt16" }],
+    [$.builtin.uint16, { jsonWriteType: "ushort", jsonReaderMethod: "GetUInt16" }],
+    [$.builtin.int32, { jsonWriteType: "int", jsonReaderMethod: "GetInt32" }],
+    [$.builtin.uint32, { jsonWriteType: "uint", jsonReaderMethod: "GetUInt32" }],
+    [$.builtin.int64, { jsonWriteType: "long", jsonReaderMethod: "GetInt64" }],
+    [$.builtin.uint64, { jsonWriteType: "ulong", jsonReaderMethod: "GetUInt64" }],
+    [$.builtin.float32, { jsonWriteType: "float", jsonReaderMethod: "GetSingle" }],
+    [$.builtin.float64, { jsonWriteType: "double", jsonReaderMethod: "GetDouble" }],
+  ]);
+  if (props.encodeType.kind !== "Scalar" || !map.has(props.encodeType)) {
+    throw new Error(
+      `TimeSpanSecondsJsonConverter only supports encodeType of int16, uint16, int32, uint32, int64, uint64, float32, or float64. Received: kind = ${props.encodeType.kind} ${props.encodeType.kind === "Scalar" ? `name = ${props.encodeType.name}` : ""}`,
+    );
+  }
+  const found = map.get(props.encodeType)!;
+  const capitalizedTypeName = capitalize(props.encodeType.name);
+  const defaultName = `TimeSpanSeconds${capitalizedTypeName}JsonConverter`;
+
+  return (
+    <JsonConverter
+      refkey={props.refkey}
+      name={props.name ?? namekey(defaultName)}
+      type={$.builtin.duration}
+      decodeAndReturn={(reader) => {
+        return code`var seconds = ${reader}.${found.jsonReaderMethod}();
+                    return ${System.TimeSpan}.FromSeconds(seconds);`;
+      }}
+      encodeAndWrite={(writer, value) => {
+        return code`${writer}.WriteNumberValue(${found.jsonWriteType === "double" || `(${found.jsonWriteType})`}${value}.TotalSeconds);`;
+      }}
+    />
+  );
+}
+
+export function TimeSpanIso8601JsonConverter(props: { name?: string | Namekey; refkey?: Refkey }) {
+  const { $ } = useTsp();
+  return (
+    <JsonConverter
+      refkey={props.refkey}
+      name={props.name ?? namekey("TimeSpanIso8601JsonConverter")}
+      type={$.builtin.duration}
+      decodeAndReturn={(reader) => {
+        return code`var isoString = ${reader}.GetString();
+                    if( isoString == null) 
+                    {
+                      throw new ${System.FormatException}("Invalid ISO8601 duration string: null");
+                    }
+                    return ${Xml.XmlConvert}.ToTimeSpan(isoString);`;
+      }}
+      encodeAndWrite={(writer, value) => {
+        return code`${writer}.WriteStringValue(${Xml.XmlConvert}.ToString(${value}));`;
+      }}
+    />
+  );
+}

package/src/csharp/components/property/property.test.tsx

@@ -1,9 +1,14 @@
 import { Tester } from "#test/test-host.js";
-import { List, type Children } from "@alloy-js/core";
+import { For, List, type Children } from "@alloy-js/core";
 import { ClassDeclaration, createCSharpNamePolicy, SourceFile } from "@alloy-js/csharp";
 import { t, type TesterInstance } from "@typespec/compiler/testing";
 import { beforeEach, describe, expect, it } from "vitest";
 import { Output } from "../../../core/components/output.jsx";
+import {
+  createJsonConverterResolver,
+  JsonConverterResolver,
+  useJsonConverterResolver,
+} from "../json-converter/json-converter-resolver.jsx";
 import { Property } from "./property.jsx";
 
 let tester: TesterInstance;
@@ -93,9 +98,11 @@ describe("jsonAttributes", () => {
         <Property type={prop1} jsonAttributes />
       </Wrapper>,
     ).toRenderTo(`
+      using System.Text.Json.Serialization;
+
       class Test
       {
-          [System.Text.Json.JsonPropertyName("prop1")]
+          [JsonPropertyName("prop1")]
           public required string Prop1 { get; set; }
       }
   `);
@@ -114,11 +121,13 @@ describe("jsonAttributes", () => {
         <Property type={prop1} jsonAttributes />
       </Wrapper>,
     ).toRenderTo(`
-        class Test
-        {
-            [System.Text.Json.JsonPropertyName("prop_1")]
-            public required string Prop1 { get; set; }
-        }
+      using System.Text.Json.Serialization;
+
+      class Test
+      {
+          [JsonPropertyName("prop_1")]
+          public required string Prop1 { get; set; }
+      }
   `);
   });
 
@@ -177,4 +186,99 @@ describe("jsonAttributes", () => {
       }
     `);
   });
+
+  it("json converter: duration -> seconds(int32)", async () => {
+    const r = await tester.compile(t.code`
+      model BaseModel {
+        @encode(DurationKnownEncoding.seconds, int32)
+        ${t.modelProperty("prop1")}?: duration;
+        @encode(DurationKnownEncoding.seconds, float64)
+        ${t.modelProperty("prop2")}: duration;
+        @encode(DurationKnownEncoding.ISO8601, string)
+        ${t.modelProperty("prop3")}: duration;
+      }
+    `);
+
+    expect(
+      <Wrapper>
+        <JsonConverterResolver.Provider value={createJsonConverterResolver()}>
+          <List>
+            <Property type={r.prop1} jsonAttributes />
+            <Property type={r.prop2} jsonAttributes />
+            <Property type={r.prop3} jsonAttributes />
+            <hbr />
+            // JsonConverter wont work as nested class, but good enough for test to verify the
+            generated code.
+            <For each={useJsonConverterResolver()?.listResolvedJsonConverters() ?? []}>
+              {(x) => <>{x.converter}</>}
+            </For>
+          </List>
+        </JsonConverterResolver.Provider>
+      </Wrapper>,
+    ).toRenderTo(`
+      using System;
+      using System.Text.Json;
+      using System.Text.Json.Serialization;
+      using System.Xml;
+
+      class Test
+      {
+          [JsonPropertyName("prop1")]
+          [JsonConverter(typeof(TimeSpanSecondsInt32JsonConverter))]
+          public TimeSpan? Prop1 { get; set; }
+          [JsonPropertyName("prop2")]
+          [JsonConverter(typeof(TimeSpanSecondsFloat64JsonConverter))]
+          public required TimeSpan Prop2 { get; set; }
+          [JsonPropertyName("prop3")]
+          [JsonConverter(typeof(TimeSpanIso8601JsonConverter))]
+          public required TimeSpan Prop3 { get; set; }
+
+
+          // JsonConverter wont work as nested class, but good enough for test to verify the generated code.
+          internal sealed class TimeSpanSecondsInt32JsonConverter : JsonConverter<TimeSpan>
+          {
+              public override TimeSpan Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+              {
+                  var seconds = reader.GetInt32();
+                  return TimeSpan.FromSeconds(seconds);
+              }
+
+              public override void Write(Utf8JsonWriter writer, TimeSpan value, JsonSerializerOptions options)
+              {
+                  writer.WriteNumberValue((int)value.TotalSeconds);
+              }
+          }
+          internal sealed class TimeSpanSecondsFloat64JsonConverter : JsonConverter<TimeSpan>
+          {
+              public override TimeSpan Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+              {
+                  var seconds = reader.GetDouble();
+                  return TimeSpan.FromSeconds(seconds);
+              }
+
+              public override void Write(Utf8JsonWriter writer, TimeSpan value, JsonSerializerOptions options)
+              {
+                  writer.WriteNumberValue(value.TotalSeconds);
+              }
+          }
+          internal sealed class TimeSpanIso8601JsonConverter : JsonConverter<TimeSpan>
+          {
+              public override TimeSpan Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+              {
+                  var isoString = reader.GetString();
+                  if( isoString == null)
+                  {
+                      throw new FormatException("Invalid ISO8601 duration string: null");
+                  }
+                  return XmlConvert.ToTimeSpan(isoString);
+              }
+
+              public override void Write(Utf8JsonWriter writer, TimeSpan value, JsonSerializerOptions options)
+              {
+                  writer.WriteStringValue(XmlConvert.ToString(value));
+              }
+          }
+      }
+    `);
+  });
 });