@contractkit/plugin-csharp 0.1.5 → 0.2.0

package/dist/index.js

@@ -189,6 +189,7 @@ function generateCSharpModels(root, opts) {
   const modelIndex = opts.modelIndex ?? buildModelIndex(root.models);
   const ctx = {
     namespace: opts.namespace,
+    dateTypes: opts.dateTypes ?? "dateonly",
     modelsWithInput,
     modelIndex,
     hoisted: opts.hoisted,
@@ -202,7 +203,7 @@ function generateCSharpModels(root, opts) {
   };
   for (const model of topoSortModels(root.models)) append(generateModel(model, ctx));
   for (const decl of opts.hoisted?.byFile.get(root.file) ?? []) append(generateHoisted(decl, ctx));
-  return renderFile(`${opts.namespace}.Models`, ctx.globalAliases, [...MODEL_USINGS], bodies);
+  return renderFile(`${opts.namespace}.Models`, ctx.globalAliases, [...MODEL_USINGS, `using ${opts.namespace}.Runtime;`], bodies);
 }
 function resolveModelsWithInput(models, external = /* @__PURE__ */ new Set()) {
   const seed = new Set(external);
@@ -211,6 +212,7 @@ function resolveModelsWithInput(models, external = /* @__PURE__ */ new Set()) {
 function createRenderContext(opts) {
   return {
     namespace: opts.namespace,
+    dateTypes: opts.dateTypes ?? "dateonly",
     modelsWithInput: opts.modelsWithInput,
     modelIndex: opts.modelIndex ?? /* @__PURE__ */ new Map(),
     hoisted: opts.hoisted,
@@ -310,8 +312,9 @@ function renderScalar(name, ctx) {
       return qualify("decimal", "System.Decimal", ctx);
     case "boolean":
       return qualify("bool", "System.Boolean", ctx);
+    // Both carried as the wire form by a converter: `yyyy-MM-dd` and `HH:mm:ss`.
     case "date":
-      return qualify("DateOnly", "System.DateOnly", ctx);
+      return ctx.dateTypes === "datetime" ? qualify("DateTime", "System.DateTime", ctx) : qualify("DateOnly", "System.DateOnly", ctx);
     case "time":
       return qualify("TimeOnly", "System.TimeOnly", ctx);
     case "datetime":
@@ -506,8 +509,25 @@ function addAlias(name, type, ctx, forInput) {
       `Contract '${name}' aliases a nullable type, which C# cannot express as a using alias; '${name}' is generated as '${aliased}'. Declare the nullability at each use site instead.`
     );
   }
+  const polyfilled = polyfillAliasTarget(aliased, ctx);
+  if (polyfilled) {
+    ctx.globalAliases.push(`#if NETSTANDARD2_0
+global using ${name} = ${polyfilled};
+#else
+global using ${name} = ${aliased};
+#endif`);
+    return;
+  }
   ctx.globalAliases.push(`global using ${name} = ${aliased};`);
 }
+var POLYFILLED_TYPES = ["System.DateOnly", "System.TimeOnly"];
+function polyfillAliasTarget(target, ctx) {
+  let out = target;
+  for (const full of POLYFILLED_TYPES) {
+    out = out.split(full).join(`${ctx.namespace}.Runtime.${full.slice("System.".length)}`);
+  }
+  return out === target ? void 0 : out;
+}
 function isNullableValueType(type, ctx) {
   const inner = type.kind === "lazy" ? type.inner : type;
   if (inner.kind !== "union") return false;
@@ -524,6 +544,7 @@ var VALUE_TYPES = /* @__PURE__ */ new Set([
   "BigInteger",
   "DateOnly",
   "TimeOnly",
+  "DateTime",
   "DateTimeOffset",
   "TimeSpan",
   "Guid",
@@ -927,7 +948,7 @@ function generateMethod(route, op, ctx, methodName) {
   if (resolveModifiers(route, op).includes("deprecated")) lines.push('[Obsolete("Deprecated in the contract")]');
   lines.push(`public async ${returnType === "void" ? "Task" : `Task<${returnType}>`} ${methodName}(${signature})`);
   lines.push("{");
-  const callArgs = [`HttpMethod.${httpMethodConstant(op.method)}`, buildPathExpression(route.path, route.params, pathBindings)];
+  const callArgs = [httpMethodExpression(op.method), buildPathExpression(route.path, route.params, pathBindings)];
   if (op.query) callArgs.push("query: http.Params(query)");
   if (op.headers) callArgs.push("headers: http.Params(customHeaders)");
   const content = bodyArgument(op);
@@ -1066,7 +1087,7 @@ function responseDeclarations(route, op, ctx) {
   const lines = [];
   const headerRecord = (headers, name) => {
     const parameters = headers.map((header) => {
-      const reader = headerReader(header, place);
+      const reader = headerReader(header, place, ctx.dateTypes);
       const type = header.optional ? `${reader.type}?` : reader.type;
       return `${type} ${safeMemberName(toCSharpPropertyName(header.name), name)}`;
     }).join(", ");
@@ -1121,7 +1142,7 @@ function responseDeclarations(route, op, ctx) {
   lines.push("}");
   return lines;
 }
-function headerReader(header, place) {
+function headerReader(header, place, dateTypes) {
   const scalar = header.type.kind === "scalar" ? header.type.name : void 0;
   switch (scalar) {
     case "string":
@@ -1141,7 +1162,7 @@ function headerReader(header, place) {
     case "uuid":
       return { type: "Guid", read: (raw) => `Guid.Parse(${raw})` };
     case "date":
-      return { type: "DateOnly", read: (raw) => `DateOnly.Parse(${raw}, CultureInfo.InvariantCulture)` };
+      return dateTypes === "datetime" ? { type: "DateTime", read: (raw) => `DateTime.Parse(${raw}, CultureInfo.InvariantCulture)` } : { type: "DateOnly", read: (raw) => `DateOnly.Parse(${raw}, CultureInfo.InvariantCulture)` };
     case "time":
       return { type: "TimeOnly", read: (raw) => `TimeOnly.Parse(${raw}, CultureInfo.InvariantCulture)` };
     case "datetime":
@@ -1165,7 +1186,7 @@ function readHeaderLines(headers, typeName, ctx, place, indent, bound) {
     bound
   );
   const args = headers.map((header) => {
-    const reader = headerReader(header, place);
+    const reader = headerReader(header, place, ctx.dateTypes);
     const name = quoteCSharpString(header.name);
     if (!header.optional) return reader.read(`http.RequireHeader(response, ${name})`);
     const local = locals.get(header.name);
@@ -1186,9 +1207,10 @@ function methodDoc(route, op, observable) {
   if (thrown.length > 0) lines.push(`/// <exception cref="SdkException">On ${thrown.join(", ")}.</exception>`);
   return lines;
 }
-function httpMethodConstant(method) {
+function httpMethodExpression(method) {
   const lower = method.toLowerCase();
-  return lower.charAt(0).toUpperCase() + lower.slice(1);
+  if (lower === "patch") return "SdkHttp.Patch";
+  return `HttpMethod.${lower.charAt(0).toUpperCase()}${lower.slice(1)}`;
 }
 var PATH_PLACEHOLDER = /\{([a-zA-Z_$][a-zA-Z0-9_$.-]*)\}/g;
 function buildPathExpression(path, params, bindings) {
@@ -1624,7 +1646,13 @@ public sealed class SdkOptions
 public class SdkException : HttpRequestException
 {
     public SdkException(int status, string body, HttpResponseHeaders? responseHeaders = null, string? message = null)
+#if NETSTANDARD2_0
+        // .NET Standard 2.0's HttpRequestException carries no status of its own. Status below does,
+        // so nothing is lost but the base type's own StatusCode property.
+        : base(message ?? $"Request failed with status {status}")
+#else
         : base(message ?? $"Request failed with status {status}", null, ToStatusCode(status))
+#endif
     {
         Status = status;
         Body = body;
@@ -1683,8 +1711,10 @@ public class SdkException : HttpRequestException
         }
     }
 
+#if !NETSTANDARD2_0
     private static HttpStatusCode? ToStatusCode(int status) =>
         status is >= 100 and <= 599 ? (HttpStatusCode)status : null;
+#endif
 }
 
 /// <summary>
@@ -1772,6 +1802,16 @@ public sealed class SdkHttp : IDisposable
 
     public JsonSerializerOptions Json { get; }
 
+    /// <summary>
+    /// The PATCH verb.
+    /// </summary>
+    /// <remarks>
+    /// <c>HttpMethod</c> carries a static for every other verb a contract can declare, but not for
+    /// this one on every framework the SDK builds against, so it is spelled once here rather than
+    /// allocated per call.
+    /// </remarks>
+    public static readonly HttpMethod Patch = new HttpMethod("PATCH");
+
     /// <summary>
     /// Send one request and read its body.
     /// </summary>
@@ -1810,7 +1850,13 @@ public sealed class SdkHttp : IDisposable
         }
 
         var message = await Client.SendAsync(request, HttpCompletionOption.ResponseContentRead, cancellationToken).ConfigureAwait(false);
+#if NETSTANDARD2_0
+        // The cancellable overload arrived in .NET 5. ResponseContentRead above has already buffered
+        // the body, so this read is a copy rather than a wait on the network.
+        var bytes = await message.Content.ReadAsByteArrayAsync().ConfigureAwait(false);
+#else
         var bytes = await message.Content.ReadAsByteArrayAsync(cancellationToken).ConfigureAwait(false);
+#endif
         var response = new SdkResponse(message, bytes);
 
         var status = response.Status;
@@ -1943,7 +1989,78 @@ public sealed class SdkHttp : IDisposable
 }
 
 // src/runtime-converters.ts
-function generateConvertersCs(namespaceName) {
+var ISO_DATE_CONVERTER = `/// <summary>
+/// A calendar date, as <c>yyyy-MM-dd</c>, carried in the date part of a <c>DateTime</c>.
+/// </summary>
+/// <remarks>
+/// The time is midnight and the kind is unspecified: a contract's <c>date</c> names neither, and
+/// pretending to either would put a zone offset on the wire.
+/// </remarks>
+public sealed class IsoDateConverter : JsonConverter<DateTime>
+{
+    public override DateTime Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        if (reader.TokenType != JsonTokenType.String)
+        {
+            throw new JsonException($"Expected a date string, got {reader.TokenType}.");
+        }
+
+        var text = reader.GetString() ?? throw new JsonException("Expected a date string.");
+        if (DateTime.TryParseExact(text, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None, out var exact))
+        {
+            return exact;
+        }
+
+        // A service sending more than the contract promised is read for the part it promised.
+        if (DateTime.TryParse(text, CultureInfo.InvariantCulture, DateTimeStyles.None, out var parsed))
+        {
+            return parsed.Date;
+        }
+
+        throw new JsonException($"'{text}' is not a date.");
+    }
+
+    public override void Write(Utf8JsonWriter writer, DateTime value, JsonSerializerOptions options)
+    {
+        writer.WriteStringValue(value.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture));
+    }
+}
+
+`;
+var DATE_ONLY_CONVERTER = `
+/// <summary>
+/// A calendar date, as <c>yyyy-MM-dd</c>.
+/// </summary>
+/// <remarks>
+/// Compiled only where <c>DateOnly</c> is the SDK's own polyfill. The wire form is the one the
+/// framework's converter writes on net10.0, so a service reads a body from either leg of the build.
+/// </remarks>
+public sealed class DateOnlyConverter : JsonConverter<DateOnly>
+{
+    public override DateOnly Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        if (reader.TokenType != JsonTokenType.String)
+        {
+            throw new JsonException($"Expected a date string, got {reader.TokenType}.");
+        }
+
+        var text = reader.GetString() ?? throw new JsonException("Expected a date string.");
+        if (!DateOnly.TryParse(text, CultureInfo.InvariantCulture, out var value))
+        {
+            throw new JsonException($"'{text}' is not a date.");
+        }
+
+        return value;
+    }
+
+    public override void Write(Utf8JsonWriter writer, DateOnly value, JsonSerializerOptions options)
+    {
+        writer.WriteStringValue(value.ToString());
+    }
+}
+`;
+function generateConvertersCs(namespaceName, dateTypes = "dateonly") {
+  const asDateTime = dateTypes === "datetime";
   return `// <auto-generated/>
 // Generated by @contractkit/plugin-csharp. Do not edit manually.
 #nullable enable
@@ -1977,6 +2094,11 @@ public static class SdkJson
         options.Converters.Add(new BigIntegerConverter());
         options.Converters.Add(new DecimalStringConverter());
         options.Converters.Add(new IsoTimeSpanConverter());
+${asDateTime ? "        options.Converters.Add(new IsoDateConverter());\n" : ""}#if NETSTANDARD2_0
+        // These are the SDK's own types on this framework, so System.Text.Json has no built-in
+        // converter for them. On net10.0 the framework handles them and these are not compiled.
+${asDateTime ? "" : "        options.Converters.Add(new DateOnlyConverter());\n"}        options.Converters.Add(new TimeOnlyConverter());
+#endif
         return options;
     }
 }
@@ -2001,8 +2123,9 @@ public sealed class BigIntegerConverter : JsonConverter<BigInteger>
         if (reader.TokenType == JsonTokenType.Number)
         {
             // Read the raw token rather than a long: the value may be wider than any BCL integer,
-            // which is the whole reason the contract called it a bigint.
-            var raw = Encoding.UTF8.GetString(reader.HasValueSequence ? reader.ValueSequence.ToArray() : reader.ValueSpan);
+            // which is the whole reason the contract called it a bigint. Copied to an array rather
+            // than handed to the span overload of GetString, which netstandard2.0 does not have.
+            var raw = Encoding.UTF8.GetString(reader.HasValueSequence ? reader.ValueSequence.ToArray() : reader.ValueSpan.ToArray());
             return BigInteger.Parse(raw, NumberStyles.Integer, CultureInfo.InvariantCulture);
         }
 
@@ -2074,35 +2197,422 @@ public sealed class IsoTimeSpanConverter : JsonConverter<TimeSpan>
         writer.WriteStringValue(XmlConvert.ToString(value));
     }
 }
+
+${asDateTime ? ISO_DATE_CONVERTER : ""}#if NETSTANDARD2_0
+${asDateTime ? "" : DATE_ONLY_CONVERTER}
+/// <summary>
+/// A time of day, as <c>HH:mm:ss</c>, with a seven-digit fraction when there is one.
+/// </summary>
+/// <remarks>
+/// Compiled only where <c>TimeOnly</c> is the SDK's own polyfill, and writing what the framework's
+/// own converter writes on net10.0, so a service reads a body from either leg of the build.
+/// </remarks>
+public sealed class TimeOnlyConverter : JsonConverter<TimeOnly>
+{
+    public override TimeOnly Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        if (reader.TokenType != JsonTokenType.String)
+        {
+            throw new JsonException($"Expected a time-of-day string, got {reader.TokenType}.");
+        }
+
+        var text = reader.GetString() ?? throw new JsonException("Expected a time-of-day string.");
+        if (!TimeOnly.TryParse(text, CultureInfo.InvariantCulture, out var value))
+        {
+            throw new JsonException($"'{text}' is not a time of day.");
+        }
+
+        return value;
+    }
+
+    public override void Write(Utf8JsonWriter writer, TimeOnly value, JsonSerializerOptions options)
+    {
+        writer.WriteStringValue(value.ToString());
+    }
+}
+
+#endif
+`;
+}
+
+// src/runtime-polyfills.ts
+function generatePolyfillsCs(namespaceName) {
+  return `// <auto-generated/>
+// Generated by @contractkit/plugin-csharp. Do not edit manually.
+#nullable enable
+
+#if NETSTANDARD2_0
+
+using System;
+using System.Globalization;
+
+namespace System.Runtime.CompilerServices
+{
+    /// <summary>
+    /// The marker the compiler requires before it will emit an <c>init</c> accessor.
+    /// </summary>
+    internal static class IsExternalInit
+    {
+    }
+
+    /// <summary>
+    /// Marks a member whose initialization the compiler requires at every construction site.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = false, Inherited = false)]
+    internal sealed class RequiredMemberAttribute : Attribute
+    {
+    }
+
+    /// <summary>
+    /// Names a compiler feature a member depends on, so a compiler that does not have it refuses the
+    /// member rather than misreading it.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.All, AllowMultiple = true, Inherited = false)]
+    internal sealed class CompilerFeatureRequiredAttribute : Attribute
+    {
+        public CompilerFeatureRequiredAttribute(string featureName)
+        {
+            FeatureName = featureName;
+        }
+
+        public string FeatureName { get; }
+
+        public bool IsOptional { get; init; }
+
+        public const string RefStructs = nameof(RefStructs);
+
+        public const string RequiredMembers = nameof(RequiredMembers);
+    }
+}
+
+namespace System.Diagnostics.CodeAnalysis
+{
+    /// <summary>
+    /// Marks a constructor that sets every required member itself.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Constructor, AllowMultiple = false, Inherited = false)]
+    internal sealed class SetsRequiredMembersAttribute : Attribute
+    {
+    }
+}
+
+namespace ${namespaceName}.Runtime
+{
+    /// <summary>
+    /// A calendar date with no time and no offset. Stands in for <c>System.DateOnly</c>.
+    /// </summary>
+    /// <remarks>
+    /// Carries what a generated SDK and the code around it need: construction, ordering, conversion
+    /// to and from <see cref="DateTime"/>, and the <c>yyyy-MM-dd</c> form a contract's <c>date</c>
+    /// travels as. Not a complete reimplementation of the framework type.
+    /// </remarks>
+    public readonly struct DateOnly : IEquatable<DateOnly>, IComparable<DateOnly>, IComparable
+    {
+        private readonly DateTime _value;
+
+        public DateOnly(int year, int month, int day)
+        {
+            _value = new DateTime(year, month, day);
+        }
+
+        private DateOnly(DateTime value)
+        {
+            _value = value.Date;
+        }
+
+        public static DateOnly MinValue => new DateOnly(DateTime.MinValue);
+
+        public static DateOnly MaxValue => new DateOnly(DateTime.MaxValue);
+
+        public int Year => _value.Year;
+
+        public int Month => _value.Month;
+
+        public int Day => _value.Day;
+
+        public int DayOfYear => _value.DayOfYear;
+
+        public DayOfWeek DayOfWeek => _value.DayOfWeek;
+
+        /// <summary>The date part of <paramref name="value"/>, dropping its time and kind.</summary>
+        public static DateOnly FromDateTime(DateTime value) => new DateOnly(value);
+
+        /// <summary>This date at midnight, with an unspecified kind. What a XAML date picker binds to.</summary>
+        public DateTime ToDateTime() => _value;
+
+        /// <summary>This date at <paramref name="time"/>, with an unspecified kind.</summary>
+        public DateTime ToDateTime(TimeOnly time) => _value.Add(time.ToTimeSpan());
+
+        public DateOnly AddDays(int value) => new DateOnly(_value.AddDays(value));
+
+        public DateOnly AddMonths(int value) => new DateOnly(_value.AddMonths(value));
+
+        public DateOnly AddYears(int value) => new DateOnly(_value.AddYears(value));
+
+        public static DateOnly Parse(string s) => Parse(s, CultureInfo.InvariantCulture);
+
+        /// <exception cref="FormatException">When <paramref name="s"/> is not a date.</exception>
+        public static DateOnly Parse(string s, IFormatProvider? provider)
+        {
+            if (!TryParse(s, provider, out var result))
+            {
+                throw new FormatException("'" + s + "' is not a date.");
+            }
+
+            return result;
+        }
+
+        public static bool TryParse(string? s, out DateOnly result) => TryParse(s, CultureInfo.InvariantCulture, out result);
+
+        /// <remarks>
+        /// The wire form is tried first and exactly; anything else the culture reads as a date is
+        /// then taken by its date part, which is what the framework type does too.
+        /// </remarks>
+        public static bool TryParse(string? s, IFormatProvider? provider, out DateOnly result)
+        {
+            var culture = provider ?? CultureInfo.InvariantCulture;
+            if (DateTime.TryParseExact(s, "yyyy-MM-dd", culture, DateTimeStyles.None, out var exact))
+            {
+                result = new DateOnly(exact);
+                return true;
+            }
+
+            if (DateTime.TryParse(s, culture, DateTimeStyles.None, out var parsed))
+            {
+                result = new DateOnly(parsed);
+                return true;
+            }
+
+            result = default;
+            return false;
+        }
+
+        /// <summary>The ISO 8601 form, <c>yyyy-MM-dd</c>. Also how the date travels on the wire.</summary>
+        public override string ToString() => _value.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture);
+
+        public string ToString(string? format) => _value.ToString(format, CultureInfo.InvariantCulture);
+
+        public string ToString(string? format, IFormatProvider? provider) => _value.ToString(format, provider);
+
+        public bool Equals(DateOnly other) => _value == other._value;
+
+        public override bool Equals(object? obj) => obj is DateOnly other && Equals(other);
+
+        public override int GetHashCode() => _value.GetHashCode();
+
+        public int CompareTo(DateOnly other) => _value.CompareTo(other._value);
+
+        public int CompareTo(object? obj)
+        {
+            if (obj is null) return 1;
+            if (obj is DateOnly other) return CompareTo(other);
+            throw new ArgumentException("Object must be of type DateOnly.", nameof(obj));
+        }
+
+        public static bool operator ==(DateOnly left, DateOnly right) => left.Equals(right);
+
+        public static bool operator !=(DateOnly left, DateOnly right) => !left.Equals(right);
+
+        public static bool operator <(DateOnly left, DateOnly right) => left.CompareTo(right) < 0;
+
+        public static bool operator <=(DateOnly left, DateOnly right) => left.CompareTo(right) <= 0;
+
+        public static bool operator >(DateOnly left, DateOnly right) => left.CompareTo(right) > 0;
+
+        public static bool operator >=(DateOnly left, DateOnly right) => left.CompareTo(right) >= 0;
+    }
+
+    /// <summary>
+    /// A time of day with no date and no offset. Stands in for <c>System.TimeOnly</c>.
+    /// </summary>
+    /// <remarks>
+    /// At least zero and less than 24 hours, which is what separates it from the
+    /// <see cref="TimeSpan"/> a contract's <c>duration</c> maps to.
+    /// </remarks>
+    public readonly struct TimeOnly : IEquatable<TimeOnly>, IComparable<TimeOnly>, IComparable
+    {
+        private static readonly TimeSpan OneDay = TimeSpan.FromDays(1);
+
+        /// <summary>Accepted on the way in: the wire form, with or without a fraction, and <c>HH:mm</c>.</summary>
+        private static readonly string[] Formats = { "HH:mm:ss.FFFFFFF", "HH:mm" };
+
+        private readonly TimeSpan _value;
+
+        public TimeOnly(int hour, int minute)
+            : this(new TimeSpan(hour, minute, 0))
+        {
+        }
+
+        public TimeOnly(int hour, int minute, int second)
+            : this(new TimeSpan(hour, minute, second))
+        {
+        }
+
+        public TimeOnly(int hour, int minute, int second, int millisecond)
+            : this(new TimeSpan(0, hour, minute, second, millisecond))
+        {
+        }
+
+        private TimeOnly(TimeSpan value)
+        {
+            if (value < TimeSpan.Zero || value >= OneDay)
+            {
+                throw new ArgumentOutOfRangeException(nameof(value), "A time of day is at least zero and less than 24 hours.");
+            }
+
+            _value = value;
+        }
+
+        public static TimeOnly MinValue => new TimeOnly(TimeSpan.Zero);
+
+        public static TimeOnly MaxValue => new TimeOnly(OneDay - TimeSpan.FromTicks(1));
+
+        public int Hour => _value.Hours;
+
+        public int Minute => _value.Minutes;
+
+        public int Second => _value.Seconds;
+
+        public int Millisecond => _value.Milliseconds;
+
+        public long Ticks => _value.Ticks;
+
+        /// <summary>The time part of <paramref name="value"/>.</summary>
+        public static TimeOnly FromDateTime(DateTime value) => new TimeOnly(value.TimeOfDay);
+
+        /// <exception cref="ArgumentOutOfRangeException">When <paramref name="value"/> is negative or a day or more.</exception>
+        public static TimeOnly FromTimeSpan(TimeSpan value) => new TimeOnly(value);
+
+        /// <summary>This time as a span since midnight. What a XAML time picker binds to.</summary>
+        public TimeSpan ToTimeSpan() => _value;
+
+        public static TimeOnly Parse(string s) => Parse(s, CultureInfo.InvariantCulture);
+
+        /// <exception cref="FormatException">When <paramref name="s"/> is not a time of day.</exception>
+        public static TimeOnly Parse(string s, IFormatProvider? provider)
+        {
+            if (!TryParse(s, provider, out var result))
+            {
+                throw new FormatException("'" + s + "' is not a time of day.");
+            }
+
+            return result;
+        }
+
+        public static bool TryParse(string? s, out TimeOnly result) => TryParse(s, CultureInfo.InvariantCulture, out result);
+
+        public static bool TryParse(string? s, IFormatProvider? provider, out TimeOnly result)
+        {
+            var culture = provider ?? CultureInfo.InvariantCulture;
+            if (DateTime.TryParseExact(s, Formats, culture, DateTimeStyles.None, out var exact))
+            {
+                result = new TimeOnly(exact.TimeOfDay);
+                return true;
+            }
+
+            if (DateTime.TryParse(s, culture, DateTimeStyles.None, out var parsed))
+            {
+                result = new TimeOnly(parsed.TimeOfDay);
+                return true;
+            }
+
+            result = default;
+            return false;
+        }
+
+        /// <summary>
+        /// The ISO 8601 form: <c>HH:mm:ss</c>, and a fraction of seven digits when there is one.
+        /// </summary>
+        /// <remarks>
+        /// Byte for byte what System.Text.Json's own converter writes for a <c>TimeOnly</c> on
+        /// net10.0 \u2014 including the seven digits, which it does not trim \u2014 so a service cannot tell
+        /// which leg of the build sent a body.
+        /// </remarks>
+        public override string ToString() =>
+            _value.Ticks % TimeSpan.TicksPerSecond == 0
+                ? _value.ToString("hh':'mm':'ss", CultureInfo.InvariantCulture)
+                : _value.ToString("hh':'mm':'ss'.'fffffff", CultureInfo.InvariantCulture);
+
+        public string ToString(string? format) => _value.ToString(format, CultureInfo.InvariantCulture);
+
+        public string ToString(string? format, IFormatProvider? provider) => _value.ToString(format, provider);
+
+        public bool Equals(TimeOnly other) => _value == other._value;
+
+        public override bool Equals(object? obj) => obj is TimeOnly other && Equals(other);
+
+        public override int GetHashCode() => _value.GetHashCode();
+
+        public int CompareTo(TimeOnly other) => _value.CompareTo(other._value);
+
+        public int CompareTo(object? obj)
+        {
+            if (obj is null) return 1;
+            if (obj is TimeOnly other) return CompareTo(other);
+            throw new ArgumentException("Object must be of type TimeOnly.", nameof(obj));
+        }
+
+        public static bool operator ==(TimeOnly left, TimeOnly right) => left.Equals(right);
+
+        public static bool operator !=(TimeOnly left, TimeOnly right) => !left.Equals(right);
+
+        public static bool operator <(TimeOnly left, TimeOnly right) => left.CompareTo(right) < 0;
+
+        public static bool operator <=(TimeOnly left, TimeOnly right) => left.CompareTo(right) <= 0;
+
+        public static bool operator >(TimeOnly left, TimeOnly right) => left.CompareTo(right) > 0;
+
+        public static bool operator >=(TimeOnly left, TimeOnly right) => left.CompareTo(right) >= 0;
+    }
+}
+
+#endif
 `;
 }
 
 // src/scaffold.ts
 var SCAFFOLD_VERSIONS = {
-  targetFramework: "net10.0"
+  targetFramework: "net10.0",
+  systemTextJson: "10.0.12",
+  /** The oldest language version the generated sources compile under: records, `required`, primary constructors. */
+  netstandardLangVersion: "12.0"
 };
-function generateCsproj(namespaceName, sdkName) {
+var DEFAULT_TARGET_FRAMEWORKS = [SCAFFOLD_VERSIONS.targetFramework];
+function generateCsproj(namespaceName, sdkName, targetFrameworks = DEFAULT_TARGET_FRAMEWORKS) {
+  const frameworks = targetFrameworks.length === 1 ? `    <TargetFramework>${targetFrameworks[0]}</TargetFramework>` : `    <TargetFrameworks>${targetFrameworks.join(";")}</TargetFrameworks>`;
+  const netstandard = targetFrameworks.includes("netstandard2.0") ? `
+  <!-- .NET Standard 2.0 predates the language features the generated sources use. -->
+  <PropertyGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
+    <LangVersion>${SCAFFOLD_VERSIONS.netstandardLangVersion}</LangVersion>
+  </PropertyGroup>
+
+  <!-- The one framework where System.Text.Json is a package rather than part of the platform. -->
+  <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
+    <PackageReference Include="System.Text.Json" Version="${SCAFFOLD_VERSIONS.systemTextJson}" />
+  </ItemGroup>
+` : "";
   return `<!-- Created once by @contractkit/plugin-csharp. Yours to edit: it is never regenerated. -->
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>${SCAFFOLD_VERSIONS.targetFramework}</TargetFramework>
+${frameworks}
     <Nullable>enable</Nullable>
     <ImplicitUsings>disable</ImplicitUsings>
     <RootNamespace>${namespaceName}</RootNamespace>
     <AssemblyName>${sdkName}</AssemblyName>
   </PropertyGroup>
-
+${netstandard}
 </Project>
 `;
 }
 
 // src/index.ts
-var CSHARP_CODEGEN_VERSION = "1";
+var CSHARP_CODEGEN_VERSION = "2";
 var CACHE_MANIFEST_FILENAME = "csharp-manifest.json";
 var DEFAULT_BASE_DIR = "csharp-sdk";
 var DEFAULT_NAMESPACE = "ContractKit.Sdk";
 var DEFAULT_SDK_NAME = "Sdk";
+var DEFAULT_DATE_TYPES = "dateonly";
 var plugin = {
   name: "csharp-sdk",
   async generateTargets(inputs, ctx) {
@@ -2148,12 +2658,38 @@ function assertValidConfig(config) {
       throw new Error(`plugin-csharp: ${key} must be a boolean \u2014 got ${JSON.stringify(value)}.`);
     }
   }
+  assertValidTargetFrameworks(config.targetFrameworks);
+  if (config.dateTypes !== void 0 && !DATE_TYPES.includes(config.dateTypes)) {
+    throw new Error(`plugin-csharp: dateTypes ${JSON.stringify(config.dateTypes)} is not supported \u2014 expected one of ${DATE_TYPES.join(", ")}.`);
+  }
+}
+var DATE_TYPES = ["dateonly", "datetime"];
+var TARGET_FRAMEWORKS = ["netstandard2.0", "net10.0"];
+function assertValidTargetFrameworks(frameworks) {
+  if (frameworks === void 0) return;
+  if (!Array.isArray(frameworks) || frameworks.length === 0) {
+    throw new Error(`plugin-csharp: targetFrameworks must be a non-empty array \u2014 got ${JSON.stringify(frameworks)}.`);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const framework of frameworks) {
+    if (typeof framework !== "string" || !TARGET_FRAMEWORKS.includes(framework)) {
+      throw new Error(
+        `plugin-csharp: targetFrameworks entry ${JSON.stringify(framework)} is not supported \u2014 expected one of ${TARGET_FRAMEWORKS.join(", ")}.`
+      );
+    }
+    if (seen.has(framework)) {
+      throw new Error(`plugin-csharp: targetFrameworks lists '${framework}' twice.`);
+    }
+    seen.add(framework);
+  }
 }
 async function runCSharpCodegen(inputs, ctx, config, rootDir) {
   assertValidConfig(config);
   const { contractRoots } = inputs;
   const namespaceName = config.namespace ?? DEFAULT_NAMESPACE;
   const sdkName = config.sdkName ?? DEFAULT_SDK_NAME;
+  const targetFrameworks = config.targetFrameworks ?? DEFAULT_TARGET_FRAMEWORKS;
+  const dateTypes = config.dateTypes ?? DEFAULT_DATE_TYPES;
   const outDir = resolve(rootDir, config.baseDir ?? DEFAULT_BASE_DIR);
   const manifestPath = resolve(ctx.cacheDir, CACHE_MANIFEST_FILENAME);
   const allModels = contractRoots.flatMap((root) => root.models);
@@ -2181,6 +2717,7 @@ async function runCSharpCodegen(inputs, ctx, config, rootDir) {
       v: CSHARP_CODEGEN_VERSION,
       relPath,
       namespace: namespaceName,
+      dateTypes,
       root,
       externalBases,
       modelsWithInput: relevantInputModels,
@@ -2195,6 +2732,7 @@ async function runCSharpCodegen(inputs, ctx, config, rootDir) {
           relativePath: relPath,
           content: generateCSharpModels(root, {
             namespace: namespaceName,
+            dateTypes,
             modelsWithInput,
             modelIndex,
             hoisted,
@@ -2216,6 +2754,7 @@ async function runCSharpCodegen(inputs, ctx, config, rootDir) {
       v: CSHARP_CODEGEN_VERSION,
       relPath,
       namespace: namespaceName,
+      dateTypes,
       root,
       referencedModels,
       modelsWithInput: relevantInputModels,
@@ -2229,6 +2768,7 @@ async function runCSharpCodegen(inputs, ctx, config, rootDir) {
           relativePath: relPath,
           content: generateCSharpClient(root, {
             namespace: namespaceName,
+            dateTypes,
             modelsWithInput,
             modelIndex,
             hoisted,
@@ -2240,12 +2780,19 @@ async function runCSharpCodegen(inputs, ctx, config, rootDir) {
     });
   }
   const globalFiles = [
-    { relativePath: "Runtime/Converters.cs", content: generateConvertersCs(namespaceName) },
+    { relativePath: "Runtime/Converters.cs", content: generateConvertersCs(namespaceName, dateTypes) },
     { relativePath: "Runtime/SdkRuntime.cs", content: generateRuntimeCs(namespaceName) },
     { relativePath: `${sdkName}.cs`, content: generateSdkCs(namespaceName, sdkName, clients) }
   ];
+  if (targetFrameworks.includes("netstandard2.0")) {
+    globalFiles.push({ relativePath: "Runtime/Polyfills.cs", content: generatePolyfillsCs(namespaceName) });
+  }
   if (config.scaffold) {
-    globalFiles.push({ relativePath: `${sdkName}.csproj`, content: generateCsproj(namespaceName, sdkName), ifAbsent: true });
+    globalFiles.push({
+      relativePath: `${sdkName}.csproj`,
+      content: generateCsproj(namespaceName, sdkName, targetFrameworks),
+      ifAbsent: true
+    });
   }
   const result = runIncrementalCodegen({
     codegenVersion: CSHARP_CODEGEN_VERSION,